extern void __VERIFIER_error() __attribute__ ((__noreturn__)); /* Generated by CIL v. 1.5.1 */ /* print_CIL_Input is false */ typedef signed char __s8; typedef unsigned char __u8; typedef short __s16; typedef unsigned short __u16; typedef int __s32; typedef unsigned int __u32; typedef unsigned long long __u64; typedef signed char s8; typedef unsigned char u8; typedef short s16; typedef unsigned short u16; typedef int s32; typedef unsigned int u32; typedef long long s64; typedef unsigned long long u64; typedef long __kernel_long_t; typedef unsigned long __kernel_ulong_t; typedef int __kernel_pid_t; typedef unsigned int __kernel_uid32_t; typedef unsigned int __kernel_gid32_t; typedef __kernel_ulong_t __kernel_size_t; typedef __kernel_long_t __kernel_ssize_t; struct __anonstruct___kernel_fsid_t_5 { int val[2U] ; }; typedef struct __anonstruct___kernel_fsid_t_5 __kernel_fsid_t; typedef long long __kernel_loff_t; typedef __kernel_long_t __kernel_time_t; typedef __kernel_long_t __kernel_clock_t; typedef int __kernel_timer_t; typedef int __kernel_clockid_t; typedef __u16 __be16; typedef __u32 __be32; typedef __u32 __wsum; typedef __u32 __kernel_dev_t; typedef __kernel_dev_t dev_t; typedef unsigned short umode_t; typedef __kernel_pid_t pid_t; typedef __kernel_clockid_t clockid_t; typedef _Bool bool; typedef __kernel_uid32_t uid_t; typedef __kernel_gid32_t gid_t; typedef __kernel_loff_t loff_t; typedef __kernel_size_t size_t; typedef __kernel_ssize_t ssize_t; typedef __kernel_time_t time_t; typedef __s32 int32_t; typedef __u8 uint8_t; typedef __u32 uint32_t; typedef __u64 uint64_t; typedef unsigned long sector_t; typedef unsigned long blkcnt_t; typedef u64 dma_addr_t; typedef unsigned int gfp_t; typedef unsigned int fmode_t; typedef unsigned int oom_flags_t; struct __anonstruct_atomic_t_6 { int counter ; }; typedef struct __anonstruct_atomic_t_6 atomic_t; struct __anonstruct_atomic64_t_7 { long counter ; }; typedef struct __anonstruct_atomic64_t_7 atomic64_t; struct list_head { struct list_head *next ; struct list_head *prev ; }; struct hlist_node; struct hlist_head { struct hlist_node *first ; }; struct hlist_node { struct hlist_node *next ; struct hlist_node **pprev ; }; struct callback_head { struct callback_head *next ; void (*func)(struct callback_head * ) ; }; struct kernel_symbol { unsigned long value ; char const *name ; }; struct module; struct pt_regs { unsigned long r15 ; unsigned long r14 ; unsigned long r13 ; unsigned long r12 ; unsigned long bp ; unsigned long bx ; unsigned long r11 ; unsigned long r10 ; unsigned long r9 ; unsigned long r8 ; unsigned long ax ; unsigned long cx ; unsigned long dx ; unsigned long si ; unsigned long di ; unsigned long orig_ax ; unsigned long ip ; unsigned long cs ; unsigned long flags ; unsigned long sp ; unsigned long ss ; }; typedef void (*ctor_fn_t)(void); struct __anonstruct_ldv_1207_9 { unsigned int a ; unsigned int b ; }; struct __anonstruct_ldv_1222_10 { u16 limit0 ; u16 base0 ; unsigned char base1 ; unsigned char type : 4 ; unsigned char s : 1 ; unsigned char dpl : 2 ; unsigned char p : 1 ; unsigned char limit : 4 ; unsigned char avl : 1 ; unsigned char l : 1 ; unsigned char d : 1 ; unsigned char g : 1 ; unsigned char base2 ; }; union __anonunion_ldv_1223_8 { struct __anonstruct_ldv_1207_9 ldv_1207 ; struct __anonstruct_ldv_1222_10 ldv_1222 ; }; struct desc_struct { union __anonunion_ldv_1223_8 ldv_1223 ; }; typedef unsigned long pgdval_t; typedef unsigned long pgprotval_t; struct pgprot { pgprotval_t pgprot ; }; typedef struct pgprot pgprot_t; struct __anonstruct_pgd_t_12 { pgdval_t pgd ; }; typedef struct __anonstruct_pgd_t_12 pgd_t; struct page; typedef struct page *pgtable_t; struct file; struct seq_file; struct thread_struct; struct mm_struct; struct task_struct; struct cpumask; struct arch_spinlock; typedef u16 __ticket_t; typedef u32 __ticketpair_t; struct __raw_tickets { __ticket_t head ; __ticket_t tail ; }; union __anonunion_ldv_1629_15 { __ticketpair_t head_tail ; struct __raw_tickets tickets ; }; struct arch_spinlock { union __anonunion_ldv_1629_15 ldv_1629 ; }; typedef struct arch_spinlock arch_spinlock_t; struct __anonstruct_ldv_1636_17 { u32 read ; s32 write ; }; union __anonunion_arch_rwlock_t_16 { s64 lock ; struct __anonstruct_ldv_1636_17 ldv_1636 ; }; typedef union __anonunion_arch_rwlock_t_16 arch_rwlock_t; struct file_operations; struct device; struct net_device; struct completion; struct pid; struct bug_entry { int bug_addr_disp ; int file_disp ; unsigned short line ; unsigned short flags ; }; struct timespec; struct compat_timespec; struct __anonstruct_futex_19 { u32 *uaddr ; u32 val ; u32 flags ; u32 bitset ; u64 time ; u32 *uaddr2 ; }; struct __anonstruct_nanosleep_20 { clockid_t clockid ; struct timespec *rmtp ; struct compat_timespec *compat_rmtp ; u64 expires ; }; struct pollfd; struct __anonstruct_poll_21 { struct pollfd *ufds ; int nfds ; int has_timeout ; unsigned long tv_sec ; unsigned long tv_nsec ; }; union __anonunion_ldv_2781_18 { struct __anonstruct_futex_19 futex ; struct __anonstruct_nanosleep_20 nanosleep ; struct __anonstruct_poll_21 poll ; }; struct restart_block { long (*fn)(struct restart_block * ) ; union __anonunion_ldv_2781_18 ldv_2781 ; }; struct exec_domain; struct kernel_vm86_regs { struct pt_regs pt ; unsigned short es ; unsigned short __esh ; unsigned short ds ; unsigned short __dsh ; unsigned short fs ; unsigned short __fsh ; unsigned short gs ; unsigned short __gsh ; }; union __anonunion_ldv_2929_22 { struct pt_regs *regs ; struct kernel_vm86_regs *vm86 ; }; struct math_emu_info { long ___orig_eip ; union __anonunion_ldv_2929_22 ldv_2929 ; }; struct cpumask { unsigned long bits[64U] ; }; typedef struct cpumask cpumask_t; typedef struct cpumask *cpumask_var_t; struct static_key; struct map_segment; struct exec_domain { char const *name ; void (*handler)(int , struct pt_regs * ) ; unsigned char pers_low ; unsigned char pers_high ; unsigned long *signal_map ; unsigned long *signal_invmap ; struct map_segment *err_map ; struct map_segment *socktype_map ; struct map_segment *sockopt_map ; struct map_segment *af_map ; struct module *module ; struct exec_domain *next ; }; struct seq_operations; struct i387_fsave_struct { u32 cwd ; u32 swd ; u32 twd ; u32 fip ; u32 fcs ; u32 foo ; u32 fos ; u32 st_space[20U] ; u32 status ; }; struct __anonstruct_ldv_5210_27 { u64 rip ; u64 rdp ; }; struct __anonstruct_ldv_5216_28 { u32 fip ; u32 fcs ; u32 foo ; u32 fos ; }; union __anonunion_ldv_5217_26 { struct __anonstruct_ldv_5210_27 ldv_5210 ; struct __anonstruct_ldv_5216_28 ldv_5216 ; }; union __anonunion_ldv_5226_29 { u32 padding1[12U] ; u32 sw_reserved[12U] ; }; struct i387_fxsave_struct { u16 cwd ; u16 swd ; u16 twd ; u16 fop ; union __anonunion_ldv_5217_26 ldv_5217 ; u32 mxcsr ; u32 mxcsr_mask ; u32 st_space[32U] ; u32 xmm_space[64U] ; u32 padding[12U] ; union __anonunion_ldv_5226_29 ldv_5226 ; }; struct i387_soft_struct { u32 cwd ; u32 swd ; u32 twd ; u32 fip ; u32 fcs ; u32 foo ; u32 fos ; u32 st_space[20U] ; u8 ftop ; u8 changed ; u8 lookahead ; u8 no_update ; u8 rm ; u8 alimit ; struct math_emu_info *info ; u32 entry_eip ; }; struct ymmh_struct { u32 ymmh_space[64U] ; }; struct xsave_hdr_struct { u64 xstate_bv ; u64 reserved1[2U] ; u64 reserved2[5U] ; }; struct xsave_struct { struct i387_fxsave_struct i387 ; struct xsave_hdr_struct xsave_hdr ; struct ymmh_struct ymmh ; }; union thread_xstate { struct i387_fsave_struct fsave ; struct i387_fxsave_struct fxsave ; struct i387_soft_struct soft ; struct xsave_struct xsave ; }; struct fpu { unsigned int last_cpu ; unsigned int has_fpu ; union thread_xstate *state ; }; struct kmem_cache; struct perf_event; struct thread_struct { struct desc_struct tls_array[3U] ; unsigned long sp0 ; unsigned long sp ; unsigned long usersp ; unsigned short es ; unsigned short ds ; unsigned short fsindex ; unsigned short gsindex ; unsigned long fs ; unsigned long gs ; struct perf_event *ptrace_bps[4U] ; unsigned long debugreg6 ; unsigned long ptrace_dr7 ; unsigned long cr2 ; unsigned long trap_nr ; unsigned long error_code ; struct fpu fpu ; unsigned long *io_bitmap_ptr ; unsigned long iopl ; unsigned int io_bitmap_max ; }; struct __anonstruct_mm_segment_t_31 { unsigned long seg ; }; typedef struct __anonstruct_mm_segment_t_31 mm_segment_t; typedef atomic64_t atomic_long_t; struct thread_info { struct task_struct *task ; struct exec_domain *exec_domain ; __u32 flags ; __u32 status ; __u32 cpu ; int preempt_count ; mm_segment_t addr_limit ; struct restart_block restart_block ; void *sysenter_return ; unsigned char sig_on_uaccess_error : 1 ; unsigned char uaccess_err : 1 ; }; struct lockdep_map; struct stack_trace { unsigned int nr_entries ; unsigned int max_entries ; unsigned long *entries ; int skip ; }; struct lockdep_subclass_key { char __one_byte ; }; struct lock_class_key { struct lockdep_subclass_key subkeys[8U] ; }; struct lock_class { struct list_head hash_entry ; struct list_head lock_entry ; struct lockdep_subclass_key *key ; unsigned int subclass ; unsigned int dep_gen_id ; unsigned long usage_mask ; struct stack_trace usage_traces[13U] ; struct list_head locks_after ; struct list_head locks_before ; unsigned int version ; unsigned long ops ; char const *name ; int name_version ; unsigned long contention_point[4U] ; unsigned long contending_point[4U] ; }; struct lockdep_map { struct lock_class_key *key ; struct lock_class *class_cache[2U] ; char const *name ; int cpu ; unsigned long ip ; }; struct held_lock { u64 prev_chain_key ; unsigned long acquire_ip ; struct lockdep_map *instance ; struct lockdep_map *nest_lock ; u64 waittime_stamp ; u64 holdtime_stamp ; unsigned short class_idx : 13 ; unsigned char irq_context : 2 ; unsigned char trylock : 1 ; unsigned char read : 2 ; unsigned char check : 2 ; unsigned char hardirqs_off : 1 ; unsigned short references : 11 ; }; struct raw_spinlock { arch_spinlock_t raw_lock ; unsigned int magic ; unsigned int owner_cpu ; void *owner ; struct lockdep_map dep_map ; }; typedef struct raw_spinlock raw_spinlock_t; struct __anonstruct_ldv_6139_33 { u8 __padding[24U] ; struct lockdep_map dep_map ; }; union __anonunion_ldv_6140_32 { struct raw_spinlock rlock ; struct __anonstruct_ldv_6139_33 ldv_6139 ; }; struct spinlock { union __anonunion_ldv_6140_32 ldv_6140 ; }; typedef struct spinlock spinlock_t; struct __anonstruct_rwlock_t_34 { arch_rwlock_t raw_lock ; unsigned int magic ; unsigned int owner_cpu ; void *owner ; struct lockdep_map dep_map ; }; typedef struct __anonstruct_rwlock_t_34 rwlock_t; struct static_key { atomic_t enabled ; }; struct seqcount { unsigned int sequence ; }; typedef struct seqcount seqcount_t; struct __anonstruct_seqlock_t_35 { struct seqcount seqcount ; spinlock_t lock ; }; typedef struct __anonstruct_seqlock_t_35 seqlock_t; struct timespec { __kernel_time_t tv_sec ; long tv_nsec ; }; struct user_namespace; struct __anonstruct_kuid_t_36 { uid_t val ; }; typedef struct __anonstruct_kuid_t_36 kuid_t; struct __anonstruct_kgid_t_37 { gid_t val ; }; typedef struct __anonstruct_kgid_t_37 kgid_t; struct kstat { u64 ino ; dev_t dev ; umode_t mode ; unsigned int nlink ; kuid_t uid ; kgid_t gid ; dev_t rdev ; loff_t size ; struct timespec atime ; struct timespec mtime ; struct timespec ctime ; unsigned long blksize ; unsigned long long blocks ; }; struct __wait_queue; typedef struct __wait_queue wait_queue_t; struct __wait_queue { unsigned int flags ; void *private ; int (*func)(wait_queue_t * , unsigned int , int , void * ) ; struct list_head task_list ; }; struct __wait_queue_head { spinlock_t lock ; struct list_head task_list ; }; typedef struct __wait_queue_head wait_queue_head_t; struct __anonstruct_nodemask_t_38 { unsigned long bits[16U] ; }; typedef struct __anonstruct_nodemask_t_38 nodemask_t; struct mutex { atomic_t count ; spinlock_t wait_lock ; struct list_head wait_list ; struct task_struct *owner ; char const *name ; void *magic ; struct lockdep_map dep_map ; }; struct mutex_waiter { struct list_head list ; struct task_struct *task ; void *magic ; }; struct rw_semaphore; struct rw_semaphore { long count ; raw_spinlock_t wait_lock ; struct list_head wait_list ; struct lockdep_map dep_map ; }; struct completion { unsigned int done ; wait_queue_head_t wait ; }; struct notifier_block; union ktime { s64 tv64 ; }; typedef union ktime ktime_t; struct tvec_base; struct timer_list { struct list_head entry ; unsigned long expires ; struct tvec_base *base ; void (*function)(unsigned long ) ; unsigned long data ; int slack ; int start_pid ; void *start_site ; char start_comm[16U] ; struct lockdep_map lockdep_map ; }; struct hrtimer; enum hrtimer_restart; struct workqueue_struct; struct work_struct; struct work_struct { atomic_long_t data ; struct list_head entry ; void (*func)(struct work_struct * ) ; struct lockdep_map lockdep_map ; }; struct delayed_work { struct work_struct work ; struct timer_list timer ; struct workqueue_struct *wq ; int cpu ; }; struct notifier_block { int (*notifier_call)(struct notifier_block * , unsigned long , void * ) ; struct notifier_block *next ; int priority ; }; struct blocking_notifier_head { struct rw_semaphore rwsem ; struct notifier_block *head ; }; struct ctl_table; struct pm_message { int event ; }; typedef struct pm_message pm_message_t; struct dev_pm_ops { int (*prepare)(struct device * ) ; void (*complete)(struct device * ) ; int (*suspend)(struct device * ) ; int (*resume)(struct device * ) ; int (*freeze)(struct device * ) ; int (*thaw)(struct device * ) ; int (*poweroff)(struct device * ) ; int (*restore)(struct device * ) ; int (*suspend_late)(struct device * ) ; int (*resume_early)(struct device * ) ; int (*freeze_late)(struct device * ) ; int (*thaw_early)(struct device * ) ; int (*poweroff_late)(struct device * ) ; int (*restore_early)(struct device * ) ; int (*suspend_noirq)(struct device * ) ; int (*resume_noirq)(struct device * ) ; int (*freeze_noirq)(struct device * ) ; int (*thaw_noirq)(struct device * ) ; int (*poweroff_noirq)(struct device * ) ; int (*restore_noirq)(struct device * ) ; int (*runtime_suspend)(struct device * ) ; int (*runtime_resume)(struct device * ) ; int (*runtime_idle)(struct device * ) ; }; enum rpm_status { RPM_ACTIVE = 0, RPM_RESUMING = 1, RPM_SUSPENDED = 2, RPM_SUSPENDING = 3 } ; enum rpm_request { RPM_REQ_NONE = 0, RPM_REQ_IDLE = 1, RPM_REQ_SUSPEND = 2, RPM_REQ_AUTOSUSPEND = 3, RPM_REQ_RESUME = 4 } ; struct wakeup_source; struct pm_subsys_data { spinlock_t lock ; unsigned int refcount ; struct list_head clock_list ; }; struct dev_pm_qos; struct dev_pm_info { pm_message_t power_state ; unsigned char can_wakeup : 1 ; unsigned char async_suspend : 1 ; bool is_prepared ; bool is_suspended ; bool ignore_children ; bool early_init ; spinlock_t lock ; struct list_head entry ; struct completion completion ; struct wakeup_source *wakeup ; bool wakeup_path ; bool syscore ; struct timer_list suspend_timer ; unsigned long timer_expires ; struct work_struct work ; wait_queue_head_t wait_queue ; atomic_t usage_count ; atomic_t child_count ; unsigned char disable_depth : 3 ; unsigned char idle_notification : 1 ; unsigned char request_pending : 1 ; unsigned char deferred_resume : 1 ; unsigned char run_wake : 1 ; unsigned char runtime_auto : 1 ; unsigned char no_callbacks : 1 ; unsigned char irq_safe : 1 ; unsigned char use_autosuspend : 1 ; unsigned char timer_autosuspends : 1 ; unsigned char memalloc_noio : 1 ; enum rpm_request request ; enum rpm_status runtime_status ; int runtime_error ; int autosuspend_delay ; unsigned long last_busy ; unsigned long active_jiffies ; unsigned long suspended_jiffies ; unsigned long accounting_timestamp ; struct pm_subsys_data *subsys_data ; struct dev_pm_qos *qos ; }; struct dev_pm_domain { struct dev_pm_ops ops ; }; struct __anonstruct_mm_context_t_103 { void *ldt ; int size ; unsigned short ia32_compat ; struct mutex lock ; void *vdso ; }; typedef struct __anonstruct_mm_context_t_103 mm_context_t; struct rb_node { unsigned long __rb_parent_color ; struct rb_node *rb_right ; struct rb_node *rb_left ; }; struct rb_root { struct rb_node *rb_node ; }; struct vm_area_struct; struct device_node; struct nsproxy; struct ctl_table_root; struct ctl_table_header; struct ctl_dir; typedef int proc_handler(struct ctl_table * , int , void * , size_t * , loff_t * ); struct ctl_table_poll { atomic_t event ; wait_queue_head_t wait ; }; struct ctl_table { char const *procname ; void *data ; int maxlen ; umode_t mode ; struct ctl_table *child ; proc_handler *proc_handler ; struct ctl_table_poll *poll ; void *extra1 ; void *extra2 ; }; struct ctl_node { struct rb_node node ; struct ctl_table_header *header ; }; struct __anonstruct_ldv_13301_131 { struct ctl_table *ctl_table ; int used ; int count ; int nreg ; }; union __anonunion_ldv_13303_130 { struct __anonstruct_ldv_13301_131 ldv_13301 ; struct callback_head rcu ; }; struct ctl_table_set; struct ctl_table_header { union __anonunion_ldv_13303_130 ldv_13303 ; struct completion *unregistering ; struct ctl_table *ctl_table_arg ; struct ctl_table_root *root ; struct ctl_table_set *set ; struct ctl_dir *parent ; struct ctl_node *node ; }; struct ctl_dir { struct ctl_table_header header ; struct rb_root root ; }; struct ctl_table_set { int (*is_seen)(struct ctl_table_set * ) ; struct ctl_dir dir ; }; struct ctl_table_root { struct ctl_table_set default_set ; struct ctl_table_set *(*lookup)(struct ctl_table_root * , struct nsproxy * ) ; int (*permissions)(struct ctl_table_header * , struct ctl_table * ) ; }; struct cred; typedef __u64 Elf64_Addr; typedef __u16 Elf64_Half; typedef __u32 Elf64_Word; typedef __u64 Elf64_Xword; struct elf64_sym { Elf64_Word st_name ; unsigned char st_info ; unsigned char st_other ; Elf64_Half st_shndx ; Elf64_Addr st_value ; Elf64_Xword st_size ; }; typedef struct elf64_sym Elf64_Sym; struct sock; struct kobject; enum kobj_ns_type { KOBJ_NS_TYPE_NONE = 0, KOBJ_NS_TYPE_NET = 1, KOBJ_NS_TYPES = 2 } ; struct kobj_ns_type_operations { enum kobj_ns_type type ; bool (*current_may_mount)(void) ; void *(*grab_current_ns)(void) ; void const *(*netlink_ns)(struct sock * ) ; void const *(*initial_ns)(void) ; void (*drop_ns)(void * ) ; }; struct bin_attribute; struct attribute { char const *name ; umode_t mode ; bool ignore_lockdep ; struct lock_class_key *key ; struct lock_class_key skey ; }; struct attribute_group { char const *name ; umode_t (*is_visible)(struct kobject * , struct attribute * , int ) ; struct attribute **attrs ; struct bin_attribute **bin_attrs ; }; struct bin_attribute { struct attribute attr ; size_t size ; void *private ; ssize_t (*read)(struct file * , struct kobject * , struct bin_attribute * , char * , loff_t , size_t ) ; ssize_t (*write)(struct file * , struct kobject * , struct bin_attribute * , char * , loff_t , size_t ) ; int (*mmap)(struct file * , struct kobject * , struct bin_attribute * , struct vm_area_struct * ) ; }; struct sysfs_ops { ssize_t (*show)(struct kobject * , struct attribute * , char * ) ; ssize_t (*store)(struct kobject * , struct attribute * , char const * , size_t ) ; void const *(*namespace)(struct kobject * , struct attribute const * ) ; }; struct sysfs_dirent; struct kref { atomic_t refcount ; }; struct kset; struct kobj_type; struct kobject { char const *name ; struct list_head entry ; struct kobject *parent ; struct kset *kset ; struct kobj_type *ktype ; struct sysfs_dirent *sd ; struct kref kref ; struct delayed_work release ; unsigned char state_initialized : 1 ; unsigned char state_in_sysfs : 1 ; unsigned char state_add_uevent_sent : 1 ; unsigned char state_remove_uevent_sent : 1 ; unsigned char uevent_suppress : 1 ; }; struct kobj_type { void (*release)(struct kobject * ) ; struct sysfs_ops const *sysfs_ops ; struct attribute **default_attrs ; struct kobj_ns_type_operations const *(*child_ns_type)(struct kobject * ) ; void const *(*namespace)(struct kobject * ) ; }; struct kobj_uevent_env { char *envp[32U] ; int envp_idx ; char buf[2048U] ; int buflen ; }; struct kset_uevent_ops { int (* const filter)(struct kset * , struct kobject * ) ; char const *(* const name)(struct kset * , struct kobject * ) ; int (* const uevent)(struct kset * , struct kobject * , struct kobj_uevent_env * ) ; }; struct kset { struct list_head list ; spinlock_t list_lock ; struct kobject kobj ; struct kset_uevent_ops const *uevent_ops ; }; struct kernel_param; struct kernel_param_ops { unsigned int flags ; int (*set)(char const * , struct kernel_param const * ) ; int (*get)(char * , struct kernel_param const * ) ; void (*free)(void * ) ; }; struct kparam_string; struct kparam_array; union __anonunion_ldv_14132_136 { void *arg ; struct kparam_string const *str ; struct kparam_array const *arr ; }; struct kernel_param { char const *name ; struct kernel_param_ops const *ops ; u16 perm ; s16 level ; union __anonunion_ldv_14132_136 ldv_14132 ; }; struct kparam_string { unsigned int maxlen ; char *string ; }; struct kparam_array { unsigned int max ; unsigned int elemsize ; unsigned int *num ; struct kernel_param_ops const *ops ; void *elem ; }; struct tracepoint; struct tracepoint_func { void *func ; void *data ; }; struct tracepoint { char const *name ; struct static_key key ; void (*regfunc)(void) ; void (*unregfunc)(void) ; struct tracepoint_func *funcs ; }; struct mod_arch_specific { }; struct module_param_attrs; struct module_kobject { struct kobject kobj ; struct module *mod ; struct kobject *drivers_dir ; struct module_param_attrs *mp ; struct completion *kobj_completion ; }; struct module_attribute { struct attribute attr ; ssize_t (*show)(struct module_attribute * , struct module_kobject * , char * ) ; ssize_t (*store)(struct module_attribute * , struct module_kobject * , char const * , size_t ) ; void (*setup)(struct module * , char const * ) ; int (*test)(struct module * ) ; void (*free)(struct module * ) ; }; struct exception_table_entry; enum module_state { MODULE_STATE_LIVE = 0, MODULE_STATE_COMING = 1, MODULE_STATE_GOING = 2, MODULE_STATE_UNFORMED = 3 } ; struct module_ref { unsigned long incs ; unsigned long decs ; }; struct module_sect_attrs; struct module_notes_attrs; struct ftrace_event_call; struct module { enum module_state state ; struct list_head list ; char name[56U] ; struct module_kobject mkobj ; struct module_attribute *modinfo_attrs ; char const *version ; char const *srcversion ; struct kobject *holders_dir ; struct kernel_symbol const *syms ; unsigned long const *crcs ; unsigned int num_syms ; struct kernel_param *kp ; unsigned int num_kp ; unsigned int num_gpl_syms ; struct kernel_symbol const *gpl_syms ; unsigned long const *gpl_crcs ; struct kernel_symbol const *unused_syms ; unsigned long const *unused_crcs ; unsigned int num_unused_syms ; unsigned int num_unused_gpl_syms ; struct kernel_symbol const *unused_gpl_syms ; unsigned long const *unused_gpl_crcs ; bool sig_ok ; struct kernel_symbol const *gpl_future_syms ; unsigned long const *gpl_future_crcs ; unsigned int num_gpl_future_syms ; unsigned int num_exentries ; struct exception_table_entry *extable ; int (*init)(void) ; void *module_init ; void *module_core ; unsigned int init_size ; unsigned int core_size ; unsigned int init_text_size ; unsigned int core_text_size ; unsigned int init_ro_size ; unsigned int core_ro_size ; struct mod_arch_specific arch ; unsigned int taints ; unsigned int num_bugs ; struct list_head bug_list ; struct bug_entry *bug_table ; Elf64_Sym *symtab ; Elf64_Sym *core_symtab ; unsigned int num_symtab ; unsigned int core_num_syms ; char *strtab ; char *core_strtab ; struct module_sect_attrs *sect_attrs ; struct module_notes_attrs *notes_attrs ; char *args ; void *percpu ; unsigned int percpu_size ; unsigned int num_tracepoints ; struct tracepoint * const *tracepoints_ptrs ; unsigned int num_trace_bprintk_fmt ; char const **trace_bprintk_fmt_start ; struct ftrace_event_call **trace_events ; unsigned int num_trace_events ; unsigned int num_ftrace_callsites ; unsigned long *ftrace_callsites ; struct list_head source_list ; struct list_head target_list ; struct task_struct *waiter ; void (*exit)(void) ; struct module_ref *refptr ; ctor_fn_t (**ctors)(void) ; unsigned int num_ctors ; }; struct mem_cgroup; struct kmem_cache_cpu { void **freelist ; unsigned long tid ; struct page *page ; struct page *partial ; unsigned int stat[26U] ; }; struct kmem_cache_order_objects { unsigned long x ; }; struct memcg_cache_params; struct kmem_cache_node; struct kmem_cache { struct kmem_cache_cpu *cpu_slab ; unsigned long flags ; unsigned long min_partial ; int size ; int object_size ; int offset ; int cpu_partial ; struct kmem_cache_order_objects oo ; struct kmem_cache_order_objects max ; struct kmem_cache_order_objects min ; gfp_t allocflags ; int refcount ; void (*ctor)(void * ) ; int inuse ; int align ; int reserved ; char const *name ; struct list_head list ; struct kobject kobj ; struct memcg_cache_params *memcg_params ; int max_attr_size ; int remote_node_defrag_ratio ; struct kmem_cache_node *node[1024U] ; }; struct __anonstruct_ldv_14807_138 { struct mem_cgroup *memcg ; struct list_head list ; struct kmem_cache *root_cache ; bool dead ; atomic_t nr_pages ; struct work_struct destroy ; }; union __anonunion_ldv_14808_137 { struct kmem_cache *memcg_caches[0U] ; struct __anonstruct_ldv_14807_138 ldv_14807 ; }; struct memcg_cache_params { bool is_root_cache ; union __anonunion_ldv_14808_137 ldv_14808 ; }; struct inode; struct nfs_pageio_descriptor; struct dentry; struct super_block; struct shrink_control; struct writeback_control; struct rpc_task; struct nfs_pgio_header; struct vm_fault; struct shrinker; struct net; struct nameidata; struct address_space; struct kernel_cap_struct { __u32 cap[2U] ; }; typedef struct kernel_cap_struct kernel_cap_t; struct arch_uprobe_task { unsigned long saved_scratch_register ; unsigned int saved_trap_nr ; unsigned int saved_tf ; }; enum uprobe_task_state { UTASK_RUNNING = 0, UTASK_SSTEP = 1, UTASK_SSTEP_ACK = 2, UTASK_SSTEP_TRAPPED = 3 } ; struct return_instance; struct uprobe; struct uprobe_task { enum uprobe_task_state state ; struct arch_uprobe_task autask ; struct return_instance *return_instances ; unsigned int depth ; struct uprobe *active_uprobe ; unsigned long xol_vaddr ; unsigned long vaddr ; }; struct xol_area { wait_queue_head_t wq ; atomic_t slot_count ; unsigned long *bitmap ; struct page *page ; unsigned long vaddr ; }; struct uprobes_state { struct xol_area *xol_area ; }; union __anonunion_ldv_15455_141 { unsigned long index ; void *freelist ; bool pfmemalloc ; }; struct __anonstruct_ldv_15465_145 { unsigned short inuse ; unsigned short objects : 15 ; unsigned char frozen : 1 ; }; union __anonunion_ldv_15467_144 { atomic_t _mapcount ; struct __anonstruct_ldv_15465_145 ldv_15465 ; int units ; }; struct __anonstruct_ldv_15469_143 { union __anonunion_ldv_15467_144 ldv_15467 ; atomic_t _count ; }; union __anonunion_ldv_15470_142 { unsigned long counters ; struct __anonstruct_ldv_15469_143 ldv_15469 ; }; struct __anonstruct_ldv_15471_140 { union __anonunion_ldv_15455_141 ldv_15455 ; union __anonunion_ldv_15470_142 ldv_15470 ; }; struct __anonstruct_ldv_15478_147 { struct page *next ; int pages ; int pobjects ; }; struct slab; union __anonunion_ldv_15482_146 { struct list_head lru ; struct __anonstruct_ldv_15478_147 ldv_15478 ; struct list_head list ; struct slab *slab_page ; }; union __anonunion_ldv_15487_148 { unsigned long private ; struct kmem_cache *slab_cache ; struct page *first_page ; }; struct page { unsigned long flags ; struct address_space *mapping ; struct __anonstruct_ldv_15471_140 ldv_15471 ; union __anonunion_ldv_15482_146 ldv_15482 ; union __anonunion_ldv_15487_148 ldv_15487 ; unsigned long debug_flags ; }; struct page_frag { struct page *page ; __u32 offset ; __u32 size ; }; struct __anonstruct_linear_150 { struct rb_node rb ; unsigned long rb_subtree_last ; }; union __anonunion_shared_149 { struct __anonstruct_linear_150 linear ; struct list_head nonlinear ; }; struct anon_vma; struct vm_operations_struct; struct mempolicy; struct vm_area_struct { unsigned long vm_start ; unsigned long vm_end ; struct vm_area_struct *vm_next ; struct vm_area_struct *vm_prev ; struct rb_node vm_rb ; unsigned long rb_subtree_gap ; struct mm_struct *vm_mm ; pgprot_t vm_page_prot ; unsigned long vm_flags ; union __anonunion_shared_149 shared ; struct list_head anon_vma_chain ; struct anon_vma *anon_vma ; struct vm_operations_struct const *vm_ops ; unsigned long vm_pgoff ; struct file *vm_file ; void *vm_private_data ; struct mempolicy *vm_policy ; }; struct core_thread { struct task_struct *task ; struct core_thread *next ; }; struct core_state { atomic_t nr_threads ; struct core_thread dumper ; struct completion startup ; }; struct mm_rss_stat { atomic_long_t count[3U] ; }; struct kioctx_table; struct linux_binfmt; struct mmu_notifier_mm; struct mm_struct { struct vm_area_struct *mmap ; struct rb_root mm_rb ; struct vm_area_struct *mmap_cache ; unsigned long (*get_unmapped_area)(struct file * , unsigned long , unsigned long , unsigned long , unsigned long ) ; unsigned long mmap_base ; unsigned long mmap_legacy_base ; unsigned long task_size ; unsigned long highest_vm_end ; pgd_t *pgd ; atomic_t mm_users ; atomic_t mm_count ; int map_count ; spinlock_t page_table_lock ; struct rw_semaphore mmap_sem ; struct list_head mmlist ; unsigned long hiwater_rss ; unsigned long hiwater_vm ; unsigned long total_vm ; unsigned long locked_vm ; unsigned long pinned_vm ; unsigned long shared_vm ; unsigned long exec_vm ; unsigned long stack_vm ; unsigned long def_flags ; unsigned long nr_ptes ; unsigned long start_code ; unsigned long end_code ; unsigned long start_data ; unsigned long end_data ; unsigned long start_brk ; unsigned long brk ; unsigned long start_stack ; unsigned long arg_start ; unsigned long arg_end ; unsigned long env_start ; unsigned long env_end ; unsigned long saved_auxv[44U] ; struct mm_rss_stat rss_stat ; struct linux_binfmt *binfmt ; cpumask_var_t cpu_vm_mask_var ; mm_context_t context ; unsigned long flags ; struct core_state *core_state ; spinlock_t ioctx_lock ; struct kioctx_table *ioctx_table ; struct task_struct *owner ; struct file *exe_file ; struct mmu_notifier_mm *mmu_notifier_mm ; pgtable_t pmd_huge_pte ; struct cpumask cpumask_allocation ; unsigned long numa_next_scan ; unsigned long numa_next_reset ; unsigned long numa_scan_offset ; int numa_scan_seq ; int first_nid ; struct uprobes_state uprobes_state ; }; typedef unsigned long cputime_t; struct sem_undo_list; struct sysv_sem { struct sem_undo_list *undo_list ; }; struct __anonstruct_sigset_t_151 { unsigned long sig[1U] ; }; typedef struct __anonstruct_sigset_t_151 sigset_t; struct siginfo; typedef void __signalfn_t(int ); typedef __signalfn_t *__sighandler_t; typedef void __restorefn_t(void); typedef __restorefn_t *__sigrestore_t; union sigval { int sival_int ; void *sival_ptr ; }; typedef union sigval sigval_t; struct __anonstruct__kill_153 { __kernel_pid_t _pid ; __kernel_uid32_t _uid ; }; struct __anonstruct__timer_154 { __kernel_timer_t _tid ; int _overrun ; char _pad[0U] ; sigval_t _sigval ; int _sys_private ; }; struct __anonstruct__rt_155 { __kernel_pid_t _pid ; __kernel_uid32_t _uid ; sigval_t _sigval ; }; struct __anonstruct__sigchld_156 { __kernel_pid_t _pid ; __kernel_uid32_t _uid ; int _status ; __kernel_clock_t _utime ; __kernel_clock_t _stime ; }; struct __anonstruct__sigfault_157 { void *_addr ; short _addr_lsb ; }; struct __anonstruct__sigpoll_158 { long _band ; int _fd ; }; struct __anonstruct__sigsys_159 { void *_call_addr ; int _syscall ; unsigned int _arch ; }; union __anonunion__sifields_152 { int _pad[28U] ; struct __anonstruct__kill_153 _kill ; struct __anonstruct__timer_154 _timer ; struct __anonstruct__rt_155 _rt ; struct __anonstruct__sigchld_156 _sigchld ; struct __anonstruct__sigfault_157 _sigfault ; struct __anonstruct__sigpoll_158 _sigpoll ; struct __anonstruct__sigsys_159 _sigsys ; }; struct siginfo { int si_signo ; int si_errno ; int si_code ; union __anonunion__sifields_152 _sifields ; }; typedef struct siginfo siginfo_t; struct user_struct; struct sigpending { struct list_head list ; sigset_t signal ; }; struct sigaction { __sighandler_t sa_handler ; unsigned long sa_flags ; __sigrestore_t sa_restorer ; sigset_t sa_mask ; }; struct k_sigaction { struct sigaction sa ; }; enum pid_type { PIDTYPE_PID = 0, PIDTYPE_PGID = 1, PIDTYPE_SID = 2, PIDTYPE_MAX = 3 } ; struct pid_namespace; struct upid { int nr ; struct pid_namespace *ns ; struct hlist_node pid_chain ; }; struct pid { atomic_t count ; unsigned int level ; struct hlist_head tasks[3U] ; struct callback_head rcu ; struct upid numbers[1U] ; }; struct pid_link { struct hlist_node node ; struct pid *pid ; }; struct percpu_counter { raw_spinlock_t lock ; s64 count ; struct list_head list ; s32 *counters ; }; struct seccomp_filter; struct seccomp { int mode ; struct seccomp_filter *filter ; }; struct plist_head { struct list_head node_list ; }; struct plist_node { int prio ; struct list_head prio_list ; struct list_head node_list ; }; struct rt_mutex_waiter; struct rlimit { unsigned long rlim_cur ; unsigned long rlim_max ; }; struct timerqueue_node { struct rb_node node ; ktime_t expires ; }; struct timerqueue_head { struct rb_root head ; struct timerqueue_node *next ; }; struct hrtimer_clock_base; struct hrtimer_cpu_base; enum hrtimer_restart { HRTIMER_NORESTART = 0, HRTIMER_RESTART = 1 } ; struct hrtimer { struct timerqueue_node node ; ktime_t _softexpires ; enum hrtimer_restart (*function)(struct hrtimer * ) ; struct hrtimer_clock_base *base ; unsigned long state ; int start_pid ; void *start_site ; char start_comm[16U] ; }; struct hrtimer_clock_base { struct hrtimer_cpu_base *cpu_base ; int index ; clockid_t clockid ; struct timerqueue_head active ; ktime_t resolution ; ktime_t (*get_time)(void) ; ktime_t softirq_time ; ktime_t offset ; }; struct hrtimer_cpu_base { raw_spinlock_t lock ; unsigned int active_bases ; unsigned int clock_was_set ; ktime_t expires_next ; int hres_active ; int hang_detected ; unsigned long nr_events ; unsigned long nr_retries ; unsigned long nr_hangs ; ktime_t max_hang_time ; struct hrtimer_clock_base clock_base[4U] ; }; struct task_io_accounting { u64 rchar ; u64 wchar ; u64 syscr ; u64 syscw ; u64 read_bytes ; u64 write_bytes ; u64 cancelled_write_bytes ; }; struct latency_record { unsigned long backtrace[12U] ; unsigned int count ; unsigned long time ; unsigned long max ; }; typedef int32_t key_serial_t; typedef uint32_t key_perm_t; struct key; struct signal_struct; struct key_type; struct keyring_list; union __anonunion_ldv_16757_162 { struct list_head graveyard_link ; struct rb_node serial_node ; }; struct key_user; union __anonunion_ldv_16766_163 { time_t expiry ; time_t revoked_at ; }; union __anonunion_type_data_164 { struct list_head link ; unsigned long x[2U] ; void *p[2U] ; int reject_error ; }; union __anonunion_payload_165 { unsigned long value ; void *rcudata ; void *data ; struct keyring_list *subscriptions ; }; struct key { atomic_t usage ; key_serial_t serial ; union __anonunion_ldv_16757_162 ldv_16757 ; struct key_type *type ; struct rw_semaphore sem ; struct key_user *user ; void *security ; union __anonunion_ldv_16766_163 ldv_16766 ; time_t last_used_at ; kuid_t uid ; kgid_t gid ; key_perm_t perm ; unsigned short quotalen ; unsigned short datalen ; unsigned long flags ; char *description ; union __anonunion_type_data_164 type_data ; union __anonunion_payload_165 payload ; }; struct audit_context; struct group_info { atomic_t usage ; int ngroups ; int nblocks ; kgid_t small_block[32U] ; kgid_t *blocks[0U] ; }; struct cred { atomic_t usage ; atomic_t subscribers ; void *put_addr ; unsigned int magic ; kuid_t uid ; kgid_t gid ; kuid_t suid ; kgid_t sgid ; kuid_t euid ; kgid_t egid ; kuid_t fsuid ; kgid_t fsgid ; unsigned int securebits ; kernel_cap_t cap_inheritable ; kernel_cap_t cap_permitted ; kernel_cap_t cap_effective ; kernel_cap_t cap_bset ; unsigned char jit_keyring ; struct key *session_keyring ; struct key *process_keyring ; struct key *thread_keyring ; struct key *request_key_auth ; void *security ; struct user_struct *user ; struct user_namespace *user_ns ; struct group_info *group_info ; struct callback_head rcu ; }; struct llist_node; struct llist_node { struct llist_node *next ; }; struct futex_pi_state; struct robust_list_head; struct bio_list; struct fs_struct; struct perf_event_context; struct blk_plug; struct cfs_rq; struct task_group; struct sighand_struct { atomic_t count ; struct k_sigaction action[64U] ; spinlock_t siglock ; wait_queue_head_t signalfd_wqh ; }; struct pacct_struct { int ac_flag ; long ac_exitcode ; unsigned long ac_mem ; cputime_t ac_utime ; cputime_t ac_stime ; unsigned long ac_minflt ; unsigned long ac_majflt ; }; struct cpu_itimer { cputime_t expires ; cputime_t incr ; u32 error ; u32 incr_error ; }; struct cputime { cputime_t utime ; cputime_t stime ; }; struct task_cputime { cputime_t utime ; cputime_t stime ; unsigned long long sum_exec_runtime ; }; struct thread_group_cputimer { struct task_cputime cputime ; int running ; raw_spinlock_t lock ; }; struct autogroup; struct tty_struct; struct taskstats; struct tty_audit_buf; struct signal_struct { atomic_t sigcnt ; atomic_t live ; int nr_threads ; wait_queue_head_t wait_chldexit ; struct task_struct *curr_target ; struct sigpending shared_pending ; int group_exit_code ; int notify_count ; struct task_struct *group_exit_task ; int group_stop_count ; unsigned int flags ; unsigned char is_child_subreaper : 1 ; unsigned char has_child_subreaper : 1 ; int posix_timer_id ; struct list_head posix_timers ; struct hrtimer real_timer ; struct pid *leader_pid ; ktime_t it_real_incr ; struct cpu_itimer it[2U] ; struct thread_group_cputimer cputimer ; struct task_cputime cputime_expires ; struct list_head cpu_timers[3U] ; struct pid *tty_old_pgrp ; int leader ; struct tty_struct *tty ; struct autogroup *autogroup ; cputime_t utime ; cputime_t stime ; cputime_t cutime ; cputime_t cstime ; cputime_t gtime ; cputime_t cgtime ; struct cputime prev_cputime ; unsigned long nvcsw ; unsigned long nivcsw ; unsigned long cnvcsw ; unsigned long cnivcsw ; unsigned long min_flt ; unsigned long maj_flt ; unsigned long cmin_flt ; unsigned long cmaj_flt ; unsigned long inblock ; unsigned long oublock ; unsigned long cinblock ; unsigned long coublock ; unsigned long maxrss ; unsigned long cmaxrss ; struct task_io_accounting ioac ; unsigned long long sum_sched_runtime ; struct rlimit rlim[16U] ; struct pacct_struct pacct ; struct taskstats *stats ; unsigned int audit_tty ; unsigned int audit_tty_log_passwd ; struct tty_audit_buf *tty_audit_buf ; struct rw_semaphore group_rwsem ; oom_flags_t oom_flags ; short oom_score_adj ; short oom_score_adj_min ; struct mutex cred_guard_mutex ; }; struct user_struct { atomic_t __count ; atomic_t processes ; atomic_t files ; atomic_t sigpending ; atomic_t inotify_watches ; atomic_t inotify_devs ; atomic_t fanotify_listeners ; atomic_long_t epoll_watches ; unsigned long mq_bytes ; unsigned long locked_shm ; struct key *uid_keyring ; struct key *session_keyring ; struct hlist_node uidhash_node ; kuid_t uid ; atomic_long_t locked_vm ; }; struct backing_dev_info; struct reclaim_state; struct sched_info { unsigned long pcount ; unsigned long long run_delay ; unsigned long long last_arrival ; unsigned long long last_queued ; }; struct task_delay_info { spinlock_t lock ; unsigned int flags ; struct timespec blkio_start ; struct timespec blkio_end ; u64 blkio_delay ; u64 swapin_delay ; u32 blkio_count ; u32 swapin_count ; struct timespec freepages_start ; struct timespec freepages_end ; u64 freepages_delay ; u32 freepages_count ; }; struct io_context; struct pipe_inode_info; struct uts_namespace; struct load_weight { unsigned long weight ; unsigned long inv_weight ; }; struct sched_avg { u32 runnable_avg_sum ; u32 runnable_avg_period ; u64 last_runnable_update ; s64 decay_count ; unsigned long load_avg_contrib ; }; struct sched_statistics { u64 wait_start ; u64 wait_max ; u64 wait_count ; u64 wait_sum ; u64 iowait_count ; u64 iowait_sum ; u64 sleep_start ; u64 sleep_max ; s64 sum_sleep_runtime ; u64 block_start ; u64 block_max ; u64 exec_max ; u64 slice_max ; u64 nr_migrations_cold ; u64 nr_failed_migrations_affine ; u64 nr_failed_migrations_running ; u64 nr_failed_migrations_hot ; u64 nr_forced_migrations ; u64 nr_wakeups ; u64 nr_wakeups_sync ; u64 nr_wakeups_migrate ; u64 nr_wakeups_local ; u64 nr_wakeups_remote ; u64 nr_wakeups_affine ; u64 nr_wakeups_affine_attempts ; u64 nr_wakeups_passive ; u64 nr_wakeups_idle ; }; struct sched_entity { struct load_weight load ; struct rb_node run_node ; struct list_head group_node ; unsigned int on_rq ; u64 exec_start ; u64 sum_exec_runtime ; u64 vruntime ; u64 prev_sum_exec_runtime ; u64 nr_migrations ; struct sched_statistics statistics ; struct sched_entity *parent ; struct cfs_rq *cfs_rq ; struct cfs_rq *my_q ; struct sched_avg avg ; }; struct rt_rq; struct sched_rt_entity { struct list_head run_list ; unsigned long timeout ; unsigned long watchdog_stamp ; unsigned int time_slice ; struct sched_rt_entity *back ; struct sched_rt_entity *parent ; struct rt_rq *rt_rq ; struct rt_rq *my_q ; }; struct memcg_batch_info { int do_batch ; struct mem_cgroup *memcg ; unsigned long nr_pages ; unsigned long memsw_nr_pages ; }; struct memcg_oom_info { unsigned char may_oom : 1 ; unsigned char in_memcg_oom : 1 ; unsigned char oom_locked : 1 ; int wakeups ; struct mem_cgroup *wait_on_memcg ; }; struct sched_class; struct files_struct; struct css_set; struct compat_robust_list_head; struct ftrace_ret_stack; struct task_struct { long volatile state ; void *stack ; atomic_t usage ; unsigned int flags ; unsigned int ptrace ; struct llist_node wake_entry ; int on_cpu ; struct task_struct *last_wakee ; unsigned long wakee_flips ; unsigned long wakee_flip_decay_ts ; int on_rq ; int prio ; int static_prio ; int normal_prio ; unsigned int rt_priority ; struct sched_class const *sched_class ; struct sched_entity se ; struct sched_rt_entity rt ; struct task_group *sched_task_group ; struct hlist_head preempt_notifiers ; unsigned char fpu_counter ; unsigned int btrace_seq ; unsigned int policy ; int nr_cpus_allowed ; cpumask_t cpus_allowed ; struct sched_info sched_info ; struct list_head tasks ; struct plist_node pushable_tasks ; struct mm_struct *mm ; struct mm_struct *active_mm ; unsigned char brk_randomized : 1 ; int exit_state ; int exit_code ; int exit_signal ; int pdeath_signal ; unsigned int jobctl ; unsigned int personality ; unsigned char did_exec : 1 ; unsigned char in_execve : 1 ; unsigned char in_iowait : 1 ; unsigned char no_new_privs : 1 ; unsigned char sched_reset_on_fork : 1 ; unsigned char sched_contributes_to_load : 1 ; pid_t pid ; pid_t tgid ; unsigned long stack_canary ; struct task_struct *real_parent ; struct task_struct *parent ; struct list_head children ; struct list_head sibling ; struct task_struct *group_leader ; struct list_head ptraced ; struct list_head ptrace_entry ; struct pid_link pids[3U] ; struct list_head thread_group ; struct completion *vfork_done ; int *set_child_tid ; int *clear_child_tid ; cputime_t utime ; cputime_t stime ; cputime_t utimescaled ; cputime_t stimescaled ; cputime_t gtime ; struct cputime prev_cputime ; unsigned long nvcsw ; unsigned long nivcsw ; struct timespec start_time ; struct timespec real_start_time ; unsigned long min_flt ; unsigned long maj_flt ; struct task_cputime cputime_expires ; struct list_head cpu_timers[3U] ; struct cred const *real_cred ; struct cred const *cred ; char comm[16U] ; int link_count ; int total_link_count ; struct sysv_sem sysvsem ; unsigned long last_switch_count ; struct thread_struct thread ; struct fs_struct *fs ; struct files_struct *files ; struct nsproxy *nsproxy ; struct signal_struct *signal ; struct sighand_struct *sighand ; sigset_t blocked ; sigset_t real_blocked ; sigset_t saved_sigmask ; struct sigpending pending ; unsigned long sas_ss_sp ; size_t sas_ss_size ; int (*notifier)(void * ) ; void *notifier_data ; sigset_t *notifier_mask ; struct callback_head *task_works ; struct audit_context *audit_context ; kuid_t loginuid ; unsigned int sessionid ; struct seccomp seccomp ; u32 parent_exec_id ; u32 self_exec_id ; spinlock_t alloc_lock ; raw_spinlock_t pi_lock ; struct plist_head pi_waiters ; struct rt_mutex_waiter *pi_blocked_on ; struct mutex_waiter *blocked_on ; unsigned int irq_events ; unsigned long hardirq_enable_ip ; unsigned long hardirq_disable_ip ; unsigned int hardirq_enable_event ; unsigned int hardirq_disable_event ; int hardirqs_enabled ; int hardirq_context ; unsigned long softirq_disable_ip ; unsigned long softirq_enable_ip ; unsigned int softirq_disable_event ; unsigned int softirq_enable_event ; int softirqs_enabled ; int softirq_context ; u64 curr_chain_key ; int lockdep_depth ; unsigned int lockdep_recursion ; struct held_lock held_locks[48U] ; gfp_t lockdep_reclaim_gfp ; void *journal_info ; struct bio_list *bio_list ; struct blk_plug *plug ; struct reclaim_state *reclaim_state ; struct backing_dev_info *backing_dev_info ; struct io_context *io_context ; unsigned long ptrace_message ; siginfo_t *last_siginfo ; struct task_io_accounting ioac ; u64 acct_rss_mem1 ; u64 acct_vm_mem1 ; cputime_t acct_timexpd ; nodemask_t mems_allowed ; seqcount_t mems_allowed_seq ; int cpuset_mem_spread_rotor ; int cpuset_slab_spread_rotor ; struct css_set *cgroups ; struct list_head cg_list ; struct robust_list_head *robust_list ; struct compat_robust_list_head *compat_robust_list ; struct list_head pi_state_list ; struct futex_pi_state *pi_state_cache ; struct perf_event_context *perf_event_ctxp[2U] ; struct mutex perf_event_mutex ; struct list_head perf_event_list ; struct mempolicy *mempolicy ; short il_next ; short pref_node_fork ; int numa_scan_seq ; int numa_migrate_seq ; unsigned int numa_scan_period ; u64 node_stamp ; struct callback_head numa_work ; struct callback_head rcu ; struct pipe_inode_info *splice_pipe ; struct page_frag task_frag ; struct task_delay_info *delays ; int make_it_fail ; int nr_dirtied ; int nr_dirtied_pause ; unsigned long dirty_paused_when ; int latency_record_count ; struct latency_record latency_record[32U] ; unsigned long timer_slack_ns ; unsigned long default_timer_slack_ns ; int curr_ret_stack ; struct ftrace_ret_stack *ret_stack ; unsigned long long ftrace_timestamp ; atomic_t trace_overrun ; atomic_t tracing_graph_pause ; unsigned long trace ; unsigned long trace_recursion ; struct memcg_batch_info memcg_batch ; unsigned int memcg_kmem_skip_account ; struct memcg_oom_info memcg_oom ; struct uprobe_task *utask ; unsigned int sequential_io ; unsigned int sequential_io_avg ; }; struct shrink_control { gfp_t gfp_mask ; unsigned long nr_to_scan ; nodemask_t nodes_to_scan ; int nid ; }; struct shrinker { unsigned long (*count_objects)(struct shrinker * , struct shrink_control * ) ; unsigned long (*scan_objects)(struct shrinker * , struct shrink_control * ) ; int seeks ; long batch ; unsigned long flags ; struct list_head list ; atomic_long_t *nr_deferred ; }; struct file_ra_state; struct vm_fault { unsigned int flags ; unsigned long pgoff ; void *virtual_address ; struct page *page ; }; struct vm_operations_struct { void (*open)(struct vm_area_struct * ) ; void (*close)(struct vm_area_struct * ) ; int (*fault)(struct vm_area_struct * , struct vm_fault * ) ; int (*page_mkwrite)(struct vm_area_struct * , struct vm_fault * ) ; int (*access)(struct vm_area_struct * , unsigned long , void * , int , int ) ; int (*set_policy)(struct vm_area_struct * , struct mempolicy * ) ; struct mempolicy *(*get_policy)(struct vm_area_struct * , unsigned long ) ; int (*migrate)(struct vm_area_struct * , nodemask_t const * , nodemask_t const * , unsigned long ) ; int (*remap_pages)(struct vm_area_struct * , unsigned long , unsigned long , unsigned long ) ; }; struct kvec; struct iovec { void *iov_base ; __kernel_size_t iov_len ; }; struct kvec { void *iov_base ; size_t iov_len ; }; typedef unsigned short __kernel_sa_family_t; struct __kernel_sockaddr_storage { __kernel_sa_family_t ss_family ; char __data[126U] ; }; typedef __kernel_sa_family_t sa_family_t; struct sockaddr { sa_family_t sa_family ; char sa_data[14U] ; }; 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 int msg_flags ; }; struct in_addr { __be32 s_addr ; }; struct sockaddr_in { __kernel_sa_family_t sin_family ; __be16 sin_port ; struct in_addr sin_addr ; unsigned char __pad[8U] ; }; union __anonunion_in6_u_167 { __u8 u6_addr8[16U] ; __be16 u6_addr16[8U] ; __be32 u6_addr32[4U] ; }; struct in6_addr { union __anonunion_in6_u_167 in6_u ; }; struct sockaddr_in6 { unsigned short sin6_family ; __be16 sin6_port ; __be32 sin6_flowinfo ; struct in6_addr sin6_addr ; __u32 sin6_scope_id ; }; typedef u32 rpc_authflavor_t; struct scatterlist { unsigned long sg_magic ; unsigned long page_link ; unsigned int offset ; unsigned int length ; dma_addr_t dma_address ; unsigned int dma_length ; }; struct sg_table { struct scatterlist *sgl ; unsigned int nents ; unsigned int orig_nents ; }; struct xdr_netobj { unsigned int len ; u8 *data ; }; struct xdr_buf { struct kvec head[1U] ; struct kvec tail[1U] ; struct page **pages ; unsigned int page_base ; unsigned int page_len ; unsigned int flags ; unsigned int buflen ; unsigned int len ; }; struct sk_buff; struct xdr_stream { __be32 *p ; struct xdr_buf *buf ; __be32 *end ; struct kvec *iov ; struct kvec scratch ; struct page **page_ptr ; unsigned int nwords ; }; struct rpc_procinfo; struct rpc_cred; struct rpc_message { struct rpc_procinfo *rpc_proc ; void *rpc_argp ; void *rpc_resp ; struct rpc_cred *rpc_cred ; }; struct rpc_call_ops; struct rpc_wait_queue; struct rpc_wait { struct list_head list ; struct list_head links ; struct list_head timer_list ; unsigned long expires ; }; struct rpc_clnt; struct rpc_rqst; union __anonunion_u_168 { struct work_struct tk_work ; struct rpc_wait tk_wait ; }; struct rpc_task { atomic_t tk_count ; struct list_head tk_task ; struct rpc_clnt *tk_client ; struct rpc_rqst *tk_rqstp ; struct rpc_message tk_msg ; void (*tk_callback)(struct rpc_task * ) ; void (*tk_action)(struct rpc_task * ) ; struct rpc_call_ops const *tk_ops ; void *tk_calldata ; unsigned long tk_timeout ; unsigned long tk_runstate ; struct workqueue_struct *tk_workqueue ; struct rpc_wait_queue *tk_waitqueue ; union __anonunion_u_168 u ; ktime_t tk_start ; pid_t tk_owner ; int tk_status ; unsigned short tk_flags ; unsigned short tk_timeouts ; unsigned short tk_pid ; unsigned char tk_priority : 2 ; unsigned char tk_garb_retry : 2 ; unsigned char tk_cred_retry : 2 ; unsigned char tk_rebind_retry : 2 ; }; struct rpc_call_ops { void (*rpc_call_prepare)(struct rpc_task * , void * ) ; void (*rpc_call_done)(struct rpc_task * , void * ) ; void (*rpc_count_stats)(struct rpc_task * , void * ) ; void (*rpc_release)(void * ) ; }; struct rpc_timer { struct timer_list timer ; struct list_head list ; unsigned long expires ; }; struct rpc_wait_queue { spinlock_t lock ; struct list_head tasks[4U] ; pid_t owner ; unsigned char maxpriority ; unsigned char priority ; unsigned char nr ; unsigned short qlen ; struct rpc_timer timer_list ; char const *name ; }; struct rpc_timeout { unsigned long to_initval ; unsigned long to_maxval ; unsigned long to_increment ; unsigned int to_retries ; unsigned char to_exponential ; }; enum rpc_display_format_t { RPC_DISPLAY_ADDR = 0, RPC_DISPLAY_PORT = 1, RPC_DISPLAY_PROTO = 2, RPC_DISPLAY_HEX_ADDR = 3, RPC_DISPLAY_HEX_PORT = 4, RPC_DISPLAY_NETID = 5, RPC_DISPLAY_MAX = 6 } ; struct rpc_xprt; struct rpc_rqst { struct rpc_xprt *rq_xprt ; struct xdr_buf rq_snd_buf ; struct xdr_buf rq_rcv_buf ; struct rpc_task *rq_task ; struct rpc_cred *rq_cred ; __be32 rq_xid ; int rq_cong ; u32 rq_seqno ; int rq_enc_pages_num ; struct page **rq_enc_pages ; void (*rq_release_snd_buf)(struct rpc_rqst * ) ; struct list_head rq_list ; __u32 *rq_buffer ; size_t rq_callsize ; size_t rq_rcvsize ; size_t rq_xmit_bytes_sent ; size_t rq_reply_bytes_recvd ; struct xdr_buf rq_private_buf ; unsigned long rq_majortimeo ; unsigned long rq_timeout ; ktime_t rq_rtt ; unsigned int rq_retries ; unsigned int rq_connect_cookie ; u32 rq_bytes_sent ; ktime_t rq_xtime ; int rq_ntrans ; struct list_head rq_bc_list ; unsigned long rq_bc_pa_state ; struct list_head rq_bc_pa_list ; }; struct rpc_xprt_ops { void (*set_buffer_size)(struct rpc_xprt * , size_t , size_t ) ; int (*reserve_xprt)(struct rpc_xprt * , struct rpc_task * ) ; void (*release_xprt)(struct rpc_xprt * , struct rpc_task * ) ; void (*alloc_slot)(struct rpc_xprt * , struct rpc_task * ) ; void (*rpcbind)(struct rpc_task * ) ; void (*set_port)(struct rpc_xprt * , unsigned short ) ; void (*connect)(struct rpc_xprt * , struct rpc_task * ) ; void *(*buf_alloc)(struct rpc_task * , size_t ) ; void (*buf_free)(void * ) ; int (*send_request)(struct rpc_task * ) ; void (*set_retrans_timeout)(struct rpc_task * ) ; void (*timer)(struct rpc_xprt * , struct rpc_task * ) ; void (*release_request)(struct rpc_task * ) ; void (*close)(struct rpc_xprt * ) ; void (*destroy)(struct rpc_xprt * ) ; void (*print_stats)(struct rpc_xprt * , struct seq_file * ) ; }; struct svc_xprt; struct svc_serv; struct __anonstruct_stat_169 { unsigned long bind_count ; unsigned long connect_count ; unsigned long connect_start ; unsigned long connect_time ; unsigned long sends ; unsigned long recvs ; unsigned long bad_xids ; unsigned long max_slots ; unsigned long long req_u ; unsigned long long bklog_u ; unsigned long long sending_u ; unsigned long long pending_u ; }; struct rpc_xprt { atomic_t count ; struct rpc_xprt_ops *ops ; struct rpc_timeout const *timeout ; struct __kernel_sockaddr_storage addr ; size_t addrlen ; int prot ; unsigned long cong ; unsigned long cwnd ; size_t max_payload ; unsigned int tsh_size ; struct rpc_wait_queue binding ; struct rpc_wait_queue sending ; struct rpc_wait_queue pending ; struct rpc_wait_queue backlog ; struct list_head free ; unsigned int max_reqs ; unsigned int min_reqs ; atomic_t num_reqs ; unsigned long state ; unsigned char resvport : 1 ; unsigned int swapper ; unsigned int bind_index ; unsigned long bind_timeout ; unsigned long reestablish_timeout ; unsigned int connect_cookie ; struct work_struct task_cleanup ; struct timer_list timer ; unsigned long last_used ; unsigned long idle_timeout ; spinlock_t transport_lock ; spinlock_t reserve_lock ; u32 xid ; struct rpc_task *snd_task ; struct svc_xprt *bc_xprt ; struct svc_serv *bc_serv ; unsigned int bc_alloc_count ; spinlock_t bc_pa_lock ; struct list_head bc_pa_list ; struct list_head recv ; struct __anonstruct_stat_169 stat ; struct net *xprt_net ; char const *servername ; char const *address_strings[6U] ; }; struct rpcsec_gss_info; struct auth_cred { kuid_t uid ; kgid_t gid ; struct group_info *group_info ; char const *principal ; unsigned long ac_flags ; unsigned char machine_cred : 1 ; }; struct rpc_auth; struct rpc_credops; struct rpc_cred { struct hlist_node cr_hash ; struct list_head cr_lru ; struct callback_head cr_rcu ; struct rpc_auth *cr_auth ; struct rpc_credops const *cr_ops ; unsigned long cr_magic ; unsigned long cr_expire ; unsigned long cr_flags ; atomic_t cr_count ; kuid_t cr_uid ; }; struct rpc_cred_cache; struct rpc_authops; struct rpc_auth { unsigned int au_cslack ; unsigned int au_rslack ; unsigned int au_verfsize ; unsigned int au_flags ; struct rpc_authops const *au_ops ; rpc_authflavor_t au_flavor ; atomic_t au_count ; struct rpc_cred_cache *au_credcache ; }; struct rpc_auth_create_args { rpc_authflavor_t pseudoflavor ; char const *target_name ; }; struct rpc_authops { struct module *owner ; rpc_authflavor_t au_flavor ; char *au_name ; struct rpc_auth *(*create)(struct rpc_auth_create_args * , struct rpc_clnt * ) ; void (*destroy)(struct rpc_auth * ) ; struct rpc_cred *(*lookup_cred)(struct rpc_auth * , struct auth_cred * , int ) ; struct rpc_cred *(*crcreate)(struct rpc_auth * , struct auth_cred * , int ) ; int (*list_pseudoflavors)(rpc_authflavor_t * , int ) ; rpc_authflavor_t (*info2flavor)(struct rpcsec_gss_info * ) ; int (*flavor2info)(rpc_authflavor_t , struct rpcsec_gss_info * ) ; int (*key_timeout)(struct rpc_auth * , struct rpc_cred * ) ; }; struct rpc_credops { char const *cr_name ; int (*cr_init)(struct rpc_auth * , struct rpc_cred * ) ; void (*crdestroy)(struct rpc_cred * ) ; int (*crmatch)(struct auth_cred * , struct rpc_cred * , int ) ; struct rpc_cred *(*crbind)(struct rpc_task * , struct rpc_cred * , int ) ; __be32 *(*crmarshal)(struct rpc_task * , __be32 * ) ; int (*crrefresh)(struct rpc_task * ) ; __be32 *(*crvalidate)(struct rpc_task * , __be32 * ) ; int (*crwrap_req)(struct rpc_task * , void (*)(void * , struct xdr_stream * , void * ) , void * , __be32 * , void * ) ; int (*crunwrap_resp)(struct rpc_task * , int (*)(void * , struct xdr_stream * , void * ) , void * , __be32 * , void * ) ; int (*crkey_timeout)(struct rpc_cred * ) ; bool (*crkey_to_expire)(struct rpc_cred * ) ; }; struct hlist_bl_node; struct hlist_bl_head { struct hlist_bl_node *first ; }; struct hlist_bl_node { struct hlist_bl_node *next ; struct hlist_bl_node **pprev ; }; struct __anonstruct_ldv_22557_171 { spinlock_t lock ; unsigned int count ; }; union __anonunion_ldv_22558_170 { struct __anonstruct_ldv_22557_171 ldv_22557 ; }; struct lockref { union __anonunion_ldv_22558_170 ldv_22558 ; }; struct path; struct vfsmount; struct __anonstruct_ldv_22578_173 { u32 hash ; u32 len ; }; union __anonunion_ldv_22580_172 { struct __anonstruct_ldv_22578_173 ldv_22578 ; u64 hash_len ; }; struct qstr { union __anonunion_ldv_22580_172 ldv_22580 ; unsigned char const *name ; }; struct dentry_operations; union __anonunion_d_u_174 { struct list_head d_child ; struct callback_head d_rcu ; }; struct dentry { unsigned int d_flags ; seqcount_t d_seq ; struct hlist_bl_node d_hash ; struct dentry *d_parent ; struct qstr d_name ; struct inode *d_inode ; unsigned char d_iname[32U] ; struct lockref d_lockref ; struct dentry_operations const *d_op ; struct super_block *d_sb ; unsigned long d_time ; void *d_fsdata ; struct list_head d_lru ; union __anonunion_d_u_174 d_u ; struct list_head d_subdirs ; struct hlist_node d_alias ; }; struct dentry_operations { int (*d_revalidate)(struct dentry * , unsigned int ) ; int (*d_weak_revalidate)(struct dentry * , unsigned int ) ; int (*d_hash)(struct dentry const * , struct qstr * ) ; int (*d_compare)(struct dentry const * , struct dentry const * , unsigned int , char const * , struct qstr const * ) ; int (*d_delete)(struct dentry const * ) ; void (*d_release)(struct dentry * ) ; void (*d_prune)(struct dentry * ) ; void (*d_iput)(struct dentry * , struct inode * ) ; char *(*d_dname)(struct dentry * , char * , int ) ; struct vfsmount *(*d_automount)(struct path * ) ; int (*d_manage)(struct dentry * , bool ) ; }; struct path { struct vfsmount *mnt ; struct dentry *dentry ; }; struct list_lru_node { spinlock_t lock ; struct list_head list ; long nr_items ; }; struct list_lru { struct list_lru_node *node ; nodemask_t active_nodes ; }; struct radix_tree_node; struct radix_tree_root { unsigned int height ; gfp_t gfp_mask ; struct radix_tree_node *rnode ; }; struct fiemap_extent { __u64 fe_logical ; __u64 fe_physical ; __u64 fe_length ; __u64 fe_reserved64[2U] ; __u32 fe_flags ; __u32 fe_reserved[3U] ; }; enum migrate_mode { MIGRATE_ASYNC = 0, MIGRATE_SYNC_LIGHT = 1, MIGRATE_SYNC = 2 } ; struct block_device; struct cgroup_subsys_state; struct export_operations; struct kiocb; struct poll_table_struct; struct kstatfs; struct swap_info_struct; struct iattr { unsigned int ia_valid ; umode_t ia_mode ; kuid_t ia_uid ; kgid_t ia_gid ; loff_t ia_size ; struct timespec ia_atime ; struct timespec ia_mtime ; struct timespec ia_ctime ; struct file *ia_file ; }; struct fs_disk_quota { __s8 d_version ; __s8 d_flags ; __u16 d_fieldmask ; __u32 d_id ; __u64 d_blk_hardlimit ; __u64 d_blk_softlimit ; __u64 d_ino_hardlimit ; __u64 d_ino_softlimit ; __u64 d_bcount ; __u64 d_icount ; __s32 d_itimer ; __s32 d_btimer ; __u16 d_iwarns ; __u16 d_bwarns ; __s32 d_padding2 ; __u64 d_rtb_hardlimit ; __u64 d_rtb_softlimit ; __u64 d_rtbcount ; __s32 d_rtbtimer ; __u16 d_rtbwarns ; __s16 d_padding3 ; char d_padding4[8U] ; }; struct fs_qfilestat { __u64 qfs_ino ; __u64 qfs_nblks ; __u32 qfs_nextents ; }; typedef struct fs_qfilestat fs_qfilestat_t; struct fs_quota_stat { __s8 qs_version ; __u16 qs_flags ; __s8 qs_pad ; fs_qfilestat_t qs_uquota ; fs_qfilestat_t qs_gquota ; __u32 qs_incoredqs ; __s32 qs_btimelimit ; __s32 qs_itimelimit ; __s32 qs_rtbtimelimit ; __u16 qs_bwarnlimit ; __u16 qs_iwarnlimit ; }; struct fs_qfilestatv { __u64 qfs_ino ; __u64 qfs_nblks ; __u32 qfs_nextents ; __u32 qfs_pad ; }; struct fs_quota_statv { __s8 qs_version ; __u8 qs_pad1 ; __u16 qs_flags ; __u32 qs_incoredqs ; struct fs_qfilestatv qs_uquota ; struct fs_qfilestatv qs_gquota ; struct fs_qfilestatv qs_pquota ; __s32 qs_btimelimit ; __s32 qs_itimelimit ; __s32 qs_rtbtimelimit ; __u16 qs_bwarnlimit ; __u16 qs_iwarnlimit ; __u64 qs_pad2[8U] ; }; struct dquot; typedef __kernel_uid32_t projid_t; struct __anonstruct_kprojid_t_175 { projid_t val ; }; typedef struct __anonstruct_kprojid_t_175 kprojid_t; struct if_dqinfo { __u64 dqi_bgrace ; __u64 dqi_igrace ; __u32 dqi_flags ; __u32 dqi_valid ; }; enum quota_type { USRQUOTA = 0, GRPQUOTA = 1, PRJQUOTA = 2 } ; typedef long long qsize_t; union __anonunion_ldv_23393_176 { kuid_t uid ; kgid_t gid ; kprojid_t projid ; }; struct kqid { union __anonunion_ldv_23393_176 ldv_23393 ; enum quota_type type ; }; struct mem_dqblk { qsize_t dqb_bhardlimit ; qsize_t dqb_bsoftlimit ; qsize_t dqb_curspace ; qsize_t dqb_rsvspace ; qsize_t dqb_ihardlimit ; qsize_t dqb_isoftlimit ; qsize_t dqb_curinodes ; time_t dqb_btime ; time_t dqb_itime ; }; struct quota_format_type; struct mem_dqinfo { struct quota_format_type *dqi_format ; int dqi_fmt_id ; struct list_head dqi_dirty_list ; unsigned long dqi_flags ; unsigned int dqi_bgrace ; unsigned int dqi_igrace ; qsize_t dqi_maxblimit ; qsize_t dqi_maxilimit ; void *dqi_priv ; }; struct dquot { struct hlist_node dq_hash ; struct list_head dq_inuse ; struct list_head dq_free ; struct list_head dq_dirty ; struct mutex dq_lock ; atomic_t dq_count ; wait_queue_head_t dq_wait_unused ; struct super_block *dq_sb ; struct kqid dq_id ; loff_t dq_off ; unsigned long dq_flags ; struct mem_dqblk dq_dqb ; }; struct quota_format_ops { int (*check_quota_file)(struct super_block * , int ) ; int (*read_file_info)(struct super_block * , int ) ; int (*write_file_info)(struct super_block * , int ) ; int (*free_file_info)(struct super_block * , int ) ; int (*read_dqblk)(struct dquot * ) ; int (*commit_dqblk)(struct dquot * ) ; int (*release_dqblk)(struct dquot * ) ; }; struct dquot_operations { int (*write_dquot)(struct dquot * ) ; struct dquot *(*alloc_dquot)(struct super_block * , int ) ; void (*destroy_dquot)(struct dquot * ) ; int (*acquire_dquot)(struct dquot * ) ; int (*release_dquot)(struct dquot * ) ; int (*mark_dirty)(struct dquot * ) ; int (*write_info)(struct super_block * , int ) ; qsize_t *(*get_reserved_space)(struct inode * ) ; }; struct quotactl_ops { int (*quota_on)(struct super_block * , int , int , struct path * ) ; int (*quota_on_meta)(struct super_block * , int , int ) ; int (*quota_off)(struct super_block * , int ) ; int (*quota_sync)(struct super_block * , int ) ; int (*get_info)(struct super_block * , int , struct if_dqinfo * ) ; int (*set_info)(struct super_block * , int , struct if_dqinfo * ) ; int (*get_dqblk)(struct super_block * , struct kqid , struct fs_disk_quota * ) ; int (*set_dqblk)(struct super_block * , struct kqid , struct fs_disk_quota * ) ; int (*get_xstate)(struct super_block * , struct fs_quota_stat * ) ; int (*set_xstate)(struct super_block * , unsigned int , int ) ; int (*get_xstatev)(struct super_block * , struct fs_quota_statv * ) ; }; struct quota_format_type { int qf_fmt_id ; struct quota_format_ops const *qf_ops ; struct module *qf_owner ; struct quota_format_type *qf_next ; }; struct quota_info { unsigned int flags ; struct mutex dqio_mutex ; struct mutex dqonoff_mutex ; struct rw_semaphore dqptr_sem ; struct inode *files[2U] ; struct mem_dqinfo info[2U] ; struct quota_format_ops const *ops[2U] ; }; union __anonunion_arg_178 { char *buf ; void *data ; }; struct __anonstruct_read_descriptor_t_177 { size_t written ; size_t count ; union __anonunion_arg_178 arg ; int error ; }; typedef struct __anonstruct_read_descriptor_t_177 read_descriptor_t; struct address_space_operations { int (*writepage)(struct page * , struct writeback_control * ) ; int (*readpage)(struct file * , struct page * ) ; int (*writepages)(struct address_space * , struct writeback_control * ) ; int (*set_page_dirty)(struct page * ) ; int (*readpages)(struct file * , struct address_space * , struct list_head * , unsigned int ) ; int (*write_begin)(struct file * , struct address_space * , loff_t , unsigned int , unsigned int , struct page ** , void ** ) ; int (*write_end)(struct file * , struct address_space * , loff_t , unsigned int , unsigned int , struct page * , void * ) ; sector_t (*bmap)(struct address_space * , sector_t ) ; void (*invalidatepage)(struct page * , unsigned int , unsigned int ) ; int (*releasepage)(struct page * , gfp_t ) ; void (*freepage)(struct page * ) ; ssize_t (*direct_IO)(int , struct kiocb * , struct iovec const * , loff_t , unsigned long ) ; int (*get_xip_mem)(struct address_space * , unsigned long , int , void ** , unsigned long * ) ; int (*migratepage)(struct address_space * , struct page * , struct page * , enum migrate_mode ) ; int (*launder_page)(struct page * ) ; int (*is_partially_uptodate)(struct page * , read_descriptor_t * , unsigned long ) ; void (*is_dirty_writeback)(struct page * , bool * , bool * ) ; int (*error_remove_page)(struct address_space * , struct page * ) ; int (*swap_activate)(struct swap_info_struct * , struct file * , sector_t * ) ; void (*swap_deactivate)(struct file * ) ; }; struct address_space { struct inode *host ; struct radix_tree_root page_tree ; spinlock_t tree_lock ; unsigned int i_mmap_writable ; struct rb_root i_mmap ; struct list_head i_mmap_nonlinear ; struct mutex i_mmap_mutex ; unsigned long nrpages ; unsigned long writeback_index ; struct address_space_operations const *a_ops ; unsigned long flags ; struct backing_dev_info *backing_dev_info ; spinlock_t private_lock ; struct list_head private_list ; void *private_data ; }; struct request_queue; struct hd_struct; struct gendisk; struct block_device { dev_t bd_dev ; int bd_openers ; struct inode *bd_inode ; struct super_block *bd_super ; struct mutex bd_mutex ; struct list_head bd_inodes ; void *bd_claiming ; void *bd_holder ; int bd_holders ; bool bd_write_holder ; struct list_head bd_holder_disks ; struct block_device *bd_contains ; unsigned int bd_block_size ; struct hd_struct *bd_part ; unsigned int bd_part_count ; int bd_invalidated ; struct gendisk *bd_disk ; struct request_queue *bd_queue ; struct list_head bd_list ; unsigned long bd_private ; int bd_fsfreeze_count ; struct mutex bd_fsfreeze_mutex ; }; struct posix_acl; struct inode_operations; union __anonunion_ldv_23837_179 { unsigned int const i_nlink ; unsigned int __i_nlink ; }; union __anonunion_ldv_23857_180 { struct hlist_head i_dentry ; struct callback_head i_rcu ; }; struct file_lock; struct cdev; union __anonunion_ldv_23873_181 { struct pipe_inode_info *i_pipe ; struct block_device *i_bdev ; struct cdev *i_cdev ; }; struct inode { umode_t i_mode ; unsigned short i_opflags ; kuid_t i_uid ; kgid_t i_gid ; unsigned int i_flags ; struct posix_acl *i_acl ; struct posix_acl *i_default_acl ; struct inode_operations const *i_op ; struct super_block *i_sb ; struct address_space *i_mapping ; void *i_security ; unsigned long i_ino ; union __anonunion_ldv_23837_179 ldv_23837 ; dev_t i_rdev ; loff_t i_size ; struct timespec i_atime ; struct timespec i_mtime ; struct timespec i_ctime ; spinlock_t i_lock ; unsigned short i_bytes ; unsigned int i_blkbits ; blkcnt_t i_blocks ; unsigned long i_state ; struct mutex i_mutex ; unsigned long dirtied_when ; struct hlist_node i_hash ; struct list_head i_wb_list ; struct list_head i_lru ; struct list_head i_sb_list ; union __anonunion_ldv_23857_180 ldv_23857 ; u64 i_version ; atomic_t i_count ; atomic_t i_dio_count ; atomic_t i_writecount ; struct file_operations const *i_fop ; struct file_lock *i_flock ; struct address_space i_data ; struct dquot *i_dquot[2U] ; struct list_head i_devices ; union __anonunion_ldv_23873_181 ldv_23873 ; __u32 i_generation ; __u32 i_fsnotify_mask ; struct hlist_head i_fsnotify_marks ; atomic_t i_readcount ; void *i_private ; }; struct fown_struct { rwlock_t lock ; struct pid *pid ; enum pid_type pid_type ; kuid_t uid ; kuid_t euid ; int signum ; }; struct file_ra_state { unsigned long start ; unsigned int size ; unsigned int async_size ; unsigned int ra_pages ; unsigned int mmap_miss ; loff_t prev_pos ; }; union __anonunion_f_u_182 { struct list_head fu_list ; struct llist_node fu_llist ; struct callback_head fu_rcuhead ; }; struct file { union __anonunion_f_u_182 f_u ; struct path f_path ; struct inode *f_inode ; struct file_operations const *f_op ; spinlock_t f_lock ; int f_sb_list_cpu ; atomic_long_t f_count ; unsigned int f_flags ; fmode_t f_mode ; loff_t f_pos ; struct fown_struct f_owner ; struct cred const *f_cred ; struct file_ra_state f_ra ; u64 f_version ; void *f_security ; void *private_data ; struct list_head f_ep_links ; struct list_head f_tfile_llink ; struct address_space *f_mapping ; unsigned long f_mnt_write_state ; }; typedef struct files_struct *fl_owner_t; struct file_lock_operations { void (*fl_copy_lock)(struct file_lock * , struct file_lock * ) ; void (*fl_release_private)(struct file_lock * ) ; }; struct lock_manager_operations { int (*lm_compare_owner)(struct file_lock * , struct file_lock * ) ; unsigned long (*lm_owner_key)(struct file_lock * ) ; void (*lm_notify)(struct file_lock * ) ; int (*lm_grant)(struct file_lock * , struct file_lock * , int ) ; void (*lm_break)(struct file_lock * ) ; int (*lm_change)(struct file_lock ** , int ) ; }; struct nlm_lockowner; struct nfs_lock_info { u32 state ; struct nlm_lockowner *owner ; struct list_head list ; }; struct nfs4_lock_state; struct nfs4_lock_info { struct nfs4_lock_state *owner ; }; struct fasync_struct; struct __anonstruct_afs_184 { struct list_head link ; int state ; }; union __anonunion_fl_u_183 { struct nfs_lock_info nfs_fl ; struct nfs4_lock_info nfs4_fl ; struct __anonstruct_afs_184 afs ; }; struct file_lock { struct file_lock *fl_next ; struct hlist_node fl_link ; struct list_head fl_block ; fl_owner_t fl_owner ; unsigned int fl_flags ; unsigned char fl_type ; unsigned int fl_pid ; int fl_link_cpu ; struct pid *fl_nspid ; wait_queue_head_t fl_wait ; struct file *fl_file ; loff_t fl_start ; loff_t fl_end ; struct fasync_struct *fl_fasync ; unsigned long fl_break_time ; unsigned long fl_downgrade_time ; struct file_lock_operations const *fl_ops ; struct lock_manager_operations const *fl_lmops ; union __anonunion_fl_u_183 fl_u ; }; struct fasync_struct { spinlock_t fa_lock ; int magic ; int fa_fd ; struct fasync_struct *fa_next ; struct file *fa_file ; struct callback_head fa_rcu ; }; struct sb_writers { struct percpu_counter counter[3U] ; wait_queue_head_t wait ; int frozen ; wait_queue_head_t wait_unfrozen ; struct lockdep_map lock_map[3U] ; }; struct file_system_type; struct super_operations; struct xattr_handler; struct mtd_info; struct super_block { struct list_head s_list ; dev_t s_dev ; unsigned char s_blocksize_bits ; unsigned long s_blocksize ; loff_t s_maxbytes ; struct file_system_type *s_type ; struct super_operations const *s_op ; struct dquot_operations const *dq_op ; struct quotactl_ops const *s_qcop ; struct export_operations const *s_export_op ; unsigned long s_flags ; unsigned long s_magic ; struct dentry *s_root ; struct rw_semaphore s_umount ; int s_count ; atomic_t s_active ; void *s_security ; struct xattr_handler const **s_xattr ; struct list_head s_inodes ; struct hlist_bl_head s_anon ; struct list_head *s_files ; struct list_head s_mounts ; struct block_device *s_bdev ; struct backing_dev_info *s_bdi ; struct mtd_info *s_mtd ; struct hlist_node s_instances ; struct quota_info s_dquot ; struct sb_writers s_writers ; char s_id[32U] ; u8 s_uuid[16U] ; void *s_fs_info ; unsigned int s_max_links ; fmode_t s_mode ; u32 s_time_gran ; struct mutex s_vfs_rename_mutex ; char *s_subtype ; char *s_options ; struct dentry_operations const *s_d_op ; int cleancache_poolid ; struct shrinker s_shrink ; atomic_long_t s_remove_count ; int s_readonly_remount ; struct workqueue_struct *s_dio_done_wq ; struct list_lru s_dentry_lru ; struct list_lru s_inode_lru ; }; struct fiemap_extent_info { unsigned int fi_flags ; unsigned int fi_extents_mapped ; unsigned int fi_extents_max ; struct fiemap_extent *fi_extents_start ; }; struct dir_context { int (*actor)(void * , char const * , int , loff_t , u64 , unsigned int ) ; loff_t pos ; }; 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 * , char const * , size_t , loff_t * ) ; ssize_t (*aio_read)(struct kiocb * , struct iovec const * , unsigned long , loff_t ) ; ssize_t (*aio_write)(struct kiocb * , struct iovec const * , unsigned long , loff_t ) ; int (*iterate)(struct file * , struct dir_context * ) ; unsigned int (*poll)(struct file * , struct poll_table_struct * ) ; long (*unlocked_ioctl)(struct file * , unsigned int , unsigned long ) ; long (*compat_ioctl)(struct file * , unsigned int , unsigned long ) ; int (*mmap)(struct file * , struct vm_area_struct * ) ; int (*open)(struct inode * , struct file * ) ; int (*flush)(struct file * , fl_owner_t ) ; int (*release)(struct inode * , struct file * ) ; int (*fsync)(struct file * , loff_t , loff_t , int ) ; int (*aio_fsync)(struct kiocb * , int ) ; int (*fasync)(int , struct file * , int ) ; int (*lock)(struct file * , int , struct file_lock * ) ; ssize_t (*sendpage)(struct file * , struct page * , int , size_t , loff_t * , int ) ; unsigned long (*get_unmapped_area)(struct file * , unsigned long , unsigned long , unsigned long , unsigned long ) ; int (*check_flags)(int ) ; int (*flock)(struct file * , int , struct file_lock * ) ; ssize_t (*splice_write)(struct pipe_inode_info * , struct file * , loff_t * , size_t , unsigned int ) ; ssize_t (*splice_read)(struct file * , loff_t * , struct pipe_inode_info * , size_t , unsigned int ) ; int (*setlease)(struct file * , long , struct file_lock ** ) ; long (*fallocate)(struct file * , int , loff_t , loff_t ) ; int (*show_fdinfo)(struct seq_file * , struct file * ) ; }; struct inode_operations { struct dentry *(*lookup)(struct inode * , struct dentry * , unsigned int ) ; void *(*follow_link)(struct dentry * , struct nameidata * ) ; int (*permission)(struct inode * , int ) ; struct posix_acl *(*get_acl)(struct inode * , int ) ; int (*readlink)(struct dentry * , char * , int ) ; void (*put_link)(struct dentry * , struct nameidata * , void * ) ; int (*create)(struct inode * , struct dentry * , umode_t , bool ) ; int (*link)(struct dentry * , struct inode * , struct dentry * ) ; int (*unlink)(struct inode * , struct dentry * ) ; int (*symlink)(struct inode * , struct dentry * , char const * ) ; int (*mkdir)(struct inode * , struct dentry * , umode_t ) ; int (*rmdir)(struct inode * , struct dentry * ) ; int (*mknod)(struct inode * , struct dentry * , umode_t , dev_t ) ; int (*rename)(struct inode * , struct dentry * , struct inode * , struct dentry * ) ; int (*setattr)(struct dentry * , struct iattr * ) ; int (*getattr)(struct vfsmount * , struct dentry * , struct kstat * ) ; int (*setxattr)(struct dentry * , char const * , void const * , size_t , int ) ; ssize_t (*getxattr)(struct dentry * , char const * , void * , size_t ) ; ssize_t (*listxattr)(struct dentry * , char * , size_t ) ; int (*removexattr)(struct dentry * , char const * ) ; int (*fiemap)(struct inode * , struct fiemap_extent_info * , u64 , u64 ) ; int (*update_time)(struct inode * , struct timespec * , int ) ; int (*atomic_open)(struct inode * , struct dentry * , struct file * , unsigned int , umode_t , int * ) ; int (*tmpfile)(struct inode * , struct dentry * , umode_t ) ; }; struct super_operations { struct inode *(*alloc_inode)(struct super_block * ) ; void (*destroy_inode)(struct inode * ) ; void (*dirty_inode)(struct inode * , int ) ; int (*write_inode)(struct inode * , struct writeback_control * ) ; int (*drop_inode)(struct inode * ) ; void (*evict_inode)(struct inode * ) ; void (*put_super)(struct super_block * ) ; int (*sync_fs)(struct super_block * , int ) ; int (*freeze_fs)(struct super_block * ) ; int (*unfreeze_fs)(struct super_block * ) ; int (*statfs)(struct dentry * , struct kstatfs * ) ; int (*remount_fs)(struct super_block * , int * , char * ) ; void (*umount_begin)(struct super_block * ) ; int (*show_options)(struct seq_file * , struct dentry * ) ; int (*show_devname)(struct seq_file * , struct dentry * ) ; int (*show_path)(struct seq_file * , struct dentry * ) ; int (*show_stats)(struct seq_file * , struct dentry * ) ; ssize_t (*quota_read)(struct super_block * , int , char * , size_t , loff_t ) ; ssize_t (*quota_write)(struct super_block * , int , char const * , size_t , loff_t ) ; int (*bdev_try_to_free_page)(struct super_block * , struct page * , gfp_t ) ; long (*nr_cached_objects)(struct super_block * , int ) ; long (*free_cached_objects)(struct super_block * , long , int ) ; }; struct file_system_type { char const *name ; int fs_flags ; struct dentry *(*mount)(struct file_system_type * , int , char const * , void * ) ; void (*kill_sb)(struct super_block * ) ; struct module *owner ; struct file_system_type *next ; struct hlist_head fs_supers ; struct lock_class_key s_lock_key ; struct lock_class_key s_umount_key ; struct lock_class_key s_vfs_rename_key ; struct lock_class_key s_writers_key[3U] ; struct lock_class_key i_lock_key ; struct lock_class_key i_mutex_key ; struct lock_class_key i_mutex_dir_key ; }; struct proc_dir_entry; struct rpc_program; struct rpc_stat { struct rpc_program const *program ; unsigned int netcnt ; unsigned int netudpcnt ; unsigned int nettcpcnt ; unsigned int nettcpconn ; unsigned int netreconn ; unsigned int rpccnt ; unsigned int rpcretrans ; unsigned int rpcauthrefresh ; unsigned int rpcgarbage ; }; struct svc_program; struct svc_stat { struct svc_program *program ; unsigned int netcnt ; unsigned int netudpcnt ; unsigned int nettcpcnt ; unsigned int nettcpconn ; unsigned int rpccnt ; unsigned int rpcbadfmt ; unsigned int rpcbadauth ; unsigned int rpcbadclnt ; }; struct rpc_rtt { unsigned long timeo ; unsigned long srtt[5U] ; unsigned long sdrtt[5U] ; int ntimeouts[5U] ; }; struct rpc_pipe_dir_head { struct list_head pdh_entries ; struct dentry *pdh_dentry ; }; struct rpc_pipe_msg { struct list_head list ; void *data ; size_t len ; size_t copied ; int errno ; }; struct rpc_pipe_ops { ssize_t (*upcall)(struct file * , struct rpc_pipe_msg * , char * , size_t ) ; ssize_t (*downcall)(struct file * , char const * , size_t ) ; void (*release_pipe)(struct inode * ) ; int (*open_pipe)(struct inode * ) ; void (*destroy_msg)(struct rpc_pipe_msg * ) ; }; struct rpc_pipe { struct list_head pipe ; struct list_head in_upcall ; struct list_head in_downcall ; int pipelen ; int nreaders ; int nwriters ; int flags ; struct delayed_work queue_timeout ; struct rpc_pipe_ops const *ops ; spinlock_t lock ; struct dentry *dentry ; }; struct cache_detail; struct ipv6_devconf { __s32 forwarding ; __s32 hop_limit ; __s32 mtu6 ; __s32 accept_ra ; __s32 accept_redirects ; __s32 autoconf ; __s32 dad_transmits ; __s32 rtr_solicits ; __s32 rtr_solicit_interval ; __s32 rtr_solicit_delay ; __s32 force_mld_version ; __s32 mldv1_unsolicited_report_interval ; __s32 mldv2_unsolicited_report_interval ; __s32 use_tempaddr ; __s32 temp_valid_lft ; __s32 temp_prefered_lft ; __s32 regen_max_retry ; __s32 max_desync_factor ; __s32 max_addresses ; __s32 accept_ra_defrtr ; __s32 accept_ra_pinfo ; __s32 accept_ra_rtr_pref ; __s32 rtr_probe_interval ; __s32 accept_ra_rt_info_max_plen ; __s32 proxy_ndp ; __s32 accept_source_route ; __s32 optimistic_dad ; __s32 mc_forwarding ; __s32 disable_ipv6 ; __s32 accept_dad ; __s32 force_tllao ; __s32 ndisc_notify ; __s32 suppress_frag_ndisc ; void *sysctl ; }; enum ldv_20505 { SS_FREE = 0, SS_UNCONNECTED = 1, SS_CONNECTING = 2, SS_CONNECTED = 3, SS_DISCONNECTING = 4 } ; typedef enum ldv_20505 socket_state; struct socket_wq { wait_queue_head_t wait ; struct fasync_struct *fasync_list ; struct callback_head rcu ; }; struct proto_ops; struct socket { socket_state state ; short type ; unsigned long flags ; struct socket_wq *wq ; struct file *file ; struct sock *sk ; struct proto_ops const *ops ; }; struct proto_ops { int family ; struct module *owner ; int (*release)(struct socket * ) ; int (*bind)(struct socket * , struct sockaddr * , int ) ; int (*connect)(struct socket * , struct sockaddr * , int , int ) ; int (*socketpair)(struct socket * , struct socket * ) ; int (*accept)(struct socket * , struct socket * , int ) ; int (*getname)(struct socket * , struct sockaddr * , int * , int ) ; unsigned int (*poll)(struct file * , struct socket * , struct poll_table_struct * ) ; int (*ioctl)(struct socket * , unsigned int , unsigned long ) ; int (*compat_ioctl)(struct socket * , unsigned int , unsigned long ) ; int (*listen)(struct socket * , int ) ; int (*shutdown)(struct socket * , int ) ; int (*setsockopt)(struct socket * , int , int , char * , unsigned int ) ; int (*getsockopt)(struct socket * , int , int , char * , int * ) ; int (*compat_setsockopt)(struct socket * , int , int , char * , unsigned int ) ; int (*compat_getsockopt)(struct socket * , int , int , char * , int * ) ; int (*sendmsg)(struct kiocb * , struct socket * , struct msghdr * , size_t ) ; int (*recvmsg)(struct kiocb * , struct socket * , struct msghdr * , size_t , int ) ; int (*mmap)(struct file * , struct socket * , struct vm_area_struct * ) ; ssize_t (*sendpage)(struct socket * , struct page * , int , size_t , int ) ; ssize_t (*splice_read)(struct socket * , loff_t * , struct pipe_inode_info * , size_t , unsigned int ) ; void (*set_peek_off)(struct sock * , int ) ; }; struct exception_table_entry { int insn ; int fixup ; }; struct klist_node; struct klist_node { void *n_klist ; struct list_head n_node ; struct kref n_ref ; }; struct dma_map_ops; struct dev_archdata { struct dma_map_ops *dma_ops ; void *iommu ; }; struct device_private; struct device_driver; struct driver_private; struct class; struct subsys_private; struct bus_type; struct iommu_ops; struct iommu_group; struct bus_attribute { struct attribute attr ; ssize_t (*show)(struct bus_type * , char * ) ; ssize_t (*store)(struct bus_type * , char const * , size_t ) ; }; struct device_attribute; struct driver_attribute; struct bus_type { char const *name ; char const *dev_name ; struct device *dev_root ; struct bus_attribute *bus_attrs ; struct device_attribute *dev_attrs ; struct driver_attribute *drv_attrs ; struct attribute_group const **bus_groups ; struct attribute_group const **dev_groups ; struct attribute_group const **drv_groups ; int (*match)(struct device * , struct device_driver * ) ; int (*uevent)(struct device * , struct kobj_uevent_env * ) ; int (*probe)(struct device * ) ; int (*remove)(struct device * ) ; void (*shutdown)(struct device * ) ; int (*online)(struct device * ) ; int (*offline)(struct device * ) ; int (*suspend)(struct device * , pm_message_t ) ; int (*resume)(struct device * ) ; struct dev_pm_ops const *pm ; struct iommu_ops *iommu_ops ; struct subsys_private *p ; struct lock_class_key lock_key ; }; struct device_type; struct of_device_id; struct acpi_device_id; struct device_driver { char const *name ; struct bus_type *bus ; struct module *owner ; char const *mod_name ; bool suppress_bind_attrs ; struct of_device_id const *of_match_table ; struct acpi_device_id const *acpi_match_table ; int (*probe)(struct device * ) ; int (*remove)(struct device * ) ; void (*shutdown)(struct device * ) ; int (*suspend)(struct device * , pm_message_t ) ; int (*resume)(struct device * ) ; struct attribute_group const **groups ; struct dev_pm_ops const *pm ; struct driver_private *p ; }; struct driver_attribute { struct attribute attr ; ssize_t (*show)(struct device_driver * , char * ) ; ssize_t (*store)(struct device_driver * , char const * , size_t ) ; }; struct class_attribute; struct class { char const *name ; struct module *owner ; struct class_attribute *class_attrs ; struct device_attribute *dev_attrs ; struct attribute_group const **dev_groups ; struct bin_attribute *dev_bin_attrs ; struct kobject *dev_kobj ; int (*dev_uevent)(struct device * , struct kobj_uevent_env * ) ; char *(*devnode)(struct device * , umode_t * ) ; void (*class_release)(struct class * ) ; void (*dev_release)(struct device * ) ; int (*suspend)(struct device * , pm_message_t ) ; int (*resume)(struct device * ) ; struct kobj_ns_type_operations const *ns_type ; void const *(*namespace)(struct device * ) ; struct dev_pm_ops const *pm ; struct subsys_private *p ; }; struct class_attribute { struct attribute attr ; ssize_t (*show)(struct class * , struct class_attribute * , char * ) ; ssize_t (*store)(struct class * , struct class_attribute * , char const * , size_t ) ; void const *(*namespace)(struct class * , struct class_attribute const * ) ; }; struct device_type { char const *name ; struct attribute_group const **groups ; int (*uevent)(struct device * , struct kobj_uevent_env * ) ; char *(*devnode)(struct device * , umode_t * , kuid_t * , kgid_t * ) ; void (*release)(struct device * ) ; struct dev_pm_ops const *pm ; }; struct device_attribute { struct attribute attr ; ssize_t (*show)(struct device * , struct device_attribute * , char * ) ; ssize_t (*store)(struct device * , struct device_attribute * , char const * , size_t ) ; }; struct device_dma_parameters { unsigned int max_segment_size ; unsigned long segment_boundary_mask ; }; struct acpi_dev_node { void *handle ; }; struct dma_coherent_mem; struct device { struct device *parent ; struct device_private *p ; struct kobject kobj ; char const *init_name ; struct device_type const *type ; struct mutex mutex ; struct bus_type *bus ; struct device_driver *driver ; void *platform_data ; struct dev_pm_info power ; struct dev_pm_domain *pm_domain ; int numa_node ; u64 *dma_mask ; u64 coherent_dma_mask ; struct device_dma_parameters *dma_parms ; struct list_head dma_pools ; struct dma_coherent_mem *dma_mem ; struct dev_archdata archdata ; struct device_node *of_node ; struct acpi_dev_node acpi_node ; dev_t devt ; u32 id ; spinlock_t devres_lock ; struct list_head devres_head ; struct klist_node knode_class ; struct class *class ; struct attribute_group const **groups ; void (*release)(struct device * ) ; struct iommu_group *iommu_group ; bool offline_disabled ; bool offline ; }; struct wakeup_source { char const *name ; struct list_head entry ; spinlock_t lock ; struct timer_list timer ; unsigned long timer_expires ; ktime_t total_time ; ktime_t max_time ; ktime_t last_time ; ktime_t start_prevent_time ; ktime_t prevent_sleep_time ; unsigned long event_count ; unsigned long active_count ; unsigned long relax_count ; unsigned long expire_count ; unsigned long wakeup_count ; bool active ; bool autosleep_enabled ; }; typedef s32 dma_cookie_t; struct dma_attrs { unsigned long flags[1U] ; }; enum dma_data_direction { DMA_BIDIRECTIONAL = 0, DMA_TO_DEVICE = 1, DMA_FROM_DEVICE = 2, DMA_NONE = 3 } ; struct dma_map_ops { void *(*alloc)(struct device * , size_t , dma_addr_t * , gfp_t , struct dma_attrs * ) ; void (*free)(struct device * , size_t , void * , dma_addr_t , struct dma_attrs * ) ; int (*mmap)(struct device * , struct vm_area_struct * , void * , dma_addr_t , size_t , struct dma_attrs * ) ; int (*get_sgtable)(struct device * , struct sg_table * , void * , dma_addr_t , size_t , struct dma_attrs * ) ; dma_addr_t (*map_page)(struct device * , struct page * , unsigned long , size_t , enum dma_data_direction , struct dma_attrs * ) ; void (*unmap_page)(struct device * , dma_addr_t , size_t , enum dma_data_direction , struct dma_attrs * ) ; int (*map_sg)(struct device * , struct scatterlist * , int , enum dma_data_direction , struct dma_attrs * ) ; void (*unmap_sg)(struct device * , struct scatterlist * , int , enum dma_data_direction , struct dma_attrs * ) ; void (*sync_single_for_cpu)(struct device * , dma_addr_t , size_t , enum dma_data_direction ) ; void (*sync_single_for_device)(struct device * , dma_addr_t , size_t , enum dma_data_direction ) ; void (*sync_sg_for_cpu)(struct device * , struct scatterlist * , int , enum dma_data_direction ) ; void (*sync_sg_for_device)(struct device * , struct scatterlist * , int , enum dma_data_direction ) ; int (*mapping_error)(struct device * , dma_addr_t ) ; int (*dma_supported)(struct device * , u64 ) ; int (*set_dma_mask)(struct device * , u64 ) ; int is_phys ; }; typedef u64 netdev_features_t; struct nf_conntrack { atomic_t use ; }; struct nf_bridge_info { atomic_t use ; unsigned int mask ; struct net_device *physindev ; struct net_device *physoutdev ; unsigned long data[4U] ; }; struct sk_buff_head { struct sk_buff *next ; struct sk_buff *prev ; __u32 qlen ; spinlock_t lock ; }; typedef unsigned int sk_buff_data_t; struct sec_path; struct __anonstruct_ldv_29206_189 { __u16 csum_start ; __u16 csum_offset ; }; union __anonunion_ldv_29207_188 { __wsum csum ; struct __anonstruct_ldv_29206_189 ldv_29206 ; }; union __anonunion_ldv_29244_190 { unsigned int napi_id ; dma_cookie_t dma_cookie ; }; union __anonunion_ldv_29250_191 { __u32 mark ; __u32 dropcount ; __u32 reserved_tailroom ; }; struct sk_buff { struct sk_buff *next ; struct sk_buff *prev ; ktime_t tstamp ; struct sock *sk ; struct net_device *dev ; char cb[48U] ; unsigned long _skb_refdst ; struct sec_path *sp ; unsigned int len ; unsigned int data_len ; __u16 mac_len ; __u16 hdr_len ; union __anonunion_ldv_29207_188 ldv_29207 ; __u32 priority ; unsigned char local_df : 1 ; unsigned char cloned : 1 ; unsigned char ip_summed : 2 ; unsigned char nohdr : 1 ; unsigned char nfctinfo : 3 ; unsigned char pkt_type : 3 ; unsigned char fclone : 2 ; unsigned char ipvs_property : 1 ; unsigned char peeked : 1 ; unsigned char nf_trace : 1 ; __be16 protocol ; void (*destructor)(struct sk_buff * ) ; struct nf_conntrack *nfct ; struct sk_buff *nfct_reasm ; struct nf_bridge_info *nf_bridge ; int skb_iif ; __u32 rxhash ; __be16 vlan_proto ; __u16 vlan_tci ; __u16 tc_index ; __u16 tc_verd ; __u16 queue_mapping ; unsigned char ndisc_nodetype : 2 ; unsigned char pfmemalloc : 1 ; unsigned char ooo_okay : 1 ; unsigned char l4_rxhash : 1 ; unsigned char wifi_acked_valid : 1 ; unsigned char wifi_acked : 1 ; unsigned char no_fcs : 1 ; unsigned char head_frag : 1 ; unsigned char encapsulation : 1 ; union __anonunion_ldv_29244_190 ldv_29244 ; __u32 secmark ; union __anonunion_ldv_29250_191 ldv_29250 ; __be16 inner_protocol ; __u16 inner_transport_header ; __u16 inner_network_header ; __u16 inner_mac_header ; __u16 transport_header ; __u16 network_header ; __u16 mac_header ; sk_buff_data_t tail ; sk_buff_data_t end ; unsigned char *head ; unsigned char *data ; unsigned int truesize ; atomic_t users ; }; struct dst_entry; struct rtable; struct pm_qos_request { struct plist_node node ; int pm_qos_class ; struct delayed_work work ; }; struct pm_qos_flags_request { struct list_head node ; s32 flags ; }; enum dev_pm_qos_req_type { DEV_PM_QOS_LATENCY = 1, DEV_PM_QOS_FLAGS = 2 } ; union __anonunion_data_193 { struct plist_node pnode ; struct pm_qos_flags_request flr ; }; struct dev_pm_qos_request { enum dev_pm_qos_req_type type ; union __anonunion_data_193 data ; struct device *dev ; }; enum pm_qos_type { PM_QOS_UNITIALIZED = 0, PM_QOS_MAX = 1, PM_QOS_MIN = 2 } ; struct pm_qos_constraints { struct plist_head list ; s32 target_value ; s32 default_value ; enum pm_qos_type type ; struct blocking_notifier_head *notifiers ; }; struct pm_qos_flags { struct list_head list ; s32 effective_flags ; }; struct dev_pm_qos { struct pm_qos_constraints latency ; struct pm_qos_flags flags ; struct dev_pm_qos_request *latency_req ; struct dev_pm_qos_request *flags_req ; }; struct dql { unsigned int num_queued ; unsigned int adj_limit ; unsigned int last_obj_cnt ; unsigned int limit ; unsigned int num_completed ; unsigned int prev_ovlimit ; unsigned int prev_num_queued ; unsigned int prev_last_obj_cnt ; unsigned int lowest_slack ; unsigned long slack_start_time ; unsigned int max_limit ; unsigned int min_limit ; unsigned int slack_hold_time ; }; struct __anonstruct_sync_serial_settings_194 { unsigned int clock_rate ; unsigned int clock_type ; unsigned short loopback ; }; typedef struct __anonstruct_sync_serial_settings_194 sync_serial_settings; struct __anonstruct_te1_settings_195 { unsigned int clock_rate ; unsigned int clock_type ; unsigned short loopback ; unsigned int slot_map ; }; typedef struct __anonstruct_te1_settings_195 te1_settings; struct __anonstruct_raw_hdlc_proto_196 { unsigned short encoding ; unsigned short parity ; }; typedef struct __anonstruct_raw_hdlc_proto_196 raw_hdlc_proto; struct __anonstruct_fr_proto_197 { unsigned int t391 ; unsigned int t392 ; unsigned int n391 ; unsigned int n392 ; unsigned int n393 ; unsigned short lmi ; unsigned short dce ; }; typedef struct __anonstruct_fr_proto_197 fr_proto; struct __anonstruct_fr_proto_pvc_198 { unsigned int dlci ; }; typedef struct __anonstruct_fr_proto_pvc_198 fr_proto_pvc; struct __anonstruct_fr_proto_pvc_info_199 { unsigned int dlci ; char master[16U] ; }; typedef struct __anonstruct_fr_proto_pvc_info_199 fr_proto_pvc_info; struct __anonstruct_cisco_proto_200 { unsigned int interval ; unsigned int timeout ; }; typedef struct __anonstruct_cisco_proto_200 cisco_proto; struct ifmap { unsigned long mem_start ; unsigned long mem_end ; unsigned short base_addr ; unsigned char irq ; unsigned char dma ; unsigned char port ; }; union __anonunion_ifs_ifsu_201 { raw_hdlc_proto *raw_hdlc ; cisco_proto *cisco ; fr_proto *fr ; fr_proto_pvc *fr_pvc ; fr_proto_pvc_info *fr_pvc_info ; sync_serial_settings *sync ; te1_settings *te1 ; }; struct if_settings { unsigned int type ; unsigned int size ; union __anonunion_ifs_ifsu_201 ifs_ifsu ; }; union __anonunion_ifr_ifrn_202 { char ifrn_name[16U] ; }; union __anonunion_ifr_ifru_203 { struct sockaddr ifru_addr ; struct sockaddr ifru_dstaddr ; struct sockaddr ifru_broadaddr ; struct sockaddr ifru_netmask ; struct sockaddr ifru_hwaddr ; short ifru_flags ; int ifru_ivalue ; int ifru_mtu ; struct ifmap ifru_map ; char ifru_slave[16U] ; char ifru_newname[16U] ; void *ifru_data ; struct if_settings ifru_settings ; }; struct ifreq { union __anonunion_ifr_ifrn_202 ifr_ifrn ; union __anonunion_ifr_ifru_203 ifr_ifru ; }; typedef s32 compat_time_t; typedef s32 compat_long_t; typedef u32 compat_uptr_t; struct compat_timespec { compat_time_t tv_sec ; s32 tv_nsec ; }; struct compat_robust_list { compat_uptr_t next ; }; struct compat_robust_list_head { struct compat_robust_list list ; compat_long_t futex_offset ; compat_uptr_t list_op_pending ; }; struct ethhdr { unsigned char h_dest[6U] ; unsigned char h_source[6U] ; __be16 h_proto ; }; struct ethtool_cmd { __u32 cmd ; __u32 supported ; __u32 advertising ; __u16 speed ; __u8 duplex ; __u8 port ; __u8 phy_address ; __u8 transceiver ; __u8 autoneg ; __u8 mdio_support ; __u32 maxtxpkt ; __u32 maxrxpkt ; __u16 speed_hi ; __u8 eth_tp_mdix ; __u8 eth_tp_mdix_ctrl ; __u32 lp_advertising ; __u32 reserved[2U] ; }; struct ethtool_drvinfo { __u32 cmd ; char driver[32U] ; char version[32U] ; char fw_version[32U] ; char bus_info[32U] ; char reserved1[32U] ; char reserved2[12U] ; __u32 n_priv_flags ; __u32 n_stats ; __u32 testinfo_len ; __u32 eedump_len ; __u32 regdump_len ; }; struct ethtool_wolinfo { __u32 cmd ; __u32 supported ; __u32 wolopts ; __u8 sopass[6U] ; }; struct ethtool_regs { __u32 cmd ; __u32 version ; __u32 len ; __u8 data[0U] ; }; struct ethtool_eeprom { __u32 cmd ; __u32 magic ; __u32 offset ; __u32 len ; __u8 data[0U] ; }; struct ethtool_eee { __u32 cmd ; __u32 supported ; __u32 advertised ; __u32 lp_advertised ; __u32 eee_active ; __u32 eee_enabled ; __u32 tx_lpi_enabled ; __u32 tx_lpi_timer ; __u32 reserved[2U] ; }; struct ethtool_modinfo { __u32 cmd ; __u32 type ; __u32 eeprom_len ; __u32 reserved[8U] ; }; struct ethtool_coalesce { __u32 cmd ; __u32 rx_coalesce_usecs ; __u32 rx_max_coalesced_frames ; __u32 rx_coalesce_usecs_irq ; __u32 rx_max_coalesced_frames_irq ; __u32 tx_coalesce_usecs ; __u32 tx_max_coalesced_frames ; __u32 tx_coalesce_usecs_irq ; __u32 tx_max_coalesced_frames_irq ; __u32 stats_block_coalesce_usecs ; __u32 use_adaptive_rx_coalesce ; __u32 use_adaptive_tx_coalesce ; __u32 pkt_rate_low ; __u32 rx_coalesce_usecs_low ; __u32 rx_max_coalesced_frames_low ; __u32 tx_coalesce_usecs_low ; __u32 tx_max_coalesced_frames_low ; __u32 pkt_rate_high ; __u32 rx_coalesce_usecs_high ; __u32 rx_max_coalesced_frames_high ; __u32 tx_coalesce_usecs_high ; __u32 tx_max_coalesced_frames_high ; __u32 rate_sample_interval ; }; struct ethtool_ringparam { __u32 cmd ; __u32 rx_max_pending ; __u32 rx_mini_max_pending ; __u32 rx_jumbo_max_pending ; __u32 tx_max_pending ; __u32 rx_pending ; __u32 rx_mini_pending ; __u32 rx_jumbo_pending ; __u32 tx_pending ; }; struct ethtool_channels { __u32 cmd ; __u32 max_rx ; __u32 max_tx ; __u32 max_other ; __u32 max_combined ; __u32 rx_count ; __u32 tx_count ; __u32 other_count ; __u32 combined_count ; }; struct ethtool_pauseparam { __u32 cmd ; __u32 autoneg ; __u32 rx_pause ; __u32 tx_pause ; }; struct ethtool_test { __u32 cmd ; __u32 flags ; __u32 reserved ; __u32 len ; __u64 data[0U] ; }; struct ethtool_stats { __u32 cmd ; __u32 n_stats ; __u64 data[0U] ; }; struct ethtool_tcpip4_spec { __be32 ip4src ; __be32 ip4dst ; __be16 psrc ; __be16 pdst ; __u8 tos ; }; struct ethtool_ah_espip4_spec { __be32 ip4src ; __be32 ip4dst ; __be32 spi ; __u8 tos ; }; struct ethtool_usrip4_spec { __be32 ip4src ; __be32 ip4dst ; __be32 l4_4_bytes ; __u8 tos ; __u8 ip_ver ; __u8 proto ; }; union ethtool_flow_union { struct ethtool_tcpip4_spec tcp_ip4_spec ; struct ethtool_tcpip4_spec udp_ip4_spec ; struct ethtool_tcpip4_spec sctp_ip4_spec ; struct ethtool_ah_espip4_spec ah_ip4_spec ; struct ethtool_ah_espip4_spec esp_ip4_spec ; struct ethtool_usrip4_spec usr_ip4_spec ; struct ethhdr ether_spec ; __u8 hdata[52U] ; }; struct ethtool_flow_ext { __u8 padding[2U] ; unsigned char h_dest[6U] ; __be16 vlan_etype ; __be16 vlan_tci ; __be32 data[2U] ; }; struct ethtool_rx_flow_spec { __u32 flow_type ; union ethtool_flow_union h_u ; struct ethtool_flow_ext h_ext ; union ethtool_flow_union m_u ; struct ethtool_flow_ext m_ext ; __u64 ring_cookie ; __u32 location ; }; struct ethtool_rxnfc { __u32 cmd ; __u32 flow_type ; __u64 data ; struct ethtool_rx_flow_spec fs ; __u32 rule_cnt ; __u32 rule_locs[0U] ; }; struct ethtool_flash { __u32 cmd ; __u32 region ; char data[128U] ; }; struct ethtool_dump { __u32 cmd ; __u32 version ; __u32 flag ; __u32 len ; __u8 data[0U] ; }; struct ethtool_ts_info { __u32 cmd ; __u32 so_timestamping ; __s32 phc_index ; __u32 tx_types ; __u32 tx_reserved[3U] ; __u32 rx_filters ; __u32 rx_reserved[3U] ; }; enum ethtool_phys_id_state { ETHTOOL_ID_INACTIVE = 0, ETHTOOL_ID_ACTIVE = 1, ETHTOOL_ID_ON = 2, ETHTOOL_ID_OFF = 3 } ; struct ethtool_ops { int (*get_settings)(struct net_device * , struct ethtool_cmd * ) ; int (*set_settings)(struct net_device * , struct ethtool_cmd * ) ; void (*get_drvinfo)(struct net_device * , struct ethtool_drvinfo * ) ; int (*get_regs_len)(struct net_device * ) ; void (*get_regs)(struct net_device * , struct ethtool_regs * , void * ) ; void (*get_wol)(struct net_device * , struct ethtool_wolinfo * ) ; int (*set_wol)(struct net_device * , struct ethtool_wolinfo * ) ; u32 (*get_msglevel)(struct net_device * ) ; void (*set_msglevel)(struct net_device * , u32 ) ; int (*nway_reset)(struct net_device * ) ; u32 (*get_link)(struct net_device * ) ; int (*get_eeprom_len)(struct net_device * ) ; int (*get_eeprom)(struct net_device * , struct ethtool_eeprom * , u8 * ) ; int (*set_eeprom)(struct net_device * , struct ethtool_eeprom * , u8 * ) ; int (*get_coalesce)(struct net_device * , struct ethtool_coalesce * ) ; int (*set_coalesce)(struct net_device * , struct ethtool_coalesce * ) ; void (*get_ringparam)(struct net_device * , struct ethtool_ringparam * ) ; int (*set_ringparam)(struct net_device * , struct ethtool_ringparam * ) ; void (*get_pauseparam)(struct net_device * , struct ethtool_pauseparam * ) ; int (*set_pauseparam)(struct net_device * , struct ethtool_pauseparam * ) ; void (*self_test)(struct net_device * , struct ethtool_test * , u64 * ) ; void (*get_strings)(struct net_device * , u32 , u8 * ) ; int (*set_phys_id)(struct net_device * , enum ethtool_phys_id_state ) ; void (*get_ethtool_stats)(struct net_device * , struct ethtool_stats * , u64 * ) ; int (*begin)(struct net_device * ) ; void (*complete)(struct net_device * ) ; u32 (*get_priv_flags)(struct net_device * ) ; int (*set_priv_flags)(struct net_device * , u32 ) ; int (*get_sset_count)(struct net_device * , int ) ; int (*get_rxnfc)(struct net_device * , struct ethtool_rxnfc * , u32 * ) ; int (*set_rxnfc)(struct net_device * , struct ethtool_rxnfc * ) ; int (*flash_device)(struct net_device * , struct ethtool_flash * ) ; int (*reset)(struct net_device * , u32 * ) ; u32 (*get_rxfh_indir_size)(struct net_device * ) ; int (*get_rxfh_indir)(struct net_device * , u32 * ) ; int (*set_rxfh_indir)(struct net_device * , u32 const * ) ; void (*get_channels)(struct net_device * , struct ethtool_channels * ) ; int (*set_channels)(struct net_device * , struct ethtool_channels * ) ; int (*get_dump_flag)(struct net_device * , struct ethtool_dump * ) ; int (*get_dump_data)(struct net_device * , struct ethtool_dump * , void * ) ; int (*set_dump)(struct net_device * , struct ethtool_dump * ) ; int (*get_ts_info)(struct net_device * , struct ethtool_ts_info * ) ; int (*get_module_info)(struct net_device * , struct ethtool_modinfo * ) ; int (*get_module_eeprom)(struct net_device * , struct ethtool_eeprom * , u8 * ) ; int (*get_eee)(struct net_device * , struct ethtool_eee * ) ; int (*set_eee)(struct net_device * , struct ethtool_eee * ) ; }; struct prot_inuse; struct netns_core { struct ctl_table_header *sysctl_hdr ; int sysctl_somaxconn ; struct prot_inuse *inuse ; }; struct u64_stats_sync { }; struct ipstats_mib { u64 mibs[36U] ; struct u64_stats_sync syncp ; }; struct icmp_mib { unsigned long mibs[28U] ; }; struct icmpmsg_mib { atomic_long_t mibs[512U] ; }; struct icmpv6_mib { unsigned long mibs[6U] ; }; struct icmpv6_mib_device { atomic_long_t mibs[6U] ; }; struct icmpv6msg_mib { atomic_long_t mibs[512U] ; }; struct icmpv6msg_mib_device { atomic_long_t mibs[512U] ; }; struct tcp_mib { unsigned long mibs[16U] ; }; struct udp_mib { unsigned long mibs[8U] ; }; struct linux_mib { unsigned long mibs[96U] ; }; struct linux_xfrm_mib { unsigned long mibs[29U] ; }; struct netns_mib { struct tcp_mib *tcp_statistics[1U] ; struct ipstats_mib *ip_statistics[1U] ; struct linux_mib *net_statistics[1U] ; struct udp_mib *udp_statistics[1U] ; struct udp_mib *udplite_statistics[1U] ; struct icmp_mib *icmp_statistics[1U] ; struct icmpmsg_mib *icmpmsg_statistics ; struct proc_dir_entry *proc_net_devsnmp6 ; struct udp_mib *udp_stats_in6[1U] ; struct udp_mib *udplite_stats_in6[1U] ; struct ipstats_mib *ipv6_statistics[1U] ; struct icmpv6_mib *icmpv6_statistics[1U] ; struct icmpv6msg_mib *icmpv6msg_statistics ; struct linux_xfrm_mib *xfrm_statistics[1U] ; }; struct netns_unix { int sysctl_max_dgram_qlen ; struct ctl_table_header *ctl ; }; struct netns_packet { struct mutex sklist_lock ; struct hlist_head sklist ; }; struct netns_frags { int nqueues ; struct list_head lru_list ; spinlock_t lru_lock ; struct percpu_counter mem ; int timeout ; int high_thresh ; int low_thresh ; }; struct tcpm_hash_bucket; struct ipv4_devconf; struct fib_rules_ops; struct fib_table; struct inet_peer_base; struct xt_table; struct netns_ipv4 { struct ctl_table_header *forw_hdr ; struct ctl_table_header *frags_hdr ; struct ctl_table_header *ipv4_hdr ; struct ctl_table_header *route_hdr ; struct ctl_table_header *xfrm4_hdr ; struct ipv4_devconf *devconf_all ; struct ipv4_devconf *devconf_dflt ; struct fib_rules_ops *rules_ops ; bool fib_has_custom_rules ; struct fib_table *fib_local ; struct fib_table *fib_main ; struct fib_table *fib_default ; int fib_num_tclassid_users ; struct hlist_head *fib_table_hash ; struct sock *fibnl ; struct sock **icmp_sk ; struct inet_peer_base *peers ; struct tcpm_hash_bucket *tcp_metrics_hash ; unsigned int tcp_metrics_hash_log ; struct netns_frags frags ; struct xt_table *iptable_filter ; struct xt_table *iptable_mangle ; struct xt_table *iptable_raw ; struct xt_table *arptable_filter ; struct xt_table *iptable_security ; struct xt_table *nat_table ; int sysctl_icmp_echo_ignore_all ; int sysctl_icmp_echo_ignore_broadcasts ; int sysctl_icmp_ignore_bogus_error_responses ; int sysctl_icmp_ratelimit ; int sysctl_icmp_ratemask ; int sysctl_icmp_errors_use_inbound_ifaddr ; int sysctl_tcp_ecn ; kgid_t sysctl_ping_group_range[2U] ; long sysctl_tcp_mem[3U] ; atomic_t dev_addr_genid ; struct list_head mr_tables ; struct fib_rules_ops *mr_rules_ops ; atomic_t rt_genid ; }; struct neighbour; struct dst_ops { unsigned short family ; __be16 protocol ; unsigned int gc_thresh ; int (*gc)(struct dst_ops * ) ; struct dst_entry *(*check)(struct dst_entry * , __u32 ) ; unsigned int (*default_advmss)(struct dst_entry const * ) ; unsigned int (*mtu)(struct dst_entry const * ) ; u32 *(*cow_metrics)(struct dst_entry * , unsigned long ) ; void (*destroy)(struct dst_entry * ) ; void (*ifdown)(struct dst_entry * , struct net_device * , int ) ; struct dst_entry *(*negative_advice)(struct dst_entry * ) ; void (*link_failure)(struct sk_buff * ) ; void (*update_pmtu)(struct dst_entry * , struct sock * , struct sk_buff * , u32 ) ; void (*redirect)(struct dst_entry * , struct sock * , struct sk_buff * ) ; int (*local_out)(struct sk_buff * ) ; struct neighbour *(*neigh_lookup)(struct dst_entry const * , struct sk_buff * , void const * ) ; struct kmem_cache *kmem_cachep ; struct percpu_counter pcpuc_entries ; }; struct netns_sysctl_ipv6 { struct ctl_table_header *hdr ; struct ctl_table_header *route_hdr ; struct ctl_table_header *icmp_hdr ; struct ctl_table_header *frags_hdr ; struct ctl_table_header *xfrm6_hdr ; int bindv6only ; int flush_delay ; int ip6_rt_max_size ; int ip6_rt_gc_min_interval ; int ip6_rt_gc_timeout ; int ip6_rt_gc_interval ; int ip6_rt_gc_elasticity ; int ip6_rt_mtu_expires ; int ip6_rt_min_advmss ; int icmpv6_time ; }; struct rt6_info; struct rt6_statistics; struct fib6_table; struct netns_ipv6 { struct netns_sysctl_ipv6 sysctl ; struct ipv6_devconf *devconf_all ; struct ipv6_devconf *devconf_dflt ; struct inet_peer_base *peers ; struct netns_frags frags ; struct xt_table *ip6table_filter ; struct xt_table *ip6table_mangle ; struct xt_table *ip6table_raw ; struct xt_table *ip6table_security ; struct xt_table *ip6table_nat ; struct rt6_info *ip6_null_entry ; struct rt6_statistics *rt6_stats ; struct timer_list ip6_fib_timer ; struct hlist_head *fib_table_hash ; struct fib6_table *fib6_main_tbl ; struct dst_ops ip6_dst_ops ; unsigned int ip6_rt_gc_expire ; unsigned long ip6_rt_last_gc ; struct rt6_info *ip6_prohibit_entry ; struct rt6_info *ip6_blk_hole_entry ; struct fib6_table *fib6_local_tbl ; struct fib_rules_ops *fib6_rules_ops ; struct sock **icmp_sk ; struct sock *ndisc_sk ; struct sock *tcp_sk ; struct sock *igmp_sk ; struct list_head mr6_tables ; struct fib_rules_ops *mr6_rules_ops ; atomic_t dev_addr_genid ; atomic_t rt_genid ; }; struct netns_nf_frag { struct netns_sysctl_ipv6 sysctl ; struct netns_frags frags ; }; struct sctp_mib; struct netns_sctp { struct sctp_mib *sctp_statistics[1U] ; struct proc_dir_entry *proc_net_sctp ; struct ctl_table_header *sysctl_header ; struct sock *ctl_sock ; struct list_head local_addr_list ; struct list_head addr_waitq ; struct timer_list addr_wq_timer ; struct list_head auto_asconf_splist ; spinlock_t addr_wq_lock ; spinlock_t local_addr_lock ; unsigned int rto_initial ; unsigned int rto_min ; unsigned int rto_max ; int rto_alpha ; int rto_beta ; int max_burst ; int cookie_preserve_enable ; char *sctp_hmac_alg ; unsigned int valid_cookie_life ; unsigned int sack_timeout ; unsigned int hb_interval ; int max_retrans_association ; int max_retrans_path ; int max_retrans_init ; int pf_retrans ; int sndbuf_policy ; int rcvbuf_policy ; int default_auto_asconf ; int addip_enable ; int addip_noauth ; int prsctp_enable ; int auth_enable ; int scope_policy ; int rwnd_upd_shift ; unsigned long max_autoclose ; }; struct netns_dccp { struct sock *v4_ctl_sk ; struct sock *v6_ctl_sk ; }; struct nlattr; struct nf_logger; struct netns_nf { struct proc_dir_entry *proc_netfilter ; struct nf_logger const *nf_loggers[13U] ; struct ctl_table_header *nf_log_dir_header ; }; struct ebt_table; struct netns_xt { struct list_head tables[13U] ; bool notrack_deprecated_warning ; struct ebt_table *broute_table ; struct ebt_table *frame_filter ; struct ebt_table *frame_nat ; bool ulog_warn_deprecated ; bool ebt_ulog_warn_deprecated ; }; struct hlist_nulls_node; struct hlist_nulls_head { struct hlist_nulls_node *first ; }; struct hlist_nulls_node { struct hlist_nulls_node *next ; struct hlist_nulls_node **pprev ; }; struct nf_proto_net { struct ctl_table_header *ctl_table_header ; struct ctl_table *ctl_table ; struct ctl_table_header *ctl_compat_header ; struct ctl_table *ctl_compat_table ; unsigned int users ; }; struct nf_generic_net { struct nf_proto_net pn ; unsigned int timeout ; }; struct nf_tcp_net { struct nf_proto_net pn ; unsigned int timeouts[14U] ; unsigned int tcp_loose ; unsigned int tcp_be_liberal ; unsigned int tcp_max_retrans ; }; struct nf_udp_net { struct nf_proto_net pn ; unsigned int timeouts[2U] ; }; struct nf_icmp_net { struct nf_proto_net pn ; unsigned int timeout ; }; struct nf_ip_net { struct nf_generic_net generic ; struct nf_tcp_net tcp ; struct nf_udp_net udp ; struct nf_icmp_net icmp ; struct nf_icmp_net icmpv6 ; struct ctl_table_header *ctl_table_header ; struct ctl_table *ctl_table ; }; struct ip_conntrack_stat; struct nf_ct_event_notifier; struct nf_exp_event_notifier; struct netns_ct { atomic_t count ; unsigned int expect_count ; unsigned int htable_size ; struct kmem_cache *nf_conntrack_cachep ; struct hlist_nulls_head *hash ; struct hlist_head *expect_hash ; struct hlist_nulls_head unconfirmed ; struct hlist_nulls_head dying ; struct hlist_nulls_head tmpl ; struct ip_conntrack_stat *stat ; struct nf_ct_event_notifier *nf_conntrack_event_cb ; struct nf_exp_event_notifier *nf_expect_event_cb ; int sysctl_events ; unsigned int sysctl_events_retry_timeout ; int sysctl_acct ; int sysctl_tstamp ; int sysctl_checksum ; unsigned int sysctl_log_invalid ; int sysctl_auto_assign_helper ; bool auto_assign_helper_warned ; struct nf_ip_net nf_ct_proto ; unsigned int labels_used ; u8 label_words ; struct hlist_head *nat_bysource ; unsigned int nat_htable_size ; struct ctl_table_header *sysctl_header ; struct ctl_table_header *acct_sysctl_header ; struct ctl_table_header *tstamp_sysctl_header ; struct ctl_table_header *event_sysctl_header ; struct ctl_table_header *helper_sysctl_header ; char *slabname ; }; struct xfrm_policy_hash { struct hlist_head *table ; unsigned int hmask ; }; struct netns_xfrm { struct list_head state_all ; struct hlist_head *state_bydst ; struct hlist_head *state_bysrc ; struct hlist_head *state_byspi ; unsigned int state_hmask ; unsigned int state_num ; struct work_struct state_hash_work ; struct hlist_head state_gc_list ; struct work_struct state_gc_work ; wait_queue_head_t km_waitq ; struct list_head policy_all ; struct hlist_head *policy_byidx ; unsigned int policy_idx_hmask ; struct hlist_head policy_inexact[6U] ; struct xfrm_policy_hash policy_bydst[6U] ; unsigned int policy_count[6U] ; struct work_struct policy_hash_work ; struct sock *nlsk ; struct sock *nlsk_stash ; u32 sysctl_aevent_etime ; u32 sysctl_aevent_rseqth ; int sysctl_larval_drop ; u32 sysctl_acq_expires ; struct ctl_table_header *sysctl_hdr ; struct dst_ops xfrm4_dst_ops ; struct dst_ops xfrm6_dst_ops ; }; struct net_generic; struct netns_ipvs; struct net { atomic_t passive ; atomic_t count ; spinlock_t rules_mod_lock ; struct list_head list ; struct list_head cleanup_list ; struct list_head exit_list ; struct user_namespace *user_ns ; unsigned int proc_inum ; struct proc_dir_entry *proc_net ; struct proc_dir_entry *proc_net_stat ; struct ctl_table_set sysctls ; struct sock *rtnl ; struct sock *genl_sock ; struct list_head dev_base_head ; struct hlist_head *dev_name_head ; struct hlist_head *dev_index_head ; unsigned int dev_base_seq ; int ifindex ; struct list_head rules_ops ; struct net_device *loopback_dev ; struct netns_core core ; struct netns_mib mib ; struct netns_packet packet ; struct netns_unix unx ; struct netns_ipv4 ipv4 ; struct netns_ipv6 ipv6 ; struct netns_sctp sctp ; struct netns_dccp dccp ; struct netns_nf nf ; struct netns_xt xt ; struct netns_ct ct ; struct netns_nf_frag nf_frag ; struct sock *nfnl ; struct sock *nfnl_stash ; struct sk_buff_head wext_nlevents ; struct net_generic *gen ; struct netns_xfrm xfrm ; struct netns_ipvs *ipvs ; struct sock *diag_nlsk ; atomic_t fnhe_genid ; }; struct seq_file { char *buf ; size_t size ; size_t from ; size_t count ; loff_t index ; loff_t read_pos ; u64 version ; struct mutex lock ; struct seq_operations const *op ; int poll_event ; struct user_namespace *user_ns ; void *private ; }; struct seq_operations { void *(*start)(struct seq_file * , loff_t * ) ; void (*stop)(struct seq_file * , void * ) ; void *(*next)(struct seq_file * , void * , loff_t * ) ; int (*show)(struct seq_file * , void * ) ; }; struct dsa_chip_data { struct device *mii_bus ; int sw_addr ; char *port_names[12U] ; s8 *rtable ; }; struct dsa_platform_data { struct device *netdev ; int nr_chips ; struct dsa_chip_data *chip ; }; struct dsa_switch; struct dsa_switch_tree { struct dsa_platform_data *pd ; struct net_device *master_netdev ; __be16 tag_protocol ; s8 cpu_switch ; s8 cpu_port ; int link_poll_needed ; struct work_struct link_poll_work ; struct timer_list link_poll_timer ; struct dsa_switch *ds[4U] ; }; struct dsa_switch_driver; struct mii_bus; struct dsa_switch { struct dsa_switch_tree *dst ; int index ; struct dsa_chip_data *pd ; struct dsa_switch_driver *drv ; struct mii_bus *master_mii_bus ; u32 dsa_port_mask ; u32 phys_port_mask ; struct mii_bus *slave_mii_bus ; struct net_device *ports[12U] ; }; struct dsa_switch_driver { struct list_head list ; __be16 tag_protocol ; int priv_size ; char *(*probe)(struct mii_bus * , int ) ; int (*setup)(struct dsa_switch * ) ; int (*set_addr)(struct dsa_switch * , u8 * ) ; int (*phy_read)(struct dsa_switch * , int , int ) ; int (*phy_write)(struct dsa_switch * , int , int , u16 ) ; void (*poll_link)(struct dsa_switch * ) ; void (*get_strings)(struct dsa_switch * , int , uint8_t * ) ; void (*get_ethtool_stats)(struct dsa_switch * , int , uint64_t * ) ; int (*get_sset_count)(struct dsa_switch * ) ; }; struct ieee_ets { __u8 willing ; __u8 ets_cap ; __u8 cbs ; __u8 tc_tx_bw[8U] ; __u8 tc_rx_bw[8U] ; __u8 tc_tsa[8U] ; __u8 prio_tc[8U] ; __u8 tc_reco_bw[8U] ; __u8 tc_reco_tsa[8U] ; __u8 reco_prio_tc[8U] ; }; struct ieee_maxrate { __u64 tc_maxrate[8U] ; }; struct ieee_pfc { __u8 pfc_cap ; __u8 pfc_en ; __u8 mbc ; __u16 delay ; __u64 requests[8U] ; __u64 indications[8U] ; }; struct cee_pg { __u8 willing ; __u8 error ; __u8 pg_en ; __u8 tcs_supported ; __u8 pg_bw[8U] ; __u8 prio_pg[8U] ; }; struct cee_pfc { __u8 willing ; __u8 error ; __u8 pfc_en ; __u8 tcs_supported ; }; struct dcb_app { __u8 selector ; __u8 priority ; __u16 protocol ; }; struct dcb_peer_app_info { __u8 willing ; __u8 error ; }; struct dcbnl_rtnl_ops { int (*ieee_getets)(struct net_device * , struct ieee_ets * ) ; int (*ieee_setets)(struct net_device * , struct ieee_ets * ) ; int (*ieee_getmaxrate)(struct net_device * , struct ieee_maxrate * ) ; int (*ieee_setmaxrate)(struct net_device * , struct ieee_maxrate * ) ; int (*ieee_getpfc)(struct net_device * , struct ieee_pfc * ) ; int (*ieee_setpfc)(struct net_device * , struct ieee_pfc * ) ; int (*ieee_getapp)(struct net_device * , struct dcb_app * ) ; int (*ieee_setapp)(struct net_device * , struct dcb_app * ) ; int (*ieee_delapp)(struct net_device * , struct dcb_app * ) ; int (*ieee_peer_getets)(struct net_device * , struct ieee_ets * ) ; int (*ieee_peer_getpfc)(struct net_device * , struct ieee_pfc * ) ; u8 (*getstate)(struct net_device * ) ; u8 (*setstate)(struct net_device * , u8 ) ; void (*getpermhwaddr)(struct net_device * , u8 * ) ; void (*setpgtccfgtx)(struct net_device * , int , u8 , u8 , u8 , u8 ) ; void (*setpgbwgcfgtx)(struct net_device * , int , u8 ) ; void (*setpgtccfgrx)(struct net_device * , int , u8 , u8 , u8 , u8 ) ; void (*setpgbwgcfgrx)(struct net_device * , int , u8 ) ; void (*getpgtccfgtx)(struct net_device * , int , u8 * , u8 * , u8 * , u8 * ) ; void (*getpgbwgcfgtx)(struct net_device * , int , u8 * ) ; void (*getpgtccfgrx)(struct net_device * , int , u8 * , u8 * , u8 * , u8 * ) ; void (*getpgbwgcfgrx)(struct net_device * , int , u8 * ) ; void (*setpfccfg)(struct net_device * , int , u8 ) ; void (*getpfccfg)(struct net_device * , int , u8 * ) ; u8 (*setall)(struct net_device * ) ; u8 (*getcap)(struct net_device * , int , u8 * ) ; int (*getnumtcs)(struct net_device * , int , u8 * ) ; int (*setnumtcs)(struct net_device * , int , u8 ) ; u8 (*getpfcstate)(struct net_device * ) ; void (*setpfcstate)(struct net_device * , u8 ) ; void (*getbcncfg)(struct net_device * , int , u32 * ) ; void (*setbcncfg)(struct net_device * , int , u32 ) ; void (*getbcnrp)(struct net_device * , int , u8 * ) ; void (*setbcnrp)(struct net_device * , int , u8 ) ; u8 (*setapp)(struct net_device * , u8 , u16 , u8 ) ; u8 (*getapp)(struct net_device * , u8 , u16 ) ; u8 (*getfeatcfg)(struct net_device * , int , u8 * ) ; u8 (*setfeatcfg)(struct net_device * , int , u8 ) ; u8 (*getdcbx)(struct net_device * ) ; u8 (*setdcbx)(struct net_device * , u8 ) ; int (*peer_getappinfo)(struct net_device * , struct dcb_peer_app_info * , u16 * ) ; int (*peer_getapptable)(struct net_device * , struct dcb_app * ) ; int (*cee_peer_getpg)(struct net_device * , struct cee_pg * ) ; int (*cee_peer_getpfc)(struct net_device * , struct cee_pfc * ) ; }; struct taskstats { __u16 version ; __u32 ac_exitcode ; __u8 ac_flag ; __u8 ac_nice ; __u64 cpu_count ; __u64 cpu_delay_total ; __u64 blkio_count ; __u64 blkio_delay_total ; __u64 swapin_count ; __u64 swapin_delay_total ; __u64 cpu_run_real_total ; __u64 cpu_run_virtual_total ; char ac_comm[32U] ; __u8 ac_sched ; __u8 ac_pad[3U] ; __u32 ac_uid ; __u32 ac_gid ; __u32 ac_pid ; __u32 ac_ppid ; __u32 ac_btime ; __u64 ac_etime ; __u64 ac_utime ; __u64 ac_stime ; __u64 ac_minflt ; __u64 ac_majflt ; __u64 coremem ; __u64 virtmem ; __u64 hiwater_rss ; __u64 hiwater_vm ; __u64 read_char ; __u64 write_char ; __u64 read_syscalls ; __u64 write_syscalls ; __u64 read_bytes ; __u64 write_bytes ; __u64 cancelled_write_bytes ; __u64 nvcsw ; __u64 nivcsw ; __u64 ac_utimescaled ; __u64 ac_stimescaled ; __u64 cpu_scaled_run_real_total ; __u64 freepages_count ; __u64 freepages_delay_total ; }; struct idr_layer { int prefix ; unsigned long bitmap[4U] ; struct idr_layer *ary[256U] ; int count ; int layer ; struct callback_head callback_head ; }; struct idr { struct idr_layer *hint ; struct idr_layer *top ; struct idr_layer *id_free ; int layers ; int id_free_cnt ; int cur ; spinlock_t lock ; }; struct ida_bitmap { long nr_busy ; unsigned long bitmap[15U] ; }; struct ida { struct idr idr ; struct ida_bitmap *free_bitmap ; }; struct xattr_handler { char const *prefix ; int flags ; size_t (*list)(struct dentry * , char * , size_t , char const * , size_t , int ) ; int (*get)(struct dentry * , char const * , void * , size_t , int ) ; int (*set)(struct dentry * , char const * , void const * , size_t , int , int ) ; }; struct simple_xattrs { struct list_head head ; spinlock_t lock ; }; struct percpu_ref; typedef void percpu_ref_func_t(struct percpu_ref * ); struct percpu_ref { atomic_t count ; unsigned int *pcpu_count ; percpu_ref_func_t *release ; percpu_ref_func_t *confirm_kill ; struct callback_head rcu ; }; struct cgroupfs_root; struct cgroup_subsys; struct cgroup; struct css_id; struct eventfd_ctx; struct cgroup_subsys_state { struct cgroup *cgroup ; struct cgroup_subsys *ss ; struct percpu_ref refcnt ; struct cgroup_subsys_state *parent ; unsigned long flags ; struct css_id *id ; struct callback_head callback_head ; struct work_struct destroy_work ; }; struct cgroup_name { struct callback_head callback_head ; char name[] ; }; struct cgroup { unsigned long flags ; int id ; int nr_css ; struct list_head sibling ; struct list_head children ; struct list_head files ; struct cgroup *parent ; struct dentry *dentry ; u64 serial_nr ; struct cgroup_name *name ; struct cgroup_subsys_state *subsys[12U] ; struct cgroupfs_root *root ; struct list_head cset_links ; struct list_head release_list ; struct list_head pidlists ; struct mutex pidlist_mutex ; struct cgroup_subsys_state dummy_css ; struct callback_head callback_head ; struct work_struct destroy_work ; struct list_head event_list ; spinlock_t event_list_lock ; struct simple_xattrs xattrs ; }; struct cgroupfs_root { struct super_block *sb ; unsigned long subsys_mask ; int hierarchy_id ; struct list_head subsys_list ; struct cgroup top_cgroup ; int number_of_cgroups ; struct list_head root_list ; unsigned long flags ; struct idr cgroup_idr ; char release_agent_path[4096U] ; char name[64U] ; }; struct css_set { atomic_t refcount ; struct hlist_node hlist ; struct list_head tasks ; struct list_head cgrp_links ; struct cgroup_subsys_state *subsys[12U] ; struct callback_head callback_head ; }; struct cgroup_map_cb { int (*fill)(struct cgroup_map_cb * , char const * , u64 ) ; void *state ; }; struct cftype { char name[64U] ; int private ; umode_t mode ; size_t max_write_len ; unsigned int flags ; struct cgroup_subsys *ss ; int (*open)(struct inode * , struct file * ) ; ssize_t (*read)(struct cgroup_subsys_state * , struct cftype * , struct file * , char * , size_t , loff_t * ) ; u64 (*read_u64)(struct cgroup_subsys_state * , struct cftype * ) ; s64 (*read_s64)(struct cgroup_subsys_state * , struct cftype * ) ; int (*read_map)(struct cgroup_subsys_state * , struct cftype * , struct cgroup_map_cb * ) ; int (*read_seq_string)(struct cgroup_subsys_state * , struct cftype * , struct seq_file * ) ; ssize_t (*write)(struct cgroup_subsys_state * , struct cftype * , struct file * , char const * , size_t , loff_t * ) ; int (*write_u64)(struct cgroup_subsys_state * , struct cftype * , u64 ) ; int (*write_s64)(struct cgroup_subsys_state * , struct cftype * , s64 ) ; int (*write_string)(struct cgroup_subsys_state * , struct cftype * , char const * ) ; int (*trigger)(struct cgroup_subsys_state * , unsigned int ) ; int (*release)(struct inode * , struct file * ) ; int (*register_event)(struct cgroup_subsys_state * , struct cftype * , struct eventfd_ctx * , char const * ) ; void (*unregister_event)(struct cgroup_subsys_state * , struct cftype * , struct eventfd_ctx * ) ; }; struct cftype_set { struct list_head node ; struct cftype *cfts ; }; struct cgroup_taskset; struct cgroup_subsys { struct cgroup_subsys_state *(*css_alloc)(struct cgroup_subsys_state * ) ; int (*css_online)(struct cgroup_subsys_state * ) ; void (*css_offline)(struct cgroup_subsys_state * ) ; void (*css_free)(struct cgroup_subsys_state * ) ; int (*can_attach)(struct cgroup_subsys_state * , struct cgroup_taskset * ) ; void (*cancel_attach)(struct cgroup_subsys_state * , struct cgroup_taskset * ) ; void (*attach)(struct cgroup_subsys_state * , struct cgroup_taskset * ) ; void (*fork)(struct task_struct * ) ; void (*exit)(struct cgroup_subsys_state * , struct cgroup_subsys_state * , struct task_struct * ) ; void (*bind)(struct cgroup_subsys_state * ) ; int subsys_id ; int disabled ; int early_init ; bool use_id ; bool broken_hierarchy ; bool warned_broken_hierarchy ; char const *name ; struct cgroupfs_root *root ; struct list_head sibling ; struct idr idr ; spinlock_t id_lock ; struct list_head cftsets ; struct cftype *base_cftypes ; struct cftype_set base_cftset ; struct module *module ; }; struct netprio_map { struct callback_head rcu ; u32 priomap_len ; u32 priomap[] ; }; struct xfrm_policy; struct xfrm_state; struct request_sock; struct security_mnt_opts { char **mnt_opts ; int *mnt_opts_flags ; int num_mnt_opts ; }; struct mnt_namespace; struct ipc_namespace; struct nsproxy { atomic_t count ; struct uts_namespace *uts_ns ; struct ipc_namespace *ipc_ns ; struct mnt_namespace *mnt_ns ; struct pid_namespace *pid_ns_for_children ; struct net *net_ns ; }; struct nlmsghdr { __u32 nlmsg_len ; __u16 nlmsg_type ; __u16 nlmsg_flags ; __u32 nlmsg_seq ; __u32 nlmsg_pid ; }; struct nlattr { __u16 nla_len ; __u16 nla_type ; }; struct netlink_callback { struct sk_buff *skb ; struct nlmsghdr const *nlh ; int (*dump)(struct sk_buff * , struct netlink_callback * ) ; int (*done)(struct netlink_callback * ) ; void *data ; struct module *module ; u16 family ; u16 min_dump_alloc ; unsigned int prev_seq ; unsigned int seq ; long args[6U] ; }; struct ndmsg { __u8 ndm_family ; __u8 ndm_pad1 ; __u16 ndm_pad2 ; __s32 ndm_ifindex ; __u16 ndm_state ; __u8 ndm_flags ; __u8 ndm_type ; }; struct rtnl_link_stats64 { __u64 rx_packets ; __u64 tx_packets ; __u64 rx_bytes ; __u64 tx_bytes ; __u64 rx_errors ; __u64 tx_errors ; __u64 rx_dropped ; __u64 tx_dropped ; __u64 multicast ; __u64 collisions ; __u64 rx_length_errors ; __u64 rx_over_errors ; __u64 rx_crc_errors ; __u64 rx_frame_errors ; __u64 rx_fifo_errors ; __u64 rx_missed_errors ; __u64 tx_aborted_errors ; __u64 tx_carrier_errors ; __u64 tx_fifo_errors ; __u64 tx_heartbeat_errors ; __u64 tx_window_errors ; __u64 rx_compressed ; __u64 tx_compressed ; }; struct ifla_vf_info { __u32 vf ; __u8 mac[32U] ; __u32 vlan ; __u32 qos ; __u32 tx_rate ; __u32 spoofchk ; __u32 linkstate ; }; struct netpoll_info; struct phy_device; struct wireless_dev; enum netdev_tx { __NETDEV_TX_MIN = (-0x7FFFFFFF-1), NETDEV_TX_OK = 0, NETDEV_TX_BUSY = 16, NETDEV_TX_LOCKED = 32 } ; typedef enum netdev_tx netdev_tx_t; struct net_device_stats { unsigned long rx_packets ; unsigned long tx_packets ; unsigned long rx_bytes ; unsigned long tx_bytes ; unsigned long rx_errors ; unsigned long tx_errors ; unsigned long rx_dropped ; unsigned long tx_dropped ; unsigned long multicast ; unsigned long collisions ; unsigned long rx_length_errors ; unsigned long rx_over_errors ; unsigned long rx_crc_errors ; unsigned long rx_frame_errors ; unsigned long rx_fifo_errors ; unsigned long rx_missed_errors ; unsigned long tx_aborted_errors ; unsigned long tx_carrier_errors ; unsigned long tx_fifo_errors ; unsigned long tx_heartbeat_errors ; unsigned long tx_window_errors ; unsigned long rx_compressed ; unsigned long tx_compressed ; }; struct neigh_parms; struct netdev_hw_addr_list { struct list_head list ; int count ; }; struct hh_cache { u16 hh_len ; u16 __pad ; seqlock_t hh_lock ; unsigned long hh_data[16U] ; }; struct header_ops { int (*create)(struct sk_buff * , struct net_device * , unsigned short , void const * , void const * , unsigned int ) ; int (*parse)(struct sk_buff const * , unsigned char * ) ; int (*rebuild)(struct sk_buff * ) ; int (*cache)(struct neighbour const * , struct hh_cache * , __be16 ) ; void (*cache_update)(struct hh_cache * , struct net_device const * , unsigned char const * ) ; }; struct napi_struct { struct list_head poll_list ; unsigned long state ; int weight ; unsigned int gro_count ; int (*poll)(struct napi_struct * , int ) ; spinlock_t poll_lock ; int poll_owner ; struct net_device *dev ; struct sk_buff *gro_list ; struct sk_buff *skb ; struct list_head dev_list ; struct hlist_node napi_hash_node ; unsigned int napi_id ; }; enum rx_handler_result { RX_HANDLER_CONSUMED = 0, RX_HANDLER_ANOTHER = 1, RX_HANDLER_EXACT = 2, RX_HANDLER_PASS = 3 } ; typedef enum rx_handler_result rx_handler_result_t; typedef rx_handler_result_t rx_handler_func_t(struct sk_buff ** ); struct Qdisc; struct netdev_queue { struct net_device *dev ; struct Qdisc *qdisc ; struct Qdisc *qdisc_sleeping ; struct kobject kobj ; int numa_node ; spinlock_t _xmit_lock ; int xmit_lock_owner ; unsigned long trans_start ; unsigned long trans_timeout ; unsigned long state ; struct dql dql ; }; struct rps_map { unsigned int len ; struct callback_head rcu ; u16 cpus[0U] ; }; struct rps_dev_flow { u16 cpu ; u16 filter ; unsigned int last_qtail ; }; struct rps_dev_flow_table { unsigned int mask ; struct callback_head rcu ; struct rps_dev_flow flows[0U] ; }; struct netdev_rx_queue { struct rps_map *rps_map ; struct rps_dev_flow_table *rps_flow_table ; struct kobject kobj ; struct net_device *dev ; }; struct xps_map { unsigned int len ; unsigned int alloc_len ; struct callback_head rcu ; u16 queues[0U] ; }; struct xps_dev_maps { struct callback_head rcu ; struct xps_map *cpu_map[0U] ; }; struct netdev_tc_txq { u16 count ; u16 offset ; }; struct netdev_fcoe_hbainfo { char manufacturer[64U] ; char serial_number[64U] ; char hardware_version[64U] ; char driver_version[64U] ; char optionrom_version[64U] ; char firmware_version[64U] ; char model[256U] ; char model_description[256U] ; }; struct netdev_phys_port_id { unsigned char id[32U] ; unsigned char id_len ; }; struct net_device_ops { int (*ndo_init)(struct net_device * ) ; void (*ndo_uninit)(struct net_device * ) ; int (*ndo_open)(struct net_device * ) ; int (*ndo_stop)(struct net_device * ) ; netdev_tx_t (*ndo_start_xmit)(struct sk_buff * , struct net_device * ) ; u16 (*ndo_select_queue)(struct net_device * , struct sk_buff * ) ; void (*ndo_change_rx_flags)(struct net_device * , int ) ; void (*ndo_set_rx_mode)(struct net_device * ) ; int (*ndo_set_mac_address)(struct net_device * , void * ) ; int (*ndo_validate_addr)(struct net_device * ) ; int (*ndo_do_ioctl)(struct net_device * , struct ifreq * , int ) ; int (*ndo_set_config)(struct net_device * , struct ifmap * ) ; int (*ndo_change_mtu)(struct net_device * , int ) ; int (*ndo_neigh_setup)(struct net_device * , struct neigh_parms * ) ; void (*ndo_tx_timeout)(struct net_device * ) ; struct rtnl_link_stats64 *(*ndo_get_stats64)(struct net_device * , struct rtnl_link_stats64 * ) ; struct net_device_stats *(*ndo_get_stats)(struct net_device * ) ; int (*ndo_vlan_rx_add_vid)(struct net_device * , __be16 , u16 ) ; int (*ndo_vlan_rx_kill_vid)(struct net_device * , __be16 , u16 ) ; void (*ndo_poll_controller)(struct net_device * ) ; int (*ndo_netpoll_setup)(struct net_device * , struct netpoll_info * , gfp_t ) ; void (*ndo_netpoll_cleanup)(struct net_device * ) ; int (*ndo_busy_poll)(struct napi_struct * ) ; int (*ndo_set_vf_mac)(struct net_device * , int , u8 * ) ; int (*ndo_set_vf_vlan)(struct net_device * , int , u16 , u8 ) ; int (*ndo_set_vf_tx_rate)(struct net_device * , int , int ) ; int (*ndo_set_vf_spoofchk)(struct net_device * , int , bool ) ; int (*ndo_get_vf_config)(struct net_device * , int , struct ifla_vf_info * ) ; int (*ndo_set_vf_link_state)(struct net_device * , int , int ) ; int (*ndo_set_vf_port)(struct net_device * , int , struct nlattr ** ) ; int (*ndo_get_vf_port)(struct net_device * , int , struct sk_buff * ) ; int (*ndo_setup_tc)(struct net_device * , u8 ) ; int (*ndo_fcoe_enable)(struct net_device * ) ; int (*ndo_fcoe_disable)(struct net_device * ) ; int (*ndo_fcoe_ddp_setup)(struct net_device * , u16 , struct scatterlist * , unsigned int ) ; int (*ndo_fcoe_ddp_done)(struct net_device * , u16 ) ; int (*ndo_fcoe_ddp_target)(struct net_device * , u16 , struct scatterlist * , unsigned int ) ; int (*ndo_fcoe_get_hbainfo)(struct net_device * , struct netdev_fcoe_hbainfo * ) ; int (*ndo_fcoe_get_wwn)(struct net_device * , u64 * , int ) ; int (*ndo_rx_flow_steer)(struct net_device * , struct sk_buff const * , u16 , u32 ) ; int (*ndo_add_slave)(struct net_device * , struct net_device * ) ; int (*ndo_del_slave)(struct net_device * , struct net_device * ) ; netdev_features_t (*ndo_fix_features)(struct net_device * , netdev_features_t ) ; int (*ndo_set_features)(struct net_device * , netdev_features_t ) ; int (*ndo_neigh_construct)(struct neighbour * ) ; void (*ndo_neigh_destroy)(struct neighbour * ) ; int (*ndo_fdb_add)(struct ndmsg * , struct nlattr ** , struct net_device * , unsigned char const * , u16 ) ; int (*ndo_fdb_del)(struct ndmsg * , struct nlattr ** , struct net_device * , unsigned char const * ) ; int (*ndo_fdb_dump)(struct sk_buff * , struct netlink_callback * , struct net_device * , int ) ; int (*ndo_bridge_setlink)(struct net_device * , struct nlmsghdr * ) ; int (*ndo_bridge_getlink)(struct sk_buff * , u32 , u32 , struct net_device * , u32 ) ; int (*ndo_bridge_dellink)(struct net_device * , struct nlmsghdr * ) ; int (*ndo_change_carrier)(struct net_device * , bool ) ; int (*ndo_get_phys_port_id)(struct net_device * , struct netdev_phys_port_id * ) ; void (*ndo_add_vxlan_port)(struct net_device * , sa_family_t , __u16 ) ; void (*ndo_del_vxlan_port)(struct net_device * , sa_family_t , __u16 ) ; }; struct iw_handler_def; struct iw_public_data; struct vlan_info; struct in_device; struct dn_dev; struct inet6_dev; struct cpu_rmap; struct pcpu_lstats; struct pcpu_tstats; struct pcpu_dstats; struct pcpu_vstats; union __anonunion_ldv_39381_231 { void *ml_priv ; struct pcpu_lstats *lstats ; struct pcpu_tstats *tstats ; struct pcpu_dstats *dstats ; struct pcpu_vstats *vstats ; }; struct garp_port; struct mrp_port; struct rtnl_link_ops; struct net_device { char name[16U] ; struct hlist_node name_hlist ; char *ifalias ; unsigned long mem_end ; unsigned long mem_start ; unsigned long base_addr ; unsigned int irq ; unsigned long state ; struct list_head dev_list ; struct list_head napi_list ; struct list_head unreg_list ; struct list_head upper_dev_list ; struct list_head lower_dev_list ; netdev_features_t features ; netdev_features_t hw_features ; netdev_features_t wanted_features ; netdev_features_t vlan_features ; netdev_features_t hw_enc_features ; netdev_features_t mpls_features ; int ifindex ; int iflink ; struct net_device_stats stats ; atomic_long_t rx_dropped ; struct iw_handler_def const *wireless_handlers ; struct iw_public_data *wireless_data ; struct net_device_ops const *netdev_ops ; struct ethtool_ops const *ethtool_ops ; struct header_ops const *header_ops ; unsigned int flags ; unsigned int priv_flags ; unsigned short gflags ; unsigned short padded ; unsigned char operstate ; unsigned char link_mode ; unsigned char if_port ; unsigned char dma ; unsigned int mtu ; unsigned short type ; unsigned short hard_header_len ; unsigned short needed_headroom ; unsigned short needed_tailroom ; unsigned char perm_addr[32U] ; unsigned char addr_assign_type ; unsigned char addr_len ; unsigned char neigh_priv_len ; unsigned short dev_id ; spinlock_t addr_list_lock ; struct netdev_hw_addr_list uc ; struct netdev_hw_addr_list mc ; struct netdev_hw_addr_list dev_addrs ; struct kset *queues_kset ; bool uc_promisc ; unsigned int promiscuity ; unsigned int allmulti ; struct vlan_info *vlan_info ; struct dsa_switch_tree *dsa_ptr ; void *atalk_ptr ; struct in_device *ip_ptr ; struct dn_dev *dn_ptr ; struct inet6_dev *ip6_ptr ; void *ax25_ptr ; struct wireless_dev *ieee80211_ptr ; unsigned long last_rx ; unsigned char *dev_addr ; struct netdev_rx_queue *_rx ; unsigned int num_rx_queues ; unsigned int real_num_rx_queues ; rx_handler_func_t *rx_handler ; void *rx_handler_data ; struct netdev_queue *ingress_queue ; unsigned char broadcast[32U] ; struct netdev_queue *_tx ; unsigned int num_tx_queues ; unsigned int real_num_tx_queues ; struct Qdisc *qdisc ; unsigned long tx_queue_len ; spinlock_t tx_global_lock ; struct xps_dev_maps *xps_maps ; struct cpu_rmap *rx_cpu_rmap ; unsigned long trans_start ; int watchdog_timeo ; struct timer_list watchdog_timer ; int *pcpu_refcnt ; struct list_head todo_list ; struct hlist_node index_hlist ; struct list_head link_watch_list ; unsigned char reg_state ; bool dismantle ; unsigned short rtnl_link_state ; void (*destructor)(struct net_device * ) ; struct netpoll_info *npinfo ; struct net *nd_net ; union __anonunion_ldv_39381_231 ldv_39381 ; struct garp_port *garp_port ; struct mrp_port *mrp_port ; struct device dev ; struct attribute_group const *sysfs_groups[4U] ; struct rtnl_link_ops const *rtnl_link_ops ; unsigned int gso_max_size ; u16 gso_max_segs ; struct dcbnl_rtnl_ops const *dcbnl_ops ; u8 num_tc ; struct netdev_tc_txq tc_to_txq[16U] ; u8 prio_tc_map[16U] ; unsigned int fcoe_ddp_xid ; struct netprio_map *priomap ; struct phy_device *phydev ; struct lock_class_key *qdisc_tx_busylock ; int group ; struct pm_qos_request pm_qos_req ; }; struct res_counter { unsigned long long usage ; unsigned long long max_usage ; unsigned long long limit ; unsigned long long soft_limit ; unsigned long long failcnt ; spinlock_t lock ; struct res_counter *parent ; }; struct kioctx; typedef int kiocb_cancel_fn(struct kiocb * ); union __anonunion_ki_obj_232 { void *user ; struct task_struct *tsk ; }; struct kiocb { struct file *ki_filp ; struct kioctx *ki_ctx ; kiocb_cancel_fn *ki_cancel ; void *private ; union __anonunion_ki_obj_232 ki_obj ; __u64 ki_user_data ; loff_t ki_pos ; size_t ki_nbytes ; struct list_head ki_list ; struct eventfd_ctx *ki_eventfd ; }; struct sock_filter { __u16 code ; __u8 jt ; __u8 jf ; __u32 k ; }; struct sk_filter { atomic_t refcnt ; unsigned int len ; unsigned int (*bpf_func)(struct sk_buff const * , struct sock_filter const * ) ; struct callback_head rcu ; struct sock_filter insns[0U] ; }; struct pollfd { int fd ; short events ; short revents ; }; struct poll_table_struct { void (*_qproc)(struct file * , wait_queue_head_t * , struct poll_table_struct * ) ; unsigned long _key ; }; struct nla_policy { u16 type ; u16 len ; }; struct rtnl_link_ops { struct list_head list ; char const *kind ; size_t priv_size ; void (*setup)(struct net_device * ) ; int maxtype ; struct nla_policy const *policy ; int (*validate)(struct nlattr ** , struct nlattr ** ) ; int (*newlink)(struct net * , struct net_device * , struct nlattr ** , struct nlattr ** ) ; int (*changelink)(struct net_device * , struct nlattr ** , struct nlattr ** ) ; void (*dellink)(struct net_device * , struct list_head * ) ; size_t (*get_size)(struct net_device const * ) ; int (*fill_info)(struct sk_buff * , struct net_device const * ) ; size_t (*get_xstats_size)(struct net_device const * ) ; int (*fill_xstats)(struct sk_buff * , struct net_device const * ) ; unsigned int (*get_num_tx_queues)(void) ; unsigned int (*get_num_rx_queues)(void) ; }; struct neigh_table; struct neigh_parms { struct net *net ; struct net_device *dev ; struct neigh_parms *next ; int (*neigh_setup)(struct neighbour * ) ; void (*neigh_cleanup)(struct neighbour * ) ; struct neigh_table *tbl ; void *sysctl_table ; int dead ; atomic_t refcnt ; struct callback_head callback_head ; int base_reachable_time ; int retrans_time ; int gc_staletime ; int reachable_time ; int delay_probe_time ; int queue_len_bytes ; int ucast_probes ; int app_probes ; int mcast_probes ; int anycast_delay ; int proxy_delay ; int proxy_qlen ; int locktime ; }; struct neigh_statistics { unsigned long allocs ; unsigned long destroys ; unsigned long hash_grows ; unsigned long res_failed ; unsigned long lookups ; unsigned long hits ; unsigned long rcv_probes_mcast ; unsigned long rcv_probes_ucast ; unsigned long periodic_gc_runs ; unsigned long forced_gc_runs ; unsigned long unres_discards ; }; struct neigh_ops; struct neighbour { struct neighbour *next ; struct neigh_table *tbl ; struct neigh_parms *parms ; unsigned long confirmed ; unsigned long updated ; rwlock_t lock ; atomic_t refcnt ; struct sk_buff_head arp_queue ; unsigned int arp_queue_len_bytes ; struct timer_list timer ; unsigned long used ; atomic_t probes ; __u8 flags ; __u8 nud_state ; __u8 type ; __u8 dead ; seqlock_t ha_lock ; unsigned char ha[32U] ; struct hh_cache hh ; int (*output)(struct neighbour * , struct sk_buff * ) ; struct neigh_ops const *ops ; struct callback_head rcu ; struct net_device *dev ; u8 primary_key[0U] ; }; struct neigh_ops { int family ; void (*solicit)(struct neighbour * , struct sk_buff * ) ; void (*error_report)(struct neighbour * , struct sk_buff * ) ; int (*output)(struct neighbour * , struct sk_buff * ) ; int (*connected_output)(struct neighbour * , struct sk_buff * ) ; }; struct pneigh_entry { struct pneigh_entry *next ; struct net *net ; struct net_device *dev ; u8 flags ; u8 key[0U] ; }; struct neigh_hash_table { struct neighbour **hash_buckets ; unsigned int hash_shift ; __u32 hash_rnd[4U] ; struct callback_head rcu ; }; struct neigh_table { struct neigh_table *next ; int family ; int entry_size ; int key_len ; __u32 (*hash)(void const * , struct net_device const * , __u32 * ) ; int (*constructor)(struct neighbour * ) ; int (*pconstructor)(struct pneigh_entry * ) ; void (*pdestructor)(struct pneigh_entry * ) ; void (*proxy_redo)(struct sk_buff * ) ; char *id ; struct neigh_parms parms ; int gc_interval ; int gc_thresh1 ; int gc_thresh2 ; int gc_thresh3 ; unsigned long last_flush ; struct delayed_work gc_work ; struct timer_list proxy_timer ; struct sk_buff_head proxy_queue ; atomic_t entries ; rwlock_t lock ; unsigned long last_rand ; struct neigh_statistics *stats ; struct neigh_hash_table *nht ; struct pneigh_entry **phash_buckets ; }; struct dn_route; union __anonunion_ldv_42537_237 { struct dst_entry *next ; struct rtable *rt_next ; struct rt6_info *rt6_next ; struct dn_route *dn_next ; }; struct dst_entry { struct callback_head callback_head ; struct dst_entry *child ; struct net_device *dev ; struct dst_ops *ops ; unsigned long _metrics ; unsigned long expires ; struct dst_entry *path ; struct dst_entry *from ; struct xfrm_state *xfrm ; int (*input)(struct sk_buff * ) ; int (*output)(struct sk_buff * ) ; unsigned short flags ; unsigned short pending_confirm ; short error ; short obsolete ; unsigned short header_len ; unsigned short trailer_len ; __u32 tclassid ; long __pad_to_align_refcnt[2U] ; atomic_t __refcnt ; int __use ; unsigned long lastuse ; union __anonunion_ldv_42537_237 ldv_42537 ; }; struct __anonstruct_socket_lock_t_238 { spinlock_t slock ; int owned ; wait_queue_head_t wq ; struct lockdep_map dep_map ; }; typedef struct __anonstruct_socket_lock_t_238 socket_lock_t; struct proto; typedef __u32 __portpair; typedef __u64 __addrpair; struct __anonstruct_ldv_42758_240 { __be32 skc_daddr ; __be32 skc_rcv_saddr ; }; union __anonunion_ldv_42759_239 { __addrpair skc_addrpair ; struct __anonstruct_ldv_42758_240 ldv_42758 ; }; union __anonunion_ldv_42763_241 { unsigned int skc_hash ; __u16 skc_u16hashes[2U] ; }; struct __anonstruct_ldv_42769_243 { __be16 skc_dport ; __u16 skc_num ; }; union __anonunion_ldv_42770_242 { __portpair skc_portpair ; struct __anonstruct_ldv_42769_243 ldv_42769 ; }; union __anonunion_ldv_42779_244 { struct hlist_node skc_bind_node ; struct hlist_nulls_node skc_portaddr_node ; }; union __anonunion_ldv_42786_245 { struct hlist_node skc_node ; struct hlist_nulls_node skc_nulls_node ; }; struct sock_common { union __anonunion_ldv_42759_239 ldv_42759 ; union __anonunion_ldv_42763_241 ldv_42763 ; union __anonunion_ldv_42770_242 ldv_42770 ; unsigned short skc_family ; unsigned char volatile skc_state ; unsigned char skc_reuse : 4 ; unsigned char skc_reuseport : 4 ; int skc_bound_dev_if ; union __anonunion_ldv_42779_244 ldv_42779 ; struct proto *skc_prot ; struct net *skc_net ; int skc_dontcopy_begin[0U] ; union __anonunion_ldv_42786_245 ldv_42786 ; int skc_tx_queue_mapping ; atomic_t skc_refcnt ; int skc_dontcopy_end[0U] ; }; struct cg_proto; struct __anonstruct_sk_backlog_246 { atomic_t rmem_alloc ; int len ; struct sk_buff *head ; struct sk_buff *tail ; }; struct sock { struct sock_common __sk_common ; socket_lock_t sk_lock ; struct sk_buff_head sk_receive_queue ; struct __anonstruct_sk_backlog_246 sk_backlog ; int sk_forward_alloc ; __u32 sk_rxhash ; unsigned int sk_napi_id ; unsigned int sk_ll_usec ; atomic_t sk_drops ; int sk_rcvbuf ; struct sk_filter *sk_filter ; struct socket_wq *sk_wq ; struct sk_buff_head sk_async_wait_queue ; struct xfrm_policy *sk_policy[2U] ; unsigned long sk_flags ; struct dst_entry *sk_rx_dst ; struct dst_entry *sk_dst_cache ; spinlock_t sk_dst_lock ; atomic_t sk_wmem_alloc ; atomic_t sk_omem_alloc ; int sk_sndbuf ; struct sk_buff_head sk_write_queue ; unsigned char sk_shutdown : 2 ; unsigned char sk_no_check : 2 ; unsigned char sk_userlocks : 4 ; unsigned char sk_protocol ; unsigned short sk_type ; int sk_wmem_queued ; gfp_t sk_allocation ; u32 sk_pacing_rate ; netdev_features_t sk_route_caps ; netdev_features_t sk_route_nocaps ; int sk_gso_type ; unsigned int sk_gso_max_size ; u16 sk_gso_max_segs ; int sk_rcvlowat ; unsigned long sk_lingertime ; struct sk_buff_head sk_error_queue ; struct proto *sk_prot_creator ; rwlock_t sk_callback_lock ; int sk_err ; int sk_err_soft ; unsigned short sk_ack_backlog ; unsigned short sk_max_ack_backlog ; __u32 sk_priority ; __u32 sk_cgrp_prioidx ; struct pid *sk_peer_pid ; struct cred const *sk_peer_cred ; long sk_rcvtimeo ; long sk_sndtimeo ; void *sk_protinfo ; struct timer_list sk_timer ; ktime_t sk_stamp ; struct socket *sk_socket ; void *sk_user_data ; struct page_frag sk_frag ; struct sk_buff *sk_send_head ; __s32 sk_peek_off ; int sk_write_pending ; void *sk_security ; __u32 sk_mark ; u32 sk_classid ; struct cg_proto *sk_cgrp ; void (*sk_state_change)(struct sock * ) ; void (*sk_data_ready)(struct sock * , int ) ; void (*sk_write_space)(struct sock * ) ; void (*sk_error_report)(struct sock * ) ; int (*sk_backlog_rcv)(struct sock * , struct sk_buff * ) ; void (*sk_destruct)(struct sock * ) ; }; struct request_sock_ops; struct timewait_sock_ops; struct inet_hashinfo; struct raw_hashinfo; struct udp_table; union __anonunion_h_247 { struct inet_hashinfo *hashinfo ; struct udp_table *udp_table ; struct raw_hashinfo *raw_hash ; }; struct proto { void (*close)(struct sock * , long ) ; int (*connect)(struct sock * , struct sockaddr * , int ) ; int (*disconnect)(struct sock * , int ) ; struct sock *(*accept)(struct sock * , int , int * ) ; int (*ioctl)(struct sock * , int , unsigned long ) ; int (*init)(struct sock * ) ; void (*destroy)(struct sock * ) ; void (*shutdown)(struct sock * , int ) ; int (*setsockopt)(struct sock * , int , int , char * , unsigned int ) ; int (*getsockopt)(struct sock * , int , int , char * , int * ) ; int (*compat_setsockopt)(struct sock * , int , int , char * , unsigned int ) ; int (*compat_getsockopt)(struct sock * , int , int , char * , int * ) ; int (*compat_ioctl)(struct sock * , unsigned int , unsigned long ) ; int (*sendmsg)(struct kiocb * , struct sock * , struct msghdr * , size_t ) ; int (*recvmsg)(struct kiocb * , struct sock * , struct msghdr * , size_t , int , int , int * ) ; int (*sendpage)(struct sock * , struct page * , int , size_t , int ) ; int (*bind)(struct sock * , struct sockaddr * , int ) ; int (*backlog_rcv)(struct sock * , struct sk_buff * ) ; void (*release_cb)(struct sock * ) ; void (*mtu_reduced)(struct sock * ) ; void (*hash)(struct sock * ) ; void (*unhash)(struct sock * ) ; void (*rehash)(struct sock * ) ; int (*get_port)(struct sock * , unsigned short ) ; void (*clear_sk)(struct sock * , int ) ; unsigned int inuse_idx ; bool (*stream_memory_free)(struct sock const * ) ; void (*enter_memory_pressure)(struct sock * ) ; atomic_long_t *memory_allocated ; struct percpu_counter *sockets_allocated ; int *memory_pressure ; long *sysctl_mem ; int *sysctl_wmem ; int *sysctl_rmem ; int max_header ; bool no_autobind ; struct kmem_cache *slab ; unsigned int obj_size ; int slab_flags ; struct percpu_counter *orphan_count ; struct request_sock_ops *rsk_prot ; struct timewait_sock_ops *twsk_prot ; union __anonunion_h_247 h ; struct module *owner ; char name[32U] ; struct list_head node ; int (*init_cgroup)(struct mem_cgroup * , struct cgroup_subsys * ) ; void (*destroy_cgroup)(struct mem_cgroup * ) ; struct cg_proto *(*proto_cgroup)(struct mem_cgroup * ) ; }; struct cg_proto { void (*enter_memory_pressure)(struct sock * ) ; struct res_counter *memory_allocated ; struct percpu_counter *sockets_allocated ; int *memory_pressure ; long *sysctl_mem ; unsigned long flags ; struct mem_cgroup *memcg ; }; struct request_sock_ops { int family ; int obj_size ; struct kmem_cache *slab ; char *slab_name ; int (*rtx_syn_ack)(struct sock * , struct request_sock * ) ; void (*send_ack)(struct sock * , struct sk_buff * , struct request_sock * ) ; void (*send_reset)(struct sock * , struct sk_buff * ) ; void (*destructor)(struct request_sock * ) ; void (*syn_ack_timeout)(struct sock * , struct request_sock * ) ; }; struct request_sock { struct request_sock *dl_next ; u16 mss ; u8 num_retrans ; unsigned char cookie_ts : 1 ; unsigned char num_timeout : 7 ; u32 window_clamp ; u32 rcv_wnd ; u32 ts_recent ; unsigned long expires ; struct request_sock_ops const *rsk_ops ; struct sock *sk ; u32 secid ; u32 peer_secid ; }; struct timewait_sock_ops { struct kmem_cache *twsk_slab ; char *twsk_slab_name ; unsigned int twsk_obj_size ; int (*twsk_unique)(struct sock * , struct sock * , void * ) ; void (*twsk_destructor)(struct sock * ) ; }; struct ip6_sf_list { struct ip6_sf_list *sf_next ; struct in6_addr sf_addr ; unsigned long sf_count[2U] ; unsigned char sf_gsresp ; unsigned char sf_oldin ; unsigned char sf_crcount ; }; struct ifmcaddr6 { struct in6_addr mca_addr ; struct inet6_dev *idev ; struct ifmcaddr6 *next ; struct ip6_sf_list *mca_sources ; struct ip6_sf_list *mca_tomb ; unsigned int mca_sfmode ; unsigned char mca_crcount ; unsigned long mca_sfcount[2U] ; struct timer_list mca_timer ; unsigned int mca_flags ; int mca_users ; atomic_t mca_refcnt ; spinlock_t mca_lock ; unsigned long mca_cstamp ; unsigned long mca_tstamp ; }; struct ifacaddr6 { struct in6_addr aca_addr ; struct inet6_dev *aca_idev ; struct rt6_info *aca_rt ; struct ifacaddr6 *aca_next ; int aca_users ; atomic_t aca_refcnt ; spinlock_t aca_lock ; unsigned long aca_cstamp ; unsigned long aca_tstamp ; }; struct ipv6_devstat { struct proc_dir_entry *proc_dir_entry ; struct ipstats_mib *ipv6[1U] ; struct icmpv6_mib_device *icmpv6dev ; struct icmpv6msg_mib_device *icmpv6msgdev ; }; struct inet6_dev { struct net_device *dev ; struct list_head addr_list ; int valid_ll_addr_cnt ; struct ifmcaddr6 *mc_list ; struct ifmcaddr6 *mc_tomb ; spinlock_t mc_lock ; unsigned char mc_qrv ; unsigned char mc_gq_running ; unsigned char mc_ifc_count ; unsigned char mc_dad_count ; unsigned long mc_v1_seen ; unsigned long mc_qi ; unsigned long mc_qri ; unsigned long mc_maxdelay ; struct timer_list mc_gq_timer ; struct timer_list mc_ifc_timer ; struct timer_list mc_dad_timer ; struct ifacaddr6 *ac_list ; rwlock_t lock ; atomic_t refcnt ; __u32 if_flags ; int dead ; u8 rndid[8U] ; struct timer_list regen_timer ; struct list_head tempaddr_list ; struct in6_addr token ; struct neigh_parms *nd_parms ; struct ipv6_devconf cnf ; struct ipv6_devstat stats ; struct timer_list rs_timer ; __u8 rs_probes ; unsigned long tstamp ; struct callback_head rcu ; }; struct rpc_iostats; struct rpc_clnt { atomic_t cl_count ; unsigned int cl_clid ; struct list_head cl_clients ; struct list_head cl_tasks ; spinlock_t cl_lock ; struct rpc_xprt *cl_xprt ; struct rpc_procinfo *cl_procinfo ; u32 cl_prog ; u32 cl_vers ; u32 cl_maxproc ; struct rpc_auth *cl_auth ; struct rpc_stat *cl_stats ; struct rpc_iostats *cl_metrics ; unsigned char cl_softrtry : 1 ; unsigned char cl_discrtry : 1 ; unsigned char cl_autobind : 1 ; unsigned char cl_chatty : 1 ; struct rpc_rtt *cl_rtt ; struct rpc_timeout const *cl_timeout ; int cl_nodelen ; char cl_nodename[32U] ; struct rpc_pipe_dir_head cl_pipedir_objects ; struct rpc_clnt *cl_parent ; struct rpc_rtt cl_rtt_default ; struct rpc_timeout cl_timeout_default ; struct rpc_program const *cl_program ; }; struct rpc_version; struct rpc_program { char const *name ; u32 number ; unsigned int nrvers ; struct rpc_version const **version ; struct rpc_stat *stats ; char const *pipe_dir_name ; }; struct rpc_version { u32 number ; unsigned int nrprocs ; struct rpc_procinfo *procs ; }; struct rpc_procinfo { u32 p_proc ; void (*p_encode)(void * , struct xdr_stream * , void * ) ; int (*p_decode)(void * , struct xdr_stream * , void * ) ; unsigned int p_arglen ; unsigned int p_replen ; unsigned int p_count ; unsigned int p_timer ; u32 p_statidx ; char const *p_name ; }; struct rpc_create_args { struct net *net ; int protocol ; struct sockaddr *address ; size_t addrsize ; struct sockaddr *saddress ; struct rpc_timeout const *timeout ; char const *servername ; struct rpc_program const *program ; u32 prognumber ; u32 version ; rpc_authflavor_t authflavor ; unsigned long flags ; char *client_name ; struct svc_xprt *bc_xprt ; }; struct rpc_iostats { unsigned long om_ops ; unsigned long om_ntrans ; unsigned long om_timeouts ; unsigned long long om_bytes_sent ; unsigned long long om_bytes_recv ; ktime_t om_queue ; ktime_t om_rtt ; ktime_t om_execute ; }; struct nfs_fh { unsigned short size ; unsigned char data[128U] ; }; enum nfs3_stable_how { NFS_UNSTABLE = 0, NFS_DATA_SYNC = 1, NFS_FILE_SYNC = 2 } ; struct nfs4_label { uint32_t lfs ; uint32_t pi ; u32 len ; char *label ; }; struct __anonstruct_nfs4_verifier_259 { char data[8U] ; }; typedef struct __anonstruct_nfs4_verifier_259 nfs4_verifier; struct nfs_stateid4 { __be32 seqid ; char other[12U] ; }; typedef struct nfs_stateid4 nfs4_stateid; struct nfs4_deviceid { char data[16U] ; }; union __anonunion_ldv_47209_260 { kuid_t e_uid ; kgid_t e_gid ; }; struct posix_acl_entry { short e_tag ; unsigned short e_perm ; union __anonunion_ldv_47209_260 ldv_47209 ; }; union __anonunion_ldv_47213_261 { atomic_t a_refcount ; struct callback_head a_rcu ; }; struct posix_acl { union __anonunion_ldv_47213_261 ldv_47213 ; unsigned int a_count ; struct posix_acl_entry a_entries[0U] ; }; struct gss_api_mech; struct gss_ctx { struct gss_api_mech *mech_type ; void *internal_ctx_id ; }; struct rpcsec_gss_oid { unsigned int len ; u8 data[32U] ; }; struct rpcsec_gss_info { struct rpcsec_gss_oid oid ; u32 qop ; u32 service ; }; struct pf_desc { u32 pseudoflavor ; u32 qop ; u32 service ; char *name ; char *auth_domain_name ; }; struct gss_api_ops; struct gss_api_mech { struct list_head gm_list ; struct module *gm_owner ; struct rpcsec_gss_oid gm_oid ; char *gm_name ; struct gss_api_ops const *gm_ops ; int gm_pf_num ; struct pf_desc *gm_pfs ; char const *gm_upcall_enctypes ; }; struct gss_api_ops { int (*gss_import_sec_context)(void const * , size_t , struct gss_ctx * , time_t * , gfp_t ) ; u32 (*gss_get_mic)(struct gss_ctx * , struct xdr_buf * , struct xdr_netobj * ) ; u32 (*gss_verify_mic)(struct gss_ctx * , struct xdr_buf * , struct xdr_netobj * ) ; u32 (*gss_wrap)(struct gss_ctx * , int , struct xdr_buf * , struct page ** ) ; u32 (*gss_unwrap)(struct gss_ctx * , int , struct xdr_buf * ) ; void (*gss_delete_sec_context)(void * ) ; }; struct nfs4_string { unsigned int len ; char *data ; }; struct nfs_fsid { uint64_t major ; uint64_t minor ; }; struct nfs4_threshold { __u32 bm ; __u32 l_type ; __u64 rd_sz ; __u64 wr_sz ; __u64 rd_io_sz ; __u64 wr_io_sz ; }; struct __anonstruct_nfs2_263 { __u32 blocksize ; __u32 blocks ; }; struct __anonstruct_nfs3_264 { __u64 used ; }; union __anonunion_du_262 { struct __anonstruct_nfs2_263 nfs2 ; struct __anonstruct_nfs3_264 nfs3 ; }; struct nfs_fattr { unsigned int valid ; umode_t mode ; __u32 nlink ; kuid_t uid ; kgid_t gid ; dev_t rdev ; __u64 size ; union __anonunion_du_262 du ; struct nfs_fsid fsid ; __u64 fileid ; __u64 mounted_on_fileid ; struct timespec atime ; struct timespec mtime ; struct timespec ctime ; __u64 change_attr ; __u64 pre_change_attr ; __u64 pre_size ; struct timespec pre_mtime ; struct timespec pre_ctime ; unsigned long time_start ; unsigned long gencount ; struct nfs4_string *owner_name ; struct nfs4_string *group_name ; struct nfs4_threshold *mdsthreshold ; }; struct nfs_fsinfo { struct nfs_fattr *fattr ; __u32 rtmax ; __u32 rtpref ; __u32 rtmult ; __u32 wtmax ; __u32 wtpref ; __u32 wtmult ; __u32 dtpref ; __u64 maxfilesize ; struct timespec time_delta ; __u32 lease_time ; __u32 layouttype ; __u32 blksize ; }; struct nfs_fsstat { struct nfs_fattr *fattr ; __u64 tbytes ; __u64 fbytes ; __u64 abytes ; __u64 tfiles ; __u64 ffiles ; __u64 afiles ; }; struct nfs_pathconf { struct nfs_fattr *fattr ; __u32 max_link ; __u32 max_namelen ; }; struct nfs4_change_info { u32 atomic ; u64 before ; u64 after ; }; struct nfs4_slot; struct nfs4_sequence_args { struct nfs4_slot *sa_slot ; unsigned char sa_cache_this : 1 ; unsigned char sa_privileged : 1 ; }; struct nfs4_sequence_res { struct nfs4_slot *sr_slot ; unsigned long sr_timestamp ; int sr_status ; u32 sr_status_flags ; u32 sr_highest_slotid ; u32 sr_target_highest_slotid ; }; struct nfs4_layoutdriver_data { struct page **pages ; __u32 pglen ; __u32 len ; }; struct pnfs_layout_range { u32 iomode ; u64 offset ; u64 length ; }; struct nfs_open_context; struct nfs4_layoutget_res { struct nfs4_sequence_res seq_res ; __u32 return_on_close ; struct pnfs_layout_range range ; __u32 type ; nfs4_stateid stateid ; struct nfs4_layoutdriver_data *layoutp ; }; struct nfs4_layoutcommit_args { struct nfs4_sequence_args seq_args ; nfs4_stateid stateid ; __u64 lastbytewritten ; struct inode *inode ; u32 const *bitmask ; }; struct nfs_server; struct nfs4_layoutcommit_res { struct nfs4_sequence_res seq_res ; struct nfs_fattr *fattr ; struct nfs_server const *server ; int status ; }; struct nfs4_layoutcommit_data { struct rpc_task task ; struct nfs_fattr fattr ; struct list_head lseg_list ; struct rpc_cred *cred ; struct nfs4_layoutcommit_args args ; struct nfs4_layoutcommit_res res ; }; struct pnfs_layout_hdr; struct nfs4_layoutreturn_args { struct nfs4_sequence_args seq_args ; struct pnfs_layout_hdr *layout ; struct inode *inode ; nfs4_stateid stateid ; __u32 layout_type ; }; struct nfs_client; struct nfs_lock_context; struct nfs_readargs { struct nfs4_sequence_args seq_args ; struct nfs_fh *fh ; struct nfs_open_context *context ; struct nfs_lock_context *lock_context ; nfs4_stateid stateid ; __u64 offset ; __u32 count ; unsigned int pgbase ; struct page **pages ; }; struct nfs_readres { struct nfs4_sequence_res seq_res ; struct nfs_fattr *fattr ; __u32 count ; int eof ; }; struct nfs_writeargs { struct nfs4_sequence_args seq_args ; struct nfs_fh *fh ; struct nfs_open_context *context ; struct nfs_lock_context *lock_context ; nfs4_stateid stateid ; __u64 offset ; __u32 count ; enum nfs3_stable_how stable ; unsigned int pgbase ; struct page **pages ; u32 const *bitmask ; }; struct nfs_write_verifier { char data[8U] ; }; struct nfs_writeverf { struct nfs_write_verifier verifier ; enum nfs3_stable_how committed ; }; struct nfs_writeres { struct nfs4_sequence_res seq_res ; struct nfs_fattr *fattr ; struct nfs_writeverf *verf ; __u32 count ; struct nfs_server const *server ; }; struct nfs_commitargs { struct nfs4_sequence_args seq_args ; struct nfs_fh *fh ; __u64 offset ; __u32 count ; u32 const *bitmask ; }; struct nfs_commitres { struct nfs4_sequence_res seq_res ; struct nfs_fattr *fattr ; struct nfs_writeverf *verf ; struct nfs_server const *server ; }; struct nfs_removeargs { struct nfs4_sequence_args seq_args ; struct nfs_fh const *fh ; struct qstr name ; }; struct nfs_removeres { struct nfs4_sequence_res seq_res ; struct nfs_server const *server ; struct nfs_fattr *dir_attr ; struct nfs4_change_info cinfo ; }; struct nfs_renameargs { struct nfs4_sequence_args seq_args ; struct nfs_fh const *old_dir ; struct nfs_fh const *new_dir ; struct qstr const *old_name ; struct qstr const *new_name ; }; struct nfs_renameres { struct nfs4_sequence_res seq_res ; struct nfs_server const *server ; struct nfs4_change_info old_cinfo ; struct nfs_fattr *old_fattr ; struct nfs4_change_info new_cinfo ; struct nfs_fattr *new_fattr ; }; struct nfs_entry { __u64 ino ; __u64 cookie ; __u64 prev_cookie ; char const *name ; unsigned int len ; int eof ; struct nfs_fh *fh ; struct nfs_fattr *fattr ; struct nfs4_label *label ; unsigned char d_type ; struct nfs_server *server ; }; struct nfstime4 { u64 seconds ; u32 nseconds ; }; struct pnfs_layout_segment; struct pnfs_commit_bucket { struct list_head written ; struct list_head committing ; struct pnfs_layout_segment *wlseg ; struct pnfs_layout_segment *clseg ; }; struct pnfs_ds_commit_info { int nwritten ; int ncommitting ; int nbuckets ; struct pnfs_commit_bucket *buckets ; }; struct nfs41_server_owner { uint64_t minor_id ; uint32_t major_id_sz ; char major_id[1024U] ; }; struct nfs41_server_scope { uint32_t server_scope_sz ; char server_scope[1024U] ; }; struct nfs41_impl_id { char domain[1025U] ; char name[1025U] ; struct nfstime4 date ; }; struct nfs4_session; struct nfs_page; struct nfs_page_array { struct page **pagevec ; unsigned int npages ; struct page *page_array[8U] ; }; struct nfs_read_data { struct nfs_pgio_header *header ; struct list_head list ; struct rpc_task task ; struct nfs_fattr fattr ; struct nfs_readargs args ; struct nfs_readres res ; unsigned long timestamp ; int (*read_done_cb)(struct rpc_task * , struct nfs_read_data * ) ; __u64 mds_offset ; struct nfs_page_array pages ; struct nfs_client *ds_clp ; }; struct nfs_pgio_completion_ops; struct nfs_direct_req; struct nfs_pgio_header { struct inode *inode ; struct rpc_cred *cred ; struct list_head pages ; struct list_head rpc_list ; atomic_t refcnt ; struct nfs_page *req ; struct nfs_writeverf *verf ; struct pnfs_layout_segment *lseg ; loff_t io_start ; struct rpc_call_ops const *mds_ops ; void (*release)(struct nfs_pgio_header * ) ; struct nfs_pgio_completion_ops const *completion_ops ; struct nfs_direct_req *dreq ; void *layout_private ; spinlock_t lock ; int pnfs_error ; int error ; unsigned long good_bytes ; unsigned long flags ; }; struct nfs_write_data { struct nfs_pgio_header *header ; struct list_head list ; struct rpc_task task ; struct nfs_fattr fattr ; struct nfs_writeverf verf ; struct nfs_writeargs args ; struct nfs_writeres res ; unsigned long timestamp ; int (*write_done_cb)(struct rpc_task * , struct nfs_write_data * ) ; __u64 mds_offset ; struct nfs_page_array pages ; struct nfs_client *ds_clp ; }; struct nfs_mds_commit_info { atomic_t rpcs_out ; unsigned long ncommit ; struct list_head list ; }; struct nfs_commit_data; struct nfs_inode; struct nfs_commit_completion_ops { void (*error_cleanup)(struct nfs_inode * ) ; void (*completion)(struct nfs_commit_data * ) ; }; struct nfs_commit_info { spinlock_t *lock ; struct nfs_mds_commit_info *mds ; struct pnfs_ds_commit_info *ds ; struct nfs_direct_req *dreq ; struct nfs_commit_completion_ops const *completion_ops ; }; struct nfs_commit_data { struct rpc_task task ; struct inode *inode ; struct rpc_cred *cred ; struct nfs_fattr fattr ; struct nfs_writeverf verf ; struct list_head pages ; struct list_head list ; struct nfs_direct_req *dreq ; struct nfs_commitargs args ; struct nfs_commitres res ; struct nfs_open_context *context ; struct pnfs_layout_segment *lseg ; struct nfs_client *ds_clp ; int ds_commit_index ; struct rpc_call_ops const *mds_ops ; struct nfs_commit_completion_ops const *completion_ops ; int (*commit_done_cb)(struct rpc_task * , struct nfs_commit_data * ) ; }; struct nfs_pgio_completion_ops { void (*error_cleanup)(struct list_head * ) ; void (*init_hdr)(struct nfs_pgio_header * ) ; void (*completion)(struct nfs_pgio_header * ) ; }; struct nfs_unlinkdata { struct hlist_node list ; struct nfs_removeargs args ; struct nfs_removeres res ; struct inode *dir ; struct rpc_cred *cred ; struct nfs_fattr dir_attr ; }; struct nfs_renamedata { struct nfs_renameargs args ; struct nfs_renameres res ; struct rpc_cred *cred ; struct inode *old_dir ; struct dentry *old_dentry ; struct nfs_fattr old_fattr ; struct inode *new_dir ; struct dentry *new_dentry ; struct nfs_fattr new_fattr ; }; struct nfs_access_entry; struct nfs_subversion; struct nfs_mount_info; struct nfs_client_initdata; struct nfs_rpc_ops { u32 version ; struct dentry_operations const *dentry_ops ; struct inode_operations const *dir_inode_ops ; struct inode_operations const *file_inode_ops ; struct file_operations const *file_ops ; int (*getroot)(struct nfs_server * , struct nfs_fh * , struct nfs_fsinfo * ) ; struct vfsmount *(*submount)(struct nfs_server * , struct dentry * , struct nfs_fh * , struct nfs_fattr * ) ; struct dentry *(*try_mount)(int , char const * , struct nfs_mount_info * , struct nfs_subversion * ) ; int (*getattr)(struct nfs_server * , struct nfs_fh * , struct nfs_fattr * , struct nfs4_label * ) ; int (*setattr)(struct dentry * , struct nfs_fattr * , struct iattr * ) ; int (*lookup)(struct inode * , struct qstr * , struct nfs_fh * , struct nfs_fattr * , struct nfs4_label * ) ; int (*access)(struct inode * , struct nfs_access_entry * ) ; int (*readlink)(struct inode * , struct page * , unsigned int , unsigned int ) ; int (*create)(struct inode * , struct dentry * , struct iattr * , int ) ; int (*remove)(struct inode * , struct qstr * ) ; void (*unlink_setup)(struct rpc_message * , struct inode * ) ; void (*unlink_rpc_prepare)(struct rpc_task * , struct nfs_unlinkdata * ) ; int (*unlink_done)(struct rpc_task * , struct inode * ) ; int (*rename)(struct inode * , struct qstr * , struct inode * , struct qstr * ) ; void (*rename_setup)(struct rpc_message * , struct inode * ) ; void (*rename_rpc_prepare)(struct rpc_task * , struct nfs_renamedata * ) ; int (*rename_done)(struct rpc_task * , struct inode * , struct inode * ) ; int (*link)(struct inode * , struct inode * , struct qstr * ) ; int (*symlink)(struct inode * , struct dentry * , struct page * , unsigned int , struct iattr * ) ; int (*mkdir)(struct inode * , struct dentry * , struct iattr * ) ; int (*rmdir)(struct inode * , struct qstr * ) ; int (*readdir)(struct dentry * , struct rpc_cred * , u64 , struct page ** , unsigned int , int ) ; int (*mknod)(struct inode * , struct dentry * , struct iattr * , dev_t ) ; int (*statfs)(struct nfs_server * , struct nfs_fh * , struct nfs_fsstat * ) ; int (*fsinfo)(struct nfs_server * , struct nfs_fh * , struct nfs_fsinfo * ) ; int (*pathconf)(struct nfs_server * , struct nfs_fh * , struct nfs_pathconf * ) ; int (*set_capabilities)(struct nfs_server * , struct nfs_fh * ) ; int (*decode_dirent)(struct xdr_stream * , struct nfs_entry * , int ) ; void (*read_setup)(struct nfs_read_data * , struct rpc_message * ) ; void (*read_pageio_init)(struct nfs_pageio_descriptor * , struct inode * , struct nfs_pgio_completion_ops const * ) ; int (*read_rpc_prepare)(struct rpc_task * , struct nfs_read_data * ) ; int (*read_done)(struct rpc_task * , struct nfs_read_data * ) ; void (*write_setup)(struct nfs_write_data * , struct rpc_message * ) ; void (*write_pageio_init)(struct nfs_pageio_descriptor * , struct inode * , int , struct nfs_pgio_completion_ops const * ) ; int (*write_rpc_prepare)(struct rpc_task * , struct nfs_write_data * ) ; int (*write_done)(struct rpc_task * , struct nfs_write_data * ) ; void (*commit_setup)(struct nfs_commit_data * , struct rpc_message * ) ; void (*commit_rpc_prepare)(struct rpc_task * , struct nfs_commit_data * ) ; int (*commit_done)(struct rpc_task * , struct nfs_commit_data * ) ; int (*lock)(struct file * , int , struct file_lock * ) ; int (*lock_check_bounds)(struct file_lock const * ) ; void (*clear_acl_cache)(struct inode * ) ; void (*close_context)(struct nfs_open_context * , int ) ; struct inode *(*open_context)(struct inode * , struct nfs_open_context * , int , struct iattr * ) ; int (*have_delegation)(struct inode * , fmode_t ) ; int (*return_delegation)(struct inode * ) ; struct nfs_client *(*alloc_client)(struct nfs_client_initdata const * ) ; struct nfs_client *(*init_client)(struct nfs_client * , struct rpc_timeout const * , char const * ) ; void (*free_client)(struct nfs_client * ) ; struct nfs_server *(*create_server)(struct nfs_mount_info * , struct nfs_subversion * ) ; struct nfs_server *(*clone_server)(struct nfs_server * , struct nfs_fh * , struct nfs_fattr * , rpc_authflavor_t ) ; }; struct fprop_local_percpu { struct percpu_counter events ; unsigned int period ; raw_spinlock_t lock ; }; enum writeback_sync_modes { WB_SYNC_NONE = 0, WB_SYNC_ALL = 1 } ; struct writeback_control { long nr_to_write ; long pages_skipped ; loff_t range_start ; loff_t range_end ; enum writeback_sync_modes sync_mode ; unsigned char for_kupdate : 1 ; unsigned char for_background : 1 ; unsigned char tagged_writepages : 1 ; unsigned char for_reclaim : 1 ; unsigned char range_cyclic : 1 ; unsigned char for_sync : 1 ; }; struct bdi_writeback; typedef int congested_fn(void * , int ); struct bdi_writeback { struct backing_dev_info *bdi ; unsigned int nr ; unsigned long last_old_flush ; struct delayed_work dwork ; struct list_head b_dirty ; struct list_head b_io ; struct list_head b_more_io ; spinlock_t list_lock ; }; struct backing_dev_info { struct list_head bdi_list ; unsigned long ra_pages ; unsigned long state ; unsigned int capabilities ; congested_fn *congested_fn ; void *congested_data ; char *name ; struct percpu_counter bdi_stat[4U] ; unsigned long bw_time_stamp ; unsigned long dirtied_stamp ; unsigned long written_stamp ; unsigned long write_bandwidth ; unsigned long avg_write_bandwidth ; unsigned long dirty_ratelimit ; unsigned long balanced_dirty_ratelimit ; struct fprop_local_percpu completions ; int dirty_exceeded ; unsigned int min_ratio ; unsigned int max_ratio ; unsigned int max_prop_frac ; struct bdi_writeback wb ; spinlock_t wb_lock ; struct list_head work_list ; struct device *dev ; struct timer_list laptop_mode_wb_timer ; struct dentry *debug_dir ; struct dentry *debug_stats ; }; struct nfs_iostats; struct nlm_host; struct nfs4_minor_version_ops; struct idmap; struct nfs4_slot_table; struct fscache_cookie; struct nfs_client { atomic_t cl_count ; atomic_t cl_mds_count ; int cl_cons_state ; unsigned long cl_res_state ; unsigned long cl_flags ; struct __kernel_sockaddr_storage cl_addr ; size_t cl_addrlen ; char *cl_hostname ; struct list_head cl_share_link ; struct list_head cl_superblocks ; struct rpc_clnt *cl_rpcclient ; struct nfs_rpc_ops const *rpc_ops ; int cl_proto ; struct nfs_subversion *cl_nfs_mod ; u32 cl_minorversion ; struct rpc_cred *cl_machine_cred ; struct list_head cl_ds_clients ; u64 cl_clientid ; nfs4_verifier cl_confirm ; unsigned long cl_state ; spinlock_t cl_lock ; unsigned long cl_lease_time ; unsigned long cl_last_renewal ; struct delayed_work cl_renewd ; struct rpc_wait_queue cl_rpcwaitq ; struct idmap *cl_idmap ; char cl_ipaddr[48U] ; u32 cl_cb_ident ; struct nfs4_minor_version_ops const *cl_mvops ; struct nfs4_slot_table *cl_slot_tbl ; u32 cl_seqid ; u32 cl_exchange_flags ; struct nfs4_session *cl_session ; bool cl_preserve_clid ; struct nfs41_server_owner *cl_serverowner ; struct nfs41_server_scope *cl_serverscope ; struct nfs41_impl_id *cl_implid ; unsigned long cl_sp4_flags ; struct fscache_cookie *fscache ; struct net *cl_net ; }; struct nfs_fscache_key; struct pnfs_layoutdriver_type; struct nfs_server { struct nfs_client *nfs_client ; struct list_head client_link ; struct list_head master_link ; struct rpc_clnt *client ; struct rpc_clnt *client_acl ; struct nlm_host *nlm_host ; struct nfs_iostats *io_stats ; struct backing_dev_info backing_dev_info ; atomic_long_t writeback ; int flags ; unsigned int caps ; unsigned int rsize ; unsigned int rpages ; unsigned int wsize ; unsigned int wpages ; unsigned int wtmult ; unsigned int dtsize ; unsigned short port ; unsigned int bsize ; unsigned int acregmin ; unsigned int acregmax ; unsigned int acdirmin ; unsigned int acdirmax ; unsigned int namelen ; unsigned int options ; struct nfs_fsid fsid ; __u64 maxfilesize ; struct timespec time_delta ; unsigned long mount_time ; dev_t s_dev ; struct nfs_fscache_key *fscache_key ; struct fscache_cookie *fscache ; u32 pnfs_blksize ; u32 attr_bitmask[3U] ; u32 attr_bitmask_nl[3U] ; u32 cache_consistency_bitmask[3U] ; u32 acl_bitmask ; u32 fh_expire_type ; struct pnfs_layoutdriver_type *pnfs_curr_ld ; struct rpc_wait_queue roc_rpcwaitq ; void *pnfs_ld_data ; struct rb_root state_owners ; struct ida openowner_id ; struct ida lockowner_id ; struct list_head state_owners_lru ; struct list_head layouts ; struct list_head delegations ; void (*destroy)(struct nfs_server * ) ; atomic_t active ; struct __kernel_sockaddr_storage mountd_address ; size_t mountd_addrlen ; u32 mountd_version ; unsigned short mountd_port ; unsigned short mountd_protocol ; }; struct nfs_access_entry { struct rb_node rb_node ; struct list_head lru ; unsigned long jiffies ; struct rpc_cred *cred ; int mask ; }; struct nfs_lockowner { fl_owner_t l_owner ; pid_t l_pid ; }; struct nfs_io_counter { unsigned long flags ; atomic_t io_count ; }; struct nfs_lock_context { atomic_t count ; struct list_head list ; struct nfs_open_context *open_context ; struct nfs_lockowner lockowner ; struct nfs_io_counter io_count ; }; struct nfs4_state; struct nfs_open_context { struct nfs_lock_context lock_context ; struct dentry *dentry ; struct rpc_cred *cred ; struct nfs4_state *state ; fmode_t mode ; unsigned long flags ; int error ; struct list_head list ; struct nfs4_threshold *mdsthreshold ; }; struct nfs_delegation; struct nfs4_cached_acl; struct nfs_inode { __u64 fileid ; struct nfs_fh fh ; unsigned long flags ; unsigned long cache_validity ; unsigned long read_cache_jiffies ; unsigned long attrtimeo ; unsigned long attrtimeo_timestamp ; unsigned long attr_gencount ; unsigned long cache_change_attribute ; struct rb_root access_cache ; struct list_head access_cache_entry_lru ; struct list_head access_cache_inode_lru ; struct posix_acl *acl_access ; struct posix_acl *acl_default ; __be32 cookieverf[2U] ; unsigned long npages ; struct nfs_mds_commit_info commit_info ; struct list_head open_files ; atomic_t silly_count ; struct hlist_head silly_list ; wait_queue_head_t waitqueue ; struct nfs4_cached_acl *nfs4_acl ; struct list_head open_states ; struct nfs_delegation *delegation ; fmode_t delegation_state ; struct rw_semaphore rwsem ; struct pnfs_layout_hdr *layout ; __u64 write_io ; __u64 read_io ; struct fscache_cookie *fscache ; struct inode vfs_inode ; }; struct svc_rqst; struct nlmclnt_initdata { char const *hostname ; struct sockaddr const *address ; size_t addrlen ; unsigned short protocol ; u32 nfs_version ; int noresvport ; struct net *net ; }; struct vfsmount { struct dentry *mnt_root ; struct super_block *mnt_sb ; int mnt_flags ; }; struct kstatfs { long f_type ; long f_bsize ; u64 f_blocks ; u64 f_bfree ; u64 f_bavail ; u64 f_files ; u64 f_ffree ; __kernel_fsid_t f_fsid ; long f_namelen ; long f_frsize ; long f_flags ; long f_spare[4U] ; }; struct cache_head { struct cache_head *next ; time_t expiry_time ; time_t last_refresh ; struct kref ref ; unsigned long flags ; }; struct cache_detail_procfs { struct proc_dir_entry *proc_ent ; struct proc_dir_entry *flush_ent ; struct proc_dir_entry *channel_ent ; struct proc_dir_entry *content_ent ; }; struct cache_detail_pipefs { struct dentry *dir ; }; union __anonunion_u_271 { struct cache_detail_procfs procfs ; struct cache_detail_pipefs pipefs ; }; struct cache_detail { struct module *owner ; int hash_size ; struct cache_head **hash_table ; rwlock_t hash_lock ; atomic_t inuse ; char *name ; void (*cache_put)(struct kref * ) ; int (*cache_upcall)(struct cache_detail * , struct cache_head * ) ; void (*cache_request)(struct cache_detail * , struct cache_head * , char ** , int * ) ; int (*cache_parse)(struct cache_detail * , char * , int ) ; int (*cache_show)(struct seq_file * , struct cache_detail * , struct cache_head * ) ; void (*warn_no_listener)(struct cache_detail * , int ) ; struct cache_head *(*alloc)(void) ; int (*match)(struct cache_head * , struct cache_head * ) ; void (*init)(struct cache_head * , struct cache_head * ) ; void (*update)(struct cache_head * , struct cache_head * ) ; time_t flush_time ; struct list_head others ; time_t nextcheck ; int entries ; struct list_head queue ; atomic_t readers ; time_t last_close ; time_t last_warn ; union __anonunion_u_271 u ; struct net *net ; }; struct cache_deferred_req; struct cache_req { struct cache_deferred_req *(*defer)(struct cache_req * ) ; int thread_wait ; }; struct cache_deferred_req { struct hlist_node hash ; struct list_head recent ; struct cache_head *item ; void *owner ; void (*revisit)(struct cache_deferred_req * , int ) ; }; struct svc_cred { kuid_t cr_uid ; kgid_t cr_gid ; struct group_info *cr_group_info ; u32 cr_flavor ; char *cr_principal ; struct gss_api_mech *cr_gss_mech ; }; struct auth_ops; struct auth_domain { struct kref ref ; struct hlist_node hash ; char *name ; struct auth_ops *flavour ; }; struct auth_ops { char *name ; struct module *owner ; int flavour ; int (*accept)(struct svc_rqst * , __be32 * ) ; int (*release)(struct svc_rqst * ) ; void (*domain_release)(struct auth_domain * ) ; int (*set_client)(struct svc_rqst * ) ; }; struct svc_pool_stats { unsigned long packets ; unsigned long sockets_queued ; unsigned long threads_woken ; unsigned long threads_timedout ; }; struct svc_pool { unsigned int sp_id ; spinlock_t sp_lock ; struct list_head sp_threads ; struct list_head sp_sockets ; unsigned int sp_nrthreads ; struct list_head sp_all_threads ; struct svc_pool_stats sp_stats ; int sp_task_pending ; }; struct svc_serv { struct svc_program *sv_program ; struct svc_stat *sv_stats ; spinlock_t sv_lock ; unsigned int sv_nrthreads ; unsigned int sv_maxconn ; unsigned int sv_max_payload ; unsigned int sv_max_mesg ; unsigned int sv_xdrsize ; struct list_head sv_permsocks ; struct list_head sv_tempsocks ; int sv_tmpcnt ; struct timer_list sv_temptimer ; char *sv_name ; unsigned int sv_nrpools ; struct svc_pool *sv_pools ; void (*sv_shutdown)(struct svc_serv * , struct net * ) ; struct module *sv_module ; int (*sv_function)(void * ) ; struct list_head sv_cb_list ; spinlock_t sv_cb_lock ; wait_queue_head_t sv_cb_waitq ; struct svc_xprt *sv_bc_xprt ; }; struct svc_procedure; struct svc_deferred_req; struct svc_cacherep; struct svc_rqst { struct list_head rq_list ; struct list_head rq_all ; struct svc_xprt *rq_xprt ; struct __kernel_sockaddr_storage rq_addr ; size_t rq_addrlen ; struct __kernel_sockaddr_storage rq_daddr ; size_t rq_daddrlen ; struct svc_serv *rq_server ; struct svc_pool *rq_pool ; struct svc_procedure *rq_procinfo ; struct auth_ops *rq_authop ; struct svc_cred rq_cred ; void *rq_xprt_ctxt ; struct svc_deferred_req *rq_deferred ; int rq_usedeferral ; size_t rq_xprt_hlen ; struct xdr_buf rq_arg ; struct xdr_buf rq_res ; struct page *rq_pages[259U] ; struct page **rq_respages ; struct page **rq_next_page ; struct kvec rq_vec[259U] ; __be32 rq_xid ; u32 rq_prog ; u32 rq_vers ; u32 rq_proc ; u32 rq_prot ; unsigned char rq_secure : 1 ; void *rq_argp ; void *rq_resp ; void *rq_auth_data ; int rq_reserved ; struct cache_req rq_chandle ; bool rq_dropme ; struct auth_domain *rq_client ; struct auth_domain *rq_gssclient ; int rq_cachetype ; struct svc_cacherep *rq_cacherep ; int rq_splice_ok ; wait_queue_head_t rq_wait ; struct task_struct *rq_task ; }; struct svc_deferred_req { u32 prot ; struct svc_xprt *xprt ; struct __kernel_sockaddr_storage addr ; size_t addrlen ; struct __kernel_sockaddr_storage daddr ; size_t daddrlen ; struct cache_deferred_req handle ; size_t xprt_hlen ; int argslen ; __be32 args[0U] ; }; struct svc_version; struct svc_program { struct svc_program *pg_next ; u32 pg_prog ; unsigned int pg_lovers ; unsigned int pg_hivers ; unsigned int pg_nvers ; struct svc_version **pg_vers ; char *pg_name ; char *pg_class ; struct svc_stat *pg_stats ; int (*pg_authenticate)(struct svc_rqst * ) ; }; struct svc_version { u32 vs_vers ; u32 vs_nproc ; struct svc_procedure *vs_proc ; u32 vs_xdrsize ; unsigned char vs_hidden : 1 ; int (*vs_dispatch)(struct svc_rqst * , __be32 * ) ; }; struct svc_procedure { __be32 (*pc_func)(struct svc_rqst * , void * , void * ) ; int (*pc_decode)(void * , __be32 * , void * ) ; int (*pc_encode)(void * , __be32 * , void * ) ; int (*pc_release)(void * , __be32 * , void * ) ; unsigned int pc_argsize ; unsigned int pc_ressize ; unsigned int pc_count ; unsigned int pc_cachetype ; unsigned int pc_xdrressize ; }; struct svc_xprt_ops { struct svc_xprt *(*xpo_create)(struct svc_serv * , struct net * , struct sockaddr * , int , int ) ; struct svc_xprt *(*xpo_accept)(struct svc_xprt * ) ; int (*xpo_has_wspace)(struct svc_xprt * ) ; int (*xpo_recvfrom)(struct svc_rqst * ) ; void (*xpo_prep_reply_hdr)(struct svc_rqst * ) ; int (*xpo_sendto)(struct svc_rqst * ) ; void (*xpo_release_rqst)(struct svc_rqst * ) ; void (*xpo_detach)(struct svc_xprt * ) ; void (*xpo_free)(struct svc_xprt * ) ; }; struct svc_xprt_class { char const *xcl_name ; struct module *xcl_owner ; struct svc_xprt_ops *xcl_ops ; struct list_head xcl_list ; u32 xcl_max_payload ; }; struct svc_xprt { struct svc_xprt_class *xpt_class ; struct svc_xprt_ops *xpt_ops ; struct kref xpt_ref ; struct list_head xpt_list ; struct list_head xpt_ready ; unsigned long xpt_flags ; struct svc_serv *xpt_server ; atomic_t xpt_reserved ; struct mutex xpt_mutex ; spinlock_t xpt_lock ; void *xpt_auth_cache ; struct list_head xpt_deferred ; struct __kernel_sockaddr_storage xpt_local ; size_t xpt_locallen ; struct __kernel_sockaddr_storage xpt_remote ; size_t xpt_remotelen ; struct rpc_wait_queue xpt_bc_pending ; struct list_head xpt_users ; struct net *xpt_net ; struct rpc_xprt *xpt_bc_xprt ; }; struct pidmap { atomic_t nr_free ; void *page ; }; struct bsd_acct_struct; struct pid_namespace { struct kref kref ; struct pidmap pidmap[128U] ; int last_pid ; unsigned int nr_hashed ; struct task_struct *child_reaper ; struct kmem_cache *pid_cachep ; unsigned int level ; struct pid_namespace *parent ; struct vfsmount *proc_mnt ; struct dentry *proc_self ; struct bsd_acct_struct *bacct ; struct user_namespace *user_ns ; struct work_struct proc_work ; kgid_t pid_gid ; int hide_pid ; int reboot ; unsigned int proc_inum ; }; struct nfs4_state_recovery_ops; struct nfs4_state_maintenance_ops; struct nfs4_minor_version_ops { u32 minor_version ; unsigned int init_caps ; int (*init_client)(struct nfs_client * ) ; void (*shutdown_client)(struct nfs_client * ) ; bool (*match_stateid)(nfs4_stateid const * , nfs4_stateid const * ) ; int (*find_root_sec)(struct nfs_server * , struct nfs_fh * , struct nfs_fsinfo * ) ; int (*free_lock_state)(struct nfs_server * , struct nfs4_lock_state * ) ; struct rpc_call_ops const *call_sync_ops ; struct nfs4_state_recovery_ops const *reboot_recovery_ops ; struct nfs4_state_recovery_ops const *nograce_recovery_ops ; struct nfs4_state_maintenance_ops const *state_renewal_ops ; }; struct nfs_seqid_counter { ktime_t create_time ; int owner_id ; int flags ; u32 counter ; spinlock_t lock ; struct list_head list ; struct rpc_wait_queue wait ; }; struct nfs4_state_owner { struct nfs_server *so_server ; struct list_head so_lru ; unsigned long so_expires ; struct rb_node so_server_node ; struct rpc_cred *so_cred ; spinlock_t so_lock ; atomic_t so_count ; unsigned long so_flags ; struct list_head so_states ; struct nfs_seqid_counter so_seqid ; seqcount_t so_reclaim_seqcount ; struct mutex so_delegreturn_mutex ; }; union __anonunion_lo_u_272 { fl_owner_t posix_owner ; pid_t flock_owner ; }; struct nfs4_lock_owner { unsigned int lo_type ; union __anonunion_lo_u_272 lo_u ; }; struct nfs4_lock_state { struct list_head ls_locks ; struct nfs4_state *ls_state ; unsigned long ls_flags ; struct nfs_seqid_counter ls_seqid ; nfs4_stateid ls_stateid ; atomic_t ls_count ; struct nfs4_lock_owner ls_owner ; }; struct nfs4_state { struct list_head open_states ; struct list_head inode_states ; struct list_head lock_states ; struct nfs4_state_owner *owner ; struct inode *inode ; unsigned long flags ; spinlock_t state_lock ; seqlock_t seqlock ; nfs4_stateid stateid ; nfs4_stateid open_stateid ; unsigned int n_rdonly ; unsigned int n_wronly ; unsigned int n_rdwr ; fmode_t state ; atomic_t count ; }; struct nfs4_state_recovery_ops { int owner_flag_bit ; int state_flag_bit ; int (*recover_open)(struct nfs4_state_owner * , struct nfs4_state * ) ; int (*recover_lock)(struct nfs4_state * , struct file_lock * ) ; int (*establish_clid)(struct nfs_client * , struct rpc_cred * ) ; int (*reclaim_complete)(struct nfs_client * , struct rpc_cred * ) ; int (*detect_trunking)(struct nfs_client * , struct nfs_client ** , struct rpc_cred * ) ; }; struct nfs4_state_maintenance_ops { int (*sched_state_renewal)(struct nfs_client * , struct rpc_cred * , unsigned int ) ; struct rpc_cred *(*get_state_renewal_cred_locked)(struct nfs_client * ) ; int (*renew_lease)(struct nfs_client * , struct rpc_cred * ) ; }; struct nfs_delegation { struct list_head super_list ; struct rpc_cred *cred ; struct inode *inode ; nfs4_stateid stateid ; fmode_t type ; loff_t maxsize ; __u64 change_attr ; unsigned long flags ; spinlock_t lock ; struct callback_head rcu ; }; struct nfs_iostats { unsigned long long bytes[8U] ; unsigned long long fscache[5U] ; unsigned long events[27U] ; }; struct nfs_clone_mount { struct super_block const *sb ; struct dentry const *dentry ; struct nfs_fh *fh ; struct nfs_fattr *fattr ; char *hostname ; char *mnt_path ; struct sockaddr *addr ; size_t addrlen ; rpc_authflavor_t authflavor ; }; struct nfs_client_initdata { unsigned long init_flags ; char const *hostname ; struct sockaddr const *addr ; size_t addrlen ; struct nfs_subversion *nfs_mod ; int proto ; u32 minorversion ; struct net *net ; }; struct __anonstruct_mount_server_275 { struct __kernel_sockaddr_storage address ; size_t addrlen ; char *hostname ; u32 version ; int port ; unsigned short protocol ; }; struct __anonstruct_nfs_server_276 { struct __kernel_sockaddr_storage address ; size_t addrlen ; char *hostname ; char *export_path ; int port ; unsigned short protocol ; }; struct nfs_parsed_mount_data { int flags ; unsigned int rsize ; unsigned int wsize ; unsigned int timeo ; unsigned int retrans ; unsigned int acregmin ; unsigned int acregmax ; unsigned int acdirmin ; unsigned int acdirmax ; unsigned int namlen ; unsigned int options ; unsigned int bsize ; unsigned int auth_flavor_len ; rpc_authflavor_t auth_flavors[1U] ; char *client_address ; unsigned int version ; unsigned int minorversion ; char *fscache_uniq ; bool need_mount ; struct __anonstruct_mount_server_275 mount_server ; struct __anonstruct_nfs_server_276 nfs_server ; struct security_mnt_opts lsm_opts ; struct net *net ; }; struct nfs_mount_info { void (*fill_super)(struct super_block * , struct nfs_mount_info * ) ; int (*set_security)(struct super_block * , struct dentry * , struct nfs_mount_info * ) ; struct nfs_parsed_mount_data *parsed ; struct nfs_clone_mount *cloned ; struct nfs_fh *mntfh ; }; struct __anonstruct_super_278 { unsigned long s_flags ; }; struct __anonstruct_nfs_server_279 { struct nfs_fsid fsid ; int flags ; unsigned int rsize ; unsigned int wsize ; unsigned int acregmin ; unsigned int acregmax ; unsigned int acdirmin ; unsigned int acdirmax ; }; struct __anonstruct_rpc_auth_280 { rpc_authflavor_t au_flavor ; }; struct __anonstruct_key_277 { struct __anonstruct_super_278 super ; struct __anonstruct_nfs_server_279 nfs_server ; struct __anonstruct_rpc_auth_280 rpc_auth ; u8 uniq_len ; char uniquifier[0U] ; }; struct nfs_fscache_key { struct rb_node node ; struct nfs_client *nfs_client ; struct __anonstruct_key_277 key ; }; struct nfs_page { struct list_head wb_list ; struct page *wb_page ; struct nfs_open_context *wb_context ; struct nfs_lock_context *wb_lock_context ; unsigned long wb_index ; unsigned int wb_offset ; unsigned int wb_pgbase ; unsigned int wb_bytes ; struct kref wb_kref ; unsigned long wb_flags ; struct nfs_write_verifier wb_verf ; }; struct nfs_pageio_ops { void (*pg_init)(struct nfs_pageio_descriptor * , struct nfs_page * ) ; bool (*pg_test)(struct nfs_pageio_descriptor * , struct nfs_page * , struct nfs_page * ) ; int (*pg_doio)(struct nfs_pageio_descriptor * ) ; }; struct nfs_pageio_descriptor { struct list_head pg_list ; unsigned long pg_bytes_written ; size_t pg_count ; size_t pg_bsize ; unsigned int pg_base ; unsigned char pg_moreio : 1 ; unsigned char pg_recoalesce : 1 ; struct inode *pg_inode ; struct nfs_pageio_ops const *pg_ops ; int pg_ioflags ; int pg_error ; struct rpc_call_ops const *pg_rpc_callops ; struct nfs_pgio_completion_ops const *pg_completion_ops ; struct pnfs_layout_segment *pg_lseg ; struct nfs_direct_req *pg_dreq ; void *pg_layout_private ; }; struct pnfs_layout_segment { struct list_head pls_list ; struct list_head pls_lc_list ; struct pnfs_layout_range pls_range ; atomic_t pls_refcount ; unsigned long pls_flags ; struct pnfs_layout_hdr *pls_layout ; }; enum pnfs_try_status { PNFS_ATTEMPTED = 0, PNFS_NOT_ATTEMPTED = 1 } ; struct nfs4_deviceid_node; struct pnfs_layoutdriver_type { struct list_head pnfs_tblid ; u32 const id ; char const *name ; struct module *owner ; unsigned int flags ; int (*set_layoutdriver)(struct nfs_server * , struct nfs_fh const * ) ; int (*clear_layoutdriver)(struct nfs_server * ) ; struct pnfs_layout_hdr *(*alloc_layout_hdr)(struct inode * , gfp_t ) ; void (*free_layout_hdr)(struct pnfs_layout_hdr * ) ; struct pnfs_layout_segment *(*alloc_lseg)(struct pnfs_layout_hdr * , struct nfs4_layoutget_res * , gfp_t ) ; void (*free_lseg)(struct pnfs_layout_segment * ) ; struct nfs_pageio_ops const *pg_read_ops ; struct nfs_pageio_ops const *pg_write_ops ; struct pnfs_ds_commit_info *(*get_ds_info)(struct inode * ) ; void (*mark_request_commit)(struct nfs_page * , struct pnfs_layout_segment * , struct nfs_commit_info * ) ; void (*clear_request_commit)(struct nfs_page * , struct nfs_commit_info * ) ; int (*scan_commit_lists)(struct nfs_commit_info * , int ) ; void (*recover_commit_reqs)(struct list_head * , struct nfs_commit_info * ) ; int (*commit_pagelist)(struct inode * , struct list_head * , int , struct nfs_commit_info * ) ; enum pnfs_try_status (*read_pagelist)(struct nfs_read_data * ) ; enum pnfs_try_status (*write_pagelist)(struct nfs_write_data * , int ) ; void (*free_deviceid_node)(struct nfs4_deviceid_node * ) ; void (*encode_layoutreturn)(struct pnfs_layout_hdr * , struct xdr_stream * , struct nfs4_layoutreturn_args const * ) ; void (*cleanup_layoutcommit)(struct nfs4_layoutcommit_data * ) ; void (*encode_layoutcommit)(struct pnfs_layout_hdr * , struct xdr_stream * , struct nfs4_layoutcommit_args const * ) ; }; struct pnfs_layout_hdr { atomic_t plh_refcount ; struct list_head plh_layouts ; struct list_head plh_bulk_destroy ; struct list_head plh_segs ; nfs4_stateid plh_stateid ; atomic_t plh_outstanding ; unsigned long plh_block_lgets ; u32 plh_barrier ; unsigned long plh_retry_timestamp ; unsigned long plh_flags ; loff_t plh_lwb ; struct rpc_cred *plh_lc_cred ; struct inode *plh_inode ; }; struct nfs4_deviceid_node { struct hlist_node node ; struct hlist_node tmpnode ; struct pnfs_layoutdriver_type const *ld ; struct nfs_client const *nfs_client ; unsigned long flags ; unsigned long timestamp_unavailable ; struct nfs4_deviceid deviceid ; atomic_t ref ; }; struct nfs_subversion { struct module *owner ; struct file_system_type *nfs_fs ; struct rpc_version const *rpc_vers ; struct nfs_rpc_ops const *rpc_ops ; struct super_operations const *sops ; struct xattr_handler const **xattr ; struct list_head list ; }; struct net_generic { unsigned int len ; struct callback_head rcu ; void *ptr[0U] ; }; struct bl_dev_msg { int32_t status ; uint32_t major ; uint32_t minor ; }; struct nfs_net { struct cache_detail *nfs_dns_resolve ; struct rpc_pipe *bl_device_pipe ; struct bl_dev_msg bl_mount_reply ; wait_queue_head_t bl_wq ; struct list_head nfs_client_list ; struct list_head nfs_volume_list ; struct idr cb_ident_idr ; unsigned short nfs_callback_tcpport ; unsigned short nfs_callback_tcpport6 ; int cb_users[3U] ; spinlock_t nfs_client_lock ; struct timespec boot_time ; }; struct paravirt_callee_save { void *func ; }; struct pv_irq_ops { struct paravirt_callee_save save_fl ; struct paravirt_callee_save restore_fl ; struct paravirt_callee_save irq_disable ; struct paravirt_callee_save irq_enable ; void (*safe_halt)(void) ; void (*halt)(void) ; void (*adjust_exception_frame)(void) ; }; enum hrtimer_restart; typedef int filler_t(void * , struct page * ); struct nfs_open_dir_context { struct rpc_cred *cred ; unsigned long attr_gencount ; __u64 dir_cookie ; __u64 dup_cookie ; signed char duped ; }; struct nameidata { struct path path ; struct qstr last ; struct path root ; struct inode *inode ; unsigned int flags ; unsigned int seq ; int last_type ; unsigned int depth ; char *saved_names[9U] ; }; struct reclaim_state { unsigned long reclaimed_slab ; }; struct swap_extent { struct list_head list ; unsigned long start_page ; unsigned long nr_pages ; sector_t start_block ; }; struct swap_cluster_info { unsigned int data : 24 ; unsigned char flags ; }; struct percpu_cluster { struct swap_cluster_info index ; unsigned int next ; }; struct swap_info_struct { unsigned long flags ; short prio ; signed char type ; signed char next ; unsigned int max ; unsigned char *swap_map ; struct swap_cluster_info *cluster_info ; struct swap_cluster_info free_cluster_head ; struct swap_cluster_info free_cluster_tail ; unsigned int lowest_bit ; unsigned int highest_bit ; unsigned int pages ; unsigned int inuse_pages ; unsigned int cluster_next ; unsigned int cluster_nr ; struct percpu_cluster *percpu_cluster ; struct swap_extent *curr_swap_extent ; struct swap_extent first_swap_extent ; struct block_device *bdev ; struct file *swap_file ; unsigned int old_block_size ; unsigned long *frontswap_map ; atomic_t frontswap_pages ; spinlock_t lock ; struct work_struct discard_work ; struct swap_cluster_info discard_cluster_head ; struct swap_cluster_info discard_cluster_tail ; }; enum nfs_stat_eventcounters { NFSIOS_INODEREVALIDATE = 0, NFSIOS_DENTRYREVALIDATE = 1, NFSIOS_DATAINVALIDATE = 2, NFSIOS_ATTRINVALIDATE = 3, NFSIOS_VFSOPEN = 4, NFSIOS_VFSLOOKUP = 5, NFSIOS_VFSACCESS = 6, NFSIOS_VFSUPDATEPAGE = 7, NFSIOS_VFSREADPAGE = 8, NFSIOS_VFSREADPAGES = 9, NFSIOS_VFSWRITEPAGE = 10, NFSIOS_VFSWRITEPAGES = 11, NFSIOS_VFSGETDENTS = 12, NFSIOS_VFSSETATTR = 13, NFSIOS_VFSFLUSH = 14, NFSIOS_VFSFSYNC = 15, NFSIOS_VFSLOCK = 16, NFSIOS_VFSRELEASE = 17, NFSIOS_CONGESTIONWAIT = 18, NFSIOS_SETATTRTRUNC = 19, NFSIOS_EXTENDWRITE = 20, NFSIOS_SILLYRENAME = 21, NFSIOS_SHORTREAD = 22, NFSIOS_SHORTWRITE = 23, NFSIOS_DELAY = 24, NFSIOS_PNFS_READ = 25, NFSIOS_PNFS_WRITE = 26, __NFSIOS_COUNTSMAX = 27 } ; typedef unsigned long pao_T_____35; typedef unsigned long pao_T_____36; typedef unsigned long pao_T_____37; typedef unsigned long pao_T_____38; struct nfs_cache_array_entry { u64 cookie ; u64 ino ; struct qstr string ; unsigned char d_type ; }; struct nfs_cache_array { int size ; int eof_index ; u64 last_cookie ; struct nfs_cache_array_entry array[0U] ; }; struct __anonstruct_nfs_readdir_descriptor_t_281 { struct file *file ; struct page *page ; struct dir_context *ctx ; unsigned long page_index ; u64 *dir_cookie ; u64 last_cookie ; loff_t current_index ; int (*decode)(struct xdr_stream * , struct nfs_entry * , int ) ; unsigned long timestamp ; unsigned long gencount ; unsigned int cache_entry_index ; unsigned char plus : 1 ; unsigned char eof : 1 ; }; typedef struct __anonstruct_nfs_readdir_descriptor_t_281 nfs_readdir_descriptor_t; enum hrtimer_restart; enum nfs_stat_bytecounters { NFSIOS_NORMALREADBYTES = 0, NFSIOS_NORMALWRITTENBYTES = 1, NFSIOS_DIRECTREADBYTES = 2, NFSIOS_DIRECTWRITTENBYTES = 3, NFSIOS_SERVERREADBYTES = 4, NFSIOS_SERVERWRITTENBYTES = 5, NFSIOS_READPAGES = 6, NFSIOS_WRITEPAGES = 7, __NFSIOS_BYTESMAX = 8 } ; typedef unsigned long long pao_T_____39; typedef unsigned long long pao_T_____40; typedef unsigned long long pao_T_____41; typedef unsigned long long pao_T_____42; enum hrtimer_restart; typedef __kernel_ulong_t __kernel_ino_t; typedef __kernel_ino_t ino_t; enum hrtimer_restart; typedef u32 compat_ulong_t; struct pernet_operations { struct list_head list ; int (*init)(struct net * ) ; void (*exit)(struct net * ) ; void (*exit_batch)(struct list_head * ) ; int *id ; size_t size ; }; struct nfs_find_desc { struct nfs_fh *fh ; struct nfs_fattr *fattr ; }; enum hrtimer_restart; struct nfs2_fh { char data[32U] ; }; struct nfs3_fh { unsigned short size ; unsigned char data[64U] ; }; struct nfs4_sessionid { unsigned char data[16U] ; }; struct nfs4_channel_attrs { u32 max_rqst_sz ; u32 max_resp_sz ; u32 max_resp_sz_cached ; u32 max_ops ; u32 max_reqs ; }; struct nfs_mount_data { int version ; int fd ; struct nfs2_fh old_root ; int flags ; int rsize ; int wsize ; int timeo ; int retrans ; int acregmin ; int acregmax ; int acdirmin ; int acdirmax ; struct sockaddr_in addr ; char hostname[256U] ; int namlen ; unsigned int bsize ; struct nfs3_fh root ; int pseudoflavor ; char context[257U] ; }; struct nfs_string { unsigned int len ; char const *data ; }; struct nfs4_mount_data { int version ; int flags ; int rsize ; int wsize ; int timeo ; int retrans ; int acregmin ; int acregmax ; int acdirmin ; int acdirmax ; struct nfs_string client_addr ; struct nfs_string mnt_path ; struct nfs_string hostname ; unsigned int host_addrlen ; struct sockaddr *host_addr ; int proto ; int auth_flavourlen ; int *auth_flavours ; }; struct match_token { int token ; char const *pattern ; }; struct __anonstruct_substring_t_271 { char *from ; char *to ; }; typedef struct __anonstruct_substring_t_271 substring_t; struct nfs_mount_request { struct sockaddr *sap ; size_t salen ; char *hostname ; char *dirpath ; u32 version ; unsigned short protocol ; struct nfs_fh *fh ; int noresvport ; unsigned int *auth_flav_len ; rpc_authflavor_t *auth_flavs ; struct net *net ; }; struct nfs4_slot { struct nfs4_slot_table *table ; struct nfs4_slot *next ; unsigned long generation ; u32 slot_nr ; u32 seq_nr ; unsigned char interrupted : 1 ; }; struct nfs4_slot_table { struct nfs4_session *session ; struct nfs4_slot *slots ; unsigned long used_slots[16U] ; spinlock_t slot_tbl_lock ; struct rpc_wait_queue slot_tbl_waitq ; u32 max_slots ; u32 max_slotid ; u32 highest_used_slotid ; u32 target_highest_slotid ; u32 server_highest_slotid ; s32 d_target_highest_slotid ; s32 d2_target_highest_slotid ; unsigned long generation ; struct completion complete ; unsigned long slot_tbl_state ; }; struct nfs4_session { struct nfs4_sessionid sess_id ; u32 flags ; unsigned long session_state ; u32 hash_alg ; u32 ssv_len ; struct nfs4_channel_attrs fc_attrs ; struct nfs4_slot_table fc_slot_table ; struct nfs4_channel_attrs bc_attrs ; struct nfs4_slot_table bc_slot_table ; struct nfs_client *clp ; }; struct __anonstruct_sec_flavours_283 { rpc_authflavor_t flavour ; char const *str ; }; struct proc_nfs_info { int flag ; char const *str ; char const *nostr ; }; struct nfs_sb_mountdata { struct nfs_server *server ; int mntflags ; }; enum hrtimer_restart; struct nfs_direct_req { struct kref kref ; struct nfs_open_context *ctx ; struct nfs_lock_context *l_ctx ; struct kiocb *iocb ; struct inode *inode ; atomic_t io_count ; spinlock_t lock ; ssize_t count ; ssize_t bytes_left ; ssize_t error ; struct completion completion ; struct nfs_mds_commit_info mds_cinfo ; struct pnfs_ds_commit_info ds_cinfo ; struct work_struct work ; int flags ; struct nfs_writeverf verf ; }; struct wait_bit_key { void *flags ; int bit_nr ; }; struct wait_bit_queue { struct wait_bit_key key ; wait_queue_t wait ; }; enum hrtimer_restart; enum hrtimer_restart; struct rpc_task_setup { struct rpc_task *task ; struct rpc_clnt *rpc_client ; struct rpc_message const *rpc_message ; struct rpc_call_ops const *callback_ops ; void *callback_data ; struct workqueue_struct *workqueue ; unsigned short flags ; signed char priority ; }; struct nfs_read_header { struct nfs_pgio_header header ; struct nfs_read_data rpc_data ; }; struct nfs_readdesc { struct nfs_pageio_descriptor *pgio ; struct nfs_open_context *ctx ; }; enum hrtimer_restart; enum hrtimer_restart; enum zone_stat_item { NR_FREE_PAGES = 0, NR_ALLOC_BATCH = 1, NR_LRU_BASE = 2, NR_INACTIVE_ANON = 2, NR_ACTIVE_ANON = 3, NR_INACTIVE_FILE = 4, NR_ACTIVE_FILE = 5, NR_UNEVICTABLE = 6, NR_MLOCK = 7, NR_ANON_PAGES = 8, NR_FILE_MAPPED = 9, NR_FILE_PAGES = 10, NR_FILE_DIRTY = 11, NR_WRITEBACK = 12, NR_SLAB_RECLAIMABLE = 13, NR_SLAB_UNRECLAIMABLE = 14, NR_PAGETABLE = 15, NR_KERNEL_STACK = 16, NR_UNSTABLE_NFS = 17, NR_BOUNCE = 18, NR_VMSCAN_WRITE = 19, NR_VMSCAN_IMMEDIATE = 20, NR_WRITEBACK_TEMP = 21, NR_ISOLATED_ANON = 22, NR_ISOLATED_FILE = 23, NR_SHMEM = 24, NR_DIRTIED = 25, NR_WRITTEN = 26, NUMA_HIT = 27, NUMA_MISS = 28, NUMA_FOREIGN = 29, NUMA_INTERLEAVE_HIT = 30, NUMA_LOCAL = 31, NUMA_OTHER = 32, NR_ANON_TRANSPARENT_HUGEPAGES = 33, NR_FREE_CMA_PAGES = 34, NR_VM_ZONE_STAT_ITEMS = 35 } ; enum hrtimer_restart; union __anonunion_v_187 { short preferred_node ; nodemask_t nodes ; }; union __anonunion_w_188 { nodemask_t cpuset_mems_allowed ; nodemask_t user_nodemask ; }; struct mempolicy { atomic_t refcnt ; unsigned short mode ; unsigned short flags ; union __anonunion_v_187 v ; union __anonunion_w_188 w ; }; struct nfs_write_header { struct nfs_pgio_header header ; struct nfs_write_data rpc_data ; struct nfs_writeverf verf ; }; enum bdi_stat_item { BDI_RECLAIMABLE = 0, BDI_WRITEBACK = 1, BDI_DIRTIED = 2, BDI_WRITTEN = 3, NR_BDI_STAT_ITEMS = 4 } ; typedef void *mempool_alloc_t(gfp_t , void * ); typedef void mempool_free_t(void * , void * ); struct mempool_s { spinlock_t lock ; int min_nr ; int curr_nr ; void **elements ; void *pool_data ; mempool_alloc_t *alloc ; mempool_free_t *free ; wait_queue_head_t wait ; }; typedef struct mempool_s mempool_t; enum hrtimer_restart; enum hrtimer_restart; struct __anonstruct_mnt_errtbl_274 { u32 status ; int errno ; }; struct __anonstruct_mnt3_errtbl_275 { u32 status ; int errno ; }; struct mountres { int errno ; struct nfs_fh *fh ; unsigned int *auth_count ; rpc_authflavor_t *auth_flavors ; }; enum hrtimer_restart; struct ring_buffer; struct ring_buffer_iter; struct trace_seq; struct trace_seq { unsigned char buffer[4096U] ; unsigned int len ; unsigned int readpos ; int full ; }; union __anonunion_ldv_52963_274 { __u64 sample_period ; __u64 sample_freq ; }; union __anonunion_ldv_52993_275 { __u32 wakeup_events ; __u32 wakeup_watermark ; }; union __anonunion_ldv_52998_276 { __u64 bp_addr ; __u64 config1 ; }; union __anonunion_ldv_53002_277 { __u64 bp_len ; __u64 config2 ; }; struct perf_event_attr { __u32 type ; __u32 size ; __u64 config ; union __anonunion_ldv_52963_274 ldv_52963 ; __u64 sample_type ; __u64 read_format ; unsigned char disabled : 1 ; unsigned char inherit : 1 ; unsigned char pinned : 1 ; unsigned char exclusive : 1 ; unsigned char exclude_user : 1 ; unsigned char exclude_kernel : 1 ; unsigned char exclude_hv : 1 ; unsigned char exclude_idle : 1 ; unsigned char mmap : 1 ; unsigned char comm : 1 ; unsigned char freq : 1 ; unsigned char inherit_stat : 1 ; unsigned char enable_on_exec : 1 ; unsigned char task : 1 ; unsigned char watermark : 1 ; unsigned char precise_ip : 2 ; unsigned char mmap_data : 1 ; unsigned char sample_id_all : 1 ; unsigned char exclude_host : 1 ; unsigned char exclude_guest : 1 ; unsigned char exclude_callchain_kernel : 1 ; unsigned char exclude_callchain_user : 1 ; unsigned char mmap2 : 1 ; unsigned long __reserved_1 : 40 ; union __anonunion_ldv_52993_275 ldv_52993 ; __u32 bp_type ; union __anonunion_ldv_52998_276 ldv_52998 ; union __anonunion_ldv_53002_277 ldv_53002 ; __u64 branch_sample_type ; __u64 sample_regs_user ; __u32 sample_stack_user ; __u32 __reserved_2 ; }; struct __anonstruct_ldv_53067_280 { unsigned char mem_op : 5 ; unsigned short mem_lvl : 14 ; unsigned char mem_snoop : 5 ; unsigned char mem_lock : 2 ; unsigned char mem_dtlb : 7 ; unsigned int mem_rsvd : 31 ; }; union perf_mem_data_src { __u64 val ; struct __anonstruct_ldv_53067_280 ldv_53067 ; }; struct perf_branch_entry { __u64 from ; __u64 to ; unsigned char mispred : 1 ; unsigned char predicted : 1 ; unsigned char in_tx : 1 ; unsigned char abort : 1 ; unsigned long reserved : 60 ; }; struct __anonstruct_local_t_284 { atomic_long_t a ; }; typedef struct __anonstruct_local_t_284 local_t; struct __anonstruct_local64_t_285 { local_t a ; }; typedef struct __anonstruct_local64_t_285 local64_t; struct arch_hw_breakpoint { unsigned long address ; u8 len ; u8 type ; }; struct pmu; struct ftrace_hash; struct ftrace_ops; struct ftrace_ops { void (*func)(unsigned long , unsigned long , struct ftrace_ops * , struct pt_regs * ) ; struct ftrace_ops *next ; unsigned long flags ; int *disabled ; struct ftrace_hash *notrace_hash ; struct ftrace_hash *filter_hash ; struct mutex regex_lock ; }; struct ftrace_ret_stack { unsigned long ret ; unsigned long func ; unsigned long long calltime ; unsigned long long subtime ; unsigned long fp ; }; struct irq_work { unsigned long flags ; struct llist_node llnode ; void (*func)(struct irq_work * ) ; }; struct perf_callchain_entry { __u64 nr ; __u64 ip[127U] ; }; struct perf_raw_record { u32 size ; void *data ; }; struct perf_branch_stack { __u64 nr ; struct perf_branch_entry entries[0U] ; }; struct perf_regs_user { __u64 abi ; struct pt_regs *regs ; }; struct hw_perf_event_extra { u64 config ; unsigned int reg ; int alloc ; int idx ; }; struct event_constraint; struct __anonstruct_ldv_54184_288 { u64 config ; u64 last_tag ; unsigned long config_base ; unsigned long event_base ; int event_base_rdpmc ; int idx ; int last_cpu ; int flags ; struct hw_perf_event_extra extra_reg ; struct hw_perf_event_extra branch_reg ; struct event_constraint *constraint ; }; struct __anonstruct_ldv_54187_289 { struct hrtimer hrtimer ; }; struct __anonstruct_ldv_54191_290 { struct task_struct *tp_target ; struct list_head tp_list ; }; struct __anonstruct_ldv_54196_291 { struct task_struct *bp_target ; struct arch_hw_breakpoint info ; struct list_head bp_list ; }; union __anonunion_ldv_54197_287 { struct __anonstruct_ldv_54184_288 ldv_54184 ; struct __anonstruct_ldv_54187_289 ldv_54187 ; struct __anonstruct_ldv_54191_290 ldv_54191 ; struct __anonstruct_ldv_54196_291 ldv_54196 ; }; struct hw_perf_event { union __anonunion_ldv_54197_287 ldv_54197 ; int state ; local64_t prev_count ; u64 sample_period ; u64 last_period ; local64_t period_left ; u64 interrupts_seq ; u64 interrupts ; u64 freq_time_stamp ; u64 freq_count_stamp ; }; struct perf_cpu_context; struct pmu { struct list_head entry ; struct device *dev ; struct attribute_group const **attr_groups ; char const *name ; int type ; int *pmu_disable_count ; struct perf_cpu_context *pmu_cpu_context ; int task_ctx_nr ; int hrtimer_interval_ms ; void (*pmu_enable)(struct pmu * ) ; void (*pmu_disable)(struct pmu * ) ; int (*event_init)(struct perf_event * ) ; int (*add)(struct perf_event * , int ) ; void (*del)(struct perf_event * , int ) ; void (*start)(struct perf_event * , int ) ; void (*stop)(struct perf_event * , int ) ; void (*read)(struct perf_event * ) ; void (*start_txn)(struct pmu * ) ; int (*commit_txn)(struct pmu * ) ; void (*cancel_txn)(struct pmu * ) ; int (*event_idx)(struct perf_event * ) ; void (*flush_branch_stack)(void) ; }; enum perf_event_active_state { PERF_EVENT_STATE_ERROR = -2, PERF_EVENT_STATE_OFF = -1, PERF_EVENT_STATE_INACTIVE = 0, PERF_EVENT_STATE_ACTIVE = 1 } ; struct perf_sample_data; struct perf_cgroup; struct event_filter; struct perf_event { struct list_head group_entry ; struct list_head event_entry ; struct list_head sibling_list ; struct hlist_node hlist_entry ; int nr_siblings ; int group_flags ; struct perf_event *group_leader ; struct pmu *pmu ; enum perf_event_active_state state ; unsigned int attach_state ; local64_t count ; atomic64_t child_count ; u64 total_time_enabled ; u64 total_time_running ; u64 tstamp_enabled ; u64 tstamp_running ; u64 tstamp_stopped ; u64 shadow_ctx_time ; struct perf_event_attr attr ; u16 header_size ; u16 id_header_size ; u16 read_size ; struct hw_perf_event hw ; struct perf_event_context *ctx ; atomic_long_t refcount ; atomic64_t child_total_time_enabled ; atomic64_t child_total_time_running ; struct mutex child_mutex ; struct list_head child_list ; struct perf_event *parent ; int oncpu ; int cpu ; struct list_head owner_entry ; struct task_struct *owner ; struct mutex mmap_mutex ; atomic_t mmap_count ; struct ring_buffer *rb ; struct list_head rb_entry ; wait_queue_head_t waitq ; struct fasync_struct *fasync ; int pending_wakeup ; int pending_kill ; int pending_disable ; struct irq_work pending ; atomic_t event_limit ; void (*destroy)(struct perf_event * ) ; struct callback_head callback_head ; struct pid_namespace *ns ; u64 id ; void (*overflow_handler)(struct perf_event * , struct perf_sample_data * , struct pt_regs * ) ; void *overflow_handler_context ; struct ftrace_event_call *tp_event ; struct event_filter *filter ; struct ftrace_ops ftrace_ops ; struct perf_cgroup *cgrp ; int cgrp_defer_enabled ; }; enum perf_event_context_type { task_context = 0, cpu_context = 1 } ; struct perf_event_context { struct pmu *pmu ; enum perf_event_context_type type ; raw_spinlock_t lock ; struct mutex mutex ; struct list_head pinned_groups ; struct list_head flexible_groups ; struct list_head event_list ; int nr_events ; int nr_active ; int is_active ; int nr_stat ; int nr_freq ; int rotate_disable ; atomic_t refcount ; struct task_struct *task ; u64 time ; u64 timestamp ; struct perf_event_context *parent_ctx ; u64 parent_gen ; u64 generation ; int pin_count ; int nr_cgroups ; int nr_branch_stack ; struct callback_head callback_head ; }; struct perf_cpu_context { struct perf_event_context ctx ; struct perf_event_context *task_ctx ; int active_oncpu ; int exclusive ; struct hrtimer hrtimer ; ktime_t hrtimer_interval ; struct list_head rotation_list ; struct pmu *unique_pmu ; struct perf_cgroup *cgrp ; }; struct __anonstruct_tid_entry_292 { u32 pid ; u32 tid ; }; struct __anonstruct_cpu_entry_293 { u32 cpu ; u32 reserved ; }; struct perf_sample_data { u64 type ; u64 ip ; struct __anonstruct_tid_entry_292 tid_entry ; u64 time ; u64 addr ; u64 id ; u64 stream_id ; struct __anonstruct_cpu_entry_293 cpu_entry ; u64 period ; union perf_mem_data_src data_src ; struct perf_callchain_entry *callchain ; struct perf_raw_record *raw ; struct perf_branch_stack *br_stack ; struct perf_regs_user regs_user ; u64 stack_user_size ; u64 weight ; }; struct trace_array; struct trace_buffer; struct tracer; struct trace_print_flags { unsigned long mask ; char const *name ; }; struct trace_iterator; struct trace_event; struct trace_entry { unsigned short type ; unsigned char flags ; unsigned char preempt_count ; int pid ; }; struct trace_iterator { struct trace_array *tr ; struct tracer *trace ; struct trace_buffer *trace_buffer ; void *private ; int cpu_file ; struct mutex mutex ; struct ring_buffer_iter **buffer_iter ; unsigned long iter_flags ; struct trace_seq tmp_seq ; cpumask_var_t started ; bool snapshot ; struct trace_seq seq ; struct trace_entry *ent ; unsigned long lost_events ; int leftover ; int ent_size ; int cpu ; u64 ts ; loff_t pos ; long idx ; }; enum print_line_t; struct trace_event_functions { enum print_line_t (*trace)(struct trace_iterator * , int , struct trace_event * ) ; enum print_line_t (*raw)(struct trace_iterator * , int , struct trace_event * ) ; enum print_line_t (*hex)(struct trace_iterator * , int , struct trace_event * ) ; enum print_line_t (*binary)(struct trace_iterator * , int , struct trace_event * ) ; }; struct trace_event { struct hlist_node node ; struct list_head list ; int type ; struct trace_event_functions *funcs ; }; enum print_line_t { TRACE_TYPE_PARTIAL_LINE = 0, TRACE_TYPE_HANDLED = 1, TRACE_TYPE_UNHANDLED = 2, TRACE_TYPE_NO_CONSUME = 3 } ; enum trace_reg { TRACE_REG_REGISTER = 0, TRACE_REG_UNREGISTER = 1, TRACE_REG_PERF_REGISTER = 2, TRACE_REG_PERF_UNREGISTER = 3, TRACE_REG_PERF_OPEN = 4, TRACE_REG_PERF_CLOSE = 5, TRACE_REG_PERF_ADD = 6, TRACE_REG_PERF_DEL = 7 } ; struct ftrace_event_class { char *system ; void *probe ; void *perf_probe ; int (*reg)(struct ftrace_event_call * , enum trace_reg , void * ) ; int (*define_fields)(struct ftrace_event_call * ) ; struct list_head *(*get_fields)(struct ftrace_event_call * ) ; struct list_head fields ; int (*raw_init)(struct ftrace_event_call * ) ; }; struct ftrace_event_call { struct list_head list ; struct ftrace_event_class *class ; char *name ; struct trace_event event ; char const *print_fmt ; struct event_filter *filter ; struct list_head *files ; void *mod ; void *data ; int flags ; int perf_refcount ; struct hlist_head *perf_events ; }; struct ftrace_raw_nfs_inode_event { struct trace_entry ent ; dev_t dev ; u32 fhandle ; u64 fileid ; u64 version ; char __data[0U] ; }; struct ftrace_raw_nfs_inode_event_done { struct trace_entry ent ; int error ; dev_t dev ; u32 fhandle ; unsigned char type ; u64 fileid ; u64 version ; loff_t size ; unsigned long nfsi_flags ; unsigned long cache_validity ; char __data[0U] ; }; struct ftrace_raw_nfs_lookup_event { struct trace_entry ent ; unsigned int flags ; dev_t dev ; u64 dir ; u32 __data_loc_name ; char __data[0U] ; }; struct ftrace_raw_nfs_lookup_event_done { struct trace_entry ent ; int error ; unsigned int flags ; dev_t dev ; u64 dir ; u32 __data_loc_name ; char __data[0U] ; }; struct ftrace_raw_nfs_atomic_open_enter { struct trace_entry ent ; unsigned int flags ; unsigned int fmode ; dev_t dev ; u64 dir ; u32 __data_loc_name ; char __data[0U] ; }; struct ftrace_raw_nfs_atomic_open_exit { struct trace_entry ent ; int error ; unsigned int flags ; unsigned int fmode ; dev_t dev ; u64 dir ; u32 __data_loc_name ; char __data[0U] ; }; struct ftrace_raw_nfs_create_enter { struct trace_entry ent ; unsigned int flags ; dev_t dev ; u64 dir ; u32 __data_loc_name ; char __data[0U] ; }; struct ftrace_raw_nfs_create_exit { struct trace_entry ent ; int error ; unsigned int flags ; dev_t dev ; u64 dir ; u32 __data_loc_name ; char __data[0U] ; }; struct ftrace_raw_nfs_directory_event { struct trace_entry ent ; dev_t dev ; u64 dir ; u32 __data_loc_name ; char __data[0U] ; }; struct ftrace_raw_nfs_directory_event_done { struct trace_entry ent ; int error ; dev_t dev ; u64 dir ; u32 __data_loc_name ; char __data[0U] ; }; struct ftrace_raw_nfs_link_enter { struct trace_entry ent ; dev_t dev ; u64 fileid ; u64 dir ; u32 __data_loc_name ; char __data[0U] ; }; struct ftrace_raw_nfs_link_exit { struct trace_entry ent ; int error ; dev_t dev ; u64 fileid ; u64 dir ; u32 __data_loc_name ; char __data[0U] ; }; struct ftrace_raw_nfs_rename_event { struct trace_entry ent ; dev_t dev ; u64 old_dir ; u64 new_dir ; u32 __data_loc_old_name ; u32 __data_loc_new_name ; char __data[0U] ; }; struct ftrace_raw_nfs_rename_event_done { struct trace_entry ent ; dev_t dev ; int error ; u64 old_dir ; u32 __data_loc_old_name ; u64 new_dir ; u32 __data_loc_new_name ; char __data[0U] ; }; struct ftrace_raw_nfs_sillyrename_unlink { struct trace_entry ent ; dev_t dev ; int error ; u64 dir ; u32 __data_loc_name ; char __data[0U] ; }; enum hrtimer_restart; typedef struct ctl_table ctl_table; typedef __u16 uint16_t; enum hrtimer_restart; enum nfs_stat_fscachecounters { NFSIOS_FSCACHE_PAGES_READ_OK = 0, NFSIOS_FSCACHE_PAGES_READ_FAIL = 1, NFSIOS_FSCACHE_PAGES_WRITTEN_OK = 2, NFSIOS_FSCACHE_PAGES_WRITTEN_FAIL = 3, NFSIOS_FSCACHE_PAGES_UNCACHED = 4, __NFSIOS_FSCACHEMAX = 5 } ; typedef unsigned long long pao_T_____43; typedef unsigned long long pao_T_____44; typedef unsigned long long pao_T_____45; typedef unsigned long long pao_T_____46; struct fscache_cache_tag; struct fscache_netfs; enum fscache_checkaux { FSCACHE_CHECKAUX_OKAY = 0, FSCACHE_CHECKAUX_NEEDS_UPDATE = 1, FSCACHE_CHECKAUX_OBSOLETE = 2 } ; struct fscache_cookie_def { char name[16U] ; uint8_t type ; struct fscache_cache_tag *(*select_cache)(void const * , void const * ) ; uint16_t (*get_key)(void const * , void * , uint16_t ) ; void (*get_attr)(void const * , uint64_t * ) ; uint16_t (*get_aux)(void const * , void * , uint16_t ) ; enum fscache_checkaux (*check_aux)(void * , void const * , uint16_t ) ; void (*get_context)(void * , void * ) ; void (*put_context)(void * , void * ) ; void (*mark_page_cached)(void * , struct address_space * , struct page * ) ; void (*now_uncached)(void * ) ; }; struct fscache_netfs { uint32_t version ; char const *name ; struct fscache_cookie *primary_index ; struct list_head link ; }; enum hrtimer_restart; struct pagevec { unsigned long nr ; unsigned long cold ; struct page *pages[14U] ; }; union __anonunion_addr_278 { struct in_addr ipv4_addr ; struct in6_addr ipv6_addr ; }; struct nfs_server_key { uint16_t nfsversion ; uint16_t family ; uint16_t port ; union __anonunion_addr_278 addr[0U] ; }; struct nfs_fscache_inode_auxdata { struct timespec mtime ; struct timespec ctime ; loff_t size ; u64 change_attr ; }; long ldv__builtin_expect(long exp , long c ) ; __inline static void INIT_LIST_HEAD(struct list_head *list ) { { list->next = list; list->prev = list; return; } } extern void __list_add(struct list_head * , struct list_head * , struct list_head * ) ; __inline static void list_add(struct list_head *new , struct list_head *head ) { { __list_add(new, head, head->next); return; } } __inline static void list_add_tail(struct list_head *new , struct list_head *head ) { { __list_add(new, head->prev, head); return; } } extern void __list_del_entry(struct list_head * ) ; extern void list_del(struct list_head * ) ; __inline static int list_empty(struct list_head const *head ) { { return ((unsigned long )((struct list_head const *)head->next) == (unsigned long )head); } } extern struct module __this_module ; __inline static void set_bit(long nr , unsigned long volatile *addr ) { { __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; bts %1,%0": "+m" (*((long volatile *)addr)): "Ir" (nr): "memory"); return; } } __inline static void clear_bit(long nr , unsigned long volatile *addr ) { { __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; btr %1,%0": "+m" (*((long volatile *)addr)): "Ir" (nr)); return; } } __inline static int constant_test_bit(long nr , unsigned long const volatile *addr ) { { return ((int )((unsigned long )*(addr + (unsigned long )(nr >> 6)) >> ((int )nr & 63)) & 1); } } __inline static int variable_test_bit(long nr , unsigned long const volatile *addr ) { int oldbit ; { __asm__ volatile ("bt %2,%1\n\tsbb %0,%0": "=r" (oldbit): "m" (*((unsigned long *)addr)), "Ir" (nr)); return (oldbit); } } extern int printk(char const * , ...) ; extern int snprintf(char * , size_t , char const * , ...) ; extern void warn_slowpath_null(char const * , int const ) ; extern void __bad_percpu_size(void) ; extern struct task_struct *current_task ; __inline static struct task_struct *get_current(void) { struct task_struct *pfo_ret__ ; { switch (8UL) { case 1UL: __asm__ ("movb %%gs:%P1,%0": "=q" (pfo_ret__): "p" (& current_task)); goto ldv_3023; case 2UL: __asm__ ("movw %%gs:%P1,%0": "=r" (pfo_ret__): "p" (& current_task)); goto ldv_3023; case 4UL: __asm__ ("movl %%gs:%P1,%0": "=r" (pfo_ret__): "p" (& current_task)); goto ldv_3023; case 8UL: __asm__ ("movq %%gs:%P1,%0": "=r" (pfo_ret__): "p" (& current_task)); goto ldv_3023; default: __bad_percpu_size(); } ldv_3023: ; return (pfo_ret__); } } extern void *__memcpy(void * , void const * , size_t ) ; extern char *kstrdup(char const * , gfp_t ) ; __inline static void *ERR_PTR(long error ) { { return ((void *)error); } } __inline static long PTR_ERR(void const *ptr ) { { return ((long )ptr); } } __inline static long IS_ERR(void const *ptr ) { long tmp ; { tmp = ldv__builtin_expect((unsigned long )ptr > 0xfffffffffffff000UL, 0L); return (tmp); } } __inline static int atomic_read(atomic_t const *v ) { { return ((int )*((int volatile *)(& v->counter))); } } __inline static void atomic_set(atomic_t *v , int i ) { { v->counter = i; return; } } __inline static void atomic_inc(atomic_t *v ) { { __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; incl %0": "+m" (v->counter)); return; } } __inline static int atomic_dec_and_test(atomic_t *v ) { unsigned char c ; { __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; decl %0; sete %1": "+m" (v->counter), "=qm" (c): : "memory"); return ((unsigned int )c != 0U); } } extern unsigned long kernel_stack ; __inline static struct thread_info *current_thread_info(void) { struct thread_info *ti ; unsigned long pfo_ret__ ; { switch (8UL) { case 1UL: __asm__ ("movb %%gs:%P1,%0": "=q" (pfo_ret__): "p" (& kernel_stack)); goto ldv_5844; case 2UL: __asm__ ("movw %%gs:%P1,%0": "=r" (pfo_ret__): "p" (& kernel_stack)); goto ldv_5844; case 4UL: __asm__ ("movl %%gs:%P1,%0": "=r" (pfo_ret__): "p" (& kernel_stack)); goto ldv_5844; case 8UL: __asm__ ("movq %%gs:%P1,%0": "=r" (pfo_ret__): "p" (& kernel_stack)); goto ldv_5844; default: __bad_percpu_size(); } ldv_5844: ti = (struct thread_info *)(pfo_ret__ - 8152UL); return (ti); } } __inline static int test_ti_thread_flag(struct thread_info *ti , int flag ) { int tmp ; { tmp = variable_test_bit((long )flag, (unsigned long const volatile *)(& ti->flags)); return (tmp); } } extern void lock_acquire(struct lockdep_map * , unsigned int , int , int , int , struct lockdep_map * , unsigned long ) ; extern void lock_release(struct lockdep_map * , int , unsigned long ) ; extern int lock_is_held(struct lockdep_map * ) ; extern void lockdep_rcu_suspicious(char const * , int const , char const * ) ; extern void __raw_spin_lock_init(raw_spinlock_t * , char const * , struct lock_class_key * ) ; extern void _raw_spin_lock(raw_spinlock_t * ) ; extern void _raw_spin_unlock(raw_spinlock_t * ) ; __inline static raw_spinlock_t *spinlock_check(spinlock_t *lock ) { { return (& lock->ldv_6140.rlock); } } __inline static void spin_lock(spinlock_t *lock ) { { _raw_spin_lock(& lock->ldv_6140.rlock); return; } } __inline static void spin_unlock(spinlock_t *lock ) { { _raw_spin_unlock(& lock->ldv_6140.rlock); return; } } extern int _atomic_dec_and_lock(atomic_t * , spinlock_t * ) ; extern struct timespec current_kernel_time(void) ; extern void __wake_up(wait_queue_head_t * , unsigned int , int , void * ) ; extern void prepare_to_wait(wait_queue_head_t * , wait_queue_t * , int ) ; extern void finish_wait(wait_queue_head_t * , wait_queue_t * ) ; extern int autoremove_wake_function(wait_queue_t * , unsigned int , int , void * ) ; extern void mutex_lock_nested(struct mutex * , unsigned int ) ; extern void mutex_unlock(struct mutex * ) ; extern void synchronize_sched(void) ; __inline static void __rcu_read_lock(void) { struct thread_info *tmp ; { tmp = current_thread_info(); tmp->preempt_count = tmp->preempt_count + 1; __asm__ volatile ("": : : "memory"); return; } } __inline static void __rcu_read_unlock(void) { struct thread_info *tmp ; { __asm__ volatile ("": : : "memory"); tmp = current_thread_info(); tmp->preempt_count = tmp->preempt_count + -1; __asm__ volatile ("": : : "memory"); return; } } __inline static void synchronize_rcu(void) { { synchronize_sched(); return; } } extern int rcu_is_cpu_idle(void) ; extern bool rcu_lockdep_current_cpu_online(void) ; __inline static void rcu_lock_acquire(struct lockdep_map *map ) { { lock_acquire(map, 0U, 0, 2, 1, (struct lockdep_map *)0, (unsigned long )((void *)0)); return; } } __inline static void rcu_lock_release(struct lockdep_map *map ) { { lock_release(map, 1, (unsigned long )((void *)0)); return; } } extern struct lockdep_map rcu_lock_map ; extern int debug_lockdep_rcu_enabled(void) ; __inline static int rcu_read_lock_held(void) { int tmp ; int tmp___0 ; bool tmp___1 ; int tmp___2 ; int tmp___3 ; { tmp = debug_lockdep_rcu_enabled(); if (tmp == 0) { return (1); } else { } tmp___0 = rcu_is_cpu_idle(); if (tmp___0 != 0) { return (0); } else { } tmp___1 = rcu_lockdep_current_cpu_online(); if (tmp___1) { tmp___2 = 0; } else { tmp___2 = 1; } if (tmp___2) { return (0); } else { } tmp___3 = lock_is_held(& rcu_lock_map); return (tmp___3); } } __inline static void rcu_read_lock(void) { bool __warned ; int tmp ; int tmp___0 ; { __rcu_read_lock(); rcu_lock_acquire(& rcu_lock_map); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_is_cpu_idle(); if (tmp___0 != 0) { __warned = 1; lockdep_rcu_suspicious("include/linux/rcupdate.h", 775, "rcu_read_lock() used illegally while idle"); } else { } } else { } return; } } __inline static void rcu_read_unlock(void) { bool __warned ; int tmp ; int tmp___0 ; { tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_is_cpu_idle(); if (tmp___0 != 0) { __warned = 1; lockdep_rcu_suspicious("include/linux/rcupdate.h", 796, "rcu_read_unlock() used illegally while idle"); } else { } } else { } rcu_lock_release(& rcu_lock_map); __rcu_read_unlock(); return; } } extern unsigned long volatile jiffies ; extern void *__alloc_percpu(size_t , size_t ) ; extern void free_percpu(void * ) ; extern int __request_module(bool , char const * , ...) ; bool ldv_try_module_get_7(struct module *ldv_func_arg1 ) ; bool ldv_try_module_get_9(struct module *ldv_func_arg1 ) ; void ldv_module_put_8(struct module *ldv_func_arg1 ) ; int ldv_try_module_get(struct module *module ) ; void ldv_module_put(struct module *module ) ; extern void kfree(void const * ) ; extern void *__kmalloc(size_t , gfp_t ) ; __inline static void *kmalloc(size_t size , gfp_t flags ) { void *tmp___2 ; { tmp___2 = __kmalloc(size, flags); return (tmp___2); } } __inline static void *kzalloc(size_t size , gfp_t flags ) { void *tmp ; { tmp = kmalloc(size, flags | 32768U); return (tmp); } } extern void *malloc(size_t size ) ; extern void *calloc(size_t nmemb , size_t size ) ; extern int __VERIFIER_nondet_int(void) ; extern size_t __VERIFIER_nondet_size_t(void) ; extern loff_t __VERIFIER_nondet_loff_t(void) ; extern unsigned long __VERIFIER_nondet_ulong(void) ; extern void *__VERIFIER_nondet_pointer(void) ; extern void __VERIFIER_assume(int expression ) ; void *ldv_malloc(size_t size ) { void *p ; void *tmp ; int tmp___0 ; { tmp___0 = __VERIFIER_nondet_int(); if (tmp___0 != 0) { return ((void *)0); } else { tmp = malloc(size); p = tmp; __VERIFIER_assume((unsigned long )p != (unsigned long )((void *)0)); return (p); } } } void *ldv_zalloc(size_t size ) { void *p ; void *tmp ; int tmp___0 ; { tmp___0 = __VERIFIER_nondet_int(); if (tmp___0 != 0) { return ((void *)0); } else { tmp = calloc(1UL, size); p = tmp; __VERIFIER_assume((unsigned long )p != (unsigned long )((void *)0)); return (p); } } } int ldv_undef_int(void) { int tmp ; { tmp = __VERIFIER_nondet_int(); return (tmp); } } void *ldv_undef_ptr(void) { void *tmp ; { tmp = __VERIFIER_nondet_pointer(); return (tmp); } } unsigned long ldv_undef_ulong(void) { unsigned long tmp ; { tmp = __VERIFIER_nondet_ulong(); return (tmp); } } __inline static void ldv_error(void) { { ERROR: ; __VERIFIER_error(); } } __inline static void ldv_stop(void) { { LDV_STOP: ; goto LDV_STOP; } } long ldv__builtin_expect(long exp , long c ) { { return (exp); } } void ldv__builtin_trap(void) { { ldv_error(); return; } } struct inode *nfs_server_list_fops_group1 ; struct seq_file *nfs_server_list_ops_group1 ; int ldv_state_variable_73 ; int ref_cnt ; struct seq_file *nfs_volume_list_ops_group1 ; int ldv_state_variable_72 ; struct inode *nfs_volume_list_fops_group1 ; int LDV_IN_INTERRUPT = 1; void *nfs_server_list_ops_group2 ; int ldv_state_variable_74 ; loff_t *nfs_volume_list_ops_group3 ; struct file *nfs_server_list_fops_group2 ; int ldv_state_variable_71 ; loff_t *nfs_server_list_ops_group3 ; struct file *nfs_volume_list_fops_group2 ; void *nfs_volume_list_ops_group2 ; void ldv_file_operations_71(void) ; void ldv_seq_operations_74(void) ; void ldv_seq_operations_72(void) ; void ldv_file_operations_73(void) ; __inline static int sigismember(sigset_t *set , int _sig ) { unsigned long sig ; { sig = (unsigned long )(_sig + -1); return ((int )(set->sig[0] >> (int )sig) & 1); } } extern void __list_add_rcu(struct list_head * , struct list_head * , struct list_head * ) ; __inline static void list_add_tail_rcu(struct list_head *new , struct list_head *head ) { { __list_add_rcu(new, head->prev, head); return; } } __inline static void list_del_rcu(struct list_head *entry ) { { __list_del_entry(entry); entry->prev = (struct list_head *)-2401263026316508672L; return; } } extern void schedule(void) ; __inline static int test_tsk_thread_flag(struct task_struct *tsk , int flag ) { int tmp ; { tmp = test_ti_thread_flag((struct thread_info *)tsk->stack, flag); return (tmp); } } __inline static int signal_pending(struct task_struct *p ) { int tmp ; long tmp___0 ; { tmp = test_tsk_thread_flag(p, 2); tmp___0 = ldv__builtin_expect(tmp != 0, 0L); return ((int )tmp___0); } } __inline static int __fatal_signal_pending(struct task_struct *p ) { int tmp ; long tmp___0 ; { tmp = sigismember(& p->pending.signal, 9); tmp___0 = ldv__builtin_expect(tmp != 0, 0L); return ((int )tmp___0); } } __inline static int fatal_signal_pending(struct task_struct *p ) { int tmp ; int tmp___0 ; int tmp___1 ; { tmp = signal_pending(p); if (tmp != 0) { tmp___0 = __fatal_signal_pending(p); if (tmp___0 != 0) { tmp___1 = 1; } else { tmp___1 = 0; } } else { tmp___1 = 0; } return (tmp___1); } } extern unsigned int nfs_debug ; extern void rpc_init_wait_queue(struct rpc_wait_queue * , char const * ) ; extern struct rpc_cred *rpc_lookup_machine_cred(char const * ) ; extern void put_rpccred(struct rpc_cred * ) ; extern struct proc_dir_entry *proc_mkdir(char const * , struct proc_dir_entry * ) ; extern struct proc_dir_entry *proc_create_data(char const * , umode_t , struct proc_dir_entry * , struct file_operations const * , void * ) ; __inline static struct proc_dir_entry *proc_create(char const *name , umode_t mode , struct proc_dir_entry *parent , struct file_operations const *proc_fops ) { struct proc_dir_entry *tmp ; { tmp = proc_create_data(name, (int )mode, parent, proc_fops, (void *)0); return (tmp); } } extern void remove_proc_entry(char const * , struct proc_dir_entry * ) ; extern int seq_open(struct file * , struct seq_operations const * ) ; extern ssize_t seq_read(struct file * , char * , size_t , loff_t * ) ; extern loff_t seq_lseek(struct file * , loff_t , int ) ; extern int seq_release(struct inode * , struct file * ) ; extern int seq_puts(struct seq_file * , char const * ) ; extern int seq_printf(struct seq_file * , char const * , ...) ; extern struct list_head *seq_list_start_head(struct list_head * , loff_t ) ; extern struct list_head *seq_list_next(void * , struct list_head * , loff_t * ) ; extern void __put_net(struct net * ) ; __inline static struct net *get_net(struct net *net ) { { atomic_inc(& net->count); return (net); } } __inline static void put_net(struct net *net ) { int tmp ; { tmp = atomic_dec_and_test(& net->count); if (tmp != 0) { __put_net(net); } else { } return; } } extern void idr_remove(struct idr * , int ) ; extern void idr_destroy(struct idr * ) ; extern void idr_init(struct idr * ) ; extern void ida_destroy(struct ida * ) ; extern void ida_init(struct ida * ) ; extern int __ipv6_addr_type(struct in6_addr const * ) ; __inline static int ipv6_addr_type(struct in6_addr const *addr ) { int tmp ; { tmp = __ipv6_addr_type(addr); return (tmp & 65535); } } __inline static bool ipv6_addr_equal(struct in6_addr const *a1 , struct in6_addr const *a2 ) { unsigned long const *ul1 ; unsigned long const *ul2 ; { ul1 = (unsigned long const *)a1; ul2 = (unsigned long const *)a2; return ((((unsigned long )*ul1 ^ (unsigned long )*ul2) | ((unsigned long )*(ul1 + 1UL) ^ (unsigned long )*(ul2 + 1UL))) == 0UL); } } extern struct rpc_clnt *rpc_create(struct rpc_create_args * ) ; extern struct rpc_clnt *rpc_clone_client_set_auth(struct rpc_clnt * , rpc_authflavor_t ) ; extern void rpc_shutdown_client(struct rpc_clnt * ) ; extern void rpc_setbufsize(struct rpc_clnt * , unsigned int , unsigned int ) ; extern size_t rpc_max_payload(struct rpc_clnt * ) ; extern char const *rpc_peeraddr2str(struct rpc_clnt * , enum rpc_display_format_t ) ; extern int bdi_init(struct backing_dev_info * ) ; extern void bdi_destroy(struct backing_dev_info * ) ; void nfs_fattr_init(struct nfs_fattr *fattr ) ; struct nfs_fattr *nfs_alloc_fattr(void) ; __inline static void nfs_free_fattr(struct nfs_fattr const *fattr ) { { kfree((void const *)fattr); return; } } void nfs_release_automount_timer(void) ; extern struct nlm_host *nlmclnt_init(struct nlmclnt_initdata const * ) ; extern void nlmclnt_done(struct nlm_host * ) ; __inline static struct nfs_iostats *nfs_alloc_iostats(void) { void *tmp ; { tmp = __alloc_percpu(320UL, 64UL); return ((struct nfs_iostats *)tmp); } } __inline static void nfs_free_iostats(struct nfs_iostats *stats ) { { if ((unsigned long )stats != (unsigned long )((struct nfs_iostats *)0)) { free_percpu((void *)stats); } else { } return; } } struct rpc_program const nfs_program ; void nfs_clients_init(struct net *net ) ; struct nfs_client *nfs_alloc_client(struct nfs_client_initdata const *cl_init ) ; int nfs_create_rpc_client(struct nfs_client *clp , struct rpc_timeout const *timeparms , rpc_authflavor_t flavor ) ; struct nfs_client *nfs_get_client(struct nfs_client_initdata const *cl_init , struct rpc_timeout const *timeparms , char const *ip_addr , rpc_authflavor_t authflavour ) ; int nfs_probe_fsinfo(struct nfs_server *server , struct nfs_fh *mntfh , struct nfs_fattr *fattr ) ; void nfs_server_insert_lists(struct nfs_server *server ) ; void nfs_init_timeout_values(struct rpc_timeout *to , int proto , unsigned int timeo , unsigned int retrans ) ; int nfs_init_server_rpcclient(struct nfs_server *server , struct rpc_timeout const *timeo , rpc_authflavor_t pseudoflavour ) ; struct nfs_server *nfs_alloc_server(void) ; void nfs_server_copy_userdata(struct nfs_server *target , struct nfs_server *source ) ; void nfs_cleanup_cb_ident_idr(struct net *net ) ; void nfs_put_client(struct nfs_client *clp ) ; void nfs_free_client(struct nfs_client *clp ) ; struct nfs_server *nfs_create_server(struct nfs_mount_info *mount_info , struct nfs_subversion *nfs_mod ) ; void nfs_free_server(struct nfs_server *server ) ; struct nfs_server *nfs_clone_server(struct nfs_server *source , struct nfs_fh *fh , struct nfs_fattr *fattr , rpc_authflavor_t flavor ) ; int nfs_wait_client_init_complete(struct nfs_client const *clp ) ; void nfs_mark_client_ready(struct nfs_client *clp , int state ) ; int nfs_fs_proc_init(void) ; void nfs_fs_proc_exit(void) ; int nfs_sockaddr_match_ipaddr(struct sockaddr const *sa1 , struct sockaddr const *sa2 ) ; struct nfs_client *nfs_init_client(struct nfs_client *clp , struct rpc_timeout const *timeparms , char const *ip_addr ) ; struct rpc_stat nfs_rpcstat ; __inline static unsigned long nfs_block_bits(unsigned long bsize , unsigned char *nrbitsp ) { unsigned char nrbits ; { if (((bsize - 1UL) & bsize) != 0UL || (unsigned long )nrbitsp != (unsigned long )((unsigned char *)0U)) { nrbits = 31U; goto ldv_52251; ldv_52250: nrbits = (unsigned char )((int )nrbits - 1); ldv_52251: ; if ((unsigned int )nrbits != 0U && ((unsigned long )(1 << (int )nrbits) & bsize) == 0UL) { goto ldv_52250; } else { } bsize = (unsigned long )(1 << (int )nrbits); if ((unsigned long )nrbitsp != (unsigned long )((unsigned char *)0U)) { *nrbitsp = nrbits; } else { } } else { } return (bsize); } } __inline static unsigned long nfs_block_size(unsigned long bsize , unsigned char *nrbitsp ) { unsigned long tmp ; { if (bsize <= 1023UL) { bsize = 4096UL; } else if (bsize > 1048575UL) { bsize = 1048576UL; } else { } tmp = nfs_block_bits(bsize, nrbitsp); return (tmp); } } void nfs_fscache_get_client_cookie(struct nfs_client *clp ) ; void nfs_fscache_release_client_cookie(struct nfs_client *clp ) ; __inline static char const *nfs_server_fscache_state(struct nfs_server *server ) { { if ((unsigned long )server->fscache != (unsigned long )((struct fscache_cookie *)0) && (int )server->options & 1) { return ("yes"); } else { } return ("no "); } } struct nfs_subversion *get_nfs_version(unsigned int version ) ; void put_nfs_version(struct nfs_subversion *nfs ) ; void register_nfs_version(struct nfs_subversion *nfs ) ; void unregister_nfs_version(struct nfs_subversion *nfs ) ; __inline static void *net_generic(struct net const *net , int id ) { struct net_generic *ng ; void *ptr ; struct net_generic *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; { rcu_read_lock(); _________p1 = *((struct net_generic * const volatile *)(& net->gen)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("include/net/netns/generic.h", 40, "suspicious rcu_dereference_check() usage"); } else { } } else { } ng = _________p1; tmp___1 = ldv__builtin_expect(id == 0, 0L); if (tmp___1 != 0L) { goto _L; } else { tmp___2 = ldv__builtin_expect((unsigned int )id > ng->len, 0L); if (tmp___2 != 0L) { _L: /* CIL Label */ __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"include/net/netns/generic.h"), "i" (41), "i" (12UL)); ldv_53083: ; goto ldv_53083; } else { } } ptr = ng->ptr[id + -1]; rcu_read_unlock(); tmp___3 = ldv__builtin_expect((unsigned long )ptr == (unsigned long )((void *)0), 0L); if (tmp___3 != 0L) { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"include/net/netns/generic.h"), "i" (45), "i" (12UL)); ldv_53084: ; goto ldv_53084; } else { } return (ptr); } } int nfs_net_id ; static wait_queue_head_t nfs_client_active_wq = {{{{{{0U}}, 3735899821U, 4294967295U, (void *)-1, {0, {0, 0}, "nfs_client_active_wq.lock", 0, 0UL}}}}, {& nfs_client_active_wq.task_list, & nfs_client_active_wq.task_list}}; static spinlock_t nfs_version_lock = {{{{{0U}}, 3735899821U, 4294967295U, (void *)-1, {0, {0, 0}, "nfs_version_lock", 0, 0UL}}}}; static struct mutex nfs_version_mutex = {{1}, {{{{{0U}}, 3735899821U, 4294967295U, (void *)-1, {0, {0, 0}, "nfs_version_mutex.wait_lock", 0, 0UL}}}}, {& nfs_version_mutex.wait_list, & nfs_version_mutex.wait_list}, 0, 0, (void *)(& nfs_version_mutex), {0, {0, 0}, "nfs_version_mutex", 0, 0UL}}; static struct list_head nfs_versions = {& nfs_versions, & nfs_versions}; static struct rpc_version const *nfs_version[5U] = { 0, 0, (struct rpc_version const *)0, (struct rpc_version const *)0, (struct rpc_version const *)0}; struct rpc_program const nfs_program = {"nfs", 100003U, 5U, (struct rpc_version const **)(& nfs_version), & nfs_rpcstat, "nfs"}; struct rpc_stat nfs_rpcstat = {& nfs_program, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U}; static struct nfs_subversion *find_nfs_version(unsigned int version ) { struct nfs_subversion *nfs ; struct list_head const *__mptr ; struct list_head const *__mptr___0 ; void *tmp ; { spin_lock(& nfs_version_lock); __mptr = (struct list_head const *)nfs_versions.next; nfs = (struct nfs_subversion *)__mptr + 0xffffffffffffffd0UL; goto ldv_53124; ldv_53123: ; if ((unsigned int )(nfs->rpc_ops)->version == version) { spin_unlock(& nfs_version_lock); return (nfs); } else { } __mptr___0 = (struct list_head const *)nfs->list.next; nfs = (struct nfs_subversion *)__mptr___0 + 0xffffffffffffffd0UL; ldv_53124: ; if ((unsigned long )(& nfs->list) != (unsigned long )(& nfs_versions)) { goto ldv_53123; } else { } spin_unlock(& nfs_version_lock); tmp = ERR_PTR(-93L); return ((struct nfs_subversion *)tmp); } } struct nfs_subversion *get_nfs_version(unsigned int version ) { struct nfs_subversion *nfs ; struct nfs_subversion *tmp ; long tmp___0 ; long tmp___1 ; { tmp = find_nfs_version(version); nfs = tmp; tmp___0 = IS_ERR((void const *)nfs); if (tmp___0 != 0L) { mutex_lock_nested(& nfs_version_mutex, 0U); __request_module(1, "nfsv%d", version); nfs = find_nfs_version(version); mutex_unlock(& nfs_version_mutex); } else { } tmp___1 = IS_ERR((void const *)nfs); if (tmp___1 == 0L) { ldv_try_module_get_7(nfs->owner); } else { } return (nfs); } } void put_nfs_version(struct nfs_subversion *nfs ) { { ldv_module_put_8(nfs->owner); return; } } void register_nfs_version(struct nfs_subversion *nfs ) { { spin_lock(& nfs_version_lock); list_add(& nfs->list, & nfs_versions); nfs_version[(nfs->rpc_ops)->version] = nfs->rpc_vers; spin_unlock(& nfs_version_lock); return; } } void unregister_nfs_version(struct nfs_subversion *nfs ) { { spin_lock(& nfs_version_lock); nfs_version[(nfs->rpc_ops)->version] = (struct rpc_version const *)0; list_del(& nfs->list); spin_unlock(& nfs_version_lock); return; } } struct nfs_client *nfs_alloc_client(struct nfs_client_initdata const *cl_init ) { struct nfs_client *clp ; struct rpc_cred *cred ; int err ; void *tmp ; size_t __len ; void *__ret ; void *tmp___0 ; long tmp___1 ; void *tmp___2 ; { err = -12; tmp = kzalloc(1072UL, 208U); clp = (struct nfs_client *)tmp; if ((unsigned long )clp == (unsigned long )((struct nfs_client *)0)) { goto error_0; } else { } clp->cl_nfs_mod = cl_init->nfs_mod; ldv_try_module_get_9((clp->cl_nfs_mod)->owner); clp->rpc_ops = (clp->cl_nfs_mod)->rpc_ops; atomic_set(& clp->cl_count, 1); clp->cl_cons_state = 1; __len = cl_init->addrlen; __ret = __builtin_memcpy((void *)(& clp->cl_addr), (void const *)cl_init->addr, __len); clp->cl_addrlen = cl_init->addrlen; if ((unsigned long )cl_init->hostname != (unsigned long )((char const */* const */)0)) { err = -12; clp->cl_hostname = kstrdup(cl_init->hostname, 208U); if ((unsigned long )clp->cl_hostname == (unsigned long )((char *)0)) { goto error_cleanup; } else { } } else { } INIT_LIST_HEAD(& clp->cl_superblocks); tmp___0 = ERR_PTR(-22L); clp->cl_rpcclient = (struct rpc_clnt *)tmp___0; clp->cl_proto = cl_init->proto; clp->cl_net = get_net(cl_init->net); cred = rpc_lookup_machine_cred("*"); tmp___1 = IS_ERR((void const *)cred); if (tmp___1 == 0L) { clp->cl_machine_cred = cred; } else { } nfs_fscache_get_client_cookie(clp); return (clp); error_cleanup: put_nfs_version(clp->cl_nfs_mod); kfree((void const *)clp); error_0: tmp___2 = ERR_PTR((long )err); return ((struct nfs_client *)tmp___2); } } void nfs_cleanup_cb_ident_idr(struct net *net ) { struct nfs_net *nn ; void *tmp ; { tmp = net_generic((struct net const *)net, nfs_net_id); nn = (struct nfs_net *)tmp; idr_destroy(& nn->cb_ident_idr); return; } } static void nfs_cb_idr_remove_locked(struct nfs_client *clp ) { struct nfs_net *nn ; void *tmp ; { tmp = net_generic((struct net const *)clp->cl_net, nfs_net_id); nn = (struct nfs_net *)tmp; if (clp->cl_cb_ident != 0U) { idr_remove(& nn->cb_ident_idr, (int )clp->cl_cb_ident); } else { } return; } } static void pnfs_init_server(struct nfs_server *server ) { { rpc_init_wait_queue(& server->roc_rpcwaitq, "pNFS ROC"); return; } } void nfs_free_client(struct nfs_client *clp ) { long tmp ; long tmp___0 ; long tmp___1 ; { tmp = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp != 0L) { printk("\001d--> nfs_free_client(%u)\n", (clp->rpc_ops)->version); } else { } nfs_fscache_release_client_cookie(clp); tmp___0 = IS_ERR((void const *)clp->cl_rpcclient); if (tmp___0 == 0L) { rpc_shutdown_client(clp->cl_rpcclient); } else { } if ((unsigned long )clp->cl_machine_cred != (unsigned long )((struct rpc_cred *)0)) { put_rpccred(clp->cl_machine_cred); } else { } put_net(clp->cl_net); put_nfs_version(clp->cl_nfs_mod); kfree((void const *)clp->cl_hostname); kfree((void const *)clp); tmp___1 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001d<-- nfs_free_client()\n"); } else { } return; } } void nfs_put_client(struct nfs_client *clp ) { struct nfs_net *nn ; int tmp ; long tmp___0 ; void *tmp___1 ; bool __warned ; int __ret_warn_once ; int tmp___2 ; int __ret_warn_on ; long tmp___3 ; long tmp___4 ; long tmp___5 ; int tmp___6 ; { if ((unsigned long )clp == (unsigned long )((struct nfs_client *)0)) { return; } else { } tmp___0 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___0 != 0L) { tmp = atomic_read((atomic_t const *)(& clp->cl_count)); printk("\001d--> nfs_put_client({%d})\n", tmp); } else { } tmp___1 = net_generic((struct net const *)clp->cl_net, nfs_net_id); nn = (struct nfs_net *)tmp___1; tmp___6 = _atomic_dec_and_lock(& clp->cl_count, & nn->nfs_client_lock); if (tmp___6 != 0) { list_del(& clp->cl_share_link); nfs_cb_idr_remove_locked(clp); spin_unlock(& nn->nfs_client_lock); tmp___2 = list_empty((struct list_head const *)(& clp->cl_superblocks)); __ret_warn_once = tmp___2 == 0; tmp___5 = ldv__builtin_expect(__ret_warn_once != 0, 0L); if (tmp___5 != 0L) { __ret_warn_on = ! __warned; tmp___3 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___3 != 0L) { warn_slowpath_null("/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/client.o.c.prepared", 471); } else { } tmp___4 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___4 != 0L) { __warned = 1; } else { } } else { } ldv__builtin_expect(__ret_warn_once != 0, 0L); (*((clp->rpc_ops)->free_client))(clp); } else { } return; } } static int nfs_sockaddr_match_ipaddr6(struct sockaddr const *sa1 , struct sockaddr const *sa2 ) { struct sockaddr_in6 const *sin1 ; struct sockaddr_in6 const *sin2 ; int tmp ; bool tmp___0 ; int tmp___1 ; { sin1 = (struct sockaddr_in6 const *)sa1; sin2 = (struct sockaddr_in6 const *)sa2; tmp___0 = ipv6_addr_equal(& sin1->sin6_addr, & sin2->sin6_addr); if (tmp___0) { tmp___1 = 0; } else { tmp___1 = 1; } if (tmp___1) { return (0); } else { tmp = ipv6_addr_type(& sin1->sin6_addr); if (((unsigned int )tmp & 32U) != 0U) { return ((unsigned int )sin1->sin6_scope_id == (unsigned int )sin2->sin6_scope_id); } else { } } return (1); } } static int nfs_sockaddr_match_ipaddr4(struct sockaddr const *sa1 , struct sockaddr const *sa2 ) { struct sockaddr_in const *sin1 ; struct sockaddr_in const *sin2 ; { sin1 = (struct sockaddr_in const *)sa1; sin2 = (struct sockaddr_in const *)sa2; return ((unsigned int )sin1->sin_addr.s_addr == (unsigned int )sin2->sin_addr.s_addr); } } static int nfs_sockaddr_cmp_ip6(struct sockaddr const *sa1 , struct sockaddr const *sa2 ) { struct sockaddr_in6 const *sin1 ; struct sockaddr_in6 const *sin2 ; int tmp ; { sin1 = (struct sockaddr_in6 const *)sa1; sin2 = (struct sockaddr_in6 const *)sa2; tmp = nfs_sockaddr_match_ipaddr6(sa1, sa2); return (tmp != 0 && (int )((unsigned short )sin1->sin6_port) == (int )((unsigned short )sin2->sin6_port)); } } static int nfs_sockaddr_cmp_ip4(struct sockaddr const *sa1 , struct sockaddr const *sa2 ) { struct sockaddr_in const *sin1 ; struct sockaddr_in const *sin2 ; int tmp ; { sin1 = (struct sockaddr_in const *)sa1; sin2 = (struct sockaddr_in const *)sa2; tmp = nfs_sockaddr_match_ipaddr4(sa1, sa2); return (tmp != 0 && (int )((unsigned short )sin1->sin_port) == (int )((unsigned short )sin2->sin_port)); } } int nfs_sockaddr_match_ipaddr(struct sockaddr const *sa1 , struct sockaddr const *sa2 ) { int tmp ; int tmp___0 ; { if ((int )((unsigned short )sa1->sa_family) != (int )((unsigned short )sa2->sa_family)) { return (0); } else { } switch ((int )sa1->sa_family) { case 2: tmp = nfs_sockaddr_match_ipaddr4(sa1, sa2); return (tmp); case 10: tmp___0 = nfs_sockaddr_match_ipaddr6(sa1, sa2); return (tmp___0); } return (0); } } static int nfs_sockaddr_cmp(struct sockaddr const *sa1 , struct sockaddr const *sa2 ) { int tmp ; int tmp___0 ; { if ((int )((unsigned short )sa1->sa_family) != (int )((unsigned short )sa2->sa_family)) { return (0); } else { } switch ((int )sa1->sa_family) { case 2: tmp = nfs_sockaddr_cmp_ip4(sa1, sa2); return (tmp); case 10: tmp___0 = nfs_sockaddr_cmp_ip6(sa1, sa2); return (tmp___0); } return (0); } } static struct nfs_client *nfs_match_client(struct nfs_client_initdata const *data ) { struct nfs_client *clp ; struct sockaddr const *sap ; struct nfs_net *nn ; void *tmp ; struct list_head const *__mptr ; struct sockaddr const *clap ; int tmp___0 ; struct list_head const *__mptr___0 ; { sap = data->addr; tmp = net_generic((struct net const *)data->net, nfs_net_id); nn = (struct nfs_net *)tmp; __mptr = (struct list_head const *)nn->nfs_client_list.next; clp = (struct nfs_client *)__mptr + 0xffffffffffffff50UL; goto ldv_53259; ldv_53258: clap = (struct sockaddr const *)(& clp->cl_addr); if (clp->cl_cons_state < 0) { goto ldv_53257; } else { } if ((unsigned long )clp->rpc_ops != (unsigned long )(data->nfs_mod)->rpc_ops) { goto ldv_53257; } else { } if (clp->cl_proto != (int )data->proto) { goto ldv_53257; } else { } if (clp->cl_minorversion != (u32 )data->minorversion) { goto ldv_53257; } else { } tmp___0 = nfs_sockaddr_cmp(sap, clap); if (tmp___0 == 0) { goto ldv_53257; } else { } atomic_inc(& clp->cl_count); return (clp); ldv_53257: __mptr___0 = (struct list_head const *)clp->cl_share_link.next; clp = (struct nfs_client *)__mptr___0 + 0xffffffffffffff50UL; ldv_53259: ; if ((unsigned long )(& clp->cl_share_link) != (unsigned long )(& nn->nfs_client_list)) { goto ldv_53258; } else { } return ((struct nfs_client *)0); } } static bool nfs_client_init_is_complete(struct nfs_client const *clp ) { { return ((int )clp->cl_cons_state != 1); } } int nfs_wait_client_init_complete(struct nfs_client const *clp ) { int __ret ; wait_queue_t __wait ; struct task_struct *tmp ; bool tmp___0 ; struct task_struct *tmp___1 ; int tmp___2 ; bool tmp___3 ; int tmp___4 ; { __ret = 0; tmp___3 = nfs_client_init_is_complete(clp); if (tmp___3) { tmp___4 = 0; } else { tmp___4 = 1; } if (tmp___4) { tmp = get_current(); __wait.flags = 0U; __wait.private = (void *)tmp; __wait.func = & autoremove_wake_function; __wait.task_list.next = & __wait.task_list; __wait.task_list.prev = & __wait.task_list; ldv_53271: prepare_to_wait(& nfs_client_active_wq, & __wait, 130); tmp___0 = nfs_client_init_is_complete(clp); if ((int )tmp___0) { goto ldv_53269; } else { } tmp___1 = get_current(); tmp___2 = fatal_signal_pending(tmp___1); if (tmp___2 == 0) { schedule(); goto ldv_53270; } else { } __ret = -512; goto ldv_53269; ldv_53270: ; goto ldv_53271; ldv_53269: finish_wait(& nfs_client_active_wq, & __wait); } else { } return (__ret); } } static struct nfs_client *nfs_found_client(struct nfs_client_initdata const *cl_init , struct nfs_client *clp ) { int error ; void *tmp ; void *tmp___0 ; long tmp___1 ; { error = nfs_wait_client_init_complete((struct nfs_client const *)clp); if (error < 0) { nfs_put_client(clp); tmp = ERR_PTR(-512L); return ((struct nfs_client *)tmp); } else { } if (clp->cl_cons_state < 0) { error = clp->cl_cons_state; nfs_put_client(clp); tmp___0 = ERR_PTR((long )error); return ((struct nfs_client *)tmp___0); } else { } __asm__ volatile ("": : : "memory"); tmp___1 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001d<-- %s found nfs_client %p for %s\n", "nfs_found_client", clp, (unsigned long )cl_init->hostname != (unsigned long )((char const */* const */)0) ? cl_init->hostname : (char const */* const */)""); } else { } return (clp); } } struct nfs_client *nfs_get_client(struct nfs_client_initdata const *cl_init , struct rpc_timeout const *timeparms , char const *ip_addr , rpc_authflavor_t authflavour ) { struct nfs_client *clp ; struct nfs_client *new ; struct nfs_net *nn ; void *tmp ; struct nfs_rpc_ops const *rpc_ops ; long tmp___0 ; struct nfs_client *tmp___1 ; struct nfs_client *tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; { new = (struct nfs_client *)0; tmp = net_generic((struct net const *)cl_init->net, nfs_net_id); nn = (struct nfs_net *)tmp; rpc_ops = (cl_init->nfs_mod)->rpc_ops; tmp___0 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001d--> nfs_get_client(%s,v%u)\n", (unsigned long )cl_init->hostname != (unsigned long )((char const */* const */)0) ? cl_init->hostname : (char const */* const */)"", rpc_ops->version); } else { } ldv_53295: spin_lock(& nn->nfs_client_lock); clp = nfs_match_client(cl_init); if ((unsigned long )clp != (unsigned long )((struct nfs_client *)0)) { spin_unlock(& nn->nfs_client_lock); if ((unsigned long )new != (unsigned long )((struct nfs_client *)0)) { (*((new->rpc_ops)->free_client))(new); } else { } tmp___1 = nfs_found_client(cl_init, clp); return (tmp___1); } else { } if ((unsigned long )new != (unsigned long )((struct nfs_client *)0)) { list_add_tail(& new->cl_share_link, & nn->nfs_client_list); spin_unlock(& nn->nfs_client_lock); new->cl_flags = cl_init->init_flags; tmp___2 = (*(rpc_ops->init_client))(new, timeparms, ip_addr); return (tmp___2); } else { } spin_unlock(& nn->nfs_client_lock); new = (*(rpc_ops->alloc_client))(cl_init); tmp___3 = IS_ERR((void const *)new); if (tmp___3 == 0L) { goto ldv_53295; } else { } tmp___5 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___5 != 0L) { tmp___4 = PTR_ERR((void const *)new); printk("\001d<-- nfs_get_client() Failed to find %s (%ld)\n", (unsigned long )cl_init->hostname != (unsigned long )((char const */* const */)0) ? cl_init->hostname : (char const */* const */)"", tmp___4); } else { } return (new); } } void nfs_mark_client_ready(struct nfs_client *clp , int state ) { { __asm__ volatile ("": : : "memory"); clp->cl_cons_state = state; __wake_up(& nfs_client_active_wq, 3U, 0, (void *)0); return; } } void nfs_init_timeout_values(struct rpc_timeout *to , int proto , unsigned int timeo , unsigned int retrans ) { { to->to_initval = (unsigned long )((timeo * 250U) / 10U); to->to_retries = retrans; switch (proto) { case 6: ; case 256: ; if (to->to_retries == 0U) { to->to_retries = 2U; } else { } if (to->to_initval == 0UL) { to->to_initval = 15000UL; } else { } if (to->to_initval > 150000UL) { to->to_initval = 150000UL; } else { } to->to_increment = to->to_initval; to->to_maxval = to->to_initval + to->to_increment * (unsigned long )to->to_retries; if (to->to_maxval > 150000UL) { to->to_maxval = 150000UL; } else { } if (to->to_maxval < to->to_initval) { to->to_maxval = to->to_initval; } else { } to->to_exponential = 0U; goto ldv_53325; case 17: ; if (to->to_retries == 0U) { to->to_retries = 3U; } else { } if (to->to_initval == 0UL) { to->to_initval = 275UL; } else { } if (to->to_initval > 15000UL) { to->to_initval = 15000UL; } else { } to->to_maxval = 15000UL; to->to_exponential = 1U; goto ldv_53325; default: __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/client.o.c.prepared"), "i" (758), "i" (12UL)); ldv_53328: ; goto ldv_53328; } ldv_53325: ; return; } } int nfs_create_rpc_client(struct nfs_client *clp , struct rpc_timeout const *timeparms , rpc_authflavor_t flavor ) { struct rpc_clnt *clnt ; struct rpc_create_args args ; int tmp ; int tmp___0 ; int tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; { clnt = (struct rpc_clnt *)0; args.net = clp->cl_net; args.protocol = clp->cl_proto; args.address = (struct sockaddr *)(& clp->cl_addr); args.addrsize = clp->cl_addrlen; args.saddress = 0; args.timeout = timeparms; args.servername = (char const *)clp->cl_hostname; args.program = & nfs_program; args.prognumber = 0U; args.version = (clp->rpc_ops)->version; args.authflavor = flavor; args.flags = 0UL; args.client_name = 0; args.bc_xprt = 0; tmp = constant_test_bit(1L, (unsigned long const volatile *)(& clp->cl_flags)); if (tmp != 0) { args.flags = args.flags | 32UL; } else { } tmp___0 = constant_test_bit(0L, (unsigned long const volatile *)(& clp->cl_flags)); if (tmp___0 != 0) { args.flags = args.flags | 8UL; } else { } tmp___1 = constant_test_bit(3L, (unsigned long const volatile *)(& clp->cl_flags)); if (tmp___1 != 0) { args.flags = args.flags | 128UL; } else { } tmp___2 = IS_ERR((void const *)clp->cl_rpcclient); if (tmp___2 == 0L) { return (0); } else { } clnt = rpc_create(& args); tmp___6 = IS_ERR((void const *)clnt); if (tmp___6 != 0L) { tmp___4 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___4 != 0L) { tmp___3 = PTR_ERR((void const *)clnt); printk("\001d%s: cannot create RPC client. Error = %ld\n", "nfs_create_rpc_client", tmp___3); } else { } tmp___5 = PTR_ERR((void const *)clnt); return ((int )tmp___5); } else { } clp->cl_rpcclient = clnt; return (0); } } static void nfs_destroy_server(struct nfs_server *server ) { { if ((unsigned long )server->nlm_host != (unsigned long )((struct nlm_host *)0)) { nlmclnt_done(server->nlm_host); } else { } return; } } static int nfs_start_lockd(struct nfs_server *server ) { struct nlm_host *host ; struct nfs_client *clp ; struct nlmclnt_initdata nlm_init ; long tmp ; long tmp___0 ; { clp = server->nfs_client; nlm_init.hostname = (char const *)clp->cl_hostname; nlm_init.address = (struct sockaddr const *)(& clp->cl_addr); nlm_init.addrlen = clp->cl_addrlen; nlm_init.protocol = (unsigned short)0; nlm_init.nfs_version = (clp->rpc_ops)->version; nlm_init.noresvport = (server->flags & 262144) != 0; nlm_init.net = clp->cl_net; if (nlm_init.nfs_version > 3U) { return (0); } else { } if ((server->flags & 1048576) != 0 && (server->flags & 2097152) != 0) { return (0); } else { } switch (clp->cl_proto) { default: nlm_init.protocol = 6U; goto ldv_53364; case 17: nlm_init.protocol = 17U; } ldv_53364: host = nlmclnt_init((struct nlmclnt_initdata const *)(& nlm_init)); tmp___0 = IS_ERR((void const *)host); if (tmp___0 != 0L) { tmp = PTR_ERR((void const *)host); return ((int )tmp); } else { } server->nlm_host = host; server->destroy = & nfs_destroy_server; return (0); } } int nfs_init_server_rpcclient(struct nfs_server *server , struct rpc_timeout const *timeo , rpc_authflavor_t pseudoflavour ) { struct nfs_client *clp ; long tmp ; long tmp___0 ; long tmp___1 ; size_t __len ; void *__ret ; { clp = server->nfs_client; server->client = rpc_clone_client_set_auth(clp->cl_rpcclient, pseudoflavour); tmp___1 = IS_ERR((void const *)server->client); if (tmp___1 != 0L) { tmp = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp != 0L) { printk("\001d%s: couldn\'t create rpc_client!\n", "nfs_init_server_rpcclient"); } else { } tmp___0 = PTR_ERR((void const *)server->client); return ((int )tmp___0); } else { } __len = 32UL; if (__len > 63UL) { __ret = __memcpy((void *)(& (server->client)->cl_timeout_default), (void const *)timeo, __len); } else { __ret = __builtin_memcpy((void *)(& (server->client)->cl_timeout_default), (void const *)timeo, __len); } (server->client)->cl_timeout = (struct rpc_timeout const *)(& (server->client)->cl_timeout_default); (server->client)->cl_softrtry = 0U; if (server->flags & 1) { (server->client)->cl_softrtry = 1U; } else { } return (0); } } struct nfs_client *nfs_init_client(struct nfs_client *clp , struct rpc_timeout const *timeparms , char const *ip_addr ) { int error ; long tmp ; long tmp___0 ; void *tmp___1 ; { if (clp->cl_cons_state == 0) { tmp = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp != 0L) { printk("\001d<-- nfs_init_client() = 0 [already %p]\n", clp); } else { } return (clp); } else { } error = nfs_create_rpc_client(clp, timeparms, 1U); if (error < 0) { goto error; } else { } nfs_mark_client_ready(clp, 0); return (clp); error: nfs_mark_client_ready(clp, error); nfs_put_client(clp); tmp___0 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001d<-- nfs_init_client() = xerror %d\n", error); } else { } tmp___1 = ERR_PTR((long )error); return ((struct nfs_client *)tmp___1); } } static int nfs_init_server(struct nfs_server *server , struct nfs_parsed_mount_data const *data , struct nfs_subversion *nfs_mod ) { struct nfs_client_initdata cl_init ; struct rpc_timeout timeparms ; struct nfs_client *clp ; int error ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; unsigned long tmp___4 ; unsigned long tmp___5 ; size_t __len ; void *__ret ; long tmp___6 ; long tmp___7 ; { cl_init.init_flags = 0UL; cl_init.hostname = (char const *)data->nfs_server.hostname; cl_init.addr = (struct sockaddr const *)(& data->nfs_server.address); cl_init.addrlen = data->nfs_server.addrlen; cl_init.nfs_mod = nfs_mod; cl_init.proto = (int )data->nfs_server.protocol; cl_init.minorversion = 0U; cl_init.net = data->net; tmp = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp != 0L) { printk("\001d--> nfs_init_server()\n"); } else { } nfs_init_timeout_values(& timeparms, (int )data->nfs_server.protocol, data->timeo, data->retrans); if (((int )data->flags & 262144) != 0) { set_bit(0L, (unsigned long volatile *)(& cl_init.init_flags)); } else { } clp = nfs_get_client((struct nfs_client_initdata const *)(& cl_init), (struct rpc_timeout const *)(& timeparms), (char const *)0, 1U); tmp___3 = IS_ERR((void const *)clp); if (tmp___3 != 0L) { tmp___1 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___1 != 0L) { tmp___0 = PTR_ERR((void const *)clp); printk("\001d<-- nfs_init_server() = error %ld\n", tmp___0); } else { } tmp___2 = PTR_ERR((void const *)clp); return ((int )tmp___2); } else { } server->nfs_client = clp; server->flags = data->flags; server->options = data->options; server->caps = server->caps | 16358U; if ((unsigned int )data->rsize != 0U) { tmp___4 = nfs_block_size((unsigned long )data->rsize, (unsigned char *)0U); server->rsize = (unsigned int )tmp___4; } else { } if ((unsigned int )data->wsize != 0U) { tmp___5 = nfs_block_size((unsigned long )data->wsize, (unsigned char *)0U); server->wsize = (unsigned int )tmp___5; } else { } server->acregmin = (unsigned int )data->acregmin * 250U; server->acregmax = (unsigned int )data->acregmax * 250U; server->acdirmin = (unsigned int )data->acdirmin * 250U; server->acdirmax = (unsigned int )data->acdirmax * 250U; error = nfs_start_lockd(server); if (error < 0) { goto error; } else { } server->port = (unsigned short )data->nfs_server.port; error = nfs_init_server_rpcclient(server, (struct rpc_timeout const *)(& timeparms), data->auth_flavors[0]); if (error < 0) { goto error; } else { } if ((unsigned long )data->mount_server.addrlen != 0UL) { __len = data->mount_server.addrlen; __ret = __builtin_memcpy((void *)(& server->mountd_address), (void const *)(& data->mount_server.address), __len); server->mountd_addrlen = data->mount_server.addrlen; } else { } server->mountd_version = data->mount_server.version; server->mountd_port = (unsigned short )data->mount_server.port; server->mountd_protocol = data->mount_server.protocol; server->namelen = data->namlen; tmp___6 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___6 != 0L) { printk("\001d<-- nfs_init_server() = 0 [new %p]\n", clp); } else { } return (0); error: server->nfs_client = (struct nfs_client *)0; nfs_put_client(clp); tmp___7 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___7 != 0L) { printk("\001d<-- nfs_init_server() = xerror %d\n", error); } else { } return (error); } } static void nfs_server_set_fsinfo(struct nfs_server *server , struct nfs_fh *mntfh , struct nfs_fsinfo *fsinfo ) { unsigned long max_rpc_payload ; unsigned long tmp ; unsigned long tmp___0 ; unsigned long tmp___1 ; unsigned long tmp___2 ; size_t tmp___3 ; unsigned long tmp___4 ; unsigned long tmp___5 ; unsigned int tmp___6 ; unsigned int tmp___7 ; { if (server->rsize == 0U) { tmp = nfs_block_size((unsigned long )fsinfo->rtpref, (unsigned char *)0U); server->rsize = (unsigned int )tmp; } else { } if (server->wsize == 0U) { tmp___0 = nfs_block_size((unsigned long )fsinfo->wtpref, (unsigned char *)0U); server->wsize = (unsigned int )tmp___0; } else { } if (fsinfo->rtmax > 511U && server->rsize > fsinfo->rtmax) { tmp___1 = nfs_block_size((unsigned long )fsinfo->rtmax, (unsigned char *)0U); server->rsize = (unsigned int )tmp___1; } else { } if (fsinfo->wtmax > 511U && server->wsize > fsinfo->wtmax) { tmp___2 = nfs_block_size((unsigned long )fsinfo->wtmax, (unsigned char *)0U); server->wsize = (unsigned int )tmp___2; } else { } tmp___3 = rpc_max_payload(server->client); max_rpc_payload = nfs_block_size(tmp___3, (unsigned char *)0U); if ((unsigned long )server->rsize > max_rpc_payload) { server->rsize = (unsigned int )max_rpc_payload; } else { } if (server->rsize > 1048576U) { server->rsize = 1048576U; } else { } server->rpages = (unsigned int )(((unsigned long )server->rsize + 4095UL) >> 12); server->backing_dev_info.name = (char *)"nfs"; server->backing_dev_info.ra_pages = (unsigned long )(server->rpages * 15U); if ((unsigned long )server->wsize > max_rpc_payload) { server->wsize = (unsigned int )max_rpc_payload; } else { } if (server->wsize > 1048576U) { server->wsize = 1048576U; } else { } server->wpages = (unsigned int )(((unsigned long )server->wsize + 4095UL) >> 12); tmp___4 = nfs_block_bits((unsigned long )fsinfo->wtmult, (unsigned char *)0U); server->wtmult = (unsigned int )tmp___4; tmp___5 = nfs_block_size((unsigned long )fsinfo->dtpref, (unsigned char *)0U); server->dtsize = (unsigned int )tmp___5; if (server->dtsize > 32768U) { server->dtsize = 32768U; } else { } if (server->dtsize > server->rsize) { server->dtsize = server->rsize; } else { } if ((server->flags & 32) != 0) { tmp___6 = 0U; server->acregmax = tmp___6; server->acregmin = tmp___6; tmp___7 = 0U; server->acdirmax = tmp___7; server->acdirmin = tmp___7; } else { } server->maxfilesize = fsinfo->maxfilesize; server->time_delta = fsinfo->time_delta; rpc_setbufsize(server->client, server->wsize + 100U, server->rsize + 100U); return; } } int nfs_probe_fsinfo(struct nfs_server *server , struct nfs_fh *mntfh , struct nfs_fattr *fattr ) { struct nfs_fsinfo fsinfo ; struct nfs_client *clp ; int error ; long tmp ; struct nfs_pathconf pathinfo ; int tmp___0 ; long tmp___1 ; long tmp___2 ; { clp = server->nfs_client; tmp = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp != 0L) { printk("\001d--> nfs_probe_fsinfo()\n"); } else { } if ((unsigned long )(clp->rpc_ops)->set_capabilities != (unsigned long )((int (*/* const */)(struct nfs_server * , struct nfs_fh * ))0)) { error = (*((clp->rpc_ops)->set_capabilities))(server, mntfh); if (error < 0) { goto out_error; } else { } } else { } fsinfo.fattr = fattr; fsinfo.layouttype = 0U; error = (*((clp->rpc_ops)->fsinfo))(server, mntfh, & fsinfo); if (error < 0) { goto out_error; } else { } nfs_server_set_fsinfo(server, mntfh, & fsinfo); if (server->namelen == 0U) { pathinfo.fattr = fattr; nfs_fattr_init(fattr); tmp___0 = (*((clp->rpc_ops)->pathconf))(server, mntfh, & pathinfo); if (tmp___0 >= 0) { server->namelen = pathinfo.max_namelen; } else { } } else { } tmp___1 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001d<-- nfs_probe_fsinfo() = 0\n"); } else { } return (0); out_error: tmp___2 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___2 != 0L) { printk("\001dnfs_probe_fsinfo: error = %d\n", - error); } else { } return (error); } } void nfs_server_copy_userdata(struct nfs_server *target , struct nfs_server *source ) { { target->flags = source->flags; target->rsize = source->rsize; target->wsize = source->wsize; target->acregmin = source->acregmin; target->acregmax = source->acregmax; target->acdirmin = source->acdirmin; target->acdirmax = source->acdirmax; target->caps = source->caps; target->options = source->options; return; } } void nfs_server_insert_lists(struct nfs_server *server ) { struct nfs_client *clp ; struct nfs_net *nn ; void *tmp ; { clp = server->nfs_client; tmp = net_generic((struct net const *)clp->cl_net, nfs_net_id); nn = (struct nfs_net *)tmp; spin_lock(& nn->nfs_client_lock); list_add_tail_rcu(& server->client_link, & clp->cl_superblocks); list_add_tail(& server->master_link, & nn->nfs_volume_list); clear_bit(4L, (unsigned long volatile *)(& clp->cl_res_state)); spin_unlock(& nn->nfs_client_lock); return; } } static void nfs_server_remove_lists(struct nfs_server *server ) { struct nfs_client *clp ; struct nfs_net *nn ; void *tmp ; int tmp___0 ; { clp = server->nfs_client; if ((unsigned long )clp == (unsigned long )((struct nfs_client *)0)) { return; } else { } tmp = net_generic((struct net const *)clp->cl_net, nfs_net_id); nn = (struct nfs_net *)tmp; spin_lock(& nn->nfs_client_lock); list_del_rcu(& server->client_link); tmp___0 = list_empty((struct list_head const *)(& clp->cl_superblocks)); if (tmp___0 != 0) { set_bit(4L, (unsigned long volatile *)(& clp->cl_res_state)); } else { } list_del(& server->master_link); spin_unlock(& nn->nfs_client_lock); synchronize_rcu(); return; } } struct nfs_server *nfs_alloc_server(void) { struct nfs_server *server ; void *tmp ; struct rpc_clnt *tmp___0 ; void *tmp___1 ; int tmp___2 ; { tmp = kzalloc(2392UL, 208U); server = (struct nfs_server *)tmp; if ((unsigned long )server == (unsigned long )((struct nfs_server *)0)) { return ((struct nfs_server *)0); } else { } tmp___1 = ERR_PTR(-22L); tmp___0 = (struct rpc_clnt *)tmp___1; server->client_acl = tmp___0; server->client = tmp___0; INIT_LIST_HEAD(& server->client_link); INIT_LIST_HEAD(& server->master_link); INIT_LIST_HEAD(& server->delegations); INIT_LIST_HEAD(& server->layouts); INIT_LIST_HEAD(& server->state_owners_lru); atomic_set(& server->active, 0); server->io_stats = nfs_alloc_iostats(); if ((unsigned long )server->io_stats == (unsigned long )((struct nfs_iostats *)0)) { kfree((void const *)server); return ((struct nfs_server *)0); } else { } tmp___2 = bdi_init(& server->backing_dev_info); if (tmp___2 != 0) { nfs_free_iostats(server->io_stats); kfree((void const *)server); return ((struct nfs_server *)0); } else { } ida_init(& server->openowner_id); ida_init(& server->lockowner_id); pnfs_init_server(server); return (server); } } void nfs_free_server(struct nfs_server *server ) { long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; { tmp = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp != 0L) { printk("\001d--> nfs_free_server()\n"); } else { } nfs_server_remove_lists(server); if ((unsigned long )server->destroy != (unsigned long )((void (*)(struct nfs_server * ))0)) { (*(server->destroy))(server); } else { } tmp___0 = IS_ERR((void const *)server->client_acl); if (tmp___0 == 0L) { rpc_shutdown_client(server->client_acl); } else { } tmp___1 = IS_ERR((void const *)server->client); if (tmp___1 == 0L) { rpc_shutdown_client(server->client); } else { } nfs_put_client(server->nfs_client); ida_destroy(& server->lockowner_id); ida_destroy(& server->openowner_id); nfs_free_iostats(server->io_stats); bdi_destroy(& server->backing_dev_info); kfree((void const *)server); nfs_release_automount_timer(); tmp___2 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___2 != 0L) { printk("\001d<-- nfs_free_server()\n"); } else { } return; } } struct nfs_server *nfs_create_server(struct nfs_mount_info *mount_info , struct nfs_subversion *nfs_mod ) { struct nfs_server *server ; struct nfs_fattr *fattr ; int error ; void *tmp ; long tmp___0 ; size_t __len ; void *__ret ; long tmp___1 ; void *tmp___2 ; { server = nfs_alloc_server(); if ((unsigned long )server == (unsigned long )((struct nfs_server *)0)) { tmp = ERR_PTR(-12L); return ((struct nfs_server *)tmp); } else { } error = -12; fattr = nfs_alloc_fattr(); if ((unsigned long )fattr == (unsigned long )((struct nfs_fattr *)0)) { goto error; } else { } error = nfs_init_server(server, (struct nfs_parsed_mount_data const *)mount_info->parsed, nfs_mod); if (error < 0) { goto error; } else { } error = nfs_probe_fsinfo(server, mount_info->mntfh, fattr); if (error < 0) { goto error; } else { } if ((unsigned int )((server->nfs_client)->rpc_ops)->version == 3U) { if (server->namelen == 0U || server->namelen > 255U) { server->namelen = 255U; } else { } if (((mount_info->parsed)->flags & 16384) == 0) { server->caps = server->caps | 1U; } else { } } else if (server->namelen == 0U || server->namelen > 255U) { server->namelen = 255U; } else { } if ((fattr->valid & 162943U) == 0U) { error = (*((nfs_mod->rpc_ops)->getattr))(server, mount_info->mntfh, fattr, (struct nfs4_label *)0); if (error < 0) { tmp___0 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001dnfs_create_server: getattr error = %d\n", - error); } else { } goto error; } else { } } else { } __len = 16UL; if (__len > 63UL) { __ret = __memcpy((void *)(& server->fsid), (void const *)(& fattr->fsid), __len); } else { __ret = __builtin_memcpy((void *)(& server->fsid), (void const *)(& fattr->fsid), __len); } tmp___1 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001dServer FSID: %llx:%llx\n", server->fsid.major, server->fsid.minor); } else { } nfs_server_insert_lists(server); server->mount_time = jiffies; nfs_free_fattr((struct nfs_fattr const *)fattr); return (server); error: nfs_free_fattr((struct nfs_fattr const *)fattr); nfs_free_server(server); tmp___2 = ERR_PTR((long )error); return ((struct nfs_server *)tmp___2); } } struct nfs_server *nfs_clone_server(struct nfs_server *source , struct nfs_fh *fh , struct nfs_fattr *fattr , rpc_authflavor_t flavor ) { struct nfs_server *server ; struct nfs_fattr *fattr_fsinfo ; int error ; long tmp ; void *tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; void *tmp___4 ; { tmp = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp != 0L) { printk("\001d--> nfs_clone_server(,%llx:%llx,)\n", fattr->fsid.major, fattr->fsid.minor); } else { } server = nfs_alloc_server(); if ((unsigned long )server == (unsigned long )((struct nfs_server *)0)) { tmp___0 = ERR_PTR(-12L); return ((struct nfs_server *)tmp___0); } else { } error = -12; fattr_fsinfo = nfs_alloc_fattr(); if ((unsigned long )fattr_fsinfo == (unsigned long )((struct nfs_fattr *)0)) { goto out_free_server; } else { } server->nfs_client = source->nfs_client; server->destroy = source->destroy; atomic_inc(& (server->nfs_client)->cl_count); nfs_server_copy_userdata(server, source); server->fsid = fattr->fsid; error = nfs_init_server_rpcclient(server, (source->client)->cl_timeout, flavor); if (error < 0) { goto out_free_server; } else { } error = nfs_probe_fsinfo(server, fh, fattr_fsinfo); if (error < 0) { goto out_free_server; } else { } if (server->namelen == 0U || server->namelen > 255U) { server->namelen = 255U; } else { } tmp___1 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001dCloned FSID: %llx:%llx\n", server->fsid.major, server->fsid.minor); } else { } error = nfs_start_lockd(server); if (error < 0) { goto out_free_server; } else { } nfs_server_insert_lists(server); server->mount_time = jiffies; nfs_free_fattr((struct nfs_fattr const *)fattr_fsinfo); tmp___2 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___2 != 0L) { printk("\001d<-- nfs_clone_server() = %p\n", server); } else { } return (server); out_free_server: nfs_free_fattr((struct nfs_fattr const *)fattr_fsinfo); nfs_free_server(server); tmp___3 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___3 != 0L) { printk("\001d<-- nfs_clone_server() = error %d\n", error); } else { } tmp___4 = ERR_PTR((long )error); return ((struct nfs_server *)tmp___4); } } void nfs_clients_init(struct net *net ) { struct nfs_net *nn ; void *tmp ; struct lock_class_key __key ; { tmp = net_generic((struct net const *)net, nfs_net_id); nn = (struct nfs_net *)tmp; INIT_LIST_HEAD(& nn->nfs_client_list); INIT_LIST_HEAD(& nn->nfs_volume_list); idr_init(& nn->cb_ident_idr); spinlock_check(& nn->nfs_client_lock); __raw_spin_lock_init(& nn->nfs_client_lock.ldv_6140.rlock, "&(&nn->nfs_client_lock)->rlock", & __key); nn->boot_time = current_kernel_time(); return; } } static struct proc_dir_entry *proc_fs_nfs ; static int nfs_server_list_open(struct inode *inode , struct file *file ) ; static void *nfs_server_list_start(struct seq_file *m , loff_t *_pos ) ; static void *nfs_server_list_next(struct seq_file *p , void *v , loff_t *pos ) ; static void nfs_server_list_stop(struct seq_file *p , void *v ) ; static int nfs_server_list_show(struct seq_file *m , void *v ) ; static struct seq_operations const nfs_server_list_ops = {& nfs_server_list_start, & nfs_server_list_stop, & nfs_server_list_next, & nfs_server_list_show}; static struct file_operations const nfs_server_list_fops = {& __this_module, & seq_lseek, & seq_read, 0, 0, 0, 0, 0, 0, 0, 0, & nfs_server_list_open, 0, & seq_release, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; static int nfs_volume_list_open(struct inode *inode , struct file *file ) ; static void *nfs_volume_list_start(struct seq_file *m , loff_t *_pos ) ; static void *nfs_volume_list_next(struct seq_file *p , void *v , loff_t *pos ) ; static void nfs_volume_list_stop(struct seq_file *p , void *v ) ; static int nfs_volume_list_show(struct seq_file *m , void *v ) ; static struct seq_operations const nfs_volume_list_ops = {& nfs_volume_list_start, & nfs_volume_list_stop, & nfs_volume_list_next, & nfs_volume_list_show}; static struct file_operations const nfs_volume_list_fops = {& __this_module, & seq_lseek, & seq_read, 0, 0, 0, 0, 0, 0, 0, 0, & nfs_volume_list_open, 0, & seq_release, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; static int nfs_server_list_open(struct inode *inode , struct file *file ) { struct seq_file *m ; int ret ; struct pid_namespace *pid_ns ; struct net *net ; { pid_ns = (struct pid_namespace *)((file->f_path.dentry)->d_sb)->s_fs_info; net = ((pid_ns->child_reaper)->nsproxy)->net_ns; ret = seq_open(file, & nfs_server_list_ops); if (ret < 0) { return (ret); } else { } m = (struct seq_file *)file->private_data; m->private = (void *)net; return (0); } } static void *nfs_server_list_start(struct seq_file *m , loff_t *_pos ) { struct nfs_net *nn ; void *tmp ; struct list_head *tmp___0 ; { tmp = net_generic((struct net const *)m->private, nfs_net_id); nn = (struct nfs_net *)tmp; spin_lock(& nn->nfs_client_lock); tmp___0 = seq_list_start_head(& nn->nfs_client_list, *_pos); return ((void *)tmp___0); } } static void *nfs_server_list_next(struct seq_file *p , void *v , loff_t *pos ) { struct nfs_net *nn ; void *tmp ; struct list_head *tmp___0 ; { tmp = net_generic((struct net const *)p->private, nfs_net_id); nn = (struct nfs_net *)tmp; tmp___0 = seq_list_next(v, & nn->nfs_client_list, pos); return ((void *)tmp___0); } } static void nfs_server_list_stop(struct seq_file *p , void *v ) { struct nfs_net *nn ; void *tmp ; { tmp = net_generic((struct net const *)p->private, nfs_net_id); nn = (struct nfs_net *)tmp; spin_unlock(& nn->nfs_client_lock); return; } } static int nfs_server_list_show(struct seq_file *m , void *v ) { struct nfs_client *clp ; struct nfs_net *nn ; void *tmp ; struct list_head const *__mptr ; int tmp___0 ; char const *tmp___1 ; char const *tmp___2 ; { tmp = net_generic((struct net const *)m->private, nfs_net_id); nn = (struct nfs_net *)tmp; if ((unsigned long )((void *)(& nn->nfs_client_list)) == (unsigned long )v) { seq_puts(m, "NV SERVER PORT USE HOSTNAME\n"); return (0); } else { } __mptr = (struct list_head const *)v; clp = (struct nfs_client *)__mptr + 0xffffffffffffff50UL; if (clp->cl_cons_state != 0) { return (0); } else { } rcu_read_lock(); tmp___0 = atomic_read((atomic_t const *)(& clp->cl_count)); tmp___1 = rpc_peeraddr2str(clp->cl_rpcclient, 4); tmp___2 = rpc_peeraddr2str(clp->cl_rpcclient, 3); seq_printf(m, "v%u %s %s %3d %s\n", (clp->rpc_ops)->version, tmp___2, tmp___1, tmp___0, clp->cl_hostname); rcu_read_unlock(); return (0); } } static int nfs_volume_list_open(struct inode *inode , struct file *file ) { struct seq_file *m ; int ret ; struct pid_namespace *pid_ns ; struct net *net ; { pid_ns = (struct pid_namespace *)((file->f_path.dentry)->d_sb)->s_fs_info; net = ((pid_ns->child_reaper)->nsproxy)->net_ns; ret = seq_open(file, & nfs_volume_list_ops); if (ret < 0) { return (ret); } else { } m = (struct seq_file *)file->private_data; m->private = (void *)net; return (0); } } static void *nfs_volume_list_start(struct seq_file *m , loff_t *_pos ) { struct nfs_net *nn ; void *tmp ; struct list_head *tmp___0 ; { tmp = net_generic((struct net const *)m->private, nfs_net_id); nn = (struct nfs_net *)tmp; spin_lock(& nn->nfs_client_lock); tmp___0 = seq_list_start_head(& nn->nfs_volume_list, *_pos); return ((void *)tmp___0); } } static void *nfs_volume_list_next(struct seq_file *p , void *v , loff_t *pos ) { struct nfs_net *nn ; void *tmp ; struct list_head *tmp___0 ; { tmp = net_generic((struct net const *)p->private, nfs_net_id); nn = (struct nfs_net *)tmp; tmp___0 = seq_list_next(v, & nn->nfs_volume_list, pos); return ((void *)tmp___0); } } static void nfs_volume_list_stop(struct seq_file *p , void *v ) { struct nfs_net *nn ; void *tmp ; { tmp = net_generic((struct net const *)p->private, nfs_net_id); nn = (struct nfs_net *)tmp; spin_unlock(& nn->nfs_client_lock); return; } } static int nfs_volume_list_show(struct seq_file *m , void *v ) { struct nfs_server *server ; struct nfs_client *clp ; char dev[8U] ; char fsid[17U] ; struct nfs_net *nn ; void *tmp ; struct list_head const *__mptr ; char const *tmp___0 ; char const *tmp___1 ; char const *tmp___2 ; { tmp = net_generic((struct net const *)m->private, nfs_net_id); nn = (struct nfs_net *)tmp; if ((unsigned long )((void *)(& nn->nfs_volume_list)) == (unsigned long )v) { seq_puts(m, "NV SERVER PORT DEV FSID FSC\n"); return (0); } else { } __mptr = (struct list_head const *)v; server = (struct nfs_server *)__mptr + 0xffffffffffffffe8UL; clp = server->nfs_client; snprintf((char *)(& dev), 8UL, "%u:%u", server->s_dev >> 20, server->s_dev & 1048575U); snprintf((char *)(& fsid), 17UL, "%llx:%llx", server->fsid.major, server->fsid.minor); rcu_read_lock(); tmp___0 = nfs_server_fscache_state(server); tmp___1 = rpc_peeraddr2str(clp->cl_rpcclient, 4); tmp___2 = rpc_peeraddr2str(clp->cl_rpcclient, 3); seq_printf(m, "v%u %s %s %-7s %-17s %s\n", (clp->rpc_ops)->version, tmp___2, tmp___1, (char *)(& dev), (char *)(& fsid), tmp___0); rcu_read_unlock(); return (0); } } int nfs_fs_proc_init(void) { struct proc_dir_entry *p ; { proc_fs_nfs = proc_mkdir("fs/nfsfs", (struct proc_dir_entry *)0); if ((unsigned long )proc_fs_nfs == (unsigned long )((struct proc_dir_entry *)0)) { goto error_0; } else { } p = proc_create("servers", 33060, proc_fs_nfs, & nfs_server_list_fops); if ((unsigned long )p == (unsigned long )((struct proc_dir_entry *)0)) { goto error_1; } else { } p = proc_create("volumes", 33060, proc_fs_nfs, & nfs_volume_list_fops); if ((unsigned long )p == (unsigned long )((struct proc_dir_entry *)0)) { goto error_2; } else { } return (0); error_2: remove_proc_entry("servers", proc_fs_nfs); error_1: remove_proc_entry("fs/nfsfs", (struct proc_dir_entry *)0); error_0: ; return (-12); } } void nfs_fs_proc_exit(void) { { remove_proc_entry("volumes", proc_fs_nfs); remove_proc_entry("servers", proc_fs_nfs); remove_proc_entry("fs/nfsfs", (struct proc_dir_entry *)0); return; } } int ldv_retval_0 ; void *ldv_retval_4 ; int ldv_retval_6 ; void *ldv_retval_1 ; void *ldv_retval_3 ; void *ldv_retval_2 ; void ldv_file_operations_71(void) { void *tmp ; void *tmp___0 ; { tmp = ldv_zalloc(1032UL); nfs_volume_list_fops_group1 = (struct inode *)tmp; tmp___0 = ldv_zalloc(360UL); nfs_volume_list_fops_group2 = (struct file *)tmp___0; return; } } void ldv_seq_operations_74(void) { void *tmp ; { tmp = ldv_zalloc(256UL); nfs_server_list_ops_group1 = (struct seq_file *)tmp; return; } } void ldv_seq_operations_72(void) { void *tmp ; { tmp = ldv_zalloc(256UL); nfs_volume_list_ops_group1 = (struct seq_file *)tmp; return; } } void ldv_file_operations_73(void) { void *tmp ; void *tmp___0 ; { tmp = ldv_zalloc(1032UL); nfs_server_list_fops_group1 = (struct inode *)tmp; tmp___0 = ldv_zalloc(360UL); nfs_server_list_fops_group2 = (struct file *)tmp___0; return; } } void ldv_main_exported_74(void) { int tmp ; { tmp = __VERIFIER_nondet_int(); switch (tmp) { case 0: ; if (ldv_state_variable_74 == 1) { ldv_retval_4 = nfs_server_list_start(nfs_server_list_ops_group1, nfs_server_list_ops_group3); if ((unsigned long )ldv_retval_4 == (unsigned long )((void *)0)) { ldv_state_variable_74 = 3; ref_cnt = ref_cnt + 1; } else { } if ((unsigned long )ldv_retval_4 != (unsigned long )((void *)0)) { ldv_state_variable_74 = 2; ref_cnt = ref_cnt + 1; } else { } } else { } goto ldv_53659; case 1: ; if (ldv_state_variable_74 == 3) { nfs_server_list_stop(nfs_server_list_ops_group1, nfs_server_list_ops_group2); ldv_state_variable_74 = 1; ref_cnt = ref_cnt - 1; } else { } if (ldv_state_variable_74 == 2) { nfs_server_list_stop(nfs_server_list_ops_group1, nfs_server_list_ops_group2); ldv_state_variable_74 = 1; ref_cnt = ref_cnt - 1; } else { } goto ldv_53659; case 2: ; if (ldv_state_variable_74 == 3) { nfs_server_list_show(nfs_server_list_ops_group1, (void *)nfs_server_list_ops_group3); ldv_state_variable_74 = 3; } else { } goto ldv_53659; case 3: ; if (ldv_state_variable_74 == 3) { ldv_retval_3 = nfs_server_list_next(nfs_server_list_ops_group1, nfs_server_list_ops_group2, nfs_server_list_ops_group3); if ((unsigned long )ldv_retval_3 == (unsigned long )((void *)0)) { ldv_state_variable_74 = 3; ref_cnt = ref_cnt + 1; } else { } if ((unsigned long )ldv_retval_3 != (unsigned long )((void *)0)) { ldv_state_variable_74 = 2; ref_cnt = ref_cnt + 1; } else { } } else { } goto ldv_53659; default: ldv_stop(); } ldv_53659: ; return; } } void ldv_main_exported_72(void) { int tmp ; { tmp = __VERIFIER_nondet_int(); switch (tmp) { case 0: ; if (ldv_state_variable_72 == 1) { ldv_retval_2 = nfs_volume_list_start(nfs_volume_list_ops_group1, nfs_volume_list_ops_group3); if ((unsigned long )ldv_retval_2 != (unsigned long )((void *)0)) { ldv_state_variable_72 = 3; ref_cnt = ref_cnt + 1; } else { } if ((unsigned long )ldv_retval_2 == (unsigned long )((void *)0)) { ldv_state_variable_72 = 2; ref_cnt = ref_cnt + 1; } else { } } else { } goto ldv_53668; case 1: ; if (ldv_state_variable_72 == 3) { nfs_volume_list_stop(nfs_volume_list_ops_group1, nfs_volume_list_ops_group2); ldv_state_variable_72 = 1; ref_cnt = ref_cnt - 1; } else { } if (ldv_state_variable_72 == 2) { nfs_volume_list_stop(nfs_volume_list_ops_group1, nfs_volume_list_ops_group2); ldv_state_variable_72 = 1; ref_cnt = ref_cnt - 1; } else { } goto ldv_53668; case 2: ; if (ldv_state_variable_72 == 2) { nfs_volume_list_show(nfs_volume_list_ops_group1, (void *)nfs_volume_list_ops_group3); ldv_state_variable_72 = 2; } else { } goto ldv_53668; case 3: ; if (ldv_state_variable_72 == 2) { ldv_retval_1 = nfs_volume_list_next(nfs_volume_list_ops_group1, nfs_volume_list_ops_group2, nfs_volume_list_ops_group3); if ((unsigned long )ldv_retval_1 == (unsigned long )((void *)0)) { ldv_state_variable_72 = 2; ref_cnt = ref_cnt + 1; } else { } if ((unsigned long )ldv_retval_1 != (unsigned long )((void *)0)) { ldv_state_variable_72 = 3; ref_cnt = ref_cnt + 1; } else { } } else { } goto ldv_53668; default: ldv_stop(); } ldv_53668: ; return; } } void ldv_main_exported_71(void) { size_t ldvarg15 ; size_t tmp ; char *ldvarg16 ; void *tmp___0 ; int ldvarg12 ; int tmp___1 ; loff_t ldvarg13 ; loff_t tmp___2 ; loff_t *ldvarg14 ; void *tmp___3 ; int tmp___4 ; { tmp = __VERIFIER_nondet_size_t(); ldvarg15 = tmp; tmp___0 = ldv_zalloc(1UL); ldvarg16 = (char *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); ldvarg12 = tmp___1; tmp___2 = __VERIFIER_nondet_loff_t(); ldvarg13 = tmp___2; tmp___3 = ldv_zalloc(8UL); ldvarg14 = (loff_t *)tmp___3; tmp___4 = __VERIFIER_nondet_int(); switch (tmp___4) { case 0: ; if (ldv_state_variable_71 == 2) { seq_release(nfs_volume_list_fops_group1, nfs_volume_list_fops_group2); ldv_state_variable_71 = 1; ref_cnt = ref_cnt - 1; } else { } goto ldv_53682; case 1: ; if (ldv_state_variable_71 == 2) { seq_read(nfs_volume_list_fops_group2, ldvarg16, ldvarg15, ldvarg14); ldv_state_variable_71 = 2; } else { } goto ldv_53682; case 2: ; if (ldv_state_variable_71 == 2) { seq_lseek(nfs_volume_list_fops_group2, ldvarg13, ldvarg12); ldv_state_variable_71 = 2; } else { } goto ldv_53682; case 3: ; if (ldv_state_variable_71 == 1) { ldv_retval_0 = nfs_volume_list_open(nfs_volume_list_fops_group1, nfs_volume_list_fops_group2); if (ldv_retval_0 == 0) { ldv_state_variable_71 = 2; ref_cnt = ref_cnt + 1; } else { } } else { } goto ldv_53682; default: ldv_stop(); } ldv_53682: ; return; } } void ldv_main_exported_73(void) { size_t ldvarg148 ; size_t tmp ; char *ldvarg149 ; void *tmp___0 ; loff_t ldvarg146 ; loff_t tmp___1 ; int ldvarg145 ; int tmp___2 ; loff_t *ldvarg147 ; void *tmp___3 ; int tmp___4 ; { tmp = __VERIFIER_nondet_size_t(); ldvarg148 = tmp; tmp___0 = ldv_zalloc(1UL); ldvarg149 = (char *)tmp___0; tmp___1 = __VERIFIER_nondet_loff_t(); ldvarg146 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); ldvarg145 = tmp___2; tmp___3 = ldv_zalloc(8UL); ldvarg147 = (loff_t *)tmp___3; tmp___4 = __VERIFIER_nondet_int(); switch (tmp___4) { case 0: ; if (ldv_state_variable_73 == 2) { seq_release(nfs_server_list_fops_group1, nfs_server_list_fops_group2); ldv_state_variable_73 = 1; ref_cnt = ref_cnt - 1; } else { } goto ldv_53696; case 1: ; if (ldv_state_variable_73 == 2) { seq_read(nfs_server_list_fops_group2, ldvarg149, ldvarg148, ldvarg147); ldv_state_variable_73 = 2; } else { } goto ldv_53696; case 2: ; if (ldv_state_variable_73 == 2) { seq_lseek(nfs_server_list_fops_group2, ldvarg146, ldvarg145); ldv_state_variable_73 = 2; } else { } goto ldv_53696; case 3: ; if (ldv_state_variable_73 == 1) { ldv_retval_6 = nfs_server_list_open(nfs_server_list_fops_group1, nfs_server_list_fops_group2); if (ldv_retval_6 == 0) { ldv_state_variable_73 = 2; ref_cnt = ref_cnt + 1; } else { } } else { } goto ldv_53696; default: ldv_stop(); } ldv_53696: ; return; } } bool ldv_try_module_get_7(struct module *ldv_func_arg1 ) { int tmp ; { tmp = ldv_try_module_get(ldv_func_arg1); return (tmp != 0); } } void ldv_module_put_8(struct module *ldv_func_arg1 ) { { ldv_module_put(ldv_func_arg1); return; } } bool ldv_try_module_get_9(struct module *ldv_func_arg1 ) { int tmp ; { tmp = ldv_try_module_get(ldv_func_arg1); return (tmp != 0); } } __inline static void list_del_init(struct list_head *entry ) { { __list_del_entry(entry); INIT_LIST_HEAD(entry); return; } } __inline static void list_move(struct list_head *list , struct list_head *head ) { { __list_del_entry(list); list_add(list, head); return; } } __inline static void list_move_tail(struct list_head *list , struct list_head *head ) { { __list_del_entry(list); list_add_tail(list, head); return; } } extern struct pv_irq_ops pv_irq_ops ; __inline static int test_and_set_bit(long nr , unsigned long volatile *addr ) { int oldbit ; { __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; bts %2,%1\n\tsbb %0,%0": "=r" (oldbit), "+m" (*((long volatile *)addr)): "Ir" (nr): "memory"); return (oldbit); } } __inline static int test_and_clear_bit(long nr , unsigned long volatile *addr ) { int oldbit ; { __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; btr %2,%1\n\tsbb %0,%0": "=r" (oldbit), "+m" (*((long volatile *)addr)): "Ir" (nr): "memory"); return (oldbit); } } extern int __printk_ratelimit(char const * ) ; extern void __might_sleep(char const * , int , int ) ; extern void *memset(void * , int , size_t ) ; extern int memcmp(void const * , void const * , size_t ) ; extern size_t strlen(char const * ) ; extern void *kmemdup(void const * , size_t , gfp_t ) ; __inline static unsigned long arch_local_save_flags(void) { unsigned long __ret ; unsigned long __edi ; unsigned long __esi ; unsigned long __edx ; unsigned long __ecx ; unsigned long __eax ; long tmp ; { __edi = __edi; __esi = __esi; __edx = __edx; __ecx = __ecx; __eax = __eax; tmp = ldv__builtin_expect((unsigned long )pv_irq_ops.save_fl.func == (unsigned long )((void *)0), 0L); if (tmp != 0L) { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/arch/x86/include/asm/paravirt.h"), "i" (804), "i" (12UL)); ldv_4800: ; goto ldv_4800; } else { } __asm__ volatile ("771:\n\tcall *%c2;\n772:\n.pushsection .parainstructions,\"a\"\n .balign 8 \n .quad 771b\n .byte %c1\n .byte 772b-771b\n .short %c3\n.popsection\n": "=a" (__eax): [paravirt_typenum] "i" (44UL), [paravirt_opptr] "i" (& pv_irq_ops.save_fl.func), [paravirt_clobber] "i" (1): "memory", "cc"); __ret = __eax; return (__ret); } } __inline static void *ERR_CAST(void const *ptr ) { { return ((void *)ptr); } } __inline static int arch_irqs_disabled_flags(unsigned long flags ) { { return ((flags & 512UL) == 0UL); } } __inline static long atomic64_read(atomic64_t const *v ) { { return ((long )*((long volatile *)(& v->counter))); } } __inline static void atomic64_inc(atomic64_t *v ) { { __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; incq %0": "=m" (v->counter): "m" (v->counter)); return; } } __inline static void atomic64_dec(atomic64_t *v ) { { __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; decq %0": "=m" (v->counter): "m" (v->counter)); return; } } __inline static long atomic_long_read(atomic_long_t *l ) { atomic64_t *v ; long tmp ; { v = l; tmp = atomic64_read((atomic64_t const *)v); return (tmp); } } __inline static void atomic_long_inc(atomic_long_t *l ) { atomic64_t *v ; { v = l; atomic64_inc(v); return; } } __inline static void atomic_long_dec(atomic_long_t *l ) { atomic64_t *v ; { v = l; atomic64_dec(v); return; } } extern int debug_locks ; __inline static bool static_key_false(struct static_key *key ) { int tmp ; long tmp___0 ; { tmp = atomic_read((atomic_t const *)(& key->enabled)); tmp___0 = ldv__builtin_expect(tmp != 0, 0L); if (tmp___0 > 0L) { return (1); } else { } return (0); } } extern struct lockdep_map rcu_sched_lock_map ; __inline static int rcu_read_lock_sched_held(void) { int lockdep_opinion ; int tmp ; int tmp___0 ; bool tmp___1 ; int tmp___2 ; struct thread_info *tmp___3 ; unsigned long _flags ; int tmp___4 ; int tmp___5 ; { lockdep_opinion = 0; tmp = debug_lockdep_rcu_enabled(); if (tmp == 0) { return (1); } else { } tmp___0 = rcu_is_cpu_idle(); if (tmp___0 != 0) { return (0); } else { } tmp___1 = rcu_lockdep_current_cpu_online(); if (tmp___1) { tmp___2 = 0; } else { tmp___2 = 1; } if (tmp___2) { return (0); } else { } if (debug_locks != 0) { lockdep_opinion = lock_is_held(& rcu_sched_lock_map); } else { } if (lockdep_opinion != 0) { tmp___5 = 1; } else { tmp___3 = current_thread_info(); if (tmp___3->preempt_count != 0) { tmp___5 = 1; } else { _flags = arch_local_save_flags(); tmp___4 = arch_irqs_disabled_flags(_flags); if (tmp___4 != 0) { tmp___5 = 1; } else { tmp___5 = 0; } } } return (tmp___5); } } extern void rb_insert_color(struct rb_node * , struct rb_root * ) ; extern void rb_erase(struct rb_node * , struct rb_root * ) ; extern struct rb_node *rb_first(struct rb_root const * ) ; extern void rb_replace_node(struct rb_node * , struct rb_node * , struct rb_root * ) ; __inline static void rb_link_node(struct rb_node *node , struct rb_node *parent , struct rb_node **rb_link ) { struct rb_node *tmp ; { node->__rb_parent_color = (unsigned long )parent; tmp = (struct rb_node *)0; node->rb_right = tmp; node->rb_left = tmp; *rb_link = node; return; } } extern void __bad_size_call_parameter(void) ; extern struct page *alloc_pages_current(gfp_t , unsigned int ) ; __inline static struct page *alloc_pages(gfp_t gfp_mask , unsigned int order ) { struct page *tmp ; { tmp = alloc_pages_current(gfp_mask, order); return (tmp); } } extern void __free_pages(struct page * , unsigned int ) ; extern void kmemleak_not_leak(void const * ) ; extern unsigned int __VERIFIER_nondet_uint(void) ; int ldv_state_variable_66 ; struct dentry *nfs4_dentry_operations_group0 ; struct dentry *nfs_dentry_operations_group0 ; int ldv_state_variable_68 ; int ldv_state_variable_69 ; int ldv_state_variable_65 ; int ldv_state_variable_70 ; struct inode *nfs_dir_operations_group1 ; int ldv_state_variable_67 ; struct file *nfs_dir_operations_group2 ; void ldv_file_operations_70(void) ; void ldv_initialize_dentry_operations_67(void) ; void ldv_initialize_dentry_operations_68(void) ; void ldv_initialize_dentry_operations_65(void) ; void ldv_initialize_dentry_operations_66(void) ; __inline static void SetPageUptodate(struct page *page ) { { __asm__ volatile ("": : : "memory"); set_bit(3L, (unsigned long volatile *)(& page->flags)); return; } } extern void put_page(struct page * ) ; __inline static void *lowmem_page_address(struct page const *page ) { { return ((void *)((unsigned long )((unsigned long long )(((long )page + 24189255811072L) / 64L) << 12) + 0xffff880000000000UL)); } } extern void xdr_init_decode_pages(struct xdr_stream * , struct xdr_buf * , struct page ** , unsigned int ) ; extern void xdr_set_scratch_buffer(struct xdr_stream * , void * , size_t ) ; extern struct rpc_cred *rpc_lookup_cred(void) ; __inline static struct rpc_cred *get_rpccred(struct rpc_cred *cred ) { { atomic_inc(& cred->cr_count); return (cred); } } __inline static int new_valid_dev(dev_t dev ) { { return (1); } } __inline static int hlist_bl_unhashed(struct hlist_bl_node const *h ) { { return ((unsigned long )h->pprev == (unsigned long )((struct hlist_bl_node **/* const */)0)); } } extern unsigned int full_name_hash(unsigned char const * , unsigned int ) ; extern void d_instantiate(struct dentry * , struct inode * ) ; extern struct dentry *d_materialise_unique(struct dentry * , struct inode * ) ; extern void __d_drop(struct dentry * ) ; extern void d_drop(struct dentry * ) ; extern void d_delete(struct dentry * ) ; extern struct dentry *d_alloc(struct dentry * , struct qstr const * ) ; extern int d_invalidate(struct dentry * ) ; extern int check_submounts_and_drop(struct dentry * ) ; extern void d_rehash(struct dentry * ) ; __inline static void d_add(struct dentry *entry , struct inode *inode ) { { d_instantiate(entry, inode); d_rehash(entry); return; } } extern void d_move(struct dentry * , struct dentry * ) ; extern struct dentry *d_lookup(struct dentry const * , struct qstr const * ) ; __inline static unsigned int d_count(struct dentry const *dentry ) { { return ((unsigned int )dentry->d_lockref.ldv_22558.ldv_22557.count); } } extern struct dentry *dget_parent(struct dentry * ) ; __inline static int d_unhashed(struct dentry const *dentry ) { int tmp ; { tmp = hlist_bl_unhashed(& dentry->d_hash); return (tmp); } } extern void dput(struct dentry * ) ; __inline static bool d_mountpoint(struct dentry const *dentry ) { { return (((unsigned int )dentry->d_flags & 65536U) != 0U); } } extern int sysctl_vfs_cache_pressure ; __inline static unsigned long vfs_pressure_ratio(unsigned long val ) { unsigned long quot ; unsigned long rem ; { quot = val / 100UL; rem = val % 100UL; return ((unsigned long )sysctl_vfs_cache_pressure * quot + ((unsigned long )sysctl_vfs_cache_pressure * rem) / 100UL); } } extern void clear_nlink(struct inode * ) ; extern int current_umask(void) ; extern int finish_open(struct file * , struct dentry * , int (*)(struct inode * , struct file * ) , int * ) ; extern int finish_no_open(struct file * , struct dentry * ) ; extern int is_bad_inode(struct inode * ) ; extern int invalidate_inode_pages2_range(struct address_space * , unsigned long , unsigned long ) ; extern int write_inode_now(struct inode * , int ) ; extern int generic_permission(struct inode * , int ) ; __inline static bool execute_ok(struct inode *inode ) { { return ((bool )(((int )inode->i_mode & 73) != 0 || ((int )inode->i_mode & 61440) == 16384)); } } __inline static struct inode *file_inode(struct file *f ) { { return (f->f_inode); } } extern void ihold(struct inode * ) ; extern void iput(struct inode * ) ; extern ssize_t generic_read_dir(struct file * , char * , size_t , loff_t * ) ; __inline static bool dir_emit(struct dir_context *ctx , char const *name , int namelen , u64 ino , unsigned int type ) { int tmp ; { tmp = (*(ctx->actor))((void *)ctx, name, namelen, ctx->pos, ino, type); return (tmp == 0); } } __inline static void *kmap(struct page *page ) { void *tmp ; { __might_sleep("include/linux/highmem.h", 58, 0); tmp = lowmem_page_address((struct page const *)page); return (tmp); } } __inline static void kunmap(struct page *page ) { { return; } } __inline static void *kmap_atomic(struct page *page ) { void *tmp ; { __rcu_read_lock(); tmp = lowmem_page_address((struct page const *)page); return (tmp); } } __inline static void __kunmap_atomic(void *addr ) { { __rcu_read_unlock(); return; } } extern struct page *read_cache_page(struct address_space * , unsigned long , filler_t * , void * ) ; extern void unlock_page(struct page * ) ; extern int add_to_page_cache_lru(struct page * , struct address_space * , unsigned long , gfp_t ) ; __inline static int nfs_compare_fh(struct nfs_fh const *a , struct nfs_fh const *b ) { int tmp ; int tmp___0 ; { if ((int )((unsigned short )a->size) != (int )((unsigned short )b->size)) { tmp___0 = 1; } else { tmp = memcmp((void const *)(& a->data), (void const *)(& b->data), (size_t )a->size); if (tmp != 0) { tmp___0 = 1; } else { tmp___0 = 0; } } return (tmp___0); } } __inline static struct nfs_inode *NFS_I(struct inode const *inode ) { struct inode const *__mptr ; { __mptr = inode; return ((struct nfs_inode *)__mptr + 0xfffffffffffffd80UL); } } __inline static struct nfs_server *NFS_SB(struct super_block const *s ) { { return ((struct nfs_server *)s->s_fs_info); } } __inline static struct nfs_fh *NFS_FH(struct inode const *inode ) { struct nfs_inode *tmp ; { tmp = NFS_I(inode); return (& tmp->fh); } } __inline static struct nfs_server *NFS_SERVER(struct inode const *inode ) { struct nfs_server *tmp ; { tmp = NFS_SB((struct super_block const *)inode->i_sb); return (tmp); } } __inline static struct nfs_rpc_ops const *NFS_PROTO(struct inode const *inode ) { struct nfs_server *tmp ; { tmp = NFS_SERVER(inode); return ((tmp->nfs_client)->rpc_ops); } } __inline static int NFS_STALE(struct inode const *inode ) { struct nfs_inode *tmp ; int tmp___0 ; { tmp = NFS_I(inode); tmp___0 = constant_test_bit(1L, (unsigned long const volatile *)(& tmp->flags)); return (tmp___0); } } __inline static void nfs_mark_for_revalidate(struct inode *inode ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; spin_lock(& inode->i_lock); nfsi->cache_validity = nfsi->cache_validity | 9UL; if (((int )inode->i_mode & 61440) == 16384) { nfsi->cache_validity = nfsi->cache_validity | 34UL; } else { } spin_unlock(& inode->i_lock); return; } } __inline static int nfs_server_capable(struct inode *inode , int cap ) { struct nfs_server *tmp ; { tmp = NFS_SERVER((struct inode const *)inode); return ((int )(tmp->caps & (unsigned int )cap)); } } __inline static void nfs_set_verifier(struct dentry *dentry , unsigned long verf ) { { dentry->d_time = verf; return; } } __inline static unsigned long nfs_save_change_attribute(struct inode *dir ) { struct nfs_inode *tmp ; { tmp = NFS_I((struct inode const *)dir); return (tmp->cache_change_attribute); } } __inline static int nfs_verify_change_attribute(struct inode *dir , unsigned long chattr ) { struct nfs_inode *tmp ; { tmp = NFS_I((struct inode const *)dir); return (tmp->cache_change_attribute == chattr); } } void nfs_zap_mapping(struct inode *inode , struct address_space *mapping ) ; void nfs_zap_caches(struct inode *inode ) ; struct inode *nfs_fhget(struct super_block *sb , struct nfs_fh *fh , struct nfs_fattr *fattr , struct nfs4_label *label ) ; int nfs_refresh_inode(struct inode *inode , struct nfs_fattr *fattr ) ; void nfs_access_add_cache(struct inode *inode , struct nfs_access_entry *set ) ; void nfs_access_set_mask(struct nfs_access_entry *entry , u32 access_result ) ; int nfs_permission(struct inode *inode , int mask ) ; int nfs_attribute_cache_expired(struct inode *inode ) ; int nfs_revalidate_inode(struct nfs_server *server , struct inode *inode ) ; int __nfs_revalidate_inode(struct nfs_server *server , struct inode *inode ) ; int nfs_revalidate_mapping(struct inode *inode , struct address_space *mapping ) ; void nfs_setsecurity(struct inode *inode , struct nfs_fattr *fattr , struct nfs4_label *label ) ; void put_nfs_open_context(struct nfs_open_context *ctx ) ; struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry , fmode_t f_mode ) ; void nfs_file_set_open_context(struct file *filp , struct nfs_open_context *ctx ) ; u64 nfs_compat_user_ino64(u64 fileid ) ; unsigned long nfs_inc_attr_generation_counter(void) ; struct nfs_fh *nfs_alloc_fhandle(void) ; __inline static void nfs_free_fhandle(struct nfs_fh const *fh ) { { kfree((void const *)fh); return; } } struct address_space_operations const nfs_dir_aops ; struct file_operations const nfs_dir_operations ; struct dentry_operations const nfs_dentry_operations ; void nfs_force_lookup_revalidate(struct inode *dir ) ; int nfs_instantiate(struct dentry *dentry , struct nfs_fh *fhandle , struct nfs_fattr *fattr , struct nfs4_label *label ) ; int nfs_may_open(struct inode *inode , struct rpc_cred *cred , int openflags ) ; void nfs_access_zap_cache(struct inode *inode ) ; struct nfs4_label *nfs4_label_alloc(struct nfs_server *server , gfp_t flags ) ; __inline static void nfs4_label_free(struct nfs4_label *label ) { { if ((unsigned long )label != (unsigned long )((struct nfs4_label *)0)) { kfree((void const *)label->label); kfree((void const *)label); } else { } return; } } void nfs_complete_unlink(struct dentry *dentry , struct inode *inode ) ; void nfs_wait_on_sillyrename(struct dentry *dentry ) ; void nfs_block_sillyrename(struct dentry *dentry ) ; void nfs_unblock_sillyrename(struct dentry *dentry ) ; int nfs_sillyrename(struct inode *dir , struct dentry *dentry ) ; __inline static int nfs_have_delegated_attributes(struct inode *inode ) { struct nfs_rpc_ops const *tmp ; int tmp___0 ; struct nfs_inode *tmp___1 ; int tmp___2 ; { tmp = NFS_PROTO((struct inode const *)inode); tmp___0 = (*(tmp->have_delegation))(inode, 1U); if (tmp___0 != 0) { tmp___1 = NFS_I((struct inode const *)inode); if ((tmp___1->cache_validity & 64UL) == 0UL) { tmp___2 = 1; } else { tmp___2 = 0; } } else { tmp___2 = 0; } return (tmp___2); } } __inline static void nfs_inc_server_stats(struct nfs_server const *server , enum nfs_stat_eventcounters stat ) { void const *__vpp_verify ; int pao_ID__ ; int pao_ID_____0 ; int pao_ID_____1 ; int pao_ID_____2 ; { __vpp_verify = (void const *)0; switch (8UL) { case 1UL: pao_ID__ = 1; switch (8UL) { case 1UL: ; if (pao_ID__ == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_50222; case 2UL: ; if (pao_ID__ == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50222; case 4UL: ; if (pao_ID__ == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50222; case 8UL: ; if (pao_ID__ == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_50222; default: __bad_percpu_size(); } ldv_50222: ; goto ldv_50227; case 2UL: pao_ID_____0 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____0 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_50233; case 2UL: ; if (pao_ID_____0 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50233; case 4UL: ; if (pao_ID_____0 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50233; case 8UL: ; if (pao_ID_____0 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_50233; default: __bad_percpu_size(); } ldv_50233: ; goto ldv_50227; case 4UL: pao_ID_____1 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____1 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_50243; case 2UL: ; if (pao_ID_____1 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50243; case 4UL: ; if (pao_ID_____1 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50243; case 8UL: ; if (pao_ID_____1 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_50243; default: __bad_percpu_size(); } ldv_50243: ; goto ldv_50227; case 8UL: pao_ID_____2 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____2 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_50253; case 2UL: ; if (pao_ID_____2 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50253; case 4UL: ; if (pao_ID_____2 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50253; case 8UL: ; if (pao_ID_____2 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_50253; default: __bad_percpu_size(); } ldv_50253: ; goto ldv_50227; default: __bad_size_call_parameter(); goto ldv_50227; } ldv_50227: ; return; } } __inline static void nfs_inc_stats(struct inode const *inode , enum nfs_stat_eventcounters stat ) { struct nfs_server *tmp ; { tmp = NFS_SERVER(inode); nfs_inc_server_stats((struct nfs_server const *)tmp, stat); return; } } struct dentry_operations const nfs4_dentry_operations ; int nfs_atomic_open(struct inode *dir , struct dentry *dentry , struct file *file , unsigned int open_flags , umode_t mode , int *opened ) ; unsigned long nfs_access_cache_count(struct shrinker *shrink , struct shrink_control *sc ) ; unsigned long nfs_access_cache_scan(struct shrinker *shrink , struct shrink_control *sc ) ; struct dentry *nfs_lookup(struct inode *dir , struct dentry *dentry , unsigned int flags ) ; int nfs_create(struct inode *dir , struct dentry *dentry , umode_t mode , bool excl ) ; int nfs_mkdir(struct inode *dir , struct dentry *dentry , umode_t mode ) ; int nfs_rmdir(struct inode *dir , struct dentry *dentry ) ; int nfs_unlink(struct inode *dir , struct dentry *dentry ) ; int nfs_symlink(struct inode *dir , struct dentry *dentry , char const *symname ) ; int nfs_link(struct dentry *old_dentry , struct inode *dir , struct dentry *dentry ) ; int nfs_mknod(struct inode *dir , struct dentry *dentry , umode_t mode , dev_t rdev ) ; int nfs_rename(struct inode *old_dir , struct dentry *old_dentry , struct inode *new_dir , struct dentry *new_dentry ) ; int nfs_check_flags(int flags ) ; struct vfsmount *nfs_d_automount(struct path *path ) ; void nfs_fscache_set_inode_cookie(struct inode *inode , struct file *filp ) ; struct tracepoint __tracepoint_nfs_access_enter ; __inline static void trace_nfs_access_enter(struct inode const *inode ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_access_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_access_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 157, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52336: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * ))it_func))(__data, inode); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52336; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_access_exit ; __inline static void trace_nfs_access_exit(struct inode const *inode , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_access_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_access_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 158, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52369: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , int ))it_func))(__data, inode, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52369; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_lookup_enter ; __inline static void trace_nfs_lookup_enter(struct inode const *dir , struct dentry const *dentry , unsigned int flags ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_lookup_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_lookup_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 257, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52407: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * , unsigned int ))it_func))(__data, dir, dentry, flags); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52407; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_lookup_exit ; __inline static void trace_nfs_lookup_exit(struct inode const *dir , struct dentry const *dentry , unsigned int flags , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_lookup_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_lookup_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 258, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52450: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * , unsigned int , int ))it_func))(__data, dir, dentry, flags, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52450; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_lookup_revalidate_enter ; __inline static void trace_nfs_lookup_revalidate_enter(struct inode const *dir , struct dentry const *dentry , unsigned int flags ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_lookup_revalidate_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_lookup_revalidate_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 259, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52494: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * , unsigned int ))it_func))(__data, dir, dentry, flags); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52494; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_lookup_revalidate_exit ; __inline static void trace_nfs_lookup_revalidate_exit(struct inode const *dir , struct dentry const *dentry , unsigned int flags , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_lookup_revalidate_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_lookup_revalidate_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 260, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52537: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * , unsigned int , int ))it_func))(__data, dir, dentry, flags, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52537; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_atomic_open_enter ; __inline static void trace_nfs_atomic_open_enter(struct inode const *dir , struct nfs_open_context const *ctx , unsigned int flags ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_atomic_open_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_atomic_open_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 312, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52581: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct nfs_open_context const * , unsigned int ))it_func))(__data, dir, ctx, flags); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52581; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_atomic_open_exit ; __inline static void trace_nfs_atomic_open_exit(struct inode const *dir , struct nfs_open_context const *ctx , unsigned int flags , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_atomic_open_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_atomic_open_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 353, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52624: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct nfs_open_context const * , unsigned int , int ))it_func))(__data, dir, ctx, flags, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52624; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_create_enter ; __inline static void trace_nfs_create_enter(struct inode const *dir , struct dentry const *dentry , unsigned int flags ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_create_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_create_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 386, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52668: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * , unsigned int ))it_func))(__data, dir, dentry, flags); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52668; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_create_exit ; __inline static void trace_nfs_create_exit(struct inode const *dir , struct dentry const *dentry , unsigned int flags , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_create_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_create_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 423, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52711: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * , unsigned int , int ))it_func))(__data, dir, dentry, flags, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52711; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_mknod_enter ; __inline static void trace_nfs_mknod_enter(struct inode const *dir , struct dentry const *dentry ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_mknod_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_mknod_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 502, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52753: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * ))it_func))(__data, dir, dentry); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52753; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_mknod_exit ; __inline static void trace_nfs_mknod_exit(struct inode const *dir , struct dentry const *dentry , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_mknod_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_mknod_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 503, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52791: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * , int ))it_func))(__data, dir, dentry, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52791; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_mkdir_enter ; __inline static void trace_nfs_mkdir_enter(struct inode const *dir , struct dentry const *dentry ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_mkdir_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_mkdir_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 504, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52830: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * ))it_func))(__data, dir, dentry); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52830; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_mkdir_exit ; __inline static void trace_nfs_mkdir_exit(struct inode const *dir , struct dentry const *dentry , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_mkdir_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_mkdir_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 505, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52868: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * , int ))it_func))(__data, dir, dentry, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52868; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_rmdir_enter ; __inline static void trace_nfs_rmdir_enter(struct inode const *dir , struct dentry const *dentry ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_rmdir_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_rmdir_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 506, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52907: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * ))it_func))(__data, dir, dentry); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52907; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_rmdir_exit ; __inline static void trace_nfs_rmdir_exit(struct inode const *dir , struct dentry const *dentry , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_rmdir_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_rmdir_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 507, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52945: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * , int ))it_func))(__data, dir, dentry, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52945; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_remove_enter ; __inline static void trace_nfs_remove_enter(struct inode const *dir , struct dentry const *dentry ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_remove_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_remove_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 508, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52984: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * ))it_func))(__data, dir, dentry); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52984; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_remove_exit ; __inline static void trace_nfs_remove_exit(struct inode const *dir , struct dentry const *dentry , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_remove_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_remove_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 509, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_53022: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * , int ))it_func))(__data, dir, dentry, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_53022; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_unlink_enter ; __inline static void trace_nfs_unlink_enter(struct inode const *dir , struct dentry const *dentry ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_unlink_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_unlink_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 510, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_53061: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * ))it_func))(__data, dir, dentry); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_53061; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_unlink_exit ; __inline static void trace_nfs_unlink_exit(struct inode const *dir , struct dentry const *dentry , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_unlink_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_unlink_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 511, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_53099: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * , int ))it_func))(__data, dir, dentry, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_53099; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_symlink_enter ; __inline static void trace_nfs_symlink_enter(struct inode const *dir , struct dentry const *dentry ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_symlink_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_symlink_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 512, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_53138: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * ))it_func))(__data, dir, dentry); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_53138; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_symlink_exit ; __inline static void trace_nfs_symlink_exit(struct inode const *dir , struct dentry const *dentry , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_symlink_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_symlink_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 513, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_53176: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * , int ))it_func))(__data, dir, dentry, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_53176; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_link_enter ; __inline static void trace_nfs_link_enter(struct inode const *inode , struct inode const *dir , struct dentry const *dentry ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_link_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_link_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 546, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_53217: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct inode const * , struct dentry const * ))it_func))(__data, inode, dir, dentry); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_53217; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_link_exit ; __inline static void trace_nfs_link_exit(struct inode const *inode , struct inode const *dir , struct dentry const *dentry , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_link_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_link_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 583, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_53260: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct inode const * , struct dentry const * , int ))it_func))(__data, inode, dir, dentry, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_53260; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_rename_enter ; __inline static void trace_nfs_rename_enter(struct inode const *old_dir , struct dentry const *old_dentry , struct inode const *new_dir , struct dentry const *new_dentry ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_rename_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_rename_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 684, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_53306: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * , struct inode const * , struct dentry const * ))it_func))(__data, old_dir, old_dentry, new_dir, new_dentry); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_53306; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_rename_exit ; __inline static void trace_nfs_rename_exit(struct inode const *old_dir , struct dentry const *old_dentry , struct inode const *new_dir , struct dentry const *new_dentry , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_rename_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_rename_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 685, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_53354: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * , struct inode const * , struct dentry const * , int ))it_func))(__data, old_dir, old_dentry, new_dir, new_dentry, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_53354; } else { } } else { } __rcu_read_unlock(); } else { } return; } } static int nfs_opendir(struct inode *inode , struct file *filp ) ; static int nfs_closedir(struct inode *inode , struct file *filp ) ; static int nfs_readdir(struct file *file , struct dir_context *ctx ) ; static int nfs_fsync_dir(struct file *filp , loff_t start , loff_t end , int datasync ) ; static loff_t nfs_llseek_dir(struct file *filp , loff_t offset , int whence ) ; static void nfs_readdir_clear_array(struct page *page ) ; struct file_operations const nfs_dir_operations = {0, & nfs_llseek_dir, & generic_read_dir, 0, 0, 0, & nfs_readdir, 0, 0, 0, 0, & nfs_opendir, 0, & nfs_closedir, & nfs_fsync_dir, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; struct address_space_operations const nfs_dir_aops = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, & nfs_readdir_clear_array, 0, 0, 0, 0, 0, 0, 0, 0, 0}; static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct inode *dir , struct rpc_cred *cred ) { struct nfs_open_dir_context *ctx ; void *tmp ; struct nfs_inode *tmp___0 ; void *tmp___1 ; { tmp = kmalloc(40UL, 208U); ctx = (struct nfs_open_dir_context *)tmp; if ((unsigned long )ctx != (unsigned long )((struct nfs_open_dir_context *)0)) { ctx->duped = 0; tmp___0 = NFS_I((struct inode const *)dir); ctx->attr_gencount = tmp___0->attr_gencount; ctx->dir_cookie = 0ULL; ctx->dup_cookie = 0ULL; ctx->cred = get_rpccred(cred); return (ctx); } else { } tmp___1 = ERR_PTR(-12L); return ((struct nfs_open_dir_context *)tmp___1); } } static void put_nfs_open_dir_context(struct nfs_open_dir_context *ctx ) { { put_rpccred(ctx->cred); kfree((void const *)ctx); return; } } static int nfs_opendir(struct inode *inode , struct file *filp ) { int res ; struct nfs_open_dir_context *ctx ; struct rpc_cred *cred ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; struct nfs_server *tmp___4 ; { res = 0; tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: open dir(%s/%s)\n", ((filp->f_path.dentry)->d_parent)->d_name.name, (filp->f_path.dentry)->d_name.name); } else { } nfs_inc_stats((struct inode const *)inode, 4); cred = rpc_lookup_cred(); tmp___1 = IS_ERR((void const *)cred); if (tmp___1 != 0L) { tmp___0 = PTR_ERR((void const *)cred); return ((int )tmp___0); } else { } ctx = alloc_nfs_open_dir_context(inode, cred); tmp___3 = IS_ERR((void const *)ctx); if (tmp___3 != 0L) { tmp___2 = PTR_ERR((void const *)ctx); res = (int )tmp___2; goto out; } else { } filp->private_data = (void *)ctx; if ((unsigned long )filp->f_path.dentry == (unsigned long )(filp->f_path.mnt)->mnt_root) { tmp___4 = NFS_SERVER((struct inode const *)inode); __nfs_revalidate_inode(tmp___4, inode); } else { } out: put_rpccred(cred); return (res); } } static int nfs_closedir(struct inode *inode , struct file *filp ) { { put_nfs_open_dir_context((struct nfs_open_dir_context *)filp->private_data); return (0); } } static struct nfs_cache_array *nfs_readdir_get_array(struct page *page ) { void *ptr ; void *tmp ; void *tmp___0 ; { if ((unsigned long )page == (unsigned long )((struct page *)0)) { tmp = ERR_PTR(-5L); return ((struct nfs_cache_array *)tmp); } else { } ptr = kmap(page); if ((unsigned long )ptr == (unsigned long )((void *)0)) { tmp___0 = ERR_PTR(-12L); return ((struct nfs_cache_array *)tmp___0); } else { } return ((struct nfs_cache_array *)ptr); } } static void nfs_readdir_release_array(struct page *page ) { { kunmap(page); return; } } static void nfs_readdir_clear_array(struct page *page ) { struct nfs_cache_array *array ; int i ; void *tmp ; { tmp = kmap_atomic(page); array = (struct nfs_cache_array *)tmp; i = 0; goto ldv_53556; ldv_53555: kfree((void const *)array->array[i].string.name); i = i + 1; ldv_53556: ; if (array->size > i) { goto ldv_53555; } else { } __kunmap_atomic((void *)array); return; } } static int nfs_readdir_make_qstr(struct qstr *string , char const *name , unsigned int len ) { void *tmp ; { string->ldv_22580.ldv_22578.len = len; tmp = kmemdup((void const *)name, (size_t )len, 208U); string->name = (unsigned char const *)tmp; if ((unsigned long )string->name == (unsigned long )((unsigned char const *)0U)) { return (-12); } else { } kmemleak_not_leak((void const *)string->name); string->ldv_22580.ldv_22578.hash = full_name_hash((unsigned char const *)name, len); return (0); } } static int nfs_readdir_add_to_array(struct nfs_entry *entry , struct page *page ) { struct nfs_cache_array *array ; struct nfs_cache_array *tmp ; struct nfs_cache_array_entry *cache_entry ; int ret ; long tmp___0 ; long tmp___1 ; void *tmp___2 ; { tmp = nfs_readdir_get_array(page); array = tmp; tmp___1 = IS_ERR((void const *)array); if (tmp___1 != 0L) { tmp___0 = PTR_ERR((void const *)array); return ((int )tmp___0); } else { } cache_entry = (struct nfs_cache_array_entry *)(& array->array) + (unsigned long )array->size; ret = -28; tmp___2 = lowmem_page_address((struct page const *)page); if ((unsigned long )((long )((char *)cache_entry + 1U) - (long )tmp___2) > 4096UL) { goto out; } else { } cache_entry->cookie = entry->prev_cookie; cache_entry->ino = entry->ino; cache_entry->d_type = entry->d_type; ret = nfs_readdir_make_qstr(& cache_entry->string, entry->name, entry->len); if (ret != 0) { goto out; } else { } array->last_cookie = entry->cookie; array->size = array->size + 1; if (entry->eof != 0) { array->eof_index = array->size; } else { } out: nfs_readdir_release_array(page); return (ret); } } static int nfs_readdir_search_for_pos(struct nfs_cache_array *array , nfs_readdir_descriptor_t *desc ) { loff_t diff ; unsigned int index ; { diff = (desc->ctx)->pos - desc->current_index; if (diff < 0LL) { goto out_eof; } else { } if ((loff_t )array->size <= diff) { if (array->eof_index >= 0) { goto out_eof; } else { } return (-11); } else { } index = (unsigned int )diff; *(desc->dir_cookie) = array->array[index].cookie; desc->cache_entry_index = index; return (0); out_eof: desc->eof = 1U; return (-523); } } static int nfs_readdir_search_for_cookie(struct nfs_cache_array *array , nfs_readdir_descriptor_t *desc ) { int i ; loff_t new_pos ; int status ; struct nfs_inode *nfsi ; struct inode *tmp ; struct nfs_inode *tmp___0 ; struct nfs_open_dir_context *ctx ; int tmp___1 ; { status = -11; i = 0; goto ldv_53590; ldv_53589: ; if (array->array[i].cookie == *(desc->dir_cookie)) { tmp = file_inode(desc->file); tmp___0 = NFS_I((struct inode const *)tmp); nfsi = tmp___0; ctx = (struct nfs_open_dir_context *)(desc->file)->private_data; new_pos = desc->current_index + (loff_t )i; if (ctx->attr_gencount != nfsi->attr_gencount || (nfsi->cache_validity & 3UL) != 0UL) { ctx->duped = 0; ctx->attr_gencount = nfsi->attr_gencount; } else if ((desc->ctx)->pos > new_pos) { if ((int )ctx->duped > 0 && ctx->dup_cookie == *(desc->dir_cookie)) { tmp___1 = __printk_ratelimit("nfs_readdir_search_for_cookie"); if (tmp___1 != 0) { printk("\rNFS: directory %s/%s contains a readdir loop.Please contact your server vendor. The file: %s has duplicate cookie %llu\n", (((desc->file)->f_path.dentry)->d_parent)->d_name.name, ((desc->file)->f_path.dentry)->d_name.name, array->array[i].string.name, *(desc->dir_cookie)); } else { } status = -40; goto out; } else { } ctx->dup_cookie = *(desc->dir_cookie); ctx->duped = -1; } else { } (desc->ctx)->pos = new_pos; desc->cache_entry_index = (unsigned int )i; return (0); } else { } i = i + 1; ldv_53590: ; if (array->size > i) { goto ldv_53589; } else { } if (array->eof_index >= 0) { status = -523; if (*(desc->dir_cookie) == array->last_cookie) { desc->eof = 1U; } else { } } else { } out: ; return (status); } } static int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc ) { struct nfs_cache_array *array ; int status ; long tmp ; long tmp___0 ; { array = nfs_readdir_get_array(desc->page); tmp___0 = IS_ERR((void const *)array); if (tmp___0 != 0L) { tmp = PTR_ERR((void const *)array); status = (int )tmp; goto out; } else { } if (*(desc->dir_cookie) == 0ULL) { status = nfs_readdir_search_for_pos(array, desc); } else { status = nfs_readdir_search_for_cookie(array, desc); } if (status == -11) { desc->last_cookie = array->last_cookie; desc->current_index = desc->current_index + (loff_t )array->size; desc->page_index = desc->page_index + 1UL; } else { } nfs_readdir_release_array(desc->page); out: ; return (status); } } static int nfs_readdir_xdr_filler(struct page **pages , nfs_readdir_descriptor_t *desc , struct nfs_entry *entry , struct file *file , struct inode *inode ) { struct nfs_open_dir_context *ctx ; struct rpc_cred *cred ; unsigned long timestamp ; unsigned long gencount ; int error ; struct nfs_rpc_ops const *tmp ; struct nfs_server *tmp___0 ; struct nfs_server *tmp___1 ; struct nfs_inode *tmp___2 ; { ctx = (struct nfs_open_dir_context *)file->private_data; cred = ctx->cred; again: timestamp = jiffies; gencount = nfs_inc_attr_generation_counter(); tmp = NFS_PROTO((struct inode const *)inode); tmp___0 = NFS_SERVER((struct inode const *)inode); error = (*(tmp->readdir))(file->f_path.dentry, cred, entry->cookie, pages, tmp___0->dtsize, (int )desc->plus); if (error < 0) { if (error == -524 && (unsigned int )*((unsigned char *)desc + 84UL) != 0U) { tmp___1 = NFS_SERVER((struct inode const *)inode); tmp___1->caps = tmp___1->caps & 4294967294U; tmp___2 = NFS_I((struct inode const *)inode); clear_bit(0L, (unsigned long volatile *)(& tmp___2->flags)); desc->plus = 0U; goto again; } else { } goto error; } else { } desc->timestamp = timestamp; desc->gencount = gencount; error: ; return (error); } } static int xdr_decode(nfs_readdir_descriptor_t *desc , struct nfs_entry *entry , struct xdr_stream *xdr ) { int error ; { error = (*(desc->decode))(xdr, entry, (int )desc->plus); if (error != 0) { return (error); } else { } (entry->fattr)->time_start = desc->timestamp; (entry->fattr)->gencount = desc->gencount; return (0); } } static int nfs_same_file(struct dentry *dentry , struct nfs_entry *entry ) { struct nfs_fh *tmp ; int tmp___0 ; { if ((unsigned long )dentry->d_inode == (unsigned long )((struct inode *)0)) { goto different; } else { } tmp = NFS_FH((struct inode const *)dentry->d_inode); tmp___0 = nfs_compare_fh((struct nfs_fh const *)entry->fh, (struct nfs_fh const *)tmp); if (tmp___0 != 0) { goto different; } else { } return (1); different: ; return (0); } } static bool nfs_use_readdirplus(struct inode *dir , struct dir_context *ctx ) { int tmp ; struct nfs_inode *tmp___0 ; int tmp___1 ; { tmp = nfs_server_capable(dir, 1); if (tmp == 0) { return (0); } else { } tmp___0 = NFS_I((struct inode const *)dir); tmp___1 = test_and_clear_bit(0L, (unsigned long volatile *)(& tmp___0->flags)); if (tmp___1 != 0) { return (1); } else { } if (ctx->pos == 0LL) { return (1); } else { } return (0); } } static void nfs_advise_use_readdirplus(struct inode *dir ) { struct nfs_inode *tmp ; { tmp = NFS_I((struct inode const *)dir); set_bit(0L, (unsigned long volatile *)(& tmp->flags)); return; } } static void nfs_prime_dcache(struct dentry *parent , struct nfs_entry *entry ) { struct qstr filename ; struct dentry *dentry ; struct dentry *alias ; struct inode *dir ; struct inode *inode ; int status ; unsigned long tmp ; int tmp___0 ; int tmp___1 ; long tmp___2 ; unsigned long tmp___3 ; unsigned long tmp___4 ; long tmp___5 ; { filename.ldv_22580.ldv_22578.hash = 0U; filename.ldv_22580.ldv_22578.len = entry->len; filename.name = (unsigned char const *)entry->name; dir = parent->d_inode; if ((unsigned int )((unsigned char )*(filename.name)) == 46U) { if (filename.ldv_22580.ldv_22578.len == 1U) { return; } else { } if (filename.ldv_22580.ldv_22578.len == 2U && (unsigned int )((unsigned char )*(filename.name + 1UL)) == 46U) { return; } else { } } else { } filename.ldv_22580.ldv_22578.hash = full_name_hash(filename.name, filename.ldv_22580.ldv_22578.len); dentry = d_lookup((struct dentry const *)parent, (struct qstr const *)(& filename)); if ((unsigned long )dentry != (unsigned long )((struct dentry *)0)) { tmp___1 = nfs_same_file(dentry, entry); if (tmp___1 != 0) { tmp = nfs_save_change_attribute(dir); nfs_set_verifier(dentry, tmp); status = nfs_refresh_inode(dentry->d_inode, entry->fattr); if (status == 0) { nfs_setsecurity(dentry->d_inode, entry->fattr, entry->label); } else { } goto out; } else { tmp___0 = d_invalidate(dentry); if (tmp___0 != 0) { goto out; } else { } dput(dentry); } } else { } dentry = d_alloc(parent, (struct qstr const *)(& filename)); if ((unsigned long )dentry == (unsigned long )((struct dentry *)0)) { return; } else { } inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr, entry->label); tmp___2 = IS_ERR((void const *)inode); if (tmp___2 != 0L) { goto out; } else { } alias = d_materialise_unique(dentry, inode); tmp___5 = IS_ERR((void const *)alias); if (tmp___5 != 0L) { goto out; } else if ((unsigned long )alias != (unsigned long )((struct dentry *)0)) { tmp___3 = nfs_save_change_attribute(dir); nfs_set_verifier(alias, tmp___3); dput(alias); } else { tmp___4 = nfs_save_change_attribute(dir); nfs_set_verifier(dentry, tmp___4); } out: dput(dentry); return; } } static int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc , struct nfs_entry *entry , struct page **xdr_pages , struct page *page , unsigned int buflen ) { struct xdr_stream stream ; struct xdr_buf buf ; struct page *scratch ; struct nfs_cache_array *array ; unsigned int count ; int status ; void *tmp ; long tmp___0 ; long tmp___1 ; { count = 0U; scratch = alloc_pages(208U, 0U); if ((unsigned long )scratch == (unsigned long )((struct page *)0)) { return (-12); } else { } xdr_init_decode_pages(& stream, & buf, xdr_pages, buflen); tmp = lowmem_page_address((struct page const *)scratch); xdr_set_scratch_buffer(& stream, tmp, 4096UL); ldv_53655: status = xdr_decode(desc, entry, & stream); if (status != 0) { if (status == -11) { status = 0; } else { } goto ldv_53654; } else { } count = count + 1U; if ((unsigned int )*((unsigned char *)desc + 84UL) != 0U) { nfs_prime_dcache((desc->file)->f_path.dentry, entry); } else { } status = nfs_readdir_add_to_array(entry, page); if (status != 0) { goto ldv_53654; } else { } if (entry->eof == 0) { goto ldv_53655; } else { } ldv_53654: ; if (count == 0U || (status == -523 && entry->eof != 0)) { array = nfs_readdir_get_array(page); tmp___1 = IS_ERR((void const *)array); if (tmp___1 == 0L) { array->eof_index = array->size; status = 0; nfs_readdir_release_array(page); } else { tmp___0 = PTR_ERR((void const *)array); status = (int )tmp___0; } } else { } put_page(scratch); return (status); } } static void nfs_readdir_free_pagearray(struct page **pages , unsigned int npages ) { unsigned int i ; { i = 0U; goto ldv_53662; ldv_53661: put_page(*(pages + (unsigned long )i)); i = i + 1U; ldv_53662: ; if (i < npages) { goto ldv_53661; } else { } return; } } static void nfs_readdir_free_large_page(void *ptr , struct page **pages , unsigned int npages ) { { nfs_readdir_free_pagearray(pages, npages); return; } } static int nfs_readdir_large_page(struct page **pages , unsigned int npages ) { unsigned int i ; struct page *page ; struct page *tmp ; { i = 0U; goto ldv_53677; ldv_53676: tmp = alloc_pages(208U, 0U); page = tmp; if ((unsigned long )page == (unsigned long )((struct page *)0)) { goto out_freepages; } else { } *(pages + (unsigned long )i) = page; i = i + 1U; ldv_53677: ; if (i < npages) { goto ldv_53676; } else { } return (0); out_freepages: nfs_readdir_free_pagearray(pages, i); return (-12); } } static int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc , struct page *page , struct inode *inode ) { struct page *pages[8U] ; void *pages_ptr ; struct nfs_entry entry ; struct file *file ; struct nfs_cache_array *array ; int status ; unsigned int array_size ; struct nfs_server *tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; unsigned int pglen ; { pages_ptr = (void *)0; file = desc->file; status = -12; array_size = 8U; entry.prev_cookie = 0ULL; entry.cookie = desc->last_cookie; entry.eof = 0; entry.fh = nfs_alloc_fhandle(); entry.fattr = nfs_alloc_fattr(); entry.server = NFS_SERVER((struct inode const *)inode); if ((unsigned long )entry.fh == (unsigned long )((struct nfs_fh *)0) || (unsigned long )entry.fattr == (unsigned long )((struct nfs_fattr *)0)) { goto out; } else { } tmp = NFS_SERVER((struct inode const *)inode); entry.label = nfs4_label_alloc(tmp, 0U); tmp___1 = IS_ERR((void const *)entry.label); if (tmp___1 != 0L) { tmp___0 = PTR_ERR((void const *)entry.label); status = (int )tmp___0; goto out; } else { } array = nfs_readdir_get_array(page); tmp___3 = IS_ERR((void const *)array); if (tmp___3 != 0L) { tmp___2 = PTR_ERR((void const *)array); status = (int )tmp___2; goto out_label_free; } else { } memset((void *)array, 0, 16UL); array->eof_index = -1; status = nfs_readdir_large_page((struct page **)(& pages), array_size); if (status < 0) { goto out_release_array; } else { } ldv_53698: status = nfs_readdir_xdr_filler((struct page **)(& pages), desc, & entry, file, inode); if (status < 0) { goto ldv_53697; } else { } pglen = (unsigned int )status; status = nfs_readdir_page_filler(desc, & entry, (struct page **)(& pages), page, pglen); if (status < 0) { if (status == -28) { status = 0; } else { } goto ldv_53697; } else { } if (array->eof_index < 0) { goto ldv_53698; } else { } ldv_53697: nfs_readdir_free_large_page(pages_ptr, (struct page **)(& pages), array_size); out_release_array: nfs_readdir_release_array(page); out_label_free: nfs4_label_free(entry.label); out: nfs_free_fattr((struct nfs_fattr const *)entry.fattr); nfs_free_fhandle((struct nfs_fh const *)entry.fh); return (status); } } static int nfs_readdir_filler(nfs_readdir_descriptor_t *desc , struct page *page ) { struct inode *inode ; struct inode *tmp ; int ret ; int tmp___0 ; { tmp = file_inode(desc->file); inode = tmp; ret = nfs_readdir_xdr_to_array(desc, page, inode); if (ret < 0) { goto error; } else { } SetPageUptodate(page); tmp___0 = invalidate_inode_pages2_range(inode->i_mapping, page->ldv_15471.ldv_15455.index + 1UL, 0xffffffffffffffffUL); if (tmp___0 < 0) { nfs_zap_mapping(inode, inode->i_mapping); } else { } unlock_page(page); return (0); error: unlock_page(page); return (ret); } } static void cache_page_release(nfs_readdir_descriptor_t *desc ) { { if ((unsigned long )(desc->page)->mapping == (unsigned long )((struct address_space *)0)) { nfs_readdir_clear_array(desc->page); } else { } put_page(desc->page); desc->page = (struct page *)0; return; } } static struct page *get_cache_page(nfs_readdir_descriptor_t *desc ) { struct inode *tmp ; struct page *tmp___0 ; { tmp = file_inode(desc->file); tmp___0 = read_cache_page(tmp->i_mapping, desc->page_index, (filler_t *)(& nfs_readdir_filler), (void *)desc); return (tmp___0); } } static int find_cache_page(nfs_readdir_descriptor_t *desc ) { int res ; long tmp ; long tmp___0 ; { desc->page = get_cache_page(desc); tmp___0 = IS_ERR((void const *)desc->page); if (tmp___0 != 0L) { tmp = PTR_ERR((void const *)desc->page); return ((int )tmp); } else { } res = nfs_readdir_search_array(desc); if (res != 0) { cache_page_release(desc); } else { } return (res); } } __inline static int readdir_search_pagecache(nfs_readdir_descriptor_t *desc ) { int res ; { if (desc->page_index == 0UL) { desc->current_index = 0LL; desc->last_cookie = 0ULL; } else { } ldv_53720: res = find_cache_page(desc); if (res == -11) { goto ldv_53720; } else { } return (res); } } static int nfs_do_filldir(nfs_readdir_descriptor_t *desc ) { struct file *file ; int i ; int res ; struct nfs_cache_array *array ; struct nfs_open_dir_context *ctx ; long tmp ; long tmp___0 ; struct nfs_cache_array_entry *ent ; u64 tmp___1 ; bool tmp___2 ; int tmp___3 ; long tmp___4 ; { file = desc->file; i = 0; res = 0; array = (struct nfs_cache_array *)0; ctx = (struct nfs_open_dir_context *)file->private_data; array = nfs_readdir_get_array(desc->page); tmp___0 = IS_ERR((void const *)array); if (tmp___0 != 0L) { tmp = PTR_ERR((void const *)array); res = (int )tmp; goto out; } else { } i = (int )desc->cache_entry_index; goto ldv_53734; ldv_53733: ent = (struct nfs_cache_array_entry *)(& array->array) + (unsigned long )i; tmp___1 = nfs_compat_user_ino64(ent->ino); tmp___2 = dir_emit(desc->ctx, (char const *)ent->string.name, (int )ent->string.ldv_22580.ldv_22578.len, tmp___1, (unsigned int )ent->d_type); if (tmp___2) { tmp___3 = 0; } else { tmp___3 = 1; } if (tmp___3) { desc->eof = 1U; goto ldv_53732; } else { } (desc->ctx)->pos = (desc->ctx)->pos + 1LL; if (array->size + -1 > i) { *(desc->dir_cookie) = array->array[i + 1].cookie; } else { *(desc->dir_cookie) = array->last_cookie; } if ((int )ctx->duped != 0) { ctx->duped = 1; } else { } i = i + 1; ldv_53734: ; if (array->size > i) { goto ldv_53733; } else { } ldv_53732: ; if (array->eof_index >= 0) { desc->eof = 1U; } else { } nfs_readdir_release_array(desc->page); out: cache_page_release(desc); tmp___4 = ldv__builtin_expect((nfs_debug & 2U) != 0U, 0L); if (tmp___4 != 0L) { printk("\001dNFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n", *(desc->dir_cookie), res); } else { } return (res); } } __inline static int uncached_readdir(nfs_readdir_descriptor_t *desc ) { struct page *page ; int status ; struct inode *inode ; struct inode *tmp ; struct nfs_open_dir_context *ctx ; long tmp___0 ; long tmp___1 ; { page = (struct page *)0; tmp = file_inode(desc->file); inode = tmp; ctx = (struct nfs_open_dir_context *)(desc->file)->private_data; tmp___0 = ldv__builtin_expect((nfs_debug & 2U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001dNFS: uncached_readdir() searching for cookie %Lu\n", *(desc->dir_cookie)); } else { } page = alloc_pages(131282U, 0U); if ((unsigned long )page == (unsigned long )((struct page *)0)) { status = -12; goto out; } else { } desc->page_index = 0UL; desc->last_cookie = *(desc->dir_cookie); desc->page = page; ctx->duped = 0; status = nfs_readdir_xdr_to_array(desc, page, inode); if (status < 0) { goto out_release; } else { } status = nfs_do_filldir(desc); out: tmp___1 = ldv__builtin_expect((nfs_debug & 2U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001dNFS: %s: returns %d\n", "uncached_readdir", status); } else { } return (status); out_release: cache_page_release(desc); goto out; } } static int nfs_readdir(struct file *file , struct dir_context *ctx ) { struct dentry *dentry ; struct inode *inode ; nfs_readdir_descriptor_t my_desc ; nfs_readdir_descriptor_t *desc ; struct nfs_open_dir_context *dir_ctx ; int res ; long tmp ; struct nfs_rpc_ops const *tmp___0 ; bool tmp___1 ; int tmp___2 ; struct nfs_inode *tmp___3 ; long tmp___4 ; { dentry = file->f_path.dentry; inode = dentry->d_inode; desc = & my_desc; dir_ctx = (struct nfs_open_dir_context *)file->private_data; res = 0; tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: readdir(%s/%s) starting at cookie %llu\n", (dentry->d_parent)->d_name.name, dentry->d_name.name, ctx->pos); } else { } nfs_inc_stats((struct inode const *)inode, 12); memset((void *)desc, 0, 88UL); desc->file = file; desc->ctx = ctx; desc->dir_cookie = & dir_ctx->dir_cookie; tmp___0 = NFS_PROTO((struct inode const *)inode); desc->decode = tmp___0->decode_dirent; tmp___1 = nfs_use_readdirplus(inode, ctx); desc->plus = (unsigned char )tmp___1; nfs_block_sillyrename(dentry); if (ctx->pos == 0LL) { res = nfs_revalidate_mapping(inode, file->f_mapping); } else { tmp___2 = nfs_attribute_cache_expired(inode); if (tmp___2 != 0) { res = nfs_revalidate_mapping(inode, file->f_mapping); } else { } } if (res < 0) { goto out; } else { } ldv_53758: res = readdir_search_pagecache(desc); if (res == -523) { res = 0; if (*(desc->dir_cookie) != 0ULL && (unsigned int )*((unsigned char *)desc + 84UL) == 0U) { res = uncached_readdir(desc); if (res == 0) { goto ldv_53756; } else { } } else { } goto ldv_53757; } else { } if (res == -525 && (unsigned int )*((unsigned char *)desc + 84UL) != 0U) { tmp___3 = NFS_I((struct inode const *)inode); clear_bit(0L, (unsigned long volatile *)(& tmp___3->flags)); nfs_zap_caches(inode); desc->page_index = 0UL; desc->plus = 0U; desc->eof = 0U; goto ldv_53756; } else { } if (res < 0) { goto ldv_53757; } else { } res = nfs_do_filldir(desc); if (res < 0) { goto ldv_53757; } else { } ldv_53756: ; if ((unsigned int )*((unsigned char *)desc + 84UL) == 0U) { goto ldv_53758; } else { } ldv_53757: ; out: nfs_unblock_sillyrename(dentry); if (res > 0) { res = 0; } else { } tmp___4 = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp___4 != 0L) { printk("\001dNFS: readdir(%s/%s) returns %d\n", (dentry->d_parent)->d_name.name, dentry->d_name.name, res); } else { } return (res); } } static loff_t nfs_llseek_dir(struct file *filp , loff_t offset , int whence ) { struct dentry *dentry ; struct inode *inode ; struct nfs_open_dir_context *dir_ctx ; long tmp ; { dentry = filp->f_path.dentry; inode = dentry->d_inode; dir_ctx = (struct nfs_open_dir_context *)filp->private_data; tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: llseek dir(%s/%s, %lld, %d)\n", (dentry->d_parent)->d_name.name, dentry->d_name.name, offset, whence); } else { } mutex_lock_nested(& inode->i_mutex, 0U); switch (whence) { case 1: offset = filp->f_pos + offset; case 0: ; if (offset >= 0LL) { goto ldv_53769; } else { } default: offset = -22LL; goto out; } ldv_53769: ; if (filp->f_pos != offset) { filp->f_pos = offset; dir_ctx->dir_cookie = 0ULL; dir_ctx->duped = 0; } else { } out: mutex_unlock(& inode->i_mutex); return (offset); } } static int nfs_fsync_dir(struct file *filp , loff_t start , loff_t end , int datasync ) { struct dentry *dentry ; struct inode *inode ; long tmp ; { dentry = filp->f_path.dentry; inode = dentry->d_inode; tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: fsync dir(%s/%s) datasync %d\n", (dentry->d_parent)->d_name.name, dentry->d_name.name, datasync); } else { } mutex_lock_nested(& inode->i_mutex, 0U); nfs_inc_stats((struct inode const *)dentry->d_inode, 15); mutex_unlock(& inode->i_mutex); return (0); } } void nfs_force_lookup_revalidate(struct inode *dir ) { struct nfs_inode *tmp ; { tmp = NFS_I((struct inode const *)dir); tmp->cache_change_attribute = tmp->cache_change_attribute + 1UL; return; } } static int nfs_check_verifier(struct inode *dir , struct dentry *dentry ) { struct nfs_server *tmp ; int tmp___0 ; struct nfs_server *tmp___1 ; int tmp___2 ; int tmp___3 ; { if ((unsigned long )dentry->d_parent == (unsigned long )dentry) { return (1); } else { } tmp = NFS_SERVER((struct inode const *)dir); if ((tmp->flags & 131072) != 0) { return (0); } else { } tmp___0 = nfs_verify_change_attribute(dir, dentry->d_time); if (tmp___0 == 0) { return (0); } else { } tmp___1 = NFS_SERVER((struct inode const *)dir); tmp___2 = nfs_revalidate_inode(tmp___1, dir); if (tmp___2 < 0) { return (0); } else { } tmp___3 = nfs_verify_change_attribute(dir, dentry->d_time); if (tmp___3 == 0) { return (0); } else { } return (1); } } static int nfs_is_exclusive_create(struct inode *dir , unsigned int flags ) { struct nfs_rpc_ops const *tmp ; { tmp = NFS_PROTO((struct inode const *)dir); if ((unsigned int )tmp->version == 2U) { return (0); } else { } return ((int )flags & 1024); } } static int nfs_lookup_verify_inode(struct inode *inode , unsigned int flags ) { struct nfs_server *server ; struct nfs_server *tmp ; int ret ; { tmp = NFS_SERVER((struct inode const *)inode); server = tmp; if ((inode->i_flags & 2048U) != 0U) { return (0); } else { } if ((flags & 32U) != 0U) { goto out_force; } else { } if (((flags & 256U) != 0U && (server->flags & 16) == 0) && (((int )inode->i_mode & 61440) == 32768 || ((int )inode->i_mode & 61440) == 16384)) { goto out_force; } else { } out: ; return ((unsigned int )inode->ldv_23837.i_nlink == 0U ? -2 : 0); out_force: ret = __nfs_revalidate_inode(server, inode); if (ret != 0) { return (ret); } else { } goto out; } } __inline static int nfs_neg_need_reval(struct inode *dir , struct dentry *dentry , unsigned int flags ) { struct nfs_server *tmp ; int tmp___0 ; { if ((flags & 512U) != 0U) { return (0); } else { } tmp = NFS_SERVER((struct inode const *)dir); if ((tmp->flags & 65536) != 0) { return (1); } else { } tmp___0 = nfs_check_verifier(dir, dentry); return (tmp___0 == 0); } } static int nfs_lookup_revalidate(struct dentry *dentry , unsigned int flags ) { struct inode *dir ; struct inode *inode ; struct dentry *parent ; struct nfs_fh *fhandle ; struct nfs_fattr *fattr ; struct nfs4_label *label ; int error ; int tmp ; long tmp___0 ; int tmp___1 ; struct nfs_rpc_ops const *tmp___2 ; int tmp___3 ; int tmp___4 ; int tmp___5 ; int tmp___6 ; int tmp___7 ; struct nfs_server *tmp___8 ; long tmp___9 ; struct nfs_rpc_ops const *tmp___10 ; struct nfs_fh *tmp___11 ; int tmp___12 ; unsigned long tmp___13 ; long tmp___14 ; int tmp___15 ; long tmp___16 ; long tmp___17 ; { fhandle = (struct nfs_fh *)0; fattr = (struct nfs_fattr *)0; label = (struct nfs4_label *)0; if ((flags & 64U) != 0U) { return (-10); } else { } parent = dget_parent(dentry); dir = parent->d_inode; nfs_inc_stats((struct inode const *)dir, 1); inode = dentry->d_inode; if ((unsigned long )inode == (unsigned long )((struct inode *)0)) { tmp = nfs_neg_need_reval(dir, dentry, flags); if (tmp != 0) { goto out_bad; } else { } goto out_valid_noent; } else { } tmp___1 = is_bad_inode(inode); if (tmp___1 != 0) { tmp___0 = ldv__builtin_expect((nfs_debug & 4U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001d%s: %s/%s has dud inode\n", "nfs_lookup_revalidate", (dentry->d_parent)->d_name.name, dentry->d_name.name); } else { } goto out_bad; } else { } tmp___2 = NFS_PROTO((struct inode const *)dir); tmp___3 = (*(tmp___2->have_delegation))(inode, 1U); if (tmp___3 != 0) { goto out_set_verifier; } else { } tmp___5 = nfs_is_exclusive_create(dir, flags); if (tmp___5 == 0) { tmp___6 = nfs_check_verifier(dir, dentry); if (tmp___6 != 0) { tmp___4 = nfs_lookup_verify_inode(inode, flags); if (tmp___4 != 0) { goto out_zap_parent; } else { } goto out_valid; } else { } } else { } tmp___7 = NFS_STALE((struct inode const *)inode); if (tmp___7 != 0) { goto out_bad; } else { } error = -12; fhandle = nfs_alloc_fhandle(); fattr = nfs_alloc_fattr(); if ((unsigned long )fhandle == (unsigned long )((struct nfs_fh *)0) || (unsigned long )fattr == (unsigned long )((struct nfs_fattr *)0)) { goto out_error; } else { } tmp___8 = NFS_SERVER((struct inode const *)inode); label = nfs4_label_alloc(tmp___8, 0U); tmp___9 = IS_ERR((void const *)label); if (tmp___9 != 0L) { goto out_error; } else { } trace_nfs_lookup_revalidate_enter((struct inode const *)dir, (struct dentry const *)dentry, flags); tmp___10 = NFS_PROTO((struct inode const *)dir); error = (*(tmp___10->lookup))(dir, & dentry->d_name, fhandle, fattr, label); trace_nfs_lookup_revalidate_exit((struct inode const *)dir, (struct dentry const *)dentry, flags, error); if (error != 0) { goto out_bad; } else { } tmp___11 = NFS_FH((struct inode const *)inode); tmp___12 = nfs_compare_fh((struct nfs_fh const *)tmp___11, (struct nfs_fh const *)fhandle); if (tmp___12 != 0) { goto out_bad; } else { } error = nfs_refresh_inode(inode, fattr); if (error != 0) { goto out_bad; } else { } nfs_setsecurity(inode, fattr, label); nfs_free_fattr((struct nfs_fattr const *)fattr); nfs_free_fhandle((struct nfs_fh const *)fhandle); nfs4_label_free(label); out_set_verifier: tmp___13 = nfs_save_change_attribute(dir); nfs_set_verifier(dentry, tmp___13); out_valid: nfs_advise_use_readdirplus(dir); out_valid_noent: dput(parent); tmp___14 = ldv__builtin_expect((nfs_debug & 4U) != 0U, 0L); if (tmp___14 != 0L) { printk("\001dNFS: %s(%s/%s) is valid\n", "nfs_lookup_revalidate", (dentry->d_parent)->d_name.name, dentry->d_name.name); } else { } return (1); out_zap_parent: nfs_zap_caches(dir); out_bad: nfs_free_fattr((struct nfs_fattr const *)fattr); nfs_free_fhandle((struct nfs_fh const *)fhandle); nfs4_label_free(label); nfs_mark_for_revalidate(dir); if ((unsigned long )inode != (unsigned long )((struct inode *)0) && ((int )inode->i_mode & 61440) == 16384) { nfs_zap_caches(inode); if ((dentry->d_flags & 32U) != 0U) { goto out_valid; } else { } } else { } tmp___15 = check_submounts_and_drop(dentry); if (tmp___15 != 0) { goto out_valid; } else { } dput(parent); tmp___16 = ldv__builtin_expect((nfs_debug & 4U) != 0U, 0L); if (tmp___16 != 0L) { printk("\001dNFS: %s(%s/%s) is invalid\n", "nfs_lookup_revalidate", (dentry->d_parent)->d_name.name, dentry->d_name.name); } else { } return (0); out_error: nfs_free_fattr((struct nfs_fattr const *)fattr); nfs_free_fhandle((struct nfs_fh const *)fhandle); nfs4_label_free(label); dput(parent); tmp___17 = ldv__builtin_expect((nfs_debug & 4U) != 0U, 0L); if (tmp___17 != 0L) { printk("\001dNFS: %s(%s/%s) lookup returned error %d\n", "nfs_lookup_revalidate", (dentry->d_parent)->d_name.name, dentry->d_name.name, error); } else { } return (error); } } static int nfs_weak_revalidate(struct dentry *dentry , unsigned int flags ) { int error ; struct inode *inode ; long tmp ; long tmp___0 ; int tmp___1 ; struct nfs_server *tmp___2 ; long tmp___3 ; { inode = dentry->d_inode; if ((unsigned long )inode == (unsigned long )((struct inode *)0)) { tmp = ldv__builtin_expect((nfs_debug & 4U) != 0U, 0L); if (tmp != 0L) { printk("\001d%s: %s/%s has negative inode\n", "nfs_weak_revalidate", (dentry->d_parent)->d_name.name, dentry->d_name.name); } else { } return (1); } else { } tmp___1 = is_bad_inode(inode); if (tmp___1 != 0) { tmp___0 = ldv__builtin_expect((nfs_debug & 4U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001d%s: %s/%s has dud inode\n", "nfs_weak_revalidate", (dentry->d_parent)->d_name.name, dentry->d_name.name); } else { } return (0); } else { } tmp___2 = NFS_SERVER((struct inode const *)inode); error = nfs_revalidate_inode(tmp___2, inode); tmp___3 = ldv__builtin_expect((nfs_debug & 4U) != 0U, 0L); if (tmp___3 != 0L) { printk("\001dNFS: %s: inode %lu is %s\n", "nfs_weak_revalidate", inode->i_ino, error != 0 ? (char *)"invalid" : (char *)"valid"); } else { } return (error == 0); } } static int nfs_dentry_delete(struct dentry const *dentry ) { long tmp ; int tmp___0 ; { tmp = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp != 0L) { printk("\001dNFS: dentry_delete(%s/%s, %x)\n", (dentry->d_parent)->d_name.name, dentry->d_name.name, dentry->d_flags); } else { } if ((unsigned long )dentry->d_inode != (unsigned long )((struct inode */* const */)0)) { tmp___0 = NFS_STALE((struct inode const *)dentry->d_inode); if (tmp___0 != 0) { return (1); } else { } } else { } if (((unsigned int )dentry->d_flags & 4096U) != 0U) { return (1); } else { } if (((dentry->d_sb)->s_flags & 1073741824UL) == 0UL) { return (1); } else { } return (0); } } static void nfs_drop_nlink(struct inode *inode ) { struct nfs_inode *tmp ; { spin_lock(& inode->i_lock); if ((unsigned int )inode->ldv_23837.i_nlink == 1U) { clear_nlink(inode); } else { } tmp = NFS_I((struct inode const *)inode); tmp->cache_validity = tmp->cache_validity | 1UL; spin_unlock(& inode->i_lock); return; } } static void nfs_dentry_iput(struct dentry *dentry , struct inode *inode ) { struct nfs_inode *tmp ; { if (((int )inode->i_mode & 61440) == 16384) { tmp = NFS_I((struct inode const *)inode); tmp->cache_validity = tmp->cache_validity | 2UL; } else { } if ((dentry->d_flags & 4096U) != 0U) { nfs_complete_unlink(dentry, inode); nfs_drop_nlink(inode); } else { } iput(inode); return; } } static void nfs_d_release(struct dentry *dentry ) { int __ret_warn_on ; long tmp ; long tmp___0 ; { tmp___0 = ldv__builtin_expect((unsigned long )dentry->d_fsdata != (unsigned long )((void *)0), 0L); if (tmp___0 != 0L) { if ((dentry->d_flags & 4096U) != 0U) { __ret_warn_on = 1; tmp = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp != 0L) { warn_slowpath_null("/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/dir.o.c.prepared", 1455); } else { } ldv__builtin_expect(__ret_warn_on != 0, 0L); } else { kfree((void const *)dentry->d_fsdata); } } else { } return; } } struct dentry_operations const nfs_dentry_operations = {& nfs_lookup_revalidate, & nfs_weak_revalidate, 0, 0, & nfs_dentry_delete, & nfs_d_release, 0, & nfs_dentry_iput, 0, & nfs_d_automount, 0}; struct dentry *nfs_lookup(struct inode *dir , struct dentry *dentry , unsigned int flags ) { struct dentry *res ; struct dentry *parent ; struct inode *inode ; struct nfs_fh *fhandle ; struct nfs_fattr *fattr ; struct nfs4_label *label ; int error ; long tmp ; void *tmp___0 ; struct nfs_server *tmp___1 ; int tmp___2 ; void *tmp___3 ; struct nfs_server *tmp___4 ; long tmp___5 ; struct nfs_rpc_ops const *tmp___6 ; void *tmp___7 ; void *tmp___8 ; long tmp___9 ; long tmp___10 ; unsigned long tmp___11 ; { inode = (struct inode *)0; fhandle = (struct nfs_fh *)0; fattr = (struct nfs_fattr *)0; label = (struct nfs4_label *)0; tmp = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp != 0L) { printk("\001dNFS: lookup(%s/%s)\n", (dentry->d_parent)->d_name.name, dentry->d_name.name); } else { } nfs_inc_stats((struct inode const *)dir, 5); tmp___0 = ERR_PTR(-36L); res = (struct dentry *)tmp___0; tmp___1 = NFS_SERVER((struct inode const *)dir); if (dentry->d_name.ldv_22580.ldv_22578.len > tmp___1->namelen) { goto out; } else { } tmp___2 = nfs_is_exclusive_create(dir, flags); if (tmp___2 != 0) { d_instantiate(dentry, (struct inode *)0); res = (struct dentry *)0; goto out; } else { } tmp___3 = ERR_PTR(-12L); res = (struct dentry *)tmp___3; fhandle = nfs_alloc_fhandle(); fattr = nfs_alloc_fattr(); if ((unsigned long )fhandle == (unsigned long )((struct nfs_fh *)0) || (unsigned long )fattr == (unsigned long )((struct nfs_fattr *)0)) { goto out; } else { } tmp___4 = NFS_SERVER((struct inode const *)dir); label = nfs4_label_alloc(tmp___4, 0U); tmp___5 = IS_ERR((void const *)label); if (tmp___5 != 0L) { goto out; } else { } parent = dentry->d_parent; trace_nfs_lookup_enter((struct inode const *)dir, (struct dentry const *)dentry, flags); nfs_block_sillyrename(parent); tmp___6 = NFS_PROTO((struct inode const *)dir); error = (*(tmp___6->lookup))(dir, & dentry->d_name, fhandle, fattr, label); if (error == -2) { goto no_entry; } else { } if (error < 0) { tmp___7 = ERR_PTR((long )error); res = (struct dentry *)tmp___7; goto out_unblock_sillyrename; } else { } inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label); tmp___8 = ERR_CAST((void const *)inode); res = (struct dentry *)tmp___8; tmp___9 = IS_ERR((void const *)res); if (tmp___9 != 0L) { goto out_unblock_sillyrename; } else { } nfs_advise_use_readdirplus(dir); no_entry: res = d_materialise_unique(dentry, inode); if ((unsigned long )res != (unsigned long )((struct dentry *)0)) { tmp___10 = IS_ERR((void const *)res); if (tmp___10 != 0L) { goto out_unblock_sillyrename; } else { } dentry = res; } else { } tmp___11 = nfs_save_change_attribute(dir); nfs_set_verifier(dentry, tmp___11); out_unblock_sillyrename: nfs_unblock_sillyrename(parent); trace_nfs_lookup_exit((struct inode const *)dir, (struct dentry const *)dentry, flags, error); nfs4_label_free(label); out: nfs_free_fattr((struct nfs_fattr const *)fattr); nfs_free_fhandle((struct nfs_fh const *)fhandle); return (res); } } static int nfs4_lookup_revalidate(struct dentry *dentry , unsigned int flags ) ; struct dentry_operations const nfs4_dentry_operations = {& nfs4_lookup_revalidate, 0, 0, 0, & nfs_dentry_delete, & nfs_d_release, 0, & nfs_dentry_iput, 0, & nfs_d_automount, 0}; static fmode_t flags_to_mode(int flags ) { fmode_t res ; { res = (unsigned int )flags & 32U; if ((flags & 3) != 1) { res = res | 1U; } else { } if ((flags & 3) != 0) { res = res | 2U; } else { } return (res); } } static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry , int open_flags ) { fmode_t tmp ; struct nfs_open_context *tmp___0 ; { tmp = flags_to_mode(open_flags); tmp___0 = alloc_nfs_open_context(dentry, tmp); return (tmp___0); } } static int do_open(struct inode *inode , struct file *filp ) { { nfs_fscache_set_inode_cookie(inode, filp); return (0); } } static int nfs_finish_open(struct nfs_open_context *ctx , struct dentry *dentry , struct file *file , unsigned int open_flags , int *opened ) { int err ; { err = finish_open(file, dentry, & do_open, opened); if (err != 0) { goto out; } else { } nfs_file_set_open_context(file, ctx); out: ; return (err); } } int nfs_atomic_open(struct inode *dir , struct dentry *dentry , struct file *file , unsigned int open_flags , umode_t mode , int *opened ) { struct nfs_open_context *ctx ; struct dentry *res ; struct iattr attr ; struct inode *inode ; unsigned int lookup_flags ; int err ; long tmp ; long tmp___0 ; int tmp___1 ; struct nfs_server *tmp___2 ; int tmp___3 ; long tmp___4 ; long tmp___5 ; struct nfs_rpc_ops const *tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; int tmp___11 ; { attr.ia_valid = 32768U; attr.ia_mode = (unsigned short)0; attr.ia_uid.val = 0U; attr.ia_gid.val = 0U; attr.ia_size = 0LL; attr.ia_atime.tv_sec = 0L; attr.ia_atime.tv_nsec = 0L; attr.ia_mtime.tv_sec = 0L; attr.ia_mtime.tv_nsec = 0L; attr.ia_ctime.tv_sec = 0L; attr.ia_ctime.tv_nsec = 0L; attr.ia_file = 0; lookup_flags = 0U; tmp = ldv__builtin_expect((unsigned long )dentry->d_inode != (unsigned long )((struct inode *)0), 0L); if (tmp != 0L) { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/dir.o.c.prepared"), "i" (1608), "i" (12UL)); ldv_53923: ; goto ldv_53923; } else { } tmp___0 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___0 != 0L) { printk("\001dNFS: atomic_open(%s/%ld), %s\n", (char *)(& (dir->i_sb)->s_id), dir->i_ino, dentry->d_name.name); } else { } err = nfs_check_flags((int )open_flags); if (err != 0) { return (err); } else { } if ((open_flags & 65536U) != 0U) { tmp___1 = d_unhashed((struct dentry const *)dentry); if (tmp___1 == 0) { return (-2); } else { } lookup_flags = 258U; goto no_open; } else { } tmp___2 = NFS_SERVER((struct inode const *)dir); if (dentry->d_name.ldv_22580.ldv_22578.len > tmp___2->namelen) { return (-36); } else { } if ((open_flags & 64U) != 0U) { attr.ia_valid = attr.ia_valid | 1U; tmp___3 = current_umask(); attr.ia_mode = (umode_t )(~ ((int )((short )tmp___3)) & (int )((short )mode)); } else { } if ((open_flags & 512U) != 0U) { attr.ia_valid = attr.ia_valid | 8U; attr.ia_size = 0LL; } else { } ctx = create_nfs_open_context(dentry, (int )open_flags); tmp___4 = PTR_ERR((void const *)ctx); err = (int )tmp___4; tmp___5 = IS_ERR((void const *)ctx); if (tmp___5 != 0L) { goto out; } else { } trace_nfs_atomic_open_enter((struct inode const *)dir, (struct nfs_open_context const *)ctx, open_flags); nfs_block_sillyrename(dentry->d_parent); tmp___6 = NFS_PROTO((struct inode const *)dir); inode = (*(tmp___6->open_context))(dir, ctx, (int )open_flags, & attr); nfs_unblock_sillyrename(dentry->d_parent); tmp___8 = IS_ERR((void const *)inode); if (tmp___8 != 0L) { tmp___7 = PTR_ERR((void const *)inode); err = (int )tmp___7; trace_nfs_atomic_open_exit((struct inode const *)dir, (struct nfs_open_context const *)ctx, open_flags, err); put_nfs_open_context(ctx); switch (err) { case -2: d_drop(dentry); d_add(dentry, (struct inode *)0); goto ldv_53927; case -21: ; case -20: ; goto no_open; case -40: ; if ((open_flags & 131072U) == 0U) { goto no_open; } else { } goto ldv_53927; default: ; goto ldv_53927; } ldv_53927: ; goto out; } else { } err = nfs_finish_open(ctx, ctx->dentry, file, open_flags, opened); trace_nfs_atomic_open_exit((struct inode const *)dir, (struct nfs_open_context const *)ctx, open_flags, err); put_nfs_open_context(ctx); out: ; return (err); no_open: res = nfs_lookup(dir, dentry, lookup_flags); tmp___9 = PTR_ERR((void const *)res); err = (int )tmp___9; tmp___10 = IS_ERR((void const *)res); if (tmp___10 != 0L) { goto out; } else { } tmp___11 = finish_no_open(file, res); return (tmp___11); } } static int nfs4_lookup_revalidate(struct dentry *dentry , unsigned int flags ) { struct dentry *parent ; struct inode *inode ; struct inode *dir ; int ret ; bool tmp ; struct nfs_server *tmp___0 ; int tmp___1 ; int tmp___2 ; { parent = (struct dentry *)0; ret = 0; if ((flags & 64U) != 0U) { return (-10); } else { } if ((flags & 256U) == 0U || (flags & 2U) != 0U) { goto no_open; } else { } tmp = d_mountpoint((struct dentry const *)dentry); if ((int )tmp) { goto no_open; } else { } tmp___0 = NFS_SB((struct super_block const *)dentry->d_sb); if ((tmp___0->caps & 131072U) != 0U) { goto no_open; } else { } inode = dentry->d_inode; parent = dget_parent(dentry); dir = parent->d_inode; if ((unsigned long )inode == (unsigned long )((struct inode *)0)) { tmp___1 = nfs_neg_need_reval(dir, dentry, flags); if (tmp___1 == 0) { ret = 1; } else { } goto out; } else { } if (((int )inode->i_mode & 61440) != 32768) { goto no_open_dput; } else { } if ((flags & 1024U) != 0U) { goto no_open_dput; } else { } ret = 1; out: dput(parent); return (ret); no_open_dput: dput(parent); no_open: tmp___2 = nfs_lookup_revalidate(dentry, flags); return (tmp___2); } } int nfs_instantiate(struct dentry *dentry , struct nfs_fh *fhandle , struct nfs_fattr *fattr , struct nfs4_label *label ) { struct dentry *parent ; struct dentry *tmp ; struct inode *dir ; struct inode *inode ; int error ; struct nfs_rpc_ops const *tmp___0 ; unsigned long tmp___1 ; struct nfs_server *server ; struct nfs_server *tmp___2 ; long tmp___3 ; long tmp___4 ; { tmp = dget_parent(dentry); parent = tmp; dir = parent->d_inode; error = -13; d_drop(dentry); if ((unsigned long )dentry->d_inode != (unsigned long )((struct inode *)0)) { goto out; } else { } if ((unsigned int )fhandle->size == 0U) { tmp___0 = NFS_PROTO((struct inode const *)dir); error = (*(tmp___0->lookup))(dir, & dentry->d_name, fhandle, fattr, (struct nfs4_label *)0); if (error != 0) { goto out_error; } else { } } else { } tmp___1 = nfs_save_change_attribute(dir); nfs_set_verifier(dentry, tmp___1); if ((fattr->valid & 162943U) == 0U) { tmp___2 = NFS_SB((struct super_block const *)dentry->d_sb); server = tmp___2; error = (*(((server->nfs_client)->rpc_ops)->getattr))(server, fhandle, fattr, (struct nfs4_label *)0); if (error < 0) { goto out_error; } else { } } else { } inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label); tmp___3 = PTR_ERR((void const *)inode); error = (int )tmp___3; tmp___4 = IS_ERR((void const *)inode); if (tmp___4 != 0L) { goto out_error; } else { } d_add(dentry, inode); out: dput(parent); return (0); out_error: nfs_mark_for_revalidate(dir); dput(parent); return (error); } } int nfs_create(struct inode *dir , struct dentry *dentry , umode_t mode , bool excl ) { struct iattr attr ; int open_flags ; int error ; long tmp ; struct nfs_rpc_ops const *tmp___0 ; { open_flags = (int )excl ? 192 : 64; tmp = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp != 0L) { printk("\001dNFS: create(%s/%ld), %s\n", (char *)(& (dir->i_sb)->s_id), dir->i_ino, dentry->d_name.name); } else { } attr.ia_mode = mode; attr.ia_valid = 1U; trace_nfs_create_enter((struct inode const *)dir, (struct dentry const *)dentry, (unsigned int )open_flags); tmp___0 = NFS_PROTO((struct inode const *)dir); error = (*(tmp___0->create))(dir, dentry, & attr, open_flags); trace_nfs_create_exit((struct inode const *)dir, (struct dentry const *)dentry, (unsigned int )open_flags, error); if (error != 0) { goto out_err; } else { } return (0); out_err: d_drop(dentry); return (error); } } int nfs_mknod(struct inode *dir , struct dentry *dentry , umode_t mode , dev_t rdev ) { struct iattr attr ; int status ; long tmp ; int tmp___0 ; struct nfs_rpc_ops const *tmp___1 ; { tmp = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp != 0L) { printk("\001dNFS: mknod(%s/%ld), %s\n", (char *)(& (dir->i_sb)->s_id), dir->i_ino, dentry->d_name.name); } else { } tmp___0 = new_valid_dev(rdev); if (tmp___0 == 0) { return (-22); } else { } attr.ia_mode = mode; attr.ia_valid = 1U; trace_nfs_mknod_enter((struct inode const *)dir, (struct dentry const *)dentry); tmp___1 = NFS_PROTO((struct inode const *)dir); status = (*(tmp___1->mknod))(dir, dentry, & attr, rdev); trace_nfs_mknod_exit((struct inode const *)dir, (struct dentry const *)dentry, status); if (status != 0) { goto out_err; } else { } return (0); out_err: d_drop(dentry); return (status); } } int nfs_mkdir(struct inode *dir , struct dentry *dentry , umode_t mode ) { struct iattr attr ; int error ; long tmp ; struct nfs_rpc_ops const *tmp___0 ; { tmp = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp != 0L) { printk("\001dNFS: mkdir(%s/%ld), %s\n", (char *)(& (dir->i_sb)->s_id), dir->i_ino, dentry->d_name.name); } else { } attr.ia_valid = 1U; attr.ia_mode = (umode_t )((unsigned int )mode | 16384U); trace_nfs_mkdir_enter((struct inode const *)dir, (struct dentry const *)dentry); tmp___0 = NFS_PROTO((struct inode const *)dir); error = (*(tmp___0->mkdir))(dir, dentry, & attr); trace_nfs_mkdir_exit((struct inode const *)dir, (struct dentry const *)dentry, error); if (error != 0) { goto out_err; } else { } return (0); out_err: d_drop(dentry); return (error); } } static void nfs_dentry_handle_enoent(struct dentry *dentry ) { int tmp ; { if ((unsigned long )dentry->d_inode != (unsigned long )((struct inode *)0)) { tmp = d_unhashed((struct dentry const *)dentry); if (tmp == 0) { d_delete(dentry); } else { } } else { } return; } } int nfs_rmdir(struct inode *dir , struct dentry *dentry ) { int error ; long tmp ; struct nfs_rpc_ops const *tmp___0 ; struct nfs_rpc_ops const *tmp___1 ; { tmp = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp != 0L) { printk("\001dNFS: rmdir(%s/%ld), %s\n", (char *)(& (dir->i_sb)->s_id), dir->i_ino, dentry->d_name.name); } else { } trace_nfs_rmdir_enter((struct inode const *)dir, (struct dentry const *)dentry); if ((unsigned long )dentry->d_inode != (unsigned long )((struct inode *)0)) { nfs_wait_on_sillyrename(dentry); tmp___0 = NFS_PROTO((struct inode const *)dir); error = (*(tmp___0->rmdir))(dir, & dentry->d_name); switch (error) { case 0: clear_nlink(dentry->d_inode); goto ldv_54038; case -2: nfs_dentry_handle_enoent(dentry); } ldv_54038: ; } else { tmp___1 = NFS_PROTO((struct inode const *)dir); error = (*(tmp___1->rmdir))(dir, & dentry->d_name); } trace_nfs_rmdir_exit((struct inode const *)dir, (struct dentry const *)dentry, error); return (error); } } static int nfs_safe_remove(struct dentry *dentry ) { struct inode *dir ; struct inode *inode ; int error ; long tmp ; struct nfs_rpc_ops const *tmp___0 ; struct nfs_rpc_ops const *tmp___1 ; struct nfs_rpc_ops const *tmp___2 ; { dir = (dentry->d_parent)->d_inode; inode = dentry->d_inode; error = -16; tmp = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp != 0L) { printk("\001dNFS: safe_remove(%s/%s)\n", (dentry->d_parent)->d_name.name, dentry->d_name.name); } else { } if ((dentry->d_flags & 4096U) != 0U) { error = 0; goto out; } else { } trace_nfs_remove_enter((struct inode const *)dir, (struct dentry const *)dentry); if ((unsigned long )inode != (unsigned long )((struct inode *)0)) { tmp___0 = NFS_PROTO((struct inode const *)inode); (*(tmp___0->return_delegation))(inode); tmp___1 = NFS_PROTO((struct inode const *)dir); error = (*(tmp___1->remove))(dir, & dentry->d_name); if (error == 0) { nfs_drop_nlink(inode); } else { } } else { tmp___2 = NFS_PROTO((struct inode const *)dir); error = (*(tmp___2->remove))(dir, & dentry->d_name); } if (error == -2) { nfs_dentry_handle_enoent(dentry); } else { } trace_nfs_remove_exit((struct inode const *)dir, (struct dentry const *)dentry, error); out: ; return (error); } } int nfs_unlink(struct inode *dir , struct dentry *dentry ) { int error ; int need_rehash ; long tmp ; unsigned int tmp___0 ; int tmp___1 ; unsigned long tmp___2 ; { need_rehash = 0; tmp = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp != 0L) { printk("\001dNFS: unlink(%s/%ld, %s)\n", (char *)(& (dir->i_sb)->s_id), dir->i_ino, dentry->d_name.name); } else { } trace_nfs_unlink_enter((struct inode const *)dir, (struct dentry const *)dentry); spin_lock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); tmp___0 = d_count((struct dentry const *)dentry); if (tmp___0 > 1U) { spin_unlock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); write_inode_now(dentry->d_inode, 0); error = nfs_sillyrename(dir, dentry); goto out; } else { } tmp___1 = d_unhashed((struct dentry const *)dentry); if (tmp___1 == 0) { __d_drop(dentry); need_rehash = 1; } else { } spin_unlock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); error = nfs_safe_remove(dentry); if (error == 0 || error == -2) { tmp___2 = nfs_save_change_attribute(dir); nfs_set_verifier(dentry, tmp___2); } else if (need_rehash != 0) { d_rehash(dentry); } else { } out: trace_nfs_unlink_exit((struct inode const *)dir, (struct dentry const *)dentry, error); return (error); } } int nfs_symlink(struct inode *dir , struct dentry *dentry , char const *symname ) { struct page *page ; char *kaddr ; struct iattr attr ; unsigned int pathlen ; size_t tmp ; int error ; long tmp___0 ; void *tmp___1 ; size_t __len ; void *__ret ; struct nfs_rpc_ops const *tmp___2 ; long tmp___3 ; int tmp___4 ; { tmp = strlen(symname); pathlen = (unsigned int )tmp; tmp___0 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___0 != 0L) { printk("\001dNFS: symlink(%s/%ld, %s, %s)\n", (char *)(& (dir->i_sb)->s_id), dir->i_ino, dentry->d_name.name, symname); } else { } if (pathlen > 4096U) { return (-36); } else { } attr.ia_mode = 41471U; attr.ia_valid = 1U; page = alloc_pages(131282U, 0U); if ((unsigned long )page == (unsigned long )((struct page *)0)) { return (-12); } else { } tmp___1 = kmap_atomic(page); kaddr = (char *)tmp___1; __len = (size_t )pathlen; __ret = __builtin_memcpy((void *)kaddr, (void const *)symname, __len); if (pathlen <= 4095U) { memset((void *)kaddr + (unsigned long )pathlen, 0, 4096UL - (unsigned long )pathlen); } else { } __kunmap_atomic((void *)kaddr); trace_nfs_symlink_enter((struct inode const *)dir, (struct dentry const *)dentry); tmp___2 = NFS_PROTO((struct inode const *)dir); error = (*(tmp___2->symlink))(dir, dentry, page, pathlen, & attr); trace_nfs_symlink_exit((struct inode const *)dir, (struct dentry const *)dentry, error); if (error != 0) { tmp___3 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___3 != 0L) { printk("\001dNFS: symlink(%s/%ld, %s, %s) error %d\n", (char *)(& (dir->i_sb)->s_id), dir->i_ino, dentry->d_name.name, symname, error); } else { } d_drop(dentry); __free_pages(page, 0U); return (error); } else { } tmp___4 = add_to_page_cache_lru(page, (dentry->d_inode)->i_mapping, 0UL, 208U); if (tmp___4 == 0) { SetPageUptodate(page); unlock_page(page); } else { __free_pages(page, 0U); } return (0); } } int nfs_link(struct dentry *old_dentry , struct inode *dir , struct dentry *dentry ) { struct inode *inode ; int error ; long tmp ; struct nfs_rpc_ops const *tmp___0 ; struct nfs_rpc_ops const *tmp___1 ; { inode = old_dentry->d_inode; tmp = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp != 0L) { printk("\001dNFS: link(%s/%s -> %s/%s)\n", (old_dentry->d_parent)->d_name.name, old_dentry->d_name.name, (dentry->d_parent)->d_name.name, dentry->d_name.name); } else { } trace_nfs_link_enter((struct inode const *)inode, (struct inode const *)dir, (struct dentry const *)dentry); tmp___0 = NFS_PROTO((struct inode const *)inode); (*(tmp___0->return_delegation))(inode); d_drop(dentry); tmp___1 = NFS_PROTO((struct inode const *)dir); error = (*(tmp___1->link))(inode, dir, & dentry->d_name); if (error == 0) { ihold(inode); d_add(dentry, inode); } else { } trace_nfs_link_exit((struct inode const *)inode, (struct inode const *)dir, (struct dentry const *)dentry, error); return (error); } } int nfs_rename(struct inode *old_dir , struct dentry *old_dentry , struct inode *new_dir , struct dentry *new_dentry ) { struct inode *old_inode ; struct inode *new_inode___0 ; struct dentry *dentry ; struct dentry *rehash ; int error ; unsigned int tmp ; long tmp___0 ; int tmp___1 ; int err ; unsigned int tmp___2 ; struct nfs_rpc_ops const *tmp___3 ; struct nfs_rpc_ops const *tmp___4 ; struct nfs_rpc_ops const *tmp___5 ; unsigned long tmp___6 ; { old_inode = old_dentry->d_inode; new_inode___0 = new_dentry->d_inode; dentry = (struct dentry *)0; rehash = (struct dentry *)0; error = -16; tmp___0 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___0 != 0L) { tmp = d_count((struct dentry const *)new_dentry); printk("\001dNFS: rename(%s/%s -> %s/%s, ct=%d)\n", (old_dentry->d_parent)->d_name.name, old_dentry->d_name.name, (new_dentry->d_parent)->d_name.name, new_dentry->d_name.name, tmp); } else { } trace_nfs_rename_enter((struct inode const *)old_dir, (struct dentry const *)old_dentry, (struct inode const *)new_dir, (struct dentry const *)new_dentry); if ((unsigned long )new_inode___0 != (unsigned long )((struct inode *)0) && ((int )new_inode___0->i_mode & 61440) != 16384) { tmp___1 = d_unhashed((struct dentry const *)new_dentry); if (tmp___1 == 0) { d_drop(new_dentry); rehash = new_dentry; } else { } tmp___2 = d_count((struct dentry const *)new_dentry); if (tmp___2 > 2U) { dentry = d_alloc(new_dentry->d_parent, (struct qstr const *)(& new_dentry->d_name)); if ((unsigned long )dentry == (unsigned long )((struct dentry *)0)) { goto out; } else { } err = nfs_sillyrename(new_dir, new_dentry); if (err != 0) { goto out; } else { } new_dentry = dentry; rehash = (struct dentry *)0; new_inode___0 = (struct inode *)0; } else { } } else { } tmp___3 = NFS_PROTO((struct inode const *)old_inode); (*(tmp___3->return_delegation))(old_inode); if ((unsigned long )new_inode___0 != (unsigned long )((struct inode *)0)) { tmp___4 = NFS_PROTO((struct inode const *)new_inode___0); (*(tmp___4->return_delegation))(new_inode___0); } else { } tmp___5 = NFS_PROTO((struct inode const *)old_dir); error = (*(tmp___5->rename))(old_dir, & old_dentry->d_name, new_dir, & new_dentry->d_name); nfs_mark_for_revalidate(old_inode); out: ; if ((unsigned long )rehash != (unsigned long )((struct dentry *)0)) { d_rehash(rehash); } else { } trace_nfs_rename_exit((struct inode const *)old_dir, (struct dentry const *)old_dentry, (struct inode const *)new_dir, (struct dentry const *)new_dentry, error); if (error == 0) { if ((unsigned long )new_inode___0 != (unsigned long )((struct inode *)0)) { nfs_drop_nlink(new_inode___0); } else { } d_move(old_dentry, new_dentry); tmp___6 = nfs_save_change_attribute(new_dir); nfs_set_verifier(new_dentry, tmp___6); } else if (error == -2) { nfs_dentry_handle_enoent(old_dentry); } else { } if ((unsigned long )dentry != (unsigned long )((struct dentry *)0)) { dput(dentry); } else { } return (error); } } static spinlock_t nfs_access_lru_lock = {{{{{0U}}, 3735899821U, 4294967295U, (void *)-1, {0, {0, 0}, "nfs_access_lru_lock", 0, 0UL}}}}; static struct list_head nfs_access_lru_list = {& nfs_access_lru_list, & nfs_access_lru_list}; static atomic_long_t nfs_access_nr_entries ; static void nfs_access_free_entry(struct nfs_access_entry *entry ) { { put_rpccred(entry->cred); kfree((void const *)entry); __asm__ volatile ("": : : "memory"); atomic_long_dec(& nfs_access_nr_entries); __asm__ volatile ("": : : "memory"); return; } } static void nfs_access_free_list(struct list_head *head ) { struct nfs_access_entry *cache ; struct list_head const *__mptr ; int tmp ; { goto ldv_54140; ldv_54139: __mptr = (struct list_head const *)head->next; cache = (struct nfs_access_entry *)__mptr + 0xffffffffffffffe8UL; list_del(& cache->lru); nfs_access_free_entry(cache); ldv_54140: tmp = list_empty((struct list_head const *)head); if (tmp == 0) { goto ldv_54139; } else { } return; } } unsigned long nfs_access_cache_scan(struct shrinker *shrink , struct shrink_control *sc ) { struct list_head head ; struct nfs_inode *nfsi ; struct nfs_inode *next ; struct nfs_access_entry *cache ; int nr_to_scan ; gfp_t gfp_mask ; long freed ; struct list_head const *__mptr ; struct list_head const *__mptr___0 ; struct inode *inode ; int tmp ; int tmp___0 ; struct list_head const *__mptr___1 ; int tmp___1 ; struct list_head const *__mptr___2 ; { head.next = & head; head.prev = & head; nr_to_scan = (int )sc->nr_to_scan; gfp_mask = sc->gfp_mask; freed = 0L; if ((gfp_mask & 208U) != 208U) { return (0xffffffffffffffffUL); } else { } spin_lock(& nfs_access_lru_lock); __mptr = (struct list_head const *)nfs_access_lru_list.next; nfsi = (struct nfs_inode *)__mptr + 0xffffffffffffff20UL; __mptr___0 = (struct list_head const *)nfsi->access_cache_inode_lru.next; next = (struct nfs_inode *)__mptr___0 + 0xffffffffffffff20UL; goto ldv_54165; ldv_54164: tmp = nr_to_scan; nr_to_scan = nr_to_scan - 1; if (tmp == 0) { goto ldv_54160; } else { } inode = & nfsi->vfs_inode; spin_lock(& inode->i_lock); tmp___0 = list_empty((struct list_head const *)(& nfsi->access_cache_entry_lru)); if (tmp___0 != 0) { goto remove_lru_entry; } else { } __mptr___1 = (struct list_head const *)nfsi->access_cache_entry_lru.next; cache = (struct nfs_access_entry *)__mptr___1 + 0xffffffffffffffe8UL; list_move(& cache->lru, & head); rb_erase(& cache->rb_node, & nfsi->access_cache); freed = freed + 1L; tmp___1 = list_empty((struct list_head const *)(& nfsi->access_cache_entry_lru)); if (tmp___1 == 0) { list_move_tail(& nfsi->access_cache_inode_lru, & nfs_access_lru_list); } else { remove_lru_entry: list_del_init(& nfsi->access_cache_inode_lru); __asm__ volatile ("": : : "memory"); clear_bit(2L, (unsigned long volatile *)(& nfsi->flags)); __asm__ volatile ("": : : "memory"); } spin_unlock(& inode->i_lock); nfsi = next; __mptr___2 = (struct list_head const *)next->access_cache_inode_lru.next; next = (struct nfs_inode *)__mptr___2 + 0xffffffffffffff20UL; ldv_54165: ; if ((unsigned long )(& nfsi->access_cache_inode_lru) != (unsigned long )(& nfs_access_lru_list)) { goto ldv_54164; } else { } ldv_54160: spin_unlock(& nfs_access_lru_lock); nfs_access_free_list(& head); return ((unsigned long )freed); } } unsigned long nfs_access_cache_count(struct shrinker *shrink , struct shrink_control *sc ) { long tmp ; unsigned long tmp___0 ; { tmp = atomic_long_read(& nfs_access_nr_entries); tmp___0 = vfs_pressure_ratio((unsigned long )tmp); return (tmp___0); } } static void __nfs_access_zap_cache(struct nfs_inode *nfsi , struct list_head *head ) { struct rb_root *root_node ; struct rb_node *n ; struct nfs_access_entry *entry ; struct rb_node const *__mptr ; { root_node = & nfsi->access_cache; goto ldv_54180; ldv_54179: __mptr = (struct rb_node const *)n; entry = (struct nfs_access_entry *)__mptr; rb_erase(n, root_node); list_move(& entry->lru, head); ldv_54180: n = rb_first((struct rb_root const *)root_node); if ((unsigned long )n != (unsigned long )((struct rb_node *)0)) { goto ldv_54179; } else { } nfsi->cache_validity = nfsi->cache_validity & 0xfffffffffffffff7UL; return; } } void nfs_access_zap_cache(struct inode *inode ) { struct list_head head ; struct nfs_inode *tmp ; int tmp___0 ; struct nfs_inode *tmp___1 ; struct nfs_inode *tmp___2 ; int tmp___3 ; struct nfs_inode *tmp___4 ; { head.next = & head; head.prev = & head; tmp = NFS_I((struct inode const *)inode); tmp___0 = constant_test_bit(2L, (unsigned long const volatile *)(& tmp->flags)); if (tmp___0 == 0) { return; } else { } spin_lock(& nfs_access_lru_lock); tmp___2 = NFS_I((struct inode const *)inode); tmp___3 = test_and_clear_bit(2L, (unsigned long volatile *)(& tmp___2->flags)); if (tmp___3 != 0) { tmp___1 = NFS_I((struct inode const *)inode); list_del_init(& tmp___1->access_cache_inode_lru); } else { } spin_lock(& inode->i_lock); tmp___4 = NFS_I((struct inode const *)inode); __nfs_access_zap_cache(tmp___4, & head); spin_unlock(& inode->i_lock); spin_unlock(& nfs_access_lru_lock); nfs_access_free_list(& head); return; } } static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode , struct rpc_cred *cred ) { struct rb_node *n ; struct nfs_inode *tmp ; struct nfs_access_entry *entry ; struct rb_node const *__mptr ; { tmp = NFS_I((struct inode const *)inode); n = tmp->access_cache.rb_node; goto ldv_54201; ldv_54200: __mptr = (struct rb_node const *)n; entry = (struct nfs_access_entry *)__mptr; if ((unsigned long )entry->cred > (unsigned long )cred) { n = n->rb_left; } else if ((unsigned long )entry->cred < (unsigned long )cred) { n = n->rb_right; } else { return (entry); } ldv_54201: ; if ((unsigned long )n != (unsigned long )((struct rb_node *)0)) { goto ldv_54200; } else { } return ((struct nfs_access_entry *)0); } } static int nfs_access_get_cached(struct inode *inode , struct rpc_cred *cred , struct nfs_access_entry *res ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; struct nfs_access_entry *cache ; int err ; int tmp___0 ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; err = -2; spin_lock(& inode->i_lock); if ((nfsi->cache_validity & 8UL) != 0UL) { goto out_zap; } else { } cache = nfs_access_search_rbtree(inode, cred); if ((unsigned long )cache == (unsigned long )((struct nfs_access_entry *)0)) { goto out; } else { } tmp___0 = nfs_have_delegated_attributes(inode); if (tmp___0 == 0 && ((long )((unsigned long )jiffies - cache->jiffies) < 0L || (long )((unsigned long )jiffies - (cache->jiffies + nfsi->attrtimeo)) >= 0L)) { goto out_stale; } else { } res->jiffies = cache->jiffies; res->cred = cache->cred; res->mask = cache->mask; list_move_tail(& cache->lru, & nfsi->access_cache_entry_lru); err = 0; out: spin_unlock(& inode->i_lock); return (err); out_stale: rb_erase(& cache->rb_node, & nfsi->access_cache); list_del(& cache->lru); spin_unlock(& inode->i_lock); nfs_access_free_entry(cache); return (-2); out_zap: spin_unlock(& inode->i_lock); nfs_access_zap_cache(inode); return (-2); } } static void nfs_access_add_rbtree(struct inode *inode , struct nfs_access_entry *set ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; struct rb_root *root_node ; struct rb_node **p ; struct rb_node *parent ; struct nfs_access_entry *entry ; struct rb_node const *__mptr ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; root_node = & nfsi->access_cache; p = & root_node->rb_node; parent = (struct rb_node *)0; spin_lock(& inode->i_lock); goto ldv_54239; ldv_54238: parent = *p; __mptr = (struct rb_node const *)parent; entry = (struct nfs_access_entry *)__mptr; if ((unsigned long )set->cred < (unsigned long )entry->cred) { p = & parent->rb_left; } else if ((unsigned long )set->cred > (unsigned long )entry->cred) { p = & parent->rb_right; } else { goto found; } ldv_54239: ; if ((unsigned long )*p != (unsigned long )((struct rb_node *)0)) { goto ldv_54238; } else { } rb_link_node(& set->rb_node, parent, p); rb_insert_color(& set->rb_node, root_node); list_add_tail(& set->lru, & nfsi->access_cache_entry_lru); spin_unlock(& inode->i_lock); return; found: rb_replace_node(parent, & set->rb_node, root_node); list_add_tail(& set->lru, & nfsi->access_cache_entry_lru); list_del(& entry->lru); spin_unlock(& inode->i_lock); nfs_access_free_entry(entry); return; } } void nfs_access_add_cache(struct inode *inode , struct nfs_access_entry *set ) { struct nfs_access_entry *cache ; void *tmp ; struct nfs_inode *tmp___0 ; struct nfs_inode *tmp___1 ; int tmp___2 ; struct nfs_inode *tmp___3 ; int tmp___4 ; { tmp = kmalloc(64UL, 208U); cache = (struct nfs_access_entry *)tmp; if ((unsigned long )cache == (unsigned long )((struct nfs_access_entry *)0)) { return; } else { } cache->rb_node.__rb_parent_color = (unsigned long )(& cache->rb_node); cache->jiffies = set->jiffies; cache->cred = get_rpccred(set->cred); cache->mask = set->mask; nfs_access_add_rbtree(inode, cache); __asm__ volatile ("": : : "memory"); atomic_long_inc(& nfs_access_nr_entries); __asm__ volatile ("": : : "memory"); tmp___3 = NFS_I((struct inode const *)inode); tmp___4 = constant_test_bit(2L, (unsigned long const volatile *)(& tmp___3->flags)); if (tmp___4 == 0) { spin_lock(& nfs_access_lru_lock); tmp___1 = NFS_I((struct inode const *)inode); tmp___2 = test_and_set_bit(2L, (unsigned long volatile *)(& tmp___1->flags)); if (tmp___2 == 0) { tmp___0 = NFS_I((struct inode const *)inode); list_add_tail(& tmp___0->access_cache_inode_lru, & nfs_access_lru_list); } else { } spin_unlock(& nfs_access_lru_lock); } else { } return; } } void nfs_access_set_mask(struct nfs_access_entry *entry , u32 access_result ) { { entry->mask = 0; if ((int )access_result & 1) { entry->mask = entry->mask | 4; } else { } if ((access_result & 28U) != 0U) { entry->mask = entry->mask | 2; } else { } if ((access_result & 34U) != 0U) { entry->mask = entry->mask | 1; } else { } return; } } static int nfs_do_access(struct inode *inode , struct rpc_cred *cred , int mask ) { struct nfs_access_entry cache ; int status ; struct nfs_rpc_ops const *tmp ; struct nfs_inode *tmp___0 ; { trace_nfs_access_enter((struct inode const *)inode); status = nfs_access_get_cached(inode, cred, & cache); if (status == 0) { goto out_cached; } else { } cache.mask = 7; cache.cred = cred; cache.jiffies = jiffies; tmp = NFS_PROTO((struct inode const *)inode); status = (*(tmp->access))(inode, & cache); if (status != 0) { if (status == -116) { nfs_zap_caches(inode); if (((int )inode->i_mode & 61440) != 16384) { tmp___0 = NFS_I((struct inode const *)inode); set_bit(1L, (unsigned long volatile *)(& tmp___0->flags)); } else { } } else { } goto out; } else { } nfs_access_add_cache(inode, & cache); out_cached: ; if (((~ cache.mask & mask) & 7) != 0) { status = -13; } else { } out: trace_nfs_access_exit((struct inode const *)inode, status); return (status); } } static int nfs_open_permission_mask(int openflags ) { int mask ; { mask = 0; if ((openflags & 32) != 0) { mask = 1; } else { if ((openflags & 3) != 1) { mask = mask | 4; } else { } if ((openflags & 3) != 0) { mask = mask | 2; } else { } } return (mask); } } int nfs_may_open(struct inode *inode , struct rpc_cred *cred , int openflags ) { int tmp ; int tmp___0 ; { tmp = nfs_open_permission_mask(openflags); tmp___0 = nfs_do_access(inode, cred, tmp); return (tmp___0); } } int nfs_permission(struct inode *inode , int mask ) { struct rpc_cred *cred ; int res ; struct nfs_rpc_ops const *tmp ; long tmp___0 ; long tmp___1 ; bool tmp___2 ; int tmp___3 ; long tmp___4 ; struct nfs_server *tmp___5 ; { res = 0; if ((mask & 128) != 0) { return (-10); } else { } nfs_inc_stats((struct inode const *)inode, 6); if ((mask & 7) == 0) { goto out; } else { } if ((mask & 80) != 0) { goto force_lookup; } else { } switch ((int )inode->i_mode & 61440) { case 40960: ; goto out; case 32768: ; goto ldv_54300; case 16384: ; if ((mask & 2) != 0 && (mask & 4) == 0) { goto out; } else { } } ldv_54300: ; force_lookup: tmp = NFS_PROTO((struct inode const *)inode); if ((unsigned long )tmp->access == (unsigned long )((int (*/* const */)(struct inode * , struct nfs_access_entry * ))0)) { goto out_notsup; } else { } cred = rpc_lookup_cred(); tmp___1 = IS_ERR((void const *)cred); if (tmp___1 == 0L) { res = nfs_do_access(inode, cred, mask); put_rpccred(cred); } else { tmp___0 = PTR_ERR((void const *)cred); res = (int )tmp___0; } out: ; if (res == 0 && mask & 1) { tmp___2 = execute_ok(inode); if (tmp___2) { tmp___3 = 0; } else { tmp___3 = 1; } if (tmp___3) { res = -13; } else { } } else { } tmp___4 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___4 != 0L) { printk("\001dNFS: permission(%s/%ld), mask=0x%x, res=%d\n", (char *)(& (inode->i_sb)->s_id), inode->i_ino, mask, res); } else { } return (res); out_notsup: tmp___5 = NFS_SERVER((struct inode const *)inode); res = nfs_revalidate_inode(tmp___5, inode); if (res == 0) { res = generic_permission(inode, mask); } else { } goto out; } } int ldv_retval_8 ; void ldv_file_operations_70(void) { void *tmp ; void *tmp___0 ; { tmp = ldv_zalloc(1032UL); nfs_dir_operations_group1 = (struct inode *)tmp; tmp___0 = ldv_zalloc(360UL); nfs_dir_operations_group2 = (struct file *)tmp___0; return; } } void ldv_initialize_dentry_operations_67(void) { void *tmp ; { tmp = ldv_zalloc(264UL); nfs_dentry_operations_group0 = (struct dentry *)tmp; return; } } void ldv_initialize_dentry_operations_68(void) { void *tmp ; { tmp = ldv_zalloc(264UL); nfs_dentry_operations_group0 = (struct dentry *)tmp; return; } } void ldv_initialize_dentry_operations_65(void) { void *tmp ; { tmp = ldv_zalloc(264UL); nfs4_dentry_operations_group0 = (struct dentry *)tmp; return; } } void ldv_initialize_dentry_operations_66(void) { void *tmp ; { tmp = ldv_zalloc(264UL); nfs4_dentry_operations_group0 = (struct dentry *)tmp; return; } } void ldv_main_exported_69(void) { struct page *ldvarg254 ; void *tmp ; int tmp___0 ; { tmp = ldv_zalloc(64UL); ldvarg254 = (struct page *)tmp; tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_69 == 1) { nfs_readdir_clear_array(ldvarg254); ldv_state_variable_69 = 1; } else { } goto ldv_54331; default: ldv_stop(); } ldv_54331: ; return; } } void ldv_main_exported_67(void) { struct dentry *ldvarg202 ; void *tmp ; unsigned int ldvarg201 ; unsigned int tmp___0 ; unsigned int ldvarg205 ; unsigned int tmp___1 ; struct inode *ldvarg203 ; void *tmp___2 ; struct path *ldvarg204 ; void *tmp___3 ; int tmp___4 ; { tmp = ldv_zalloc(264UL); ldvarg202 = (struct dentry *)tmp; tmp___0 = __VERIFIER_nondet_uint(); ldvarg201 = tmp___0; tmp___1 = __VERIFIER_nondet_uint(); ldvarg205 = tmp___1; tmp___2 = ldv_zalloc(1032UL); ldvarg203 = (struct inode *)tmp___2; tmp___3 = ldv_zalloc(16UL); ldvarg204 = (struct path *)tmp___3; tmp___4 = __VERIFIER_nondet_int(); switch (tmp___4) { case 0: ; if (ldv_state_variable_67 == 1) { nfs_d_release(nfs_dentry_operations_group0); ldv_state_variable_67 = 1; } else { } goto ldv_54342; case 1: ; if (ldv_state_variable_67 == 1) { nfs_weak_revalidate(nfs_dentry_operations_group0, ldvarg205); ldv_state_variable_67 = 1; } else { } goto ldv_54342; case 2: ; if (ldv_state_variable_67 == 1) { nfs_d_automount(ldvarg204); ldv_state_variable_67 = 1; } else { } goto ldv_54342; case 3: ; if (ldv_state_variable_67 == 1) { nfs_dentry_iput(nfs_dentry_operations_group0, ldvarg203); ldv_state_variable_67 = 1; } else { } goto ldv_54342; case 4: ; if (ldv_state_variable_67 == 1) { nfs_dentry_delete((struct dentry const *)ldvarg202); ldv_state_variable_67 = 1; } else { } goto ldv_54342; case 5: ; if (ldv_state_variable_67 == 1) { nfs_lookup_revalidate(nfs_dentry_operations_group0, ldvarg201); ldv_state_variable_67 = 1; } else { } goto ldv_54342; default: ldv_stop(); } ldv_54342: ; return; } } void ldv_main_exported_70(void) { loff_t ldvarg210 ; loff_t tmp ; loff_t *ldvarg212 ; void *tmp___0 ; int ldvarg206 ; int tmp___1 ; char *ldvarg214 ; void *tmp___2 ; loff_t ldvarg207 ; loff_t tmp___3 ; struct dir_context *ldvarg208 ; void *tmp___4 ; loff_t ldvarg211 ; loff_t tmp___5 ; int ldvarg209 ; int tmp___6 ; size_t ldvarg213 ; size_t tmp___7 ; int tmp___8 ; { tmp = __VERIFIER_nondet_loff_t(); ldvarg210 = tmp; tmp___0 = ldv_zalloc(8UL); ldvarg212 = (loff_t *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); ldvarg206 = tmp___1; tmp___2 = ldv_zalloc(1UL); ldvarg214 = (char *)tmp___2; tmp___3 = __VERIFIER_nondet_loff_t(); ldvarg207 = tmp___3; tmp___4 = ldv_zalloc(16UL); ldvarg208 = (struct dir_context *)tmp___4; tmp___5 = __VERIFIER_nondet_loff_t(); ldvarg211 = tmp___5; tmp___6 = __VERIFIER_nondet_int(); ldvarg209 = tmp___6; tmp___7 = __VERIFIER_nondet_size_t(); ldvarg213 = tmp___7; tmp___8 = __VERIFIER_nondet_int(); switch (tmp___8) { case 0: ; if (ldv_state_variable_70 == 2) { nfs_closedir(nfs_dir_operations_group1, nfs_dir_operations_group2); ldv_state_variable_70 = 1; ref_cnt = ref_cnt - 1; } else { } goto ldv_54362; case 1: ; if (ldv_state_variable_70 == 2) { generic_read_dir(nfs_dir_operations_group2, ldvarg214, ldvarg213, ldvarg212); ldv_state_variable_70 = 2; } else { } goto ldv_54362; case 2: ; if (ldv_state_variable_70 == 1) { nfs_fsync_dir(nfs_dir_operations_group2, ldvarg211, ldvarg210, ldvarg209); ldv_state_variable_70 = 1; } else { } if (ldv_state_variable_70 == 2) { nfs_fsync_dir(nfs_dir_operations_group2, ldvarg211, ldvarg210, ldvarg209); ldv_state_variable_70 = 2; } else { } goto ldv_54362; case 3: ; if (ldv_state_variable_70 == 1) { nfs_readdir(nfs_dir_operations_group2, ldvarg208); ldv_state_variable_70 = 1; } else { } if (ldv_state_variable_70 == 2) { nfs_readdir(nfs_dir_operations_group2, ldvarg208); ldv_state_variable_70 = 2; } else { } goto ldv_54362; case 4: ; if (ldv_state_variable_70 == 2) { nfs_llseek_dir(nfs_dir_operations_group2, ldvarg207, ldvarg206); ldv_state_variable_70 = 2; } else { } goto ldv_54362; case 5: ; if (ldv_state_variable_70 == 1) { ldv_retval_8 = nfs_opendir(nfs_dir_operations_group1, nfs_dir_operations_group2); if (ldv_retval_8 == 0) { ldv_state_variable_70 = 2; ref_cnt = ref_cnt + 1; } else { } } else { } goto ldv_54362; default: ldv_stop(); } ldv_54362: ; return; } } void ldv_main_exported_66(void) { struct inode *ldvarg152 ; void *tmp ; struct dentry *ldvarg151 ; void *tmp___0 ; struct path *ldvarg153 ; void *tmp___1 ; unsigned int ldvarg150 ; unsigned int tmp___2 ; int tmp___3 ; { tmp = ldv_zalloc(1032UL); ldvarg152 = (struct inode *)tmp; tmp___0 = ldv_zalloc(264UL); ldvarg151 = (struct dentry *)tmp___0; tmp___1 = ldv_zalloc(16UL); ldvarg153 = (struct path *)tmp___1; tmp___2 = __VERIFIER_nondet_uint(); ldvarg150 = tmp___2; tmp___3 = __VERIFIER_nondet_int(); switch (tmp___3) { case 0: ; if (ldv_state_variable_66 == 1) { nfs_d_release(nfs4_dentry_operations_group0); ldv_state_variable_66 = 1; } else { } goto ldv_54377; case 1: ; if (ldv_state_variable_66 == 1) { nfs_d_automount(ldvarg153); ldv_state_variable_66 = 1; } else { } goto ldv_54377; case 2: ; if (ldv_state_variable_66 == 1) { nfs_dentry_iput(nfs4_dentry_operations_group0, ldvarg152); ldv_state_variable_66 = 1; } else { } goto ldv_54377; case 3: ; if (ldv_state_variable_66 == 1) { nfs_dentry_delete((struct dentry const *)ldvarg151); ldv_state_variable_66 = 1; } else { } goto ldv_54377; case 4: ; if (ldv_state_variable_66 == 1) { nfs4_lookup_revalidate(nfs4_dentry_operations_group0, ldvarg150); ldv_state_variable_66 = 1; } else { } goto ldv_54377; default: ldv_stop(); } ldv_54377: ; return; } } void ldv_main_exported_68(void) { struct dentry *ldvarg216 ; void *tmp ; unsigned int ldvarg219 ; unsigned int tmp___0 ; struct inode *ldvarg217 ; void *tmp___1 ; struct path *ldvarg218 ; void *tmp___2 ; unsigned int ldvarg215 ; unsigned int tmp___3 ; int tmp___4 ; { tmp = ldv_zalloc(264UL); ldvarg216 = (struct dentry *)tmp; tmp___0 = __VERIFIER_nondet_uint(); ldvarg219 = tmp___0; tmp___1 = ldv_zalloc(1032UL); ldvarg217 = (struct inode *)tmp___1; tmp___2 = ldv_zalloc(16UL); ldvarg218 = (struct path *)tmp___2; tmp___3 = __VERIFIER_nondet_uint(); ldvarg215 = tmp___3; tmp___4 = __VERIFIER_nondet_int(); switch (tmp___4) { case 0: ; if (ldv_state_variable_68 == 1) { nfs_d_release(nfs_dentry_operations_group0); ldv_state_variable_68 = 1; } else { } goto ldv_54392; case 1: ; if (ldv_state_variable_68 == 1) { nfs_weak_revalidate(nfs_dentry_operations_group0, ldvarg219); ldv_state_variable_68 = 1; } else { } goto ldv_54392; case 2: ; if (ldv_state_variable_68 == 1) { nfs_d_automount(ldvarg218); ldv_state_variable_68 = 1; } else { } goto ldv_54392; case 3: ; if (ldv_state_variable_68 == 1) { nfs_dentry_iput(nfs_dentry_operations_group0, ldvarg217); ldv_state_variable_68 = 1; } else { } goto ldv_54392; case 4: ; if (ldv_state_variable_68 == 1) { nfs_dentry_delete((struct dentry const *)ldvarg216); ldv_state_variable_68 = 1; } else { } goto ldv_54392; case 5: ; if (ldv_state_variable_68 == 1) { nfs_lookup_revalidate(nfs_dentry_operations_group0, ldvarg215); ldv_state_variable_68 = 1; } else { } goto ldv_54392; default: ldv_stop(); } ldv_54392: ; return; } } void ldv_main_exported_65(void) { struct inode *ldvarg96 ; void *tmp ; unsigned int ldvarg94 ; unsigned int tmp___0 ; struct path *ldvarg97 ; void *tmp___1 ; struct dentry *ldvarg95 ; void *tmp___2 ; int tmp___3 ; { tmp = ldv_zalloc(1032UL); ldvarg96 = (struct inode *)tmp; tmp___0 = __VERIFIER_nondet_uint(); ldvarg94 = tmp___0; tmp___1 = ldv_zalloc(16UL); ldvarg97 = (struct path *)tmp___1; tmp___2 = ldv_zalloc(264UL); ldvarg95 = (struct dentry *)tmp___2; tmp___3 = __VERIFIER_nondet_int(); switch (tmp___3) { case 0: ; if (ldv_state_variable_65 == 1) { nfs_d_release(nfs4_dentry_operations_group0); ldv_state_variable_65 = 1; } else { } goto ldv_54407; case 1: ; if (ldv_state_variable_65 == 1) { nfs_d_automount(ldvarg97); ldv_state_variable_65 = 1; } else { } goto ldv_54407; case 2: ; if (ldv_state_variable_65 == 1) { nfs_dentry_iput(nfs4_dentry_operations_group0, ldvarg96); ldv_state_variable_65 = 1; } else { } goto ldv_54407; case 3: ; if (ldv_state_variable_65 == 1) { nfs_dentry_delete((struct dentry const *)ldvarg95); ldv_state_variable_65 = 1; } else { } goto ldv_54407; case 4: ; if (ldv_state_variable_65 == 1) { nfs4_lookup_revalidate(nfs4_dentry_operations_group0, ldvarg94); ldv_state_variable_65 = 1; } else { } goto ldv_54407; default: ldv_stop(); } ldv_54407: ; return; } } __inline static int test_and_set_bit_lock(long nr , unsigned long volatile *addr ) { int tmp ; { tmp = test_and_set_bit(nr, addr); return (tmp); } } extern void __xchg_wrong_size(void) ; extern int out_of_line_wait_on_bit(void * , int , int (*)(void * ) , unsigned int ) ; __inline static int wait_on_bit(void *word , int bit , int (*action)(void * ) , unsigned int mode ) { int tmp ; int tmp___0 ; { tmp = variable_test_bit((long )bit, (unsigned long const volatile *)word); if (tmp == 0) { return (0); } else { } tmp___0 = out_of_line_wait_on_bit(word, bit, action, mode); return (tmp___0); } } struct file *nfs_file_aops_group2 ; int ldv_state_variable_61 ; int ldv_state_variable_64 ; struct writeback_control *nfs_file_aops_group0 ; struct page *nfs_file_aops_group3 ; struct vm_fault *nfs_file_vm_ops_group0 ; struct file *nfs_file_operations_group2 ; int ldv_state_variable_62 ; struct vm_area_struct *nfs_file_vm_ops_group1 ; int ldv_state_variable_63 ; struct inode *nfs_file_operations_group1 ; struct address_space *nfs_file_aops_group1 ; void ldv_initialize_vm_operations_struct_63(void) ; void ldv_file_operations_62(void) ; void ldv_file_operations_61(void) ; void ldv_initialize_address_space_operations_64(void) ; __inline static size_t iov_length(struct iovec const *iov , unsigned long nr_segs ) { unsigned long seg ; size_t ret ; { ret = 0UL; seg = 0UL; goto ldv_15195; ldv_15194: ret = (unsigned long )(iov + seg)->iov_len + ret; seg = seg + 1UL; ldv_15195: ; if (seg < nr_segs) { goto ldv_15194; } else { } return (ret); } } __inline static int PagePrivate(struct page const *page ) { int tmp ; { tmp = constant_test_bit(11L, (unsigned long const volatile *)(& page->flags)); return (tmp); } } __inline static int PagePrivate2(struct page const *page ) { int tmp ; { tmp = constant_test_bit(12L, (unsigned long const volatile *)(& page->flags)); return (tmp); } } __inline static int PageWriteback(struct page const *page ) { int tmp ; { tmp = constant_test_bit(13L, (unsigned long const volatile *)(& page->flags)); return (tmp); } } __inline static int PageSwapCache(struct page const *page ) { int tmp ; { tmp = constant_test_bit(16L, (unsigned long const volatile *)(& page->flags)); return (tmp); } } __inline static int PageUptodate(struct page *page ) { int ret ; int tmp ; { tmp = constant_test_bit(3L, (unsigned long const volatile *)(& page->flags)); ret = tmp; if (ret != 0) { __asm__ volatile ("": : : "memory"); } else { } return (ret); } } extern struct address_space *__page_file_mapping(struct page * ) ; __inline static struct address_space *page_file_mapping(struct page *page ) { struct address_space *tmp ; int tmp___0 ; long tmp___1 ; { tmp___0 = PageSwapCache((struct page const *)page); tmp___1 = ldv__builtin_expect(tmp___0 != 0, 0L); if (tmp___1 != 0L) { tmp = __page_file_mapping(page); return (tmp); } else { } return (page->mapping); } } extern unsigned long __page_file_index(struct page * ) ; __inline static unsigned long page_file_index(struct page *page ) { unsigned long tmp ; int tmp___0 ; long tmp___1 ; { tmp___0 = PageSwapCache((struct page const *)page); tmp___1 = ldv__builtin_expect(tmp___0 != 0, 0L); if (tmp___1 != 0L) { tmp = __page_file_index(page); return (tmp); } else { } return (page->ldv_15471.ldv_15455.index); } } extern int generic_error_remove_page(struct address_space * , struct page * ) ; extern int __set_page_dirty_nobuffers(struct page * ) ; extern int filemap_fault(struct vm_area_struct * , struct vm_fault * ) ; __inline static loff_t i_size_read(struct inode const *inode ) { { return ((loff_t )inode->i_size); } } extern void posix_test_lock(struct file * , struct file_lock * ) ; extern int posix_lock_file_wait(struct file * , struct file_lock * ) ; extern int flock_lock_file_wait(struct file * , struct file_lock * ) ; __inline static int __mandatory_lock(struct inode *ino ) { { return (((int )ino->i_mode & 1032) == 1024); } } extern int filemap_fdatawrite(struct address_space * ) ; extern int filemap_write_and_wait_range(struct address_space * , loff_t , loff_t ) ; extern int vfs_fsync(struct file * , int ) ; extern int generic_file_mmap(struct file * , struct vm_area_struct * ) ; extern int generic_file_remap_pages(struct vm_area_struct * , unsigned long , unsigned long , unsigned long ) ; extern ssize_t generic_file_aio_read(struct kiocb * , struct iovec const * , unsigned long , loff_t ) ; extern ssize_t generic_file_aio_write(struct kiocb * , struct iovec const * , unsigned long , loff_t ) ; extern ssize_t do_sync_read(struct file * , char * , size_t , loff_t * ) ; extern ssize_t do_sync_write(struct file * , char const * , size_t , loff_t * ) ; extern ssize_t generic_file_splice_read(struct file * , loff_t * , struct pipe_inode_info * , size_t , unsigned int ) ; extern ssize_t generic_file_splice_write(struct pipe_inode_info * , struct file * , loff_t * , size_t , unsigned int ) ; extern loff_t generic_file_llseek(struct file * , loff_t , int ) ; __inline static void zero_user_segments(struct page *page , unsigned int start1 , unsigned int end1 , unsigned int start2 , unsigned int end2 ) { void *kaddr ; void *tmp ; long tmp___0 ; long tmp___1 ; { tmp = kmap_atomic(page); kaddr = tmp; tmp___0 = ldv__builtin_expect(end1 > 4096U, 0L); if (tmp___0 != 0L) { goto _L; } else { tmp___1 = ldv__builtin_expect(end2 > 4096U, 0L); if (tmp___1 != 0L) { _L: /* CIL Label */ __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"include/linux/highmem.h"), "i" (198), "i" (12UL)); ldv_23662: ; goto ldv_23662; } else { } } if (end1 > start1) { memset(kaddr + (unsigned long )start1, 0, (size_t )(end1 - start1)); } else { } if (end2 > start2) { memset(kaddr + (unsigned long )start2, 0, (size_t )(end2 - start2)); } else { } __kunmap_atomic(kaddr); return; } } __inline static void zero_user_segment(struct page *page , unsigned int start , unsigned int end ) { { zero_user_segments(page, start, end, 0U, 0U); return; } } extern struct page *grab_cache_page_write_begin(struct address_space * , unsigned long , unsigned int ) ; __inline static loff_t page_offset(struct page *page ) { { return ((long long )page->ldv_15471.ldv_15455.index << 12); } } extern void __lock_page(struct page * ) ; __inline static int trylock_page(struct page *page ) { int tmp ; long tmp___0 ; { tmp = test_and_set_bit_lock(0L, (unsigned long volatile *)(& page->flags)); tmp___0 = ldv__builtin_expect(tmp == 0, 1L); return ((int )tmp___0); } } __inline static void lock_page(struct page *page ) { int tmp ; { __might_sleep("include/linux/pagemap.h", 350, 0); tmp = trylock_page(page); if (tmp == 0) { __lock_page(page); } else { } return; } } extern void wait_on_page_bit(struct page * , int ) ; __inline static void wait_on_page_writeback(struct page *page ) { int tmp ; { tmp = PageWriteback((struct page const *)page); if (tmp != 0) { wait_on_page_bit(page, 13); } else { } return; } } extern int xs_swapper(struct rpc_xprt * , int ) ; __inline static struct rpc_clnt *NFS_CLIENT(struct inode const *inode ) { struct nfs_server *tmp ; { tmp = NFS_SERVER(inode); return (tmp->client); } } int nfs_sync_mapping(struct address_space *mapping ) ; int nfs_open(struct inode *inode , struct file *filp ) ; int nfs_release(struct inode *inode , struct file *filp ) ; int nfs_attribute_timeout(struct inode *inode ) ; struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx ) ; void nfs_put_lock_context(struct nfs_lock_context *l_ctx ) ; struct file_operations const nfs_file_operations ; struct address_space_operations const nfs_file_aops ; __inline static struct nfs_open_context *nfs_file_open_context(struct file *filp ) { { return ((struct nfs_open_context *)filp->private_data); } } ssize_t nfs_direct_IO(int rw , struct kiocb *iocb , struct iovec const *iov , loff_t pos , unsigned long nr_segs ) ; ssize_t nfs_file_direct_read(struct kiocb *iocb , struct iovec const *iov , unsigned long nr_segs , loff_t pos , bool uio ) ; ssize_t nfs_file_direct_write(struct kiocb *iocb , struct iovec const *iov , unsigned long nr_segs , loff_t pos , bool uio ) ; int nfs_writepage(struct page *page , struct writeback_control *wbc ) ; int nfs_writepages(struct address_space *mapping , struct writeback_control *wbc ) ; int nfs_flush_incompatible(struct file *file , struct page *page ) ; int nfs_updatepage(struct file *file , struct page *page , unsigned int offset , unsigned int count ) ; int nfs_wb_all(struct inode *inode ) ; int nfs_wb_page(struct inode *inode , struct page *page ) ; int nfs_wb_page_cancel(struct inode *inode , struct page *page ) ; int nfs_commit_inode(struct inode *inode , int how ) ; int nfs_readpage(struct file *file , struct page *page ) ; int nfs_readpages(struct file *filp , struct address_space *mapping , struct list_head *pages , unsigned int nr_pages ) ; __inline static int current_is_kswapd(void) { struct task_struct *tmp ; { tmp = get_current(); return ((int )tmp->flags & 262144); } } int nfs_iocounter_wait(struct nfs_io_counter *c ) ; int nfs_file_fsync_commit(struct file *file , loff_t start , loff_t end , int datasync ) ; loff_t nfs_file_llseek(struct file *filp , loff_t offset , int whence ) ; int nfs_file_flush(struct file *file , fl_owner_t id ) ; ssize_t nfs_file_read(struct kiocb *iocb , struct iovec const *iov , unsigned long nr_segs , loff_t pos ) ; ssize_t nfs_file_splice_read(struct file *filp , loff_t *ppos , struct pipe_inode_info *pipe , size_t count , unsigned int flags ) ; int nfs_file_mmap(struct file *file , struct vm_area_struct *vma ) ; ssize_t nfs_file_write(struct kiocb *iocb , struct iovec const *iov , unsigned long nr_segs , loff_t pos ) ; int nfs_file_release(struct inode *inode , struct file *filp ) ; int nfs_lock(struct file *filp , int cmd , struct file_lock *fl ) ; int nfs_flock(struct file *filp , int cmd , struct file_lock *fl ) ; ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe , struct file *filp , loff_t *ppos , size_t count , unsigned int flags ) ; int nfs_setlease(struct file *file , long arg , struct file_lock **fl ) ; int nfs_wait_bit_killable(void *word ) ; int nfs_key_timeout_notify(struct file *filp , struct inode *inode ) ; bool nfs_ctx_key_to_expire(struct nfs_open_context *ctx ) ; int nfs_migrate_page(struct address_space *mapping , struct page *newpage , struct page *page , enum migrate_mode mode ) ; __inline static unsigned int nfs_page_length(struct page *page ) { loff_t i_size ; struct address_space *tmp ; loff_t tmp___0 ; unsigned long page_index___0 ; unsigned long tmp___1 ; unsigned long end_index ; { tmp = page_file_mapping(page); tmp___0 = i_size_read((struct inode const *)tmp->host); i_size = tmp___0; if (i_size > 0LL) { tmp___1 = page_file_index(page); page_index___0 = tmp___1; end_index = (unsigned long )((i_size + -1LL) >> 12); if (page_index___0 < end_index) { return (4096U); } else { } if (page_index___0 == end_index) { return ((((unsigned int )i_size + 4294967295U) & 4095U) + 1U); } else { } } else { } return (0U); } } __inline static void nfs_inc_server_stats___0(struct nfs_server const *server , enum nfs_stat_eventcounters stat ) { void const *__vpp_verify ; int pao_ID__ ; int pao_ID_____0 ; int pao_ID_____1 ; int pao_ID_____2 ; { __vpp_verify = (void const *)0; switch (8UL) { case 1UL: pao_ID__ = 1; switch (8UL) { case 1UL: ; if (pao_ID__ == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_51175; case 2UL: ; if (pao_ID__ == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51175; case 4UL: ; if (pao_ID__ == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51175; case 8UL: ; if (pao_ID__ == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_51175; default: __bad_percpu_size(); } ldv_51175: ; goto ldv_51180; case 2UL: pao_ID_____0 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____0 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_51186; case 2UL: ; if (pao_ID_____0 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51186; case 4UL: ; if (pao_ID_____0 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51186; case 8UL: ; if (pao_ID_____0 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_51186; default: __bad_percpu_size(); } ldv_51186: ; goto ldv_51180; case 4UL: pao_ID_____1 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____1 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_51196; case 2UL: ; if (pao_ID_____1 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51196; case 4UL: ; if (pao_ID_____1 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51196; case 8UL: ; if (pao_ID_____1 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_51196; default: __bad_percpu_size(); } ldv_51196: ; goto ldv_51180; case 8UL: pao_ID_____2 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____2 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_51206; case 2UL: ; if (pao_ID_____2 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51206; case 4UL: ; if (pao_ID_____2 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51206; case 8UL: ; if (pao_ID_____2 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_51206; default: __bad_percpu_size(); } ldv_51206: ; goto ldv_51180; default: __bad_size_call_parameter(); goto ldv_51180; } ldv_51180: ; return; } } __inline static void nfs_inc_stats___0(struct inode const *inode , enum nfs_stat_eventcounters stat ) { struct nfs_server *tmp ; { tmp = NFS_SERVER(inode); nfs_inc_server_stats___0((struct nfs_server const *)tmp, stat); return; } } __inline static void nfs_add_server_stats(struct nfs_server const *server , enum nfs_stat_bytecounters stat , long addend ) { void const *__vpp_verify ; int pao_ID__ ; int pao_ID_____0 ; int pao_ID_____1 ; int pao_ID_____2 ; { __vpp_verify = (void const *)0; switch (8UL) { case 1UL: pao_ID__ = 0; switch (8UL) { case 1UL: ; if (pao_ID__ == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_51227; case 2UL: ; if (pao_ID__ == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51227; case 4UL: ; if (pao_ID__ == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51227; case 8UL: ; if (pao_ID__ == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_51227; default: __bad_percpu_size(); } ldv_51227: ; goto ldv_51232; case 2UL: pao_ID_____0 = 0; switch (8UL) { case 1UL: ; if (pao_ID_____0 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_51238; case 2UL: ; if (pao_ID_____0 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51238; case 4UL: ; if (pao_ID_____0 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51238; case 8UL: ; if (pao_ID_____0 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_51238; default: __bad_percpu_size(); } ldv_51238: ; goto ldv_51232; case 4UL: pao_ID_____1 = 0; switch (8UL) { case 1UL: ; if (pao_ID_____1 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_51248; case 2UL: ; if (pao_ID_____1 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51248; case 4UL: ; if (pao_ID_____1 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51248; case 8UL: ; if (pao_ID_____1 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_51248; default: __bad_percpu_size(); } ldv_51248: ; goto ldv_51232; case 8UL: pao_ID_____2 = 0; switch (8UL) { case 1UL: ; if (pao_ID_____2 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_51258; case 2UL: ; if (pao_ID_____2 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51258; case 4UL: ; if (pao_ID_____2 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51258; case 8UL: ; if (pao_ID_____2 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_51258; default: __bad_percpu_size(); } ldv_51258: ; goto ldv_51232; default: __bad_size_call_parameter(); goto ldv_51232; } ldv_51232: ; return; } } __inline static void nfs_add_stats(struct inode const *inode , enum nfs_stat_bytecounters stat , long addend ) { struct nfs_server *tmp ; { tmp = NFS_SERVER(inode); nfs_add_server_stats((struct nfs_server const *)tmp, stat, addend); return; } } extern void __fscache_wait_on_page_write(struct fscache_cookie * , struct page * ) ; __inline static void fscache_wait_on_page_write(struct fscache_cookie *cookie , struct page *page ) { { if ((unsigned long )cookie != (unsigned long )((struct fscache_cookie *)0)) { __fscache_wait_on_page_write(cookie, page); } else { } return; } } void __nfs_fscache_invalidate_page(struct page *page , struct inode *inode ) ; int nfs_fscache_release_page(struct page *page , gfp_t gfp ) ; __inline static void nfs_fscache_wait_on_page_write(struct nfs_inode *nfsi , struct page *page ) { int tmp ; { tmp = PagePrivate2((struct page const *)page); if (tmp != 0) { fscache_wait_on_page_write(nfsi->fscache, page); } else { } return; } } __inline static void nfs_fscache_invalidate_page(struct page *page , struct inode *inode ) { int tmp ; { tmp = PagePrivate2((struct page const *)page); if (tmp != 0) { __nfs_fscache_invalidate_page(page, inode); } else { } return; } } struct tracepoint __tracepoint_nfs_fsync_enter ; __inline static void trace_nfs_fsync_enter(struct inode const *inode ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_fsync_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_fsync_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 155, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52178: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * ))it_func))(__data, inode); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52178; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_fsync_exit ; __inline static void trace_nfs_fsync_exit(struct inode const *inode , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_fsync_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_fsync_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 156, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52211: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , int ))it_func))(__data, inode, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52211; } else { } } else { } __rcu_read_unlock(); } else { } return; } } static struct vm_operations_struct const nfs_file_vm_ops ; int nfs_check_flags(int flags ) { { if ((flags & 17408) == 17408) { return (-22); } else { } return (0); } } static int nfs_file_open(struct inode *inode , struct file *filp ) { int res ; long tmp ; { tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: open file(%s/%s)\n", ((filp->f_path.dentry)->d_parent)->d_name.name, (filp->f_path.dentry)->d_name.name); } else { } nfs_inc_stats___0((struct inode const *)inode, 4); res = nfs_check_flags((int )filp->f_flags); if (res != 0) { return (res); } else { } res = nfs_open(inode, filp); return (res); } } int nfs_file_release(struct inode *inode , struct file *filp ) { long tmp ; int tmp___0 ; { tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: release(%s/%s)\n", ((filp->f_path.dentry)->d_parent)->d_name.name, (filp->f_path.dentry)->d_name.name); } else { } nfs_inc_stats___0((struct inode const *)inode, 17); tmp___0 = nfs_release(inode, filp); return (tmp___0); } } static int nfs_revalidate_file_size(struct inode *inode , struct file *filp ) { struct nfs_server *server ; struct nfs_server *tmp ; struct nfs_inode *nfsi ; struct nfs_inode *tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; { tmp = NFS_SERVER((struct inode const *)inode); server = tmp; tmp___0 = NFS_I((struct inode const *)inode); nfsi = tmp___0; tmp___1 = nfs_have_delegated_attributes(inode); if (tmp___1 != 0) { goto out_noreval; } else { } if ((filp->f_flags & 16384U) != 0U) { goto force_reval; } else { } if ((nfsi->cache_validity & 32UL) != 0UL) { goto force_reval; } else { } tmp___2 = nfs_attribute_timeout(inode); if (tmp___2 != 0) { goto force_reval; } else { } out_noreval: ; return (0); force_reval: tmp___3 = __nfs_revalidate_inode(server, inode); return (tmp___3); } } loff_t nfs_file_llseek(struct file *filp , loff_t offset , int whence ) { long tmp ; struct inode *inode ; int retval ; int tmp___0 ; loff_t tmp___1 ; { tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: llseek file(%s/%s, %lld, %d)\n", ((filp->f_path.dentry)->d_parent)->d_name.name, (filp->f_path.dentry)->d_name.name, offset, whence); } else { } if (whence != 0 && whence != 1) { inode = (filp->f_mapping)->host; tmp___0 = nfs_revalidate_file_size(inode, filp); retval = tmp___0; if (retval < 0) { return ((loff_t )retval); } else { } } else { } tmp___1 = generic_file_llseek(filp, offset, whence); return (tmp___1); } } int nfs_file_flush(struct file *file , fl_owner_t id ) { struct dentry *dentry ; struct inode *inode ; long tmp ; int tmp___0 ; struct nfs_rpc_ops const *tmp___1 ; int tmp___2 ; int tmp___3 ; { dentry = file->f_path.dentry; inode = dentry->d_inode; tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: flush(%s/%s)\n", (dentry->d_parent)->d_name.name, dentry->d_name.name); } else { } nfs_inc_stats___0((struct inode const *)inode, 14); if ((file->f_mode & 2U) == 0U) { return (0); } else { } tmp___1 = NFS_PROTO((struct inode const *)inode); tmp___2 = (*(tmp___1->have_delegation))(inode, 2U); if (tmp___2 != 0) { tmp___0 = filemap_fdatawrite(file->f_mapping); return (tmp___0); } else { } tmp___3 = vfs_fsync(file, 0); return (tmp___3); } } ssize_t nfs_file_read(struct kiocb *iocb , struct iovec const *iov , unsigned long nr_segs , loff_t pos ) { struct dentry *dentry ; struct inode *inode ; ssize_t result ; ssize_t tmp ; size_t tmp___0 ; long tmp___1 ; int tmp___2 ; { dentry = (iocb->ki_filp)->f_path.dentry; inode = dentry->d_inode; if (((iocb->ki_filp)->f_flags & 16384U) != 0U) { tmp = nfs_file_direct_read(iocb, iov, nr_segs, pos, 1); return (tmp); } else { } tmp___1 = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp___1 != 0L) { tmp___0 = iov_length(iov, nr_segs); printk("\001dNFS: read(%s/%s, %lu@%lu)\n", (dentry->d_parent)->d_name.name, dentry->d_name.name, tmp___0, (unsigned long )pos); } else { } tmp___2 = nfs_revalidate_mapping(inode, (iocb->ki_filp)->f_mapping); result = (ssize_t )tmp___2; if (result == 0L) { result = generic_file_aio_read(iocb, iov, nr_segs, pos); if (result > 0L) { nfs_add_stats((struct inode const *)inode, 0, result); } else { } } else { } return (result); } } ssize_t nfs_file_splice_read(struct file *filp , loff_t *ppos , struct pipe_inode_info *pipe , size_t count , unsigned int flags ) { struct dentry *dentry ; struct inode *inode ; ssize_t res ; long tmp ; int tmp___0 ; { dentry = filp->f_path.dentry; inode = dentry->d_inode; tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: splice_read(%s/%s, %lu@%Lu)\n", (dentry->d_parent)->d_name.name, dentry->d_name.name, count, (unsigned long long )*ppos); } else { } tmp___0 = nfs_revalidate_mapping(inode, filp->f_mapping); res = (ssize_t )tmp___0; if (res == 0L) { res = generic_file_splice_read(filp, ppos, pipe, count, flags); if (res > 0L) { nfs_add_stats((struct inode const *)inode, 0, res); } else { } } else { } return (res); } } int nfs_file_mmap(struct file *file , struct vm_area_struct *vma ) { struct dentry *dentry ; struct inode *inode ; int status ; long tmp ; { dentry = file->f_path.dentry; inode = dentry->d_inode; tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: mmap(%s/%s)\n", (dentry->d_parent)->d_name.name, dentry->d_name.name); } else { } status = generic_file_mmap(file, vma); if (status == 0) { vma->vm_ops = & nfs_file_vm_ops; status = nfs_revalidate_mapping(inode, file->f_mapping); } else { } return (status); } } int nfs_file_fsync_commit(struct file *file , loff_t start , loff_t end , int datasync ) { struct dentry *dentry ; struct nfs_open_context *ctx ; struct nfs_open_context *tmp ; struct inode *inode ; int have_error ; int do_resend ; int status ; int ret ; long tmp___0 ; int tmp___1 ; int __ret ; int tmp___2 ; { dentry = file->f_path.dentry; tmp = nfs_file_open_context(file); ctx = tmp; inode = dentry->d_inode; ret = 0; tmp___0 = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001dNFS: fsync file(%s/%s) datasync %d\n", (dentry->d_parent)->d_name.name, dentry->d_name.name, datasync); } else { } nfs_inc_stats___0((struct inode const *)inode, 15); do_resend = test_and_clear_bit(1L, (unsigned long volatile *)(& ctx->flags)); have_error = test_and_clear_bit(0L, (unsigned long volatile *)(& ctx->flags)); status = nfs_commit_inode(inode, 1); tmp___1 = constant_test_bit(0L, (unsigned long const volatile *)(& ctx->flags)); have_error = tmp___1 | have_error; if (have_error != 0) { __ret = 0; switch (4UL) { case 1UL: __asm__ volatile ("xchgb %b0, %1\n": "+q" (__ret), "+m" (ctx->error): : "memory", "cc"); goto ldv_53510; case 2UL: __asm__ volatile ("xchgw %w0, %1\n": "+r" (__ret), "+m" (ctx->error): : "memory", "cc"); goto ldv_53510; case 4UL: __asm__ volatile ("xchgl %0, %1\n": "+r" (__ret), "+m" (ctx->error): : "memory", "cc"); goto ldv_53510; case 8UL: __asm__ volatile ("xchgq %q0, %1\n": "+r" (__ret), "+m" (ctx->error): : "memory", "cc"); goto ldv_53510; default: __xchg_wrong_size(); } ldv_53510: ret = __ret; if (ret != 0) { goto out; } else { } } else { } if (status < 0) { ret = status; goto out; } else { } tmp___2 = constant_test_bit(1L, (unsigned long const volatile *)(& ctx->flags)); do_resend = tmp___2 | do_resend; if (do_resend != 0) { ret = -11; } else { } out: ; return (ret); } } static int nfs_file_fsync(struct file *file , loff_t start , loff_t end , int datasync ) { int ret ; struct inode *inode ; struct inode *tmp ; { tmp = file_inode(file); inode = tmp; trace_nfs_fsync_enter((struct inode const *)inode); ldv_53535: ret = filemap_write_and_wait_range(inode->i_mapping, start, end); if (ret != 0) { goto ldv_53534; } else { } mutex_lock_nested(& inode->i_mutex, 0U); ret = nfs_file_fsync_commit(file, start, end, datasync); mutex_unlock(& inode->i_mutex); start = 0LL; end = 9223372036854775807LL; if (ret == -11) { goto ldv_53535; } else { } ldv_53534: trace_nfs_fsync_exit((struct inode const *)inode, ret); return (ret); } } static int nfs_want_read_modify_write(struct file *file , struct page *page , loff_t pos , unsigned int len ) { unsigned int pglen ; unsigned int tmp ; unsigned int offset ; unsigned int end ; int tmp___0 ; int tmp___1 ; { tmp = nfs_page_length(page); pglen = tmp; offset = (unsigned int )pos & 4095U; end = offset + len; if ((int )file->f_mode & 1) { tmp___0 = PageUptodate(page); if (tmp___0 == 0) { tmp___1 = PagePrivate((struct page const *)page); if (tmp___1 == 0) { if (pglen != 0U) { if (end < pglen || offset != 0U) { return (1); } else { } } else { } } else { } } else { } } else { } return (0); } } static int nfs_write_begin(struct file *file , struct address_space *mapping , loff_t pos , unsigned int len , unsigned int flags , struct page **pagep , void **fsdata ) { int ret ; unsigned long index ; struct page *page ; int once_thru ; long tmp ; struct nfs_inode *tmp___0 ; int tmp___1 ; { index = (unsigned long )(pos >> 12); once_thru = 0; tmp = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: write_begin(%s/%s(%ld), %u@%lld)\n", ((file->f_path.dentry)->d_parent)->d_name.name, (file->f_path.dentry)->d_name.name, (mapping->host)->i_ino, len, pos); } else { } start: tmp___0 = NFS_I((struct inode const *)mapping->host); ret = wait_on_bit((void *)(& tmp___0->flags), 4, & nfs_wait_bit_killable, 130U); if (ret != 0) { return (ret); } else { } page = grab_cache_page_write_begin(mapping, index, flags); if ((unsigned long )page == (unsigned long )((struct page *)0)) { return (-12); } else { } *pagep = page; ret = nfs_flush_incompatible(file, page); if (ret != 0) { unlock_page(page); put_page(page); } else if (once_thru == 0) { tmp___1 = nfs_want_read_modify_write(file, page, pos, len); if (tmp___1 != 0) { once_thru = 1; ret = nfs_readpage(file, page); put_page(page); if (ret == 0) { goto start; } else { } } else { } } else { } return (ret); } } static int nfs_write_end(struct file *file , struct address_space *mapping , loff_t pos , unsigned int len , unsigned int copied , struct page *page , void *fsdata ) { unsigned int offset ; struct nfs_open_context *ctx ; struct nfs_open_context *tmp ; int status ; long tmp___0 ; unsigned int pglen ; unsigned int tmp___1 ; unsigned int end ; int tmp___2 ; struct nfs_inode *tmp___3 ; bool tmp___4 ; { offset = (unsigned int )pos & 4095U; tmp = nfs_file_open_context(file); ctx = tmp; tmp___0 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001dNFS: write_end(%s/%s(%ld), %u@%lld)\n", ((file->f_path.dentry)->d_parent)->d_name.name, (file->f_path.dentry)->d_name.name, (mapping->host)->i_ino, len, pos); } else { } tmp___2 = PageUptodate(page); if (tmp___2 == 0) { tmp___1 = nfs_page_length(page); pglen = tmp___1; end = offset + len; if (pglen == 0U) { zero_user_segments(page, 0U, offset, end, 4096U); SetPageUptodate(page); } else if (end >= pglen) { zero_user_segment(page, end, 4096U); if (offset == 0U) { SetPageUptodate(page); } else { } } else { zero_user_segment(page, pglen, 4096U); } } else { } status = nfs_updatepage(file, page, offset, copied); unlock_page(page); put_page(page); if (status < 0) { return (status); } else { } tmp___3 = NFS_I((struct inode const *)mapping->host); tmp___3->write_io = tmp___3->write_io + (__u64 )copied; tmp___4 = nfs_ctx_key_to_expire(ctx); if ((int )tmp___4) { status = nfs_wb_all(mapping->host); if (status < 0) { return (status); } else { } } else { } return ((int )copied); } } static void nfs_invalidate_page(struct page *page , unsigned int offset , unsigned int length ) { long tmp ; struct address_space *tmp___0 ; { tmp = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: invalidate_page(%p, %u, %u)\n", page, offset, length); } else { } if (offset != 0U || length <= 4095U) { return; } else { } tmp___0 = page_file_mapping(page); nfs_wb_page_cancel(tmp___0->host, page); nfs_fscache_invalidate_page(page, (page->mapping)->host); return; } } static int nfs_release_page(struct page *page , gfp_t gfp ) { struct address_space *mapping ; long tmp ; int how ; int tmp___0 ; struct task_struct *tmp___1 ; int tmp___2 ; int tmp___3 ; { mapping = page->mapping; tmp = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: release_page(%p)\n", page); } else { } if ((unsigned long )mapping != (unsigned long )((struct address_space *)0) && (gfp & 208U) == 208U) { tmp___1 = get_current(); if ((tmp___1->flags & 131072U) == 0U) { how = 1; tmp___0 = current_is_kswapd(); if (tmp___0 != 0) { how = 0; } else { } nfs_commit_inode(mapping->host, how); } else { } } else { } tmp___2 = PagePrivate((struct page const *)page); if (tmp___2 != 0) { return (0); } else { } tmp___3 = nfs_fscache_release_page(page, gfp); return (tmp___3); } } static void nfs_check_dirty_writeback(struct page *page , bool *dirty , bool *writeback ) { struct nfs_inode *nfsi ; struct address_space *mapping ; struct address_space *tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; { tmp = page_file_mapping(page); mapping = tmp; if ((unsigned long )mapping == (unsigned long )((struct address_space *)0)) { return; } else { tmp___0 = PageSwapCache((struct page const *)page); if (tmp___0 != 0) { return; } else { } } nfsi = NFS_I((struct inode const *)mapping->host); tmp___1 = constant_test_bit(7L, (unsigned long const volatile *)(& nfsi->flags)); if (tmp___1 != 0) { *writeback = 1; return; } else { } tmp___2 = PagePrivate((struct page const *)page); if (tmp___2 != 0) { *dirty = 1; } else { } return; } } static int nfs_launder_page(struct page *page ) { struct inode *inode ; struct address_space *tmp ; struct nfs_inode *nfsi ; struct nfs_inode *tmp___0 ; loff_t tmp___1 ; long tmp___2 ; int tmp___3 ; { tmp = page_file_mapping(page); inode = tmp->host; tmp___0 = NFS_I((struct inode const *)inode); nfsi = tmp___0; tmp___2 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___2 != 0L) { tmp___1 = page_offset(page); printk("\001dNFS: launder_page(%ld, %llu)\n", inode->i_ino, tmp___1); } else { } nfs_fscache_wait_on_page_write(nfsi, page); tmp___3 = nfs_wb_page(inode, page); return (tmp___3); } } static int nfs_swap_activate(struct swap_info_struct *sis , struct file *file , sector_t *span ) { struct rpc_clnt *tmp ; int tmp___0 ; { *span = (sector_t )sis->pages; tmp = NFS_CLIENT((struct inode const *)(file->f_mapping)->host); tmp___0 = xs_swapper(tmp->cl_xprt, 1); return (tmp___0); } } static void nfs_swap_deactivate(struct file *file ) { struct rpc_clnt *tmp ; { tmp = NFS_CLIENT((struct inode const *)(file->f_mapping)->host); xs_swapper(tmp->cl_xprt, 0); return; } } struct address_space_operations const nfs_file_aops = {& nfs_writepage, & nfs_readpage, & nfs_writepages, & __set_page_dirty_nobuffers, & nfs_readpages, & nfs_write_begin, & nfs_write_end, 0, & nfs_invalidate_page, & nfs_release_page, 0, & nfs_direct_IO, 0, & nfs_migrate_page, & nfs_launder_page, 0, & nfs_check_dirty_writeback, & generic_error_remove_page, & nfs_swap_activate, & nfs_swap_deactivate}; static int nfs_vm_page_mkwrite(struct vm_area_struct *vma , struct vm_fault *vmf ) { struct page *page ; struct file *filp ; struct dentry *dentry ; unsigned int pagelen ; int ret ; struct address_space *mapping ; loff_t tmp ; long tmp___0 ; struct nfs_inode *tmp___1 ; int tmp___2 ; int tmp___3 ; { page = vmf->page; filp = vma->vm_file; dentry = filp->f_path.dentry; ret = 256; tmp___0 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___0 != 0L) { tmp = page_offset(page); printk("\001dNFS: vm_page_mkwrite(%s/%s(%ld), offset %lld)\n", (dentry->d_parent)->d_name.name, dentry->d_name.name, ((filp->f_mapping)->host)->i_ino, tmp); } else { } tmp___1 = NFS_I((struct inode const *)dentry->d_inode); nfs_fscache_wait_on_page_write(tmp___1, page); lock_page(page); mapping = page_file_mapping(page); if ((unsigned long )(dentry->d_inode)->i_mapping != (unsigned long )mapping) { goto out_unlock; } else { } wait_on_page_writeback(page); pagelen = nfs_page_length(page); if (pagelen == 0U) { goto out_unlock; } else { } ret = 512; tmp___2 = nfs_flush_incompatible(filp, page); if (tmp___2 == 0) { tmp___3 = nfs_updatepage(filp, page, 0U, pagelen); if (tmp___3 == 0) { goto out; } else { } } else { } ret = 2; out_unlock: unlock_page(page); out: ; return (ret); } } static struct vm_operations_struct const nfs_file_vm_ops = {0, 0, & filemap_fault, & nfs_vm_page_mkwrite, 0, 0, 0, 0, & generic_file_remap_pages}; static int nfs_need_sync_write(struct file *filp , struct inode *inode ) { struct nfs_open_context *ctx ; int tmp ; bool tmp___0 ; { if ((((inode->i_sb)->s_flags & 16UL) != 0UL || (int )inode->i_flags & 1) || (filp->f_flags & 4096U) != 0U) { return (1); } else { } ctx = nfs_file_open_context(filp); tmp = constant_test_bit(0L, (unsigned long const volatile *)(& ctx->flags)); if (tmp != 0) { return (1); } else { tmp___0 = nfs_ctx_key_to_expire(ctx); if ((int )tmp___0) { return (1); } else { } } return (0); } } ssize_t nfs_file_write(struct kiocb *iocb , struct iovec const *iov , unsigned long nr_segs , loff_t pos ) { struct dentry *dentry ; struct inode *inode ; unsigned long written ; ssize_t result ; size_t count ; size_t tmp ; int tmp___0 ; ssize_t tmp___1 ; long tmp___2 ; int tmp___3 ; int err ; int tmp___4 ; int tmp___5 ; { dentry = (iocb->ki_filp)->f_path.dentry; inode = dentry->d_inode; written = 0UL; tmp = iov_length(iov, nr_segs); count = tmp; tmp___0 = nfs_key_timeout_notify(iocb->ki_filp, inode); result = (ssize_t )tmp___0; if (result != 0L) { return (result); } else { } if (((iocb->ki_filp)->f_flags & 16384U) != 0U) { tmp___1 = nfs_file_direct_write(iocb, iov, nr_segs, pos, 1); return (tmp___1); } else { } tmp___2 = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp___2 != 0L) { printk("\001dNFS: write(%s/%s, %lu@%Ld)\n", (dentry->d_parent)->d_name.name, dentry->d_name.name, count, pos); } else { } result = -16L; if ((inode->i_flags & 256U) != 0U) { goto out_swapfile; } else { } if (((iocb->ki_filp)->f_flags & 1024U) != 0U) { tmp___3 = nfs_revalidate_file_size(inode, iocb->ki_filp); result = (ssize_t )tmp___3; if (result != 0L) { goto out; } else { } } else { } result = (ssize_t )count; if (count == 0UL) { goto out; } else { } result = generic_file_aio_write(iocb, iov, nr_segs, pos); if (result > 0L) { written = (unsigned long )result; } else { } if (result >= 0L) { tmp___5 = nfs_need_sync_write(iocb->ki_filp, inode); if (tmp___5 != 0) { tmp___4 = vfs_fsync(iocb->ki_filp, 0); err = tmp___4; if (err < 0) { result = (ssize_t )err; } else { } } else { } } else { } if (result > 0L) { nfs_add_stats((struct inode const *)inode, 1, (long )written); } else { } out: ; return (result); out_swapfile: printk("\016NFS: attempt to write to active swap file!\n"); goto out; } } ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe , struct file *filp , loff_t *ppos , size_t count , unsigned int flags ) { struct dentry *dentry ; struct inode *inode ; unsigned long written ; ssize_t ret ; long tmp ; int err ; int tmp___0 ; int tmp___1 ; { dentry = filp->f_path.dentry; inode = dentry->d_inode; written = 0UL; tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS splice_write(%s/%s, %lu@%llu)\n", (dentry->d_parent)->d_name.name, dentry->d_name.name, count, (unsigned long long )*ppos); } else { } ret = generic_file_splice_write(pipe, filp, ppos, count, flags); if (ret > 0L) { written = (unsigned long )ret; } else { } if (ret >= 0L) { tmp___1 = nfs_need_sync_write(filp, inode); if (tmp___1 != 0) { tmp___0 = vfs_fsync(filp, 0); err = tmp___0; if (err < 0) { ret = (ssize_t )err; } else { } } else { } } else { } if (ret > 0L) { nfs_add_stats((struct inode const *)inode, 1, (long )written); } else { } return (ret); } } static int do_getlk(struct file *filp , int cmd , struct file_lock *fl , int is_local ) { struct inode *inode ; int status ; unsigned int saved_type ; struct nfs_rpc_ops const *tmp ; int tmp___0 ; struct nfs_rpc_ops const *tmp___1 ; { inode = (filp->f_mapping)->host; status = 0; saved_type = (unsigned int )fl->fl_type; posix_test_lock(filp, fl); if ((unsigned int )fl->fl_type != 2U) { goto out; } else { } fl->fl_type = (unsigned char )saved_type; tmp = NFS_PROTO((struct inode const *)inode); tmp___0 = (*(tmp->have_delegation))(inode, 1U); if (tmp___0 != 0) { goto out_noconflict; } else { } if (is_local != 0) { goto out_noconflict; } else { } tmp___1 = NFS_PROTO((struct inode const *)inode); status = (*(tmp___1->lock))(filp, cmd, fl); out: ; return (status); out_noconflict: fl->fl_type = 2U; goto out; } } static int do_vfs_lock(struct file *file , struct file_lock *fl ) { int res ; { res = 0; switch (fl->fl_flags & 3U) { case 1U: res = posix_lock_file_wait(file, fl); goto ldv_53685; case 2U: res = flock_lock_file_wait(file, fl); goto ldv_53685; default: __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/file.o.c.prepared"), "i" (980), "i" (12UL)); ldv_53688: ; goto ldv_53688; } ldv_53685: ; return (res); } } static int do_unlk(struct file *filp , int cmd , struct file_lock *fl , int is_local ) { struct inode *inode ; struct nfs_lock_context *l_ctx ; int status ; struct nfs_open_context *tmp ; long tmp___0 ; struct nfs_rpc_ops const *tmp___1 ; { inode = (filp->f_mapping)->host; nfs_sync_mapping(filp->f_mapping); tmp = nfs_file_open_context(filp); l_ctx = nfs_get_lock_context(tmp); tmp___0 = IS_ERR((void const *)l_ctx); if (tmp___0 == 0L) { status = nfs_iocounter_wait(& l_ctx->io_count); nfs_put_lock_context(l_ctx); if (status < 0) { return (status); } else { } } else { } if (is_local == 0) { tmp___1 = NFS_PROTO((struct inode const *)inode); status = (*(tmp___1->lock))(filp, cmd, fl); } else { status = do_vfs_lock(filp, fl); } return (status); } } static int is_time_granular(struct timespec *ts ) { { return (ts->tv_sec == 0L && ts->tv_nsec <= 1000L); } } static int do_setlk(struct file *filp , int cmd , struct file_lock *fl , int is_local ) { struct inode *inode ; int status ; struct nfs_rpc_ops const *tmp ; struct nfs_server *tmp___0 ; struct nfs_server *tmp___1 ; int tmp___2 ; struct nfs_rpc_ops const *tmp___3 ; int tmp___4 ; { inode = (filp->f_mapping)->host; status = nfs_sync_mapping(filp->f_mapping); if (status != 0) { goto out; } else { } if (is_local == 0) { tmp = NFS_PROTO((struct inode const *)inode); status = (*(tmp->lock))(filp, cmd, fl); } else { status = do_vfs_lock(filp, fl); } if (status < 0) { goto out; } else { } nfs_sync_mapping(filp->f_mapping); tmp___3 = NFS_PROTO((struct inode const *)inode); tmp___4 = (*(tmp___3->have_delegation))(inode, 1U); if (tmp___4 == 0) { tmp___1 = NFS_SERVER((struct inode const *)inode); tmp___2 = is_time_granular(& tmp___1->time_delta); if (tmp___2 != 0) { tmp___0 = NFS_SERVER((struct inode const *)inode); __nfs_revalidate_inode(tmp___0, inode); } else { nfs_zap_caches(inode); } } else { } out: ; return (status); } } int nfs_lock(struct file *filp , int cmd , struct file_lock *fl ) { struct inode *inode ; int ret ; int is_local ; long tmp ; int tmp___0 ; struct nfs_server *tmp___1 ; struct nfs_rpc_ops const *tmp___2 ; struct nfs_rpc_ops const *tmp___3 ; { inode = (filp->f_mapping)->host; ret = -37; is_local = 0; tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: lock(%s/%s, t=%x, fl=%x, r=%lld:%lld)\n", ((filp->f_path.dentry)->d_parent)->d_name.name, (filp->f_path.dentry)->d_name.name, (int )fl->fl_type, fl->fl_flags, fl->fl_start, fl->fl_end); } else { } nfs_inc_stats___0((struct inode const *)inode, 16); tmp___0 = __mandatory_lock(inode); if (tmp___0 != 0 && (unsigned int )fl->fl_type != 2U) { goto out_err; } else { } tmp___1 = NFS_SERVER((struct inode const *)inode); if ((tmp___1->flags & 2097152) != 0) { is_local = 1; } else { } tmp___3 = NFS_PROTO((struct inode const *)inode); if ((unsigned long )tmp___3->lock_check_bounds != (unsigned long )((int (*/* const */)(struct file_lock const * ))0)) { tmp___2 = NFS_PROTO((struct inode const *)inode); ret = (*(tmp___2->lock_check_bounds))((struct file_lock const *)fl); if (ret < 0) { goto out_err; } else { } } else { } if (cmd == 5) { ret = do_getlk(filp, cmd, fl, is_local); } else if ((unsigned int )fl->fl_type == 2U) { ret = do_unlk(filp, cmd, fl, is_local); } else { ret = do_setlk(filp, cmd, fl, is_local); } out_err: ; return (ret); } } int nfs_flock(struct file *filp , int cmd , struct file_lock *fl ) { struct inode *inode ; int is_local ; long tmp ; struct nfs_server *tmp___0 ; int tmp___1 ; int tmp___2 ; { inode = (filp->f_mapping)->host; is_local = 0; tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: flock(%s/%s, t=%x, fl=%x)\n", ((filp->f_path.dentry)->d_parent)->d_name.name, (filp->f_path.dentry)->d_name.name, (int )fl->fl_type, fl->fl_flags); } else { } if ((fl->fl_flags & 2U) == 0U) { return (-37); } else { } if (((int )fl->fl_type & 32) != 0) { return (-22); } else { } tmp___0 = NFS_SERVER((struct inode const *)inode); if ((tmp___0->flags & 1048576) != 0) { is_local = 1; } else { } fl->fl_owner = (struct files_struct *)filp; fl->fl_start = 0LL; fl->fl_end = 9223372036854775807LL; if ((unsigned int )fl->fl_type == 2U) { tmp___1 = do_unlk(filp, cmd, fl, is_local); return (tmp___1); } else { } tmp___2 = do_setlk(filp, cmd, fl, is_local); return (tmp___2); } } int nfs_setlease(struct file *file , long arg , struct file_lock **fl ) { long tmp ; { tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: setlease(%s/%s, arg=%ld)\n", ((file->f_path.dentry)->d_parent)->d_name.name, (file->f_path.dentry)->d_name.name, arg); } else { } return (-22); } } struct file_operations const nfs_file_operations = {0, & nfs_file_llseek, & do_sync_read, & do_sync_write, & nfs_file_read, & nfs_file_write, 0, 0, 0, 0, & nfs_file_mmap, & nfs_file_open, & nfs_file_flush, & nfs_file_release, & nfs_file_fsync, 0, 0, & nfs_lock, 0, 0, & nfs_check_flags, & nfs_flock, & nfs_file_splice_write, & nfs_file_splice_read, & nfs_setlease, 0, 0}; int ldv_retval_5 ; extern int ldv_probe_63(void) ; extern int ldv_release_63(void) ; extern int ldv_release_64(void) ; int ldv_retval_7 ; extern int ldv_probe_64(void) ; void ldv_initialize_vm_operations_struct_63(void) { void *tmp ; void *tmp___0 ; { tmp = ldv_zalloc(184UL); nfs_file_vm_ops_group1 = (struct vm_area_struct *)tmp; tmp___0 = ldv_zalloc(32UL); nfs_file_vm_ops_group0 = (struct vm_fault *)tmp___0; return; } } void ldv_file_operations_62(void) { void *tmp ; void *tmp___0 ; { tmp = ldv_zalloc(1032UL); nfs_file_operations_group1 = (struct inode *)tmp; tmp___0 = ldv_zalloc(360UL); nfs_file_operations_group2 = (struct file *)tmp___0; return; } } void ldv_file_operations_61(void) { void *tmp ; void *tmp___0 ; { tmp = ldv_zalloc(1032UL); nfs_file_operations_group1 = (struct inode *)tmp; tmp___0 = ldv_zalloc(360UL); nfs_file_operations_group2 = (struct file *)tmp___0; return; } } void ldv_initialize_address_space_operations_64(void) { void *tmp ; void *tmp___0 ; void *tmp___1 ; void *tmp___2 ; { tmp = ldv_zalloc(360UL); nfs_file_aops_group2 = (struct file *)tmp; tmp___0 = ldv_zalloc(432UL); nfs_file_aops_group1 = (struct address_space *)tmp___0; tmp___1 = ldv_zalloc(40UL); nfs_file_aops_group0 = (struct writeback_control *)tmp___1; tmp___2 = ldv_zalloc(64UL); nfs_file_aops_group3 = (struct page *)tmp___2; return; } } void ldv_main_exported_63(void) { unsigned long ldvarg6 ; unsigned long tmp ; unsigned long ldvarg7 ; unsigned long tmp___0 ; unsigned long ldvarg8 ; unsigned long tmp___1 ; int tmp___2 ; { tmp = __VERIFIER_nondet_ulong(); ldvarg6 = tmp; tmp___0 = __VERIFIER_nondet_ulong(); ldvarg7 = tmp___0; tmp___1 = __VERIFIER_nondet_ulong(); ldvarg8 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_63 == 1) { filemap_fault(nfs_file_vm_ops_group1, nfs_file_vm_ops_group0); ldv_state_variable_63 = 1; } else { } if (ldv_state_variable_63 == 2) { filemap_fault(nfs_file_vm_ops_group1, nfs_file_vm_ops_group0); ldv_state_variable_63 = 2; } else { } goto ldv_53790; case 1: ; if (ldv_state_variable_63 == 1) { generic_file_remap_pages(nfs_file_vm_ops_group1, ldvarg8, ldvarg7, ldvarg6); ldv_state_variable_63 = 1; } else { } if (ldv_state_variable_63 == 2) { generic_file_remap_pages(nfs_file_vm_ops_group1, ldvarg8, ldvarg7, ldvarg6); ldv_state_variable_63 = 2; } else { } goto ldv_53790; case 2: ; if (ldv_state_variable_63 == 2) { nfs_vm_page_mkwrite(nfs_file_vm_ops_group1, nfs_file_vm_ops_group0); ldv_state_variable_63 = 2; } else { } goto ldv_53790; case 3: ; if (ldv_state_variable_63 == 2) { ldv_release_63(); ldv_state_variable_63 = 1; ref_cnt = ref_cnt - 1; } else { } goto ldv_53790; case 4: ; if (ldv_state_variable_63 == 1) { ldv_probe_63(); ldv_state_variable_63 = 2; ref_cnt = ref_cnt + 1; } else { } goto ldv_53790; default: ldv_stop(); } ldv_53790: ; return; } } void ldv_main_exported_64(void) { bool *ldvarg117 ; void *tmp ; loff_t ldvarg107 ; loff_t tmp___0 ; unsigned int ldvarg129 ; unsigned int tmp___1 ; int ldvarg108 ; int tmp___2 ; struct kiocb *ldvarg110 ; void *tmp___3 ; enum migrate_mode ldvarg105 ; unsigned int ldvarg124 ; unsigned int tmp___4 ; bool *ldvarg116 ; void *tmp___5 ; sector_t *ldvarg127 ; void *tmp___6 ; void *ldvarg114 ; void *tmp___7 ; struct list_head *ldvarg119 ; void *tmp___8 ; gfp_t ldvarg125 ; loff_t ldvarg113 ; loff_t tmp___9 ; struct page **ldvarg120 ; void *tmp___10 ; unsigned int ldvarg112 ; unsigned int tmp___11 ; unsigned long ldvarg111 ; unsigned long tmp___12 ; void **ldvarg123 ; void *tmp___13 ; struct iovec *ldvarg109 ; void *tmp___14 ; unsigned int ldvarg115 ; unsigned int tmp___15 ; unsigned int ldvarg118 ; unsigned int tmp___16 ; struct swap_info_struct *ldvarg126 ; void *tmp___17 ; unsigned int ldvarg128 ; unsigned int tmp___18 ; loff_t ldvarg122 ; loff_t tmp___19 ; struct page *ldvarg106 ; void *tmp___20 ; unsigned int ldvarg121 ; unsigned int tmp___21 ; int tmp___22 ; { tmp = ldv_zalloc(1UL); ldvarg117 = (bool *)tmp; tmp___0 = __VERIFIER_nondet_loff_t(); ldvarg107 = tmp___0; tmp___1 = __VERIFIER_nondet_uint(); ldvarg129 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); ldvarg108 = tmp___2; tmp___3 = ldv_zalloc(88UL); ldvarg110 = (struct kiocb *)tmp___3; tmp___4 = __VERIFIER_nondet_uint(); ldvarg124 = tmp___4; tmp___5 = ldv_zalloc(1UL); ldvarg116 = (bool *)tmp___5; tmp___6 = ldv_zalloc(8UL); ldvarg127 = (sector_t *)tmp___6; tmp___7 = ldv_zalloc(1UL); ldvarg114 = tmp___7; tmp___8 = ldv_zalloc(16UL); ldvarg119 = (struct list_head *)tmp___8; tmp___9 = __VERIFIER_nondet_loff_t(); ldvarg113 = tmp___9; tmp___10 = ldv_zalloc(8UL); ldvarg120 = (struct page **)tmp___10; tmp___11 = __VERIFIER_nondet_uint(); ldvarg112 = tmp___11; tmp___12 = __VERIFIER_nondet_ulong(); ldvarg111 = tmp___12; tmp___13 = ldv_zalloc(8UL); ldvarg123 = (void **)tmp___13; tmp___14 = ldv_zalloc(16UL); ldvarg109 = (struct iovec *)tmp___14; tmp___15 = __VERIFIER_nondet_uint(); ldvarg115 = tmp___15; tmp___16 = __VERIFIER_nondet_uint(); ldvarg118 = tmp___16; tmp___17 = ldv_zalloc(320UL); ldvarg126 = (struct swap_info_struct *)tmp___17; tmp___18 = __VERIFIER_nondet_uint(); ldvarg128 = tmp___18; tmp___19 = __VERIFIER_nondet_loff_t(); ldvarg122 = tmp___19; tmp___20 = ldv_zalloc(64UL); ldvarg106 = (struct page *)tmp___20; tmp___21 = __VERIFIER_nondet_uint(); ldvarg121 = tmp___21; memset((void *)(& ldvarg105), 0, 4UL); memset((void *)(& ldvarg125), 0, 4UL); tmp___22 = __VERIFIER_nondet_int(); switch (tmp___22) { case 0: ; if (ldv_state_variable_64 == 2) { nfs_readpage(nfs_file_aops_group2, nfs_file_aops_group3); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 1: ; if (ldv_state_variable_64 == 1) { nfs_invalidate_page(nfs_file_aops_group3, ldvarg129, ldvarg128); ldv_state_variable_64 = 1; } else { } if (ldv_state_variable_64 == 2) { nfs_invalidate_page(nfs_file_aops_group3, ldvarg129, ldvarg128); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 2: ; if (ldv_state_variable_64 == 1) { nfs_launder_page(nfs_file_aops_group3); ldv_state_variable_64 = 1; } else { } if (ldv_state_variable_64 == 2) { nfs_launder_page(nfs_file_aops_group3); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 3: ; if (ldv_state_variable_64 == 1) { nfs_swap_activate(ldvarg126, nfs_file_aops_group2, ldvarg127); ldv_state_variable_64 = 1; } else { } if (ldv_state_variable_64 == 2) { nfs_swap_activate(ldvarg126, nfs_file_aops_group2, ldvarg127); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 4: ; if (ldv_state_variable_64 == 1) { nfs_release_page(nfs_file_aops_group3, ldvarg125); ldv_state_variable_64 = 1; } else { } if (ldv_state_variable_64 == 2) { nfs_release_page(nfs_file_aops_group3, ldvarg125); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 5: ; if (ldv_state_variable_64 == 2) { nfs_writepage(nfs_file_aops_group3, nfs_file_aops_group0); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 6: ; if (ldv_state_variable_64 == 1) { nfs_write_begin(nfs_file_aops_group2, nfs_file_aops_group1, ldvarg122, ldvarg121, ldvarg124, ldvarg120, ldvarg123); ldv_state_variable_64 = 1; } else { } if (ldv_state_variable_64 == 2) { nfs_write_begin(nfs_file_aops_group2, nfs_file_aops_group1, ldvarg122, ldvarg121, ldvarg124, ldvarg120, ldvarg123); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 7: ; if (ldv_state_variable_64 == 1) { nfs_readpages(nfs_file_aops_group2, nfs_file_aops_group1, ldvarg119, ldvarg118); ldv_state_variable_64 = 1; } else { } if (ldv_state_variable_64 == 2) { nfs_readpages(nfs_file_aops_group2, nfs_file_aops_group1, ldvarg119, ldvarg118); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 8: ; if (ldv_state_variable_64 == 1) { nfs_check_dirty_writeback(nfs_file_aops_group3, ldvarg117, ldvarg116); ldv_state_variable_64 = 1; } else { } if (ldv_state_variable_64 == 2) { nfs_check_dirty_writeback(nfs_file_aops_group3, ldvarg117, ldvarg116); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 9: ; if (ldv_state_variable_64 == 1) { nfs_write_end(nfs_file_aops_group2, nfs_file_aops_group1, ldvarg113, ldvarg112, ldvarg115, nfs_file_aops_group3, ldvarg114); ldv_state_variable_64 = 1; } else { } if (ldv_state_variable_64 == 2) { nfs_write_end(nfs_file_aops_group2, nfs_file_aops_group1, ldvarg113, ldvarg112, ldvarg115, nfs_file_aops_group3, ldvarg114); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 10: ; if (ldv_state_variable_64 == 1) { nfs_writepages(nfs_file_aops_group1, nfs_file_aops_group0); ldv_state_variable_64 = 1; } else { } if (ldv_state_variable_64 == 2) { nfs_writepages(nfs_file_aops_group1, nfs_file_aops_group0); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 11: ; if (ldv_state_variable_64 == 1) { nfs_direct_IO(ldvarg108, ldvarg110, (struct iovec const *)ldvarg109, ldvarg107, ldvarg111); ldv_state_variable_64 = 1; } else { } if (ldv_state_variable_64 == 2) { nfs_direct_IO(ldvarg108, ldvarg110, (struct iovec const *)ldvarg109, ldvarg107, ldvarg111); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 12: ; if (ldv_state_variable_64 == 1) { __set_page_dirty_nobuffers(nfs_file_aops_group3); ldv_state_variable_64 = 1; } else { } if (ldv_state_variable_64 == 2) { __set_page_dirty_nobuffers(nfs_file_aops_group3); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 13: ; if (ldv_state_variable_64 == 1) { nfs_migrate_page(nfs_file_aops_group1, nfs_file_aops_group3, ldvarg106, ldvarg105); ldv_state_variable_64 = 1; } else { } if (ldv_state_variable_64 == 2) { nfs_migrate_page(nfs_file_aops_group1, nfs_file_aops_group3, ldvarg106, ldvarg105); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 14: ; if (ldv_state_variable_64 == 1) { nfs_swap_deactivate(nfs_file_aops_group2); ldv_state_variable_64 = 1; } else { } if (ldv_state_variable_64 == 2) { nfs_swap_deactivate(nfs_file_aops_group2); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 15: ; if (ldv_state_variable_64 == 1) { generic_error_remove_page(nfs_file_aops_group1, nfs_file_aops_group3); ldv_state_variable_64 = 1; } else { } if (ldv_state_variable_64 == 2) { generic_error_remove_page(nfs_file_aops_group1, nfs_file_aops_group3); ldv_state_variable_64 = 2; } else { } goto ldv_53825; case 16: ; if (ldv_state_variable_64 == 2) { ldv_release_64(); ldv_state_variable_64 = 1; ref_cnt = ref_cnt - 1; } else { } goto ldv_53825; case 17: ; if (ldv_state_variable_64 == 1) { ldv_probe_64(); ldv_state_variable_64 = 2; ref_cnt = ref_cnt + 1; } else { } goto ldv_53825; default: ldv_stop(); } ldv_53825: ; return; } } void ldv_main_exported_61(void) { struct vm_area_struct *ldvarg75 ; void *tmp ; unsigned long ldvarg52 ; unsigned long tmp___0 ; unsigned int ldvarg74 ; unsigned int tmp___1 ; int ldvarg76 ; int tmp___2 ; loff_t ldvarg61 ; loff_t tmp___3 ; size_t ldvarg54 ; size_t tmp___4 ; loff_t *ldvarg68 ; void *tmp___5 ; int ldvarg78 ; int tmp___6 ; char *ldvarg70 ; void *tmp___7 ; loff_t *ldvarg73 ; void *tmp___8 ; unsigned long ldvarg63 ; unsigned long tmp___9 ; loff_t ldvarg45 ; loff_t tmp___10 ; size_t ldvarg66 ; size_t tmp___11 ; struct pipe_inode_info *ldvarg55 ; void *tmp___12 ; struct files_struct *ldvarg79 ; void *tmp___13 ; loff_t *ldvarg65 ; void *tmp___14 ; unsigned int ldvarg57 ; unsigned int tmp___15 ; struct kiocb *ldvarg62 ; void *tmp___16 ; long ldvarg49 ; loff_t ldvarg59 ; loff_t tmp___17 ; loff_t ldvarg60 ; loff_t tmp___18 ; int ldvarg47 ; int tmp___19 ; struct file_lock **ldvarg48 ; void *tmp___20 ; size_t ldvarg69 ; size_t tmp___21 ; int ldvarg44 ; int tmp___22 ; struct iovec *ldvarg64 ; void *tmp___23 ; struct iovec *ldvarg53 ; void *tmp___24 ; int ldvarg58 ; int tmp___25 ; struct file_lock *ldvarg46 ; void *tmp___26 ; loff_t ldvarg50 ; loff_t tmp___27 ; loff_t *ldvarg56 ; void *tmp___28 ; struct pipe_inode_info *ldvarg72 ; void *tmp___29 ; size_t ldvarg71 ; size_t tmp___30 ; char *ldvarg67 ; void *tmp___31 ; struct kiocb *ldvarg51 ; void *tmp___32 ; struct file_lock *ldvarg77 ; void *tmp___33 ; int tmp___34 ; { tmp = ldv_zalloc(184UL); ldvarg75 = (struct vm_area_struct *)tmp; tmp___0 = __VERIFIER_nondet_ulong(); ldvarg52 = tmp___0; tmp___1 = __VERIFIER_nondet_uint(); ldvarg74 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); ldvarg76 = tmp___2; tmp___3 = __VERIFIER_nondet_loff_t(); ldvarg61 = tmp___3; tmp___4 = __VERIFIER_nondet_size_t(); ldvarg54 = tmp___4; tmp___5 = ldv_zalloc(8UL); ldvarg68 = (loff_t *)tmp___5; tmp___6 = __VERIFIER_nondet_int(); ldvarg78 = tmp___6; tmp___7 = ldv_zalloc(1UL); ldvarg70 = (char *)tmp___7; tmp___8 = ldv_zalloc(8UL); ldvarg73 = (loff_t *)tmp___8; tmp___9 = __VERIFIER_nondet_ulong(); ldvarg63 = tmp___9; tmp___10 = __VERIFIER_nondet_loff_t(); ldvarg45 = tmp___10; tmp___11 = __VERIFIER_nondet_size_t(); ldvarg66 = tmp___11; tmp___12 = __VERIFIER_nondet_pointer(); ldvarg55 = (struct pipe_inode_info *)tmp___12; tmp___13 = __VERIFIER_nondet_pointer(); ldvarg79 = (struct files_struct *)tmp___13; tmp___14 = ldv_zalloc(8UL); ldvarg65 = (loff_t *)tmp___14; tmp___15 = __VERIFIER_nondet_uint(); ldvarg57 = tmp___15; tmp___16 = ldv_zalloc(88UL); ldvarg62 = (struct kiocb *)tmp___16; tmp___17 = __VERIFIER_nondet_loff_t(); ldvarg59 = tmp___17; tmp___18 = __VERIFIER_nondet_loff_t(); ldvarg60 = tmp___18; tmp___19 = __VERIFIER_nondet_int(); ldvarg47 = tmp___19; tmp___20 = ldv_zalloc(8UL); ldvarg48 = (struct file_lock **)tmp___20; tmp___21 = __VERIFIER_nondet_size_t(); ldvarg69 = tmp___21; tmp___22 = __VERIFIER_nondet_int(); ldvarg44 = tmp___22; tmp___23 = ldv_zalloc(16UL); ldvarg64 = (struct iovec *)tmp___23; tmp___24 = ldv_zalloc(16UL); ldvarg53 = (struct iovec *)tmp___24; tmp___25 = __VERIFIER_nondet_int(); ldvarg58 = tmp___25; tmp___26 = ldv_zalloc(256UL); ldvarg46 = (struct file_lock *)tmp___26; tmp___27 = __VERIFIER_nondet_loff_t(); ldvarg50 = tmp___27; tmp___28 = ldv_zalloc(8UL); ldvarg56 = (loff_t *)tmp___28; tmp___29 = __VERIFIER_nondet_pointer(); ldvarg72 = (struct pipe_inode_info *)tmp___29; tmp___30 = __VERIFIER_nondet_size_t(); ldvarg71 = tmp___30; tmp___31 = ldv_zalloc(1UL); ldvarg67 = (char *)tmp___31; tmp___32 = ldv_zalloc(88UL); ldvarg51 = (struct kiocb *)tmp___32; tmp___33 = ldv_zalloc(256UL); ldvarg77 = (struct file_lock *)tmp___33; memset((void *)(& ldvarg49), 0, 8UL); tmp___34 = __VERIFIER_nondet_int(); switch (tmp___34) { case 0: ; if (ldv_state_variable_61 == 1) { nfs_file_flush(nfs_file_operations_group2, ldvarg79); ldv_state_variable_61 = 1; } else { } if (ldv_state_variable_61 == 2) { nfs_file_flush(nfs_file_operations_group2, ldvarg79); ldv_state_variable_61 = 2; } else { } goto ldv_53884; case 1: ; if (ldv_state_variable_61 == 1) { nfs_flock(nfs_file_operations_group2, ldvarg78, ldvarg77); ldv_state_variable_61 = 1; } else { } if (ldv_state_variable_61 == 2) { nfs_flock(nfs_file_operations_group2, ldvarg78, ldvarg77); ldv_state_variable_61 = 2; } else { } goto ldv_53884; case 2: ; if (ldv_state_variable_61 == 1) { nfs_check_flags(ldvarg76); ldv_state_variable_61 = 1; } else { } if (ldv_state_variable_61 == 2) { nfs_check_flags(ldvarg76); ldv_state_variable_61 = 2; } else { } goto ldv_53884; case 3: ; if (ldv_state_variable_61 == 1) { ldv_retval_5 = nfs_file_open(nfs_file_operations_group1, nfs_file_operations_group2); if (ldv_retval_5 == 0) { ldv_state_variable_61 = 2; ref_cnt = ref_cnt + 1; } else { } } else { } goto ldv_53884; case 4: ; if (ldv_state_variable_61 == 1) { nfs_file_mmap(nfs_file_operations_group2, ldvarg75); ldv_state_variable_61 = 1; } else { } if (ldv_state_variable_61 == 2) { nfs_file_mmap(nfs_file_operations_group2, ldvarg75); ldv_state_variable_61 = 2; } else { } goto ldv_53884; case 5: ; if (ldv_state_variable_61 == 2) { nfs_file_release(nfs_file_operations_group1, nfs_file_operations_group2); ldv_state_variable_61 = 1; ref_cnt = ref_cnt - 1; } else { } goto ldv_53884; case 6: ; if (ldv_state_variable_61 == 1) { nfs_file_splice_read(nfs_file_operations_group2, ldvarg73, ldvarg72, ldvarg71, ldvarg74); ldv_state_variable_61 = 1; } else { } if (ldv_state_variable_61 == 2) { nfs_file_splice_read(nfs_file_operations_group2, ldvarg73, ldvarg72, ldvarg71, ldvarg74); ldv_state_variable_61 = 2; } else { } goto ldv_53884; case 7: ; if (ldv_state_variable_61 == 1) { do_sync_write(nfs_file_operations_group2, (char const *)ldvarg70, ldvarg69, ldvarg68); ldv_state_variable_61 = 1; } else { } if (ldv_state_variable_61 == 2) { do_sync_write(nfs_file_operations_group2, (char const *)ldvarg70, ldvarg69, ldvarg68); ldv_state_variable_61 = 2; } else { } goto ldv_53884; case 8: ; if (ldv_state_variable_61 == 2) { do_sync_read(nfs_file_operations_group2, ldvarg67, ldvarg66, ldvarg65); ldv_state_variable_61 = 2; } else { } goto ldv_53884; case 9: ; if (ldv_state_variable_61 == 1) { nfs_file_read(ldvarg62, (struct iovec const *)ldvarg64, ldvarg63, ldvarg61); ldv_state_variable_61 = 1; } else { } if (ldv_state_variable_61 == 2) { nfs_file_read(ldvarg62, (struct iovec const *)ldvarg64, ldvarg63, ldvarg61); ldv_state_variable_61 = 2; } else { } goto ldv_53884; case 10: ; if (ldv_state_variable_61 == 1) { nfs_file_fsync(nfs_file_operations_group2, ldvarg60, ldvarg59, ldvarg58); ldv_state_variable_61 = 1; } else { } if (ldv_state_variable_61 == 2) { nfs_file_fsync(nfs_file_operations_group2, ldvarg60, ldvarg59, ldvarg58); ldv_state_variable_61 = 2; } else { } goto ldv_53884; case 11: ; if (ldv_state_variable_61 == 1) { nfs_file_splice_write(ldvarg55, nfs_file_operations_group2, ldvarg56, ldvarg54, ldvarg57); ldv_state_variable_61 = 1; } else { } if (ldv_state_variable_61 == 2) { nfs_file_splice_write(ldvarg55, nfs_file_operations_group2, ldvarg56, ldvarg54, ldvarg57); ldv_state_variable_61 = 2; } else { } goto ldv_53884; case 12: ; if (ldv_state_variable_61 == 1) { nfs_file_write(ldvarg51, (struct iovec const *)ldvarg53, ldvarg52, ldvarg50); ldv_state_variable_61 = 1; } else { } if (ldv_state_variable_61 == 2) { nfs_file_write(ldvarg51, (struct iovec const *)ldvarg53, ldvarg52, ldvarg50); ldv_state_variable_61 = 2; } else { } goto ldv_53884; case 13: ; if (ldv_state_variable_61 == 1) { nfs_setlease(nfs_file_operations_group2, ldvarg49, ldvarg48); ldv_state_variable_61 = 1; } else { } if (ldv_state_variable_61 == 2) { nfs_setlease(nfs_file_operations_group2, ldvarg49, ldvarg48); ldv_state_variable_61 = 2; } else { } goto ldv_53884; case 14: ; if (ldv_state_variable_61 == 1) { nfs_lock(nfs_file_operations_group2, ldvarg47, ldvarg46); ldv_state_variable_61 = 1; } else { } if (ldv_state_variable_61 == 2) { nfs_lock(nfs_file_operations_group2, ldvarg47, ldvarg46); ldv_state_variable_61 = 2; } else { } goto ldv_53884; case 15: ; if (ldv_state_variable_61 == 2) { nfs_file_llseek(nfs_file_operations_group2, ldvarg45, ldvarg44); ldv_state_variable_61 = 2; } else { } goto ldv_53884; default: ldv_stop(); } ldv_53884: ; return; } } void ldv_main_exported_62(void) { struct file_lock *ldvarg162 ; void *tmp ; struct pipe_inode_info *ldvarg171 ; void *tmp___0 ; struct iovec *ldvarg180 ; void *tmp___1 ; unsigned long ldvarg179 ; unsigned long tmp___2 ; unsigned int ldvarg173 ; unsigned int tmp___3 ; int ldvarg194 ; int tmp___4 ; loff_t ldvarg176 ; loff_t tmp___5 ; char *ldvarg183 ; void *tmp___6 ; struct file_lock **ldvarg164 ; void *tmp___7 ; int ldvarg192 ; int tmp___8 ; loff_t ldvarg166 ; loff_t tmp___9 ; struct file_lock *ldvarg193 ; void *tmp___10 ; unsigned int ldvarg190 ; unsigned int tmp___11 ; loff_t ldvarg177 ; loff_t tmp___12 ; char *ldvarg186 ; void *tmp___13 ; loff_t *ldvarg184 ; void *tmp___14 ; loff_t *ldvarg172 ; void *tmp___15 ; size_t ldvarg187 ; size_t tmp___16 ; struct files_struct *ldvarg195 ; void *tmp___17 ; loff_t ldvarg175 ; loff_t tmp___18 ; int ldvarg160 ; int tmp___19 ; loff_t ldvarg161 ; loff_t tmp___20 ; struct iovec *ldvarg169 ; void *tmp___21 ; int ldvarg163 ; int tmp___22 ; size_t ldvarg182 ; size_t tmp___23 ; loff_t *ldvarg189 ; void *tmp___24 ; size_t ldvarg170 ; size_t tmp___25 ; struct kiocb *ldvarg167 ; void *tmp___26 ; struct vm_area_struct *ldvarg191 ; void *tmp___27 ; size_t ldvarg185 ; size_t tmp___28 ; struct pipe_inode_info *ldvarg188 ; void *tmp___29 ; unsigned long ldvarg168 ; unsigned long tmp___30 ; long ldvarg165 ; int ldvarg174 ; int tmp___31 ; loff_t *ldvarg181 ; void *tmp___32 ; struct kiocb *ldvarg178 ; void *tmp___33 ; int tmp___34 ; { tmp = ldv_zalloc(256UL); ldvarg162 = (struct file_lock *)tmp; tmp___0 = __VERIFIER_nondet_pointer(); ldvarg171 = (struct pipe_inode_info *)tmp___0; tmp___1 = ldv_zalloc(16UL); ldvarg180 = (struct iovec *)tmp___1; tmp___2 = __VERIFIER_nondet_ulong(); ldvarg179 = tmp___2; tmp___3 = __VERIFIER_nondet_uint(); ldvarg173 = tmp___3; tmp___4 = __VERIFIER_nondet_int(); ldvarg194 = tmp___4; tmp___5 = __VERIFIER_nondet_loff_t(); ldvarg176 = tmp___5; tmp___6 = ldv_zalloc(1UL); ldvarg183 = (char *)tmp___6; tmp___7 = ldv_zalloc(8UL); ldvarg164 = (struct file_lock **)tmp___7; tmp___8 = __VERIFIER_nondet_int(); ldvarg192 = tmp___8; tmp___9 = __VERIFIER_nondet_loff_t(); ldvarg166 = tmp___9; tmp___10 = ldv_zalloc(256UL); ldvarg193 = (struct file_lock *)tmp___10; tmp___11 = __VERIFIER_nondet_uint(); ldvarg190 = tmp___11; tmp___12 = __VERIFIER_nondet_loff_t(); ldvarg177 = tmp___12; tmp___13 = ldv_zalloc(1UL); ldvarg186 = (char *)tmp___13; tmp___14 = ldv_zalloc(8UL); ldvarg184 = (loff_t *)tmp___14; tmp___15 = ldv_zalloc(8UL); ldvarg172 = (loff_t *)tmp___15; tmp___16 = __VERIFIER_nondet_size_t(); ldvarg187 = tmp___16; tmp___17 = __VERIFIER_nondet_pointer(); ldvarg195 = (struct files_struct *)tmp___17; tmp___18 = __VERIFIER_nondet_loff_t(); ldvarg175 = tmp___18; tmp___19 = __VERIFIER_nondet_int(); ldvarg160 = tmp___19; tmp___20 = __VERIFIER_nondet_loff_t(); ldvarg161 = tmp___20; tmp___21 = ldv_zalloc(16UL); ldvarg169 = (struct iovec *)tmp___21; tmp___22 = __VERIFIER_nondet_int(); ldvarg163 = tmp___22; tmp___23 = __VERIFIER_nondet_size_t(); ldvarg182 = tmp___23; tmp___24 = ldv_zalloc(8UL); ldvarg189 = (loff_t *)tmp___24; tmp___25 = __VERIFIER_nondet_size_t(); ldvarg170 = tmp___25; tmp___26 = ldv_zalloc(88UL); ldvarg167 = (struct kiocb *)tmp___26; tmp___27 = ldv_zalloc(184UL); ldvarg191 = (struct vm_area_struct *)tmp___27; tmp___28 = __VERIFIER_nondet_size_t(); ldvarg185 = tmp___28; tmp___29 = __VERIFIER_nondet_pointer(); ldvarg188 = (struct pipe_inode_info *)tmp___29; tmp___30 = __VERIFIER_nondet_ulong(); ldvarg168 = tmp___30; tmp___31 = __VERIFIER_nondet_int(); ldvarg174 = tmp___31; tmp___32 = ldv_zalloc(8UL); ldvarg181 = (loff_t *)tmp___32; tmp___33 = ldv_zalloc(88UL); ldvarg178 = (struct kiocb *)tmp___33; memset((void *)(& ldvarg165), 0, 8UL); tmp___34 = __VERIFIER_nondet_int(); switch (tmp___34) { case 0: ; if (ldv_state_variable_62 == 1) { nfs_file_flush(nfs_file_operations_group2, ldvarg195); ldv_state_variable_62 = 1; } else { } if (ldv_state_variable_62 == 2) { nfs_file_flush(nfs_file_operations_group2, ldvarg195); ldv_state_variable_62 = 2; } else { } goto ldv_53941; case 1: ; if (ldv_state_variable_62 == 1) { nfs_flock(nfs_file_operations_group2, ldvarg194, ldvarg193); ldv_state_variable_62 = 1; } else { } if (ldv_state_variable_62 == 2) { nfs_flock(nfs_file_operations_group2, ldvarg194, ldvarg193); ldv_state_variable_62 = 2; } else { } goto ldv_53941; case 2: ; if (ldv_state_variable_62 == 1) { nfs_check_flags(ldvarg192); ldv_state_variable_62 = 1; } else { } if (ldv_state_variable_62 == 2) { nfs_check_flags(ldvarg192); ldv_state_variable_62 = 2; } else { } goto ldv_53941; case 3: ; if (ldv_state_variable_62 == 1) { ldv_retval_7 = nfs_file_open(nfs_file_operations_group1, nfs_file_operations_group2); if (ldv_retval_7 == 0) { ldv_state_variable_62 = 2; ref_cnt = ref_cnt + 1; } else { } } else { } goto ldv_53941; case 4: ; if (ldv_state_variable_62 == 1) { nfs_file_mmap(nfs_file_operations_group2, ldvarg191); ldv_state_variable_62 = 1; } else { } if (ldv_state_variable_62 == 2) { nfs_file_mmap(nfs_file_operations_group2, ldvarg191); ldv_state_variable_62 = 2; } else { } goto ldv_53941; case 5: ; if (ldv_state_variable_62 == 2) { nfs_file_release(nfs_file_operations_group1, nfs_file_operations_group2); ldv_state_variable_62 = 1; ref_cnt = ref_cnt - 1; } else { } goto ldv_53941; case 6: ; if (ldv_state_variable_62 == 1) { nfs_file_splice_read(nfs_file_operations_group2, ldvarg189, ldvarg188, ldvarg187, ldvarg190); ldv_state_variable_62 = 1; } else { } if (ldv_state_variable_62 == 2) { nfs_file_splice_read(nfs_file_operations_group2, ldvarg189, ldvarg188, ldvarg187, ldvarg190); ldv_state_variable_62 = 2; } else { } goto ldv_53941; case 7: ; if (ldv_state_variable_62 == 1) { do_sync_write(nfs_file_operations_group2, (char const *)ldvarg186, ldvarg185, ldvarg184); ldv_state_variable_62 = 1; } else { } if (ldv_state_variable_62 == 2) { do_sync_write(nfs_file_operations_group2, (char const *)ldvarg186, ldvarg185, ldvarg184); ldv_state_variable_62 = 2; } else { } goto ldv_53941; case 8: ; if (ldv_state_variable_62 == 2) { do_sync_read(nfs_file_operations_group2, ldvarg183, ldvarg182, ldvarg181); ldv_state_variable_62 = 2; } else { } goto ldv_53941; case 9: ; if (ldv_state_variable_62 == 1) { nfs_file_read(ldvarg178, (struct iovec const *)ldvarg180, ldvarg179, ldvarg177); ldv_state_variable_62 = 1; } else { } if (ldv_state_variable_62 == 2) { nfs_file_read(ldvarg178, (struct iovec const *)ldvarg180, ldvarg179, ldvarg177); ldv_state_variable_62 = 2; } else { } goto ldv_53941; case 10: ; if (ldv_state_variable_62 == 1) { nfs_file_fsync(nfs_file_operations_group2, ldvarg176, ldvarg175, ldvarg174); ldv_state_variable_62 = 1; } else { } if (ldv_state_variable_62 == 2) { nfs_file_fsync(nfs_file_operations_group2, ldvarg176, ldvarg175, ldvarg174); ldv_state_variable_62 = 2; } else { } goto ldv_53941; case 11: ; if (ldv_state_variable_62 == 1) { nfs_file_splice_write(ldvarg171, nfs_file_operations_group2, ldvarg172, ldvarg170, ldvarg173); ldv_state_variable_62 = 1; } else { } if (ldv_state_variable_62 == 2) { nfs_file_splice_write(ldvarg171, nfs_file_operations_group2, ldvarg172, ldvarg170, ldvarg173); ldv_state_variable_62 = 2; } else { } goto ldv_53941; case 12: ; if (ldv_state_variable_62 == 1) { nfs_file_write(ldvarg167, (struct iovec const *)ldvarg169, ldvarg168, ldvarg166); ldv_state_variable_62 = 1; } else { } if (ldv_state_variable_62 == 2) { nfs_file_write(ldvarg167, (struct iovec const *)ldvarg169, ldvarg168, ldvarg166); ldv_state_variable_62 = 2; } else { } goto ldv_53941; case 13: ; if (ldv_state_variable_62 == 1) { nfs_setlease(nfs_file_operations_group2, ldvarg165, ldvarg164); ldv_state_variable_62 = 1; } else { } if (ldv_state_variable_62 == 2) { nfs_setlease(nfs_file_operations_group2, ldvarg165, ldvarg164); ldv_state_variable_62 = 2; } else { } goto ldv_53941; case 14: ; if (ldv_state_variable_62 == 1) { nfs_lock(nfs_file_operations_group2, ldvarg163, ldvarg162); ldv_state_variable_62 = 1; } else { } if (ldv_state_variable_62 == 2) { nfs_lock(nfs_file_operations_group2, ldvarg163, ldvarg162); ldv_state_variable_62 = 2; } else { } goto ldv_53941; case 15: ; if (ldv_state_variable_62 == 2) { nfs_file_llseek(nfs_file_operations_group2, ldvarg161, ldvarg160); ldv_state_variable_62 = 2; } else { } goto ldv_53941; default: ldv_stop(); } ldv_53941: ; return; } } __inline static void INIT_HLIST_NODE(struct hlist_node *h ) { { h->next = (struct hlist_node *)0; h->pprev = (struct hlist_node **)0; return; } } __inline static int hlist_unhashed(struct hlist_node const *h ) { { return ((unsigned long )h->pprev == (unsigned long )((struct hlist_node **/* const */)0)); } } __inline static void __hlist_del(struct hlist_node *n ) { struct hlist_node *next ; struct hlist_node **pprev ; { next = n->next; pprev = n->pprev; *pprev = next; if ((unsigned long )next != (unsigned long )((struct hlist_node *)0)) { next->pprev = pprev; } else { } return; } } __inline static void hlist_del_init(struct hlist_node *n ) { int tmp ; { tmp = hlist_unhashed((struct hlist_node const *)n); if (tmp == 0) { __hlist_del(n); INIT_HLIST_NODE(n); } else { } return; } } extern struct dentry *d_obtain_alias(struct inode * ) ; extern struct dentry *d_make_root(struct inode * ) ; extern void security_d_instantiate(struct dentry * , struct inode * ) ; struct dentry *nfs_get_root(struct super_block *sb , struct nfs_fh *mntfh , char const *devname ) ; static int nfs_superblock_set_dummy_root(struct super_block *sb , struct inode *inode ) { { if ((unsigned long )sb->s_root == (unsigned long )((struct dentry *)0)) { sb->s_root = d_make_root(inode); if ((unsigned long )sb->s_root == (unsigned long )((struct dentry *)0)) { return (-12); } else { } ihold(inode); spin_lock(& ((sb->s_root)->d_inode)->i_lock); spin_lock(& (sb->s_root)->d_lockref.ldv_22558.ldv_22557.lock); hlist_del_init(& (sb->s_root)->d_alias); spin_unlock(& (sb->s_root)->d_lockref.ldv_22558.ldv_22557.lock); spin_unlock(& ((sb->s_root)->d_inode)->i_lock); } else { } return (0); } } struct dentry *nfs_get_root(struct super_block *sb , struct nfs_fh *mntfh , char const *devname ) { struct nfs_server *server ; struct nfs_server *tmp ; struct nfs_fsinfo fsinfo ; struct dentry *ret ; struct inode *inode ; void *name ; char *tmp___0 ; int error ; void *tmp___1 ; void *tmp___2 ; long tmp___3 ; void *tmp___4 ; long tmp___5 ; void *tmp___6 ; long tmp___7 ; void *tmp___8 ; long tmp___9 ; long tmp___10 ; { tmp = NFS_SB((struct super_block const *)sb); server = tmp; tmp___0 = kstrdup(devname, 208U); name = (void *)tmp___0; if ((unsigned long )name == (unsigned long )((void *)0)) { tmp___1 = ERR_PTR(-12L); return ((struct dentry *)tmp___1); } else { } fsinfo.fattr = nfs_alloc_fattr(); if ((unsigned long )fsinfo.fattr == (unsigned long )((struct nfs_fattr *)0)) { kfree((void const *)name); tmp___2 = ERR_PTR(-12L); return ((struct dentry *)tmp___2); } else { } error = (*(((server->nfs_client)->rpc_ops)->getroot))(server, mntfh, & fsinfo); if (error < 0) { tmp___3 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___3 != 0L) { printk("\001dnfs_get_root: getattr error = %d\n", - error); } else { } tmp___4 = ERR_PTR((long )error); ret = (struct dentry *)tmp___4; goto out; } else { } inode = nfs_fhget(sb, mntfh, fsinfo.fattr, (struct nfs4_label *)0); tmp___7 = IS_ERR((void const *)inode); if (tmp___7 != 0L) { tmp___5 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___5 != 0L) { printk("\001dnfs_get_root: get root inode failed\n"); } else { } tmp___6 = ERR_CAST((void const *)inode); ret = (struct dentry *)tmp___6; goto out; } else { } error = nfs_superblock_set_dummy_root(sb, inode); if (error != 0) { tmp___8 = ERR_PTR((long )error); ret = (struct dentry *)tmp___8; goto out; } else { } ret = d_obtain_alias(inode); tmp___10 = IS_ERR((void const *)ret); if (tmp___10 != 0L) { tmp___9 = ldv__builtin_expect((nfs_debug & 512U) != 0U, 0L); if (tmp___9 != 0L) { printk("\001dnfs_get_root: get root dentry failed\n"); } else { } goto out; } else { } security_d_instantiate(ret, inode); spin_lock(& ret->d_lockref.ldv_22558.ldv_22557.lock); if ((unsigned long )ret->d_parent == (unsigned long )ret && (ret->d_flags & 4096U) == 0U) { ret->d_fsdata = name; name = (void *)0; } else { } spin_unlock(& ret->d_lockref.ldv_22558.ldv_22557.lock); out: kfree((void const *)name); nfs_free_fattr((struct nfs_fattr const *)fsinfo.fattr); return (ret); } } __inline static __u32 __arch_swab32(__u32 val ) { { __asm__ ("bswapl %0": "=r" (val): "0" (val)); return (val); } } __inline static __u32 __fswab32(__u32 val ) { __u32 tmp ; { tmp = __arch_swab32(val); return (tmp); } } __inline static __u32 __swab32p(__u32 const *p ) { __u32 tmp ; { tmp = __fswab32(*p); return (tmp); } } __inline static __u32 __be32_to_cpup(__be32 const *p ) { __u32 tmp ; { tmp = __swab32p(p); return (tmp); } } extern void __xadd_wrong_size(void) ; __inline static long atomic64_add_return(long i , atomic64_t *v ) { long __ret ; { __ret = i; switch (8UL) { case 1UL: __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; xaddb %b0, %1\n": "+q" (__ret), "+m" (v->counter): : "memory", "cc"); goto ldv_5651; case 2UL: __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; xaddw %w0, %1\n": "+r" (__ret), "+m" (v->counter): : "memory", "cc"); goto ldv_5651; case 4UL: __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; xaddl %0, %1\n": "+r" (__ret), "+m" (v->counter): : "memory", "cc"); goto ldv_5651; case 8UL: __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; xaddq %q0, %1\n": "+r" (__ret), "+m" (v->counter): : "memory", "cc"); goto ldv_5651; default: __xadd_wrong_size(); } ldv_5651: ; return (__ret + i); } } __inline static long atomic_long_inc_return(atomic_long_t *l ) { atomic64_t *v ; long tmp ; { v = l; tmp = atomic64_add_return(1L, v); return (tmp); } } __inline static int timespec_equal(struct timespec const *a , struct timespec const *b ) { { return ((long )a->tv_sec == (long )b->tv_sec && (long )a->tv_nsec == (long )b->tv_nsec); } } __inline static int timespec_compare(struct timespec const *lhs , struct timespec const *rhs ) { { if ((long )lhs->tv_sec < (long )rhs->tv_sec) { return (-1); } else { } if ((long )lhs->tv_sec > (long )rhs->tv_sec) { return (1); } else { } return ((int )((unsigned int )lhs->tv_nsec - (unsigned int )rhs->tv_nsec)); } } extern struct user_namespace init_user_ns ; __inline static uid_t __kuid_val(kuid_t uid ) { { return (uid.val); } } __inline static gid_t __kgid_val(kgid_t gid ) { { return (gid.val); } } __inline static bool uid_eq(kuid_t left , kuid_t right ) { uid_t tmp ; uid_t tmp___0 ; { tmp = __kuid_val(left); tmp___0 = __kuid_val(right); return (tmp == tmp___0); } } __inline static bool gid_eq(kgid_t left , kgid_t right ) { gid_t tmp ; gid_t tmp___0 ; { tmp = __kgid_val(left); tmp___0 = __kgid_val(right); return (tmp == tmp___0); } } extern kuid_t make_kuid(struct user_namespace * , uid_t ) ; extern kgid_t make_kgid(struct user_namespace * , gid_t ) ; extern void __init_waitqueue_head(wait_queue_head_t * , char const * , struct lock_class_key * ) ; extern void __init_rwsem(struct rw_semaphore * , char const * , struct lock_class_key * ) ; extern void call_rcu_sched(struct callback_head * , void (*)(struct callback_head * ) ) ; extern void rcu_barrier(void) ; extern struct workqueue_struct *__alloc_workqueue_key(char const * , unsigned int , int , struct lock_class_key * , char const * , ...) ; extern void destroy_workqueue(struct workqueue_struct * ) ; extern struct kmem_cache *kmem_cache_create(char const * , size_t , size_t , unsigned long , void (*)(void * ) ) ; extern void kmem_cache_destroy(struct kmem_cache * ) ; extern void kmem_cache_free(struct kmem_cache * , void * ) ; extern void *kmem_cache_alloc(struct kmem_cache * , gfp_t ) ; struct inode *nfs_server_list_fops_group1 ; int ldv_state_variable_47 ; int ldv_state_variable_20 ; struct file *nfs_file_aops_group2 ; int ldv_state_variable_30 ; struct ftrace_event_call *event_class_nfs_create_enter_group0 ; int ldv_state_variable_0 ; int ldv_state_variable_45 ; int ldv_state_variable_12 ; struct seq_file *nfs_server_list_ops_group1 ; struct kernel_param *param_ops_portnr_group0 ; int ldv_state_variable_22 ; int ldv_state_variable_54 ; int ldv_state_variable_14 ; struct ftrace_event_call *event_class_nfs_rename_event_done_group0 ; int ldv_state_variable_73 ; int ldv_state_variable_37 ; int ldv_state_variable_29 ; int ldv_state_variable_17 ; int ldv_state_variable_51 ; struct nfs_pageio_descriptor *nfs_pageio_read_ops_group0 ; struct ftrace_event_call *event_class_nfs_atomic_open_enter_group0 ; int ldv_state_variable_66 ; int ldv_state_variable_19 ; int ldv_state_variable_61 ; int ldv_state_variable_27 ; int ldv_state_variable_9 ; struct ftrace_event_call *event_class_nfs_lookup_event_group0 ; int ref_cnt ; int ldv_state_variable_42 ; int ldv_state_variable_7 ; int ldv_state_variable_23 ; struct ftrace_event_call *event_class_nfs_link_exit_group0 ; struct dentry *nfs_symlink_inode_operations_group1 ; int ldv_state_variable_55 ; struct seq_file *nfs_volume_list_ops_group1 ; int ldv_state_variable_72 ; struct super_block *nfs_sops_group3 ; int ldv_state_variable_59 ; int ldv_state_variable_6 ; struct ftrace_event_call *event_class_nfs_inode_event_done_group0 ; struct inode *nfs_volume_list_fops_group1 ; int ldv_state_variable_50 ; int ldv_state_variable_64 ; int ldv_state_variable_26 ; struct shrink_control *acl_shrinker_group1 ; int ldv_state_variable_28 ; struct seq_file *nfs_sops_group1 ; struct dentry *nfs4_dentry_operations_group0 ; int ldv_state_variable_44 ; struct writeback_control *nfs_file_aops_group0 ; int ldv_state_variable_38 ; struct rpc_task *nfs_commit_ops_group0 ; struct rpc_task *nfs_read_common_ops_group0 ; int ldv_state_variable_58 ; int ldv_state_variable_39 ; struct dentry *nfs_dentry_operations_group0 ; int ldv_state_variable_56 ; int ldv_state_variable_3 ; struct ftrace_event_call *event_class_nfs_inode_event_group0 ; int ldv_state_variable_31 ; struct page *nfs_file_aops_group3 ; struct nfs_pgio_header *nfs_direct_read_completion_ops_group0 ; int ldv_state_variable_52 ; void *nfs_server_list_ops_group2 ; int ldv_state_variable_4 ; int ldv_state_variable_68 ; struct rpc_task *nfs_write_common_ops_group0 ; int ldv_state_variable_36 ; int ldv_state_variable_60 ; int ldv_state_variable_8 ; int ldv_state_variable_46 ; int ldv_state_variable_15 ; int ldv_state_variable_48 ; struct ftrace_event_call *event_class_nfs_atomic_open_exit_group0 ; int ldv_state_variable_74 ; int ldv_state_variable_5 ; int ldv_state_variable_21 ; struct ftrace_event_call *event_class_nfs_directory_event_done_group0 ; int ldv_state_variable_33 ; struct vm_fault *nfs_file_vm_ops_group0 ; struct dentry *nfs_referral_inode_operations_group0 ; int ldv_state_variable_13 ; struct dentry *nfs_mountpoint_inode_operations_group0 ; struct rpc_task *nfs_rename_ops_group0 ; struct shrinker *acl_shrinker_group0 ; int ldv_state_variable_69 ; loff_t *nfs_volume_list_ops_group3 ; struct file *nfs_file_operations_group2 ; int ldv_state_variable_65 ; struct ftrace_event_call *event_class_nfs_directory_event_group0 ; struct nfs_pageio_descriptor *nfs_pageio_write_ops_group0 ; int ldv_state_variable_49 ; int ldv_state_variable_24 ; struct dentry *nfs_sops_group2 ; struct net *nfs_net_ops_group0 ; struct ftrace_event_call *event_class_nfs_create_exit_group0 ; struct file *nfs_server_list_fops_group2 ; int ldv_state_variable_70 ; int ldv_state_variable_1 ; int ldv_state_variable_41 ; int ldv_state_variable_62 ; struct inode *nfs_dir_operations_group1 ; struct ftrace_event_call *event_class_nfs_sillyrename_unlink_group0 ; int ldv_state_variable_40 ; int ldv_state_variable_71 ; int ldv_state_variable_10 ; loff_t *nfs_server_list_ops_group3 ; struct vm_area_struct *nfs_file_vm_ops_group1 ; int ldv_state_variable_16 ; int ldv_state_variable_63 ; int ldv_state_variable_43 ; int ldv_state_variable_2 ; int ldv_state_variable_25 ; int ldv_state_variable_57 ; struct nfs_pgio_header *nfs_direct_write_completion_ops_group0 ; struct ftrace_event_call *event_class_nfs_lookup_event_done_group0 ; int ldv_state_variable_11 ; struct ftrace_event_call *event_class_nfs_rename_event_group0 ; int ldv_state_variable_53 ; int ldv_state_variable_67 ; int ldv_state_variable_18 ; struct inode *nfs_file_operations_group1 ; struct nameidata *nfs_symlink_inode_operations_group0 ; struct file *nfs_dir_operations_group2 ; int ldv_state_variable_32 ; int ldv_state_variable_34 ; struct file *nfs_volume_list_fops_group2 ; struct rpc_task *nfs_unlink_ops_group0 ; struct ftrace_event_call *event_class_nfs_link_enter_group0 ; void *nfs_volume_list_ops_group2 ; struct address_space *nfs_file_aops_group1 ; struct inode *nfs_sops_group0 ; int ldv_state_variable_35 ; void ldv_initialize_nfs_pageio_ops_40(void) ; void ldv_initialize_ftrace_event_class_11(void) ; void ldv_initialize_ftrace_event_class_4(void) ; void ldv_initialize_rpc_call_ops_43(void) ; void ldv_initialize_ftrace_event_class_9(void) ; void ldv_initialize_ftrace_event_class_7(void) ; void ldv_initialize_rpc_call_ops_45(void) ; void ldv_initialize_rpc_call_ops_38(void) ; void ldv_initialize_ftrace_event_class_13(void) ; void ldv_initialize_ftrace_event_class_15(void) ; void ldv_initialize_nfs_pageio_ops_46(void) ; void ldv_initialize_inode_operations_35(void) ; void ldv_initialize_rpc_call_ops_42(void) ; void ldv_initialize_inode_operations_44(void) ; void ldv_initialize_ftrace_event_class_18(void) ; void ldv_initialize_ftrace_event_class_10(void) ; void ldv_initialize_ftrace_event_class_17(void) ; void ldv_initialize_nfs_pgio_completion_ops_48(void) ; void ldv_initialize_ftrace_event_class_5(void) ; void ldv_initialize_kernel_param_ops_51(void) ; void ldv_initialize_ftrace_event_class_16(void) ; void ldv_initialize_ftrace_event_class_12(void) ; void ldv_initialize_super_operations_56(void) ; void ldv_initialize_ftrace_event_class_8(void) ; void ldv_initialize_ftrace_event_class_6(void) ; void ldv_initialize_ftrace_event_class_14(void) ; void ldv_initialize_inode_operations_34(void) ; void ldv_initialize_rpc_call_ops_39(void) ; void ldv_initialize_shrinker_52(void) ; void ldv_initialize_nfs_pgio_completion_ops_50(void) ; void ldv_initialize_super_operations_55(void) ; void ldv_initialize_pernet_operations_60(void) ; extern void unmap_mapping_range(struct address_space * , loff_t const , loff_t const , int ) ; extern void truncate_pagecache(struct inode * , loff_t ) ; extern void truncate_inode_pages(struct address_space * , loff_t ) ; extern void lockref_get(struct lockref * ) ; __inline static struct dentry *dget(struct dentry *dentry ) { { if ((unsigned long )dentry != (unsigned long )((struct dentry *)0)) { lockref_get(& dentry->d_lockref); } else { } return (dentry); } } __inline static int inode_unhashed(struct inode *inode ) { int tmp ; { tmp = hlist_unhashed((struct hlist_node const *)(& inode->i_hash)); return (tmp); } } __inline static void i_size_write(struct inode *inode , loff_t i_size ) { { inode->i_size = i_size; return; } } extern void set_nlink(struct inode * , unsigned int ) ; extern void init_special_inode(struct inode * , umode_t , dev_t ) ; extern int invalidate_inode_pages2(struct address_space * ) ; extern int filemap_write_and_wait(struct address_space * ) ; extern void inode_init_once(struct inode * ) ; __inline static int generic_drop_inode(struct inode *inode ) { int tmp ; int tmp___0 ; { if ((unsigned int )inode->ldv_23837.i_nlink == 0U) { tmp___0 = 1; } else { tmp = inode_unhashed(inode); if (tmp != 0) { tmp___0 = 1; } else { tmp___0 = 0; } } return (tmp___0); } } extern struct inode *iget5_locked(struct super_block * , unsigned long , int (*)(struct inode * , void * ) , int (*)(struct inode * , void * ) , void * ) ; extern void unlock_new_inode(struct inode * ) ; extern void clear_inode(struct inode * ) ; extern void inode_dio_wait(struct inode * ) ; extern void generic_fillattr(struct inode * , struct kstat * ) ; extern int inode_newsize_ok(struct inode const * , loff_t ) ; extern struct proc_dir_entry *rpc_proc_register(struct net * , struct rpc_stat * ) ; extern void rpc_proc_unregister(struct net * , char const * ) ; extern struct net init_net ; extern int register_pernet_subsys(struct pernet_operations * ) ; extern void unregister_pernet_subsys(struct pernet_operations * ) ; extern int security_inode_notifysecctx(struct inode * , void * , u32 ) ; __inline static void nfs_copy_fh(struct nfs_fh *target , struct nfs_fh const *source ) { size_t __len ; void *__ret ; { target->size = source->size; __len = (size_t )source->size; __ret = __builtin_memcpy((void *)(& target->data), (void const *)(& source->data), __len); return; } } __inline static int nfs_fsid_equal(struct nfs_fsid const *a , struct nfs_fsid const *b ) { { return ((unsigned long long )a->major == (unsigned long long )b->major && (unsigned long long )a->minor == (unsigned long long )b->minor); } } __inline static unsigned int NFS_MINATTRTIMEO(struct inode const *inode ) { struct nfs_server *nfss ; struct nfs_server *tmp ; { tmp = NFS_SERVER(inode); nfss = tmp; return (((int )inode->i_mode & 61440) == 16384 ? nfss->acdirmin : nfss->acregmin); } } __inline static unsigned int NFS_MAXATTRTIMEO(struct inode const *inode ) { struct nfs_server *nfss ; struct nfs_server *tmp ; { tmp = NFS_SERVER(inode); nfss = tmp; return (((int )inode->i_mode & 61440) == 16384 ? nfss->acdirmax : nfss->acregmax); } } __inline static __u64 NFS_FILEID(struct inode const *inode ) { struct nfs_inode *tmp ; { tmp = NFS_I(inode); return (tmp->fileid); } } __inline static void set_nfs_fileid(struct inode *inode , __u64 fileid ) { struct nfs_inode *tmp ; { tmp = NFS_I((struct inode const *)inode); tmp->fileid = fileid; return; } } void nfs_invalidate_atime(struct inode *inode ) ; int nfs_post_op_update_inode(struct inode *inode , struct nfs_fattr *fattr ) ; int nfs_post_op_update_inode_force_wcc(struct inode *inode , struct nfs_fattr *fattr ) ; int nfs_getattr(struct vfsmount *mnt , struct dentry *dentry , struct kstat *stat ) ; int nfs_setattr(struct dentry *dentry , struct iattr *attr ) ; void nfs_setattr_update_inode(struct inode *inode , struct iattr *attr ) ; struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx ) ; struct nfs_open_context *nfs_find_open_context(struct inode *inode , struct rpc_cred *cred , fmode_t mode ) ; void nfs_inode_attach_open_context(struct nfs_open_context *ctx ) ; u32 _nfs_display_fhandle_hash(struct nfs_fh const *fh ) ; __inline static u32 nfs_display_fhandle_hash(struct nfs_fh const *fh ) { u32 tmp ; { tmp = _nfs_display_fhandle_hash(fh); return (tmp); } } void _nfs_display_fhandle(struct nfs_fh const *fh , char const *caption ) ; struct inode_operations const nfs_symlink_inode_operations ; struct inode_operations const nfs_mountpoint_inode_operations ; struct inode_operations const nfs_referral_inode_operations ; __inline static int nfs_have_writebacks(struct inode *inode ) { struct nfs_inode *tmp ; { tmp = NFS_I((struct inode const *)inode); return (tmp->npages != 0UL); } } __inline static loff_t nfs_size_to_loff_t(__u64 size ) { { if (size > 9223372036854775806ULL) { return (9223372036854775806LL); } else { } return ((loff_t )size); } } __inline static ino_t nfs_fileid_to_ino_t(u64 fileid ) { ino_t ino ; { ino = (unsigned long )fileid; return (ino); } } extern atomic_t system_freezing_cnt ; extern bool freezing_slow_path(struct task_struct * ) ; __inline static bool freezing(struct task_struct *p ) { int tmp ; long tmp___0 ; bool tmp___1 ; { tmp = atomic_read((atomic_t const *)(& system_freezing_cnt)); tmp___0 = ldv__builtin_expect(tmp == 0, 1L); if (tmp___0 != 0L) { return (0); } else { } tmp___1 = freezing_slow_path(p); return (tmp___1); } } extern bool __refrigerator(bool ) ; __inline static bool try_to_freeze_unsafe(void) { struct task_struct *tmp ; bool tmp___0 ; int tmp___1 ; long tmp___2 ; bool tmp___3 ; { __might_sleep("include/linux/freezer.h", 56, 0); tmp = get_current(); tmp___0 = freezing(tmp); if (tmp___0) { tmp___1 = 0; } else { tmp___1 = 1; } tmp___2 = ldv__builtin_expect((long )tmp___1, 1L); if (tmp___2 != 0L) { return (0); } else { } tmp___3 = __refrigerator(0); return (tmp___3); } } __inline static void freezer_do_not_count(void) { struct task_struct *tmp ; { tmp = get_current(); tmp->flags = tmp->flags | 1073741824U; return; } } __inline static void freezer_count_unsafe(void) { struct task_struct *tmp ; { tmp = get_current(); tmp->flags = tmp->flags & 3221225471U; __asm__ volatile ("mfence": : : "memory"); try_to_freeze_unsafe(); return; } } __inline static void freezable_schedule_unsafe(void) { { freezer_do_not_count(); schedule(); freezer_count_unsafe(); return; } } __inline static void nfs_inc_server_stats___1(struct nfs_server const *server , enum nfs_stat_eventcounters stat ) { void const *__vpp_verify ; int pao_ID__ ; int pao_ID_____0 ; int pao_ID_____1 ; int pao_ID_____2 ; { __vpp_verify = (void const *)0; switch (8UL) { case 1UL: pao_ID__ = 1; switch (8UL) { case 1UL: ; if (pao_ID__ == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_51228; case 2UL: ; if (pao_ID__ == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51228; case 4UL: ; if (pao_ID__ == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51228; case 8UL: ; if (pao_ID__ == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_51228; default: __bad_percpu_size(); } ldv_51228: ; goto ldv_51233; case 2UL: pao_ID_____0 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____0 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_51239; case 2UL: ; if (pao_ID_____0 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51239; case 4UL: ; if (pao_ID_____0 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51239; case 8UL: ; if (pao_ID_____0 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_51239; default: __bad_percpu_size(); } ldv_51239: ; goto ldv_51233; case 4UL: pao_ID_____1 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____1 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_51249; case 2UL: ; if (pao_ID_____1 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51249; case 4UL: ; if (pao_ID_____1 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51249; case 8UL: ; if (pao_ID_____1 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_51249; default: __bad_percpu_size(); } ldv_51249: ; goto ldv_51233; case 8UL: pao_ID_____2 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____2 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_51259; case 2UL: ; if (pao_ID_____2 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51259; case 4UL: ; if (pao_ID_____2 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51259; case 8UL: ; if (pao_ID_____2 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_51259; default: __bad_percpu_size(); } ldv_51259: ; goto ldv_51233; default: __bad_size_call_parameter(); goto ldv_51233; } ldv_51233: ; return; } } __inline static void nfs_inc_stats___1(struct inode const *inode , enum nfs_stat_eventcounters stat ) { struct nfs_server *tmp ; { tmp = NFS_SERVER(inode); nfs_inc_server_stats___1((struct nfs_server const *)tmp, stat); return; } } extern u32 crc32_le(u32 , unsigned char const * , size_t ) ; __inline static void nfs_attr_check_mountpoint(struct super_block *parent , struct nfs_fattr *fattr ) { struct nfs_server *tmp ; int tmp___0 ; { tmp = NFS_SB((struct super_block const *)parent); tmp___0 = nfs_fsid_equal((struct nfs_fsid const *)(& tmp->fsid), (struct nfs_fsid const *)(& fattr->fsid)); if (tmp___0 == 0) { fattr->valid = fattr->valid | 2097152U; } else { } return; } } __inline static int nfs_attr_use_mounted_on_fileid(struct nfs_fattr *fattr ) { { if ((fattr->valid & 4194304U) == 0U || ((fattr->valid & 2097152U) == 0U && (fattr->valid & 1048576U) == 0U)) { return (0); } else { } fattr->fileid = fattr->mounted_on_fileid; return (1); } } int nfs_init_nfspagecache(void) ; void nfs_destroy_nfspagecache(void) ; int nfs_init_readpagecache(void) ; void nfs_destroy_readpagecache(void) ; int nfs_init_writepagecache(void) ; void nfs_destroy_writepagecache(void) ; int nfs_init_directcache(void) ; void nfs_destroy_directcache(void) ; __inline static void nfs_iocounter_init(struct nfs_io_counter *c ) { { c->flags = 0UL; atomic_set(& c->io_count, 0); return; } } void nfs_close_context(struct nfs_open_context *ctx , int is_sync ) ; struct workqueue_struct *nfsiod_workqueue ; struct inode *nfs_alloc_inode(struct super_block *sb ) ; void nfs_destroy_inode(struct inode *inode ) ; int nfs_drop_inode(struct inode *inode ) ; void nfs_clear_inode(struct inode *inode ) ; void nfs_evict_inode(struct inode *inode ) ; void nfs_zap_acl_cache(struct inode *inode ) ; int register_nfs_fs(void) ; void unregister_nfs_fs(void) ; void nfs_sb_active(struct super_block *sb ) ; void nfs_sb_deactive(struct super_block *sb ) ; __inline static void nfs_inode_dio_wait(struct inode *inode ) { { inode_dio_wait(inode); return; } } __inline static blkcnt_t nfs_calc_block_size(u64 tsize ) { blkcnt_t used ; { used = (blkcnt_t )((tsize + 511ULL) >> 9); return (used); } } __inline static u32 nfs_fhandle_hash(struct nfs_fh const *fh ) { u32 tmp ; { tmp = crc32_le(4294967295U, (unsigned char const *)(& fh->data), (size_t )fh->size); return (~ tmp); } } extern void __fscache_invalidate(struct fscache_cookie * ) ; extern void __fscache_wait_on_invalidate(struct fscache_cookie * ) ; __inline static void fscache_invalidate(struct fscache_cookie *cookie ) { { if ((unsigned long )cookie != (unsigned long )((struct fscache_cookie *)0)) { __fscache_invalidate(cookie); } else { } return; } } __inline static void fscache_wait_on_invalidate(struct fscache_cookie *cookie ) { { if ((unsigned long )cookie != (unsigned long )((struct fscache_cookie *)0)) { __fscache_wait_on_invalidate(cookie); } else { } return; } } int nfs_fscache_register(void) ; void nfs_fscache_unregister(void) ; void nfs_fscache_init_inode_cookie(struct inode *inode ) ; void nfs_fscache_release_inode_cookie(struct inode *inode ) ; __inline static void nfs_fscache_invalidate(struct inode *inode ) { struct nfs_inode *tmp ; { tmp = NFS_I((struct inode const *)inode); fscache_invalidate(tmp->fscache); return; } } __inline static void nfs_fscache_wait_on_invalidate(struct inode *inode ) { struct nfs_inode *tmp ; { tmp = NFS_I((struct inode const *)inode); fscache_wait_on_invalidate(tmp->fscache); return; } } int nfs_net_id ; struct tracepoint __tracepoint_nfs_refresh_inode_enter ; __inline static void trace_nfs_refresh_inode_enter(struct inode const *inode ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_refresh_inode_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_refresh_inode_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 141, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52867: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * ))it_func))(__data, inode); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52867; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_refresh_inode_exit ; __inline static void trace_nfs_refresh_inode_exit(struct inode const *inode , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_refresh_inode_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_refresh_inode_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 142, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52900: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , int ))it_func))(__data, inode, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52900; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_revalidate_inode_enter ; __inline static void trace_nfs_revalidate_inode_enter(struct inode const *inode ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_revalidate_inode_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_revalidate_inode_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 143, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52934: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * ))it_func))(__data, inode); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52934; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_revalidate_inode_exit ; __inline static void trace_nfs_revalidate_inode_exit(struct inode const *inode , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_revalidate_inode_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_revalidate_inode_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 144, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52967: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , int ))it_func))(__data, inode, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52967; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_invalidate_mapping_enter ; __inline static void trace_nfs_invalidate_mapping_enter(struct inode const *inode ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_invalidate_mapping_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_invalidate_mapping_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 145, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_53001: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * ))it_func))(__data, inode); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_53001; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_invalidate_mapping_exit ; __inline static void trace_nfs_invalidate_mapping_exit(struct inode const *inode , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_invalidate_mapping_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_invalidate_mapping_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 146, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_53034: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , int ))it_func))(__data, inode, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_53034; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_getattr_enter ; __inline static void trace_nfs_getattr_enter(struct inode const *inode ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_getattr_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_getattr_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 147, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_53068: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * ))it_func))(__data, inode); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_53068; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_getattr_exit ; __inline static void trace_nfs_getattr_exit(struct inode const *inode , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_getattr_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_getattr_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 148, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_53101: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , int ))it_func))(__data, inode, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_53101; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_setattr_enter ; __inline static void trace_nfs_setattr_enter(struct inode const *inode ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_setattr_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_setattr_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 149, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_53135: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * ))it_func))(__data, inode); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_53135; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_setattr_exit ; __inline static void trace_nfs_setattr_exit(struct inode const *inode , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_setattr_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_setattr_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 150, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_53168: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , int ))it_func))(__data, inode, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_53168; } else { } } else { } __rcu_read_unlock(); } else { } return; } } static bool enable_ino64 = 1; static void nfs_invalidate_inode(struct inode *inode ) ; static int nfs_update_inode(struct inode *inode , struct nfs_fattr *fattr ) ; static struct kmem_cache *nfs_inode_cachep ; __inline static unsigned long nfs_fattr_to_ino_t(struct nfs_fattr *fattr ) { ino_t tmp ; { tmp = nfs_fileid_to_ino_t(fattr->fileid); return (tmp); } } int nfs_wait_bit_killable(void *word ) { struct task_struct *tmp ; int tmp___0 ; { tmp = get_current(); tmp___0 = fatal_signal_pending(tmp); if (tmp___0 != 0) { return (-512); } else { } freezable_schedule_unsafe(); return (0); } } u64 nfs_compat_user_ino64(u64 fileid ) { compat_ulong_t ino ; { if ((int )enable_ino64) { return (fileid); } else { } ino = (compat_ulong_t )fileid; ino = (compat_ulong_t )(fileid >> 32) ^ ino; return ((u64 )ino); } } int nfs_drop_inode(struct inode *inode ) { int tmp ; int tmp___0 ; int tmp___1 ; { tmp = NFS_STALE((struct inode const *)inode); if (tmp != 0) { tmp___1 = 1; } else { tmp___0 = generic_drop_inode(inode); if (tmp___0 != 0) { tmp___1 = 1; } else { tmp___1 = 0; } } return (tmp___1); } } void nfs_clear_inode(struct inode *inode ) { bool __warned ; int __ret_warn_once ; int tmp ; int __ret_warn_on ; long tmp___0 ; long tmp___1 ; long tmp___2 ; bool __warned___0 ; int __ret_warn_once___0 ; struct nfs_inode *tmp___3 ; int tmp___4 ; int __ret_warn_on___0 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; { tmp = nfs_have_writebacks(inode); __ret_warn_once = tmp != 0; tmp___2 = ldv__builtin_expect(__ret_warn_once != 0, 0L); if (tmp___2 != 0L) { __ret_warn_on = ! __warned; tmp___0 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___0 != 0L) { warn_slowpath_null("/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/inode.o.c.prepared", 314); } else { } tmp___1 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___1 != 0L) { __warned = 1; } else { } } else { } ldv__builtin_expect(__ret_warn_once != 0, 0L); tmp___3 = NFS_I((struct inode const *)inode); tmp___4 = list_empty((struct list_head const *)(& tmp___3->open_files)); __ret_warn_once___0 = tmp___4 == 0; tmp___7 = ldv__builtin_expect(__ret_warn_once___0 != 0, 0L); if (tmp___7 != 0L) { __ret_warn_on___0 = ! __warned___0; tmp___5 = ldv__builtin_expect(__ret_warn_on___0 != 0, 0L); if (tmp___5 != 0L) { warn_slowpath_null("/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/inode.o.c.prepared", 315); } else { } tmp___6 = ldv__builtin_expect(__ret_warn_on___0 != 0, 0L); if (tmp___6 != 0L) { __warned___0 = 1; } else { } } else { } ldv__builtin_expect(__ret_warn_once___0 != 0, 0L); nfs_zap_acl_cache(inode); nfs_access_zap_cache(inode); nfs_fscache_release_inode_cookie(inode); return; } } void nfs_evict_inode(struct inode *inode ) { { truncate_inode_pages(& inode->i_data, 0LL); clear_inode(inode); nfs_clear_inode(inode); return; } } int nfs_sync_mapping(struct address_space *mapping ) { int ret ; { ret = 0; if (mapping->nrpages != 0UL) { unmap_mapping_range(mapping, 0LL, 0LL, 0); ret = nfs_wb_all(mapping->host); } else { } return (ret); } } static void nfs_zap_caches_locked(struct inode *inode ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; int mode ; unsigned int tmp___0 ; struct nfs_inode *tmp___1 ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; mode = (int )inode->i_mode; nfs_inc_stats___1((struct inode const *)inode, 3); tmp___0 = NFS_MINATTRTIMEO((struct inode const *)inode); nfsi->attrtimeo = (unsigned long )tmp___0; nfsi->attrtimeo_timestamp = jiffies; tmp___1 = NFS_I((struct inode const *)inode); memset((void *)(& tmp___1->cookieverf), 0, 8UL); if (((mode & 61440) == 32768 || (mode & 61440) == 16384) || (mode & 61440) == 40960) { nfs_fscache_invalidate(inode); nfsi->cache_validity = nfsi->cache_validity | 187UL; } else { nfsi->cache_validity = nfsi->cache_validity | 185UL; } return; } } void nfs_zap_caches(struct inode *inode ) { { spin_lock(& inode->i_lock); nfs_zap_caches_locked(inode); spin_unlock(& inode->i_lock); return; } } void nfs_zap_mapping(struct inode *inode , struct address_space *mapping ) { struct nfs_inode *tmp ; { if (mapping->nrpages != 0UL) { spin_lock(& inode->i_lock); tmp = NFS_I((struct inode const *)inode); tmp->cache_validity = tmp->cache_validity | 2UL; nfs_fscache_invalidate(inode); spin_unlock(& inode->i_lock); } else { } return; } } void nfs_zap_acl_cache(struct inode *inode ) { void (*clear_acl_cache)(struct inode * ) ; struct nfs_rpc_ops const *tmp ; struct nfs_inode *tmp___0 ; { tmp = NFS_PROTO((struct inode const *)inode); clear_acl_cache = tmp->clear_acl_cache; if ((unsigned long )clear_acl_cache != (unsigned long )((void (*)(struct inode * ))0)) { (*clear_acl_cache)(inode); } else { } spin_lock(& inode->i_lock); tmp___0 = NFS_I((struct inode const *)inode); tmp___0->cache_validity = tmp___0->cache_validity & 0xffffffffffffffefUL; spin_unlock(& inode->i_lock); return; } } void nfs_invalidate_atime(struct inode *inode ) { struct nfs_inode *tmp ; { spin_lock(& inode->i_lock); tmp = NFS_I((struct inode const *)inode); tmp->cache_validity = tmp->cache_validity | 4UL; spin_unlock(& inode->i_lock); return; } } static void nfs_invalidate_inode(struct inode *inode ) { struct nfs_inode *tmp ; { tmp = NFS_I((struct inode const *)inode); set_bit(1L, (unsigned long volatile *)(& tmp->flags)); nfs_zap_caches_locked(inode); return; } } static int nfs_find_actor(struct inode *inode , void *opaque ) { struct nfs_find_desc *desc ; struct nfs_fh *fh ; struct nfs_fattr *fattr ; __u64 tmp ; struct nfs_fh *tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; { desc = (struct nfs_find_desc *)opaque; fh = desc->fh; fattr = desc->fattr; tmp = NFS_FILEID((struct inode const *)inode); if (tmp != fattr->fileid) { return (0); } else { } if (((unsigned int )((int )inode->i_mode ^ (int )fattr->mode) & 61440U) != 0U) { return (0); } else { } tmp___0 = NFS_FH((struct inode const *)inode); tmp___1 = nfs_compare_fh((struct nfs_fh const *)tmp___0, (struct nfs_fh const *)fh); if (tmp___1 != 0) { return (0); } else { } tmp___2 = is_bad_inode(inode); if (tmp___2 != 0) { return (0); } else { tmp___3 = NFS_STALE((struct inode const *)inode); if (tmp___3 != 0) { return (0); } else { } } return (1); } } static int nfs_init_locked(struct inode *inode , void *opaque ) { struct nfs_find_desc *desc ; struct nfs_fattr *fattr ; struct nfs_fh *tmp ; { desc = (struct nfs_find_desc *)opaque; fattr = desc->fattr; set_nfs_fileid(inode, fattr->fileid); tmp = NFS_FH((struct inode const *)inode); nfs_copy_fh(tmp, (struct nfs_fh const *)desc->fh); return (0); } } void nfs_setsecurity(struct inode *inode , struct nfs_fattr *fattr , struct nfs4_label *label ) { int error ; int tmp ; struct nfs_server *tmp___0 ; { if ((unsigned long )label == (unsigned long )((struct nfs4_label *)0)) { return; } else { } tmp = nfs_server_capable(inode, 262144); if (tmp == 0) { return; } else { } tmp___0 = NFS_SERVER((struct inode const *)inode); if ((tmp___0->nfs_client)->cl_minorversion <= 1U) { return; } else { } if ((fattr->valid & 33554432U) != 0U && (unsigned long )inode->i_security != (unsigned long )((void *)0)) { error = security_inode_notifysecctx(inode, (void *)label->label, label->len); if (error != 0) { printk("\v%s() %s %d security_inode_notifysecctx() %d\n", "nfs_setsecurity", label->label, label->len, error); } else { } } else { } return; } } struct nfs4_label *nfs4_label_alloc(struct nfs_server *server , gfp_t flags ) { struct nfs4_label *label ; int minor_version ; void *tmp ; void *tmp___0 ; void *tmp___1 ; void *tmp___2 ; { label = (struct nfs4_label *)0; minor_version = (int )(server->nfs_client)->cl_minorversion; if (minor_version <= 1) { return (label); } else { } if ((server->caps & 262144U) == 0U) { return (label); } else { } tmp = kzalloc(24UL, flags); label = (struct nfs4_label *)tmp; if ((unsigned long )label == (unsigned long )((struct nfs4_label *)0)) { tmp___0 = ERR_PTR(-12L); return ((struct nfs4_label *)tmp___0); } else { } tmp___1 = kzalloc(2048UL, flags); label->label = (char *)tmp___1; if ((unsigned long )label->label == (unsigned long )((char *)0)) { kfree((void const *)label); tmp___2 = ERR_PTR(-12L); return ((struct nfs4_label *)tmp___2); } else { } label->len = 2048U; return (label); } } struct inode *nfs_fhget(struct super_block *sb , struct nfs_fh *fh , struct nfs_fattr *fattr , struct nfs4_label *label ) { struct nfs_find_desc desc ; struct inode *inode ; void *tmp ; unsigned long hash ; int tmp___0 ; void *tmp___1 ; struct nfs_inode *nfsi ; struct nfs_inode *tmp___2 ; unsigned long now ; int tmp___3 ; struct nfs_server *tmp___4 ; struct nfs_server *tmp___5 ; struct nfs_server *tmp___6 ; struct nfs_server *tmp___7 ; int tmp___8 ; int tmp___9 ; int tmp___10 ; int tmp___11 ; int tmp___12 ; int tmp___13 ; int tmp___14 ; unsigned int tmp___15 ; struct rb_root __constr_expr_0 ; int tmp___16 ; u32 tmp___17 ; __u64 tmp___18 ; long tmp___19 ; long tmp___20 ; long tmp___21 ; { desc.fh = fh; desc.fattr = fattr; tmp = ERR_PTR(-2L); inode = (struct inode *)tmp; nfs_attr_check_mountpoint(sb, fattr); if ((fattr->valid & 2048U) == 0U) { tmp___0 = nfs_attr_use_mounted_on_fileid(fattr); if (tmp___0 == 0) { goto out_no_inode; } else { } } else { } if ((fattr->valid & 1U) == 0U) { goto out_no_inode; } else { } hash = nfs_fattr_to_ino_t(fattr); inode = iget5_locked(sb, hash, & nfs_find_actor, & nfs_init_locked, (void *)(& desc)); if ((unsigned long )inode == (unsigned long )((struct inode *)0)) { tmp___1 = ERR_PTR(-12L); inode = (struct inode *)tmp___1; goto out_no_inode; } else { } if ((inode->i_state & 8UL) != 0UL) { tmp___2 = NFS_I((struct inode const *)inode); nfsi = tmp___2; now = jiffies; inode->i_ino = hash; inode->i_flags = inode->i_flags | 130U; inode->i_mode = fattr->mode; if ((fattr->valid & 2U) == 0U) { tmp___3 = nfs_server_capable(inode, 128); if (tmp___3 != 0) { nfsi->cache_validity = nfsi->cache_validity | 1UL; } else { } } else { } tmp___4 = NFS_SB((struct super_block const *)sb); inode->i_op = ((tmp___4->nfs_client)->rpc_ops)->file_inode_ops; if (((int )inode->i_mode & 61440) == 32768) { tmp___5 = NFS_SB((struct super_block const *)sb); inode->i_fop = ((tmp___5->nfs_client)->rpc_ops)->file_ops; inode->i_data.a_ops = & nfs_file_aops; tmp___6 = NFS_SB((struct super_block const *)sb); inode->i_data.backing_dev_info = & tmp___6->backing_dev_info; } else if (((int )inode->i_mode & 61440) == 16384) { tmp___7 = NFS_SB((struct super_block const *)sb); inode->i_op = ((tmp___7->nfs_client)->rpc_ops)->dir_inode_ops; inode->i_fop = & nfs_dir_operations; inode->i_data.a_ops = & nfs_dir_aops; if ((fattr->valid & 2097152U) != 0U || (fattr->valid & 1048576U) != 0U) { if ((fattr->valid & 1048576U) != 0U) { inode->i_op = & nfs_referral_inode_operations; } else { inode->i_op = & nfs_mountpoint_inode_operations; } inode->i_fop = (struct file_operations const *)0; inode->i_flags = inode->i_flags | 2048U; } else { } } else if (((int )inode->i_mode & 61440) == 40960) { inode->i_op = & nfs_symlink_inode_operations; } else { init_special_inode(inode, (int )inode->i_mode, fattr->rdev); } memset((void *)(& inode->i_atime), 0, 16UL); memset((void *)(& inode->i_mtime), 0, 16UL); memset((void *)(& inode->i_ctime), 0, 16UL); inode->i_version = 0ULL; inode->i_size = 0LL; clear_nlink(inode); inode->i_uid = make_kuid(& init_user_ns, 4294967294U); inode->i_gid = make_kgid(& init_user_ns, 4294967294U); inode->i_blocks = 0UL; memset((void *)(& nfsi->cookieverf), 0, 8UL); nfsi->write_io = 0ULL; nfsi->read_io = 0ULL; nfsi->read_cache_jiffies = fattr->time_start; nfsi->attr_gencount = fattr->gencount; if ((fattr->valid & 4096U) != 0U) { inode->i_atime = fattr->atime; } else { tmp___8 = nfs_server_capable(inode, 2048); if (tmp___8 != 0) { nfsi->cache_validity = nfsi->cache_validity | 1UL; } else { } } if ((fattr->valid & 8192U) != 0U) { inode->i_mtime = fattr->mtime; } else { tmp___9 = nfs_server_capable(inode, 8192); if (tmp___9 != 0) { nfsi->cache_validity = nfsi->cache_validity | 1UL; } else { } } if ((fattr->valid & 16384U) != 0U) { inode->i_ctime = fattr->ctime; } else { tmp___10 = nfs_server_capable(inode, 4096); if (tmp___10 != 0) { nfsi->cache_validity = nfsi->cache_validity | 1UL; } else { } } if ((fattr->valid & 131072U) != 0U) { inode->i_version = fattr->change_attr; } else { tmp___11 = nfs_server_capable(inode, 32); if (tmp___11 != 0) { nfsi->cache_validity = nfsi->cache_validity | 1UL; } else { } } if ((fattr->valid & 64U) != 0U) { inode->i_size = nfs_size_to_loff_t(fattr->size); } else { nfsi->cache_validity = nfsi->cache_validity | 33UL; } if ((fattr->valid & 4U) != 0U) { set_nlink(inode, fattr->nlink); } else { tmp___12 = nfs_server_capable(inode, 256); if (tmp___12 != 0) { nfsi->cache_validity = nfsi->cache_validity | 1UL; } else { } } if ((fattr->valid & 8U) != 0U) { inode->i_uid = fattr->uid; } else { tmp___13 = nfs_server_capable(inode, 512); if (tmp___13 != 0) { nfsi->cache_validity = nfsi->cache_validity | 1UL; } else { } } if ((fattr->valid & 16U) != 0U) { inode->i_gid = fattr->gid; } else { tmp___14 = nfs_server_capable(inode, 1024); if (tmp___14 != 0) { nfsi->cache_validity = nfsi->cache_validity | 1UL; } else { } } if ((fattr->valid & 256U) != 0U) { inode->i_blocks = (blkcnt_t )fattr->du.nfs2.blocks; } else { } if ((fattr->valid & 512U) != 0U) { inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); } else { } nfs_setsecurity(inode, fattr, label); tmp___15 = NFS_MINATTRTIMEO((struct inode const *)inode); nfsi->attrtimeo = (unsigned long )tmp___15; nfsi->attrtimeo_timestamp = now; __constr_expr_0.rb_node = (struct rb_node *)0; nfsi->access_cache = __constr_expr_0; nfs_fscache_init_inode_cookie(inode); unlock_new_inode(inode); } else { nfs_refresh_inode(inode, fattr); } tmp___19 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___19 != 0L) { tmp___16 = atomic_read((atomic_t const *)(& inode->i_count)); tmp___17 = nfs_display_fhandle_hash((struct nfs_fh const *)fh); tmp___18 = NFS_FILEID((struct inode const *)inode); printk("\001dNFS: nfs_fhget(%s/%Ld fh_crc=0x%08x ct=%d)\n", (char *)(& (inode->i_sb)->s_id), (long long )tmp___18, tmp___17, tmp___16); } else { } out: ; return (inode); out_no_inode: tmp___21 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___21 != 0L) { tmp___20 = PTR_ERR((void const *)inode); printk("\001dnfs_fhget: iget failed with error %ld\n", tmp___20); } else { } goto out; } } int nfs_setattr(struct dentry *dentry , struct iattr *attr ) { struct inode *inode ; struct nfs_fattr *fattr ; int error ; loff_t tmp ; struct nfs_rpc_ops const *tmp___0 ; struct nfs_rpc_ops const *tmp___1 ; { inode = dentry->d_inode; error = -12; nfs_inc_stats___1((struct inode const *)inode, 13); if ((attr->ia_valid & 6144U) != 0U) { attr->ia_valid = attr->ia_valid & 4294967294U; } else { } if ((attr->ia_valid & 8U) != 0U) { if (((int )inode->i_mode & 61440) != 32768) { attr->ia_valid = attr->ia_valid & 4294967287U; } else { tmp = i_size_read((struct inode const *)inode); if (attr->ia_size == tmp) { attr->ia_valid = attr->ia_valid & 4294967287U; } else { } } } else { } attr->ia_valid = attr->ia_valid & 41407U; if ((attr->ia_valid & 4294926335U) == 0U) { return (0); } else { } trace_nfs_setattr_enter((struct inode const *)inode); if (((int )inode->i_mode & 61440) == 32768) { nfs_inode_dio_wait(inode); nfs_wb_all(inode); } else { } fattr = nfs_alloc_fattr(); if ((unsigned long )fattr == (unsigned long )((struct nfs_fattr *)0)) { goto out; } else { } if ((attr->ia_valid & 7U) != 0U) { tmp___0 = NFS_PROTO((struct inode const *)inode); (*(tmp___0->return_delegation))(inode); } else { } tmp___1 = NFS_PROTO((struct inode const *)inode); error = (*(tmp___1->setattr))(dentry, fattr, attr); if (error == 0) { error = nfs_refresh_inode(inode, fattr); } else { } nfs_free_fattr((struct nfs_fattr const *)fattr); out: trace_nfs_setattr_exit((struct inode const *)inode, error); return (error); } } static int nfs_vmtruncate(struct inode *inode , loff_t offset ) { int err ; { err = inode_newsize_ok((struct inode const *)inode, offset); if (err != 0) { goto out; } else { } spin_lock(& inode->i_lock); i_size_write(inode, offset); spin_unlock(& inode->i_lock); truncate_pagecache(inode, offset); out: ; return (err); } } void nfs_setattr_update_inode(struct inode *inode , struct iattr *attr ) { int mode ; struct nfs_inode *tmp ; { if ((attr->ia_valid & 7U) != 0U) { spin_lock(& inode->i_lock); if ((int )attr->ia_valid & 1) { mode = (int )attr->ia_mode & 4095; mode = ((int )inode->i_mode & -4096) | mode; inode->i_mode = (umode_t )mode; } else { } if ((attr->ia_valid & 2U) != 0U) { inode->i_uid = attr->ia_uid; } else { } if ((attr->ia_valid & 4U) != 0U) { inode->i_gid = attr->ia_gid; } else { } tmp = NFS_I((struct inode const *)inode); tmp->cache_validity = tmp->cache_validity | 24UL; spin_unlock(& inode->i_lock); } else { } if ((attr->ia_valid & 8U) != 0U) { nfs_inc_stats___1((struct inode const *)inode, 19); nfs_vmtruncate(inode, attr->ia_size); } else { } return; } } int nfs_getattr(struct vfsmount *mnt , struct dentry *dentry , struct kstat *stat ) { struct inode *inode ; int need_atime ; struct nfs_inode *tmp ; int err ; struct nfs_server *tmp___0 ; struct nfs_server *tmp___1 ; __u64 tmp___2 ; { inode = dentry->d_inode; tmp = NFS_I((struct inode const *)inode); need_atime = (int )tmp->cache_validity & 4; trace_nfs_getattr_enter((struct inode const *)inode); if (((int )inode->i_mode & 61440) == 32768) { nfs_inode_dio_wait(inode); err = filemap_write_and_wait(inode->i_mapping); if (err != 0) { goto out; } else { } } else { } if ((mnt->mnt_flags & 8) != 0 || ((mnt->mnt_flags & 16) != 0 && ((int )inode->i_mode & 61440) == 16384)) { need_atime = 0; } else { } if (need_atime != 0) { tmp___0 = NFS_SERVER((struct inode const *)inode); err = __nfs_revalidate_inode(tmp___0, inode); } else { tmp___1 = NFS_SERVER((struct inode const *)inode); err = nfs_revalidate_inode(tmp___1, inode); } if (err == 0) { generic_fillattr(inode, stat); tmp___2 = NFS_FILEID((struct inode const *)inode); stat->ino = nfs_compat_user_ino64(tmp___2); } else { } out: trace_nfs_getattr_exit((struct inode const *)inode, err); return (err); } } static void nfs_init_lock_context(struct nfs_lock_context *l_ctx ) { struct task_struct *tmp ; struct task_struct *tmp___0 ; { atomic_set(& l_ctx->count, 1); tmp = get_current(); l_ctx->lockowner.l_owner = tmp->files; tmp___0 = get_current(); l_ctx->lockowner.l_pid = tmp___0->tgid; INIT_LIST_HEAD(& l_ctx->list); nfs_iocounter_init(& l_ctx->io_count); return; } } static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx ) { struct nfs_lock_context *head ; struct nfs_lock_context *pos ; struct task_struct *tmp ; struct task_struct *tmp___0 ; struct list_head const *__mptr ; { head = & ctx->lock_context; pos = head; ldv_54760: tmp = get_current(); if ((unsigned long )pos->lockowner.l_owner != (unsigned long )tmp->files) { goto ldv_54757; } else { } tmp___0 = get_current(); if (pos->lockowner.l_pid != tmp___0->tgid) { goto ldv_54757; } else { } atomic_inc(& pos->count); return (pos); ldv_54757: __mptr = (struct list_head const *)pos->list.next; pos = (struct nfs_lock_context *)__mptr + 0xfffffffffffffff8UL; if ((unsigned long )pos != (unsigned long )head) { goto ldv_54760; } else { } return ((struct nfs_lock_context *)0); } } struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx ) { struct nfs_lock_context *res ; struct nfs_lock_context *new ; struct inode *inode ; void *tmp ; void *tmp___0 ; { new = (struct nfs_lock_context *)0; inode = (ctx->dentry)->d_inode; spin_lock(& inode->i_lock); res = __nfs_find_lock_context(ctx); if ((unsigned long )res == (unsigned long )((struct nfs_lock_context *)0)) { spin_unlock(& inode->i_lock); tmp = kmalloc(64UL, 208U); new = (struct nfs_lock_context *)tmp; if ((unsigned long )new == (unsigned long )((struct nfs_lock_context *)0)) { tmp___0 = ERR_PTR(-12L); return ((struct nfs_lock_context *)tmp___0); } else { } nfs_init_lock_context(new); spin_lock(& inode->i_lock); res = __nfs_find_lock_context(ctx); if ((unsigned long )res == (unsigned long )((struct nfs_lock_context *)0)) { list_add_tail(& new->list, & ctx->lock_context.list); new->open_context = ctx; res = new; new = (struct nfs_lock_context *)0; } else { } } else { } spin_unlock(& inode->i_lock); kfree((void const *)new); return (res); } } void nfs_put_lock_context(struct nfs_lock_context *l_ctx ) { struct nfs_open_context *ctx ; struct inode *inode ; int tmp ; { ctx = l_ctx->open_context; inode = (ctx->dentry)->d_inode; tmp = _atomic_dec_and_lock(& l_ctx->count, & inode->i_lock); if (tmp == 0) { return; } else { } list_del(& l_ctx->list); spin_unlock(& inode->i_lock); kfree((void const *)l_ctx); return; } } void nfs_close_context(struct nfs_open_context *ctx , int is_sync ) { struct inode *inode ; struct nfs_server *server ; struct nfs_inode *tmp ; int tmp___0 ; { if ((ctx->mode & 2U) == 0U) { return; } else { } if (is_sync == 0) { return; } else { } inode = (ctx->dentry)->d_inode; tmp = NFS_I((struct inode const *)inode); tmp___0 = list_empty((struct list_head const *)(& tmp->open_files)); if (tmp___0 == 0) { return; } else { } server = NFS_SERVER((struct inode const *)inode); if ((server->flags & 16) != 0) { return; } else { } nfs_revalidate_inode(server, inode); return; } } struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry , fmode_t f_mode ) { struct nfs_open_context *ctx ; struct rpc_cred *cred ; struct rpc_cred *tmp ; void *tmp___0 ; long tmp___1 ; void *tmp___2 ; void *tmp___3 ; { tmp = rpc_lookup_cred(); cred = tmp; tmp___1 = IS_ERR((void const *)cred); if (tmp___1 != 0L) { tmp___0 = ERR_CAST((void const *)cred); return ((struct nfs_open_context *)tmp___0); } else { } tmp___2 = kmalloc(136UL, 208U); ctx = (struct nfs_open_context *)tmp___2; if ((unsigned long )ctx == (unsigned long )((struct nfs_open_context *)0)) { put_rpccred(cred); tmp___3 = ERR_PTR(-12L); return ((struct nfs_open_context *)tmp___3); } else { } nfs_sb_active(dentry->d_sb); ctx->dentry = dget(dentry); ctx->cred = cred; ctx->state = (struct nfs4_state *)0; ctx->mode = f_mode; ctx->flags = 0UL; ctx->error = 0; nfs_init_lock_context(& ctx->lock_context); ctx->lock_context.open_context = ctx; INIT_LIST_HEAD(& ctx->list); ctx->mdsthreshold = (struct nfs4_threshold *)0; return (ctx); } } struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx ) { { if ((unsigned long )ctx != (unsigned long )((struct nfs_open_context *)0)) { atomic_inc(& ctx->lock_context.count); } else { } return (ctx); } } static void __put_nfs_open_context(struct nfs_open_context *ctx , int is_sync ) { struct inode *inode ; struct super_block *sb ; int tmp ; int tmp___0 ; int tmp___1 ; struct nfs_rpc_ops const *tmp___2 ; { inode = (ctx->dentry)->d_inode; sb = (ctx->dentry)->d_sb; tmp___1 = list_empty((struct list_head const *)(& ctx->list)); if (tmp___1 == 0) { tmp = _atomic_dec_and_lock(& ctx->lock_context.count, & inode->i_lock); if (tmp == 0) { return; } else { } list_del(& ctx->list); spin_unlock(& inode->i_lock); } else { tmp___0 = atomic_dec_and_test(& ctx->lock_context.count); if (tmp___0 == 0) { return; } else { } } if ((unsigned long )inode != (unsigned long )((struct inode *)0)) { tmp___2 = NFS_PROTO((struct inode const *)inode); (*(tmp___2->close_context))(ctx, is_sync); } else { } if ((unsigned long )ctx->cred != (unsigned long )((struct rpc_cred *)0)) { put_rpccred(ctx->cred); } else { } dput(ctx->dentry); nfs_sb_deactive(sb); kfree((void const *)ctx->mdsthreshold); kfree((void const *)ctx); return; } } void put_nfs_open_context(struct nfs_open_context *ctx ) { { __put_nfs_open_context(ctx, 0); return; } } void nfs_inode_attach_open_context(struct nfs_open_context *ctx ) { struct inode *inode ; struct nfs_inode *nfsi ; struct nfs_inode *tmp ; { inode = (ctx->dentry)->d_inode; tmp = NFS_I((struct inode const *)inode); nfsi = tmp; spin_lock(& inode->i_lock); list_add(& ctx->list, & nfsi->open_files); spin_unlock(& inode->i_lock); return; } } void nfs_file_set_open_context(struct file *filp , struct nfs_open_context *ctx ) { struct nfs_open_context *tmp ; int tmp___0 ; { tmp = get_nfs_open_context(ctx); filp->private_data = (void *)tmp; tmp___0 = list_empty((struct list_head const *)(& ctx->list)); if (tmp___0 != 0) { nfs_inode_attach_open_context(ctx); } else { } return; } } struct nfs_open_context *nfs_find_open_context(struct inode *inode , struct rpc_cred *cred , fmode_t mode ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; struct nfs_open_context *pos ; struct nfs_open_context *ctx ; struct list_head const *__mptr ; struct list_head const *__mptr___0 ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; ctx = (struct nfs_open_context *)0; spin_lock(& inode->i_lock); __mptr = (struct list_head const *)nfsi->open_files.next; pos = (struct nfs_open_context *)__mptr + 0xffffffffffffff90UL; goto ldv_54860; ldv_54859: ; if ((unsigned long )cred != (unsigned long )((struct rpc_cred *)0) && (unsigned long )pos->cred != (unsigned long )cred) { goto ldv_54857; } else { } if ((pos->mode & 3U) != mode) { goto ldv_54857; } else { } ctx = get_nfs_open_context(pos); goto ldv_54858; ldv_54857: __mptr___0 = (struct list_head const *)pos->list.next; pos = (struct nfs_open_context *)__mptr___0 + 0xffffffffffffff90UL; ldv_54860: ; if ((unsigned long )(& pos->list) != (unsigned long )(& nfsi->open_files)) { goto ldv_54859; } else { } ldv_54858: spin_unlock(& inode->i_lock); return (ctx); } } static void nfs_file_clear_open_context(struct file *filp ) { struct nfs_open_context *ctx ; struct nfs_open_context *tmp ; struct inode *inode ; struct nfs_inode *tmp___0 ; { tmp = nfs_file_open_context(filp); ctx = tmp; if ((unsigned long )ctx != (unsigned long )((struct nfs_open_context *)0)) { inode = (ctx->dentry)->d_inode; filp->private_data = (void *)0; spin_lock(& inode->i_lock); tmp___0 = NFS_I((struct inode const *)inode); list_move_tail(& ctx->list, & tmp___0->open_files); spin_unlock(& inode->i_lock); __put_nfs_open_context(ctx, (filp->f_flags & 16384U) == 0U); } else { } return; } } int nfs_open(struct inode *inode , struct file *filp ) { struct nfs_open_context *ctx ; long tmp ; long tmp___0 ; { ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode); tmp___0 = IS_ERR((void const *)ctx); if (tmp___0 != 0L) { tmp = PTR_ERR((void const *)ctx); return ((int )tmp); } else { } nfs_file_set_open_context(filp, ctx); put_nfs_open_context(ctx); nfs_fscache_set_inode_cookie(inode, filp); return (0); } } int nfs_release(struct inode *inode , struct file *filp ) { { nfs_file_clear_open_context(filp); return (0); } } int __nfs_revalidate_inode(struct nfs_server *server , struct inode *inode ) { int status ; struct nfs4_label *label ; struct nfs_fattr *fattr ; struct nfs_inode *nfsi ; struct nfs_inode *tmp ; __u64 tmp___0 ; long tmp___1 ; int tmp___2 ; int tmp___3 ; struct nfs_server *tmp___4 ; long tmp___5 ; long tmp___6 ; struct nfs_rpc_ops const *tmp___7 ; struct nfs_fh *tmp___8 ; __u64 tmp___9 ; long tmp___10 ; struct nfs_inode *tmp___11 ; __u64 tmp___12 ; long tmp___13 ; __u64 tmp___14 ; long tmp___15 ; { status = -116; label = (struct nfs4_label *)0; fattr = (struct nfs_fattr *)0; tmp = NFS_I((struct inode const *)inode); nfsi = tmp; tmp___1 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___1 != 0L) { tmp___0 = NFS_FILEID((struct inode const *)inode); printk("\001dNFS: revalidating (%s/%Ld)\n", (char *)(& (inode->i_sb)->s_id), (long long )tmp___0); } else { } trace_nfs_revalidate_inode_enter((struct inode const *)inode); tmp___2 = is_bad_inode(inode); if (tmp___2 != 0) { goto out; } else { } tmp___3 = NFS_STALE((struct inode const *)inode); if (tmp___3 != 0) { goto out; } else { } status = -12; fattr = nfs_alloc_fattr(); if ((unsigned long )fattr == (unsigned long )((struct nfs_fattr *)0)) { goto out; } else { } nfs_inc_stats___1((struct inode const *)inode, 0); tmp___4 = NFS_SERVER((struct inode const *)inode); label = nfs4_label_alloc(tmp___4, 208U); tmp___6 = IS_ERR((void const *)label); if (tmp___6 != 0L) { tmp___5 = PTR_ERR((void const *)label); status = (int )tmp___5; goto out; } else { } tmp___7 = NFS_PROTO((struct inode const *)inode); tmp___8 = NFS_FH((struct inode const *)inode); status = (*(tmp___7->getattr))(server, tmp___8, fattr, label); if (status != 0) { tmp___10 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___10 != 0L) { tmp___9 = NFS_FILEID((struct inode const *)inode); printk("\001dnfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n", (char *)(& (inode->i_sb)->s_id), (long long )tmp___9, status); } else { } if (status == -116) { nfs_zap_caches(inode); if (((int )inode->i_mode & 61440) != 16384) { tmp___11 = NFS_I((struct inode const *)inode); set_bit(1L, (unsigned long volatile *)(& tmp___11->flags)); } else { } } else { } goto err_out; } else { } status = nfs_refresh_inode(inode, fattr); if (status != 0) { tmp___13 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___13 != 0L) { tmp___12 = NFS_FILEID((struct inode const *)inode); printk("\001dnfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n", (char *)(& (inode->i_sb)->s_id), (long long )tmp___12, status); } else { } goto err_out; } else { } if ((nfsi->cache_validity & 16UL) != 0UL) { nfs_zap_acl_cache(inode); } else { } tmp___15 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___15 != 0L) { tmp___14 = NFS_FILEID((struct inode const *)inode); printk("\001dNFS: (%s/%Ld) revalidation complete\n", (char *)(& (inode->i_sb)->s_id), (long long )tmp___14); } else { } err_out: nfs4_label_free(label); out: nfs_free_fattr((struct nfs_fattr const *)fattr); trace_nfs_revalidate_inode_exit((struct inode const *)inode, status); return (status); } } int nfs_attribute_timeout(struct inode *inode ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; return ((long )((unsigned long )jiffies - nfsi->read_cache_jiffies) < 0L || (long )((unsigned long )jiffies - (nfsi->read_cache_jiffies + nfsi->attrtimeo)) >= 0L); } } int nfs_attribute_cache_expired(struct inode *inode ) { int tmp ; int tmp___0 ; { tmp = nfs_have_delegated_attributes(inode); if (tmp != 0) { return (0); } else { } tmp___0 = nfs_attribute_timeout(inode); return (tmp___0); } } int nfs_revalidate_inode(struct nfs_server *server , struct inode *inode ) { int tmp ; struct nfs_inode *tmp___0 ; int tmp___1 ; int tmp___2 ; { tmp___0 = NFS_I((struct inode const *)inode); if ((tmp___0->cache_validity & 129UL) == 0UL) { tmp___1 = nfs_attribute_cache_expired(inode); if (tmp___1 == 0) { tmp = NFS_STALE((struct inode const *)inode); return (tmp != 0 ? -116 : 0); } else { } } else { } tmp___2 = __nfs_revalidate_inode(server, inode); return (tmp___2); } } static int nfs_invalidate_mapping(struct inode *inode , struct address_space *mapping ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; int ret ; __u64 tmp___0 ; long tmp___1 ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; if (mapping->nrpages != 0UL) { if (((int )inode->i_mode & 61440) == 32768) { ret = nfs_sync_mapping(mapping); if (ret < 0) { return (ret); } else { } } else { } ret = invalidate_inode_pages2(mapping); if (ret < 0) { return (ret); } else { } } else { } spin_lock(& inode->i_lock); nfsi->cache_validity = nfsi->cache_validity & 0xfffffffffffffffdUL; if (((int )inode->i_mode & 61440) == 16384) { memset((void *)(& nfsi->cookieverf), 0, 8UL); } else { } spin_unlock(& inode->i_lock); nfs_inc_stats___1((struct inode const *)inode, 2); nfs_fscache_wait_on_invalidate(inode); tmp___1 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___1 != 0L) { tmp___0 = NFS_FILEID((struct inode const *)inode); printk("\001dNFS: (%s/%Ld) data cache invalidated\n", (char *)(& (inode->i_sb)->s_id), (long long )tmp___0); } else { } return (0); } } static bool nfs_mapping_need_revalidate_inode(struct inode *inode ) { int tmp ; struct nfs_inode *tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; { tmp = nfs_have_delegated_attributes(inode); if (tmp != 0) { return (0); } else { } tmp___0 = NFS_I((struct inode const *)inode); if ((tmp___0->cache_validity & 32UL) != 0UL) { tmp___3 = 1; } else { tmp___1 = nfs_attribute_timeout(inode); if (tmp___1 != 0) { tmp___3 = 1; } else { tmp___2 = NFS_STALE((struct inode const *)inode); if (tmp___2 != 0) { tmp___3 = 1; } else { tmp___3 = 0; } } } return ((bool )tmp___3); } } int nfs_revalidate_mapping(struct inode *inode , struct address_space *mapping ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; int ret ; struct nfs_server *tmp___0 ; bool tmp___1 ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; ret = 0; if ((inode->i_flags & 256U) != 0U) { goto out; } else { } tmp___1 = nfs_mapping_need_revalidate_inode(inode); if ((int )tmp___1) { tmp___0 = NFS_SERVER((struct inode const *)inode); ret = __nfs_revalidate_inode(tmp___0, inode); if (ret < 0) { goto out; } else { } } else { } if ((nfsi->cache_validity & 2UL) != 0UL) { trace_nfs_invalidate_mapping_enter((struct inode const *)inode); ret = nfs_invalidate_mapping(inode, mapping); trace_nfs_invalidate_mapping_exit((struct inode const *)inode, ret); } else { } out: ; return (ret); } } static unsigned long nfs_wcc_update_inode(struct inode *inode , struct nfs_fattr *fattr ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; unsigned long ret ; size_t __len ; void *__ret ; int tmp___0 ; size_t __len___0 ; void *__ret___0 ; int tmp___1 ; loff_t tmp___2 ; loff_t tmp___3 ; loff_t tmp___4 ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; ret = 0UL; if (((fattr->valid & 262144U) != 0U && (fattr->valid & 131072U) != 0U) && inode->i_version == fattr->pre_change_attr) { inode->i_version = fattr->change_attr; if (((int )inode->i_mode & 61440) == 16384) { nfsi->cache_validity = nfsi->cache_validity | 2UL; } else { } ret = ret | 1UL; } else { } if ((fattr->valid & 65536U) != 0U && (fattr->valid & 16384U) != 0U) { tmp___0 = timespec_equal((struct timespec const *)(& inode->i_ctime), (struct timespec const *)(& fattr->pre_ctime)); if (tmp___0 != 0) { __len = 16UL; if (__len > 63UL) { __ret = __memcpy((void *)(& inode->i_ctime), (void const *)(& fattr->ctime), __len); } else { __ret = __builtin_memcpy((void *)(& inode->i_ctime), (void const *)(& fattr->ctime), __len); } ret = ret | 1UL; } else { } } else { } if ((fattr->valid & 32768U) != 0U && (fattr->valid & 8192U) != 0U) { tmp___1 = timespec_equal((struct timespec const *)(& inode->i_mtime), (struct timespec const *)(& fattr->pre_mtime)); if (tmp___1 != 0) { __len___0 = 16UL; if (__len___0 > 63UL) { __ret___0 = __memcpy((void *)(& inode->i_mtime), (void const *)(& fattr->mtime), __len___0); } else { __ret___0 = __builtin_memcpy((void *)(& inode->i_mtime), (void const *)(& fattr->mtime), __len___0); } if (((int )inode->i_mode & 61440) == 16384) { nfsi->cache_validity = nfsi->cache_validity | 2UL; } else { } ret = ret | 1UL; } else { } } else { } if ((fattr->valid & 128U) != 0U && (fattr->valid & 64U) != 0U) { tmp___3 = i_size_read((struct inode const *)inode); tmp___4 = nfs_size_to_loff_t(fattr->pre_size); if (tmp___3 == tmp___4) { if (nfsi->npages == 0UL) { tmp___2 = nfs_size_to_loff_t(fattr->size); i_size_write(inode, tmp___2); ret = ret | 1UL; } else { } } else { } } else { } if ((nfsi->cache_validity & 2UL) != 0UL) { nfs_fscache_invalidate(inode); } else { } return (ret); } } static int nfs_check_inode_attributes(struct inode *inode , struct nfs_fattr *fattr ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; loff_t cur_size ; loff_t new_isize ; unsigned long invalid ; int tmp___0 ; int tmp___1 ; bool tmp___2 ; int tmp___3 ; bool tmp___4 ; int tmp___5 ; int tmp___6 ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; invalid = 0UL; tmp___0 = nfs_have_delegated_attributes(inode); if (tmp___0 != 0) { return (0); } else { } if ((fattr->valid & 2048U) != 0U && nfsi->fileid != fattr->fileid) { return (-5); } else { } if ((int )fattr->valid & 1 && (((int )inode->i_mode ^ (int )fattr->mode) & 61440) != 0) { return (-5); } else { } if ((fattr->valid & 131072U) != 0U && inode->i_version != fattr->change_attr) { invalid = invalid | 33UL; } else { } if ((fattr->valid & 8192U) != 0U) { tmp___1 = timespec_equal((struct timespec const *)(& inode->i_mtime), (struct timespec const *)(& fattr->mtime)); if (tmp___1 == 0) { invalid = invalid | 1UL; } else { } } else { } if ((fattr->valid & 64U) != 0U) { cur_size = i_size_read((struct inode const *)inode); new_isize = nfs_size_to_loff_t(fattr->size); if (cur_size != new_isize && nfsi->npages == 0UL) { invalid = invalid | 33UL; } else { } } else { } if ((fattr->valid & 2U) != 0U && (((int )inode->i_mode ^ (int )fattr->mode) & 4095) != 0) { invalid = invalid | 25UL; } else { } if ((fattr->valid & 8U) != 0U) { tmp___2 = uid_eq(inode->i_uid, fattr->uid); if (tmp___2) { tmp___3 = 0; } else { tmp___3 = 1; } if (tmp___3) { invalid = invalid | 25UL; } else { } } else { } if ((fattr->valid & 16U) != 0U) { tmp___4 = gid_eq(inode->i_gid, fattr->gid); if (tmp___4) { tmp___5 = 0; } else { tmp___5 = 1; } if (tmp___5) { invalid = invalid | 25UL; } else { } } else { } if ((fattr->valid & 4U) != 0U && (unsigned int )inode->ldv_23837.i_nlink != fattr->nlink) { invalid = invalid | 1UL; } else { } if ((fattr->valid & 4096U) != 0U) { tmp___6 = timespec_equal((struct timespec const *)(& inode->i_atime), (struct timespec const *)(& fattr->atime)); if (tmp___6 == 0) { invalid = invalid | 4UL; } else { } } else { } if (invalid != 0UL) { nfsi->cache_validity = nfsi->cache_validity | invalid; } else { } nfsi->read_cache_jiffies = fattr->time_start; return (0); } } static int nfs_ctime_need_update(struct inode const *inode , struct nfs_fattr const *fattr ) { int tmp ; { if (((unsigned int )fattr->valid & 16384U) == 0U) { return (0); } else { } tmp = timespec_compare(& fattr->ctime, & inode->i_ctime); return (tmp > 0); } } static int nfs_size_need_update(struct inode const *inode , struct nfs_fattr const *fattr ) { loff_t tmp ; loff_t tmp___0 ; { if (((unsigned int )fattr->valid & 64U) == 0U) { return (0); } else { } tmp = nfs_size_to_loff_t(fattr->size); tmp___0 = i_size_read(inode); return (tmp > tmp___0); } } static atomic_long_t nfs_attr_generation_counter ; static unsigned long nfs_read_attr_generation_counter(void) { long tmp ; { tmp = atomic_long_read(& nfs_attr_generation_counter); return ((unsigned long )tmp); } } unsigned long nfs_inc_attr_generation_counter(void) { long tmp ; { tmp = atomic_long_inc_return(& nfs_attr_generation_counter); return ((unsigned long )tmp); } } void nfs_fattr_init(struct nfs_fattr *fattr ) { { fattr->valid = 0U; fattr->time_start = jiffies; fattr->gencount = nfs_inc_attr_generation_counter(); fattr->owner_name = (struct nfs4_string *)0; fattr->group_name = (struct nfs4_string *)0; return; } } struct nfs_fattr *nfs_alloc_fattr(void) { struct nfs_fattr *fattr ; void *tmp ; { tmp = kmalloc(216UL, 80U); fattr = (struct nfs_fattr *)tmp; if ((unsigned long )fattr != (unsigned long )((struct nfs_fattr *)0)) { nfs_fattr_init(fattr); } else { } return (fattr); } } struct nfs_fh *nfs_alloc_fhandle(void) { struct nfs_fh *fh ; void *tmp ; { tmp = kmalloc(130UL, 80U); fh = (struct nfs_fh *)tmp; if ((unsigned long )fh != (unsigned long )((struct nfs_fh *)0)) { fh->size = 0U; } else { } return (fh); } } u32 _nfs_display_fhandle_hash(struct nfs_fh const *fh ) { u32 tmp ; { tmp = nfs_fhandle_hash(fh); return (tmp); } } void _nfs_display_fhandle(struct nfs_fh const *fh , char const *caption ) { unsigned short i ; u32 tmp ; __be32 *pos ; __u32 tmp___0 ; __u32 tmp___1 ; __u32 tmp___2 ; __u32 tmp___3 ; __u32 tmp___4 ; __u32 tmp___5 ; __u32 tmp___6 ; __u32 tmp___7 ; __u32 tmp___8 ; __u32 tmp___9 ; { if ((unsigned long )fh == (unsigned long )((struct nfs_fh const *)0) || (unsigned int )((unsigned short )fh->size) == 0U) { printk("\001d%s at %p is empty\n", caption, fh); return; } else { } tmp = _nfs_display_fhandle_hash(fh); printk("\001d%s at %p is %u bytes, crc: 0x%08x:\n", caption, fh, (int )fh->size, tmp); i = 0U; goto ldv_55008; ldv_55007: pos = (__be32 *)(& fh->data) + (unsigned long )i; switch ((((int )fh->size - (int )i) + -1) >> 2) { case 0: tmp___0 = __be32_to_cpup((__be32 const *)pos); printk("\001d %08x\n", tmp___0); goto ldv_55003; case 1: tmp___1 = __be32_to_cpup((__be32 const *)pos + 1U); tmp___2 = __be32_to_cpup((__be32 const *)pos); printk("\001d %08x %08x\n", tmp___2, tmp___1); goto ldv_55003; case 2: tmp___3 = __be32_to_cpup((__be32 const *)pos + 2U); tmp___4 = __be32_to_cpup((__be32 const *)pos + 1U); tmp___5 = __be32_to_cpup((__be32 const *)pos); printk("\001d %08x %08x %08x\n", tmp___5, tmp___4, tmp___3); goto ldv_55003; default: tmp___6 = __be32_to_cpup((__be32 const *)pos + 3U); tmp___7 = __be32_to_cpup((__be32 const *)pos + 2U); tmp___8 = __be32_to_cpup((__be32 const *)pos + 1U); tmp___9 = __be32_to_cpup((__be32 const *)pos); printk("\001d %08x %08x %08x %08x\n", tmp___9, tmp___8, tmp___7, tmp___6); } ldv_55003: i = (unsigned int )i + 16U; ldv_55008: ; if ((int )((unsigned short )fh->size) > (int )i) { goto ldv_55007; } else { } return; } } static int nfs_inode_attrs_need_update(struct inode const *inode , struct nfs_fattr const *fattr ) { struct nfs_inode const *nfsi ; struct nfs_inode *tmp ; int tmp___0 ; int tmp___1 ; unsigned long tmp___2 ; int tmp___3 ; { tmp = NFS_I(inode); nfsi = (struct nfs_inode const *)tmp; if ((long )fattr->gencount - (long )nfsi->attr_gencount > 0L) { tmp___3 = 1; } else { tmp___0 = nfs_ctime_need_update(inode, fattr); if (tmp___0 != 0) { tmp___3 = 1; } else { tmp___1 = nfs_size_need_update(inode, fattr); if (tmp___1 != 0) { tmp___3 = 1; } else { tmp___2 = nfs_read_attr_generation_counter(); if ((long )nfsi->attr_gencount - (long )tmp___2 > 0L) { tmp___3 = 1; } else { tmp___3 = 0; } } } } return (tmp___3); } } static int nfs_refresh_inode_locked(struct inode *inode , struct nfs_fattr *fattr ) { int ret ; int tmp ; { trace_nfs_refresh_inode_enter((struct inode const *)inode); tmp = nfs_inode_attrs_need_update((struct inode const *)inode, (struct nfs_fattr const *)fattr); if (tmp != 0) { ret = nfs_update_inode(inode, fattr); } else { ret = nfs_check_inode_attributes(inode, fattr); } trace_nfs_refresh_inode_exit((struct inode const *)inode, ret); return (ret); } } int nfs_refresh_inode(struct inode *inode , struct nfs_fattr *fattr ) { int status ; { if ((fattr->valid & 162943U) == 0U) { return (0); } else { } spin_lock(& inode->i_lock); status = nfs_refresh_inode_locked(inode, fattr); spin_unlock(& inode->i_lock); return (status); } } static int nfs_post_op_update_inode_locked(struct inode *inode , struct nfs_fattr *fattr ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; int tmp___0 ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; nfsi->cache_validity = nfsi->cache_validity | 33UL; if (((int )inode->i_mode & 61440) == 16384) { nfsi->cache_validity = nfsi->cache_validity | 2UL; nfs_fscache_invalidate(inode); } else { } if ((fattr->valid & 162943U) == 0U) { return (0); } else { } tmp___0 = nfs_refresh_inode_locked(inode, fattr); return (tmp___0); } } int nfs_post_op_update_inode(struct inode *inode , struct nfs_fattr *fattr ) { int status ; { spin_lock(& inode->i_lock); status = nfs_post_op_update_inode_locked(inode, fattr); spin_unlock(& inode->i_lock); return (status); } } int nfs_post_op_update_inode_force_wcc(struct inode *inode , struct nfs_fattr *fattr ) { int status ; int tmp ; size_t __len ; void *__ret ; size_t __len___0 ; void *__ret___0 ; loff_t tmp___0 ; { spin_lock(& inode->i_lock); if ((fattr->valid & 162943U) == 0U) { fattr->valid = fattr->valid & 4294606719U; goto out_noforce; } else { tmp = nfs_inode_attrs_need_update((struct inode const *)inode, (struct nfs_fattr const *)fattr); if (tmp == 0) { fattr->valid = fattr->valid & 4294606719U; goto out_noforce; } else { } } if ((fattr->valid & 131072U) != 0U && (fattr->valid & 262144U) == 0U) { fattr->pre_change_attr = inode->i_version; fattr->valid = fattr->valid | 262144U; } else { } if ((fattr->valid & 16384U) != 0U && (fattr->valid & 65536U) == 0U) { __len = 16UL; if (__len > 63UL) { __ret = __memcpy((void *)(& fattr->pre_ctime), (void const *)(& inode->i_ctime), __len); } else { __ret = __builtin_memcpy((void *)(& fattr->pre_ctime), (void const *)(& inode->i_ctime), __len); } fattr->valid = fattr->valid | 65536U; } else { } if ((fattr->valid & 8192U) != 0U && (fattr->valid & 32768U) == 0U) { __len___0 = 16UL; if (__len___0 > 63UL) { __ret___0 = __memcpy((void *)(& fattr->pre_mtime), (void const *)(& inode->i_mtime), __len___0); } else { __ret___0 = __builtin_memcpy((void *)(& fattr->pre_mtime), (void const *)(& inode->i_mtime), __len___0); } fattr->valid = fattr->valid | 32768U; } else { } if ((fattr->valid & 64U) != 0U && (fattr->valid & 128U) == 0U) { tmp___0 = i_size_read((struct inode const *)inode); fattr->pre_size = (__u64 )tmp___0; fattr->valid = fattr->valid | 128U; } else { } out_noforce: status = nfs_post_op_update_inode_locked(inode, fattr); spin_unlock(& inode->i_lock); return (status); } } static int nfs_update_inode(struct inode *inode , struct nfs_fattr *fattr ) { struct nfs_server *server ; struct nfs_inode *nfsi ; struct nfs_inode *tmp ; loff_t cur_isize ; loff_t new_isize ; unsigned long invalid ; unsigned long now ; unsigned long save_cache_validity ; int tmp___0 ; struct nfs_fh *tmp___1 ; u32 tmp___2 ; long tmp___3 ; struct nfs_server *tmp___4 ; int tmp___5 ; unsigned long tmp___6 ; long tmp___7 ; size_t __len ; void *__ret ; size_t __len___0 ; void *__ret___0 ; int tmp___8 ; long tmp___9 ; size_t __len___1 ; void *__ret___1 ; umode_t newmode ; bool tmp___10 ; int tmp___11 ; bool tmp___12 ; int tmp___13 ; unsigned int tmp___14 ; unsigned int tmp___15 ; unsigned long tmp___16 ; unsigned int tmp___17 ; struct nfs_rpc_ops const *tmp___18 ; int tmp___19 ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; invalid = 0UL; now = jiffies; tmp___3 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___3 != 0L) { tmp___0 = atomic_read((atomic_t const *)(& inode->i_count)); tmp___1 = NFS_FH((struct inode const *)inode); tmp___2 = nfs_display_fhandle_hash((struct nfs_fh const *)tmp___1); printk("\001dNFS: %s(%s/%ld fh_crc=0x%08x ct=%d info=0x%x)\n", "nfs_update_inode", (char *)(& (inode->i_sb)->s_id), inode->i_ino, tmp___2, tmp___0, fattr->valid); } else { } if ((fattr->valid & 2048U) != 0U && nfsi->fileid != fattr->fileid) { tmp___4 = NFS_SERVER((struct inode const *)inode); printk("\vNFS: server %s error: fileid changed\nfsid %s: expected fileid 0x%Lx, got 0x%Lx\n", (tmp___4->nfs_client)->cl_hostname, (char *)(& (inode->i_sb)->s_id), (long long )nfsi->fileid, (long long )fattr->fileid); goto out_err; } else { } if ((int )fattr->valid & 1 && (((int )inode->i_mode ^ (int )fattr->mode) & 61440) != 0) { printk("\017NFS: %s: inode %ld mode changed, %07o to %07o\n", "nfs_update_inode", inode->i_ino, (int )inode->i_mode, (int )fattr->mode); goto out_err; } else { } server = NFS_SERVER((struct inode const *)inode); if (((int )inode->i_mode & 61440) == 16384 && (fattr->valid & 1024U) != 0U) { tmp___5 = nfs_fsid_equal((struct nfs_fsid const *)(& server->fsid), (struct nfs_fsid const *)(& fattr->fsid)); if (tmp___5 == 0) { if ((inode->i_flags & 2048U) == 0U) { server->fsid = fattr->fsid; } else { } } else { } } else { } nfsi->read_cache_jiffies = fattr->time_start; save_cache_validity = nfsi->cache_validity; nfsi->cache_validity = nfsi->cache_validity & 0xffffffffffffff9aUL; tmp___6 = nfs_wcc_update_inode(inode, fattr); invalid = tmp___6 | invalid; if ((fattr->valid & 131072U) != 0U) { if (inode->i_version != fattr->change_attr) { tmp___7 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___7 != 0L) { printk("\001dNFS: change_attr change on server for file %s/%ld\n", (char *)(& (inode->i_sb)->s_id), inode->i_ino); } else { } invalid = invalid | 59UL; if (((int )inode->i_mode & 61440) == 16384) { nfs_force_lookup_revalidate(inode); } else { } inode->i_version = fattr->change_attr; } else { } } else if ((server->caps & 32U) != 0U) { invalid = invalid | save_cache_validity; } else { } if ((fattr->valid & 8192U) != 0U) { __len = 16UL; if (__len > 63UL) { __ret = __memcpy((void *)(& inode->i_mtime), (void const *)(& fattr->mtime), __len); } else { __ret = __builtin_memcpy((void *)(& inode->i_mtime), (void const *)(& fattr->mtime), __len); } } else if ((server->caps & 8192U) != 0U) { invalid = (save_cache_validity & 65UL) | invalid; } else { } if ((fattr->valid & 16384U) != 0U) { __len___0 = 16UL; if (__len___0 > 63UL) { __ret___0 = __memcpy((void *)(& inode->i_ctime), (void const *)(& fattr->ctime), __len___0); } else { __ret___0 = __builtin_memcpy((void *)(& inode->i_ctime), (void const *)(& fattr->ctime), __len___0); } } else if ((server->caps & 4096U) != 0U) { invalid = (save_cache_validity & 65UL) | invalid; } else { } if ((fattr->valid & 64U) != 0U) { new_isize = nfs_size_to_loff_t(fattr->size); cur_isize = i_size_read((struct inode const *)inode); if (new_isize != cur_isize) { if (nfsi->npages == 0UL) { tmp___8 = constant_test_bit(9L, (unsigned long const volatile *)(& nfsi->flags)); if (tmp___8 == 0) { i_size_write(inode, new_isize); invalid = invalid | 3UL; } else { goto _L; } } else _L: /* CIL Label */ if (new_isize > cur_isize) { i_size_write(inode, new_isize); invalid = invalid | 3UL; } else { } tmp___9 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___9 != 0L) { printk("\001dNFS: isize change on server for file %s/%ld (%Ld to %Ld)\n", (char *)(& (inode->i_sb)->s_id), inode->i_ino, cur_isize, new_isize); } else { } } else { } } else { invalid = (save_cache_validity & 97UL) | invalid; } if ((fattr->valid & 4096U) != 0U) { __len___1 = 16UL; if (__len___1 > 63UL) { __ret___1 = __memcpy((void *)(& inode->i_atime), (void const *)(& fattr->atime), __len___1); } else { __ret___1 = __builtin_memcpy((void *)(& inode->i_atime), (void const *)(& fattr->atime), __len___1); } } else if ((server->caps & 2048U) != 0U) { invalid = (save_cache_validity & 68UL) | invalid; } else { } if ((fattr->valid & 2U) != 0U) { if ((((int )inode->i_mode ^ (int )fattr->mode) & 4095) != 0) { newmode = (unsigned int )inode->i_mode & 61440U; newmode = (umode_t )(((int )((short )fattr->mode) & 4095) | (int )((short )newmode)); inode->i_mode = newmode; invalid = invalid | 25UL; } else { } } else if ((server->caps & 128U) != 0U) { invalid = (save_cache_validity & 89UL) | invalid; } else { } if ((fattr->valid & 8U) != 0U) { tmp___10 = uid_eq(inode->i_uid, fattr->uid); if (tmp___10) { tmp___11 = 0; } else { tmp___11 = 1; } if (tmp___11) { invalid = invalid | 25UL; inode->i_uid = fattr->uid; } else { } } else if ((server->caps & 512U) != 0U) { invalid = (save_cache_validity & 89UL) | invalid; } else { } if ((fattr->valid & 16U) != 0U) { tmp___12 = gid_eq(inode->i_gid, fattr->gid); if (tmp___12) { tmp___13 = 0; } else { tmp___13 = 1; } if (tmp___13) { invalid = invalid | 25UL; inode->i_gid = fattr->gid; } else { } } else if ((server->caps & 1024U) != 0U) { invalid = (save_cache_validity & 89UL) | invalid; } else { } if ((fattr->valid & 4U) != 0U) { if ((unsigned int )inode->ldv_23837.i_nlink != fattr->nlink) { invalid = invalid | 1UL; if (((int )inode->i_mode & 61440) == 16384) { invalid = invalid | 2UL; } else { } set_nlink(inode, fattr->nlink); } else { } } else if ((server->caps & 256U) != 0U) { invalid = (save_cache_validity & 65UL) | invalid; } else { } if ((fattr->valid & 512U) != 0U) { inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); } else { } if ((fattr->valid & 256U) != 0U) { inode->i_blocks = (blkcnt_t )fattr->du.nfs2.blocks; } else { } if ((invalid & 129UL) != 0UL) { nfs_inc_stats___1((struct inode const *)inode, 3); tmp___14 = NFS_MINATTRTIMEO((struct inode const *)inode); nfsi->attrtimeo = (unsigned long )tmp___14; nfsi->attrtimeo_timestamp = now; nfsi->attr_gencount = nfs_inc_attr_generation_counter(); } else if ((long )(now - nfsi->attrtimeo_timestamp) < 0L || (long )(now - (nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) >= 0L) { tmp___16 = nfsi->attrtimeo << 1; nfsi->attrtimeo = tmp___16; tmp___17 = NFS_MAXATTRTIMEO((struct inode const *)inode); if (tmp___16 > (unsigned long )tmp___17) { tmp___15 = NFS_MAXATTRTIMEO((struct inode const *)inode); nfsi->attrtimeo = (unsigned long )tmp___15; } else { } nfsi->attrtimeo_timestamp = now; } else { } invalid = invalid & 0xfffffffffffffffeUL; invalid = invalid & 0xffffffffffffff7fUL; if ((((int )inode->i_mode & 61440) != 32768 && ((int )inode->i_mode & 61440) != 16384) && ((int )inode->i_mode & 61440) != 40960) { invalid = invalid & 0xfffffffffffffffdUL; } else { } tmp___18 = NFS_PROTO((struct inode const *)inode); tmp___19 = (*(tmp___18->have_delegation))(inode, 1U); if (tmp___19 == 0 || (save_cache_validity & 64UL) != 0UL) { nfsi->cache_validity = nfsi->cache_validity | invalid; } else { } if ((invalid & 2UL) != 0UL) { nfs_fscache_invalidate(inode); } else { } return (0); out_err: nfs_invalidate_inode(inode); return (-116); } } struct inode *nfs_alloc_inode(struct super_block *sb ) { struct nfs_inode *nfsi ; void *tmp ; void *tmp___0 ; void *tmp___1 ; { tmp = kmem_cache_alloc(nfs_inode_cachep, 208U); nfsi = (struct nfs_inode *)tmp; if ((unsigned long )nfsi == (unsigned long )((struct nfs_inode *)0)) { return ((struct inode *)0); } else { } nfsi->flags = 0UL; nfsi->cache_validity = 0UL; tmp___0 = ERR_PTR(-11L); nfsi->acl_access = (struct posix_acl *)tmp___0; tmp___1 = ERR_PTR(-11L); nfsi->acl_default = (struct posix_acl *)tmp___1; nfsi->nfs4_acl = (struct nfs4_cached_acl *)0; return (& nfsi->vfs_inode); } } static void nfs_i_callback(struct callback_head *head ) { struct inode *inode ; struct callback_head const *__mptr ; struct nfs_inode *tmp ; { __mptr = (struct callback_head const *)head; inode = (struct inode *)__mptr + 0xfffffffffffffe28UL; tmp = NFS_I((struct inode const *)inode); kmem_cache_free(nfs_inode_cachep, (void *)tmp); return; } } void nfs_destroy_inode(struct inode *inode ) { { call_rcu_sched(& inode->ldv_23857.i_rcu, & nfs_i_callback); return; } } __inline static void nfs4_init_once(struct nfs_inode *nfsi ) { struct lock_class_key __key ; { INIT_LIST_HEAD(& nfsi->open_states); nfsi->delegation = (struct nfs_delegation *)0; nfsi->delegation_state = 0U; __init_rwsem(& nfsi->rwsem, "&nfsi->rwsem", & __key); nfsi->layout = (struct pnfs_layout_hdr *)0; return; } } static void init_once(void *foo ) { struct nfs_inode *nfsi ; struct lock_class_key __key ; { nfsi = (struct nfs_inode *)foo; inode_init_once(& nfsi->vfs_inode); INIT_LIST_HEAD(& nfsi->open_files); INIT_LIST_HEAD(& nfsi->access_cache_entry_lru); INIT_LIST_HEAD(& nfsi->access_cache_inode_lru); INIT_LIST_HEAD(& nfsi->commit_info.list); nfsi->npages = 0UL; nfsi->commit_info.ncommit = 0UL; atomic_set(& nfsi->commit_info.rpcs_out, 0); atomic_set(& nfsi->silly_count, 1); nfsi->silly_list.first = (struct hlist_node *)0; __init_waitqueue_head(& nfsi->waitqueue, "&nfsi->waitqueue", & __key); nfs4_init_once(nfsi); return; } } static int nfs_init_inodecache(void) { { nfs_inode_cachep = kmem_cache_create("nfs_inode_cache", 1672UL, 0UL, 1179648UL, & init_once); if ((unsigned long )nfs_inode_cachep == (unsigned long )((struct kmem_cache *)0)) { return (-12); } else { } return (0); } } static void nfs_destroy_inodecache(void) { { rcu_barrier(); kmem_cache_destroy(nfs_inode_cachep); return; } } static int nfsiod_start(void) { struct workqueue_struct *wq ; long tmp ; struct lock_class_key __key ; char const *__lock_name ; struct workqueue_struct *tmp___0 ; { tmp = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp != 0L) { printk("\001dRPC: creating workqueue nfsiod\n"); } else { } __lock_name = "nfsiod"; tmp___0 = __alloc_workqueue_key("nfsiod", 8U, 0, & __key, __lock_name); wq = tmp___0; if ((unsigned long )wq == (unsigned long )((struct workqueue_struct *)0)) { return (-12); } else { } nfsiod_workqueue = wq; return (0); } } static void nfsiod_stop(void) { struct workqueue_struct *wq ; { wq = nfsiod_workqueue; if ((unsigned long )wq == (unsigned long )((struct workqueue_struct *)0)) { return; } else { } nfsiod_workqueue = (struct workqueue_struct *)0; destroy_workqueue(wq); return; } } static int nfs_net_init(struct net *net ) { { nfs_clients_init(net); return (0); } } static void nfs_net_exit(struct net *net ) { { nfs_cleanup_cb_ident_idr(net); return; } } static struct pernet_operations nfs_net_ops = {{0, 0}, & nfs_net_init, & nfs_net_exit, 0, & nfs_net_id, 368UL}; static int init_nfs_fs(void) { int err ; { err = register_pernet_subsys(& nfs_net_ops); if (err < 0) { goto out9; } else { } err = nfs_fscache_register(); if (err < 0) { goto out8; } else { } err = nfsiod_start(); if (err != 0) { goto out7; } else { } err = nfs_fs_proc_init(); if (err != 0) { goto out6; } else { } err = nfs_init_nfspagecache(); if (err != 0) { goto out5; } else { } err = nfs_init_inodecache(); if (err != 0) { goto out4; } else { } err = nfs_init_readpagecache(); if (err != 0) { goto out3; } else { } err = nfs_init_writepagecache(); if (err != 0) { goto out2; } else { } err = nfs_init_directcache(); if (err != 0) { goto out1; } else { } rpc_proc_register(& init_net, & nfs_rpcstat); err = register_nfs_fs(); if (err != 0) { goto out0; } else { } return (0); out0: rpc_proc_unregister(& init_net, "nfs"); nfs_destroy_directcache(); out1: nfs_destroy_writepagecache(); out2: nfs_destroy_readpagecache(); out3: nfs_destroy_inodecache(); out4: nfs_destroy_nfspagecache(); out5: nfs_fs_proc_exit(); out6: nfsiod_stop(); out7: nfs_fscache_unregister(); out8: unregister_pernet_subsys(& nfs_net_ops); out9: ; return (err); } } static void exit_nfs_fs(void) { { nfs_destroy_directcache(); nfs_destroy_writepagecache(); nfs_destroy_readpagecache(); nfs_destroy_inodecache(); nfs_destroy_nfspagecache(); nfs_fscache_unregister(); unregister_pernet_subsys(& nfs_net_ops); rpc_proc_unregister(& init_net, "nfs"); unregister_nfs_fs(); nfs_fs_proc_exit(); nfsiod_stop(); return; } } extern void ldv_initialize(void) ; void ldv_check_final_state(void) ; int ldv_retval_9 ; void ldv_initialize_pernet_operations_60(void) { void *tmp ; { tmp = ldv_zalloc(5504UL); nfs_net_ops_group0 = (struct net *)tmp; return; } } void ldv_main_exported_33(void) ; void ldv_main_exported_32(void) ; void ldv_main_exported_11(void) ; void ldv_main_exported_21(void) ; void ldv_main_exported_7(void) ; void ldv_main_exported_26(void) ; void ldv_main_exported_17(void) ; void ldv_main_exported_22(void) ; void ldv_main_exported_18(void) ; void ldv_main_exported_30(void) ; void ldv_main_exported_23(void) ; void ldv_main_exported_16(void) ; void ldv_main_exported_13(void) ; void ldv_main_exported_29(void) ; void ldv_main_exported_27(void) ; void ldv_main_exported_25(void) ; void ldv_main_exported_6(void) ; void ldv_main_exported_28(void) ; void ldv_main_exported_9(void) ; void ldv_main_exported_12(void) ; void ldv_main_exported_20(void) ; void ldv_main_exported_14(void) ; void ldv_main_exported_15(void) ; void ldv_main_exported_8(void) ; void ldv_main_exported_4(void) ; void ldv_main_exported_24(void) ; void ldv_main_exported_10(void) ; void ldv_main_exported_19(void) ; void ldv_main_exported_31(void) ; void ldv_main_exported_5(void) ; void ldv_main_exported_42(void) ; void ldv_main_exported_43(void) ; void ldv_main_exported_1(void) ; void ldv_main_exported_3(void) ; void ldv_main_exported_2(void) ; void ldv_main_exported_50(void) ; void ldv_main_exported_49(void) ; void ldv_main_exported_48(void) ; void ldv_main_exported_44(void) ; void ldv_main_exported_38(void) ; void ldv_main_exported_39(void) ; void ldv_main_exported_40(void) ; void ldv_main_exported_37(void) ; void ldv_main_exported_41(void) ; void ldv_main_exported_35(void) ; void ldv_main_exported_34(void) ; void ldv_main_exported_36(void) ; void ldv_main_exported_46(void) ; void ldv_main_exported_45(void) ; void ldv_main_exported_47(void) ; void ldv_main_exported_53(void) ; void ldv_main_exported_57(void) ; void ldv_main_exported_51(void) ; void ldv_main_exported_58(void) ; void ldv_main_exported_52(void) ; void ldv_main_exported_59(void) ; void ldv_main_exported_56(void) ; void ldv_main_exported_54(void) ; void ldv_main_exported_55(void) ; int main(void) { int tmp ; int tmp___0 ; int tmp___1 ; { ldv_initialize(); ldv_state_variable_33 = 0; ldv_state_variable_32 = 0; ldv_state_variable_63 = 0; ldv_state_variable_21 = 0; ldv_state_variable_71 = 0; ldv_state_variable_7 = 0; ldv_state_variable_26 = 0; ldv_state_variable_18 = 0; ldv_state_variable_72 = 0; ldv_state_variable_16 = 0; ldv_state_variable_44 = 0; ldv_state_variable_55 = 0; ldv_state_variable_74 = 0; ldv_state_variable_27 = 0; ldv_state_variable_57 = 0; ldv_state_variable_61 = 0; ldv_state_variable_20 = 0; ldv_state_variable_10 = 0; ldv_state_variable_31 = 0; ldv_state_variable_35 = 0; ldv_state_variable_11 = 0; ldv_state_variable_48 = 0; ldv_state_variable_65 = 0; ldv_state_variable_29 = 0; ldv_state_variable_50 = 0; ldv_state_variable_39 = 0; ldv_state_variable_64 = 0; ldv_state_variable_58 = 0; ldv_state_variable_41 = 0; ldv_state_variable_12 = 0; ldv_state_variable_15 = 0; ldv_state_variable_52 = 0; ldv_state_variable_60 = 0; ldv_state_variable_56 = 0; ldv_state_variable_73 = 0; ldv_state_variable_66 = 0; ldv_state_variable_45 = 0; ldv_state_variable_19 = 0; ldv_state_variable_62 = 0; ldv_state_variable_54 = 0; ldv_state_variable_67 = 0; ldv_state_variable_70 = 0; ldv_state_variable_68 = 0; ldv_state_variable_2 = 0; ldv_state_variable_17 = 0; ldv_state_variable_1 = 0; ldv_state_variable_30 = 0; ldv_state_variable_25 = 0; ldv_state_variable_28 = 0; ldv_state_variable_40 = 0; ldv_state_variable_14 = 0; ldv_state_variable_69 = 0; ldv_state_variable_59 = 0; ldv_state_variable_49 = 0; ldv_state_variable_24 = 0; ldv_state_variable_53 = 0; ldv_state_variable_22 = 0; ldv_state_variable_42 = 0; ref_cnt = 0; ldv_state_variable_0 = 1; ldv_state_variable_46 = 0; ldv_state_variable_23 = 0; ldv_state_variable_13 = 0; ldv_state_variable_6 = 0; ldv_state_variable_3 = 0; ldv_state_variable_36 = 0; ldv_state_variable_9 = 0; ldv_state_variable_51 = 0; ldv_state_variable_47 = 0; ldv_state_variable_8 = 0; ldv_state_variable_38 = 0; ldv_state_variable_4 = 0; ldv_state_variable_34 = 0; ldv_state_variable_37 = 0; ldv_state_variable_43 = 0; ldv_state_variable_5 = 0; ldv_55462: tmp = __VERIFIER_nondet_int(); switch (tmp) { case 0: ; if (ldv_state_variable_33 != 0) { ldv_main_exported_33(); } else { } goto ldv_55377; case 1: ; if (ldv_state_variable_32 != 0) { ldv_main_exported_32(); } else { } goto ldv_55377; case 2: ; if (ldv_state_variable_63 != 0) { ldv_main_exported_63(); } else { } goto ldv_55377; case 3: ; if (ldv_state_variable_21 != 0) { ldv_main_exported_21(); } else { } goto ldv_55377; case 4: ; if (ldv_state_variable_71 != 0) { ldv_main_exported_71(); } else { } goto ldv_55377; case 5: ; if (ldv_state_variable_7 != 0) { ldv_main_exported_7(); } else { } goto ldv_55377; case 6: ; if (ldv_state_variable_26 != 0) { ldv_main_exported_26(); } else { } goto ldv_55377; case 7: ; if (ldv_state_variable_18 != 0) { ldv_main_exported_18(); } else { } goto ldv_55377; case 8: ; if (ldv_state_variable_72 != 0) { ldv_main_exported_72(); } else { } goto ldv_55377; case 9: ; if (ldv_state_variable_16 != 0) { ldv_main_exported_16(); } else { } goto ldv_55377; case 10: ; if (ldv_state_variable_44 != 0) { ldv_main_exported_44(); } else { } goto ldv_55377; case 11: ; if (ldv_state_variable_55 != 0) { ldv_main_exported_55(); } else { } goto ldv_55377; case 12: ; if (ldv_state_variable_74 != 0) { ldv_main_exported_74(); } else { } goto ldv_55377; case 13: ; if (ldv_state_variable_27 != 0) { ldv_main_exported_27(); } else { } goto ldv_55377; case 14: ; if (ldv_state_variable_57 != 0) { ldv_main_exported_57(); } else { } goto ldv_55377; case 15: ; if (ldv_state_variable_61 != 0) { ldv_main_exported_61(); } else { } goto ldv_55377; case 16: ; if (ldv_state_variable_20 != 0) { ldv_main_exported_20(); } else { } goto ldv_55377; case 17: ; if (ldv_state_variable_10 != 0) { ldv_main_exported_10(); } else { } goto ldv_55377; case 18: ; if (ldv_state_variable_31 != 0) { ldv_main_exported_31(); } else { } goto ldv_55377; case 19: ; if (ldv_state_variable_35 != 0) { ldv_main_exported_35(); } else { } goto ldv_55377; case 20: ; if (ldv_state_variable_11 != 0) { ldv_main_exported_11(); } else { } goto ldv_55377; case 21: ; if (ldv_state_variable_48 != 0) { ldv_main_exported_48(); } else { } goto ldv_55377; case 22: ; if (ldv_state_variable_65 != 0) { ldv_main_exported_65(); } else { } goto ldv_55377; case 23: ; if (ldv_state_variable_29 != 0) { ldv_main_exported_29(); } else { } goto ldv_55377; case 24: ; if (ldv_state_variable_50 != 0) { ldv_main_exported_50(); } else { } goto ldv_55377; case 25: ; if (ldv_state_variable_39 != 0) { ldv_main_exported_39(); } else { } goto ldv_55377; case 26: ; if (ldv_state_variable_64 != 0) { ldv_main_exported_64(); } else { } goto ldv_55377; case 27: ; if (ldv_state_variable_58 != 0) { ldv_main_exported_58(); } else { } goto ldv_55377; case 28: ; if (ldv_state_variable_41 != 0) { ldv_main_exported_41(); } else { } goto ldv_55377; case 29: ; if (ldv_state_variable_12 != 0) { ldv_main_exported_12(); } else { } goto ldv_55377; case 30: ; if (ldv_state_variable_15 != 0) { ldv_main_exported_15(); } else { } goto ldv_55377; case 31: ; if (ldv_state_variable_52 != 0) { ldv_main_exported_52(); } else { } goto ldv_55377; case 32: ; if (ldv_state_variable_60 != 0) { tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_60 == 1) { nfs_net_init(nfs_net_ops_group0); ldv_state_variable_60 = 1; } else { } goto ldv_55411; case 1: ; if (ldv_state_variable_60 == 1) { nfs_net_exit(nfs_net_ops_group0); ldv_state_variable_60 = 1; } else { } goto ldv_55411; default: ldv_stop(); } ldv_55411: ; } else { } goto ldv_55377; case 33: ; if (ldv_state_variable_56 != 0) { ldv_main_exported_56(); } else { } goto ldv_55377; case 34: ; if (ldv_state_variable_73 != 0) { ldv_main_exported_73(); } else { } goto ldv_55377; case 35: ; if (ldv_state_variable_66 != 0) { ldv_main_exported_66(); } else { } goto ldv_55377; case 36: ; if (ldv_state_variable_45 != 0) { ldv_main_exported_45(); } else { } goto ldv_55377; case 37: ; if (ldv_state_variable_19 != 0) { ldv_main_exported_19(); } else { } goto ldv_55377; case 38: ; if (ldv_state_variable_62 != 0) { ldv_main_exported_62(); } else { } goto ldv_55377; case 39: ; if (ldv_state_variable_54 != 0) { ldv_main_exported_54(); } else { } goto ldv_55377; case 40: ; if (ldv_state_variable_67 != 0) { ldv_main_exported_67(); } else { } goto ldv_55377; case 41: ; if (ldv_state_variable_70 != 0) { ldv_main_exported_70(); } else { } goto ldv_55377; case 42: ; if (ldv_state_variable_68 != 0) { ldv_main_exported_68(); } else { } goto ldv_55377; case 43: ; if (ldv_state_variable_2 != 0) { ldv_main_exported_2(); } else { } goto ldv_55377; case 44: ; if (ldv_state_variable_17 != 0) { ldv_main_exported_17(); } else { } goto ldv_55377; case 45: ; if (ldv_state_variable_1 != 0) { ldv_main_exported_1(); } else { } goto ldv_55377; case 46: ; if (ldv_state_variable_30 != 0) { ldv_main_exported_30(); } else { } goto ldv_55377; case 47: ; if (ldv_state_variable_25 != 0) { ldv_main_exported_25(); } else { } goto ldv_55377; case 48: ; if (ldv_state_variable_28 != 0) { ldv_main_exported_28(); } else { } goto ldv_55377; case 49: ; if (ldv_state_variable_40 != 0) { ldv_main_exported_40(); } else { } goto ldv_55377; case 50: ; if (ldv_state_variable_14 != 0) { ldv_main_exported_14(); } else { } goto ldv_55377; case 51: ; if (ldv_state_variable_69 != 0) { ldv_main_exported_69(); } else { } goto ldv_55377; case 52: ; if (ldv_state_variable_59 != 0) { ldv_main_exported_59(); } else { } goto ldv_55377; case 53: ; if (ldv_state_variable_49 != 0) { ldv_main_exported_49(); } else { } goto ldv_55377; case 54: ; if (ldv_state_variable_24 != 0) { ldv_main_exported_24(); } else { } goto ldv_55377; case 55: ; if (ldv_state_variable_53 != 0) { ldv_main_exported_53(); } else { } goto ldv_55377; case 56: ; if (ldv_state_variable_22 != 0) { ldv_main_exported_22(); } else { } goto ldv_55377; case 57: ; if (ldv_state_variable_42 != 0) { ldv_main_exported_42(); } else { } goto ldv_55377; case 58: ; if (ldv_state_variable_0 != 0) { tmp___1 = __VERIFIER_nondet_int(); switch (tmp___1) { case 0: ; if (ldv_state_variable_0 == 2 && ref_cnt == 0) { exit_nfs_fs(); ldv_state_variable_0 = 3; goto ldv_final; } else { } goto ldv_55442; case 1: ; if (ldv_state_variable_0 == 1) { ldv_retval_9 = init_nfs_fs(); if (ldv_retval_9 != 0) { ldv_state_variable_0 = 3; goto ldv_final; } else { } if (ldv_retval_9 == 0) { ldv_state_variable_0 = 2; ldv_state_variable_5 = 1; ldv_initialize_ftrace_event_class_5(); ldv_state_variable_43 = 1; ldv_initialize_rpc_call_ops_43(); ldv_state_variable_37 = 1; ldv_state_variable_34 = 1; ldv_initialize_inode_operations_34(); ldv_state_variable_4 = 1; ldv_initialize_ftrace_event_class_4(); ldv_state_variable_38 = 1; ldv_initialize_rpc_call_ops_38(); ldv_state_variable_8 = 1; ldv_initialize_ftrace_event_class_8(); ldv_state_variable_47 = 1; ldv_state_variable_51 = 1; ldv_initialize_kernel_param_ops_51(); ldv_state_variable_9 = 1; ldv_initialize_ftrace_event_class_9(); ldv_state_variable_36 = 1; ldv_state_variable_3 = 1; ldv_state_variable_6 = 1; ldv_initialize_ftrace_event_class_6(); ldv_state_variable_13 = 1; ldv_initialize_ftrace_event_class_13(); ldv_state_variable_23 = 1; ldv_state_variable_46 = 1; ldv_initialize_nfs_pageio_ops_46(); ldv_state_variable_42 = 1; ldv_initialize_rpc_call_ops_42(); ldv_state_variable_22 = 1; ldv_state_variable_53 = 1; ldv_state_variable_24 = 1; ldv_state_variable_49 = 1; ldv_state_variable_59 = 1; ldv_state_variable_69 = 1; ldv_state_variable_14 = 1; ldv_initialize_ftrace_event_class_14(); ldv_state_variable_40 = 1; ldv_initialize_nfs_pageio_ops_40(); ldv_state_variable_28 = 1; ldv_state_variable_25 = 1; ldv_state_variable_30 = 1; ldv_state_variable_1 = 1; ldv_state_variable_17 = 1; ldv_initialize_ftrace_event_class_17(); ldv_state_variable_2 = 1; ldv_state_variable_68 = 1; ldv_initialize_dentry_operations_68(); ldv_state_variable_70 = 1; ldv_file_operations_70(); ldv_state_variable_67 = 1; ldv_initialize_dentry_operations_67(); ldv_state_variable_54 = 1; ldv_state_variable_62 = 1; ldv_file_operations_62(); ldv_state_variable_19 = 1; ldv_state_variable_45 = 1; ldv_initialize_rpc_call_ops_45(); ldv_state_variable_66 = 1; ldv_initialize_dentry_operations_66(); ldv_state_variable_73 = 1; ldv_file_operations_73(); ldv_state_variable_56 = 1; ldv_initialize_super_operations_56(); ldv_state_variable_60 = 1; ldv_initialize_pernet_operations_60(); ldv_state_variable_52 = 1; ldv_initialize_shrinker_52(); ldv_state_variable_15 = 1; ldv_initialize_ftrace_event_class_15(); ldv_state_variable_12 = 1; ldv_initialize_ftrace_event_class_12(); ldv_state_variable_41 = 1; ldv_state_variable_58 = 1; ldv_state_variable_64 = 1; ldv_initialize_address_space_operations_64(); ldv_state_variable_39 = 1; ldv_initialize_rpc_call_ops_39(); ldv_state_variable_50 = 1; ldv_initialize_nfs_pgio_completion_ops_50(); ldv_state_variable_29 = 1; ldv_state_variable_65 = 1; ldv_initialize_dentry_operations_65(); ldv_state_variable_48 = 1; ldv_initialize_nfs_pgio_completion_ops_48(); ldv_state_variable_11 = 1; ldv_initialize_ftrace_event_class_11(); ldv_state_variable_35 = 1; ldv_initialize_inode_operations_35(); ldv_state_variable_31 = 1; ldv_state_variable_10 = 1; ldv_initialize_ftrace_event_class_10(); ldv_state_variable_20 = 1; ldv_state_variable_61 = 1; ldv_file_operations_61(); ldv_state_variable_57 = 1; ldv_state_variable_27 = 1; ldv_state_variable_74 = 1; ldv_seq_operations_74(); ldv_state_variable_55 = 1; ldv_initialize_super_operations_55(); ldv_state_variable_44 = 1; ldv_initialize_inode_operations_44(); ldv_state_variable_16 = 1; ldv_initialize_ftrace_event_class_16(); ldv_state_variable_72 = 1; ldv_seq_operations_72(); ldv_state_variable_18 = 1; ldv_initialize_ftrace_event_class_18(); ldv_state_variable_26 = 1; ldv_state_variable_7 = 1; ldv_initialize_ftrace_event_class_7(); ldv_state_variable_71 = 1; ldv_file_operations_71(); ldv_state_variable_21 = 1; ldv_state_variable_63 = 1; ldv_initialize_vm_operations_struct_63(); ldv_state_variable_32 = 1; ldv_state_variable_33 = 1; } else { } } else { } goto ldv_55442; default: ldv_stop(); } ldv_55442: ; } else { } goto ldv_55377; case 59: ; if (ldv_state_variable_46 != 0) { ldv_main_exported_46(); } else { } goto ldv_55377; case 60: ; if (ldv_state_variable_23 != 0) { ldv_main_exported_23(); } else { } goto ldv_55377; case 61: ; if (ldv_state_variable_13 != 0) { ldv_main_exported_13(); } else { } goto ldv_55377; case 62: ; if (ldv_state_variable_6 != 0) { ldv_main_exported_6(); } else { } goto ldv_55377; case 63: ; if (ldv_state_variable_3 != 0) { ldv_main_exported_3(); } else { } goto ldv_55377; case 64: ; if (ldv_state_variable_36 != 0) { ldv_main_exported_36(); } else { } goto ldv_55377; case 65: ; if (ldv_state_variable_9 != 0) { ldv_main_exported_9(); } else { } goto ldv_55377; case 66: ; if (ldv_state_variable_51 != 0) { ldv_main_exported_51(); } else { } goto ldv_55377; case 67: ; if (ldv_state_variable_47 != 0) { ldv_main_exported_47(); } else { } goto ldv_55377; case 68: ; if (ldv_state_variable_8 != 0) { ldv_main_exported_8(); } else { } goto ldv_55377; case 69: ; if (ldv_state_variable_38 != 0) { ldv_main_exported_38(); } else { } goto ldv_55377; case 70: ; if (ldv_state_variable_4 != 0) { ldv_main_exported_4(); } else { } goto ldv_55377; case 71: ; if (ldv_state_variable_34 != 0) { ldv_main_exported_34(); } else { } goto ldv_55377; case 72: ; if (ldv_state_variable_37 != 0) { ldv_main_exported_37(); } else { } goto ldv_55377; case 73: ; if (ldv_state_variable_43 != 0) { ldv_main_exported_43(); } else { } goto ldv_55377; case 74: ; if (ldv_state_variable_5 != 0) { ldv_main_exported_5(); } else { } goto ldv_55377; default: ldv_stop(); } ldv_55377: ; goto ldv_55462; ldv_final: ldv_check_final_state(); return 0; } } extern unsigned long find_next_bit(unsigned long const * , unsigned long , unsigned long ) ; __inline static __u16 __fswab16(__u16 val ) { { return ((__u16 )((int )((short )((int )val << 8)) | (int )((short )((int )val >> 8)))); } } extern void might_fault(void) ; extern int kstrtoull(char const * , unsigned int , unsigned long long * ) ; __inline static int kstrtoul(char const *s , unsigned int base , unsigned long *res ) { int tmp ; { tmp = kstrtoull(s, base, (unsigned long long *)res); return (tmp); } } extern void warn_slowpath_fmt(char const * , int const , char const * , ...) ; extern unsigned long __per_cpu_offset[4096U] ; extern char *strndup_user(char const * , long ) ; extern char *strcpy(char * , char const * ) ; extern char *strcat(char * , char const * ) ; extern char *strchr(char const * , int ) ; extern char *strsep(char ** , char const * ) ; extern char *kstrndup(char const * , size_t , gfp_t ) ; extern int nr_cpu_ids ; extern struct cpumask const * const cpu_possible_mask ; __inline static unsigned int cpumask_check(unsigned int cpu ) { bool __warned ; int __ret_warn_once ; int __ret_warn_on ; long tmp ; long tmp___0 ; long tmp___1 ; { __ret_warn_once = (unsigned int )nr_cpu_ids <= cpu; tmp___1 = ldv__builtin_expect(__ret_warn_once != 0, 0L); if (tmp___1 != 0L) { __ret_warn_on = ! __warned; tmp = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp != 0L) { warn_slowpath_null("include/linux/cpumask.h", 108); } else { } tmp___0 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___0 != 0L) { __warned = 1; } else { } } else { } ldv__builtin_expect(__ret_warn_once != 0, 0L); return (cpu); } } __inline static unsigned int cpumask_next(int n , struct cpumask const *srcp ) { unsigned long tmp ; { if (n != -1) { cpumask_check((unsigned int )n); } else { } tmp = find_next_bit((unsigned long const *)(& srcp->bits), (unsigned long )nr_cpu_ids, (unsigned long )(n + 1)); return ((unsigned int )tmp); } } __inline static int atomic_add_return(int i , atomic_t *v ) { int __ret ; { __ret = i; switch (4UL) { case 1UL: __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; xaddb %b0, %1\n": "+q" (__ret), "+m" (v->counter): : "memory", "cc"); goto ldv_5549; case 2UL: __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; xaddw %w0, %1\n": "+r" (__ret), "+m" (v->counter): : "memory", "cc"); goto ldv_5549; case 4UL: __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; xaddl %0, %1\n": "+r" (__ret), "+m" (v->counter): : "memory", "cc"); goto ldv_5549; case 8UL: __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; xaddq %q0, %1\n": "+r" (__ret), "+m" (v->counter): : "memory", "cc"); goto ldv_5549; default: __xadd_wrong_size(); } ldv_5549: ; return (__ret + i); } } extern unsigned long __get_free_pages(gfp_t , unsigned int ) ; extern unsigned long get_zeroed_page(gfp_t ) ; extern void free_pages(unsigned long , unsigned int ) ; extern int param_get_uint(char * , struct kernel_param const * ) ; extern int register_shrinker(struct shrinker * ) ; extern void unregister_shrinker(struct shrinker * ) ; extern void rpc_killall_tasks(struct rpc_clnt * ) ; extern int xprt_load_transport(char const * ) ; extern int rpcauth_get_gssinfo(rpc_authflavor_t , struct rpcsec_gss_info * ) ; extern void kill_anon_super(struct super_block * ) ; extern void deactivate_super(struct super_block * ) ; extern void deactivate_locked_super(struct super_block * ) ; extern int set_anon_super(struct super_block * , void * ) ; extern struct super_block *sget(struct file_system_type * , int (*)(struct super_block * , void * ) , int (*)(struct super_block * , void * ) , int , void * ) ; extern int register_filesystem(struct file_system_type * ) ; extern int unregister_filesystem(struct file_system_type * ) ; extern unsigned long _copy_from_user(void * , void const * , unsigned int ) ; __inline static unsigned long copy_from_user(void *to , void const *from , unsigned long n ) { int sz ; unsigned long tmp ; int __ret_warn_on ; long tmp___0 ; long tmp___1 ; long tmp___2 ; { tmp = __builtin_object_size((void const *)to, 0); sz = (int )tmp; might_fault(); tmp___1 = ldv__builtin_expect(sz == -1, 1L); if (tmp___1 != 0L) { n = _copy_from_user(to, from, (unsigned int )n); } else { tmp___2 = ldv__builtin_expect((unsigned long )sz >= n, 1L); if (tmp___2 != 0L) { n = _copy_from_user(to, from, (unsigned int )n); } else { __ret_warn_on = 1; tmp___0 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___0 != 0L) { warn_slowpath_fmt("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/arch/x86/include/asm/uaccess_64.h", 66, "Buffer overflow detected!\n"); } else { } ldv__builtin_expect(__ret_warn_on != 0, 0L); } } return (n); } } extern int seq_escape(struct seq_file * , char const * , char const * ) ; __inline static void security_init_mnt_opts(struct security_mnt_opts *opts ) { { opts->mnt_opts = (char **)0; opts->mnt_opts_flags = (int *)0; opts->num_mnt_opts = 0; return; } } __inline static void security_free_mnt_opts(struct security_mnt_opts *opts ) { int i ; { if ((unsigned long )opts->mnt_opts != (unsigned long )((char **)0)) { i = 0; goto ldv_36691; ldv_36690: kfree((void const *)*(opts->mnt_opts + (unsigned long )i)); i = i + 1; ldv_36691: ; if (opts->num_mnt_opts > i) { goto ldv_36690; } else { } } else { } kfree((void const *)opts->mnt_opts); opts->mnt_opts = (char **)0; kfree((void const *)opts->mnt_opts_flags); opts->mnt_opts_flags = (int *)0; opts->num_mnt_opts = 0; return; } } extern int security_sb_copy_data(char * , char * ) ; extern int security_sb_set_mnt_opts(struct super_block * , struct security_mnt_opts * , unsigned long , unsigned long * ) ; extern int security_sb_clone_mnt_opts(struct super_block const * , struct super_block * ) ; extern int security_sb_parse_opts_str(char * , struct security_mnt_opts * ) ; __inline static char *alloc_secdata(void) { unsigned long tmp ; { tmp = get_zeroed_page(208U); return ((char *)tmp); } } __inline static void free_secdata(void *secdata ) { { free_pages((unsigned long )secdata, 0U); return; } } __inline static bool ipv6_addr_any(struct in6_addr const *a ) { unsigned long const *ul ; { ul = (unsigned long const *)a; return (((unsigned long )*ul | (unsigned long )*(ul + 1UL)) == 0UL); } } extern size_t rpc_pton(struct net * , char const * , size_t const , struct sockaddr * , size_t const ) ; __inline static void rpc_set_port(struct sockaddr *sap , unsigned short const port ) { __u16 tmp ; __u16 tmp___0 ; { switch ((int )sap->sa_family) { case 2: tmp = __fswab16((int )port); ((struct sockaddr_in *)sap)->sin_port = tmp; goto ldv_46186; case 10: tmp___0 = __fswab16((int )port); ((struct sockaddr_in6 *)sap)->sin6_port = tmp___0; goto ldv_46186; } ldv_46186: ; return; } } __inline static bool __rpc_cmp_addr4(struct sockaddr const *sap1 , struct sockaddr const *sap2 ) { struct sockaddr_in const *sin1 ; struct sockaddr_in const *sin2 ; { sin1 = (struct sockaddr_in const *)sap1; sin2 = (struct sockaddr_in const *)sap2; return ((unsigned int )sin1->sin_addr.s_addr == (unsigned int )sin2->sin_addr.s_addr); } } __inline static bool __rpc_cmp_addr6(struct sockaddr const *sap1 , struct sockaddr const *sap2 ) { struct sockaddr_in6 const *sin1 ; struct sockaddr_in6 const *sin2 ; int tmp ; bool tmp___0 ; int tmp___1 ; { sin1 = (struct sockaddr_in6 const *)sap1; sin2 = (struct sockaddr_in6 const *)sap2; tmp___0 = ipv6_addr_equal(& sin1->sin6_addr, & sin2->sin6_addr); if (tmp___0) { tmp___1 = 0; } else { tmp___1 = 1; } if (tmp___1) { return (0); } else { tmp = ipv6_addr_type(& sin1->sin6_addr); if (((unsigned int )tmp & 32U) != 0U) { return ((unsigned int )sin1->sin6_scope_id == (unsigned int )sin2->sin6_scope_id); } else { } } return (1); } } __inline static bool rpc_cmp_addr(struct sockaddr const *sap1 , struct sockaddr const *sap2 ) { bool tmp ; bool tmp___0 ; { if ((int )((unsigned short )sap1->sa_family) == (int )((unsigned short )sap2->sa_family)) { switch ((int )sap1->sa_family) { case 2: tmp = __rpc_cmp_addr4(sap1, sap2); return (tmp); case 10: tmp___0 = __rpc_cmp_addr6(sap1, sap2); return (tmp___0); } } else { } return (0); } } extern void rpc_print_iostats(struct seq_file * , struct rpc_clnt * ) ; extern int bdi_register_dev(struct backing_dev_info * , dev_t ) ; extern void bdi_unregister(struct backing_dev_info * ) ; int nfs_register_sysctl(void) ; void nfs_unregister_sysctl(void) ; unsigned int nfs_idmap_cache_timeout ; extern int match_token(char * , struct match_token const * , substring_t * ) ; extern char *match_strdup(substring_t const * ) ; struct file_system_type nfs4_fs_type ; bool nfs4_disable_idmapping ; unsigned short max_session_slots ; unsigned short send_implementation_id ; bool recover_lost_locks ; char nfs4_client_id_uniquifier[64U] ; unsigned int nfs_callback_set_tcpport ; unsigned short nfs_callback_tcpport ; int nfs_mount(struct nfs_mount_request *info ) ; int nfs_write_inode(struct inode *inode , struct writeback_control *wbc ) ; struct super_operations const nfs_sops ; struct file_system_type nfs_fs_type ; struct file_system_type nfs_xdev_fs_type ; struct dentry *nfs_try_mount(int flags , char const *dev_name___0 , struct nfs_mount_info *mount_info , struct nfs_subversion *nfs_mod ) ; __inline void nfs_initialise_sb(struct super_block *sb ) ; int nfs_set_sb_security(struct super_block *s , struct dentry *mntroot , struct nfs_mount_info *mount_info ) ; int nfs_clone_sb_security(struct super_block *s , struct dentry *mntroot , struct nfs_mount_info *mount_info ) ; struct dentry *nfs_fs_mount_common(struct nfs_server *server , int flags , char const *dev_name___0 , struct nfs_mount_info *mount_info , struct nfs_subversion *nfs_mod ) ; struct dentry *nfs_fs_mount(struct file_system_type *fs_type , int flags , char const *dev_name___0 , void *raw_data ) ; void nfs_kill_super(struct super_block *s ) ; void nfs_fill_super(struct super_block *sb , struct nfs_mount_info *mount_info ) ; char *nfs_path(char **p , struct dentry *dentry , char *buffer , ssize_t buflen , unsigned int flags ) ; void nfs_clone_super(struct super_block *sb , struct nfs_mount_info *mount_info ) ; void nfs_umount_begin(struct super_block *sb ) ; int nfs_statfs(struct dentry *dentry , struct kstatfs *buf ) ; int nfs_show_options(struct seq_file *m , struct dentry *root ) ; int nfs_show_devname(struct seq_file *m , struct dentry *root ) ; int nfs_show_path(struct seq_file *m , struct dentry *dentry ) ; int nfs_show_stats(struct seq_file *m , struct dentry *root ) ; void nfs_put_super(struct super_block *s ) ; int nfs_remount(struct super_block *sb , int *flags , char *raw_data ) ; __inline static unsigned long nfs_block_bits___0(unsigned long bsize , unsigned char *nrbitsp ) { unsigned char nrbits ; { if (((bsize - 1UL) & bsize) != 0UL || (unsigned long )nrbitsp != (unsigned long )((unsigned char *)0U)) { nrbits = 31U; goto ldv_52172; ldv_52171: nrbits = (unsigned char )((int )nrbits - 1); ldv_52172: ; if ((unsigned int )nrbits != 0U && ((unsigned long )(1 << (int )nrbits) & bsize) == 0UL) { goto ldv_52171; } else { } bsize = (unsigned long )(1 << (int )nrbits); if ((unsigned long )nrbitsp != (unsigned long )((unsigned char *)0U)) { *nrbitsp = nrbits; } else { } } else { } return (bsize); } } __inline static unsigned long nfs_block_size___0(unsigned long bsize , unsigned char *nrbitsp ) { unsigned long tmp ; { if (bsize <= 1023UL) { bsize = 4096UL; } else if (bsize > 1048575UL) { bsize = 1048576UL; } else { } tmp = nfs_block_bits___0(bsize, nrbitsp); return (tmp); } } __inline static void nfs_super_set_maxbytes(struct super_block *sb , __u64 maxfilesize ) { { sb->s_maxbytes = (long long )maxfilesize; if (sb->s_maxbytes <= 0LL) { sb->s_maxbytes = 9223372036854775807LL; } else { } return; } } void nfs_fscache_get_super_cookie(struct super_block *sb , char const *uniq , int ulen ) ; void nfs_fscache_release_super_cookie(struct super_block *sb ) ; __inline static int nfs4_has_session(struct nfs_client const *clp ) { { if ((unsigned long )clp->cl_session != (unsigned long )((struct nfs4_session */* const */)0)) { return (1); } else { } return (0); } } static struct match_token const nfs_mount_option_tokens[60U] = { {51, "bg"}, {51, "fg"}, {51, "retry=%s"}, {53, "sloppy"}, {0, "soft"}, {1, "hard"}, {52, "intr"}, {52, "nointr"}, {2, "posix"}, {3, "noposix"}, {4, "cto"}, {5, "nocto"}, {6, "ac"}, {7, "noac"}, {8, "lock"}, {9, "nolock"}, {10, "udp"}, {11, "tcp"}, {12, "rdma"}, {13, "acl"}, {14, "noacl"}, {15, "rdirplus"}, {16, "nordirplus"}, {17, "sharecache"}, {18, "nosharecache"}, {19, "resvport"}, {20, "noresvport"}, {21, "fsc"}, {22, "nofsc"}, {23, "migration"}, {24, "nomigration"}, {25, "port=%s"}, {26, "rsize=%s"}, {27, "wsize=%s"}, {28, "bsize=%s"}, {29, "timeo=%s"}, {30, "retrans=%s"}, {31, "acregmin=%s"}, {32, "acregmax=%s"}, {33, "acdirmin=%s"}, {34, "acdirmax=%s"}, {35, "actimeo=%s"}, {36, "namlen=%s"}, {37, "mountport=%s"}, {38, "mountvers=%s"}, {39, "minorversion=%s"}, {40, "nfsvers=%s"}, {40, "vers=%s"}, {41, "sec=%s"}, {42, "proto=%s"}, {43, "mountproto=%s"}, {45, "addr=%s"}, {47, "clientaddr=%s"}, {44, "mounthost=%s"}, {46, "mountaddr=%s"}, {48, "lookupcache=%s"}, {49, "fsc=%s"}, {50, "local_lock=%s"}, {40, "v%s"}, {54, (char const *)0}}; static struct match_token const nfs_xprt_protocol_tokens[6U] = { {0, "udp"}, {1, "udp6"}, {2, "tcp"}, {3, "tcp6"}, {4, "rdma"}, {5, (char const *)0}}; static struct match_token const nfs_secflavor_tokens[13U] = { {0, "none"}, {0, "null"}, {1, "sys"}, {2, "krb5"}, {3, "krb5i"}, {4, "krb5p"}, {5, "lkey"}, {6, "lkeyi"}, {7, "lkeyp"}, {8, "spkm3"}, {9, "spkm3i"}, {10, "spkm3p"}, {11, (char const *)0}}; static struct match_token nfs_lookupcache_tokens[5U] = { {0, "all"}, {1, "pos"}, {1, "positive"}, {2, "none"}, {3, (char const *)0}}; static struct match_token nfs_local_lock_tokens[5U] = { {0, "all"}, {1, "flock"}, {2, "posix"}, {3, "none"}, {4, (char const *)0}}; static struct match_token nfs_vers_tokens[7U] = { {0, "2"}, {1, "3"}, {2, "4"}, {3, "4.0"}, {4, "4.1"}, {5, "4.2"}, {6, (char const *)0}}; static struct dentry *nfs_xdev_mount(struct file_system_type *fs_type , int flags , char const *dev_name___0 , void *raw_data ) ; struct file_system_type nfs_fs_type = {"nfs", 32770, & nfs_fs_mount, & nfs_kill_super, & __this_module, 0, {0}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}; struct file_system_type nfs_xdev_fs_type = {"nfs", 32770, & nfs_xdev_mount, & nfs_kill_super, & __this_module, 0, {0}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}; struct super_operations const nfs_sops = {& nfs_alloc_inode, & nfs_destroy_inode, 0, & nfs_write_inode, & nfs_drop_inode, & nfs_evict_inode, & nfs_put_super, 0, 0, 0, & nfs_statfs, & nfs_remount, & nfs_umount_begin, & nfs_show_options, & nfs_show_devname, & nfs_show_path, & nfs_show_stats, 0, 0, 0, 0, 0}; static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args ) ; static int nfs4_validate_mount_data(void *options , struct nfs_parsed_mount_data *args , char const *dev_name___0 ) ; struct file_system_type nfs4_fs_type = {"nfs4", 32770, & nfs_fs_mount, & nfs_kill_super, & __this_module, 0, {0}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}; static int register_nfs4_fs(void) { int tmp ; { tmp = register_filesystem(& nfs4_fs_type); return (tmp); } } static void unregister_nfs4_fs(void) { { unregister_filesystem(& nfs4_fs_type); return; } } static struct shrinker acl_shrinker = {& nfs_access_cache_count, & nfs_access_cache_scan, 2, 0L, 0UL, {0, 0}, 0}; int register_nfs_fs(void) { int ret ; { ret = register_filesystem(& nfs_fs_type); if (ret < 0) { goto error_0; } else { } ret = register_nfs4_fs(); if (ret < 0) { goto error_1; } else { } ret = nfs_register_sysctl(); if (ret < 0) { goto error_2; } else { } register_shrinker(& acl_shrinker); return (0); error_2: unregister_nfs4_fs(); error_1: unregister_filesystem(& nfs_fs_type); error_0: ; return (ret); } } void unregister_nfs_fs(void) { { unregister_shrinker(& acl_shrinker); nfs_unregister_sysctl(); unregister_nfs4_fs(); unregister_filesystem(& nfs_fs_type); return; } } void nfs_sb_active(struct super_block *sb ) { struct nfs_server *server ; struct nfs_server *tmp ; int tmp___0 ; { tmp = NFS_SB((struct super_block const *)sb); server = tmp; tmp___0 = atomic_add_return(1, & server->active); if (tmp___0 == 1) { atomic_inc(& sb->s_active); } else { } return; } } void nfs_sb_deactive(struct super_block *sb ) { struct nfs_server *server ; struct nfs_server *tmp ; int tmp___0 ; { tmp = NFS_SB((struct super_block const *)sb); server = tmp; tmp___0 = atomic_dec_and_test(& server->active); if (tmp___0 != 0) { deactivate_super(sb); } else { } return; } } int nfs_statfs(struct dentry *dentry , struct kstatfs *buf ) { struct nfs_server *server ; struct nfs_server *tmp ; unsigned char blockbits ; unsigned long blockres ; struct nfs_fh *fh ; struct nfs_fh *tmp___0 ; struct nfs_fsstat res ; int error ; struct dentry *pd_dentry ; long tmp___1 ; long tmp___2 ; { tmp = NFS_SB((struct super_block const *)dentry->d_sb); server = tmp; tmp___0 = NFS_FH((struct inode const *)dentry->d_inode); fh = tmp___0; error = -12; res.fattr = nfs_alloc_fattr(); if ((unsigned long )res.fattr == (unsigned long )((struct nfs_fattr *)0)) { goto out_err; } else { } error = (*(((server->nfs_client)->rpc_ops)->statfs))(server, fh, & res); tmp___1 = ldv__builtin_expect(error == -116, 0L); if (tmp___1 != 0L) { pd_dentry = dget_parent(dentry); if ((unsigned long )pd_dentry != (unsigned long )((struct dentry *)0)) { nfs_zap_caches(pd_dentry->d_inode); dput(pd_dentry); } else { } } else { } nfs_free_fattr((struct nfs_fattr const *)res.fattr); if (error < 0) { goto out_err; } else { } buf->f_type = 26985L; buf->f_frsize = (long )(dentry->d_sb)->s_blocksize; buf->f_bsize = (long )(dentry->d_sb)->s_blocksize; blockbits = (dentry->d_sb)->s_blocksize_bits; blockres = (unsigned long )((1 << (int )blockbits) + -1); buf->f_blocks = (res.tbytes + (unsigned long long )blockres) >> (int )blockbits; buf->f_bfree = (res.fbytes + (unsigned long long )blockres) >> (int )blockbits; buf->f_bavail = (res.abytes + (unsigned long long )blockres) >> (int )blockbits; buf->f_files = res.tfiles; buf->f_ffree = res.afiles; buf->f_namelen = (long )server->namelen; return (0); out_err: tmp___2 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___2 != 0L) { printk("\001d%s: statfs error = %d\n", "nfs_statfs", - error); } else { } return (error); } } static char const *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour ) { struct __anonstruct_sec_flavours_283 sec_flavours[12U] ; int i ; { sec_flavours[0].flavour = 0U; sec_flavours[0].str = "null"; sec_flavours[1].flavour = 1U; sec_flavours[1].str = "sys"; sec_flavours[2].flavour = 390003U; sec_flavours[2].str = "krb5"; sec_flavours[3].flavour = 390004U; sec_flavours[3].str = "krb5i"; sec_flavours[4].flavour = 390005U; sec_flavours[4].str = "krb5p"; sec_flavours[5].flavour = 390006U; sec_flavours[5].str = "lkey"; sec_flavours[6].flavour = 390007U; sec_flavours[6].str = "lkeyi"; sec_flavours[7].flavour = 390008U; sec_flavours[7].str = "lkeyp"; sec_flavours[8].flavour = 390009U; sec_flavours[8].str = "spkm"; sec_flavours[9].flavour = 390010U; sec_flavours[9].str = "spkmi"; sec_flavours[10].flavour = 390011U; sec_flavours[10].str = "spkmp"; sec_flavours[11].flavour = 4294967295U; sec_flavours[11].str = "unknown"; i = 0; goto ldv_53273; ldv_53272: ; if (sec_flavours[i].flavour == flavour) { goto ldv_53271; } else { } i = i + 1; ldv_53273: ; if (sec_flavours[i].flavour != 4294967295U) { goto ldv_53272; } else { } ldv_53271: ; return (sec_flavours[i].str); } } static void nfs_show_mountd_netid(struct seq_file *m , struct nfs_server *nfss , int showdefaults ) { struct sockaddr *sap ; { sap = (struct sockaddr *)(& nfss->mountd_address); seq_printf(m, ",mountproto="); switch ((int )sap->sa_family) { case 2: ; switch ((int )nfss->mountd_protocol) { case 17: seq_printf(m, "udp"); goto ldv_53282; case 6: seq_printf(m, "tcp"); goto ldv_53282; default: ; if (showdefaults != 0) { seq_printf(m, "auto"); } else { } } ldv_53282: ; goto ldv_53285; case 10: ; switch ((int )nfss->mountd_protocol) { case 17: seq_printf(m, "udp6"); goto ldv_53288; case 6: seq_printf(m, "tcp6"); goto ldv_53288; default: ; if (showdefaults != 0) { seq_printf(m, "auto"); } else { } } ldv_53288: ; goto ldv_53285; default: ; if (showdefaults != 0) { seq_printf(m, "auto"); } else { } } ldv_53285: ; return; } } static void nfs_show_mountd_options(struct seq_file *m , struct nfs_server *nfss , int showdefaults ) { struct sockaddr *sap ; struct sockaddr_in *sin ; struct sockaddr_in6 *sin6 ; { sap = (struct sockaddr *)(& nfss->mountd_address); if ((nfss->flags & 524288) != 0) { return; } else { } switch ((int )sap->sa_family) { case 2: sin = (struct sockaddr_in *)sap; seq_printf(m, ",mountaddr=%pI4", & sin->sin_addr.s_addr); goto ldv_53300; case 10: sin6 = (struct sockaddr_in6 *)sap; seq_printf(m, ",mountaddr=%pI6c", & sin6->sin6_addr); goto ldv_53300; default: ; if (showdefaults != 0) { seq_printf(m, ",mountaddr=unspecified"); } else { } } ldv_53300: ; if (nfss->mountd_version != 0U || showdefaults != 0) { seq_printf(m, ",mountvers=%u", nfss->mountd_version); } else { } if (((unsigned int )nfss->mountd_port != 0U && (unsigned int )nfss->mountd_port != 65535U) || showdefaults != 0) { seq_printf(m, ",mountport=%u", (int )nfss->mountd_port); } else { } nfs_show_mountd_netid(m, nfss, showdefaults); return; } } static void nfs_show_nfsv4_options(struct seq_file *m , struct nfs_server *nfss , int showdefaults ) { struct nfs_client *clp ; { clp = nfss->nfs_client; seq_printf(m, ",clientaddr=%s", (char *)(& clp->cl_ipaddr)); return; } } static void nfs_show_nfs_version(struct seq_file *m , unsigned int version , unsigned int minorversion ) { { seq_printf(m, ",vers=%u", version); if (version == 4U) { seq_printf(m, ".%u", minorversion); } else { } return; } } static void nfs_show_mount_options(struct seq_file *m , struct nfs_server *nfss , int showdefaults ) { struct proc_nfs_info nfs_info[10U] ; struct proc_nfs_info const *nfs_infop ; struct nfs_client *clp ; u32 version ; int local_flock ; int local_fcntl ; char const *tmp ; char const *tmp___0 ; { nfs_info[0].flag = 1; nfs_info[0].str = ",soft"; nfs_info[0].nostr = ",hard"; nfs_info[1].flag = 8; nfs_info[1].str = ",posix"; nfs_info[1].nostr = ""; nfs_info[2].flag = 16; nfs_info[2].str = ",nocto"; nfs_info[2].nostr = ""; nfs_info[3].flag = 32; nfs_info[3].str = ",noac"; nfs_info[3].nostr = ""; nfs_info[4].flag = 512; nfs_info[4].str = ",nolock"; nfs_info[4].nostr = ""; nfs_info[5].flag = 2048; nfs_info[5].str = ",noacl"; nfs_info[5].nostr = ""; nfs_info[6].flag = 16384; nfs_info[6].str = ",nordirplus"; nfs_info[6].nostr = ""; nfs_info[7].flag = 32768; nfs_info[7].str = ",nosharecache"; nfs_info[7].nostr = ""; nfs_info[8].flag = 262144; nfs_info[8].str = ",noresvport"; nfs_info[8].nostr = ""; nfs_info[9].flag = 0; nfs_info[9].str = (char const *)0; nfs_info[9].nostr = (char const *)0; clp = nfss->nfs_client; version = (clp->rpc_ops)->version; nfs_show_nfs_version(m, version, clp->cl_minorversion); seq_printf(m, ",rsize=%u", nfss->rsize); seq_printf(m, ",wsize=%u", nfss->wsize); if (nfss->bsize != 0U) { seq_printf(m, ",bsize=%u", nfss->bsize); } else { } seq_printf(m, ",namlen=%u", nfss->namelen); if (nfss->acregmin != 750U || showdefaults != 0) { seq_printf(m, ",acregmin=%u", nfss->acregmin / 250U); } else { } if (nfss->acregmax != 15000U || showdefaults != 0) { seq_printf(m, ",acregmax=%u", nfss->acregmax / 250U); } else { } if (nfss->acdirmin != 7500U || showdefaults != 0) { seq_printf(m, ",acdirmin=%u", nfss->acdirmin / 250U); } else { } if (nfss->acdirmax != 15000U || showdefaults != 0) { seq_printf(m, ",acdirmax=%u", nfss->acdirmax / 250U); } else { } nfs_infop = (struct proc_nfs_info const *)(& nfs_info); goto ldv_53331; ldv_53330: ; if ((nfss->flags & (int )nfs_infop->flag) != 0) { seq_puts(m, nfs_infop->str); } else { seq_puts(m, nfs_infop->nostr); } nfs_infop = nfs_infop + 1; ldv_53331: ; if ((int )nfs_infop->flag != 0) { goto ldv_53330; } else { } rcu_read_lock(); tmp = rpc_peeraddr2str(nfss->client, 5); seq_printf(m, ",proto=%s", tmp); rcu_read_unlock(); if (version == 4U) { if ((unsigned int )nfss->port != 2049U) { seq_printf(m, ",port=%u", (int )nfss->port); } else { } } else if ((unsigned int )nfss->port != 0U) { seq_printf(m, ",port=%u", (int )nfss->port); } else { } seq_printf(m, ",timeo=%lu", ((unsigned long )((nfss->client)->cl_timeout)->to_initval * 10UL) / 250UL); seq_printf(m, ",retrans=%u", ((nfss->client)->cl_timeout)->to_retries); tmp___0 = nfs_pseudoflavour_to_name(((nfss->client)->cl_auth)->au_flavor); seq_printf(m, ",sec=%s", tmp___0); if (version != 4U) { nfs_show_mountd_options(m, nfss, showdefaults); } else { nfs_show_nfsv4_options(m, nfss, showdefaults); } if ((int )nfss->options & 1) { seq_printf(m, ",fsc"); } else { } if ((nfss->options & 2U) != 0U) { seq_printf(m, ",migration"); } else { } if ((nfss->flags & 65536) != 0) { if ((nfss->flags & 131072) != 0) { seq_printf(m, ",lookupcache=none"); } else { seq_printf(m, ",lookupcache=pos"); } } else { } local_flock = nfss->flags & 1048576; local_fcntl = nfss->flags & 2097152; if (local_flock == 0 && local_fcntl == 0) { seq_printf(m, ",local_lock=none"); } else if (local_flock != 0 && local_fcntl != 0) { seq_printf(m, ",local_lock=all"); } else if (local_flock != 0) { seq_printf(m, ",local_lock=flock"); } else { seq_printf(m, ",local_lock=posix"); } return; } } int nfs_show_options(struct seq_file *m , struct dentry *root ) { struct nfs_server *nfss ; struct nfs_server *tmp ; char const *tmp___0 ; { tmp = NFS_SB((struct super_block const *)root->d_sb); nfss = tmp; nfs_show_mount_options(m, nfss, 0); rcu_read_lock(); tmp___0 = rpc_peeraddr2str((nfss->nfs_client)->cl_rpcclient, 0); seq_printf(m, ",addr=%s", tmp___0); rcu_read_unlock(); return (0); } } static void show_sessions(struct seq_file *m , struct nfs_server *server ) { int tmp ; { tmp = nfs4_has_session((struct nfs_client const *)server->nfs_client); if (tmp != 0) { seq_printf(m, ",sessions"); } else { } return; } } static void show_pnfs(struct seq_file *m , struct nfs_server *server ) { { seq_printf(m, ",pnfs="); if ((unsigned long )server->pnfs_curr_ld != (unsigned long )((struct pnfs_layoutdriver_type *)0)) { seq_printf(m, "%s", (server->pnfs_curr_ld)->name); } else { seq_printf(m, "not configured"); } return; } } static void show_implementation_id(struct seq_file *m , struct nfs_server *nfss ) { struct nfs41_impl_id *impl_id ; { if ((unsigned long )nfss->nfs_client != (unsigned long )((struct nfs_client *)0) && (unsigned long )(nfss->nfs_client)->cl_implid != (unsigned long )((struct nfs41_impl_id *)0)) { impl_id = (nfss->nfs_client)->cl_implid; seq_printf(m, "\n\timpl_id:\tname=\'%s\',domain=\'%s\',date=\'%llu,%u\'", (char *)(& impl_id->name), (char *)(& impl_id->domain), impl_id->date.seconds, impl_id->date.nseconds); } else { } return; } } int nfs_show_devname(struct seq_file *m , struct dentry *root ) { char *page ; unsigned long tmp ; char *devname ; char *dummy ; int err ; long tmp___0 ; long tmp___1 ; { tmp = __get_free_pages(208U, 0U); page = (char *)tmp; err = 0; if ((unsigned long )page == (unsigned long )((char *)0)) { return (-12); } else { } devname = nfs_path(& dummy, root, page, 4096L, 0U); tmp___1 = IS_ERR((void const *)devname); if (tmp___1 != 0L) { tmp___0 = PTR_ERR((void const *)devname); err = (int )tmp___0; } else { seq_escape(m, (char const *)devname, " \t\n\\"); } free_pages((unsigned long )page, 0U); return (err); } } int nfs_show_path(struct seq_file *m , struct dentry *dentry ) { { seq_puts(m, "/"); return (0); } } int nfs_show_stats(struct seq_file *m , struct dentry *root ) { int i ; int cpu ; struct nfs_server *nfss ; struct nfs_server *tmp ; struct rpc_auth *auth ; struct nfs_iostats totals ; struct nfs_iostats *stats ; struct thread_info *tmp___0 ; void const *__vpp_verify ; unsigned long __ptr ; struct thread_info *tmp___1 ; unsigned int tmp___2 ; { tmp = NFS_SB((struct super_block const *)root->d_sb); nfss = tmp; auth = (nfss->client)->cl_auth; totals.bytes[0] = 0ULL; totals.bytes[1] = 0ULL; totals.bytes[2] = 0ULL; totals.bytes[3] = 0ULL; totals.bytes[4] = 0ULL; totals.bytes[5] = 0ULL; totals.bytes[6] = 0ULL; totals.bytes[7] = 0ULL; totals.fscache[0] = 0ULL; totals.fscache[1] = 0ULL; totals.fscache[2] = 0ULL; totals.fscache[3] = 0ULL; totals.fscache[4] = 0ULL; totals.events[0] = 0UL; totals.events[1] = 0UL; totals.events[2] = 0UL; totals.events[3] = 0UL; totals.events[4] = 0UL; totals.events[5] = 0UL; totals.events[6] = 0UL; totals.events[7] = 0UL; totals.events[8] = 0UL; totals.events[9] = 0UL; totals.events[10] = 0UL; totals.events[11] = 0UL; totals.events[12] = 0UL; totals.events[13] = 0UL; totals.events[14] = 0UL; totals.events[15] = 0UL; totals.events[16] = 0UL; totals.events[17] = 0UL; totals.events[18] = 0UL; totals.events[19] = 0UL; totals.events[20] = 0UL; totals.events[21] = 0UL; totals.events[22] = 0UL; totals.events[23] = 0UL; totals.events[24] = 0UL; totals.events[25] = 0UL; totals.events[26] = 0UL; seq_printf(m, "statvers=%s", (char *)"1.1"); seq_printf(m, "\n\topts:\t"); seq_puts(m, (int )(root->d_sb)->s_flags & 1 ? "ro" : "rw"); seq_puts(m, ((root->d_sb)->s_flags & 16UL) != 0UL ? ",sync" : ""); seq_puts(m, ((root->d_sb)->s_flags & 1024UL) != 0UL ? ",noatime" : ""); seq_puts(m, ((root->d_sb)->s_flags & 2048UL) != 0UL ? ",nodiratime" : ""); nfs_show_mount_options(m, nfss, 1); seq_printf(m, "\n\tage:\t%lu", ((unsigned long )jiffies - nfss->mount_time) / 250UL); show_implementation_id(m, nfss); seq_printf(m, "\n\tcaps:\t"); seq_printf(m, "caps=0x%x", nfss->caps); seq_printf(m, ",wtmult=%u", nfss->wtmult); seq_printf(m, ",dtsize=%u", nfss->dtsize); seq_printf(m, ",bsize=%u", nfss->bsize); seq_printf(m, ",namlen=%u", nfss->namelen); if ((unsigned int )((nfss->nfs_client)->rpc_ops)->version == 4U) { seq_printf(m, "\n\tnfsv4:\t"); seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]); seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]); seq_printf(m, ",bm2=0x%x", nfss->attr_bitmask[2]); seq_printf(m, ",acl=0x%x", nfss->acl_bitmask); show_sessions(m, nfss); show_pnfs(m, nfss); } else { } seq_printf(m, "\n\tsec:\tflavor=%u", (auth->au_ops)->au_flavor); if (auth->au_flavor != 0U) { seq_printf(m, ",pseudoflavor=%u", auth->au_flavor); } else { } cpu = -1; goto ldv_53408; ldv_53407: tmp___0 = current_thread_info(); tmp___0->preempt_count = tmp___0->preempt_count + 1; __asm__ volatile ("": : : "memory"); __vpp_verify = (void const *)0; __asm__ ("": "=r" (__ptr): "0" (nfss->io_stats)); stats = (struct nfs_iostats *)(__per_cpu_offset[cpu] + __ptr); i = 0; goto ldv_53399; ldv_53398: totals.events[i] = totals.events[i] + stats->events[i]; i = i + 1; ldv_53399: ; if (i <= 26) { goto ldv_53398; } else { } i = 0; goto ldv_53402; ldv_53401: totals.bytes[i] = totals.bytes[i] + stats->bytes[i]; i = i + 1; ldv_53402: ; if (i <= 7) { goto ldv_53401; } else { } i = 0; goto ldv_53405; ldv_53404: totals.fscache[i] = totals.fscache[i] + stats->fscache[i]; i = i + 1; ldv_53405: ; if (i <= 4) { goto ldv_53404; } else { } __asm__ volatile ("": : : "memory"); tmp___1 = current_thread_info(); tmp___1->preempt_count = tmp___1->preempt_count + -1; __asm__ volatile ("": : : "memory"); ldv_53408: tmp___2 = cpumask_next(cpu, cpu_possible_mask); cpu = (int )tmp___2; if (cpu < nr_cpu_ids) { goto ldv_53407; } else { } seq_printf(m, "\n\tevents:\t"); i = 0; goto ldv_53411; ldv_53410: seq_printf(m, "%lu ", totals.events[i]); i = i + 1; ldv_53411: ; if (i <= 26) { goto ldv_53410; } else { } seq_printf(m, "\n\tbytes:\t"); i = 0; goto ldv_53414; ldv_53413: seq_printf(m, "%Lu ", totals.bytes[i]); i = i + 1; ldv_53414: ; if (i <= 7) { goto ldv_53413; } else { } if ((int )nfss->options & 1) { seq_printf(m, "\n\tfsc:\t"); i = 0; goto ldv_53417; ldv_53416: seq_printf(m, "%Lu ", totals.bytes[i]); i = i + 1; ldv_53417: ; if (i <= 4) { goto ldv_53416; } else { } } else { } seq_printf(m, "\n"); rpc_print_iostats(m, nfss->client); return (0); } } void nfs_umount_begin(struct super_block *sb ) { struct nfs_server *server ; struct rpc_clnt *rpc ; long tmp ; long tmp___0 ; { server = NFS_SB((struct super_block const *)sb); rpc = server->client_acl; tmp = IS_ERR((void const *)rpc); if (tmp == 0L) { rpc_killall_tasks(rpc); } else { } rpc = server->client; tmp___0 = IS_ERR((void const *)rpc); if (tmp___0 == 0L) { rpc_killall_tasks(rpc); } else { } return; } } static struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(void) { struct nfs_parsed_mount_data *data ; void *tmp ; struct task_struct *tmp___0 ; { tmp = kzalloc(440UL, 208U); data = (struct nfs_parsed_mount_data *)tmp; if ((unsigned long )data != (unsigned long )((struct nfs_parsed_mount_data *)0)) { data->acregmin = 3U; data->acregmax = 60U; data->acdirmin = 30U; data->acdirmax = 60U; data->mount_server.port = -1; data->nfs_server.port = -1; data->nfs_server.protocol = 6U; data->auth_flavors[0] = 8U; data->auth_flavor_len = 0U; data->minorversion = 0U; data->need_mount = 1; tmp___0 = get_current(); data->net = (tmp___0->nsproxy)->net_ns; security_init_mnt_opts(& data->lsm_opts); } else { } return (data); } } static void nfs_free_parsed_mount_data(struct nfs_parsed_mount_data *data ) { { if ((unsigned long )data != (unsigned long )((struct nfs_parsed_mount_data *)0)) { kfree((void const *)data->client_address); kfree((void const *)data->mount_server.hostname); kfree((void const *)data->nfs_server.export_path); kfree((void const *)data->nfs_server.hostname); kfree((void const *)data->fscache_uniq); security_free_mnt_opts(& data->lsm_opts); kfree((void const *)data); } else { } return; } } static int nfs_verify_server_address(struct sockaddr *addr ) { struct sockaddr_in *sa ; struct in6_addr *sa___0 ; bool tmp ; int tmp___0 ; long tmp___1 ; { switch ((int )addr->sa_family) { case 2: sa = (struct sockaddr_in *)addr; return (sa->sin_addr.s_addr != 0U); case 10: sa___0 = & ((struct sockaddr_in6 *)addr)->sin6_addr; tmp = ipv6_addr_any((struct in6_addr const *)sa___0); if (tmp) { tmp___0 = 0; } else { tmp___0 = 1; } return (tmp___0); } tmp___1 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001dNFS: Invalid IP address specified\n"); } else { } return (0); } } static void nfs_set_port(struct sockaddr *sap , int *port , unsigned short const default_port ) { { if (*port == -1) { *port = (int )default_port; } else { } rpc_set_port(sap, (int )((unsigned short const )*port)); return; } } static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data *mnt ) { { switch ((int )mnt->nfs_server.protocol) { case 17: ; case 6: ; case 256: ; goto ldv_53462; default: mnt->nfs_server.protocol = 6U; } ldv_53462: ; return; } } static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data *mnt ) { { nfs_validate_transport_protocol(mnt); if ((unsigned int )mnt->mount_server.protocol == 17U || (unsigned int )mnt->mount_server.protocol == 6U) { return; } else { } switch ((int )mnt->nfs_server.protocol) { case 17: mnt->mount_server.protocol = 17U; goto ldv_53468; case 6: ; case 256: mnt->mount_server.protocol = 6U; } ldv_53468: ; return; } } static void nfs_set_auth_parsed_mount_data(struct nfs_parsed_mount_data *data , rpc_authflavor_t pseudoflavor ) { { data->auth_flavors[0] = pseudoflavor; data->auth_flavor_len = 1U; return; } } static int nfs_parse_security_flavors(char *value , struct nfs_parsed_mount_data *mnt ) { substring_t args[3U] ; rpc_authflavor_t pseudoflavor ; long tmp ; int tmp___0 ; { tmp = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: parsing sec=%s option\n", value); } else { } tmp___0 = match_token(value, (struct match_token const *)(& nfs_secflavor_tokens), (substring_t *)(& args)); switch (tmp___0) { case 0: pseudoflavor = 0U; goto ldv_53482; case 1: pseudoflavor = 1U; goto ldv_53482; case 2: pseudoflavor = 390003U; goto ldv_53482; case 3: pseudoflavor = 390004U; goto ldv_53482; case 4: pseudoflavor = 390005U; goto ldv_53482; case 5: pseudoflavor = 390006U; goto ldv_53482; case 6: pseudoflavor = 390007U; goto ldv_53482; case 7: pseudoflavor = 390008U; goto ldv_53482; case 8: pseudoflavor = 390009U; goto ldv_53482; case 9: pseudoflavor = 390010U; goto ldv_53482; case 10: pseudoflavor = 390011U; goto ldv_53482; default: ; return (0); } ldv_53482: mnt->flags = mnt->flags | 8192; nfs_set_auth_parsed_mount_data(mnt, pseudoflavor); return (1); } } static int nfs_parse_version_string(char *string , struct nfs_parsed_mount_data *mnt , substring_t *args ) { int tmp ; { mnt->flags = mnt->flags & -129; tmp = match_token(string, (struct match_token const *)(& nfs_vers_tokens), args); switch (tmp) { case 0: mnt->version = 2U; goto ldv_53500; case 1: mnt->flags = mnt->flags | 128; mnt->version = 3U; goto ldv_53500; case 2: mnt->version = 4U; goto ldv_53500; case 3: mnt->version = 4U; mnt->minorversion = 0U; goto ldv_53500; case 4: mnt->version = 4U; mnt->minorversion = 1U; goto ldv_53500; case 5: mnt->version = 4U; mnt->minorversion = 2U; goto ldv_53500; default: ; return (0); } ldv_53500: ; return (1); } } static int nfs_get_option_str(substring_t *args , char **option ) { { kfree((void const *)*option); *option = match_strdup((substring_t const *)args); return ((unsigned long )*option == (unsigned long )((char *)0)); } } static int nfs_get_option_ul(substring_t *args , unsigned long *option ) { int rc ; char *string ; { string = match_strdup((substring_t const *)args); if ((unsigned long )string == (unsigned long )((char *)0)) { return (-12); } else { } rc = kstrtoul((char const *)string, 10U, option); kfree((void const *)string); return (rc); } } static int nfs_parse_mount_options(char *raw , struct nfs_parsed_mount_data *mnt ) { char *p ; char *string ; char *secdata ; int rc ; int sloppy ; int invalid_option ; unsigned short protofamily ; unsigned short mountfamily ; long tmp ; long tmp___0 ; substring_t args[3U] ; unsigned long option ; int token ; long tmp___1 ; int tmp___2 ; int tmp___3 ; int tmp___4 ; int tmp___5 ; int tmp___6 ; int tmp___7 ; int tmp___8 ; int tmp___9 ; int tmp___10 ; int tmp___11 ; int tmp___12 ; unsigned int tmp___13 ; unsigned int tmp___14 ; unsigned int tmp___15 ; int tmp___16 ; int tmp___17 ; int tmp___18 ; int tmp___19 ; long tmp___20 ; long tmp___21 ; long tmp___22 ; size_t tmp___23 ; int tmp___24 ; int tmp___25 ; size_t tmp___26 ; long tmp___27 ; int tmp___28 ; long tmp___29 ; long tmp___30 ; long tmp___31 ; long tmp___32 ; { sloppy = 0; invalid_option = 0; protofamily = 0U; mountfamily = 0U; if ((unsigned long )raw == (unsigned long )((char *)0)) { tmp = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: mount options string was NULL.\n"); } else { } return (1); } else { } tmp___0 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001dNFS: nfs mount opts=\'%s\'\n", raw); } else { } secdata = alloc_secdata(); if ((unsigned long )secdata == (unsigned long )((char *)0)) { goto out_nomem; } else { } rc = security_sb_copy_data(raw, secdata); if (rc != 0) { goto out_security_failure; } else { } rc = security_sb_parse_opts_str(secdata, & mnt->lsm_opts); if (rc != 0) { goto out_security_failure; } else { } free_secdata((void *)secdata); goto ldv_53534; ldv_53618: ; if ((int )((signed char )*p) == 0) { goto ldv_53534; } else { } tmp___1 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001dNFS: parsing nfs mount option \'%s\'\n", p); } else { } token = match_token(p, (struct match_token const *)(& nfs_mount_option_tokens), (substring_t *)(& args)); switch (token) { case 0: mnt->flags = mnt->flags | 1; goto ldv_53536; case 1: mnt->flags = mnt->flags & -2; goto ldv_53536; case 2: mnt->flags = mnt->flags | 8; goto ldv_53536; case 3: mnt->flags = mnt->flags & -9; goto ldv_53536; case 4: mnt->flags = mnt->flags & -17; goto ldv_53536; case 5: mnt->flags = mnt->flags | 16; goto ldv_53536; case 6: mnt->flags = mnt->flags & -33; goto ldv_53536; case 7: mnt->flags = mnt->flags | 32; goto ldv_53536; case 8: mnt->flags = mnt->flags & -513; mnt->flags = mnt->flags & -3145729; goto ldv_53536; case 9: mnt->flags = mnt->flags | 512; mnt->flags = mnt->flags | 3145728; goto ldv_53536; case 10: mnt->flags = mnt->flags & -65; mnt->nfs_server.protocol = 17U; goto ldv_53536; case 11: mnt->flags = mnt->flags | 64; mnt->nfs_server.protocol = 6U; goto ldv_53536; case 12: mnt->flags = mnt->flags | 64; mnt->nfs_server.protocol = 256U; xprt_load_transport((char const *)p); goto ldv_53536; case 13: mnt->flags = mnt->flags & -2049; goto ldv_53536; case 14: mnt->flags = mnt->flags | 2048; goto ldv_53536; case 15: mnt->flags = mnt->flags & -16385; goto ldv_53536; case 16: mnt->flags = mnt->flags | 16384; goto ldv_53536; case 17: mnt->flags = mnt->flags & -32769; goto ldv_53536; case 18: mnt->flags = mnt->flags | 32768; goto ldv_53536; case 19: mnt->flags = mnt->flags & -262145; goto ldv_53536; case 20: mnt->flags = mnt->flags | 262144; goto ldv_53536; case 21: mnt->options = mnt->options | 1U; kfree((void const *)mnt->fscache_uniq); mnt->fscache_uniq = (char *)0; goto ldv_53536; case 22: mnt->options = mnt->options & 4294967294U; kfree((void const *)mnt->fscache_uniq); mnt->fscache_uniq = (char *)0; goto ldv_53536; case 23: mnt->options = mnt->options | 2U; goto ldv_53536; case 24: mnt->options = mnt->options & 2U; goto ldv_53536; case 25: tmp___2 = nfs_get_option_ul((substring_t *)(& args), & option); if (tmp___2 != 0 || option > 65535UL) { goto out_invalid_value; } else { } mnt->nfs_server.port = (int )option; goto ldv_53536; case 26: tmp___3 = nfs_get_option_ul((substring_t *)(& args), & option); if (tmp___3 != 0) { goto out_invalid_value; } else { } mnt->rsize = (unsigned int )option; goto ldv_53536; case 27: tmp___4 = nfs_get_option_ul((substring_t *)(& args), & option); if (tmp___4 != 0) { goto out_invalid_value; } else { } mnt->wsize = (unsigned int )option; goto ldv_53536; case 28: tmp___5 = nfs_get_option_ul((substring_t *)(& args), & option); if (tmp___5 != 0) { goto out_invalid_value; } else { } mnt->bsize = (unsigned int )option; goto ldv_53536; case 29: tmp___6 = nfs_get_option_ul((substring_t *)(& args), & option); if (tmp___6 != 0 || option == 0UL) { goto out_invalid_value; } else { } mnt->timeo = (unsigned int )option; goto ldv_53536; case 30: tmp___7 = nfs_get_option_ul((substring_t *)(& args), & option); if (tmp___7 != 0 || option == 0UL) { goto out_invalid_value; } else { } mnt->retrans = (unsigned int )option; goto ldv_53536; case 31: tmp___8 = nfs_get_option_ul((substring_t *)(& args), & option); if (tmp___8 != 0) { goto out_invalid_value; } else { } mnt->acregmin = (unsigned int )option; goto ldv_53536; case 32: tmp___9 = nfs_get_option_ul((substring_t *)(& args), & option); if (tmp___9 != 0) { goto out_invalid_value; } else { } mnt->acregmax = (unsigned int )option; goto ldv_53536; case 33: tmp___10 = nfs_get_option_ul((substring_t *)(& args), & option); if (tmp___10 != 0) { goto out_invalid_value; } else { } mnt->acdirmin = (unsigned int )option; goto ldv_53536; case 34: tmp___11 = nfs_get_option_ul((substring_t *)(& args), & option); if (tmp___11 != 0) { goto out_invalid_value; } else { } mnt->acdirmax = (unsigned int )option; goto ldv_53536; case 35: tmp___12 = nfs_get_option_ul((substring_t *)(& args), & option); if (tmp___12 != 0) { goto out_invalid_value; } else { } tmp___15 = (unsigned int )option; mnt->acdirmax = tmp___15; tmp___14 = tmp___15; mnt->acdirmin = tmp___14; tmp___13 = tmp___14; mnt->acregmax = tmp___13; mnt->acregmin = tmp___13; goto ldv_53536; case 36: tmp___16 = nfs_get_option_ul((substring_t *)(& args), & option); if (tmp___16 != 0) { goto out_invalid_value; } else { } mnt->namlen = (unsigned int )option; goto ldv_53536; case 37: tmp___17 = nfs_get_option_ul((substring_t *)(& args), & option); if (tmp___17 != 0 || option > 65535UL) { goto out_invalid_value; } else { } mnt->mount_server.port = (int )option; goto ldv_53536; case 38: tmp___18 = nfs_get_option_ul((substring_t *)(& args), & option); if ((tmp___18 != 0 || option == 0UL) || option > 3UL) { goto out_invalid_value; } else { } mnt->mount_server.version = (u32 )option; goto ldv_53536; case 39: tmp___19 = nfs_get_option_ul((substring_t *)(& args), & option); if (tmp___19 != 0) { goto out_invalid_value; } else { } if (option > 2UL) { goto out_invalid_value; } else { } mnt->minorversion = (unsigned int )option; goto ldv_53536; case 40: string = match_strdup((substring_t const *)(& args)); if ((unsigned long )string == (unsigned long )((char *)0)) { goto out_nomem; } else { } rc = nfs_parse_version_string(string, mnt, (substring_t *)(& args)); kfree((void const *)string); if (rc == 0) { goto out_invalid_value; } else { } goto ldv_53536; case 41: string = match_strdup((substring_t const *)(& args)); if ((unsigned long )string == (unsigned long )((char *)0)) { goto out_nomem; } else { } rc = nfs_parse_security_flavors(string, mnt); kfree((void const *)string); if (rc == 0) { tmp___20 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___20 != 0L) { printk("\001dNFS: unrecognized security flavor\n"); } else { } return (0); } else { } goto ldv_53536; case 42: string = match_strdup((substring_t const *)(& args)); if ((unsigned long )string == (unsigned long )((char *)0)) { goto out_nomem; } else { } token = match_token(string, (struct match_token const *)(& nfs_xprt_protocol_tokens), (substring_t *)(& args)); protofamily = 2U; switch (token) { case 1: protofamily = 10U; case 0: mnt->flags = mnt->flags & -65; mnt->nfs_server.protocol = 17U; goto ldv_53582; case 3: protofamily = 10U; case 2: mnt->flags = mnt->flags | 64; mnt->nfs_server.protocol = 6U; goto ldv_53582; case 4: mnt->flags = mnt->flags | 64; mnt->nfs_server.protocol = 256U; xprt_load_transport((char const *)string); goto ldv_53582; default: tmp___21 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___21 != 0L) { printk("\001dNFS: unrecognized transport protocol\n"); } else { } kfree((void const *)string); return (0); } ldv_53582: kfree((void const *)string); goto ldv_53536; case 43: string = match_strdup((substring_t const *)(& args)); if ((unsigned long )string == (unsigned long )((char *)0)) { goto out_nomem; } else { } token = match_token(string, (struct match_token const *)(& nfs_xprt_protocol_tokens), (substring_t *)(& args)); kfree((void const *)string); mountfamily = 2U; switch (token) { case 1: mountfamily = 10U; case 0: mnt->mount_server.protocol = 17U; goto ldv_53590; case 3: mountfamily = 10U; case 2: mnt->mount_server.protocol = 6U; goto ldv_53590; case 4: ; default: tmp___22 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___22 != 0L) { printk("\001dNFS: unrecognized transport protocol\n"); } else { } return (0); } ldv_53590: ; goto ldv_53536; case 45: string = match_strdup((substring_t const *)(& args)); if ((unsigned long )string == (unsigned long )((char *)0)) { goto out_nomem; } else { } tmp___23 = strlen((char const *)string); mnt->nfs_server.addrlen = rpc_pton(mnt->net, (char const *)string, tmp___23, (struct sockaddr *)(& mnt->nfs_server.address), 128UL); kfree((void const *)string); if (mnt->nfs_server.addrlen == 0UL) { goto out_invalid_address; } else { } goto ldv_53536; case 47: tmp___24 = nfs_get_option_str((substring_t *)(& args), & mnt->client_address); if (tmp___24 != 0) { goto out_nomem; } else { } goto ldv_53536; case 44: tmp___25 = nfs_get_option_str((substring_t *)(& args), & mnt->mount_server.hostname); if (tmp___25 != 0) { goto out_nomem; } else { } goto ldv_53536; case 46: string = match_strdup((substring_t const *)(& args)); if ((unsigned long )string == (unsigned long )((char *)0)) { goto out_nomem; } else { } tmp___26 = strlen((char const *)string); mnt->mount_server.addrlen = rpc_pton(mnt->net, (char const *)string, tmp___26, (struct sockaddr *)(& mnt->mount_server.address), 128UL); kfree((void const *)string); if (mnt->mount_server.addrlen == 0UL) { goto out_invalid_address; } else { } goto ldv_53536; case 48: string = match_strdup((substring_t const *)(& args)); if ((unsigned long )string == (unsigned long )((char *)0)) { goto out_nomem; } else { } token = match_token(string, (struct match_token const *)(& nfs_lookupcache_tokens), (substring_t *)(& args)); kfree((void const *)string); switch (token) { case 0: mnt->flags = mnt->flags & -196609; goto ldv_53602; case 1: mnt->flags = mnt->flags & -131073; mnt->flags = mnt->flags | 65536; goto ldv_53602; case 2: mnt->flags = mnt->flags | 196608; goto ldv_53602; default: tmp___27 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___27 != 0L) { printk("\001dNFS: invalid lookupcache argument\n"); } else { } return (0); } ldv_53602: ; goto ldv_53536; case 49: tmp___28 = nfs_get_option_str((substring_t *)(& args), & mnt->fscache_uniq); if (tmp___28 != 0) { goto out_nomem; } else { } mnt->options = mnt->options | 1U; goto ldv_53536; case 50: string = match_strdup((substring_t const *)(& args)); if ((unsigned long )string == (unsigned long )((char *)0)) { goto out_nomem; } else { } token = match_token(string, (struct match_token const *)(& nfs_local_lock_tokens), (substring_t *)(& args)); kfree((void const *)string); switch (token) { case 0: mnt->flags = mnt->flags | 3145728; goto ldv_53609; case 1: mnt->flags = mnt->flags | 1048576; goto ldv_53609; case 2: mnt->flags = mnt->flags | 2097152; goto ldv_53609; case 3: mnt->flags = mnt->flags & -3145729; goto ldv_53609; default: tmp___29 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___29 != 0L) { printk("\001dNFS:\tinvalid\tlocal_lock argument\n"); } else { } return (0); } ldv_53609: ; goto ldv_53536; case 53: sloppy = 1; tmp___30 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___30 != 0L) { printk("\001dNFS: relaxing parsing rules\n"); } else { } goto ldv_53536; case 51: ; case 52: tmp___31 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___31 != 0L) { printk("\001dNFS: ignoring mount option \'%s\'\n", p); } else { } goto ldv_53536; default: invalid_option = 1; tmp___32 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___32 != 0L) { printk("\001dNFS: unrecognized mount option \'%s\'\n", p); } else { } } ldv_53536: ; ldv_53534: p = strsep(& raw, ","); if ((unsigned long )p != (unsigned long )((char *)0)) { goto ldv_53618; } else { } if (sloppy == 0 && invalid_option != 0) { return (0); } else { } if (mnt->minorversion != 0U && mnt->version != 4U) { goto out_minorversion_mismatch; } else { } if (((mnt->options & 2U) != 0U && mnt->version != 4U) && mnt->minorversion != 0U) { goto out_migration_misuse; } else { } if ((unsigned int )protofamily != 0U && (int )mnt->nfs_server.address.ss_family != (int )protofamily) { goto out_proto_mismatch; } else { } if ((unsigned int )mountfamily != 0U) { if (mnt->mount_server.addrlen != 0UL) { if ((int )mnt->mount_server.address.ss_family != (int )mountfamily) { goto out_mountproto_mismatch; } else { } } else if ((int )mnt->nfs_server.address.ss_family != (int )mountfamily) { goto out_mountproto_mismatch; } else { } } else { } return (1); out_mountproto_mismatch: printk("\016NFS: mount server address does not match mountproto= option\n"); return (0); out_proto_mismatch: printk("\016NFS: server address does not match proto= option\n"); return (0); out_invalid_address: printk("\016NFS: bad IP address specified: %s\n", p); return (0); out_invalid_value: printk("\016NFS: bad mount option value specified: %s\n", p); return (0); out_minorversion_mismatch: printk("\016NFS: mount option vers=%u does not support minorversion=%u\n", mnt->version, mnt->minorversion); return (0); out_migration_misuse: printk("\016NFS: \'migration\' not supported for this NFS version\n"); return (0); out_nomem: printk("\016NFS: not enough memory to parse option\n"); return (0); out_security_failure: free_secdata((void *)secdata); printk("\016NFS: security options invalid: %d\n", rc); return (0); } } static int nfs_verify_authflavor(struct nfs_parsed_mount_data *args , rpc_authflavor_t *server_authlist , unsigned int count ) { unsigned int i ; long tmp ; long tmp___0 ; { i = 0U; goto ldv_53632; ldv_53631: ; if (args->auth_flavors[0] == *(server_authlist + (unsigned long )i) || *(server_authlist + (unsigned long )i) == 0U) { goto out; } else { } i = i + 1U; ldv_53632: ; if (i < count) { goto ldv_53631; } else { } tmp = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: auth flavor %u not supported by server\n", args->auth_flavors[0]); } else { } return (-13); out: tmp___0 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001dNFS: using auth flavor %u\n", args->auth_flavors[0]); } else { } return (0); } } static int nfs_request_mount(struct nfs_parsed_mount_data *args , struct nfs_fh *root_fh , rpc_authflavor_t *server_authlist , unsigned int *server_authlist_len ) { struct nfs_mount_request request ; int status ; size_t __len ; void *__ret ; long tmp ; { request.sap = (struct sockaddr *)(& args->mount_server.address); request.salen = 0UL; request.hostname = 0; request.dirpath = args->nfs_server.export_path; request.version = 0U; request.protocol = args->mount_server.protocol; request.fh = root_fh; request.noresvport = args->flags & 262144; request.auth_flav_len = server_authlist_len; request.auth_flavs = server_authlist; request.net = args->net; if (args->mount_server.version == 0U) { switch (args->version) { default: args->mount_server.version = 3U; goto ldv_53643; case 2U: args->mount_server.version = 1U; } ldv_53643: ; } else { } request.version = args->mount_server.version; if ((unsigned long )args->mount_server.hostname != (unsigned long )((char *)0)) { request.hostname = args->mount_server.hostname; } else { request.hostname = args->nfs_server.hostname; } if ((unsigned int )args->mount_server.address.ss_family == 0U) { __len = args->nfs_server.addrlen; __ret = __builtin_memcpy((void *)request.sap, (void const *)(& args->nfs_server.address), __len); args->mount_server.addrlen = args->nfs_server.addrlen; } else { } request.salen = args->mount_server.addrlen; nfs_set_port(request.sap, & args->mount_server.port, 0); status = nfs_mount(& request); if (status != 0) { tmp = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: unable to mount server %s, error %d\n", request.hostname, status); } else { } return (status); } else { } return (0); } } static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_info , struct nfs_subversion *nfs_mod ) { int status ; unsigned int i ; bool tried_auth_unix ; bool auth_null_in_list ; struct nfs_server *server ; void *tmp ; struct nfs_parsed_mount_data *args ; rpc_authflavor_t authlist[12U] ; unsigned int authlist_len ; void *tmp___0 ; long tmp___1 ; void *tmp___2 ; struct nfs_server *tmp___3 ; rpc_authflavor_t flavor ; struct rpcsec_gss_info info ; int tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; struct nfs_server *tmp___8 ; { tried_auth_unix = 0; auth_null_in_list = 0; tmp = ERR_PTR(-13L); server = (struct nfs_server *)tmp; args = mount_info->parsed; authlist_len = 12U; status = nfs_request_mount(args, mount_info->mntfh, (rpc_authflavor_t *)(& authlist), & authlist_len); if (status != 0) { tmp___0 = ERR_PTR((long )status); return ((struct nfs_server *)tmp___0); } else { } if (args->auth_flavor_len != 0U) { status = nfs_verify_authflavor(args, (rpc_authflavor_t *)(& authlist), authlist_len); tmp___1 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001dNFS: using auth flavor %u\n", args->auth_flavors[0]); } else { } if (status != 0) { tmp___2 = ERR_PTR((long )status); return ((struct nfs_server *)tmp___2); } else { } tmp___3 = (*((nfs_mod->rpc_ops)->create_server))(mount_info, nfs_mod); return (tmp___3); } else { } i = 0U; goto ldv_53670; ldv_53669: flavor = authlist[i]; switch (flavor) { case 1U: tried_auth_unix = 1; goto ldv_53665; case 0U: auth_null_in_list = 1; goto ldv_53667; default: tmp___4 = rpcauth_get_gssinfo(flavor, & info); if (tmp___4 != 0) { goto ldv_53667; } else { } } ldv_53665: tmp___5 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___5 != 0L) { printk("\001dNFS: attempting to use auth flavor %u\n", flavor); } else { } nfs_set_auth_parsed_mount_data(args, flavor); server = (*((nfs_mod->rpc_ops)->create_server))(mount_info, nfs_mod); tmp___6 = IS_ERR((void const *)server); if (tmp___6 == 0L) { return (server); } else { } ldv_53667: i = i + 1U; ldv_53670: ; if (i < authlist_len) { goto ldv_53669; } else { } if ((int )tried_auth_unix || ! auth_null_in_list) { return (server); } else { } tmp___7 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___7 != 0L) { printk("\001dNFS: attempting to use auth flavor %u\n", 1); } else { } nfs_set_auth_parsed_mount_data(args, 1U); tmp___8 = (*((nfs_mod->rpc_ops)->create_server))(mount_info, nfs_mod); return (tmp___8); } } struct dentry *nfs_try_mount(int flags , char const *dev_name___0 , struct nfs_mount_info *mount_info , struct nfs_subversion *nfs_mod ) { struct nfs_server *server ; void *tmp ; long tmp___0 ; struct dentry *tmp___1 ; { if ((int )(mount_info->parsed)->need_mount) { server = nfs_try_mount_request(mount_info, nfs_mod); } else { server = (*((nfs_mod->rpc_ops)->create_server))(mount_info, nfs_mod); } tmp___0 = IS_ERR((void const *)server); if (tmp___0 != 0L) { tmp = ERR_CAST((void const *)server); return ((struct dentry *)tmp); } else { } tmp___1 = nfs_fs_mount_common(server, flags, dev_name___0, mount_info, nfs_mod); return (tmp___1); } } static int nfs_parse_devname(char const *dev_name___0 , char **hostname , size_t maxnamlen , char **export_path , size_t maxpathlen ) { size_t len ; char *end ; char *comma ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; { if ((int )((signed char )*dev_name___0) == 91) { dev_name___0 = dev_name___0 + 1; end = strchr(dev_name___0, 93); if ((unsigned long )end == (unsigned long )((char *)0) || (int )((signed char )*(end + 1UL)) != 58) { goto out_bad_devname; } else { } len = (size_t )((long )end - (long )dev_name___0); end = end + 1; } else { end = strchr(dev_name___0, 58); if ((unsigned long )end == (unsigned long )((char *)0)) { goto out_bad_devname; } else { } len = (size_t )((long )end - (long )dev_name___0); comma = strchr(dev_name___0, 44); if ((unsigned long )comma != (unsigned long )((char *)0) && (unsigned long )comma < (unsigned long )end) { *comma = 0; } else { } } if (len > maxnamlen) { goto out_hostname; } else { } *hostname = kstrndup(dev_name___0, len, 208U); if ((unsigned long )*hostname == (unsigned long )((char *)0)) { goto out_nomem; } else { } end = end + 1; len = strlen((char const *)end); if (len > maxpathlen) { goto out_path; } else { } *export_path = kstrndup((char const *)end, len, 208U); if ((unsigned long )*export_path == (unsigned long )((char *)0)) { goto out_nomem; } else { } tmp = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: MNTPATH: \'%s\'\n", *export_path); } else { } return (0); out_bad_devname: tmp___0 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001dNFS: device name not in host:path format\n"); } else { } return (-22); out_nomem: tmp___1 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001dNFS: not enough memory to parse device name\n"); } else { } return (-12); out_hostname: tmp___2 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___2 != 0L) { printk("\001dNFS: server hostname too long\n"); } else { } return (-36); out_path: tmp___3 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___3 != 0L) { printk("\001dNFS: export pathname too long\n"); } else { } return (-36); } } static int nfs23_validate_mount_data(void *options , struct nfs_parsed_mount_data *args , struct nfs_fh *mntfh , char const *dev_name___0 ) { struct nfs_mount_data *data ; struct sockaddr *sap ; int extra_flags ; size_t __len ; void *__ret ; size_t __len___0 ; void *__ret___0 ; size_t __len___1 ; void *__ret___1 ; __u16 tmp ; int tmp___0 ; int rc ; char *opts_str ; void *tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; { data = (struct nfs_mount_data *)options; sap = (struct sockaddr *)(& args->nfs_server.address); extra_flags = 524288; if ((unsigned long )data == (unsigned long )((struct nfs_mount_data *)0)) { goto out_no_data; } else { } args->version = 3U; switch (data->version) { case 1: data->namlen = 0; case 2: data->bsize = 0U; case 3: ; if ((data->flags & 128) != 0) { goto out_no_v3; } else { } data->root.size = 32U; __len = 32UL; if (__len > 63UL) { __ret = __memcpy((void *)(& data->root.data), (void const *)(& data->old_root.data), __len); } else { __ret = __builtin_memcpy((void *)(& data->root.data), (void const *)(& data->old_root.data), __len); } extra_flags = extra_flags | 8192; case 4: ; if ((data->flags & 8192) != 0) { goto out_no_sec; } else { } case 5: memset((void *)(& data->context), 0, 257UL); case 6: ; if ((data->flags & 128) != 0) { if ((unsigned int )data->root.size > 64U || (unsigned int )data->root.size == 0U) { goto out_invalid_fh; } else { } mntfh->size = data->root.size; args->version = 3U; } else { mntfh->size = 32U; args->version = 2U; } __len___0 = (size_t )mntfh->size; __ret___0 = __builtin_memcpy((void *)(& mntfh->data), (void const *)(& data->root.data), __len___0); if ((unsigned int )mntfh->size <= 127U) { memset((void *)(& mntfh->data) + (unsigned long )mntfh->size, 0, 128UL - (unsigned long )mntfh->size); } else { } args->flags = data->flags & 65535; args->flags = args->flags | extra_flags; args->rsize = (unsigned int )data->rsize; args->wsize = (unsigned int )data->wsize; args->timeo = (unsigned int )data->timeo; args->retrans = (unsigned int )data->retrans; args->acregmin = (unsigned int )data->acregmin; args->acregmax = (unsigned int )data->acregmax; args->acdirmin = (unsigned int )data->acdirmin; args->acdirmax = (unsigned int )data->acdirmax; args->need_mount = 0; __len___1 = 16UL; if (__len___1 > 63UL) { __ret___1 = __memcpy((void *)sap, (void const *)(& data->addr), __len___1); } else { __ret___1 = __builtin_memcpy((void *)sap, (void const *)(& data->addr), __len___1); } args->nfs_server.addrlen = 16UL; tmp = __fswab16((int )data->addr.sin_port); args->nfs_server.port = (int )tmp; tmp___0 = nfs_verify_server_address(sap); if (tmp___0 == 0) { goto out_no_address; } else { } if ((data->flags & 64) == 0) { args->nfs_server.protocol = 17U; } else { } args->nfs_server.hostname = kstrdup((char const *)(& data->hostname), 208U); args->namlen = (unsigned int )data->namlen; args->bsize = data->bsize; if ((data->flags & 8192) != 0) { nfs_set_auth_parsed_mount_data(args, (rpc_authflavor_t )data->pseudoflavor); } else { nfs_set_auth_parsed_mount_data(args, 1U); } if ((unsigned long )args->nfs_server.hostname == (unsigned long )((char *)0)) { goto out_nomem; } else { } if ((data->flags & 512) == 0) { args->flags = args->flags & -3145729; } else { args->flags = args->flags | 3145728; } if ((int )((signed char )data->context[0]) != 0) { tmp___1 = kmalloc(265UL, 208U); opts_str = (char *)tmp___1; if ((unsigned long )opts_str == (unsigned long )((char *)0)) { return (-12); } else { } strcpy(opts_str, "context="); data->context[256] = 0; strcat(opts_str, (char const *)(& data->context)); rc = security_sb_parse_opts_str(opts_str, & args->lsm_opts); kfree((void const *)opts_str); if (rc != 0) { return (rc); } else { } } else { } goto ldv_53734; default: ; return (1); } ldv_53734: ; return (0); out_no_data: tmp___2 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___2 != 0L) { printk("\001dNFS: mount program didn\'t pass any mount data\n"); } else { } return (-22); out_no_v3: tmp___3 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___3 != 0L) { printk("\001dNFS: nfs_mount_data version %d does not support v3\n", data->version); } else { } return (-22); out_no_sec: tmp___4 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___4 != 0L) { printk("\001dNFS: nfs_mount_data version supports only AUTH_SYS\n"); } else { } return (-22); out_nomem: tmp___5 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___5 != 0L) { printk("\001dNFS: not enough memory to handle mount options\n"); } else { } return (-12); out_no_address: tmp___6 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___6 != 0L) { printk("\001dNFS: mount program didn\'t pass remote address\n"); } else { } return (-22); out_invalid_fh: tmp___7 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___7 != 0L) { printk("\001dNFS: invalid root filehandle\n"); } else { } return (-22); } } static int nfs_validate_mount_data(struct file_system_type *fs_type , void *options , struct nfs_parsed_mount_data *args , struct nfs_fh *mntfh , char const *dev_name___0 ) { int tmp ; int tmp___0 ; { if ((unsigned long )fs_type == (unsigned long )(& nfs_fs_type)) { tmp = nfs23_validate_mount_data(options, args, mntfh, dev_name___0); return (tmp); } else { } tmp___0 = nfs4_validate_mount_data(options, args, dev_name___0); return (tmp___0); } } static int nfs_validate_text_mount_data(void *options , struct nfs_parsed_mount_data *args , char const *dev_name___0 ) { int port ; int max_namelen ; int max_pathlen ; struct sockaddr *sap ; int tmp ; int tmp___0 ; int tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; { port = 0; max_namelen = 4096; max_pathlen = 1024; sap = (struct sockaddr *)(& args->nfs_server.address); tmp = nfs_parse_mount_options((char *)options, args); if (tmp == 0) { return (-22); } else { } tmp___0 = nfs_verify_server_address(sap); if (tmp___0 == 0) { goto out_no_address; } else { } if (args->version == 4U) { port = 2049; max_namelen = 255; max_pathlen = 4096; nfs_validate_transport_protocol(args); if ((unsigned int )args->nfs_server.protocol == 17U) { goto out_invalid_transport_udp; } else { } nfs4_validate_mount_flags(args); } else { nfs_set_mount_transport_protocol(args); } nfs_set_port(sap, & args->nfs_server.port, (int )((unsigned short const )port)); if (args->auth_flavor_len > 1U) { goto out_bad_auth; } else { } tmp___1 = nfs_parse_devname(dev_name___0, & args->nfs_server.hostname, (size_t )max_namelen, & args->nfs_server.export_path, (size_t )max_pathlen); return (tmp___1); out_invalid_transport_udp: tmp___2 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___2 != 0L) { printk("\001dNFSv4: Unsupported transport protocol udp\n"); } else { } return (-22); out_no_address: tmp___3 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___3 != 0L) { printk("\001dNFS: mount program didn\'t pass remote address\n"); } else { } return (-22); out_bad_auth: tmp___4 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___4 != 0L) { printk("\001dNFS: Too many RPC auth flavours specified\n"); } else { } return (-22); } } static int nfs_compare_remount_data(struct nfs_server *nfss , struct nfs_parsed_mount_data *data ) { bool tmp ; int tmp___0 ; { if (((((((((((data->flags != nfss->flags || data->rsize != nfss->rsize) || data->wsize != nfss->wsize) || data->retrans != (unsigned int )((nfss->client)->cl_timeout)->to_retries) || data->auth_flavors[0] != ((nfss->client)->cl_auth)->au_flavor) || data->acregmin != nfss->acregmin / 250U) || data->acregmax != nfss->acregmax / 250U) || data->acdirmin != nfss->acdirmin / 250U) || data->acdirmax != nfss->acdirmax / 250U) || (unsigned long )data->timeo != ((unsigned long )((nfss->client)->cl_timeout)->to_initval * 10UL) / 250UL) || data->nfs_server.port != (int )nfss->port) || data->nfs_server.addrlen != (nfss->nfs_client)->cl_addrlen) { return (-22); } else { tmp = rpc_cmp_addr((struct sockaddr const *)(& data->nfs_server.address), (struct sockaddr const *)(& (nfss->nfs_client)->cl_addr)); if (tmp) { tmp___0 = 0; } else { tmp___0 = 1; } if (tmp___0) { return (-22); } else { } } return (0); } } int nfs_remount(struct super_block *sb , int *flags , char *raw_data ) { int error ; struct nfs_server *nfss ; struct nfs_parsed_mount_data *data ; struct nfs_mount_data *options ; struct nfs4_mount_data *options4 ; u32 nfsvers ; void *tmp ; size_t __len ; void *__ret ; { nfss = (struct nfs_server *)sb->s_fs_info; options = (struct nfs_mount_data *)raw_data; options4 = (struct nfs4_mount_data *)raw_data; nfsvers = ((nfss->nfs_client)->rpc_ops)->version; if ((nfsvers == 4U && ((unsigned long )options4 == (unsigned long )((struct nfs4_mount_data *)0) || options4->version == 1)) || (nfsvers <= 3U && ((unsigned long )options == (unsigned long )((struct nfs_mount_data *)0) || (options->version > 0 && options->version <= 6)))) { return (0); } else { } tmp = kzalloc(440UL, 208U); data = (struct nfs_parsed_mount_data *)tmp; if ((unsigned long )data == (unsigned long )((struct nfs_parsed_mount_data *)0)) { return (-12); } else { } data->flags = nfss->flags; data->rsize = nfss->rsize; data->wsize = nfss->wsize; data->retrans = ((nfss->client)->cl_timeout)->to_retries; nfs_set_auth_parsed_mount_data(data, ((nfss->client)->cl_auth)->au_flavor); data->acregmin = nfss->acregmin / 250U; data->acregmax = nfss->acregmax / 250U; data->acdirmin = nfss->acdirmin / 250U; data->acdirmax = nfss->acdirmax / 250U; data->timeo = (unsigned int )(((unsigned long )((nfss->client)->cl_timeout)->to_initval * 10UL) / 250UL); data->nfs_server.port = (int )nfss->port; data->nfs_server.addrlen = (nfss->nfs_client)->cl_addrlen; __len = data->nfs_server.addrlen; __ret = __builtin_memcpy((void *)(& data->nfs_server.address), (void const *)(& (nfss->nfs_client)->cl_addr), __len); error = nfs_parse_mount_options((char *)options, data); if (error < 0) { goto out; } else { } if ((data->flags & 32) != 0) { *flags = *flags | 16; } else { } error = nfs_compare_remount_data(nfss, data); out: kfree((void const *)data); return (error); } } __inline void nfs_initialise_sb(struct super_block *sb ) { struct nfs_server *server ; struct nfs_server *tmp ; { tmp = NFS_SB((struct super_block const *)sb); server = tmp; sb->s_magic = 26985UL; snprintf((char *)(& sb->s_id), 32UL, "%u:%u", sb->s_dev >> 20, sb->s_dev & 1048575U); if (sb->s_blocksize == 0UL) { sb->s_blocksize = nfs_block_bits___0((unsigned long )server->wsize, & sb->s_blocksize_bits); } else { } sb->s_bdi = & server->backing_dev_info; nfs_super_set_maxbytes(sb, server->maxfilesize); return; } } void nfs_fill_super(struct super_block *sb , struct nfs_mount_info *mount_info ) { struct nfs_parsed_mount_data *data ; struct nfs_server *server ; struct nfs_server *tmp ; { data = mount_info->parsed; tmp = NFS_SB((struct super_block const *)sb); server = tmp; sb->s_blocksize_bits = 0U; sb->s_blocksize = 0UL; sb->s_xattr = ((server->nfs_client)->cl_nfs_mod)->xattr; sb->s_op = ((server->nfs_client)->cl_nfs_mod)->sops; if ((unsigned long )data != (unsigned long )((struct nfs_parsed_mount_data *)0) && data->bsize != 0U) { sb->s_blocksize = nfs_block_size___0((unsigned long )data->bsize, & sb->s_blocksize_bits); } else { } if ((unsigned int )((server->nfs_client)->rpc_ops)->version != 2U) { sb->s_flags = sb->s_flags | 65536UL; sb->s_time_gran = 1U; } else { } nfs_initialise_sb(sb); return; } } void nfs_clone_super(struct super_block *sb , struct nfs_mount_info *mount_info ) { struct super_block const *old_sb ; struct nfs_server *server ; struct nfs_server *tmp ; { old_sb = (mount_info->cloned)->sb; tmp = NFS_SB((struct super_block const *)sb); server = tmp; sb->s_blocksize_bits = old_sb->s_blocksize_bits; sb->s_blocksize = old_sb->s_blocksize; sb->s_maxbytes = old_sb->s_maxbytes; sb->s_xattr = old_sb->s_xattr; sb->s_op = old_sb->s_op; sb->s_time_gran = 1U; if ((unsigned int )((server->nfs_client)->rpc_ops)->version != 2U) { sb->s_flags = sb->s_flags | 65536UL; } else { } nfs_initialise_sb(sb); return; } } static int nfs_compare_mount_options(struct super_block const *s , struct nfs_server const *b , int flags ) { struct nfs_server const *a ; struct rpc_clnt const *clnt_a ; struct rpc_clnt const *clnt_b ; { a = (struct nfs_server const *)s->s_fs_info; clnt_a = (struct rpc_clnt const *)a->client; clnt_b = (struct rpc_clnt const *)b->client; if ((((unsigned long )s->s_flags ^ (unsigned long )flags) & 31UL) != 0UL) { goto Ebusy; } else { } if ((unsigned long )a->nfs_client != (unsigned long )b->nfs_client) { goto Ebusy; } else { } if ((((int )a->flags ^ (int )b->flags) & -825287) != 0) { goto Ebusy; } else { } if ((unsigned int )a->wsize != (unsigned int )b->wsize) { goto Ebusy; } else { } if ((unsigned int )a->rsize != (unsigned int )b->rsize) { goto Ebusy; } else { } if ((unsigned int )a->acregmin != (unsigned int )b->acregmin) { goto Ebusy; } else { } if ((unsigned int )a->acregmax != (unsigned int )b->acregmax) { goto Ebusy; } else { } if ((unsigned int )a->acdirmin != (unsigned int )b->acdirmin) { goto Ebusy; } else { } if ((unsigned int )a->acdirmax != (unsigned int )b->acdirmax) { goto Ebusy; } else { } if (((int )b->flags & 8192) != 0 && (clnt_a->cl_auth)->au_flavor != (clnt_b->cl_auth)->au_flavor) { goto Ebusy; } else { } return (1); Ebusy: ; return (0); } } static int nfs_set_super(struct super_block *s , void *data ) { struct nfs_sb_mountdata *sb_mntdata ; struct nfs_server *server ; int ret ; { sb_mntdata = (struct nfs_sb_mountdata *)data; server = sb_mntdata->server; s->s_flags = (unsigned long )sb_mntdata->mntflags; s->s_fs_info = (void *)server; s->s_d_op = ((server->nfs_client)->rpc_ops)->dentry_ops; ret = set_anon_super(s, (void *)server); if (ret == 0) { server->s_dev = s->s_dev; } else { } return (ret); } } static int nfs_compare_super_address(struct nfs_server *server1 , struct nfs_server *server2 ) { struct sockaddr *sap1 ; struct sockaddr *sap2 ; struct sockaddr_in *sin1 ; struct sockaddr_in *sin2 ; struct sockaddr_in6 *sin1___0 ; struct sockaddr_in6 *sin2___0 ; bool tmp ; int tmp___0 ; { sap1 = (struct sockaddr *)(& (server1->nfs_client)->cl_addr); sap2 = (struct sockaddr *)(& (server2->nfs_client)->cl_addr); if ((int )sap1->sa_family != (int )sap2->sa_family) { return (0); } else { } switch ((int )sap1->sa_family) { case 2: sin1 = (struct sockaddr_in *)sap1; sin2 = (struct sockaddr_in *)sap2; if (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr) { return (0); } else { } if ((int )sin1->sin_port != (int )sin2->sin_port) { return (0); } else { } goto ldv_53833; case 10: sin1___0 = (struct sockaddr_in6 *)sap1; sin2___0 = (struct sockaddr_in6 *)sap2; tmp = ipv6_addr_equal((struct in6_addr const *)(& sin1___0->sin6_addr), (struct in6_addr const *)(& sin2___0->sin6_addr)); if (tmp) { tmp___0 = 0; } else { tmp___0 = 1; } if (tmp___0) { return (0); } else { } if ((int )sin1___0->sin6_port != (int )sin2___0->sin6_port) { return (0); } else { } goto ldv_53833; default: ; return (0); } ldv_53833: ; return (1); } } static int nfs_compare_super(struct super_block *sb , void *data ) { struct nfs_sb_mountdata *sb_mntdata ; struct nfs_server *server ; struct nfs_server *old ; struct nfs_server *tmp ; int mntflags ; int tmp___0 ; int tmp___1 ; int tmp___2 ; { sb_mntdata = (struct nfs_sb_mountdata *)data; server = sb_mntdata->server; tmp = NFS_SB((struct super_block const *)sb); old = tmp; mntflags = sb_mntdata->mntflags; tmp___0 = nfs_compare_super_address(old, server); if (tmp___0 == 0) { return (0); } else { } if ((old->flags & 32768) != 0) { return (0); } else { } tmp___1 = memcmp((void const *)(& old->fsid), (void const *)(& server->fsid), 16UL); if (tmp___1 != 0) { return (0); } else { } tmp___2 = nfs_compare_mount_options((struct super_block const *)sb, (struct nfs_server const *)server, mntflags); return (tmp___2); } } static void nfs_get_cache_cookie(struct super_block *sb , struct nfs_parsed_mount_data *parsed , struct nfs_clone_mount *cloned ) { struct nfs_server *nfss ; struct nfs_server *tmp ; char *uniq ; int ulen ; size_t tmp___0 ; struct nfs_server *mnt_s ; struct nfs_server *tmp___1 ; { tmp = NFS_SB((struct super_block const *)sb); nfss = tmp; uniq = (char *)0; ulen = 0; nfss->fscache_key = (struct nfs_fscache_key *)0; nfss->fscache = (struct fscache_cookie *)0; if ((unsigned long )parsed != (unsigned long )((struct nfs_parsed_mount_data *)0)) { if ((parsed->options & 1U) == 0U) { return; } else { } if ((unsigned long )parsed->fscache_uniq != (unsigned long )((char *)0)) { uniq = parsed->fscache_uniq; tmp___0 = strlen((char const *)parsed->fscache_uniq); ulen = (int )tmp___0; } else { } } else if ((unsigned long )cloned != (unsigned long )((struct nfs_clone_mount *)0)) { tmp___1 = NFS_SB(cloned->sb); mnt_s = tmp___1; if ((mnt_s->options & 1U) == 0U) { return; } else { } if ((unsigned long )mnt_s->fscache_key != (unsigned long )((struct nfs_fscache_key *)0)) { uniq = (char *)(& (mnt_s->fscache_key)->key.uniquifier); ulen = (int )(mnt_s->fscache_key)->key.uniq_len; } else { } } else { return; } nfs_fscache_get_super_cookie(sb, (char const *)uniq, ulen); return; } } static int nfs_bdi_register(struct nfs_server *server ) { int tmp ; { tmp = bdi_register_dev(& server->backing_dev_info, server->s_dev); return (tmp); } } int nfs_set_sb_security(struct super_block *s , struct dentry *mntroot , struct nfs_mount_info *mount_info ) { int error ; unsigned long kflags ; unsigned long kflags_out ; struct nfs_server *tmp ; struct nfs_server *tmp___0 ; struct nfs_server *tmp___1 ; { kflags = 0UL; kflags_out = 0UL; tmp = NFS_SB((struct super_block const *)s); if ((tmp->caps & 262144U) != 0U) { kflags = kflags | 1UL; } else { } error = security_sb_set_mnt_opts(s, & (mount_info->parsed)->lsm_opts, kflags, & kflags_out); if (error != 0) { goto err; } else { } tmp___1 = NFS_SB((struct super_block const *)s); if ((tmp___1->caps & 262144U) != 0U && (kflags_out & 1UL) == 0UL) { tmp___0 = NFS_SB((struct super_block const *)s); tmp___0->caps = tmp___0->caps & 4294705151U; } else { } err: ; return (error); } } int nfs_clone_sb_security(struct super_block *s , struct dentry *mntroot , struct nfs_mount_info *mount_info ) { struct nfs_server *tmp ; int tmp___0 ; { tmp = NFS_SB((struct super_block const *)s); if ((unsigned long )(mntroot->d_inode)->i_op != (unsigned long )((struct inode_operations const *)((tmp->nfs_client)->rpc_ops)->dir_inode_ops)) { return (-116); } else { } tmp___0 = security_sb_clone_mnt_opts((mount_info->cloned)->sb, s); return (tmp___0); } } struct dentry *nfs_fs_mount_common(struct nfs_server *server , int flags , char const *dev_name___0 , struct nfs_mount_info *mount_info , struct nfs_subversion *nfs_mod ) { struct super_block *s ; struct dentry *mntroot ; void *tmp ; int (*compare_super)(struct super_block * , void * ) ; struct nfs_sb_mountdata sb_mntdata ; int error ; void *tmp___0 ; long tmp___1 ; void *tmp___2 ; long tmp___3 ; void *tmp___4 ; { tmp = ERR_PTR(-12L); mntroot = (struct dentry *)tmp; compare_super = & nfs_compare_super; sb_mntdata.server = server; sb_mntdata.mntflags = flags; if ((server->flags & 32768) != 0) { compare_super = (int (*)(struct super_block * , void * ))0; } else { } if ((server->flags & 32) != 0) { sb_mntdata.mntflags = sb_mntdata.mntflags | 16; } else { } if ((unsigned long )mount_info->cloned != (unsigned long )((struct nfs_clone_mount *)0) && (unsigned long )(mount_info->cloned)->sb != (unsigned long )((struct super_block const *)0)) { if (((unsigned long )((mount_info->cloned)->sb)->s_flags & 16UL) != 0UL) { sb_mntdata.mntflags = sb_mntdata.mntflags | 16; } else { } } else { } s = sget(nfs_mod->nfs_fs, compare_super, & nfs_set_super, flags, (void *)(& sb_mntdata)); tmp___1 = IS_ERR((void const *)s); if (tmp___1 != 0L) { tmp___0 = ERR_CAST((void const *)s); mntroot = (struct dentry *)tmp___0; goto out_err_nosb; } else { } if ((unsigned long )s->s_fs_info != (unsigned long )((void *)server)) { nfs_free_server(server); server = (struct nfs_server *)0; } else { error = nfs_bdi_register(server); if (error != 0) { tmp___2 = ERR_PTR((long )error); mntroot = (struct dentry *)tmp___2; goto error_splat_bdi; } else { } } if ((unsigned long )s->s_root == (unsigned long )((struct dentry *)0)) { (*(mount_info->fill_super))(s, mount_info); nfs_get_cache_cookie(s, mount_info->parsed, mount_info->cloned); } else { } mntroot = nfs_get_root(s, mount_info->mntfh, dev_name___0); tmp___3 = IS_ERR((void const *)mntroot); if (tmp___3 != 0L) { goto error_splat_super; } else { } error = (*(mount_info->set_security))(s, mntroot, mount_info); if (error != 0) { goto error_splat_root; } else { } s->s_flags = s->s_flags | 1073741824UL; out: ; return (mntroot); out_err_nosb: nfs_free_server(server); goto out; error_splat_root: dput(mntroot); tmp___4 = ERR_PTR((long )error); mntroot = (struct dentry *)tmp___4; error_splat_super: ; if ((unsigned long )server != (unsigned long )((struct nfs_server *)0) && (unsigned long )s->s_root == (unsigned long )((struct dentry *)0)) { bdi_unregister(& server->backing_dev_info); } else { } error_splat_bdi: deactivate_locked_super(s); goto out; } } struct dentry *nfs_fs_mount(struct file_system_type *fs_type , int flags , char const *dev_name___0 , void *raw_data ) { struct nfs_mount_info mount_info ; struct dentry *mntroot ; void *tmp ; struct nfs_subversion *nfs_mod ; int error ; void *tmp___0 ; void *tmp___1 ; long tmp___2 ; { mount_info.fill_super = & nfs_fill_super; mount_info.set_security = & nfs_set_sb_security; mount_info.parsed = 0; mount_info.cloned = 0; mount_info.mntfh = 0; tmp = ERR_PTR(-12L); mntroot = (struct dentry *)tmp; mount_info.parsed = nfs_alloc_parsed_mount_data(); mount_info.mntfh = nfs_alloc_fhandle(); if ((unsigned long )mount_info.parsed == (unsigned long )((struct nfs_parsed_mount_data *)0) || (unsigned long )mount_info.mntfh == (unsigned long )((struct nfs_fh *)0)) { goto out; } else { } error = nfs_validate_mount_data(fs_type, raw_data, mount_info.parsed, mount_info.mntfh, dev_name___0); if (error == 1) { error = nfs_validate_text_mount_data(raw_data, mount_info.parsed, dev_name___0); } else { } if (error < 0) { tmp___0 = ERR_PTR((long )error); mntroot = (struct dentry *)tmp___0; goto out; } else { } nfs_mod = get_nfs_version((mount_info.parsed)->version); tmp___2 = IS_ERR((void const *)nfs_mod); if (tmp___2 != 0L) { tmp___1 = ERR_CAST((void const *)nfs_mod); mntroot = (struct dentry *)tmp___1; goto out; } else { } mntroot = (*((nfs_mod->rpc_ops)->try_mount))(flags, dev_name___0, & mount_info, nfs_mod); put_nfs_version(nfs_mod); out: nfs_free_parsed_mount_data(mount_info.parsed); nfs_free_fhandle((struct nfs_fh const *)mount_info.mntfh); return (mntroot); } } void nfs_put_super(struct super_block *s ) { struct nfs_server *server ; struct nfs_server *tmp ; { tmp = NFS_SB((struct super_block const *)s); server = tmp; bdi_unregister(& server->backing_dev_info); return; } } void nfs_kill_super(struct super_block *s ) { struct nfs_server *server ; struct nfs_server *tmp ; { tmp = NFS_SB((struct super_block const *)s); server = tmp; kill_anon_super(s); nfs_fscache_release_super_cookie(s); nfs_free_server(server); return; } } static struct dentry *nfs_xdev_mount(struct file_system_type *fs_type , int flags , char const *dev_name___0 , void *raw_data ) { struct nfs_clone_mount *data ; struct nfs_mount_info mount_info ; struct nfs_server *server ; struct dentry *mntroot ; void *tmp ; struct nfs_subversion *nfs_mod ; struct nfs_server *tmp___0 ; long tmp___1 ; struct nfs_server *tmp___2 ; void *tmp___3 ; long tmp___4 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; { data = (struct nfs_clone_mount *)raw_data; mount_info.fill_super = & nfs_clone_super; mount_info.set_security = & nfs_clone_sb_security; mount_info.parsed = 0; mount_info.cloned = data; mount_info.mntfh = 0; tmp = ERR_PTR(-12L); mntroot = (struct dentry *)tmp; tmp___0 = NFS_SB(data->sb); nfs_mod = (tmp___0->nfs_client)->cl_nfs_mod; tmp___1 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___1 != 0L) { printk("\001d--> nfs_xdev_mount()\n"); } else { } mount_info.mntfh = (mount_info.cloned)->fh; tmp___2 = NFS_SB(data->sb); server = (*((nfs_mod->rpc_ops)->clone_server))(tmp___2, data->fh, data->fattr, data->authflavor); tmp___4 = IS_ERR((void const *)server); if (tmp___4 != 0L) { tmp___3 = ERR_CAST((void const *)server); mntroot = (struct dentry *)tmp___3; } else { mntroot = nfs_fs_mount_common(server, flags, dev_name___0, & mount_info, nfs_mod); } tmp___9 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___9 != 0L) { tmp___8 = IS_ERR((void const *)mntroot); if (tmp___8 != 0L) { tmp___6 = PTR_ERR((void const *)mntroot); tmp___7 = tmp___6; } else { tmp___7 = 0L; } printk("\001d<-- nfs_xdev_mount() = %ld\n", tmp___7); } else { } return (mntroot); } } static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args ) { { args->flags = args->flags & -3148417; return; } } static int nfs4_validate_mount_data(void *options , struct nfs_parsed_mount_data *args , char const *dev_name___0 ) { struct sockaddr *sap ; struct nfs4_mount_data *data ; char *c ; unsigned long tmp ; int tmp___0 ; __u16 tmp___1 ; rpc_authflavor_t pseudoflavor ; unsigned long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; long tmp___11 ; long tmp___12 ; long tmp___13 ; { sap = (struct sockaddr *)(& args->nfs_server.address); data = (struct nfs4_mount_data *)options; if ((unsigned long )data == (unsigned long )((struct nfs4_mount_data *)0)) { goto out_no_data; } else { } args->version = 4U; switch (data->version) { case 1: ; if (data->host_addrlen > 128U) { goto out_no_address; } else { } if (data->host_addrlen == 0U) { goto out_no_address; } else { } args->nfs_server.addrlen = (size_t )data->host_addrlen; tmp = copy_from_user((void *)sap, (void const *)data->host_addr, (unsigned long )data->host_addrlen); if (tmp != 0UL) { return (-14); } else { } tmp___0 = nfs_verify_server_address(sap); if (tmp___0 == 0) { goto out_no_address; } else { } tmp___1 = __fswab16((int )((struct sockaddr_in *)sap)->sin_port); args->nfs_server.port = (int )tmp___1; if (data->auth_flavourlen != 0) { if (data->auth_flavourlen > 1) { goto out_inval_auth; } else { } tmp___2 = copy_from_user((void *)(& pseudoflavor), (void const *)data->auth_flavours, 4UL); if (tmp___2 != 0UL) { return (-14); } else { } nfs_set_auth_parsed_mount_data(args, pseudoflavor); } else { nfs_set_auth_parsed_mount_data(args, 1U); } c = strndup_user(data->hostname.data, 255L); tmp___4 = IS_ERR((void const *)c); if (tmp___4 != 0L) { tmp___3 = PTR_ERR((void const *)c); return ((int )tmp___3); } else { } args->nfs_server.hostname = c; c = strndup_user(data->mnt_path.data, 4096L); tmp___6 = IS_ERR((void const *)c); if (tmp___6 != 0L) { tmp___5 = PTR_ERR((void const *)c); return ((int )tmp___5); } else { } args->nfs_server.export_path = c; tmp___7 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___7 != 0L) { printk("\001dNFS: MNTPATH: \'%s\'\n", c); } else { } c = strndup_user(data->client_addr.data, 16L); tmp___9 = IS_ERR((void const *)c); if (tmp___9 != 0L) { tmp___8 = PTR_ERR((void const *)c); return ((int )tmp___8); } else { } args->client_address = c; args->flags = data->flags & 36915; args->rsize = (unsigned int )data->rsize; args->wsize = (unsigned int )data->wsize; args->timeo = (unsigned int )data->timeo; args->retrans = (unsigned int )data->retrans; args->acregmin = (unsigned int )data->acregmin; args->acregmax = (unsigned int )data->acregmax; args->acdirmin = (unsigned int )data->acdirmin; args->acdirmax = (unsigned int )data->acdirmax; args->nfs_server.protocol = (unsigned short )data->proto; nfs_validate_transport_protocol(args); if ((unsigned int )args->nfs_server.protocol == 17U) { goto out_invalid_transport_udp; } else { } goto ldv_53985; default: ; return (1); } ldv_53985: ; return (0); out_no_data: tmp___10 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___10 != 0L) { printk("\001dNFS4: mount program didn\'t pass any mount data\n"); } else { } return (-22); out_inval_auth: tmp___11 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___11 != 0L) { printk("\001dNFS4: Invalid number of RPC auth flavours %d\n", data->auth_flavourlen); } else { } return (-22); out_no_address: tmp___12 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___12 != 0L) { printk("\001dNFS4: mount program didn\'t pass remote address\n"); } else { } return (-22); out_invalid_transport_udp: tmp___13 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___13 != 0L) { printk("\001dNFSv4: Unsupported transport protocol udp\n"); } else { } return (-22); } } unsigned int nfs_idmap_cache_timeout = 600U; bool nfs4_disable_idmapping = 1; unsigned short max_session_slots = 64U; unsigned short send_implementation_id = 1U; char nfs4_client_id_uniquifier[64U] = { '\000'}; bool recover_lost_locks = 0; static int param_set_portnr(char const *val , struct kernel_param const *kp ) { unsigned long num ; int ret ; { if ((unsigned long )val == (unsigned long )((char const *)0)) { return (-22); } else { } ret = kstrtoul(val, 0U, & num); if (ret == -22 || num > 65535UL) { return (-22); } else { } *((unsigned int *)kp->ldv_14132.arg) = (unsigned int )num; return (0); } } extern int ldv_release_56(void) ; extern int ldv_probe_56(void) ; extern int ldv_release_55(void) ; extern int ldv_probe_55(void) ; void ldv_initialize_kernel_param_ops_51(void) { void *tmp ; { tmp = ldv_zalloc(32UL); param_ops_portnr_group0 = (struct kernel_param *)tmp; return; } } void ldv_initialize_super_operations_56(void) { void *tmp ; void *tmp___0 ; void *tmp___1 ; void *tmp___2 ; { tmp = ldv_zalloc(1032UL); nfs_sops_group0 = (struct inode *)tmp; tmp___0 = ldv_zalloc(256UL); nfs_sops_group1 = (struct seq_file *)tmp___0; tmp___1 = ldv_zalloc(264UL); nfs_sops_group2 = (struct dentry *)tmp___1; tmp___2 = ldv_zalloc(2432UL); nfs_sops_group3 = (struct super_block *)tmp___2; return; } } void ldv_initialize_shrinker_52(void) { void *tmp ; void *tmp___0 ; { tmp = ldv_zalloc(64UL); acl_shrinker_group0 = (struct shrinker *)tmp; tmp___0 = ldv_zalloc(152UL); acl_shrinker_group1 = (struct shrink_control *)tmp___0; return; } } void ldv_initialize_super_operations_55(void) { void *tmp ; void *tmp___0 ; void *tmp___1 ; void *tmp___2 ; { tmp = ldv_zalloc(1032UL); nfs_sops_group0 = (struct inode *)tmp; tmp___0 = ldv_zalloc(256UL); nfs_sops_group1 = (struct seq_file *)tmp___0; tmp___1 = ldv_zalloc(264UL); nfs_sops_group2 = (struct dentry *)tmp___1; tmp___2 = ldv_zalloc(2432UL); nfs_sops_group3 = (struct super_block *)tmp___2; return; } } void ldv_main_exported_53(void) { struct super_block *ldvarg265 ; void *tmp ; char *ldvarg268 ; void *tmp___0 ; struct file_system_type *ldvarg267 ; void *tmp___1 ; int ldvarg269 ; int tmp___2 ; void *ldvarg266 ; void *tmp___3 ; int tmp___4 ; { tmp = ldv_zalloc(2432UL); ldvarg265 = (struct super_block *)tmp; tmp___0 = ldv_zalloc(1UL); ldvarg268 = (char *)tmp___0; tmp___1 = ldv_zalloc(128UL); ldvarg267 = (struct file_system_type *)tmp___1; tmp___2 = __VERIFIER_nondet_int(); ldvarg269 = tmp___2; tmp___3 = ldv_zalloc(1UL); ldvarg266 = tmp___3; tmp___4 = __VERIFIER_nondet_int(); switch (tmp___4) { case 0: ; if (ldv_state_variable_53 == 1) { nfs_fs_mount(ldvarg267, ldvarg269, (char const *)ldvarg268, ldvarg266); ldv_state_variable_53 = 1; } else { } goto ldv_54151; case 1: ; if (ldv_state_variable_53 == 1) { nfs_kill_super(ldvarg265); ldv_state_variable_53 = 1; } else { } goto ldv_54151; default: ldv_stop(); } ldv_54151: ; return; } } void ldv_main_exported_57(void) { void *ldvarg40 ; void *tmp ; char *ldvarg42 ; void *tmp___0 ; int ldvarg43 ; int tmp___1 ; struct file_system_type *ldvarg41 ; void *tmp___2 ; struct super_block *ldvarg39 ; void *tmp___3 ; int tmp___4 ; { tmp = ldv_zalloc(1UL); ldvarg40 = tmp; tmp___0 = ldv_zalloc(1UL); ldvarg42 = (char *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); ldvarg43 = tmp___1; tmp___2 = ldv_zalloc(128UL); ldvarg41 = (struct file_system_type *)tmp___2; tmp___3 = ldv_zalloc(2432UL); ldvarg39 = (struct super_block *)tmp___3; tmp___4 = __VERIFIER_nondet_int(); switch (tmp___4) { case 0: ; if (ldv_state_variable_57 == 1) { nfs_xdev_mount(ldvarg41, ldvarg43, (char const *)ldvarg42, ldvarg40); ldv_state_variable_57 = 1; } else { } goto ldv_54163; case 1: ; if (ldv_state_variable_57 == 1) { nfs_kill_super(ldvarg39); ldv_state_variable_57 = 1; } else { } goto ldv_54163; default: ldv_stop(); } ldv_54163: ; return; } } void ldv_main_exported_51(void) { char *ldvarg292 ; void *tmp ; char *ldvarg293 ; void *tmp___0 ; int tmp___1 ; { tmp = ldv_zalloc(1UL); ldvarg292 = (char *)tmp; tmp___0 = ldv_zalloc(1UL); ldvarg293 = (char *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); switch (tmp___1) { case 0: ; if (ldv_state_variable_51 == 1) { param_set_portnr((char const *)ldvarg293, (struct kernel_param const *)param_ops_portnr_group0); ldv_state_variable_51 = 1; } else { } goto ldv_54172; case 1: ; if (ldv_state_variable_51 == 1) { param_get_uint(ldvarg292, (struct kernel_param const *)param_ops_portnr_group0); ldv_state_variable_51 = 1; } else { } goto ldv_54172; default: ldv_stop(); } ldv_54172: ; return; } } void ldv_main_exported_58(void) { struct file_system_type *ldvarg132 ; void *tmp ; struct super_block *ldvarg130 ; void *tmp___0 ; char *ldvarg133 ; void *tmp___1 ; int ldvarg134 ; int tmp___2 ; void *ldvarg131 ; void *tmp___3 ; int tmp___4 ; { tmp = ldv_zalloc(128UL); ldvarg132 = (struct file_system_type *)tmp; tmp___0 = ldv_zalloc(2432UL); ldvarg130 = (struct super_block *)tmp___0; tmp___1 = ldv_zalloc(1UL); ldvarg133 = (char *)tmp___1; tmp___2 = __VERIFIER_nondet_int(); ldvarg134 = tmp___2; tmp___3 = ldv_zalloc(1UL); ldvarg131 = tmp___3; tmp___4 = __VERIFIER_nondet_int(); switch (tmp___4) { case 0: ; if (ldv_state_variable_58 == 1) { nfs_fs_mount(ldvarg132, ldvarg134, (char const *)ldvarg133, ldvarg131); ldv_state_variable_58 = 1; } else { } goto ldv_54184; case 1: ; if (ldv_state_variable_58 == 1) { nfs_kill_super(ldvarg130); ldv_state_variable_58 = 1; } else { } goto ldv_54184; default: ldv_stop(); } ldv_54184: ; return; } } void ldv_main_exported_52(void) { int tmp ; { tmp = __VERIFIER_nondet_int(); switch (tmp) { case 0: ; if (ldv_state_variable_52 == 1) { nfs_access_cache_count(acl_shrinker_group0, acl_shrinker_group1); ldv_state_variable_52 = 1; } else { } goto ldv_54191; case 1: ; if (ldv_state_variable_52 == 1) { nfs_access_cache_scan(acl_shrinker_group0, acl_shrinker_group1); ldv_state_variable_52 = 1; } else { } goto ldv_54191; default: ldv_stop(); } ldv_54191: ; return; } } void ldv_main_exported_59(void) { struct super_block *ldvarg255 ; void *tmp ; struct file_system_type *ldvarg257 ; void *tmp___0 ; char *ldvarg258 ; void *tmp___1 ; void *ldvarg256 ; void *tmp___2 ; int ldvarg259 ; int tmp___3 ; int tmp___4 ; { tmp = ldv_zalloc(2432UL); ldvarg255 = (struct super_block *)tmp; tmp___0 = ldv_zalloc(128UL); ldvarg257 = (struct file_system_type *)tmp___0; tmp___1 = ldv_zalloc(1UL); ldvarg258 = (char *)tmp___1; tmp___2 = ldv_zalloc(1UL); ldvarg256 = tmp___2; tmp___3 = __VERIFIER_nondet_int(); ldvarg259 = tmp___3; tmp___4 = __VERIFIER_nondet_int(); switch (tmp___4) { case 0: ; if (ldv_state_variable_59 == 1) { nfs_fs_mount(ldvarg257, ldvarg259, (char const *)ldvarg258, ldvarg256); ldv_state_variable_59 = 1; } else { } goto ldv_54203; case 1: ; if (ldv_state_variable_59 == 1) { nfs_kill_super(ldvarg255); ldv_state_variable_59 = 1; } else { } goto ldv_54203; default: ldv_stop(); } ldv_54203: ; return; } } void ldv_main_exported_56(void) { struct kstatfs *ldvarg141 ; void *tmp ; struct writeback_control *ldvarg142 ; void *tmp___0 ; int *ldvarg144 ; void *tmp___1 ; char *ldvarg143 ; void *tmp___2 ; int tmp___3 ; { tmp = ldv_zalloc(120UL); ldvarg141 = (struct kstatfs *)tmp; tmp___0 = ldv_zalloc(40UL); ldvarg142 = (struct writeback_control *)tmp___0; tmp___1 = ldv_zalloc(4UL); ldvarg144 = (int *)tmp___1; tmp___2 = ldv_zalloc(1UL); ldvarg143 = (char *)tmp___2; tmp___3 = __VERIFIER_nondet_int(); switch (tmp___3) { case 0: ; if (ldv_state_variable_56 == 1) { nfs_destroy_inode(nfs_sops_group0); ldv_state_variable_56 = 1; } else { } if (ldv_state_variable_56 == 2) { nfs_destroy_inode(nfs_sops_group0); ldv_state_variable_56 = 2; } else { } goto ldv_54214; case 1: ; if (ldv_state_variable_56 == 1) { nfs_show_options(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_56 = 1; } else { } if (ldv_state_variable_56 == 2) { nfs_show_options(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_56 = 2; } else { } goto ldv_54214; case 2: ; if (ldv_state_variable_56 == 1) { nfs_umount_begin(nfs_sops_group3); ldv_state_variable_56 = 1; } else { } if (ldv_state_variable_56 == 2) { nfs_umount_begin(nfs_sops_group3); ldv_state_variable_56 = 2; } else { } goto ldv_54214; case 3: ; if (ldv_state_variable_56 == 1) { nfs_remount(nfs_sops_group3, ldvarg144, ldvarg143); ldv_state_variable_56 = 1; } else { } if (ldv_state_variable_56 == 2) { nfs_remount(nfs_sops_group3, ldvarg144, ldvarg143); ldv_state_variable_56 = 2; } else { } goto ldv_54214; case 4: ; if (ldv_state_variable_56 == 2) { nfs_write_inode(nfs_sops_group0, ldvarg142); ldv_state_variable_56 = 2; } else { } goto ldv_54214; case 5: ; if (ldv_state_variable_56 == 1) { nfs_evict_inode(nfs_sops_group0); ldv_state_variable_56 = 1; } else { } if (ldv_state_variable_56 == 2) { nfs_evict_inode(nfs_sops_group0); ldv_state_variable_56 = 2; } else { } goto ldv_54214; case 6: ; if (ldv_state_variable_56 == 1) { nfs_alloc_inode(nfs_sops_group3); ldv_state_variable_56 = 1; } else { } if (ldv_state_variable_56 == 2) { nfs_alloc_inode(nfs_sops_group3); ldv_state_variable_56 = 2; } else { } goto ldv_54214; case 7: ; if (ldv_state_variable_56 == 1) { nfs_statfs(nfs_sops_group2, ldvarg141); ldv_state_variable_56 = 1; } else { } if (ldv_state_variable_56 == 2) { nfs_statfs(nfs_sops_group2, ldvarg141); ldv_state_variable_56 = 2; } else { } goto ldv_54214; case 8: ; if (ldv_state_variable_56 == 1) { nfs_show_devname(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_56 = 1; } else { } if (ldv_state_variable_56 == 2) { nfs_show_devname(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_56 = 2; } else { } goto ldv_54214; case 9: ; if (ldv_state_variable_56 == 1) { nfs_show_path(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_56 = 1; } else { } if (ldv_state_variable_56 == 2) { nfs_show_path(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_56 = 2; } else { } goto ldv_54214; case 10: ; if (ldv_state_variable_56 == 1) { nfs_show_stats(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_56 = 1; } else { } if (ldv_state_variable_56 == 2) { nfs_show_stats(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_56 = 2; } else { } goto ldv_54214; case 11: ; if (ldv_state_variable_56 == 1) { nfs_put_super(nfs_sops_group3); ldv_state_variable_56 = 1; } else { } if (ldv_state_variable_56 == 2) { nfs_put_super(nfs_sops_group3); ldv_state_variable_56 = 2; } else { } goto ldv_54214; case 12: ; if (ldv_state_variable_56 == 1) { nfs_drop_inode(nfs_sops_group0); ldv_state_variable_56 = 1; } else { } if (ldv_state_variable_56 == 2) { nfs_drop_inode(nfs_sops_group0); ldv_state_variable_56 = 2; } else { } goto ldv_54214; case 13: ; if (ldv_state_variable_56 == 2) { ldv_release_56(); ldv_state_variable_56 = 1; ref_cnt = ref_cnt - 1; } else { } goto ldv_54214; case 14: ; if (ldv_state_variable_56 == 1) { ldv_probe_56(); ldv_state_variable_56 = 2; ref_cnt = ref_cnt + 1; } else { } goto ldv_54214; default: ldv_stop(); } ldv_54214: ; return; } } void ldv_main_exported_54(void) { struct super_block *ldvarg196 ; void *tmp ; char *ldvarg199 ; void *tmp___0 ; struct file_system_type *ldvarg198 ; void *tmp___1 ; void *ldvarg197 ; void *tmp___2 ; int ldvarg200 ; int tmp___3 ; int tmp___4 ; { tmp = ldv_zalloc(2432UL); ldvarg196 = (struct super_block *)tmp; tmp___0 = ldv_zalloc(1UL); ldvarg199 = (char *)tmp___0; tmp___1 = ldv_zalloc(128UL); ldvarg198 = (struct file_system_type *)tmp___1; tmp___2 = ldv_zalloc(1UL); ldvarg197 = tmp___2; tmp___3 = __VERIFIER_nondet_int(); ldvarg200 = tmp___3; tmp___4 = __VERIFIER_nondet_int(); switch (tmp___4) { case 0: ; if (ldv_state_variable_54 == 1) { nfs_fs_mount(ldvarg198, ldvarg200, (char const *)ldvarg199, ldvarg197); ldv_state_variable_54 = 1; } else { } goto ldv_54239; case 1: ; if (ldv_state_variable_54 == 1) { nfs_kill_super(ldvarg196); ldv_state_variable_54 = 1; } else { } goto ldv_54239; default: ldv_stop(); } ldv_54239: ; return; } } void ldv_main_exported_55(void) { struct writeback_control *ldvarg33 ; void *tmp ; char *ldvarg34 ; void *tmp___0 ; struct kstatfs *ldvarg32 ; void *tmp___1 ; int *ldvarg35 ; void *tmp___2 ; int tmp___3 ; { tmp = ldv_zalloc(40UL); ldvarg33 = (struct writeback_control *)tmp; tmp___0 = ldv_zalloc(1UL); ldvarg34 = (char *)tmp___0; tmp___1 = ldv_zalloc(120UL); ldvarg32 = (struct kstatfs *)tmp___1; tmp___2 = ldv_zalloc(4UL); ldvarg35 = (int *)tmp___2; tmp___3 = __VERIFIER_nondet_int(); switch (tmp___3) { case 0: ; if (ldv_state_variable_55 == 1) { nfs_destroy_inode(nfs_sops_group0); ldv_state_variable_55 = 1; } else { } if (ldv_state_variable_55 == 2) { nfs_destroy_inode(nfs_sops_group0); ldv_state_variable_55 = 2; } else { } goto ldv_54250; case 1: ; if (ldv_state_variable_55 == 1) { nfs_show_options(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_55 = 1; } else { } if (ldv_state_variable_55 == 2) { nfs_show_options(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_55 = 2; } else { } goto ldv_54250; case 2: ; if (ldv_state_variable_55 == 1) { nfs_umount_begin(nfs_sops_group3); ldv_state_variable_55 = 1; } else { } if (ldv_state_variable_55 == 2) { nfs_umount_begin(nfs_sops_group3); ldv_state_variable_55 = 2; } else { } goto ldv_54250; case 3: ; if (ldv_state_variable_55 == 1) { nfs_remount(nfs_sops_group3, ldvarg35, ldvarg34); ldv_state_variable_55 = 1; } else { } if (ldv_state_variable_55 == 2) { nfs_remount(nfs_sops_group3, ldvarg35, ldvarg34); ldv_state_variable_55 = 2; } else { } goto ldv_54250; case 4: ; if (ldv_state_variable_55 == 2) { nfs_write_inode(nfs_sops_group0, ldvarg33); ldv_state_variable_55 = 2; } else { } goto ldv_54250; case 5: ; if (ldv_state_variable_55 == 1) { nfs_evict_inode(nfs_sops_group0); ldv_state_variable_55 = 1; } else { } if (ldv_state_variable_55 == 2) { nfs_evict_inode(nfs_sops_group0); ldv_state_variable_55 = 2; } else { } goto ldv_54250; case 6: ; if (ldv_state_variable_55 == 1) { nfs_alloc_inode(nfs_sops_group3); ldv_state_variable_55 = 1; } else { } if (ldv_state_variable_55 == 2) { nfs_alloc_inode(nfs_sops_group3); ldv_state_variable_55 = 2; } else { } goto ldv_54250; case 7: ; if (ldv_state_variable_55 == 1) { nfs_statfs(nfs_sops_group2, ldvarg32); ldv_state_variable_55 = 1; } else { } if (ldv_state_variable_55 == 2) { nfs_statfs(nfs_sops_group2, ldvarg32); ldv_state_variable_55 = 2; } else { } goto ldv_54250; case 8: ; if (ldv_state_variable_55 == 1) { nfs_show_devname(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_55 = 1; } else { } if (ldv_state_variable_55 == 2) { nfs_show_devname(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_55 = 2; } else { } goto ldv_54250; case 9: ; if (ldv_state_variable_55 == 1) { nfs_show_path(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_55 = 1; } else { } if (ldv_state_variable_55 == 2) { nfs_show_path(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_55 = 2; } else { } goto ldv_54250; case 10: ; if (ldv_state_variable_55 == 1) { nfs_show_stats(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_55 = 1; } else { } if (ldv_state_variable_55 == 2) { nfs_show_stats(nfs_sops_group1, nfs_sops_group2); ldv_state_variable_55 = 2; } else { } goto ldv_54250; case 11: ; if (ldv_state_variable_55 == 1) { nfs_put_super(nfs_sops_group3); ldv_state_variable_55 = 1; } else { } if (ldv_state_variable_55 == 2) { nfs_put_super(nfs_sops_group3); ldv_state_variable_55 = 2; } else { } goto ldv_54250; case 12: ; if (ldv_state_variable_55 == 1) { nfs_drop_inode(nfs_sops_group0); ldv_state_variable_55 = 1; } else { } if (ldv_state_variable_55 == 2) { nfs_drop_inode(nfs_sops_group0); ldv_state_variable_55 = 2; } else { } goto ldv_54250; case 13: ; if (ldv_state_variable_55 == 2) { ldv_release_55(); ldv_state_variable_55 = 1; ref_cnt = ref_cnt - 1; } else { } goto ldv_54250; case 14: ; if (ldv_state_variable_55 == 1) { ldv_probe_55(); ldv_state_variable_55 = 2; ref_cnt = ref_cnt + 1; } else { } goto ldv_54250; default: ldv_stop(); } ldv_54250: ; return; } } __inline static int atomic_sub_and_test(int i , atomic_t *v ) { unsigned char c ; { __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; subl %2,%0; sete %1": "+m" (v->counter), "=qm" (c): "ir" (i): "memory"); return ((int )c); } } extern void lockdep_init_map(struct lockdep_map * , char const * , struct lock_class_key * , int ) ; extern void down_read(struct rw_semaphore * ) ; extern void up_read(struct rw_semaphore * ) ; __inline static void init_completion(struct completion *x ) { struct lock_class_key __key ; { x->done = 0U; __init_waitqueue_head(& x->wait, "&x->wait", & __key); return; } } extern int wait_for_completion_killable(struct completion * ) ; extern void complete_all(struct completion * ) ; extern void __init_work(struct work_struct * , int ) ; extern struct workqueue_struct *system_wq ; extern bool queue_work_on(int , struct workqueue_struct * , struct work_struct * ) ; __inline static bool queue_work(struct workqueue_struct *wq , struct work_struct *work ) { bool tmp ; { tmp = queue_work_on(4096, wq, work); return (tmp); } } __inline static bool schedule_work(struct work_struct *work ) { bool tmp ; { tmp = queue_work(system_wq, work); return (tmp); } } __inline static void kref_init(struct kref *kref ) { { atomic_set(& kref->refcount, 1); return; } } __inline static void kref_get(struct kref *kref ) { bool __warned ; int __ret_warn_once ; int tmp ; int __ret_warn_on ; long tmp___0 ; long tmp___1 ; long tmp___2 ; { tmp = atomic_add_return(1, & kref->refcount); __ret_warn_once = tmp <= 1; tmp___2 = ldv__builtin_expect(__ret_warn_once != 0, 0L); if (tmp___2 != 0L) { __ret_warn_on = ! __warned; tmp___0 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___0 != 0L) { warn_slowpath_null("include/linux/kref.h", 47); } else { } tmp___1 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___1 != 0L) { __warned = 1; } else { } } else { } ldv__builtin_expect(__ret_warn_once != 0, 0L); return; } } __inline static int kref_sub(struct kref *kref , unsigned int count , void (*release)(struct kref * ) ) { int __ret_warn_on ; long tmp ; int tmp___0 ; { __ret_warn_on = (unsigned long )release == (unsigned long )((void (*)(struct kref * ))0); tmp = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp != 0L) { warn_slowpath_null("include/linux/kref.h", 71); } else { } ldv__builtin_expect(__ret_warn_on != 0, 0L); tmp___0 = atomic_sub_and_test((int )count, & kref->refcount); if (tmp___0 != 0) { (*release)(kref); return (1); } else { } return (0); } } __inline static int kref_put(struct kref *kref , void (*release)(struct kref * ) ) { int tmp ; { tmp = kref_sub(kref, 1U, release); return (tmp); } } __inline static void *kmem_cache_zalloc(struct kmem_cache *k , gfp_t flags ) { void *tmp ; { tmp = kmem_cache_alloc(k, flags | 32768U); return (tmp); } } __inline static int PageCompound(struct page *page ) { { return ((int )page->flags & 49152); } } extern long get_user_pages(struct task_struct * , struct mm_struct * , unsigned long , unsigned long , int , int , struct page ** , struct vm_area_struct ** ) ; extern int get_kernel_page(unsigned long , int , struct page ** ) ; extern int set_page_dirty(struct page * ) ; extern int generic_write_checks(struct file * , loff_t * , size_t * , int ) ; extern void inode_dio_done(struct inode * ) ; __inline static void task_io_account_read(size_t bytes ) { struct task_struct *tmp ; struct task_struct *tmp___0 ; { tmp = get_current(); tmp___0 = get_current(); tmp->ioac.read_bytes = tmp___0->ioac.read_bytes + (unsigned long long )bytes; return; } } __inline static void task_io_account_write(size_t bytes ) { struct task_struct *tmp ; struct task_struct *tmp___0 ; { tmp = get_current(); tmp___0 = get_current(); tmp->ioac.write_bytes = tmp___0->ioac.write_bytes + (unsigned long long )bytes; return; } } __inline static size_t iov_length___0(struct iovec const *iov , unsigned long nr_segs ) { unsigned long seg ; size_t ret ; { ret = 0UL; seg = 0UL; goto ldv_26390; ldv_26389: ret = (unsigned long )(iov + seg)->iov_len + ret; seg = seg + 1UL; ldv_26390: ; if (seg < nr_segs) { goto ldv_26389; } else { } return (ret); } } __inline static bool is_sync_kiocb(struct kiocb *kiocb ) { { return ((unsigned long )kiocb->ki_ctx == (unsigned long )((struct kioctx *)0)); } } extern void aio_complete(struct kiocb * , long , long ) ; struct nfs_page *nfs_create_request(struct nfs_open_context *ctx , struct inode *inode , struct page *page , unsigned int offset , unsigned int count ) ; void nfs_release_request(struct nfs_page *req ) ; int nfs_pageio_add_request(struct nfs_pageio_descriptor *desc , struct nfs_page *req ) ; void nfs_pageio_complete(struct nfs_pageio_descriptor *desc ) ; void nfs_unlock_and_release_request(struct nfs_page *req ) ; __inline static int nfs_lock_request(struct nfs_page *req ) { int tmp ; { tmp = test_and_set_bit(0L, (unsigned long volatile *)(& req->wb_flags)); return (tmp == 0); } } __inline static void nfs_list_add_request(struct nfs_page *req , struct list_head *head ) { { list_add_tail(& req->wb_list, head); return; } } __inline static void nfs_list_remove_request(struct nfs_page *req ) { int tmp ; { tmp = list_empty((struct list_head const *)(& req->wb_list)); if (tmp != 0) { return; } else { } list_del_init(& req->wb_list); return; } } __inline static struct nfs_page *nfs_list_entry(struct list_head *head ) { struct list_head const *__mptr ; { __mptr = (struct list_head const *)head; return ((struct nfs_page *)__mptr); } } __inline static loff_t req_offset(struct nfs_page *req ) { { return (((long long )req->wb_index << 12) + (long long )req->wb_offset); } } int nfs_scan_commit_list(struct list_head *src , struct list_head *dst , struct nfs_commit_info *cinfo , int max ) ; int nfs_scan_commit(struct inode *inode , struct list_head *dst , struct nfs_commit_info *cinfo ) ; void nfs_mark_request_commit(struct nfs_page *req , struct pnfs_layout_segment *lseg , struct nfs_commit_info *cinfo ) ; int nfs_generic_commit_list(struct inode *inode , struct list_head *head , int how , struct nfs_commit_info *cinfo ) ; void nfs_init_cinfo_from_dreq(struct nfs_commit_info *cinfo , struct nfs_direct_req *dreq ) ; ssize_t nfs_dreq_bytes_left(struct nfs_direct_req *dreq ) ; __inline static unsigned int nfs_page_array_len(unsigned int base , size_t len ) { { return ((unsigned int )((((unsigned long )base + len) + 4095UL) >> 12)); } } __inline static void nfs_add_server_stats___0(struct nfs_server const *server , enum nfs_stat_bytecounters stat , long addend ) { void const *__vpp_verify ; int pao_ID__ ; int pao_ID_____0 ; int pao_ID_____1 ; int pao_ID_____2 ; { __vpp_verify = (void const *)0; switch (8UL) { case 1UL: pao_ID__ = 0; switch (8UL) { case 1UL: ; if (pao_ID__ == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_51001; case 2UL: ; if (pao_ID__ == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51001; case 4UL: ; if (pao_ID__ == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51001; case 8UL: ; if (pao_ID__ == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_51001; default: __bad_percpu_size(); } ldv_51001: ; goto ldv_51006; case 2UL: pao_ID_____0 = 0; switch (8UL) { case 1UL: ; if (pao_ID_____0 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_51012; case 2UL: ; if (pao_ID_____0 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51012; case 4UL: ; if (pao_ID_____0 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51012; case 8UL: ; if (pao_ID_____0 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_51012; default: __bad_percpu_size(); } ldv_51012: ; goto ldv_51006; case 4UL: pao_ID_____1 = 0; switch (8UL) { case 1UL: ; if (pao_ID_____1 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_51022; case 2UL: ; if (pao_ID_____1 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51022; case 4UL: ; if (pao_ID_____1 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51022; case 8UL: ; if (pao_ID_____1 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_51022; default: __bad_percpu_size(); } ldv_51022: ; goto ldv_51006; case 8UL: pao_ID_____2 = 0; switch (8UL) { case 1UL: ; if (pao_ID_____2 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_51032; case 2UL: ; if (pao_ID_____2 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51032; case 4UL: ; if (pao_ID_____2 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51032; case 8UL: ; if (pao_ID_____2 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_51032; default: __bad_percpu_size(); } ldv_51032: ; goto ldv_51006; default: __bad_size_call_parameter(); goto ldv_51006; } ldv_51006: ; return; } } __inline static void nfs_add_stats___0(struct inode const *inode , enum nfs_stat_bytecounters stat , long addend ) { struct nfs_server *tmp ; { tmp = NFS_SERVER(inode); nfs_add_server_stats___0((struct nfs_server const *)tmp, stat, addend); return; } } __inline static void pnfs_recover_commit_reqs(struct inode *inode , struct list_head *list , struct nfs_commit_info *cinfo ) { struct nfs_server *tmp ; { if ((unsigned long )cinfo->ds == (unsigned long )((struct pnfs_ds_commit_info *)0) || (cinfo->ds)->nwritten == 0) { return; } else { } tmp = NFS_SERVER((struct inode const *)inode); (*((tmp->pnfs_curr_ld)->recover_commit_reqs))(list, cinfo); return; } } static struct kmem_cache *nfs_direct_cachep ; static struct nfs_pgio_completion_ops const nfs_direct_write_completion_ops ; static struct nfs_commit_completion_ops const nfs_direct_commit_completion_ops ; static void nfs_direct_write_complete(struct nfs_direct_req *dreq , struct inode *inode ) ; static void nfs_direct_write_schedule_work(struct work_struct *work ) ; __inline static void get_dreq(struct nfs_direct_req *dreq ) { { atomic_inc(& dreq->io_count); return; } } __inline static int put_dreq(struct nfs_direct_req *dreq ) { int tmp ; { tmp = atomic_dec_and_test(& dreq->io_count); return (tmp); } } ssize_t nfs_direct_IO(int rw , struct kiocb *iocb , struct iovec const *iov , loff_t pos , unsigned long nr_segs ) { long tmp ; ssize_t tmp___0 ; ssize_t tmp___1 ; { tmp = ldv__builtin_expect(iocb->ki_nbytes != 4096UL, 0L); if (tmp != 0L) { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/direct.o.c.prepared"), "i" (325), "i" (12UL)); ldv_51457: ; goto ldv_51457; } else { } if (rw == 0 || rw == 1073741824) { tmp___0 = nfs_file_direct_read(iocb, iov, nr_segs, pos, rw == 0); return (tmp___0); } else { } tmp___1 = nfs_file_direct_write(iocb, iov, nr_segs, pos, rw == 1); return (tmp___1); } } static void nfs_direct_release_pages(struct page **pages , unsigned int npages ) { unsigned int i ; { i = 0U; goto ldv_51464; ldv_51463: put_page(*(pages + (unsigned long )i)); i = i + 1U; ldv_51464: ; if (i < npages) { goto ldv_51463; } else { } return; } } void nfs_init_cinfo_from_dreq(struct nfs_commit_info *cinfo , struct nfs_direct_req *dreq ) { { cinfo->lock = & dreq->lock; cinfo->mds = & dreq->mds_cinfo; cinfo->ds = & dreq->ds_cinfo; cinfo->dreq = dreq; cinfo->completion_ops = & nfs_direct_commit_completion_ops; return; } } __inline static struct nfs_direct_req *nfs_direct_req_alloc(void) { struct nfs_direct_req *dreq ; void *tmp ; struct lock_class_key __key ; atomic_long_t __constr_expr_0 ; struct lock_class_key __key___0 ; { tmp = kmem_cache_zalloc(nfs_direct_cachep, 208U); dreq = (struct nfs_direct_req *)tmp; if ((unsigned long )dreq == (unsigned long )((struct nfs_direct_req *)0)) { return ((struct nfs_direct_req *)0); } else { } kref_init(& dreq->kref); kref_get(& dreq->kref); init_completion(& dreq->completion); INIT_LIST_HEAD(& dreq->mds_cinfo.list); __init_work(& dreq->work, 0); __constr_expr_0.counter = 137438953408L; dreq->work.data = __constr_expr_0; lockdep_init_map(& dreq->work.lockdep_map, "(&dreq->work)", & __key, 0); INIT_LIST_HEAD(& dreq->work.entry); dreq->work.func = & nfs_direct_write_schedule_work; spinlock_check(& dreq->lock); __raw_spin_lock_init(& dreq->lock.ldv_6140.rlock, "&(&dreq->lock)->rlock", & __key___0); return (dreq); } } static void nfs_direct_req_free(struct kref *kref ) { struct nfs_direct_req *dreq ; struct kref const *__mptr ; { __mptr = (struct kref const *)kref; dreq = (struct nfs_direct_req *)__mptr; if ((unsigned long )dreq->l_ctx != (unsigned long )((struct nfs_lock_context *)0)) { nfs_put_lock_context(dreq->l_ctx); } else { } if ((unsigned long )dreq->ctx != (unsigned long )((struct nfs_open_context *)0)) { put_nfs_open_context(dreq->ctx); } else { } kmem_cache_free(nfs_direct_cachep, (void *)dreq); return; } } static void nfs_direct_req_release(struct nfs_direct_req *dreq ) { { kref_put(& dreq->kref, & nfs_direct_req_free); return; } } ssize_t nfs_dreq_bytes_left(struct nfs_direct_req *dreq ) { { return (dreq->bytes_left); } } static ssize_t nfs_direct_wait(struct nfs_direct_req *dreq ) { ssize_t result ; int tmp ; { result = -529L; if ((unsigned long )dreq->iocb != (unsigned long )((struct kiocb *)0)) { goto out; } else { } tmp = wait_for_completion_killable(& dreq->completion); result = (ssize_t )tmp; if (result == 0L) { result = dreq->error; } else { } if (result == 0L) { result = dreq->count; } else { } out: ; return (result); } } static void nfs_direct_complete(struct nfs_direct_req *dreq ) { long res ; { if ((unsigned long )dreq->iocb != (unsigned long )((struct kiocb *)0)) { res = dreq->error; if (res == 0L) { res = dreq->count; } else { } aio_complete(dreq->iocb, res, 0L); } else { } complete_all(& dreq->completion); nfs_direct_req_release(dreq); return; } } static void nfs_direct_readpage_release(struct nfs_page *req ) { loff_t tmp ; __u64 tmp___0 ; long tmp___1 ; { tmp___1 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___1 != 0L) { tmp = req_offset(req); tmp___0 = NFS_FILEID((struct inode const *)((req->wb_context)->dentry)->d_inode); printk("\001dNFS: direct read done (%s/%lld %d@%lld)\n", (char *)(& ((((req->wb_context)->dentry)->d_inode)->i_sb)->s_id), (long long )tmp___0, req->wb_bytes, tmp); } else { } nfs_release_request(req); return; } } static void nfs_direct_read_completion(struct nfs_pgio_header *hdr ) { unsigned long bytes ; struct nfs_direct_req *dreq ; int tmp ; int tmp___0 ; struct nfs_page *req ; struct nfs_page *tmp___1 ; struct page *page ; int tmp___2 ; int tmp___3 ; int tmp___4 ; { bytes = 0UL; dreq = hdr->dreq; tmp = constant_test_bit(2L, (unsigned long const volatile *)(& hdr->flags)); if (tmp != 0) { goto out_put; } else { } spin_lock(& dreq->lock); tmp___0 = constant_test_bit(0L, (unsigned long const volatile *)(& hdr->flags)); if (tmp___0 != 0 && hdr->good_bytes == 0UL) { dreq->error = (ssize_t )hdr->error; } else { dreq->count = (ssize_t )((unsigned long )dreq->count + hdr->good_bytes); } spin_unlock(& dreq->lock); goto ldv_51516; ldv_51515: tmp___1 = nfs_list_entry(hdr->pages.next); req = tmp___1; page = req->wb_page; tmp___2 = PageCompound(page); if (tmp___2 == 0 && hdr->good_bytes > bytes) { set_page_dirty(page); } else { } bytes = (unsigned long )req->wb_bytes + bytes; nfs_list_remove_request(req); nfs_direct_readpage_release(req); ldv_51516: tmp___3 = list_empty((struct list_head const *)(& hdr->pages)); if (tmp___3 == 0) { goto ldv_51515; } else { } out_put: tmp___4 = put_dreq(dreq); if (tmp___4 != 0) { nfs_direct_complete(dreq); } else { } (*(hdr->release))(hdr); return; } } static void nfs_read_sync_pgio_error(struct list_head *head ) { struct nfs_page *req ; int tmp ; { goto ldv_51523; ldv_51522: req = nfs_list_entry(head->next); nfs_list_remove_request(req); nfs_release_request(req); ldv_51523: tmp = list_empty((struct list_head const *)head); if (tmp == 0) { goto ldv_51522; } else { } return; } } static void nfs_direct_pgio_init(struct nfs_pgio_header *hdr ) { { get_dreq(hdr->dreq); return; } } static struct nfs_pgio_completion_ops const nfs_direct_read_completion_ops = {& nfs_read_sync_pgio_error, & nfs_direct_pgio_init, & nfs_direct_read_completion}; static ssize_t nfs_direct_read_schedule_segment(struct nfs_pageio_descriptor *desc , struct iovec const *iov , loff_t pos , bool uio ) { struct nfs_direct_req *dreq ; struct nfs_open_context *ctx ; struct inode *inode ; unsigned long user_addr ; size_t count ; size_t rsize ; struct nfs_server *tmp ; unsigned int pgbase ; int result ; ssize_t started ; struct page **pagevec ; unsigned int npages ; size_t bytes ; int i ; size_t _min1 ; size_t __max1 ; size_t __max2 ; size_t _min2 ; void *tmp___0 ; struct task_struct *tmp___1 ; struct task_struct *tmp___2 ; struct task_struct *tmp___3 ; long tmp___4 ; struct task_struct *tmp___5 ; int __ret_warn_on ; long tmp___6 ; int __ret_warn_on___0 ; long tmp___7 ; long tmp___8 ; struct nfs_page *req ; unsigned int req_len ; size_t __min1 ; size_t __min2 ; long tmp___9 ; long tmp___10 ; int tmp___11 ; { dreq = desc->pg_dreq; ctx = dreq->ctx; inode = (ctx->dentry)->d_inode; user_addr = (unsigned long )iov->iov_base; count = iov->iov_len; tmp = NFS_SERVER((struct inode const *)inode); rsize = (size_t )tmp->rsize; started = 0L; pagevec = (struct page **)0; ldv_51570: pgbase = (unsigned int )user_addr & 4095U; __max1 = rsize; __max2 = 4096UL; _min1 = __max1 > __max2 ? __max1 : __max2; _min2 = count; bytes = _min1 < _min2 ? _min1 : _min2; result = -12; npages = nfs_page_array_len(pgbase, bytes); if ((unsigned long )pagevec == (unsigned long )((struct page **)0)) { tmp___0 = kmalloc((unsigned long )npages * 8UL, 208U); pagevec = (struct page **)tmp___0; } else { } if ((unsigned long )pagevec == (unsigned long )((struct page **)0)) { goto ldv_51557; } else { } if ((int )uio) { tmp___1 = get_current(); down_read(& (tmp___1->mm)->mmap_sem); tmp___2 = get_current(); tmp___3 = get_current(); tmp___4 = get_user_pages(tmp___3, tmp___2->mm, user_addr, (unsigned long )npages, 1, 0, pagevec, (struct vm_area_struct **)0); result = (int )tmp___4; tmp___5 = get_current(); up_read(& (tmp___5->mm)->mmap_sem); if (result < 0) { goto ldv_51557; } else { } } else { __ret_warn_on = npages != 1U; tmp___6 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___6 != 0L) { warn_slowpath_null("/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/direct.o.c.prepared", 539); } else { } ldv__builtin_expect(__ret_warn_on != 0, 0L); result = get_kernel_page(user_addr, 1, pagevec); __ret_warn_on___0 = result != 1; tmp___7 = ldv__builtin_expect(__ret_warn_on___0 != 0, 0L); if (tmp___7 != 0L) { warn_slowpath_null("/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/direct.o.c.prepared", 541); } else { } tmp___8 = ldv__builtin_expect(__ret_warn_on___0 != 0, 0L); if (tmp___8 != 0L) { goto ldv_51557; } else { } } if ((unsigned int )result < npages) { bytes = (unsigned long )result * 4096UL; if ((size_t )pgbase >= bytes) { nfs_direct_release_pages(pagevec, (unsigned int )result); goto ldv_51557; } else { } bytes = bytes - (size_t )pgbase; npages = (unsigned int )result; } else { } i = 0; goto ldv_51569; ldv_51568: __min1 = bytes; __min2 = 4096UL - (unsigned long )pgbase; req_len = (unsigned int )(__min1 < __min2 ? __min1 : __min2); req = nfs_create_request(dreq->ctx, dreq->inode, *(pagevec + (unsigned long )i), pgbase, req_len); tmp___10 = IS_ERR((void const *)req); if (tmp___10 != 0L) { tmp___9 = PTR_ERR((void const *)req); result = (int )tmp___9; goto ldv_51567; } else { } req->wb_index = (unsigned long )(pos >> 12); req->wb_offset = (unsigned int )pos & 4095U; tmp___11 = nfs_pageio_add_request(desc, req); if (tmp___11 == 0) { result = desc->pg_error; nfs_release_request(req); goto ldv_51567; } else { } pgbase = 0U; bytes = bytes - (size_t )req_len; started = (ssize_t )req_len + started; user_addr = (unsigned long )req_len + user_addr; pos = (loff_t )req_len + pos; count = count - (size_t )req_len; dreq->bytes_left = dreq->bytes_left - (ssize_t )req_len; i = i + 1; ldv_51569: ; if ((unsigned int )i < npages) { goto ldv_51568; } else { } ldv_51567: nfs_direct_release_pages(pagevec, npages); if (count != 0UL && result >= 0) { goto ldv_51570; } else { } ldv_51557: kfree((void const *)pagevec); if (started != 0L) { return (started); } else { } return (result < 0 ? (ssize_t )result : -14L); } } static ssize_t nfs_direct_read_schedule_iovec(struct nfs_direct_req *dreq , struct iovec const *iov , unsigned long nr_segs , loff_t pos , bool uio ) { struct nfs_pageio_descriptor desc ; ssize_t result ; size_t requested_bytes ; unsigned long seg ; struct nfs_rpc_ops const *tmp ; struct iovec const *vec ; int tmp___0 ; { result = -22L; requested_bytes = 0UL; tmp = NFS_PROTO((struct inode const *)dreq->inode); (*(tmp->read_pageio_init))(& desc, dreq->inode, & nfs_direct_read_completion_ops); get_dreq(dreq); desc.pg_dreq = dreq; seg = 0UL; goto ldv_51585; ldv_51584: vec = iov + seg; result = nfs_direct_read_schedule_segment(& desc, vec, pos, (int )uio); if (result < 0L) { goto ldv_51583; } else { } requested_bytes = requested_bytes + (unsigned long )result; if ((unsigned long )result < (unsigned long )vec->iov_len) { goto ldv_51583; } else { } pos = (loff_t )((unsigned long long )vec->iov_len + (unsigned long long )pos); seg = seg + 1UL; ldv_51585: ; if (seg < nr_segs) { goto ldv_51584; } else { } ldv_51583: nfs_pageio_complete(& desc); if (requested_bytes == 0UL) { nfs_direct_req_release(dreq); return (result < 0L ? result : -5L); } else { } tmp___0 = put_dreq(dreq); if (tmp___0 != 0) { nfs_direct_complete(dreq); } else { } return (0L); } } static ssize_t nfs_direct_read(struct kiocb *iocb , struct iovec const *iov , unsigned long nr_segs , loff_t pos , bool uio ) { ssize_t result ; struct inode *inode ; struct nfs_direct_req *dreq ; struct nfs_lock_context *l_ctx ; size_t tmp ; struct nfs_open_context *tmp___0 ; long tmp___1 ; bool tmp___2 ; int tmp___3 ; struct nfs_inode *tmp___4 ; struct nfs_inode *tmp___5 ; size_t tmp___6 ; { result = -12L; inode = ((iocb->ki_filp)->f_mapping)->host; dreq = nfs_direct_req_alloc(); if ((unsigned long )dreq == (unsigned long )((struct nfs_direct_req *)0)) { goto out; } else { } dreq->inode = inode; tmp = iov_length___0(iov, nr_segs); dreq->bytes_left = (ssize_t )tmp; tmp___0 = nfs_file_open_context(iocb->ki_filp); dreq->ctx = get_nfs_open_context(tmp___0); l_ctx = nfs_get_lock_context(dreq->ctx); tmp___1 = IS_ERR((void const *)l_ctx); if (tmp___1 != 0L) { result = PTR_ERR((void const *)l_ctx); goto out_release; } else { } dreq->l_ctx = l_ctx; tmp___2 = is_sync_kiocb(iocb); if (tmp___2) { tmp___3 = 0; } else { tmp___3 = 1; } if (tmp___3) { dreq->iocb = iocb; } else { } tmp___4 = NFS_I((struct inode const *)inode); tmp___5 = NFS_I((struct inode const *)inode); tmp___6 = iov_length___0(iov, nr_segs); tmp___4->read_io = tmp___5->read_io + (unsigned long long )tmp___6; result = nfs_direct_read_schedule_iovec(dreq, iov, nr_segs, pos, (int )uio); if (result == 0L) { result = nfs_direct_wait(dreq); } else { } out_release: nfs_direct_req_release(dreq); out: ; return (result); } } static void nfs_inode_dio_write_done(struct inode *inode ) { { nfs_zap_mapping(inode, inode->i_mapping); inode_dio_done(inode); return; } } static void nfs_direct_write_reschedule(struct nfs_direct_req *dreq ) { struct nfs_pageio_descriptor desc ; struct nfs_page *req ; struct nfs_page *tmp ; struct list_head reqs ; struct nfs_commit_info cinfo ; struct list_head failed ; struct nfs_rpc_ops const *tmp___0 ; struct list_head const *__mptr ; struct list_head const *__mptr___0 ; int tmp___1 ; struct list_head const *__mptr___1 ; int tmp___2 ; int tmp___3 ; { reqs.next = & reqs; reqs.prev = & reqs; failed.next = & failed; failed.prev = & failed; nfs_init_cinfo_from_dreq(& cinfo, dreq); pnfs_recover_commit_reqs(dreq->inode, & reqs, & cinfo); spin_lock(cinfo.lock); nfs_scan_commit_list(& (cinfo.mds)->list, & reqs, & cinfo, 0); spin_unlock(cinfo.lock); dreq->count = 0L; get_dreq(dreq); tmp___0 = NFS_PROTO((struct inode const *)dreq->inode); (*(tmp___0->write_pageio_init))(& desc, dreq->inode, 4, & nfs_direct_write_completion_ops); desc.pg_dreq = dreq; __mptr = (struct list_head const *)reqs.next; req = (struct nfs_page *)__mptr; __mptr___0 = (struct list_head const *)req->wb_list.next; tmp = (struct nfs_page *)__mptr___0; goto ldv_51618; ldv_51617: tmp___1 = nfs_pageio_add_request(& desc, req); if (tmp___1 == 0) { nfs_list_remove_request(req); nfs_list_add_request(req, & failed); spin_lock(cinfo.lock); dreq->flags = 0; dreq->error = -5L; spin_unlock(cinfo.lock); } else { } nfs_release_request(req); req = tmp; __mptr___1 = (struct list_head const *)tmp->wb_list.next; tmp = (struct nfs_page *)__mptr___1; ldv_51618: ; if ((unsigned long )(& req->wb_list) != (unsigned long )(& reqs)) { goto ldv_51617; } else { } nfs_pageio_complete(& desc); goto ldv_51621; ldv_51620: req = nfs_list_entry(failed.next); nfs_list_remove_request(req); nfs_unlock_and_release_request(req); ldv_51621: tmp___2 = list_empty((struct list_head const *)(& failed)); if (tmp___2 == 0) { goto ldv_51620; } else { } tmp___3 = put_dreq(dreq); if (tmp___3 != 0) { nfs_direct_write_complete(dreq, dreq->inode); } else { } return; } } static void nfs_direct_commit_complete(struct nfs_commit_data *data ) { struct nfs_direct_req *dreq ; struct nfs_commit_info cinfo ; struct nfs_page *req ; int status ; long tmp ; long tmp___0 ; int tmp___1 ; long tmp___2 ; int tmp___3 ; int tmp___4 ; { dreq = data->dreq; status = data->task.tk_status; nfs_init_cinfo_from_dreq(& cinfo, dreq); if (status < 0) { tmp = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp != 0L) { printk("\001dNFS: %5u commit failed with error %d.\n", (int )data->task.tk_pid, status); } else { } dreq->flags = 2; } else { tmp___1 = memcmp((void const *)(& dreq->verf), (void const *)(& data->verf), 12UL); if (tmp___1 != 0) { tmp___0 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___0 != 0L) { printk("\001dNFS: %5u commit verify failed\n", (int )data->task.tk_pid); } else { } dreq->flags = 2; } else { } } tmp___2 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___2 != 0L) { printk("\001dNFS: %5u commit returned %d\n", (int )data->task.tk_pid, status); } else { } goto ldv_51631; ldv_51630: req = nfs_list_entry(data->pages.next); nfs_list_remove_request(req); if (dreq->flags == 2) { nfs_mark_request_commit(req, (struct pnfs_layout_segment *)0, & cinfo); } else { nfs_release_request(req); } nfs_unlock_and_release_request(req); ldv_51631: tmp___3 = list_empty((struct list_head const *)(& data->pages)); if (tmp___3 == 0) { goto ldv_51630; } else { } tmp___4 = atomic_dec_and_test(& (cinfo.mds)->rpcs_out); if (tmp___4 != 0) { nfs_direct_write_complete(dreq, data->inode); } else { } return; } } static void nfs_direct_error_cleanup(struct nfs_inode *nfsi ) { { return; } } static struct nfs_commit_completion_ops const nfs_direct_commit_completion_ops = {& nfs_direct_error_cleanup, & nfs_direct_commit_complete}; static void nfs_direct_commit_schedule(struct nfs_direct_req *dreq ) { int res ; struct nfs_commit_info cinfo ; struct list_head mds_list ; { mds_list.next = & mds_list; mds_list.prev = & mds_list; nfs_init_cinfo_from_dreq(& cinfo, dreq); nfs_scan_commit(dreq->inode, & mds_list, & cinfo); res = nfs_generic_commit_list(dreq->inode, & mds_list, 0, & cinfo); if (res < 0) { nfs_direct_write_reschedule(dreq); } else { } return; } } static void nfs_direct_write_schedule_work(struct work_struct *work ) { struct nfs_direct_req *dreq ; struct work_struct const *__mptr ; int flags ; { __mptr = (struct work_struct const *)work; dreq = (struct nfs_direct_req *)__mptr + 0xfffffffffffffed8UL; flags = dreq->flags; dreq->flags = 0; switch (flags) { case 1: nfs_direct_commit_schedule(dreq); goto ldv_51651; case 2: nfs_direct_write_reschedule(dreq); goto ldv_51651; default: nfs_inode_dio_write_done(dreq->inode); nfs_direct_complete(dreq); } ldv_51651: ; return; } } static void nfs_direct_write_complete(struct nfs_direct_req *dreq , struct inode *inode ) { { schedule_work(& dreq->work); return; } } static ssize_t nfs_direct_write_schedule_segment(struct nfs_pageio_descriptor *desc , struct iovec const *iov , loff_t pos , bool uio ) { struct nfs_direct_req *dreq ; struct nfs_open_context *ctx ; struct inode *inode ; unsigned long user_addr ; size_t count ; size_t wsize ; struct nfs_server *tmp ; unsigned int pgbase ; int result ; ssize_t started ; struct page **pagevec ; unsigned int npages ; size_t bytes ; int i ; size_t _min1 ; size_t __max1 ; size_t __max2 ; size_t _min2 ; void *tmp___0 ; struct task_struct *tmp___1 ; struct task_struct *tmp___2 ; struct task_struct *tmp___3 ; long tmp___4 ; struct task_struct *tmp___5 ; int __ret_warn_on ; long tmp___6 ; int __ret_warn_on___0 ; long tmp___7 ; long tmp___8 ; struct nfs_page *req ; unsigned int req_len ; size_t __min1 ; size_t __min2 ; long tmp___9 ; long tmp___10 ; int tmp___11 ; { dreq = desc->pg_dreq; ctx = dreq->ctx; inode = (ctx->dentry)->d_inode; user_addr = (unsigned long )iov->iov_base; count = iov->iov_len; tmp = NFS_SERVER((struct inode const *)inode); wsize = (size_t )tmp->wsize; started = 0L; pagevec = (struct page **)0; ldv_51699: pgbase = (unsigned int )user_addr & 4095U; __max1 = wsize; __max2 = 4096UL; _min1 = __max1 > __max2 ? __max1 : __max2; _min2 = count; bytes = _min1 < _min2 ? _min1 : _min2; result = -12; npages = nfs_page_array_len(pgbase, bytes); if ((unsigned long )pagevec == (unsigned long )((struct page **)0)) { tmp___0 = kmalloc((unsigned long )npages * 8UL, 208U); pagevec = (struct page **)tmp___0; } else { } if ((unsigned long )pagevec == (unsigned long )((struct page **)0)) { goto ldv_51686; } else { } if ((int )uio) { tmp___1 = get_current(); down_read(& (tmp___1->mm)->mmap_sem); tmp___2 = get_current(); tmp___3 = get_current(); tmp___4 = get_user_pages(tmp___3, tmp___2->mm, user_addr, (unsigned long )npages, 0, 0, pagevec, (struct vm_area_struct **)0); result = (int )tmp___4; tmp___5 = get_current(); up_read(& (tmp___5->mm)->mmap_sem); if (result < 0) { goto ldv_51686; } else { } } else { __ret_warn_on = npages != 1U; tmp___6 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___6 != 0L) { warn_slowpath_null("/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/direct.o.c.prepared", 860); } else { } ldv__builtin_expect(__ret_warn_on != 0, 0L); result = get_kernel_page(user_addr, 0, pagevec); __ret_warn_on___0 = result != 1; tmp___7 = ldv__builtin_expect(__ret_warn_on___0 != 0, 0L); if (tmp___7 != 0L) { warn_slowpath_null("/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/direct.o.c.prepared", 862); } else { } tmp___8 = ldv__builtin_expect(__ret_warn_on___0 != 0, 0L); if (tmp___8 != 0L) { goto ldv_51686; } else { } } if ((unsigned int )result < npages) { bytes = (unsigned long )result * 4096UL; if ((size_t )pgbase >= bytes) { nfs_direct_release_pages(pagevec, (unsigned int )result); goto ldv_51686; } else { } bytes = bytes - (size_t )pgbase; npages = (unsigned int )result; } else { } i = 0; goto ldv_51698; ldv_51697: __min1 = bytes; __min2 = 4096UL - (unsigned long )pgbase; req_len = (unsigned int )(__min1 < __min2 ? __min1 : __min2); req = nfs_create_request(dreq->ctx, dreq->inode, *(pagevec + (unsigned long )i), pgbase, req_len); tmp___10 = IS_ERR((void const *)req); if (tmp___10 != 0L) { tmp___9 = PTR_ERR((void const *)req); result = (int )tmp___9; goto ldv_51696; } else { } nfs_lock_request(req); req->wb_index = (unsigned long )(pos >> 12); req->wb_offset = (unsigned int )pos & 4095U; tmp___11 = nfs_pageio_add_request(desc, req); if (tmp___11 == 0) { result = desc->pg_error; nfs_unlock_and_release_request(req); goto ldv_51696; } else { } pgbase = 0U; bytes = bytes - (size_t )req_len; started = (ssize_t )req_len + started; user_addr = (unsigned long )req_len + user_addr; pos = (loff_t )req_len + pos; count = count - (size_t )req_len; dreq->bytes_left = dreq->bytes_left - (ssize_t )req_len; i = i + 1; ldv_51698: ; if ((unsigned int )i < npages) { goto ldv_51697; } else { } ldv_51696: nfs_direct_release_pages(pagevec, npages); if (count != 0UL && result >= 0) { goto ldv_51699; } else { } ldv_51686: kfree((void const *)pagevec); if (started != 0L) { return (started); } else { } return (result < 0 ? (ssize_t )result : -14L); } } static void nfs_direct_write_completion(struct nfs_pgio_header *hdr ) { struct nfs_direct_req *dreq ; struct nfs_commit_info cinfo ; int bit ; struct nfs_page *req ; struct nfs_page *tmp ; int tmp___0 ; int tmp___1 ; size_t __len ; void *__ret ; int tmp___2 ; int tmp___3 ; int tmp___4 ; int tmp___5 ; int tmp___6 ; { dreq = hdr->dreq; bit = -1; tmp = nfs_list_entry(hdr->pages.next); req = tmp; tmp___0 = constant_test_bit(2L, (unsigned long const volatile *)(& hdr->flags)); if (tmp___0 != 0) { goto out_put; } else { } nfs_init_cinfo_from_dreq(& cinfo, dreq); spin_lock(& dreq->lock); tmp___1 = constant_test_bit(0L, (unsigned long const volatile *)(& hdr->flags)); if (tmp___1 != 0) { dreq->flags = 0; dreq->error = (ssize_t )hdr->error; } else { } if (dreq->error != 0L) { bit = 0; } else { dreq->count = (ssize_t )((unsigned long )dreq->count + hdr->good_bytes); tmp___4 = constant_test_bit(4L, (unsigned long const volatile *)(& hdr->flags)); if (tmp___4 != 0) { dreq->flags = 2; bit = 4; } else { tmp___3 = constant_test_bit(3L, (unsigned long const volatile *)(& hdr->flags)); if (tmp___3 != 0) { if (dreq->flags == 2) { bit = 4; } else if (dreq->flags == 0) { __len = 12UL; if (__len > 63UL) { __ret = __memcpy((void *)(& dreq->verf), (void const *)hdr->verf, __len); } else { __ret = __builtin_memcpy((void *)(& dreq->verf), (void const *)hdr->verf, __len); } bit = 3; dreq->flags = 1; } else if (dreq->flags == 1) { tmp___2 = memcmp((void const *)(& dreq->verf), (void const *)hdr->verf, 12UL); if (tmp___2 != 0) { dreq->flags = 2; bit = 4; } else { bit = 3; } } else { } } else { } } } spin_unlock(& dreq->lock); goto ldv_51714; ldv_51713: req = nfs_list_entry(hdr->pages.next); nfs_list_remove_request(req); switch (bit) { case 4: ; case 3: kref_get(& req->wb_kref); nfs_mark_request_commit(req, hdr->lseg, & cinfo); } nfs_unlock_and_release_request(req); ldv_51714: tmp___5 = list_empty((struct list_head const *)(& hdr->pages)); if (tmp___5 == 0) { goto ldv_51713; } else { } out_put: tmp___6 = put_dreq(dreq); if (tmp___6 != 0) { nfs_direct_write_complete(dreq, hdr->inode); } else { } (*(hdr->release))(hdr); return; } } static void nfs_write_sync_pgio_error(struct list_head *head ) { struct nfs_page *req ; int tmp ; { goto ldv_51721; ldv_51720: req = nfs_list_entry(head->next); nfs_list_remove_request(req); nfs_unlock_and_release_request(req); ldv_51721: tmp = list_empty((struct list_head const *)head); if (tmp == 0) { goto ldv_51720; } else { } return; } } static struct nfs_pgio_completion_ops const nfs_direct_write_completion_ops = {& nfs_write_sync_pgio_error, & nfs_direct_pgio_init, & nfs_direct_write_completion}; static ssize_t nfs_direct_write_schedule_iovec(struct nfs_direct_req *dreq , struct iovec const *iov , unsigned long nr_segs , loff_t pos , bool uio ) { struct nfs_pageio_descriptor desc ; struct inode *inode ; ssize_t result ; size_t requested_bytes ; unsigned long seg ; struct nfs_rpc_ops const *tmp ; struct nfs_inode *tmp___0 ; struct nfs_inode *tmp___1 ; size_t tmp___2 ; struct iovec const *vec ; int tmp___3 ; { inode = dreq->inode; result = 0L; requested_bytes = 0UL; tmp = NFS_PROTO((struct inode const *)inode); (*(tmp->write_pageio_init))(& desc, inode, 32, & nfs_direct_write_completion_ops); desc.pg_dreq = dreq; get_dreq(dreq); atomic_inc(& inode->i_dio_count); tmp___0 = NFS_I((struct inode const *)dreq->inode); tmp___1 = NFS_I((struct inode const *)dreq->inode); tmp___2 = iov_length___0(iov, nr_segs); tmp___0->write_io = tmp___1->write_io + (unsigned long long )tmp___2; seg = 0UL; goto ldv_51739; ldv_51738: vec = iov + seg; result = nfs_direct_write_schedule_segment(& desc, vec, pos, (int )uio); if (result < 0L) { goto ldv_51737; } else { } requested_bytes = requested_bytes + (unsigned long )result; if ((unsigned long )result < (unsigned long )vec->iov_len) { goto ldv_51737; } else { } pos = (loff_t )((unsigned long long )vec->iov_len + (unsigned long long )pos); seg = seg + 1UL; ldv_51739: ; if (seg < nr_segs) { goto ldv_51738; } else { } ldv_51737: nfs_pageio_complete(& desc); if (requested_bytes == 0UL) { inode_dio_done(inode); nfs_direct_req_release(dreq); return (result < 0L ? result : -5L); } else { } tmp___3 = put_dreq(dreq); if (tmp___3 != 0) { nfs_direct_write_complete(dreq, dreq->inode); } else { } return (0L); } } static ssize_t nfs_direct_write(struct kiocb *iocb , struct iovec const *iov , unsigned long nr_segs , loff_t pos , size_t count , bool uio ) { ssize_t result ; struct inode *inode ; struct nfs_direct_req *dreq ; struct nfs_lock_context *l_ctx ; struct nfs_open_context *tmp ; long tmp___0 ; bool tmp___1 ; int tmp___2 ; { result = -12L; inode = ((iocb->ki_filp)->f_mapping)->host; dreq = nfs_direct_req_alloc(); if ((unsigned long )dreq == (unsigned long )((struct nfs_direct_req *)0)) { goto out; } else { } dreq->inode = inode; dreq->bytes_left = (ssize_t )count; tmp = nfs_file_open_context(iocb->ki_filp); dreq->ctx = get_nfs_open_context(tmp); l_ctx = nfs_get_lock_context(dreq->ctx); tmp___0 = IS_ERR((void const *)l_ctx); if (tmp___0 != 0L) { result = PTR_ERR((void const *)l_ctx); goto out_release; } else { } dreq->l_ctx = l_ctx; tmp___1 = is_sync_kiocb(iocb); if (tmp___1) { tmp___2 = 0; } else { tmp___2 = 1; } if (tmp___2) { dreq->iocb = iocb; } else { } result = nfs_direct_write_schedule_iovec(dreq, iov, nr_segs, pos, (int )uio); if (result == 0L) { result = nfs_direct_wait(dreq); } else { } out_release: nfs_direct_req_release(dreq); out: ; return (result); } } ssize_t nfs_file_direct_read(struct kiocb *iocb , struct iovec const *iov , unsigned long nr_segs , loff_t pos , bool uio ) { ssize_t retval ; struct file *file ; struct address_space *mapping ; size_t count ; long tmp ; int tmp___0 ; { retval = -22L; file = iocb->ki_filp; mapping = file->f_mapping; count = iov_length___0(iov, nr_segs); nfs_add_stats___0((struct inode const *)mapping->host, 2, (long )count); tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: direct read(%s/%s, %zd@%Ld)\n", ((file->f_path.dentry)->d_parent)->d_name.name, (file->f_path.dentry)->d_name.name, count, pos); } else { } retval = 0L; if (count == 0UL) { goto out; } else { } tmp___0 = nfs_sync_mapping(mapping); retval = (ssize_t )tmp___0; if (retval != 0L) { goto out; } else { } task_io_account_read(count); retval = nfs_direct_read(iocb, iov, nr_segs, pos, (int )uio); if (retval > 0L) { iocb->ki_pos = pos + (long long )retval; } else { } out: ; return (retval); } } ssize_t nfs_file_direct_write(struct kiocb *iocb , struct iovec const *iov , unsigned long nr_segs , loff_t pos , bool uio ) { ssize_t retval ; struct file *file ; struct address_space *mapping ; size_t count ; long tmp ; int tmp___0 ; int tmp___1 ; struct inode *inode ; loff_t tmp___2 ; { retval = -22L; file = iocb->ki_filp; mapping = file->f_mapping; count = iov_length___0(iov, nr_segs); nfs_add_stats___0((struct inode const *)mapping->host, 3, (long )count); tmp = ldv__builtin_expect((nfs_debug & 64U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: direct write(%s/%s, %zd@%Ld)\n", ((file->f_path.dentry)->d_parent)->d_name.name, (file->f_path.dentry)->d_name.name, count, pos); } else { } tmp___0 = generic_write_checks(file, & pos, & count, 0); retval = (ssize_t )tmp___0; if (retval != 0L) { goto out; } else { } retval = -22L; if ((long )count < 0L) { goto out; } else { } retval = 0L; if (count == 0UL) { goto out; } else { } tmp___1 = nfs_sync_mapping(mapping); retval = (ssize_t )tmp___1; if (retval != 0L) { goto out; } else { } task_io_account_write(count); retval = nfs_direct_write(iocb, iov, nr_segs, pos, count, (int )uio); if (retval > 0L) { inode = mapping->host; iocb->ki_pos = pos + (long long )retval; spin_lock(& inode->i_lock); tmp___2 = i_size_read((struct inode const *)inode); if (tmp___2 < iocb->ki_pos) { i_size_write(inode, iocb->ki_pos); } else { } spin_unlock(& inode->i_lock); } else { } out: ; return (retval); } } int nfs_init_directcache(void) { { nfs_direct_cachep = kmem_cache_create("nfs_direct_cache", 392UL, 0UL, 1179648UL, (void (*)(void * ))0); if ((unsigned long )nfs_direct_cachep == (unsigned long )((struct kmem_cache *)0)) { return (-12); } else { } return (0); } } void nfs_destroy_directcache(void) { { kmem_cache_destroy(nfs_direct_cachep); return; } } void ldv_initialize_nfs_pgio_completion_ops_48(void) { void *tmp ; { tmp = ldv_zalloc(224UL); nfs_direct_write_completion_ops_group0 = (struct nfs_pgio_header *)tmp; return; } } void ldv_initialize_nfs_pgio_completion_ops_50(void) { void *tmp ; { tmp = ldv_zalloc(224UL); nfs_direct_read_completion_ops_group0 = (struct nfs_pgio_header *)tmp; return; } } void ldv_main_exported_50(void) { struct list_head *ldvarg101 ; void *tmp ; int tmp___0 ; { tmp = ldv_zalloc(16UL); ldvarg101 = (struct list_head *)tmp; tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_50 == 1) { nfs_read_sync_pgio_error(ldvarg101); ldv_state_variable_50 = 1; } else { } goto ldv_51796; case 1: ; if (ldv_state_variable_50 == 1) { nfs_direct_read_completion(nfs_direct_read_completion_ops_group0); ldv_state_variable_50 = 1; } else { } goto ldv_51796; case 2: ; if (ldv_state_variable_50 == 1) { nfs_direct_pgio_init(nfs_direct_read_completion_ops_group0); ldv_state_variable_50 = 1; } else { } goto ldv_51796; default: ldv_stop(); } ldv_51796: ; return; } } void ldv_main_exported_49(void) { struct nfs_commit_data *ldvarg260 ; void *tmp ; struct nfs_inode *ldvarg261 ; void *tmp___0 ; int tmp___1 ; { tmp = ldv_zalloc(688UL); ldvarg260 = (struct nfs_commit_data *)tmp; tmp___0 = ldv_zalloc(1672UL); ldvarg261 = (struct nfs_inode *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); switch (tmp___1) { case 0: ; if (ldv_state_variable_49 == 1) { nfs_direct_error_cleanup(ldvarg261); ldv_state_variable_49 = 1; } else { } goto ldv_51806; case 1: ; if (ldv_state_variable_49 == 1) { nfs_direct_commit_complete(ldvarg260); ldv_state_variable_49 = 1; } else { } goto ldv_51806; default: ldv_stop(); } ldv_51806: ; return; } } void ldv_main_exported_48(void) { struct list_head *ldvarg93 ; void *tmp ; int tmp___0 ; { tmp = ldv_zalloc(16UL); ldvarg93 = (struct list_head *)tmp; tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_48 == 1) { nfs_write_sync_pgio_error(ldvarg93); ldv_state_variable_48 = 1; } else { } goto ldv_51814; case 1: ; if (ldv_state_variable_48 == 1) { nfs_direct_write_completion(nfs_direct_write_completion_ops_group0); ldv_state_variable_48 = 1; } else { } goto ldv_51814; case 2: ; if (ldv_state_variable_48 == 1) { nfs_direct_pgio_init(nfs_direct_write_completion_ops_group0); ldv_state_variable_48 = 1; } else { } goto ldv_51814; default: ldv_stop(); } ldv_51814: ; return; } } __inline static void __list_splice(struct list_head const *list , struct list_head *prev , struct list_head *next ) { struct list_head *first ; struct list_head *last ; { first = list->next; last = list->prev; first->prev = prev; prev->next = first; last->next = next; next->prev = last; return; } } __inline static void list_splice_init(struct list_head *list , struct list_head *head ) { int tmp ; { tmp = list_empty((struct list_head const *)list); if (tmp == 0) { __list_splice((struct list_head const *)list, head, head->next); INIT_LIST_HEAD(list); } else { } return; } } extern void wake_up_bit(void * , int ) ; extern wait_queue_head_t *bit_waitqueue(void * , int ) ; extern int wake_bit_function(wait_queue_t * , unsigned int , int , void * ) ; __inline static void *kmalloc_array(size_t n , size_t size , gfp_t flags ) { void *tmp ; { if (size != 0UL && 0xffffffffffffffffUL / size < n) { return ((void *)0); } else { } tmp = __kmalloc(n * size, flags); return (tmp); } } __inline static void *kcalloc(size_t n , size_t size , gfp_t flags ) { void *tmp ; { tmp = kmalloc_array(n, size, flags | 32768U); return (tmp); } } extern void io_schedule(void) ; __inline static int PageTail(struct page const *page ) { int tmp ; { tmp = constant_test_bit(15L, (unsigned long const volatile *)(& page->flags)); return (tmp); } } extern bool __get_page_tail(struct page * ) ; __inline static void get_page(struct page *page ) { bool tmp ; long tmp___0 ; int tmp___1 ; long tmp___2 ; int tmp___3 ; long tmp___4 ; { tmp___1 = PageTail((struct page const *)page); tmp___2 = ldv__builtin_expect(tmp___1 != 0, 0L); if (tmp___2 != 0L) { tmp = __get_page_tail(page); tmp___0 = ldv__builtin_expect((long )tmp, 1L); if (tmp___0 != 0L) { return; } else { } } else { } tmp___3 = atomic_read((atomic_t const *)(& page->ldv_15471.ldv_15470.ldv_15469._count)); tmp___4 = ldv__builtin_expect(tmp___3 <= 0, 0L); if (tmp___4 != 0L) { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"include/linux/mm.h"), "i" (421), "i" (12UL)); ldv_20107: ; goto ldv_20107; } else { } atomic_inc(& page->ldv_15471.ldv_15470.ldv_15469._count); return; } } void nfs_pageio_init(struct nfs_pageio_descriptor *desc , struct inode *inode , struct nfs_pageio_ops const *pg_ops , struct nfs_pgio_completion_ops const *compl_ops , size_t bsize , int io_flags ) ; void nfs_pageio_cond_complete(struct nfs_pageio_descriptor *desc , unsigned long index ) ; bool nfs_generic_pg_test(struct nfs_pageio_descriptor *desc , struct nfs_page *prev , struct nfs_page *req ) ; int nfs_wait_on_request(struct nfs_page *req ) ; void nfs_unlock_request(struct nfs_page *req ) ; bool nfs_pgarray_set(struct nfs_page_array *p , unsigned int pagecount ) ; void nfs_pgheader_init(struct nfs_pageio_descriptor *desc , struct nfs_pgio_header *hdr , void (*release)(struct nfs_pgio_header * ) ) ; void nfs_set_pgio_error(struct nfs_pgio_header *hdr , int error , loff_t pos ) ; static struct kmem_cache *nfs_page_cachep ; bool nfs_pgarray_set(struct nfs_page_array *p , unsigned int pagecount ) { void *tmp ; { p->npages = pagecount; if (pagecount <= 8U) { p->pagevec = (struct page **)(& p->page_array); } else { tmp = kcalloc((size_t )pagecount, 8UL, 208U); p->pagevec = (struct page **)tmp; if ((unsigned long )p->pagevec == (unsigned long )((struct page **)0)) { p->npages = 0U; } else { } } return ((unsigned long )p->pagevec != (unsigned long )((struct page **)0)); } } void nfs_pgheader_init(struct nfs_pageio_descriptor *desc , struct nfs_pgio_header *hdr , void (*release)(struct nfs_pgio_header * ) ) { { hdr->req = nfs_list_entry(desc->pg_list.next); hdr->inode = desc->pg_inode; hdr->cred = ((hdr->req)->wb_context)->cred; hdr->io_start = req_offset(hdr->req); hdr->good_bytes = desc->pg_count; hdr->dreq = desc->pg_dreq; hdr->layout_private = desc->pg_layout_private; hdr->release = release; hdr->completion_ops = desc->pg_completion_ops; if ((unsigned long )(hdr->completion_ops)->init_hdr != (unsigned long )((void (*/* const */)(struct nfs_pgio_header * ))0)) { (*((hdr->completion_ops)->init_hdr))(hdr); } else { } return; } } void nfs_set_pgio_error(struct nfs_pgio_header *hdr , int error , loff_t pos ) { { spin_lock(& hdr->lock); if ((unsigned long long )pos < (unsigned long long )hdr->io_start + (unsigned long long )hdr->good_bytes) { set_bit(0L, (unsigned long volatile *)(& hdr->flags)); clear_bit(1L, (unsigned long volatile *)(& hdr->flags)); hdr->good_bytes = (unsigned long )(pos - hdr->io_start); hdr->error = error; } else { } spin_unlock(& hdr->lock); return; } } __inline static struct nfs_page *nfs_page_alloc(void) { struct nfs_page *p ; void *tmp ; { tmp = kmem_cache_zalloc(nfs_page_cachep, 16U); p = (struct nfs_page *)tmp; if ((unsigned long )p != (unsigned long )((struct nfs_page *)0)) { INIT_LIST_HEAD(& p->wb_list); } else { } return (p); } } __inline static void nfs_page_free(struct nfs_page *p ) { { kmem_cache_free(nfs_page_cachep, (void *)p); return; } } static void nfs_iocounter_inc(struct nfs_io_counter *c ) { { atomic_inc(& c->io_count); return; } } static void nfs_iocounter_dec(struct nfs_io_counter *c ) { int tmp ; { tmp = atomic_dec_and_test(& c->io_count); if (tmp != 0) { clear_bit(0L, (unsigned long volatile *)(& c->flags)); __asm__ volatile ("": : : "memory"); wake_up_bit((void *)(& c->flags), 0); } else { } return; } } static int __nfs_iocounter_wait(struct nfs_io_counter *c ) { wait_queue_head_t *wq ; wait_queue_head_t *tmp ; struct wait_bit_queue q ; struct task_struct *tmp___0 ; int ret ; int tmp___1 ; int tmp___2 ; { tmp = bit_waitqueue((void *)(& c->flags), 0); wq = tmp; tmp___0 = get_current(); q.key.flags = (void *)(& c->flags); q.key.bit_nr = 0; q.wait.flags = 0U; q.wait.private = (void *)tmp___0; q.wait.func = & wake_bit_function; q.wait.task_list.next = & q.wait.task_list; q.wait.task_list.prev = & q.wait.task_list; ret = 0; ldv_51249: prepare_to_wait(wq, & q.wait, 130); set_bit(0L, (unsigned long volatile *)(& c->flags)); tmp___1 = atomic_read((atomic_t const *)(& c->io_count)); if (tmp___1 == 0) { goto ldv_51248; } else { } ret = nfs_wait_bit_killable((void *)(& c->flags)); tmp___2 = atomic_read((atomic_t const *)(& c->io_count)); if (tmp___2 != 0) { goto ldv_51249; } else { } ldv_51248: finish_wait(wq, & q.wait); return (ret); } } int nfs_iocounter_wait(struct nfs_io_counter *c ) { int tmp ; int tmp___0 ; { tmp = atomic_read((atomic_t const *)(& c->io_count)); if (tmp == 0) { return (0); } else { } tmp___0 = __nfs_iocounter_wait(c); return (tmp___0); } } struct nfs_page *nfs_create_request(struct nfs_open_context *ctx , struct inode *inode , struct page *page , unsigned int offset , unsigned int count ) { struct nfs_page *req ; struct nfs_lock_context *l_ctx ; void *tmp ; int tmp___0 ; void *tmp___1 ; void *tmp___2 ; long tmp___3 ; { tmp___0 = constant_test_bit(2L, (unsigned long const volatile *)(& ctx->flags)); if (tmp___0 != 0) { tmp = ERR_PTR(-9L); return ((struct nfs_page *)tmp); } else { } req = nfs_page_alloc(); if ((unsigned long )req == (unsigned long )((struct nfs_page *)0)) { tmp___1 = ERR_PTR(-12L); return ((struct nfs_page *)tmp___1); } else { } l_ctx = nfs_get_lock_context(ctx); tmp___3 = IS_ERR((void const *)l_ctx); if (tmp___3 != 0L) { nfs_page_free(req); tmp___2 = ERR_CAST((void const *)l_ctx); return ((struct nfs_page *)tmp___2); } else { } req->wb_lock_context = l_ctx; nfs_iocounter_inc(& l_ctx->io_count); req->wb_page = page; req->wb_index = page_file_index(page); get_page(page); req->wb_offset = offset; req->wb_pgbase = offset; req->wb_bytes = count; req->wb_context = get_nfs_open_context(ctx); kref_init(& req->wb_kref); return (req); } } void nfs_unlock_request(struct nfs_page *req ) { int tmp ; { tmp = constant_test_bit(0L, (unsigned long const volatile *)(& req->wb_flags)); if (tmp == 0) { printk("\vNFS: Invalid unlock attempted\n"); __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/pagelist.o.c.prepared"), "i" (386), "i" (12UL)); ldv_51265: ; goto ldv_51265; } else { } __asm__ volatile ("": : : "memory"); clear_bit(0L, (unsigned long volatile *)(& req->wb_flags)); __asm__ volatile ("": : : "memory"); wake_up_bit((void *)(& req->wb_flags), 0); return; } } void nfs_unlock_and_release_request(struct nfs_page *req ) { { nfs_unlock_request(req); nfs_release_request(req); return; } } static void nfs_clear_request(struct nfs_page *req ) { struct page *page ; struct nfs_open_context *ctx ; struct nfs_lock_context *l_ctx ; { page = req->wb_page; ctx = req->wb_context; l_ctx = req->wb_lock_context; if ((unsigned long )page != (unsigned long )((struct page *)0)) { put_page(page); req->wb_page = (struct page *)0; } else { } if ((unsigned long )l_ctx != (unsigned long )((struct nfs_lock_context *)0)) { nfs_iocounter_dec(& l_ctx->io_count); nfs_put_lock_context(l_ctx); req->wb_lock_context = (struct nfs_lock_context *)0; } else { } if ((unsigned long )ctx != (unsigned long )((struct nfs_open_context *)0)) { put_nfs_open_context(ctx); req->wb_context = (struct nfs_open_context *)0; } else { } return; } } static void nfs_free_request(struct kref *kref ) { struct nfs_page *req ; struct kref const *__mptr ; { __mptr = (struct kref const *)kref; req = (struct nfs_page *)__mptr + 0xffffffffffffffc4UL; nfs_clear_request(req); nfs_page_free(req); return; } } void nfs_release_request(struct nfs_page *req ) { { kref_put(& req->wb_kref, & nfs_free_request); return; } } static int nfs_wait_bit_uninterruptible(void *word ) { { io_schedule(); return (0); } } int nfs_wait_on_request(struct nfs_page *req ) { int tmp ; { tmp = wait_on_bit((void *)(& req->wb_flags), 0, & nfs_wait_bit_uninterruptible, 2U); return (tmp); } } bool nfs_generic_pg_test(struct nfs_pageio_descriptor *desc , struct nfs_page *prev , struct nfs_page *req ) { { if (desc->pg_bsize <= 4095UL) { return (0); } else { } return (desc->pg_count + (size_t )req->wb_bytes <= desc->pg_bsize); } } void nfs_pageio_init(struct nfs_pageio_descriptor *desc , struct inode *inode , struct nfs_pageio_ops const *pg_ops , struct nfs_pgio_completion_ops const *compl_ops , size_t bsize , int io_flags ) { { INIT_LIST_HEAD(& desc->pg_list); desc->pg_bytes_written = 0UL; desc->pg_count = 0UL; desc->pg_bsize = bsize; desc->pg_base = 0U; desc->pg_moreio = 0U; desc->pg_recoalesce = 0U; desc->pg_inode = inode; desc->pg_ops = pg_ops; desc->pg_completion_ops = compl_ops; desc->pg_ioflags = io_flags; desc->pg_error = 0; desc->pg_lseg = (struct pnfs_layout_segment *)0; desc->pg_dreq = (struct nfs_direct_req *)0; desc->pg_layout_private = (void *)0; return; } } static bool nfs_match_open_context(struct nfs_open_context const *ctx1 , struct nfs_open_context const *ctx2 ) { { return ((bool )((unsigned long )ctx1->cred == (unsigned long )ctx2->cred && (unsigned long )ctx1->state == (unsigned long )ctx2->state)); } } static bool nfs_match_lock_context(struct nfs_lock_context const *l1 , struct nfs_lock_context const *l2 ) { { return ((bool )((unsigned long )l1->lockowner.l_owner == (unsigned long )l2->lockowner.l_owner && (int )l1->lockowner.l_pid == (int )l2->lockowner.l_pid)); } } static bool nfs_can_coalesce_requests(struct nfs_page *prev , struct nfs_page *req , struct nfs_pageio_descriptor *pgio ) { bool tmp ; int tmp___0 ; bool tmp___1 ; int tmp___2 ; loff_t tmp___3 ; loff_t tmp___4 ; bool tmp___5 ; { tmp = nfs_match_open_context((struct nfs_open_context const *)req->wb_context, (struct nfs_open_context const *)prev->wb_context); if (tmp) { tmp___0 = 0; } else { tmp___0 = 1; } if (tmp___0) { return (0); } else { } if ((unsigned long )(((req->wb_context)->dentry)->d_inode)->i_flock != (unsigned long )((struct file_lock *)0)) { tmp___1 = nfs_match_lock_context((struct nfs_lock_context const *)req->wb_lock_context, (struct nfs_lock_context const *)prev->wb_lock_context); if (tmp___1) { tmp___2 = 0; } else { tmp___2 = 1; } if (tmp___2) { return (0); } else { } } else { } if (req->wb_pgbase != 0U) { return (0); } else { } if (prev->wb_pgbase + prev->wb_bytes != 4096U) { return (0); } else { } tmp___3 = req_offset(req); tmp___4 = req_offset(prev); if (tmp___3 != tmp___4 + (loff_t )prev->wb_bytes) { return (0); } else { } tmp___5 = (*((pgio->pg_ops)->pg_test))(pgio, prev, req); return (tmp___5); } } static int nfs_pageio_do_add_request(struct nfs_pageio_descriptor *desc , struct nfs_page *req ) { struct nfs_page *prev ; bool tmp ; int tmp___0 ; { if (desc->pg_count != 0UL) { prev = nfs_list_entry(desc->pg_list.prev); tmp = nfs_can_coalesce_requests(prev, req, desc); if (tmp) { tmp___0 = 0; } else { tmp___0 = 1; } if (tmp___0) { return (0); } else { } } else { if ((unsigned long )(desc->pg_ops)->pg_init != (unsigned long )((void (*/* const */)(struct nfs_pageio_descriptor * , struct nfs_page * ))0)) { (*((desc->pg_ops)->pg_init))(desc, req); } else { } desc->pg_base = req->wb_pgbase; } nfs_list_remove_request(req); nfs_list_add_request(req, & desc->pg_list); desc->pg_count = desc->pg_count + (size_t )req->wb_bytes; return (1); } } static void nfs_pageio_doio(struct nfs_pageio_descriptor *desc ) { int error ; int tmp ; int tmp___0 ; int tmp___1 ; { tmp___0 = list_empty((struct list_head const *)(& desc->pg_list)); if (tmp___0 == 0) { tmp = (*((desc->pg_ops)->pg_doio))(desc); error = tmp; if (error < 0) { desc->pg_error = error; } else { desc->pg_bytes_written = desc->pg_bytes_written + desc->pg_count; } } else { } tmp___1 = list_empty((struct list_head const *)(& desc->pg_list)); if (tmp___1 != 0) { desc->pg_count = 0UL; desc->pg_base = 0U; } else { } return; } } static int __nfs_pageio_add_request(struct nfs_pageio_descriptor *desc , struct nfs_page *req ) { int tmp ; { goto ldv_51349; ldv_51348: desc->pg_moreio = 1U; nfs_pageio_doio(desc); if (desc->pg_error < 0) { return (0); } else { } desc->pg_moreio = 0U; if ((unsigned int )*((unsigned char *)desc + 44UL) != 0U) { return (0); } else { } ldv_51349: tmp = nfs_pageio_do_add_request(desc, req); if (tmp == 0) { goto ldv_51348; } else { } return (1); } } static int nfs_do_recoalesce(struct nfs_pageio_descriptor *desc ) { struct list_head head ; struct nfs_page *req ; struct list_head const *__mptr ; int tmp ; int tmp___0 ; { head.next = & head; head.prev = & head; ldv_51361: list_splice_init(& desc->pg_list, & head); desc->pg_bytes_written = desc->pg_bytes_written - desc->pg_count; desc->pg_count = 0UL; desc->pg_base = 0U; desc->pg_recoalesce = 0U; goto ldv_51358; ldv_51360: __mptr = (struct list_head const *)head.next; req = (struct nfs_page *)__mptr; nfs_list_remove_request(req); tmp = __nfs_pageio_add_request(desc, req); if (tmp != 0) { goto ldv_51358; } else { } if (desc->pg_error < 0) { return (0); } else { } goto ldv_51359; ldv_51358: tmp___0 = list_empty((struct list_head const *)(& head)); if (tmp___0 == 0) { goto ldv_51360; } else { } ldv_51359: ; if ((unsigned int )*((unsigned char *)desc + 44UL) != 0U) { goto ldv_51361; } else { } return (1); } } int nfs_pageio_add_request(struct nfs_pageio_descriptor *desc , struct nfs_page *req ) { int ret ; { ldv_51369: ret = __nfs_pageio_add_request(desc, req); if (ret != 0) { goto ldv_51368; } else { } if (desc->pg_error < 0) { goto ldv_51368; } else { } ret = nfs_do_recoalesce(desc); if (ret != 0) { goto ldv_51369; } else { } ldv_51368: ; return (ret); } } void nfs_pageio_complete(struct nfs_pageio_descriptor *desc ) { int tmp ; { ldv_51381: nfs_pageio_doio(desc); if ((unsigned int )*((unsigned char *)desc + 44UL) == 0U) { goto ldv_51380; } else { } tmp = nfs_do_recoalesce(desc); if (tmp == 0) { goto ldv_51380; } else { } goto ldv_51381; ldv_51380: ; return; } } void nfs_pageio_cond_complete(struct nfs_pageio_descriptor *desc , unsigned long index ) { struct nfs_page *prev ; struct nfs_page *tmp ; int tmp___0 ; { tmp___0 = list_empty((struct list_head const *)(& desc->pg_list)); if (tmp___0 == 0) { tmp = nfs_list_entry(desc->pg_list.prev); prev = tmp; if (prev->wb_index + 1UL != index) { nfs_pageio_complete(desc); } else { } } else { } return; } } int nfs_init_nfspagecache(void) { { nfs_page_cachep = kmem_cache_create("nfs_page", 80UL, 0UL, 8192UL, (void (*)(void * ))0); if ((unsigned long )nfs_page_cachep == (unsigned long )((struct kmem_cache *)0)) { return (-12); } else { } return (0); } } void nfs_destroy_nfspagecache(void) { { kmem_cache_destroy(nfs_page_cachep); return; } } __inline static void zero_user_segments___0(struct page *page , unsigned int start1 , unsigned int end1 , unsigned int start2 , unsigned int end2 ) { void *kaddr ; void *tmp ; long tmp___0 ; long tmp___1 ; { tmp = kmap_atomic(page); kaddr = tmp; tmp___0 = ldv__builtin_expect(end1 > 4096U, 0L); if (tmp___0 != 0L) { goto _L; } else { tmp___1 = ldv__builtin_expect(end2 > 4096U, 0L); if (tmp___1 != 0L) { _L: /* CIL Label */ __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"include/linux/highmem.h"), "i" (198), "i" (12UL)); ldv_23423: ; goto ldv_23423; } else { } } if (end1 > start1) { memset(kaddr + (unsigned long )start1, 0, (size_t )(end1 - start1)); } else { } if (end2 > start2) { memset(kaddr + (unsigned long )start2, 0, (size_t )(end2 - start2)); } else { } __kunmap_atomic(kaddr); return; } } __inline static void zero_user_segment___0(struct page *page , unsigned int start , unsigned int end ) { { zero_user_segments___0(page, start, end, 0U, 0U); return; } } __inline static void zero_user(struct page *page , unsigned int start , unsigned int size ) { { zero_user_segments___0(page, start, start + size, 0U, 0U); return; } } extern int read_cache_pages(struct address_space * , struct list_head * , filler_t * , void * ) ; extern struct rpc_task *rpc_run_task(struct rpc_task_setup const * ) ; extern void rpc_put_task(struct rpc_task * ) ; extern void rpc_exit(struct rpc_task * , int ) ; extern int rpc_restart_call_prepare(struct rpc_task * ) ; int nfs_readpage_result(struct rpc_task *task , struct nfs_read_data *data ) ; int nfs_readpage_async(struct nfs_open_context *ctx , struct inode *inode , struct page *page ) ; struct nfs_read_header *nfs_readhdr_alloc(void) ; void nfs_readhdr_free(struct nfs_pgio_header *hdr ) ; void nfs_pageio_init_read(struct nfs_pageio_descriptor *pgio , struct inode *inode , struct nfs_pgio_completion_ops const *compl_ops ) ; int nfs_initiate_read(struct rpc_clnt *clnt , struct nfs_read_data *data , struct rpc_call_ops const *call_ops , int flags ) ; void nfs_read_prepare(struct rpc_task *task , void *calldata ) ; int nfs_generic_pagein(struct nfs_pageio_descriptor *desc , struct nfs_pgio_header *hdr ) ; void nfs_pageio_reset_read_mds(struct nfs_pageio_descriptor *pgio ) ; void nfs_readdata_release(struct nfs_read_data *rdata ) ; __inline static void nfs_inc_server_stats___2(struct nfs_server const *server , enum nfs_stat_eventcounters stat ) { void const *__vpp_verify ; int pao_ID__ ; int pao_ID_____0 ; int pao_ID_____1 ; int pao_ID_____2 ; { __vpp_verify = (void const *)0; switch (8UL) { case 1UL: pao_ID__ = 1; switch (8UL) { case 1UL: ; if (pao_ID__ == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_50855; case 2UL: ; if (pao_ID__ == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50855; case 4UL: ; if (pao_ID__ == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50855; case 8UL: ; if (pao_ID__ == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_50855; default: __bad_percpu_size(); } ldv_50855: ; goto ldv_50860; case 2UL: pao_ID_____0 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____0 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_50866; case 2UL: ; if (pao_ID_____0 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50866; case 4UL: ; if (pao_ID_____0 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50866; case 8UL: ; if (pao_ID_____0 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_50866; default: __bad_percpu_size(); } ldv_50866: ; goto ldv_50860; case 4UL: pao_ID_____1 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____1 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_50876; case 2UL: ; if (pao_ID_____1 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50876; case 4UL: ; if (pao_ID_____1 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50876; case 8UL: ; if (pao_ID_____1 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_50876; default: __bad_percpu_size(); } ldv_50876: ; goto ldv_50860; case 8UL: pao_ID_____2 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____2 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_50886; case 2UL: ; if (pao_ID_____2 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50886; case 4UL: ; if (pao_ID_____2 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50886; case 8UL: ; if (pao_ID_____2 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_50886; default: __bad_percpu_size(); } ldv_50886: ; goto ldv_50860; default: __bad_size_call_parameter(); goto ldv_50860; } ldv_50860: ; return; } } __inline static void nfs_inc_stats___2(struct inode const *inode , enum nfs_stat_eventcounters stat ) { struct nfs_server *tmp ; { tmp = NFS_SERVER(inode); nfs_inc_server_stats___2((struct nfs_server const *)tmp, stat); return; } } __inline static void nfs_add_server_stats___1(struct nfs_server const *server , enum nfs_stat_bytecounters stat , long addend ) { void const *__vpp_verify ; int pao_ID__ ; int pao_ID_____0 ; int pao_ID_____1 ; int pao_ID_____2 ; { __vpp_verify = (void const *)0; switch (8UL) { case 1UL: pao_ID__ = 0; switch (8UL) { case 1UL: ; if (pao_ID__ == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_50907; case 2UL: ; if (pao_ID__ == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50907; case 4UL: ; if (pao_ID__ == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50907; case 8UL: ; if (pao_ID__ == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_50907; default: __bad_percpu_size(); } ldv_50907: ; goto ldv_50912; case 2UL: pao_ID_____0 = 0; switch (8UL) { case 1UL: ; if (pao_ID_____0 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_50918; case 2UL: ; if (pao_ID_____0 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50918; case 4UL: ; if (pao_ID_____0 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50918; case 8UL: ; if (pao_ID_____0 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_50918; default: __bad_percpu_size(); } ldv_50918: ; goto ldv_50912; case 4UL: pao_ID_____1 = 0; switch (8UL) { case 1UL: ; if (pao_ID_____1 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_50928; case 2UL: ; if (pao_ID_____1 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50928; case 4UL: ; if (pao_ID_____1 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50928; case 8UL: ; if (pao_ID_____1 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_50928; default: __bad_percpu_size(); } ldv_50928: ; goto ldv_50912; case 8UL: pao_ID_____2 = 0; switch (8UL) { case 1UL: ; if (pao_ID_____2 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_50938; case 2UL: ; if (pao_ID_____2 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50938; case 4UL: ; if (pao_ID_____2 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50938; case 8UL: ; if (pao_ID_____2 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_50938; default: __bad_percpu_size(); } ldv_50938: ; goto ldv_50912; default: __bad_size_call_parameter(); goto ldv_50912; } ldv_50912: ; return; } } __inline static void nfs_add_stats___1(struct inode const *inode , enum nfs_stat_bytecounters stat , long addend ) { struct nfs_server *tmp ; { tmp = NFS_SERVER(inode); nfs_add_server_stats___1((struct nfs_server const *)tmp, stat, addend); return; } } int __nfs_readpage_from_fscache(struct nfs_open_context *ctx , struct inode *inode , struct page *page ) ; int __nfs_readpages_from_fscache(struct nfs_open_context *ctx , struct inode *inode , struct address_space *mapping , struct list_head *pages , unsigned int *nr_pages ) ; void __nfs_readpage_to_fscache(struct inode *inode , struct page *page , int sync ) ; __inline static int nfs_readpage_from_fscache(struct nfs_open_context *ctx , struct inode *inode , struct page *page ) { int tmp ; struct nfs_inode *tmp___0 ; { tmp___0 = NFS_I((struct inode const *)inode); if ((unsigned long )tmp___0->fscache != (unsigned long )((struct fscache_cookie *)0)) { tmp = __nfs_readpage_from_fscache(ctx, inode, page); return (tmp); } else { } return (-105); } } __inline static int nfs_readpages_from_fscache(struct nfs_open_context *ctx , struct inode *inode , struct address_space *mapping , struct list_head *pages , unsigned int *nr_pages ) { int tmp ; struct nfs_inode *tmp___0 ; { tmp___0 = NFS_I((struct inode const *)inode); if ((unsigned long )tmp___0->fscache != (unsigned long )((struct fscache_cookie *)0)) { tmp = __nfs_readpages_from_fscache(ctx, inode, mapping, pages, nr_pages); return (tmp); } else { } return (-105); } } __inline static void nfs_readpage_to_fscache(struct inode *inode , struct page *page , int sync ) { int tmp ; { tmp = PagePrivate2((struct page const *)page); if (tmp != 0) { __nfs_readpage_to_fscache(inode, page, sync); } else { } return; } } static struct nfs_pageio_ops const nfs_pageio_read_ops ; static struct rpc_call_ops const nfs_read_common_ops ; static struct nfs_pgio_completion_ops const nfs_async_read_completion_ops ; static struct kmem_cache *nfs_rdata_cachep ; struct nfs_read_header *nfs_readhdr_alloc(void) { struct nfs_read_header *rhdr ; void *tmp ; struct nfs_pgio_header *hdr ; struct lock_class_key __key ; { tmp = kmem_cache_zalloc(nfs_rdata_cachep, 208U); rhdr = (struct nfs_read_header *)tmp; if ((unsigned long )rhdr != (unsigned long )((struct nfs_read_header *)0)) { hdr = & rhdr->header; INIT_LIST_HEAD(& hdr->pages); INIT_LIST_HEAD(& hdr->rpc_list); spinlock_check(& hdr->lock); __raw_spin_lock_init(& hdr->lock.ldv_6140.rlock, "&(&hdr->lock)->rlock", & __key); atomic_set(& hdr->refcnt, 0); } else { } return (rhdr); } } static struct nfs_read_data *nfs_readdata_alloc(struct nfs_pgio_header *hdr , unsigned int pagecount ) { struct nfs_read_data *data ; struct nfs_read_data *prealloc ; struct nfs_pgio_header const *__mptr ; void *tmp ; bool tmp___0 ; { __mptr = (struct nfs_pgio_header const *)hdr; prealloc = & ((struct nfs_read_header *)__mptr)->rpc_data; if ((unsigned long )prealloc->header == (unsigned long )((struct nfs_pgio_header *)0)) { data = prealloc; } else { tmp = kzalloc(720UL, 208U); data = (struct nfs_read_data *)tmp; } if ((unsigned long )data == (unsigned long )((struct nfs_read_data *)0)) { goto out; } else { } tmp___0 = nfs_pgarray_set(& data->pages, pagecount); if ((int )tmp___0) { data->header = hdr; atomic_inc(& hdr->refcnt); } else { if ((unsigned long )data != (unsigned long )prealloc) { kfree((void const *)data); } else { } data = (struct nfs_read_data *)0; } out: ; return (data); } } void nfs_readhdr_free(struct nfs_pgio_header *hdr ) { struct nfs_read_header *rhdr ; struct nfs_pgio_header const *__mptr ; { __mptr = (struct nfs_pgio_header const *)hdr; rhdr = (struct nfs_read_header *)__mptr; kmem_cache_free(nfs_rdata_cachep, (void *)rhdr); return; } } void nfs_readdata_release(struct nfs_read_data *rdata ) { struct nfs_pgio_header *hdr ; struct nfs_read_header *read_header ; struct nfs_pgio_header const *__mptr ; int tmp ; { hdr = rdata->header; __mptr = (struct nfs_pgio_header const *)hdr; read_header = (struct nfs_read_header *)__mptr; put_nfs_open_context(rdata->args.context); if ((unsigned long )rdata->pages.pagevec != (unsigned long )((struct page **)(& rdata->pages.page_array))) { kfree((void const *)rdata->pages.pagevec); } else { } if ((unsigned long )(& read_header->rpc_data) == (unsigned long )rdata) { rdata->header = (struct nfs_pgio_header *)0; rdata = (struct nfs_read_data *)0; } else { } tmp = atomic_dec_and_test(& hdr->refcnt); if (tmp != 0) { (*((hdr->completion_ops)->completion))(hdr); } else { } kfree((void const *)rdata); return; } } static int nfs_return_empty_page(struct page *page ) { { zero_user(page, 0U, 4096U); SetPageUptodate(page); unlock_page(page); return (0); } } void nfs_pageio_init_read(struct nfs_pageio_descriptor *pgio , struct inode *inode , struct nfs_pgio_completion_ops const *compl_ops ) { struct nfs_server *tmp ; { tmp = NFS_SERVER((struct inode const *)inode); nfs_pageio_init(pgio, inode, & nfs_pageio_read_ops, compl_ops, (size_t )tmp->rsize, 0); return; } } void nfs_pageio_reset_read_mds(struct nfs_pageio_descriptor *pgio ) { struct nfs_server *tmp ; { pgio->pg_ops = & nfs_pageio_read_ops; tmp = NFS_SERVER((struct inode const *)pgio->pg_inode); pgio->pg_bsize = (size_t )tmp->rsize; return; } } int nfs_readpage_async(struct nfs_open_context *ctx , struct inode *inode , struct page *page ) { struct nfs_page *new ; unsigned int len ; struct nfs_pageio_descriptor pgio ; int tmp ; long tmp___0 ; long tmp___1 ; struct nfs_rpc_ops const *tmp___2 ; struct nfs_inode *tmp___3 ; struct nfs_inode *tmp___4 ; { len = nfs_page_length(page); if (len == 0U) { tmp = nfs_return_empty_page(page); return (tmp); } else { } new = nfs_create_request(ctx, inode, page, 0U, len); tmp___1 = IS_ERR((void const *)new); if (tmp___1 != 0L) { unlock_page(page); tmp___0 = PTR_ERR((void const *)new); return ((int )tmp___0); } else { } if (len <= 4095U) { zero_user_segment___0(page, len, 4096U); } else { } tmp___2 = NFS_PROTO((struct inode const *)inode); (*(tmp___2->read_pageio_init))(& pgio, inode, & nfs_async_read_completion_ops); nfs_pageio_add_request(& pgio, new); nfs_pageio_complete(& pgio); tmp___3 = NFS_I((struct inode const *)inode); tmp___4 = NFS_I((struct inode const *)inode); tmp___3->read_io = tmp___4->read_io + (unsigned long long )pgio.pg_bytes_written; return (0); } } static void nfs_readpage_release(struct nfs_page *req ) { struct inode *d_inode ; int tmp ; loff_t tmp___0 ; __u64 tmp___1 ; long tmp___2 ; { d_inode = ((req->wb_context)->dentry)->d_inode; tmp = PageUptodate(req->wb_page); if (tmp != 0) { nfs_readpage_to_fscache(d_inode, req->wb_page, 0); } else { } unlock_page(req->wb_page); tmp___2 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___2 != 0L) { tmp___0 = req_offset(req); tmp___1 = NFS_FILEID((struct inode const *)((req->wb_context)->dentry)->d_inode); printk("\001dNFS: read done (%s/%Ld %d@%Ld)\n", (char *)(& ((((req->wb_context)->dentry)->d_inode)->i_sb)->s_id), (long long )tmp___1, req->wb_bytes, tmp___0); } else { } nfs_release_request(req); return; } } static void nfs_read_completion(struct nfs_pgio_header *hdr ) { unsigned long bytes ; int tmp ; struct nfs_page *req ; struct nfs_page *tmp___0 ; struct page *page ; int tmp___1 ; int tmp___2 ; int tmp___3 ; { bytes = 0UL; tmp = constant_test_bit(2L, (unsigned long const volatile *)(& hdr->flags)); if (tmp != 0) { goto out; } else { } goto ldv_51491; ldv_51490: tmp___0 = nfs_list_entry(hdr->pages.next); req = tmp___0; page = req->wb_page; tmp___1 = constant_test_bit(1L, (unsigned long const volatile *)(& hdr->flags)); if (tmp___1 != 0) { if (hdr->good_bytes < bytes) { zero_user(page, 0U, 4096U); } else if (hdr->good_bytes - bytes <= 4095UL) { zero_user_segment___0(page, (unsigned int )hdr->good_bytes & 4095U, 4096U); } else { } } else { } bytes = (unsigned long )req->wb_bytes + bytes; tmp___2 = constant_test_bit(0L, (unsigned long const volatile *)(& hdr->flags)); if (tmp___2 != 0) { if (hdr->good_bytes >= bytes) { SetPageUptodate(page); } else { } } else { SetPageUptodate(page); } nfs_list_remove_request(req); nfs_readpage_release(req); ldv_51491: tmp___3 = list_empty((struct list_head const *)(& hdr->pages)); if (tmp___3 == 0) { goto ldv_51490; } else { } out: (*(hdr->release))(hdr); return; } } int nfs_initiate_read(struct rpc_clnt *clnt , struct nfs_read_data *data , struct rpc_call_ops const *call_ops , int flags ) { struct inode *inode ; int swap_flags ; struct rpc_task *task ; struct rpc_message msg ; struct rpc_task_setup task_setup_data ; struct nfs_rpc_ops const *tmp ; __u64 tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; { inode = (data->header)->inode; swap_flags = (inode->i_flags & 256U) != 0U ? 66 : 0; msg.rpc_proc = 0; msg.rpc_argp = (void *)(& data->args); msg.rpc_resp = (void *)(& data->res); msg.rpc_cred = (data->header)->cred; task_setup_data.task = & data->task; task_setup_data.rpc_client = clnt; task_setup_data.rpc_message = (struct rpc_message const *)(& msg); task_setup_data.callback_ops = call_ops; task_setup_data.callback_data = (void *)data; task_setup_data.workqueue = nfsiod_workqueue; task_setup_data.flags = (unsigned short )(((int )((short )swap_flags) | 1) | (int )((short )flags)); task_setup_data.priority = (signed char)0; tmp = NFS_PROTO((struct inode const *)inode); (*(tmp->read_setup))(data, & msg); tmp___1 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___1 != 0L) { tmp___0 = NFS_FILEID((struct inode const *)inode); printk("\001dNFS: %5u initiated read call (req %s/%lld, %u bytes @ offset %llu)\n", (int )data->task.tk_pid, (char *)(& (inode->i_sb)->s_id), (long long )tmp___0, data->args.count, data->args.offset); } else { } task = rpc_run_task((struct rpc_task_setup const *)(& task_setup_data)); tmp___3 = IS_ERR((void const *)task); if (tmp___3 != 0L) { tmp___2 = PTR_ERR((void const *)task); return ((int )tmp___2); } else { } rpc_put_task(task); return (0); } } static void nfs_read_rpcsetup(struct nfs_read_data *data , unsigned int count , unsigned int offset ) { struct nfs_page *req ; loff_t tmp ; { req = (data->header)->req; data->args.fh = NFS_FH((struct inode const *)(data->header)->inode); tmp = req_offset(req); data->args.offset = (__u64 )(tmp + (loff_t )offset); data->args.pgbase = req->wb_pgbase + offset; data->args.pages = data->pages.pagevec; data->args.count = count; data->args.context = get_nfs_open_context(req->wb_context); data->args.lock_context = req->wb_lock_context; data->res.fattr = & data->fattr; data->res.count = count; data->res.eof = 0; nfs_fattr_init(& data->fattr); return; } } static int nfs_do_read(struct nfs_read_data *data , struct rpc_call_ops const *call_ops ) { struct inode *inode ; struct rpc_clnt *tmp ; int tmp___0 ; { inode = (data->header)->inode; tmp = NFS_CLIENT((struct inode const *)inode); tmp___0 = nfs_initiate_read(tmp, data, call_ops, 0); return (tmp___0); } } static int nfs_do_multiple_reads(struct list_head *head , struct rpc_call_ops const *call_ops ) { struct nfs_read_data *data ; int ret ; int ret2 ; struct list_head const *__mptr ; int tmp ; { ret = 0; goto ldv_51534; ldv_51533: __mptr = (struct list_head const *)head->next; data = (struct nfs_read_data *)__mptr + 0xfffffffffffffff8UL; list_del_init(& data->list); ret2 = nfs_do_read(data, call_ops); if (ret == 0) { ret = ret2; } else { } ldv_51534: tmp = list_empty((struct list_head const *)head); if (tmp == 0) { goto ldv_51533; } else { } return (ret); } } static void nfs_async_read_error(struct list_head *head ) { struct nfs_page *req ; int tmp ; { goto ldv_51541; ldv_51540: req = nfs_list_entry(head->next); nfs_list_remove_request(req); nfs_readpage_release(req); ldv_51541: tmp = list_empty((struct list_head const *)head); if (tmp == 0) { goto ldv_51540; } else { } return; } } static struct nfs_pgio_completion_ops const nfs_async_read_completion_ops = {& nfs_async_read_error, 0, & nfs_read_completion}; static void nfs_pagein_error(struct nfs_pageio_descriptor *desc , struct nfs_pgio_header *hdr ) { struct nfs_read_data *data ; struct list_head const *__mptr ; int tmp ; { set_bit(2L, (unsigned long volatile *)(& hdr->flags)); goto ldv_51552; ldv_51551: __mptr = (struct list_head const *)hdr->rpc_list.next; data = (struct nfs_read_data *)__mptr + 0xfffffffffffffff8UL; list_del(& data->list); nfs_readdata_release(data); ldv_51552: tmp = list_empty((struct list_head const *)(& hdr->rpc_list)); if (tmp == 0) { goto ldv_51551; } else { } (*((desc->pg_completion_ops)->error_cleanup))(& desc->pg_list); return; } } static int nfs_pagein_multi(struct nfs_pageio_descriptor *desc , struct nfs_pgio_header *hdr ) { struct nfs_page *req ; struct page *page ; struct nfs_read_data *data ; size_t rsize ; size_t nbytes ; unsigned int offset ; size_t len ; size_t _min1 ; size_t _min2 ; { req = hdr->req; page = req->wb_page; rsize = desc->pg_bsize; offset = 0U; nbytes = desc->pg_count; ldv_51568: _min1 = nbytes; _min2 = rsize; len = _min1 < _min2 ? _min1 : _min2; data = nfs_readdata_alloc(hdr, 1U); if ((unsigned long )data == (unsigned long )((struct nfs_read_data *)0)) { nfs_pagein_error(desc, hdr); return (-12); } else { } *(data->pages.pagevec) = page; nfs_read_rpcsetup(data, (unsigned int )len, offset); list_add(& data->list, & hdr->rpc_list); nbytes = nbytes - len; offset = (unsigned int )len + offset; if (nbytes != 0UL) { goto ldv_51568; } else { } nfs_list_remove_request(req); nfs_list_add_request(req, & hdr->pages); desc->pg_rpc_callops = & nfs_read_common_ops; return (0); } } static int nfs_pagein_one(struct nfs_pageio_descriptor *desc , struct nfs_pgio_header *hdr ) { struct nfs_page *req ; struct page **pages ; struct nfs_read_data *data ; struct list_head *head ; unsigned int tmp ; struct page **tmp___0 ; int tmp___1 ; { head = & desc->pg_list; tmp = nfs_page_array_len(desc->pg_base, desc->pg_count); data = nfs_readdata_alloc(hdr, tmp); if ((unsigned long )data == (unsigned long )((struct nfs_read_data *)0)) { nfs_pagein_error(desc, hdr); return (-12); } else { } pages = data->pages.pagevec; goto ldv_51579; ldv_51578: req = nfs_list_entry(head->next); nfs_list_remove_request(req); nfs_list_add_request(req, & hdr->pages); tmp___0 = pages; pages = pages + 1; *tmp___0 = req->wb_page; ldv_51579: tmp___1 = list_empty((struct list_head const *)head); if (tmp___1 == 0) { goto ldv_51578; } else { } nfs_read_rpcsetup(data, (unsigned int )desc->pg_count, 0U); list_add(& data->list, & hdr->rpc_list); desc->pg_rpc_callops = & nfs_read_common_ops; return (0); } } int nfs_generic_pagein(struct nfs_pageio_descriptor *desc , struct nfs_pgio_header *hdr ) { int tmp ; int tmp___0 ; { if (desc->pg_bsize <= 4095UL) { tmp = nfs_pagein_multi(desc, hdr); return (tmp); } else { } tmp___0 = nfs_pagein_one(desc, hdr); return (tmp___0); } } static int nfs_generic_pg_readpages(struct nfs_pageio_descriptor *desc ) { struct nfs_read_header *rhdr ; struct nfs_pgio_header *hdr ; int ret ; int tmp ; { rhdr = nfs_readhdr_alloc(); if ((unsigned long )rhdr == (unsigned long )((struct nfs_read_header *)0)) { (*((desc->pg_completion_ops)->error_cleanup))(& desc->pg_list); return (-12); } else { } hdr = & rhdr->header; nfs_pgheader_init(desc, hdr, & nfs_readhdr_free); atomic_inc(& hdr->refcnt); ret = nfs_generic_pagein(desc, hdr); if (ret == 0) { ret = nfs_do_multiple_reads(& hdr->rpc_list, desc->pg_rpc_callops); } else { } tmp = atomic_dec_and_test(& hdr->refcnt); if (tmp != 0) { (*((hdr->completion_ops)->completion))(hdr); } else { } return (ret); } } static struct nfs_pageio_ops const nfs_pageio_read_ops = {0, & nfs_generic_pg_test, & nfs_generic_pg_readpages}; int nfs_readpage_result(struct rpc_task *task , struct nfs_read_data *data ) { struct inode *inode ; int status ; long tmp ; struct nfs_rpc_ops const *tmp___0 ; struct nfs_inode *tmp___1 ; { inode = (data->header)->inode; tmp = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: %s: %5u, (status %d)\n", "nfs_readpage_result", (int )task->tk_pid, task->tk_status); } else { } tmp___0 = NFS_PROTO((struct inode const *)inode); status = (*(tmp___0->read_done))(task, data); if (status != 0) { return (status); } else { } nfs_add_stats___1((struct inode const *)inode, 4, (long )data->res.count); if (task->tk_status == -116) { tmp___1 = NFS_I((struct inode const *)inode); set_bit(1L, (unsigned long volatile *)(& tmp___1->flags)); nfs_mark_for_revalidate(inode); } else { } return (0); } } static void nfs_readpage_retry(struct rpc_task *task , struct nfs_read_data *data ) { struct nfs_readargs *argp ; struct nfs_readres *resp ; { argp = & data->args; resp = & data->res; nfs_inc_stats___2((struct inode const *)(data->header)->inode, 22); if (resp->count == 0U) { nfs_set_pgio_error(data->header, -5, (loff_t )argp->offset); return; } else { } data->mds_offset = data->mds_offset + (__u64 )resp->count; argp->offset = argp->offset + (__u64 )resp->count; argp->pgbase = argp->pgbase + resp->count; argp->count = argp->count - resp->count; rpc_restart_call_prepare(task); return; } } static void nfs_readpage_result_common(struct rpc_task *task , void *calldata ) { struct nfs_read_data *data ; struct nfs_pgio_header *hdr ; int tmp ; loff_t bound ; { data = (struct nfs_read_data *)calldata; hdr = data->header; tmp = nfs_readpage_result(task, data); if (tmp != 0) { return; } else { } if (task->tk_status < 0) { nfs_set_pgio_error(hdr, task->tk_status, (loff_t )data->args.offset); } else if (data->res.eof != 0) { bound = (loff_t )(data->args.offset + (__u64 )data->res.count); spin_lock(& hdr->lock); if ((unsigned long long )bound < (unsigned long long )hdr->io_start + (unsigned long long )hdr->good_bytes) { set_bit(1L, (unsigned long volatile *)(& hdr->flags)); clear_bit(0L, (unsigned long volatile *)(& hdr->flags)); hdr->good_bytes = (unsigned long )(bound - hdr->io_start); } else { } spin_unlock(& hdr->lock); } else if (data->res.count != data->args.count) { nfs_readpage_retry(task, data); } else { } return; } } static void nfs_readpage_release_common(void *calldata ) { { nfs_readdata_release((struct nfs_read_data *)calldata); return; } } void nfs_read_prepare(struct rpc_task *task , void *calldata ) { struct nfs_read_data *data ; int err ; struct nfs_rpc_ops const *tmp ; { data = (struct nfs_read_data *)calldata; tmp = NFS_PROTO((struct inode const *)(data->header)->inode); err = (*(tmp->read_rpc_prepare))(task, data); if (err != 0) { rpc_exit(task, err); } else { } return; } } static struct rpc_call_ops const nfs_read_common_ops = {& nfs_read_prepare, & nfs_readpage_result_common, 0, & nfs_readpage_release_common}; int nfs_readpage(struct file *file , struct page *page ) { struct nfs_open_context *ctx ; struct inode *inode ; struct address_space *tmp ; int error ; unsigned long tmp___0 ; long tmp___1 ; int tmp___2 ; int tmp___3 ; struct nfs_open_context *tmp___4 ; { tmp = page_file_mapping(page); inode = tmp->host; tmp___1 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___1 != 0L) { tmp___0 = page_file_index(page); printk("\001dNFS: nfs_readpage (%p %ld@%lu)\n", page, 4096UL, tmp___0); } else { } nfs_inc_stats___2((struct inode const *)inode, 8); nfs_add_stats___1((struct inode const *)inode, 6, 1L); error = nfs_wb_page(inode, page); if (error != 0) { goto out_unlock; } else { } tmp___2 = PageUptodate(page); if (tmp___2 != 0) { goto out_unlock; } else { } error = -116; tmp___3 = NFS_STALE((struct inode const *)inode); if (tmp___3 != 0) { goto out_unlock; } else { } if ((unsigned long )file == (unsigned long )((struct file *)0)) { error = -9; ctx = nfs_find_open_context(inode, (struct rpc_cred *)0, 1U); if ((unsigned long )ctx == (unsigned long )((struct nfs_open_context *)0)) { goto out_unlock; } else { } } else { tmp___4 = nfs_file_open_context(file); ctx = get_nfs_open_context(tmp___4); } if (((inode->i_sb)->s_flags & 16UL) == 0UL && (inode->i_flags & 1U) == 0U) { error = nfs_readpage_from_fscache(ctx, inode, page); if (error == 0) { goto out; } else { } } else { } error = nfs_readpage_async(ctx, inode, page); out: put_nfs_open_context(ctx); return (error); out_unlock: unlock_page(page); return (error); } } static int readpage_async_filler(void *data , struct page *page ) { struct nfs_readdesc *desc ; struct inode *inode ; struct address_space *tmp ; struct nfs_page *new ; unsigned int len ; int error ; int tmp___0 ; long tmp___1 ; int tmp___2 ; long tmp___3 ; { desc = (struct nfs_readdesc *)data; tmp = page_file_mapping(page); inode = tmp->host; len = nfs_page_length(page); if (len == 0U) { tmp___0 = nfs_return_empty_page(page); return (tmp___0); } else { } new = nfs_create_request(desc->ctx, inode, page, 0U, len); tmp___1 = IS_ERR((void const *)new); if (tmp___1 != 0L) { goto out_error; } else { } if (len <= 4095U) { zero_user_segment___0(page, len, 4096U); } else { } tmp___2 = nfs_pageio_add_request(desc->pgio, new); if (tmp___2 == 0) { error = (desc->pgio)->pg_error; goto out_unlock; } else { } return (0); out_error: tmp___3 = PTR_ERR((void const *)new); error = (int )tmp___3; out_unlock: unlock_page(page); return (error); } } int nfs_readpages(struct file *filp , struct address_space *mapping , struct list_head *pages , unsigned int nr_pages ) { struct nfs_pageio_descriptor pgio ; struct nfs_readdesc desc ; struct inode *inode ; unsigned long npages ; int ret ; __u64 tmp ; long tmp___0 ; int tmp___1 ; struct nfs_open_context *tmp___2 ; struct nfs_rpc_ops const *tmp___3 ; struct nfs_inode *tmp___4 ; struct nfs_inode *tmp___5 ; { desc.pgio = & pgio; desc.ctx = 0; inode = mapping->host; ret = -116; tmp___0 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___0 != 0L) { tmp = NFS_FILEID((struct inode const *)inode); printk("\001dNFS: nfs_readpages (%s/%Ld %d)\n", (char *)(& (inode->i_sb)->s_id), (long long )tmp, nr_pages); } else { } nfs_inc_stats___2((struct inode const *)inode, 9); tmp___1 = NFS_STALE((struct inode const *)inode); if (tmp___1 != 0) { goto out; } else { } if ((unsigned long )filp == (unsigned long )((struct file *)0)) { desc.ctx = nfs_find_open_context(inode, (struct rpc_cred *)0, 1U); if ((unsigned long )desc.ctx == (unsigned long )((struct nfs_open_context *)0)) { return (-9); } else { } } else { tmp___2 = nfs_file_open_context(filp); desc.ctx = get_nfs_open_context(tmp___2); } ret = nfs_readpages_from_fscache(desc.ctx, inode, mapping, pages, & nr_pages); if (ret == 0) { goto read_complete; } else { } tmp___3 = NFS_PROTO((struct inode const *)inode); (*(tmp___3->read_pageio_init))(& pgio, inode, & nfs_async_read_completion_ops); ret = read_cache_pages(mapping, pages, & readpage_async_filler, (void *)(& desc)); nfs_pageio_complete(& pgio); tmp___4 = NFS_I((struct inode const *)inode); tmp___5 = NFS_I((struct inode const *)inode); tmp___4->read_io = tmp___5->read_io + (unsigned long long )pgio.pg_bytes_written; npages = (pgio.pg_bytes_written + 4095UL) >> 12; nfs_add_stats___1((struct inode const *)inode, 6, (long )npages); read_complete: put_nfs_open_context(desc.ctx); out: ; return (ret); } } int nfs_init_readpagecache(void) { { nfs_rdata_cachep = kmem_cache_create("nfs_read_data", 944UL, 0UL, 8192UL, (void (*)(void * ))0); if ((unsigned long )nfs_rdata_cachep == (unsigned long )((struct kmem_cache *)0)) { return (-12); } else { } return (0); } } void nfs_destroy_readpagecache(void) { { kmem_cache_destroy(nfs_rdata_cachep); return; } } void ldv_initialize_rpc_call_ops_45(void) { void *tmp ; { tmp = ldv_zalloc(240UL); nfs_read_common_ops_group0 = (struct rpc_task *)tmp; return; } } void ldv_initialize_nfs_pageio_ops_46(void) { void *tmp ; { tmp = ldv_zalloc(112UL); nfs_pageio_read_ops_group0 = (struct nfs_pageio_descriptor *)tmp; return; } } void ldv_main_exported_46(void) { struct nfs_page *ldvarg276 ; void *tmp ; struct nfs_page *ldvarg277 ; void *tmp___0 ; int tmp___1 ; { tmp = ldv_zalloc(80UL); ldvarg276 = (struct nfs_page *)tmp; tmp___0 = ldv_zalloc(80UL); ldvarg277 = (struct nfs_page *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); switch (tmp___1) { case 0: ; if (ldv_state_variable_46 == 1) { nfs_generic_pg_test(nfs_pageio_read_ops_group0, ldvarg277, ldvarg276); ldv_state_variable_46 = 1; } else { } goto ldv_51683; case 1: ; if (ldv_state_variable_46 == 1) { nfs_generic_pg_readpages(nfs_pageio_read_ops_group0); ldv_state_variable_46 = 1; } else { } goto ldv_51683; default: ldv_stop(); } ldv_51683: ; return; } } void ldv_main_exported_45(void) { void *ldvarg155 ; void *tmp ; void *ldvarg156 ; void *tmp___0 ; void *ldvarg154 ; void *tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(1UL); ldvarg155 = tmp; tmp___0 = ldv_zalloc(1UL); ldvarg156 = tmp___0; tmp___1 = ldv_zalloc(1UL); ldvarg154 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_45 == 1) { nfs_readpage_result_common(nfs_read_common_ops_group0, ldvarg156); ldv_state_variable_45 = 1; } else { } goto ldv_51693; case 1: ; if (ldv_state_variable_45 == 1) { nfs_read_prepare(nfs_read_common_ops_group0, ldvarg155); ldv_state_variable_45 = 1; } else { } goto ldv_51693; case 2: ; if (ldv_state_variable_45 == 1) { nfs_readpage_release_common(ldvarg154); ldv_state_variable_45 = 1; } else { } goto ldv_51693; default: ldv_stop(); } ldv_51693: ; return; } } void ldv_main_exported_47(void) { struct nfs_pgio_header *ldvarg294 ; void *tmp ; struct list_head *ldvarg295 ; void *tmp___0 ; int tmp___1 ; { tmp = ldv_zalloc(224UL); ldvarg294 = (struct nfs_pgio_header *)tmp; tmp___0 = ldv_zalloc(16UL); ldvarg295 = (struct list_head *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); switch (tmp___1) { case 0: ; if (ldv_state_variable_47 == 1) { nfs_async_read_error(ldvarg295); ldv_state_variable_47 = 1; } else { } goto ldv_51703; case 1: ; if (ldv_state_variable_47 == 1) { nfs_read_completion(ldvarg294); ldv_state_variable_47 = 1; } else { } goto ldv_51703; default: ldv_stop(); } ldv_51703: ; return; } } __inline static void SetPageError(struct page *page ) { { set_bit(1L, (unsigned long volatile *)(& page->flags)); return; } } extern void page_put_link(struct dentry * , struct nameidata * , void * ) ; extern int generic_readlink(struct dentry * , char * , int ) ; __inline static void nd_set_link(struct nameidata *nd , char *path ) { { nd->saved_names[nd->depth] = path; return; } } static int nfs_symlink_filler(struct inode *inode , struct page *page ) { int error ; struct nfs_rpc_ops const *tmp ; { tmp = NFS_PROTO((struct inode const *)inode); error = (*(tmp->readlink))(inode, page, 0U, 4096U); if (error < 0) { goto error; } else { } SetPageUptodate(page); unlock_page(page); return (0); error: SetPageError(page); unlock_page(page); return (-5); } } static void *nfs_follow_link(struct dentry *dentry , struct nameidata *nd ) { struct inode *inode ; struct page *page ; void *err ; int tmp ; long tmp___0 ; void *tmp___1 ; { inode = dentry->d_inode; tmp = nfs_revalidate_mapping(inode, inode->i_mapping); err = ERR_PTR((long )tmp); if ((unsigned long )err != (unsigned long )((void *)0)) { goto read_failed; } else { } page = read_cache_page(& inode->i_data, 0UL, (filler_t *)(& nfs_symlink_filler), (void *)inode); tmp___0 = IS_ERR((void const *)page); if (tmp___0 != 0L) { err = (void *)page; goto read_failed; } else { } tmp___1 = kmap(page); nd_set_link(nd, (char *)tmp___1); return ((void *)page); read_failed: nd_set_link(nd, (char *)err); return ((void *)0); } } struct inode_operations const nfs_symlink_inode_operations = {0, & nfs_follow_link, 0, 0, & generic_readlink, & page_put_link, 0, 0, 0, 0, 0, 0, 0, 0, & nfs_setattr, & nfs_getattr, 0, 0, 0, 0, 0, 0, 0, 0}; extern int ldv_release_44(void) ; extern int ldv_probe_44(void) ; void ldv_initialize_inode_operations_44(void) { void *tmp ; void *tmp___0 ; { tmp = ldv_zalloc(144UL); nfs_symlink_inode_operations_group0 = (struct nameidata *)tmp; tmp___0 = ldv_zalloc(264UL); nfs_symlink_inode_operations_group1 = (struct dentry *)tmp___0; return; } } void ldv_main_exported_44(void) { int ldvarg30 ; int tmp ; struct iattr *ldvarg28 ; void *tmp___0 ; void *ldvarg29 ; void *tmp___1 ; char *ldvarg31 ; void *tmp___2 ; struct vfsmount *ldvarg26 ; void *tmp___3 ; struct kstat *ldvarg27 ; void *tmp___4 ; int tmp___5 ; { tmp = __VERIFIER_nondet_int(); ldvarg30 = tmp; tmp___0 = ldv_zalloc(80UL); ldvarg28 = (struct iattr *)tmp___0; tmp___1 = ldv_zalloc(1UL); ldvarg29 = tmp___1; tmp___2 = ldv_zalloc(1UL); ldvarg31 = (char *)tmp___2; tmp___3 = __VERIFIER_nondet_pointer(); ldvarg26 = (struct vfsmount *)tmp___3; tmp___4 = ldv_zalloc(104UL); ldvarg27 = (struct kstat *)tmp___4; tmp___5 = __VERIFIER_nondet_int(); switch (tmp___5) { case 0: ; if (ldv_state_variable_44 == 1) { nfs_follow_link(nfs_symlink_inode_operations_group1, nfs_symlink_inode_operations_group0); ldv_state_variable_44 = 1; } else { } if (ldv_state_variable_44 == 2) { nfs_follow_link(nfs_symlink_inode_operations_group1, nfs_symlink_inode_operations_group0); ldv_state_variable_44 = 2; } else { } goto ldv_49706; case 1: ; if (ldv_state_variable_44 == 2) { generic_readlink(nfs_symlink_inode_operations_group1, ldvarg31, ldvarg30); ldv_state_variable_44 = 2; } else { } goto ldv_49706; case 2: ; if (ldv_state_variable_44 == 1) { page_put_link(nfs_symlink_inode_operations_group1, nfs_symlink_inode_operations_group0, ldvarg29); ldv_state_variable_44 = 1; } else { } if (ldv_state_variable_44 == 2) { page_put_link(nfs_symlink_inode_operations_group1, nfs_symlink_inode_operations_group0, ldvarg29); ldv_state_variable_44 = 2; } else { } goto ldv_49706; case 3: ; if (ldv_state_variable_44 == 1) { nfs_setattr(nfs_symlink_inode_operations_group1, ldvarg28); ldv_state_variable_44 = 1; } else { } if (ldv_state_variable_44 == 2) { nfs_setattr(nfs_symlink_inode_operations_group1, ldvarg28); ldv_state_variable_44 = 2; } else { } goto ldv_49706; case 4: ; if (ldv_state_variable_44 == 1) { nfs_getattr(ldvarg26, nfs_symlink_inode_operations_group1, ldvarg27); ldv_state_variable_44 = 1; } else { } if (ldv_state_variable_44 == 2) { nfs_getattr(ldvarg26, nfs_symlink_inode_operations_group1, ldvarg27); ldv_state_variable_44 = 2; } else { } goto ldv_49706; case 5: ; if (ldv_state_variable_44 == 2) { ldv_release_44(); ldv_state_variable_44 = 1; ref_cnt = ref_cnt - 1; } else { } goto ldv_49706; case 6: ; if (ldv_state_variable_44 == 1) { ldv_probe_44(); ldv_state_variable_44 = 2; ref_cnt = ref_cnt + 1; } else { } goto ldv_49706; default: ldv_stop(); } ldv_49706: ; return; } } __inline static int hlist_empty(struct hlist_head const *h ) { { return ((unsigned long )h->first == (unsigned long )((struct hlist_node */* const */)0)); } } __inline static void hlist_del(struct hlist_node *n ) { { __hlist_del(n); n->next = (struct hlist_node *)-2401263026317557504L; n->pprev = (struct hlist_node **)-2401263026316508672L; return; } } __inline static void hlist_add_head(struct hlist_node *n , struct hlist_head *h ) { struct hlist_node *first ; { first = h->first; n->next = first; if ((unsigned long )first != (unsigned long )((struct hlist_node *)0)) { first->pprev = & n->next; } else { } h->first = n; n->pprev = & h->first; return; } } extern int scnprintf(char * , size_t , char const * , ...) ; extern void __cmpxchg_wrong_size(void) ; __inline static int atomic_sub_return(int i , atomic_t *v ) { int tmp ; { tmp = atomic_add_return(- i, v); return (tmp); } } __inline static int atomic_cmpxchg(atomic_t *v , int old , int new ) { int __ret ; int __old ; int __new ; u8 volatile *__ptr ; u16 volatile *__ptr___0 ; u32 volatile *__ptr___1 ; u64 volatile *__ptr___2 ; { __old = old; __new = new; switch (4UL) { case 1UL: __ptr = (u8 volatile *)(& v->counter); __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; cmpxchgb %2,%1": "=a" (__ret), "+m" (*__ptr): "q" (__new), "0" (__old): "memory"); goto ldv_5569; case 2UL: __ptr___0 = (u16 volatile *)(& v->counter); __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; cmpxchgw %2,%1": "=a" (__ret), "+m" (*__ptr___0): "r" (__new), "0" (__old): "memory"); goto ldv_5569; case 4UL: __ptr___1 = (u32 volatile *)(& v->counter); __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; cmpxchgl %2,%1": "=a" (__ret), "+m" (*__ptr___1): "r" (__new), "0" (__old): "memory"); goto ldv_5569; case 8UL: __ptr___2 = (u64 volatile *)(& v->counter); __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; cmpxchgq %2,%1": "=a" (__ret), "+m" (*__ptr___2): "r" (__new), "0" (__old): "memory"); goto ldv_5569; default: __cmpxchg_wrong_size(); } ldv_5569: ; return (__ret); } } __inline static int __atomic_add_unless(atomic_t *v , int a , int u ) { int c ; int old ; long tmp ; long tmp___0 ; { c = atomic_read((atomic_t const *)v); ldv_5598: tmp = ldv__builtin_expect(c == u, 0L); if (tmp != 0L) { goto ldv_5597; } else { } old = atomic_cmpxchg(v, c, c + a); tmp___0 = ldv__builtin_expect(old == c, 1L); if (tmp___0 != 0L) { goto ldv_5597; } else { } c = old; goto ldv_5598; ldv_5597: ; return (c); } } __inline static int atomic_add_unless(atomic_t *v , int a , int u ) { int tmp ; { tmp = __atomic_add_unless(v, a, u); return (tmp != u); } } extern void rpc_put_task_async(struct rpc_task * ) ; extern int __rpc_wait_for_completion_task(struct rpc_task * , int (*)(void * ) ) ; __inline static int rpc_wait_for_completion_task(struct rpc_task *task ) { int tmp ; { tmp = __rpc_wait_for_completion_task(task, (int (*)(void * ))0); return (tmp); } } extern struct inode *igrab(struct inode * ) ; extern struct dentry *lookup_one_len(char const * , struct dentry * , int ) ; __inline static void nfs_inc_server_stats___3(struct nfs_server const *server , enum nfs_stat_eventcounters stat ) { void const *__vpp_verify ; int pao_ID__ ; int pao_ID_____0 ; int pao_ID_____1 ; int pao_ID_____2 ; { __vpp_verify = (void const *)0; switch (8UL) { case 1UL: pao_ID__ = 1; switch (8UL) { case 1UL: ; if (pao_ID__ == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_50851; case 2UL: ; if (pao_ID__ == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50851; case 4UL: ; if (pao_ID__ == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50851; case 8UL: ; if (pao_ID__ == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_50851; default: __bad_percpu_size(); } ldv_50851: ; goto ldv_50856; case 2UL: pao_ID_____0 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____0 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_50862; case 2UL: ; if (pao_ID_____0 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50862; case 4UL: ; if (pao_ID_____0 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50862; case 8UL: ; if (pao_ID_____0 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_50862; default: __bad_percpu_size(); } ldv_50862: ; goto ldv_50856; case 4UL: pao_ID_____1 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____1 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_50872; case 2UL: ; if (pao_ID_____1 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50872; case 4UL: ; if (pao_ID_____1 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50872; case 8UL: ; if (pao_ID_____1 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_50872; default: __bad_percpu_size(); } ldv_50872: ; goto ldv_50856; case 8UL: pao_ID_____2 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____2 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_50882; case 2UL: ; if (pao_ID_____2 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50882; case 4UL: ; if (pao_ID_____2 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_50882; case 8UL: ; if (pao_ID_____2 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_50882; default: __bad_percpu_size(); } ldv_50882: ; goto ldv_50856; default: __bad_size_call_parameter(); goto ldv_50856; } ldv_50856: ; return; } } __inline static void nfs_inc_stats___3(struct inode const *inode , enum nfs_stat_eventcounters stat ) { struct nfs_server *tmp ; { tmp = NFS_SERVER(inode); nfs_inc_server_stats___3((struct nfs_server const *)tmp, stat); return; } } struct tracepoint __tracepoint_nfs_sillyrename_rename ; __inline static void trace_nfs_sillyrename_rename(struct inode const *old_dir , struct dentry const *old_dentry , struct inode const *new_dir , struct dentry const *new_dentry , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_sillyrename_rename.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_sillyrename_rename.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 687, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52694: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , struct dentry const * , struct inode const * , struct dentry const * , int ))it_func))(__data, old_dir, old_dentry, new_dir, new_dentry, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52694; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_sillyrename_unlink ; __inline static void trace_nfs_sillyrename_unlink(struct nfs_unlinkdata const *data , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_sillyrename_unlink.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_sillyrename_unlink.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 722, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52739: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct nfs_unlinkdata const * , int ))it_func))(__data, data, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52739; } else { } } else { } __rcu_read_unlock(); } else { } return; } } static void nfs_free_unlinkdata(struct nfs_unlinkdata *data ) { { iput(data->dir); put_rpccred(data->cred); kfree((void const *)data->args.name.name); kfree((void const *)data); return; } } static int nfs_copy_dname(struct dentry *dentry , struct nfs_unlinkdata *data ) { char *str ; int len ; void *tmp ; { len = (int )dentry->d_name.ldv_22580.ldv_22578.len; tmp = kmemdup((void const *)dentry->d_name.name, (size_t )((len + 16) & -16), 208U); str = (char *)tmp; if ((unsigned long )str == (unsigned long )((char *)0)) { return (-12); } else { } data->args.name.ldv_22580.ldv_22578.len = (u32 )len; data->args.name.name = (unsigned char const *)str; return (0); } } static void nfs_free_dname(struct nfs_unlinkdata *data ) { { kfree((void const *)data->args.name.name); data->args.name.name = (unsigned char const *)0U; data->args.name.ldv_22580.ldv_22578.len = 0U; return; } } static void nfs_dec_sillycount(struct inode *dir ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; int tmp___0 ; { tmp = NFS_I((struct inode const *)dir); nfsi = tmp; tmp___0 = atomic_sub_return(1, & nfsi->silly_count); if (tmp___0 == 1) { __wake_up(& nfsi->waitqueue, 3U, 1, (void *)0); } else { } return; } } static void nfs_async_unlink_done(struct rpc_task *task , void *calldata ) { struct nfs_unlinkdata *data ; struct inode *dir ; struct nfs_rpc_ops const *tmp ; int tmp___0 ; { data = (struct nfs_unlinkdata *)calldata; dir = data->dir; trace_nfs_sillyrename_unlink((struct nfs_unlinkdata const *)data, task->tk_status); tmp = NFS_PROTO((struct inode const *)dir); tmp___0 = (*(tmp->unlink_done))(task, dir); if (tmp___0 == 0) { rpc_restart_call_prepare(task); } else { } return; } } static void nfs_async_unlink_release(void *calldata ) { struct nfs_unlinkdata *data ; struct super_block *sb ; { data = (struct nfs_unlinkdata *)calldata; sb = (data->dir)->i_sb; nfs_dec_sillycount(data->dir); nfs_free_unlinkdata(data); nfs_sb_deactive(sb); return; } } static void nfs_unlink_prepare(struct rpc_task *task , void *calldata ) { struct nfs_unlinkdata *data ; struct nfs_rpc_ops const *tmp ; { data = (struct nfs_unlinkdata *)calldata; tmp = NFS_PROTO((struct inode const *)data->dir); (*(tmp->unlink_rpc_prepare))(task, data); return; } } static struct rpc_call_ops const nfs_unlink_ops = {& nfs_unlink_prepare, & nfs_async_unlink_done, 0, & nfs_async_unlink_release}; static int nfs_do_call_unlink(struct dentry *parent , struct inode *dir , struct nfs_unlinkdata *data ) { struct rpc_message msg ; struct rpc_task_setup task_setup_data ; struct rpc_task *task ; struct dentry *alias ; int ret ; void *devname_garbage ; struct nfs_fh *tmp ; struct nfs_rpc_ops const *tmp___0 ; long tmp___1 ; { msg.rpc_proc = 0; msg.rpc_argp = (void *)(& data->args); msg.rpc_resp = (void *)(& data->res); msg.rpc_cred = data->cred; task_setup_data.task = 0; task_setup_data.rpc_client = 0; task_setup_data.rpc_message = (struct rpc_message const *)(& msg); task_setup_data.callback_ops = & nfs_unlink_ops; task_setup_data.callback_data = (void *)data; task_setup_data.workqueue = nfsiod_workqueue; task_setup_data.flags = 1U; task_setup_data.priority = (signed char)0; alias = d_lookup((struct dentry const *)parent, (struct qstr const *)(& data->args.name)); if ((unsigned long )alias != (unsigned long )((struct dentry *)0)) { devname_garbage = (void *)0; nfs_free_dname(data); ret = nfs_copy_dname(alias, data); spin_lock(& alias->d_lockref.ldv_22558.ldv_22557.lock); if ((ret == 0 && (unsigned long )alias->d_inode != (unsigned long )((struct inode *)0)) && (alias->d_flags & 4096U) == 0U) { devname_garbage = alias->d_fsdata; alias->d_fsdata = (void *)data; alias->d_flags = alias->d_flags | 4096U; ret = 1; } else { ret = 0; } spin_unlock(& alias->d_lockref.ldv_22558.ldv_22557.lock); nfs_dec_sillycount(dir); dput(alias); kfree((void const *)devname_garbage); return (ret); } else { } data->dir = igrab(dir); if ((unsigned long )data->dir == (unsigned long )((struct inode *)0)) { nfs_dec_sillycount(dir); return (0); } else { } nfs_sb_active(dir->i_sb); tmp = NFS_FH((struct inode const *)dir); data->args.fh = (struct nfs_fh const *)tmp; nfs_fattr_init(data->res.dir_attr); tmp___0 = NFS_PROTO((struct inode const *)dir); (*(tmp___0->unlink_setup))(& msg, dir); task_setup_data.rpc_client = NFS_CLIENT((struct inode const *)dir); task = rpc_run_task((struct rpc_task_setup const *)(& task_setup_data)); tmp___1 = IS_ERR((void const *)task); if (tmp___1 == 0L) { rpc_put_task_async(task); } else { } return (1); } } static int nfs_call_unlink(struct dentry *dentry , struct nfs_unlinkdata *data ) { struct dentry *parent ; struct inode *dir ; int ret ; struct nfs_inode *tmp ; struct nfs_inode *tmp___0 ; int tmp___1 ; { ret = 0; parent = dget_parent(dentry); if ((unsigned long )parent == (unsigned long )((struct dentry *)0)) { goto out_free; } else { } dir = parent->d_inode; spin_lock(& dir->i_lock); tmp___0 = NFS_I((struct inode const *)dir); tmp___1 = atomic_add_unless(& tmp___0->silly_count, 1, 0); if (tmp___1 == 0) { tmp = NFS_I((struct inode const *)dir); hlist_add_head(& data->list, & tmp->silly_list); spin_unlock(& dir->i_lock); ret = 1; goto out_dput; } else { } spin_unlock(& dir->i_lock); ret = nfs_do_call_unlink(parent, dir, data); out_dput: dput(parent); out_free: ; return (ret); } } void nfs_wait_on_sillyrename(struct dentry *dentry ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; int tmp___0 ; wait_queue_t __wait ; struct task_struct *tmp___1 ; int tmp___2 ; { tmp = NFS_I((struct inode const *)dentry->d_inode); nfsi = tmp; tmp___0 = atomic_read((atomic_t const *)(& nfsi->silly_count)); if (tmp___0 <= 1) { goto ldv_52818; } else { } tmp___1 = get_current(); __wait.flags = 0U; __wait.private = (void *)tmp___1; __wait.func = & autoremove_wake_function; __wait.task_list.next = & __wait.task_list; __wait.task_list.prev = & __wait.task_list; ldv_52821: prepare_to_wait(& nfsi->waitqueue, & __wait, 2); tmp___2 = atomic_read((atomic_t const *)(& nfsi->silly_count)); if (tmp___2 <= 1) { goto ldv_52820; } else { } schedule(); goto ldv_52821; ldv_52820: finish_wait(& nfsi->waitqueue, & __wait); ldv_52818: ; return; } } void nfs_block_sillyrename(struct dentry *dentry ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; int tmp___0 ; wait_queue_t __wait ; struct task_struct *tmp___1 ; int tmp___2 ; { tmp = NFS_I((struct inode const *)dentry->d_inode); nfsi = tmp; tmp___0 = atomic_cmpxchg(& nfsi->silly_count, 1, 0); if (tmp___0 == 1) { goto ldv_52826; } else { } tmp___1 = get_current(); __wait.flags = 0U; __wait.private = (void *)tmp___1; __wait.func = & autoremove_wake_function; __wait.task_list.next = & __wait.task_list; __wait.task_list.prev = & __wait.task_list; ldv_52829: prepare_to_wait(& nfsi->waitqueue, & __wait, 2); tmp___2 = atomic_cmpxchg(& nfsi->silly_count, 1, 0); if (tmp___2 == 1) { goto ldv_52828; } else { } schedule(); goto ldv_52829; ldv_52828: finish_wait(& nfsi->waitqueue, & __wait); ldv_52826: ; return; } } void nfs_unblock_sillyrename(struct dentry *dentry ) { struct inode *dir ; struct nfs_inode *nfsi ; struct nfs_inode *tmp ; struct nfs_unlinkdata *data ; int tmp___0 ; struct hlist_node const *__mptr ; int tmp___1 ; int tmp___2 ; { dir = dentry->d_inode; tmp = NFS_I((struct inode const *)dir); nfsi = tmp; atomic_inc(& nfsi->silly_count); spin_lock(& dir->i_lock); goto ldv_52840; ldv_52839: tmp___0 = atomic_add_unless(& nfsi->silly_count, 1, 0); if (tmp___0 == 0) { goto ldv_52836; } else { } __mptr = (struct hlist_node const *)nfsi->silly_list.first; data = (struct nfs_unlinkdata *)__mptr; hlist_del(& data->list); spin_unlock(& dir->i_lock); tmp___1 = nfs_do_call_unlink(dentry, dir, data); if (tmp___1 == 0) { nfs_free_unlinkdata(data); } else { } spin_lock(& dir->i_lock); ldv_52840: tmp___2 = hlist_empty((struct hlist_head const *)(& nfsi->silly_list)); if (tmp___2 == 0) { goto ldv_52839; } else { } ldv_52836: spin_unlock(& dir->i_lock); return; } } static int nfs_async_unlink(struct inode *dir , struct dentry *dentry ) { struct nfs_unlinkdata *data ; int status ; void *devname_garbage ; void *tmp ; long tmp___0 ; long tmp___1 ; { status = -12; devname_garbage = (void *)0; tmp = kzalloc(360UL, 208U); data = (struct nfs_unlinkdata *)tmp; if ((unsigned long )data == (unsigned long )((struct nfs_unlinkdata *)0)) { goto out; } else { } data->cred = rpc_lookup_cred(); tmp___1 = IS_ERR((void const *)data->cred); if (tmp___1 != 0L) { tmp___0 = PTR_ERR((void const *)data->cred); status = (int )tmp___0; goto out_free; } else { } data->res.dir_attr = & data->dir_attr; status = -16; spin_lock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); if ((dentry->d_flags & 4096U) != 0U) { goto out_unlock; } else { } dentry->d_flags = dentry->d_flags | 4096U; devname_garbage = dentry->d_fsdata; dentry->d_fsdata = (void *)data; spin_unlock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); kfree((void const *)devname_garbage); return (0); out_unlock: spin_unlock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); put_rpccred(data->cred); out_free: kfree((void const *)data); out: ; return (status); } } void nfs_complete_unlink(struct dentry *dentry , struct inode *inode ) { struct nfs_unlinkdata *data ; int tmp ; int tmp___0 ; { data = (struct nfs_unlinkdata *)0; spin_lock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); if ((dentry->d_flags & 4096U) != 0U) { dentry->d_flags = dentry->d_flags & 4294963199U; data = (struct nfs_unlinkdata *)dentry->d_fsdata; dentry->d_fsdata = (void *)0; } else { } spin_unlock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); if ((unsigned long )data != (unsigned long )((struct nfs_unlinkdata *)0)) { tmp = NFS_STALE((struct inode const *)inode); if (tmp != 0) { nfs_free_unlinkdata(data); } else { tmp___0 = nfs_call_unlink(dentry, data); if (tmp___0 == 0) { nfs_free_unlinkdata(data); } else { } } } else { } return; } } static void nfs_cancel_async_unlink(struct dentry *dentry ) { struct nfs_unlinkdata *data ; { spin_lock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); if ((dentry->d_flags & 4096U) != 0U) { data = (struct nfs_unlinkdata *)dentry->d_fsdata; dentry->d_flags = dentry->d_flags & 4294963199U; dentry->d_fsdata = (void *)0; spin_unlock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); nfs_free_unlinkdata(data); return; } else { } spin_unlock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); return; } } static void nfs_async_rename_done(struct rpc_task *task , void *calldata ) { struct nfs_renamedata *data ; struct inode *old_dir ; struct inode *new_dir ; struct dentry *old_dentry ; struct nfs_rpc_ops const *tmp ; int tmp___0 ; { data = (struct nfs_renamedata *)calldata; old_dir = data->old_dir; new_dir = data->new_dir; old_dentry = data->old_dentry; trace_nfs_sillyrename_rename((struct inode const *)old_dir, (struct dentry const *)old_dentry, (struct inode const *)new_dir, (struct dentry const *)data->new_dentry, task->tk_status); tmp = NFS_PROTO((struct inode const *)old_dir); tmp___0 = (*(tmp->rename_done))(task, old_dir, new_dir); if (tmp___0 == 0) { rpc_restart_call_prepare(task); return; } else { } if (task->tk_status != 0) { nfs_cancel_async_unlink(old_dentry); } else { } return; } } static void nfs_async_rename_release(void *calldata ) { struct nfs_renamedata *data ; struct super_block *sb ; { data = (struct nfs_renamedata *)calldata; sb = (data->old_dir)->i_sb; if ((unsigned long )(data->old_dentry)->d_inode != (unsigned long )((struct inode *)0)) { nfs_mark_for_revalidate((data->old_dentry)->d_inode); } else { } dput(data->old_dentry); dput(data->new_dentry); iput(data->old_dir); iput(data->new_dir); nfs_sb_deactive(sb); put_rpccred(data->cred); kfree((void const *)data); return; } } static void nfs_rename_prepare(struct rpc_task *task , void *calldata ) { struct nfs_renamedata *data ; struct nfs_rpc_ops const *tmp ; { data = (struct nfs_renamedata *)calldata; tmp = NFS_PROTO((struct inode const *)data->old_dir); (*(tmp->rename_rpc_prepare))(task, data); return; } } static struct rpc_call_ops const nfs_rename_ops = {& nfs_rename_prepare, & nfs_async_rename_done, 0, & nfs_async_rename_release}; static struct rpc_task *nfs_async_rename(struct inode *old_dir , struct inode *new_dir , struct dentry *old_dentry , struct dentry *new_dentry ) { struct nfs_renamedata *data ; struct rpc_message msg ; struct rpc_task_setup task_setup_data ; struct rpc_clnt *tmp ; void *tmp___0 ; void *tmp___1 ; struct rpc_task *task ; void *tmp___2 ; long tmp___3 ; struct nfs_fh *tmp___4 ; struct nfs_fh *tmp___5 ; struct nfs_rpc_ops const *tmp___6 ; struct rpc_task *tmp___7 ; { msg.rpc_proc = 0; msg.rpc_argp = 0; msg.rpc_resp = 0; msg.rpc_cred = 0; tmp = NFS_CLIENT((struct inode const *)old_dir); task_setup_data.task = 0; task_setup_data.rpc_client = tmp; task_setup_data.rpc_message = (struct rpc_message const *)(& msg); task_setup_data.callback_ops = & nfs_rename_ops; task_setup_data.callback_data = 0; task_setup_data.workqueue = nfsiod_workqueue; task_setup_data.flags = 1U; task_setup_data.priority = (signed char)0; tmp___0 = kzalloc(624UL, 208U); data = (struct nfs_renamedata *)tmp___0; if ((unsigned long )data == (unsigned long )((struct nfs_renamedata *)0)) { tmp___1 = ERR_PTR(-12L); return ((struct rpc_task *)tmp___1); } else { } task_setup_data.callback_data = (void *)data; data->cred = rpc_lookup_cred(); tmp___3 = IS_ERR((void const *)data->cred); if (tmp___3 != 0L) { tmp___2 = ERR_CAST((void const *)data->cred); task = (struct rpc_task *)tmp___2; kfree((void const *)data); return (task); } else { } msg.rpc_argp = (void *)(& data->args); msg.rpc_resp = (void *)(& data->res); msg.rpc_cred = data->cred; data->old_dir = old_dir; ihold(old_dir); data->new_dir = new_dir; ihold(new_dir); data->old_dentry = dget(old_dentry); data->new_dentry = dget(new_dentry); nfs_fattr_init(& data->old_fattr); nfs_fattr_init(& data->new_fattr); tmp___4 = NFS_FH((struct inode const *)old_dir); data->args.old_dir = (struct nfs_fh const *)tmp___4; data->args.old_name = (struct qstr const *)(& old_dentry->d_name); tmp___5 = NFS_FH((struct inode const *)new_dir); data->args.new_dir = (struct nfs_fh const *)tmp___5; data->args.new_name = (struct qstr const *)(& new_dentry->d_name); data->res.old_fattr = & data->old_fattr; data->res.new_fattr = & data->new_fattr; nfs_sb_active(old_dir->i_sb); tmp___6 = NFS_PROTO((struct inode const *)data->old_dir); (*(tmp___6->rename_setup))(& msg, old_dir); tmp___7 = rpc_run_task((struct rpc_task_setup const *)(& task_setup_data)); return (tmp___7); } } int nfs_sillyrename(struct inode *dir , struct dentry *dentry ) { unsigned int sillycounter ; unsigned char silly[29U] ; unsigned long long fileid ; struct dentry *sdentry ; struct rpc_task *task ; int error ; unsigned int tmp ; long tmp___0 ; struct nfs_rpc_ops const *tmp___1 ; int slen ; long tmp___2 ; long tmp___3 ; long tmp___4 ; unsigned long tmp___5 ; { error = -5; tmp___0 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___0 != 0L) { tmp = d_count((struct dentry const *)dentry); printk("\001dNFS: silly-rename(%s/%s, ct=%d)\n", (dentry->d_parent)->d_name.name, dentry->d_name.name, tmp); } else { } nfs_inc_stats___3((struct inode const *)dir, 21); error = -16; if ((dentry->d_flags & 4096U) != 0U) { goto out; } else { } fileid = NFS_FILEID((struct inode const *)dentry->d_inode); tmp___1 = NFS_PROTO((struct inode const *)dentry->d_inode); (*(tmp___1->return_delegation))(dentry->d_inode); sdentry = (struct dentry *)0; ldv_52901: dput(sdentry); sillycounter = sillycounter + 1U; slen = scnprintf((char *)(& silly), 29UL, ".nfs%0*llx%0*x", 16U, fileid, 8U, sillycounter); tmp___2 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___2 != 0L) { printk("\001dNFS: trying to rename %s to %s\n", dentry->d_name.name, (unsigned char *)(& silly)); } else { } sdentry = lookup_one_len((char const *)(& silly), dentry->d_parent, slen); tmp___3 = IS_ERR((void const *)sdentry); if (tmp___3 != 0L) { goto out; } else { } if ((unsigned long )sdentry->d_inode != (unsigned long )((struct inode *)0)) { goto ldv_52901; } else { } error = nfs_async_unlink(dir, dentry); if (error != 0) { goto out_dput; } else { } error = nfs_copy_dname(sdentry, (struct nfs_unlinkdata *)dentry->d_fsdata); if (error != 0) { nfs_cancel_async_unlink(dentry); goto out_dput; } else { } task = nfs_async_rename(dir, dir, dentry, sdentry); tmp___4 = IS_ERR((void const *)task); if (tmp___4 != 0L) { error = -16; nfs_cancel_async_unlink(dentry); goto out_dput; } else { } error = rpc_wait_for_completion_task(task); if (error == 0) { error = task->tk_status; } else { } switch (error) { case 0: tmp___5 = nfs_save_change_attribute(dir); nfs_set_verifier(dentry, tmp___5); d_move(dentry, sdentry); goto ldv_52905; case -512: d_drop(dentry); d_drop(sdentry); } ldv_52905: rpc_put_task(task); out_dput: dput(sdentry); out: ; return (error); } } void ldv_initialize_rpc_call_ops_43(void) { void *tmp ; { tmp = ldv_zalloc(240UL); nfs_unlink_ops_group0 = (struct rpc_task *)tmp; return; } } void ldv_initialize_rpc_call_ops_42(void) { void *tmp ; { tmp = ldv_zalloc(240UL); nfs_rename_ops_group0 = (struct rpc_task *)tmp; return; } } void ldv_main_exported_42(void) { void *ldvarg274 ; void *tmp ; void *ldvarg273 ; void *tmp___0 ; void *ldvarg275 ; void *tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(1UL); ldvarg274 = tmp; tmp___0 = ldv_zalloc(1UL); ldvarg273 = tmp___0; tmp___1 = ldv_zalloc(1UL); ldvarg275 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_42 == 1) { nfs_async_rename_done(nfs_rename_ops_group0, ldvarg275); ldv_state_variable_42 = 1; } else { } goto ldv_52920; case 1: ; if (ldv_state_variable_42 == 1) { nfs_rename_prepare(nfs_rename_ops_group0, ldvarg274); ldv_state_variable_42 = 1; } else { } goto ldv_52920; case 2: ; if (ldv_state_variable_42 == 1) { nfs_async_rename_release(ldvarg273); ldv_state_variable_42 = 1; } else { } goto ldv_52920; default: ldv_stop(); } ldv_52920: ; return; } } void ldv_main_exported_43(void) { void *ldvarg309 ; void *tmp ; void *ldvarg308 ; void *tmp___0 ; void *ldvarg310 ; void *tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(1UL); ldvarg309 = tmp; tmp___0 = ldv_zalloc(1UL); ldvarg308 = tmp___0; tmp___1 = ldv_zalloc(1UL); ldvarg310 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_43 == 1) { nfs_async_unlink_done(nfs_unlink_ops_group0, ldvarg310); ldv_state_variable_43 = 1; } else { } goto ldv_52931; case 1: ; if (ldv_state_variable_43 == 1) { nfs_unlink_prepare(nfs_unlink_ops_group0, ldvarg309); ldv_state_variable_43 = 1; } else { } goto ldv_52931; case 2: ; if (ldv_state_variable_43 == 1) { nfs_async_unlink_release(ldvarg308); ldv_state_variable_43 = 1; } else { } goto ldv_52931; default: ldv_stop(); } ldv_52931: ; return; } } __inline static void clear_bit_unlock(long nr , unsigned long volatile *addr ) { { __asm__ volatile ("": : : "memory"); clear_bit(nr, addr); return; } } __inline static int fls(int x ) { int r ; { __asm__ ("bsrl %1,%0": "=r" (r): "rm" (x), "0" (-1)); return (r + 1); } } __inline static int __ilog2_u32(u32 n ) { int tmp ; { tmp = fls((int )n); return (tmp + -1); } } extern unsigned long int_sqrt(unsigned long ) ; __inline static void arch_local_irq_restore(unsigned long f ) { unsigned long __edi ; unsigned long __esi ; unsigned long __edx ; unsigned long __ecx ; unsigned long __eax ; long tmp ; { __edi = __edi; __esi = __esi; __edx = __edx; __ecx = __ecx; __eax = __eax; tmp = ldv__builtin_expect((unsigned long )pv_irq_ops.restore_fl.func == (unsigned long )((void *)0), 0L); if (tmp != 0L) { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/arch/x86/include/asm/paravirt.h"), "i" (809), "i" (12UL)); ldv_4810: ; goto ldv_4810; } else { } __asm__ volatile ("771:\n\tcall *%c2;\n772:\n.pushsection .parainstructions,\"a\"\n .balign 8 \n .quad 771b\n .byte %c1\n .byte 772b-771b\n .short %c3\n.popsection\n": "=a" (__eax): [paravirt_typenum] "i" (45UL), [paravirt_opptr] "i" (& pv_irq_ops.restore_fl.func), [paravirt_clobber] "i" (1), "D" (f): "memory", "cc"); return; } } __inline static void arch_local_irq_disable(void) { unsigned long __edi ; unsigned long __esi ; unsigned long __edx ; unsigned long __ecx ; unsigned long __eax ; long tmp ; { __edi = __edi; __esi = __esi; __edx = __edx; __ecx = __ecx; __eax = __eax; tmp = ldv__builtin_expect((unsigned long )pv_irq_ops.irq_disable.func == (unsigned long )((void *)0), 0L); if (tmp != 0L) { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/arch/x86/include/asm/paravirt.h"), "i" (814), "i" (12UL)); ldv_4819: ; goto ldv_4819; } else { } __asm__ volatile ("771:\n\tcall *%c2;\n772:\n.pushsection .parainstructions,\"a\"\n .balign 8 \n .quad 771b\n .byte %c1\n .byte 772b-771b\n .short %c3\n.popsection\n": "=a" (__eax): [paravirt_typenum] "i" (46UL), [paravirt_opptr] "i" (& pv_irq_ops.irq_disable.func), [paravirt_clobber] "i" (1): "memory", "cc"); return; } } __inline static unsigned long arch_local_irq_save(void) { unsigned long f ; { f = arch_local_save_flags(); arch_local_irq_disable(); return (f); } } extern void trace_hardirqs_on(void) ; extern void trace_hardirqs_off(void) ; __inline static long atomic64_sub_return(long i , atomic64_t *v ) { long tmp ; { tmp = atomic64_add_return(- i, v); return (tmp); } } __inline static long atomic_long_dec_return(atomic_long_t *l ) { atomic64_t *v ; long tmp ; { v = l; tmp = atomic64_sub_return(1L, v); return (tmp); } } extern int out_of_line_wait_on_bit_lock(void * , int , int (*)(void * ) , unsigned int ) ; __inline static int wait_on_bit_lock(void *word , int bit , int (*action)(void * ) , unsigned int mode ) { int tmp ; int tmp___0 ; { tmp = test_and_set_bit((long )bit, (unsigned long volatile *)word); if (tmp == 0) { return (0); } else { } tmp___0 = out_of_line_wait_on_bit_lock(word, bit, action, mode); return (tmp___0); } } extern unsigned long totalram_pages ; __inline static void SetPagePrivate(struct page *page ) { { set_bit(11L, (unsigned long volatile *)(& page->flags)); return; } } __inline static void ClearPagePrivate(struct page *page ) { { clear_bit(11L, (unsigned long volatile *)(& page->flags)); return; } } extern void cancel_dirty_page(struct page * , unsigned int ) ; extern int test_set_page_writeback(struct page * ) ; extern void inc_zone_page_state(struct page * , enum zone_stat_item ) ; extern void dec_zone_page_state(struct page * , enum zone_stat_item ) ; extern int redirty_page_for_writepage(struct writeback_control * , struct page * ) ; extern int clear_page_dirty_for_io(struct page * ) ; extern void __percpu_counter_add(struct percpu_counter * , s64 , s32 ) ; extern void __mark_inode_dirty(struct inode * , int ) ; extern int sync_inode(struct inode * , struct writeback_control * ) ; __inline static loff_t page_file_offset(struct page *page ) { unsigned long tmp ; { tmp = page_file_index(page); return ((long long )tmp << 12); } } extern void end_page_writeback(struct page * ) ; extern int __cond_resched_lock(spinlock_t * ) ; extern int write_cache_pages(struct address_space * , struct writeback_control * , int (*)(struct page * , struct writeback_control * , void * ) , void * ) ; extern int migrate_page(struct address_space * , struct page * , struct page * , enum migrate_mode ) ; extern int rpcauth_key_timeout_notify(struct rpc_auth * , struct rpc_cred * ) ; extern bool rpcauth_cred_key_to_expire(struct rpc_cred * ) ; __inline static void __add_bdi_stat(struct backing_dev_info *bdi , enum bdi_stat_item item , s64 amount ) { int tmp ; { tmp = __ilog2_u32((u32 )nr_cpu_ids); __percpu_counter_add((struct percpu_counter *)(& bdi->bdi_stat) + (unsigned long )item, amount, (tmp + 1) * 8); return; } } __inline static void __inc_bdi_stat(struct backing_dev_info *bdi , enum bdi_stat_item item ) { { __add_bdi_stat(bdi, item, 1LL); return; } } __inline static void inc_bdi_stat(struct backing_dev_info *bdi , enum bdi_stat_item item ) { unsigned long flags ; int tmp ; { flags = arch_local_irq_save(); trace_hardirqs_off(); __inc_bdi_stat(bdi, item); tmp = arch_irqs_disabled_flags(flags); if (tmp != 0) { arch_local_irq_restore(flags); trace_hardirqs_off(); } else { trace_hardirqs_on(); arch_local_irq_restore(flags); } return; } } __inline static void __dec_bdi_stat(struct backing_dev_info *bdi , enum bdi_stat_item item ) { { __add_bdi_stat(bdi, item, -1LL); return; } } __inline static void dec_bdi_stat(struct backing_dev_info *bdi , enum bdi_stat_item item ) { unsigned long flags ; int tmp ; { flags = arch_local_irq_save(); trace_hardirqs_off(); __dec_bdi_stat(bdi, item); tmp = arch_irqs_disabled_flags(flags); if (tmp != 0) { arch_local_irq_restore(flags); trace_hardirqs_off(); } else { trace_hardirqs_on(); arch_local_irq_restore(flags); } return; } } extern void clear_bdi_congested(struct backing_dev_info * , int ) ; extern void set_bdi_congested(struct backing_dev_info * , int ) ; extern mempool_t *mempool_create(int , mempool_alloc_t * , mempool_free_t * , void * ) ; extern void mempool_destroy(mempool_t * ) ; extern void *mempool_alloc(mempool_t * , gfp_t ) ; extern void mempool_free(void * , mempool_t * ) ; extern void *mempool_alloc_slab(gfp_t , void * ) ; extern void mempool_free_slab(void * , void * ) ; __inline static mempool_t *mempool_create_slab_pool(int min_nr , struct kmem_cache *kc ) { mempool_t *tmp ; { tmp = mempool_create(min_nr, & mempool_alloc_slab, & mempool_free_slab, (void *)kc); return (tmp); } } int nfs_congestion_kb ; void nfs_writeback_done(struct rpc_task *task , struct nfs_write_data *data ) ; struct nfs_commit_data *nfs_commitdata_alloc(void) ; void nfs_commit_free(struct nfs_commit_data *p ) ; __inline static bool _nfs4_state_protect(struct nfs_client *clp , unsigned long sp4_mode , struct rpc_clnt **clntp , struct rpc_message *msg ) { struct rpc_cred *newcred ; rpc_authflavor_t flavor ; bool __warned ; int __ret_warn_once ; int __ret_warn_on ; long tmp ; long tmp___0 ; long tmp___1 ; int tmp___2 ; { newcred = (struct rpc_cred *)0; tmp___2 = variable_test_bit((long )sp4_mode, (unsigned long const volatile *)(& clp->cl_sp4_flags)); if (tmp___2 != 0) { spin_lock(& clp->cl_lock); if ((unsigned long )clp->cl_machine_cred != (unsigned long )((struct rpc_cred *)0)) { newcred = clp->cl_machine_cred; } else { } spin_unlock(& clp->cl_lock); msg->rpc_cred = newcred; flavor = ((clp->cl_rpcclient)->cl_auth)->au_flavor; __ret_warn_once = flavor != 390004U && flavor != 390005U; tmp___1 = ldv__builtin_expect(__ret_warn_once != 0, 0L); if (tmp___1 != 0L) { __ret_warn_on = ! __warned; tmp = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp != 0L) { warn_slowpath_null("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfs4_fs.h", 290); } else { } tmp___0 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___0 != 0L) { __warned = 1; } else { } } else { } ldv__builtin_expect(__ret_warn_once != 0, 0L); *clntp = clp->cl_rpcclient; return (1); } else { } return (0); } } __inline static void nfs4_state_protect(struct nfs_client *clp , unsigned long sp4_mode , struct rpc_clnt **clntp , struct rpc_message *msg ) { { _nfs4_state_protect(clp, sp4_mode, clntp, msg); return; } } __inline static void nfs4_state_protect_write(struct nfs_client *clp , struct rpc_clnt **clntp , struct rpc_message *msg , struct nfs_write_data *wdata ) { bool tmp ; int tmp___0 ; { tmp = _nfs4_state_protect(clp, 5UL, clntp, msg); if ((int )tmp) { tmp___0 = constant_test_bit(6L, (unsigned long const volatile *)(& clp->cl_sp4_flags)); if (tmp___0 == 0) { wdata->args.stable = 2; } else { } } else { } return; } } void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio , struct inode *inode , int ioflags , struct nfs_pgio_completion_ops const *compl_ops ) ; struct nfs_write_header *nfs_writehdr_alloc(void) ; void nfs_writehdr_free(struct nfs_pgio_header *hdr ) ; int nfs_generic_flush(struct nfs_pageio_descriptor *desc , struct nfs_pgio_header *hdr ) ; void nfs_pageio_reset_write_mds(struct nfs_pageio_descriptor *pgio ) ; void nfs_writedata_release(struct nfs_write_data *wdata ) ; int nfs_initiate_write(struct rpc_clnt *clnt , struct nfs_write_data *data , struct rpc_call_ops const *call_ops , int how , int flags ) ; void nfs_write_prepare(struct rpc_task *task , void *calldata ) ; void nfs_commit_prepare(struct rpc_task *task , void *calldata ) ; int nfs_initiate_commit(struct rpc_clnt *clnt , struct nfs_commit_data *data , struct rpc_call_ops const *call_ops , int how , int flags ) ; void nfs_init_commit(struct nfs_commit_data *data , struct list_head *head , struct pnfs_layout_segment *lseg , struct nfs_commit_info *cinfo ) ; void nfs_retry_commit(struct list_head *page_list , struct pnfs_layout_segment *lseg , struct nfs_commit_info *cinfo ) ; void nfs_commitdata_release(struct nfs_commit_data *data ) ; void nfs_request_add_commit_list(struct nfs_page *req , struct list_head *dst , struct nfs_commit_info *cinfo ) ; void nfs_request_remove_commit_list(struct nfs_page *req , struct nfs_commit_info *cinfo ) ; void nfs_init_cinfo(struct nfs_commit_info *cinfo , struct inode *inode , struct nfs_direct_req *dreq ) ; __inline static void nfs_inc_server_stats___4(struct nfs_server const *server , enum nfs_stat_eventcounters stat ) { void const *__vpp_verify ; int pao_ID__ ; int pao_ID_____0 ; int pao_ID_____1 ; int pao_ID_____2 ; { __vpp_verify = (void const *)0; switch (8UL) { case 1UL: pao_ID__ = 1; switch (8UL) { case 1UL: ; if (pao_ID__ == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_51528; case 2UL: ; if (pao_ID__ == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51528; case 4UL: ; if (pao_ID__ == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51528; case 8UL: ; if (pao_ID__ == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_51528; default: __bad_percpu_size(); } ldv_51528: ; goto ldv_51533; case 2UL: pao_ID_____0 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____0 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_51539; case 2UL: ; if (pao_ID_____0 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51539; case 4UL: ; if (pao_ID_____0 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51539; case 8UL: ; if (pao_ID_____0 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_51539; default: __bad_percpu_size(); } ldv_51539: ; goto ldv_51533; case 4UL: pao_ID_____1 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____1 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_51549; case 2UL: ; if (pao_ID_____1 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51549; case 4UL: ; if (pao_ID_____1 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51549; case 8UL: ; if (pao_ID_____1 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_51549; default: __bad_percpu_size(); } ldv_51549: ; goto ldv_51533; case 8UL: pao_ID_____2 = 1; switch (8UL) { case 1UL: ; if (pao_ID_____2 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "qi" (1UL)); } goto ldv_51559; case 2UL: ; if (pao_ID_____2 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51559; case 4UL: ; if (pao_ID_____2 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "ri" (1UL)); } goto ldv_51559; case 8UL: ; if (pao_ID_____2 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->events[(unsigned int )stat]): "re" (1UL)); } goto ldv_51559; default: __bad_percpu_size(); } ldv_51559: ; goto ldv_51533; default: __bad_size_call_parameter(); goto ldv_51533; } ldv_51533: ; return; } } __inline static void nfs_inc_stats___4(struct inode const *inode , enum nfs_stat_eventcounters stat ) { struct nfs_server *tmp ; { tmp = NFS_SERVER(inode); nfs_inc_server_stats___4((struct nfs_server const *)tmp, stat); return; } } __inline static void nfs_add_server_stats___2(struct nfs_server const *server , enum nfs_stat_bytecounters stat , long addend ) { void const *__vpp_verify ; int pao_ID__ ; int pao_ID_____0 ; int pao_ID_____1 ; int pao_ID_____2 ; { __vpp_verify = (void const *)0; switch (8UL) { case 1UL: pao_ID__ = 0; switch (8UL) { case 1UL: ; if (pao_ID__ == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_51580; case 2UL: ; if (pao_ID__ == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51580; case 4UL: ; if (pao_ID__ == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51580; case 8UL: ; if (pao_ID__ == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID__ == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_51580; default: __bad_percpu_size(); } ldv_51580: ; goto ldv_51585; case 2UL: pao_ID_____0 = 0; switch (8UL) { case 1UL: ; if (pao_ID_____0 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_51591; case 2UL: ; if (pao_ID_____0 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51591; case 4UL: ; if (pao_ID_____0 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51591; case 8UL: ; if (pao_ID_____0 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_51591; default: __bad_percpu_size(); } ldv_51591: ; goto ldv_51585; case 4UL: pao_ID_____1 = 0; switch (8UL) { case 1UL: ; if (pao_ID_____1 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_51601; case 2UL: ; if (pao_ID_____1 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51601; case 4UL: ; if (pao_ID_____1 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51601; case 8UL: ; if (pao_ID_____1 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_51601; default: __bad_percpu_size(); } ldv_51601: ; goto ldv_51585; case 8UL: pao_ID_____2 = 0; switch (8UL) { case 1UL: ; if (pao_ID_____2 == 1) { __asm__ ("incb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decb %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addb %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_51611; case 2UL: ; if (pao_ID_____2 == 1) { __asm__ ("incw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decw %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addw %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51611; case 4UL: ; if (pao_ID_____2 == 1) { __asm__ ("incl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decl %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addl %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_51611; case 8UL: ; if (pao_ID_____2 == 1) { __asm__ ("incq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { __asm__ ("decq %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat])); } else { __asm__ ("addq %1, %%gs:%P0": "+m" ((server->io_stats)->bytes[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_51611; default: __bad_percpu_size(); } ldv_51611: ; goto ldv_51585; default: __bad_size_call_parameter(); goto ldv_51585; } ldv_51585: ; return; } } __inline static void nfs_add_stats___2(struct inode const *inode , enum nfs_stat_bytecounters stat , long addend ) { struct nfs_server *tmp ; { tmp = NFS_SERVER(inode); nfs_add_server_stats___2((struct nfs_server const *)tmp, stat, addend); return; } } __inline static int pnfs_commit_list(struct inode *inode , struct list_head *mds_pages , int how , struct nfs_commit_info *cinfo ) { struct nfs_server *tmp ; int tmp___0 ; { if ((unsigned long )cinfo->ds == (unsigned long )((struct pnfs_ds_commit_info *)0) || (cinfo->ds)->ncommitting == 0) { return (1); } else { } tmp = NFS_SERVER((struct inode const *)inode); tmp___0 = (*((tmp->pnfs_curr_ld)->commit_pagelist))(inode, mds_pages, how, cinfo); return (tmp___0); } } __inline static struct pnfs_ds_commit_info *pnfs_get_ds_info(struct inode *inode ) { struct pnfs_layoutdriver_type *ld ; struct nfs_server *tmp ; struct pnfs_ds_commit_info *tmp___0 ; { tmp = NFS_SERVER((struct inode const *)inode); ld = tmp->pnfs_curr_ld; if ((unsigned long )ld == (unsigned long )((struct pnfs_layoutdriver_type *)0) || (unsigned long )ld->get_ds_info == (unsigned long )((struct pnfs_ds_commit_info *(*)(struct inode * ))0)) { return ((struct pnfs_ds_commit_info *)0); } else { } tmp___0 = (*(ld->get_ds_info))(inode); return (tmp___0); } } __inline static bool pnfs_mark_request_commit(struct nfs_page *req , struct pnfs_layout_segment *lseg , struct nfs_commit_info *cinfo ) { struct inode *inode ; struct pnfs_layoutdriver_type *ld ; struct nfs_server *tmp ; { inode = ((req->wb_context)->dentry)->d_inode; tmp = NFS_SERVER((struct inode const *)inode); ld = tmp->pnfs_curr_ld; if ((unsigned long )lseg == (unsigned long )((struct pnfs_layout_segment *)0) || (unsigned long )ld->mark_request_commit == (unsigned long )((void (*)(struct nfs_page * , struct pnfs_layout_segment * , struct nfs_commit_info * ))0)) { return (0); } else { } (*(ld->mark_request_commit))(req, lseg, cinfo); return (1); } } __inline static bool pnfs_clear_request_commit(struct nfs_page *req , struct nfs_commit_info *cinfo ) { struct inode *inode ; struct pnfs_layoutdriver_type *ld ; struct nfs_server *tmp ; { inode = ((req->wb_context)->dentry)->d_inode; tmp = NFS_SERVER((struct inode const *)inode); ld = tmp->pnfs_curr_ld; if ((unsigned long )ld == (unsigned long )((struct pnfs_layoutdriver_type *)0) || (unsigned long )ld->clear_request_commit == (unsigned long )((void (*)(struct nfs_page * , struct nfs_commit_info * ))0)) { return (0); } else { } (*(ld->clear_request_commit))(req, cinfo); return (1); } } __inline static int pnfs_scan_commit_lists(struct inode *inode , struct nfs_commit_info *cinfo , int max ) { struct nfs_server *tmp ; int tmp___0 ; { if ((unsigned long )cinfo->ds == (unsigned long )((struct pnfs_ds_commit_info *)0) || (cinfo->ds)->nwritten == 0) { return (0); } else { tmp = NFS_SERVER((struct inode const *)inode); tmp___0 = (*((tmp->pnfs_curr_ld)->scan_commit_lists))(cinfo, max); return (tmp___0); } } } struct tracepoint __tracepoint_nfs_writeback_page_enter ; __inline static void trace_nfs_writeback_page_enter(struct inode const *inode ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_writeback_page_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_writeback_page_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 151, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52720: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * ))it_func))(__data, inode); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52720; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_writeback_page_exit ; __inline static void trace_nfs_writeback_page_exit(struct inode const *inode , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_writeback_page_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_writeback_page_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 152, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52753: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , int ))it_func))(__data, inode, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52753; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_writeback_inode_enter ; __inline static void trace_nfs_writeback_inode_enter(struct inode const *inode ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_writeback_inode_enter.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_writeback_inode_enter.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 153, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52787: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * ))it_func))(__data, inode); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52787; } else { } } else { } __rcu_read_unlock(); } else { } return; } } struct tracepoint __tracepoint_nfs_writeback_inode_exit ; __inline static void trace_nfs_writeback_inode_exit(struct inode const *inode , int error ) { struct tracepoint_func *it_func_ptr ; void *it_func ; void *__data ; struct tracepoint_func *_________p1 ; bool __warned ; int tmp ; int tmp___0 ; bool tmp___1 ; { tmp___1 = static_key_false(& __tracepoint_nfs_writeback_inode_exit.key); if ((int )tmp___1) { __rcu_read_lock(); _________p1 = *((struct tracepoint_func * volatile *)(& __tracepoint_nfs_writeback_inode_exit.funcs)); tmp = debug_lockdep_rcu_enabled(); if (tmp != 0 && ! __warned) { tmp___0 = rcu_read_lock_sched_held(); if (tmp___0 == 0 && 1) { __warned = 1; lockdep_rcu_suspicious("/work/ldvuser/mutilin/launch/inst/current/envs/linux-3.12-rc1.tar.xz/linux-3.12-rc1/fs/nfs/nfstrace.h", 154, "suspicious rcu_dereference_check() usage"); } else { } } else { } it_func_ptr = _________p1; if ((unsigned long )it_func_ptr != (unsigned long )((struct tracepoint_func *)0)) { ldv_52820: it_func = it_func_ptr->func; __data = it_func_ptr->data; (*((void (*)(void * , struct inode const * , int ))it_func))(__data, inode, error); it_func_ptr = it_func_ptr + 1; if ((unsigned long )it_func_ptr->func != (unsigned long )((void *)0)) { goto ldv_52820; } else { } } else { } __rcu_read_unlock(); } else { } return; } } static void nfs_redirty_request(struct nfs_page *req ) ; static struct rpc_call_ops const nfs_write_common_ops ; static struct rpc_call_ops const nfs_commit_ops ; static struct nfs_pgio_completion_ops const nfs_async_write_completion_ops ; static struct nfs_commit_completion_ops const nfs_commit_completion_ops ; static struct kmem_cache *nfs_wdata_cachep ; static mempool_t *nfs_wdata_mempool ; static struct kmem_cache *nfs_cdata_cachep ; static mempool_t *nfs_commit_mempool ; struct nfs_commit_data *nfs_commitdata_alloc(void) { struct nfs_commit_data *p ; void *tmp ; { tmp = mempool_alloc(nfs_commit_mempool, 16U); p = (struct nfs_commit_data *)tmp; if ((unsigned long )p != (unsigned long )((struct nfs_commit_data *)0)) { memset((void *)p, 0, 688UL); INIT_LIST_HEAD(& p->pages); } else { } return (p); } } void nfs_commit_free(struct nfs_commit_data *p ) { { mempool_free((void *)p, nfs_commit_mempool); return; } } struct nfs_write_header *nfs_writehdr_alloc(void) { struct nfs_write_header *p ; void *tmp ; struct nfs_pgio_header *hdr ; struct lock_class_key __key ; { tmp = mempool_alloc(nfs_wdata_mempool, 16U); p = (struct nfs_write_header *)tmp; if ((unsigned long )p != (unsigned long )((struct nfs_write_header *)0)) { hdr = & p->header; memset((void *)p, 0, 1008UL); INIT_LIST_HEAD(& hdr->pages); INIT_LIST_HEAD(& hdr->rpc_list); spinlock_check(& hdr->lock); __raw_spin_lock_init(& hdr->lock.ldv_6140.rlock, "&(&hdr->lock)->rlock", & __key); atomic_set(& hdr->refcnt, 0); hdr->verf = & p->verf; } else { } return (p); } } static struct nfs_write_data *nfs_writedata_alloc(struct nfs_pgio_header *hdr , unsigned int pagecount ) { struct nfs_write_data *data ; struct nfs_write_data *prealloc ; struct nfs_pgio_header const *__mptr ; void *tmp ; bool tmp___0 ; { __mptr = (struct nfs_pgio_header const *)hdr; prealloc = & ((struct nfs_write_header *)__mptr)->rpc_data; if ((unsigned long )prealloc->header == (unsigned long )((struct nfs_pgio_header *)0)) { data = prealloc; } else { tmp = kzalloc(768UL, 208U); data = (struct nfs_write_data *)tmp; } if ((unsigned long )data == (unsigned long )((struct nfs_write_data *)0)) { goto out; } else { } tmp___0 = nfs_pgarray_set(& data->pages, pagecount); if ((int )tmp___0) { data->header = hdr; atomic_inc(& hdr->refcnt); } else { if ((unsigned long )data != (unsigned long )prealloc) { kfree((void const *)data); } else { } data = (struct nfs_write_data *)0; } out: ; return (data); } } void nfs_writehdr_free(struct nfs_pgio_header *hdr ) { struct nfs_write_header *whdr ; struct nfs_pgio_header const *__mptr ; { __mptr = (struct nfs_pgio_header const *)hdr; whdr = (struct nfs_write_header *)__mptr; mempool_free((void *)whdr, nfs_wdata_mempool); return; } } void nfs_writedata_release(struct nfs_write_data *wdata ) { struct nfs_pgio_header *hdr ; struct nfs_write_header *write_header ; struct nfs_pgio_header const *__mptr ; int tmp ; { hdr = wdata->header; __mptr = (struct nfs_pgio_header const *)hdr; write_header = (struct nfs_write_header *)__mptr; put_nfs_open_context(wdata->args.context); if ((unsigned long )wdata->pages.pagevec != (unsigned long )((struct page **)(& wdata->pages.page_array))) { kfree((void const *)wdata->pages.pagevec); } else { } if ((unsigned long )(& write_header->rpc_data) == (unsigned long )wdata) { wdata->header = (struct nfs_pgio_header *)0; wdata = (struct nfs_write_data *)0; } else { } tmp = atomic_dec_and_test(& hdr->refcnt); if (tmp != 0) { (*((hdr->completion_ops)->completion))(hdr); } else { } kfree((void const *)wdata); return; } } static void nfs_context_set_write_error(struct nfs_open_context *ctx , int error ) { { ctx->error = error; __asm__ volatile ("": : : "memory"); set_bit(0L, (unsigned long volatile *)(& ctx->flags)); return; } } static struct nfs_page *nfs_page_find_request_locked(struct nfs_inode *nfsi , struct page *page ) { struct nfs_page *req ; struct nfs_page *freq ; struct nfs_page *t ; struct list_head const *__mptr ; struct list_head const *__mptr___0 ; struct list_head const *__mptr___1 ; int tmp ; long tmp___0 ; int tmp___1 ; { req = (struct nfs_page *)0; tmp___1 = PagePrivate((struct page const *)page); if (tmp___1 != 0) { req = (struct nfs_page *)page->ldv_15487.private; } else { tmp = PageSwapCache((struct page const *)page); tmp___0 = ldv__builtin_expect(tmp != 0, 0L); if (tmp___0 != 0L) { __mptr = (struct list_head const *)nfsi->commit_info.list.next; freq = (struct nfs_page *)__mptr; __mptr___0 = (struct list_head const *)freq->wb_list.next; t = (struct nfs_page *)__mptr___0; goto ldv_54149; ldv_54148: ; if ((unsigned long )freq->wb_page == (unsigned long )page) { req = freq; goto ldv_54147; } else { } freq = t; __mptr___1 = (struct list_head const *)t->wb_list.next; t = (struct nfs_page *)__mptr___1; ldv_54149: ; if ((unsigned long )(& freq->wb_list) != (unsigned long )(& nfsi->commit_info.list)) { goto ldv_54148; } else { } ldv_54147: ; } else { } } if ((unsigned long )req != (unsigned long )((struct nfs_page *)0)) { kref_get(& req->wb_kref); } else { } return (req); } } static struct nfs_page *nfs_page_find_request(struct page *page ) { struct inode *inode ; struct address_space *tmp ; struct nfs_page *req ; struct nfs_inode *tmp___0 ; { tmp = page_file_mapping(page); inode = tmp->host; req = (struct nfs_page *)0; spin_lock(& inode->i_lock); tmp___0 = NFS_I((struct inode const *)inode); req = nfs_page_find_request_locked(tmp___0, page); spin_unlock(& inode->i_lock); return (req); } } static void nfs_grow_file(struct page *page , unsigned int offset , unsigned int count ) { struct inode *inode ; struct address_space *tmp ; loff_t end ; loff_t i_size ; unsigned long end_index ; unsigned long tmp___0 ; loff_t tmp___1 ; { tmp = page_file_mapping(page); inode = tmp->host; spin_lock(& inode->i_lock); i_size = i_size_read((struct inode const *)inode); end_index = (unsigned long )((i_size + -1LL) >> 12); if (i_size > 0LL) { tmp___0 = page_file_index(page); if (tmp___0 < end_index) { goto out; } else { } } else { } tmp___1 = page_file_offset(page); end = tmp___1 + ((long long )offset + (long long )count); if (i_size >= end) { goto out; } else { } i_size_write(inode, end); nfs_inc_stats___4((struct inode const *)inode, 20); out: spin_unlock(& inode->i_lock); return; } } static void nfs_set_pageerror(struct page *page ) { struct address_space *tmp ; struct address_space *tmp___0 ; { tmp = page_file_mapping(page); tmp___0 = page_file_mapping(page); nfs_zap_mapping(tmp___0->host, tmp); return; } } static void nfs_mark_uptodate(struct page *page , unsigned int base , unsigned int count ) { int tmp ; unsigned int tmp___0 ; { tmp = PageUptodate(page); if (tmp != 0) { return; } else { } if (base != 0U) { return; } else { } tmp___0 = nfs_page_length(page); if (tmp___0 != count) { return; } else { } SetPageUptodate(page); return; } } static int wb_priority(struct writeback_control *wbc ) { { if ((unsigned int )*((unsigned char *)wbc + 36UL) != 0U) { return (20); } else { } if ((unsigned int )*((unsigned char *)wbc + 36UL) != 0U || (unsigned int )*((unsigned char *)wbc + 36UL) != 0U) { return (40); } else { } return (32); } } static void nfs_set_page_writeback(struct page *page ) { struct nfs_server *nfss ; struct address_space *tmp ; struct nfs_server *tmp___0 ; int ret ; int tmp___1 ; bool __warned ; int __ret_warn_once ; int __ret_warn_on ; long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; { tmp = page_file_mapping(page); tmp___0 = NFS_SERVER((struct inode const *)tmp->host); nfss = tmp___0; tmp___1 = test_set_page_writeback(page); ret = tmp___1; __ret_warn_once = ret != 0; tmp___4 = ldv__builtin_expect(__ret_warn_once != 0, 0L); if (tmp___4 != 0L) { __ret_warn_on = ! __warned; tmp___2 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___2 != 0L) { warn_slowpath_null("/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/write.o.c.prepared", 444); } else { } tmp___3 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___3 != 0L) { __warned = 1; } else { } } else { } ldv__builtin_expect(__ret_warn_once != 0, 0L); tmp___5 = atomic_long_inc_return(& nfss->writeback); if (tmp___5 > (long )(nfs_congestion_kb >> 2)) { set_bdi_congested(& nfss->backing_dev_info, 0); } else { } return; } } static void nfs_end_page_writeback(struct page *page ) { struct inode *inode ; struct address_space *tmp ; struct nfs_server *nfss ; struct nfs_server *tmp___0 ; long tmp___1 ; { tmp = page_file_mapping(page); inode = tmp->host; tmp___0 = NFS_SERVER((struct inode const *)inode); nfss = tmp___0; end_page_writeback(page); tmp___1 = atomic_long_dec_return(& nfss->writeback); if (tmp___1 < (long )((nfs_congestion_kb >> 2) - (nfs_congestion_kb >> 4))) { clear_bdi_congested(& nfss->backing_dev_info, 0); } else { } return; } } static struct nfs_page *nfs_find_and_lock_request(struct page *page , bool nonblock ) { struct inode *inode ; struct address_space *tmp ; struct nfs_page *req ; int ret ; struct nfs_inode *tmp___0 ; int tmp___1 ; void *tmp___2 ; { tmp = page_file_mapping(page); inode = tmp->host; spin_lock(& inode->i_lock); ldv_54200: tmp___0 = NFS_I((struct inode const *)inode); req = nfs_page_find_request_locked(tmp___0, page); if ((unsigned long )req == (unsigned long )((struct nfs_page *)0)) { goto ldv_54199; } else { } tmp___1 = nfs_lock_request(req); if (tmp___1 != 0) { goto ldv_54199; } else { } spin_unlock(& inode->i_lock); if (! nonblock) { ret = nfs_wait_on_request(req); } else { ret = -11; } nfs_release_request(req); if (ret != 0) { tmp___2 = ERR_PTR((long )ret); return ((struct nfs_page *)tmp___2); } else { } spin_lock(& inode->i_lock); goto ldv_54200; ldv_54199: spin_unlock(& inode->i_lock); return (req); } } static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio , struct page *page , bool nonblock ) { struct nfs_page *req ; int ret ; long tmp ; long tmp___0 ; bool __warned ; int __ret_warn_once ; int tmp___1 ; int __ret_warn_on ; long tmp___2 ; long tmp___3 ; long tmp___4 ; int tmp___5 ; { ret = 0; req = nfs_find_and_lock_request(page, (int )nonblock); if ((unsigned long )req == (unsigned long )((struct nfs_page *)0)) { goto out; } else { } tmp = PTR_ERR((void const *)req); ret = (int )tmp; tmp___0 = IS_ERR((void const *)req); if (tmp___0 != 0L) { goto out; } else { } nfs_set_page_writeback(page); tmp___1 = constant_test_bit(2L, (unsigned long const volatile *)(& req->wb_flags)); __ret_warn_once = tmp___1 != 0; tmp___4 = ldv__builtin_expect(__ret_warn_once != 0, 0L); if (tmp___4 != 0L) { __ret_warn_on = ! __warned; tmp___2 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___2 != 0L) { warn_slowpath_null("/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/write.o.c.prepared", 513); } else { } tmp___3 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___3 != 0L) { __warned = 1; } else { } } else { } ldv__builtin_expect(__ret_warn_once != 0, 0L); ret = 0; tmp___5 = nfs_pageio_add_request(pgio, req); if (tmp___5 == 0) { nfs_redirty_request(req); ret = pgio->pg_error; } else { } out: ; return (ret); } } static int nfs_do_writepage(struct page *page , struct writeback_control *wbc , struct nfs_pageio_descriptor *pgio ) { struct inode *inode ; struct address_space *tmp ; int ret ; unsigned long tmp___0 ; { tmp = page_file_mapping(page); inode = tmp->host; nfs_inc_stats___4((struct inode const *)inode, 10); nfs_add_stats___2((struct inode const *)inode, 7, 1L); tmp___0 = page_file_index(page); nfs_pageio_cond_complete(pgio, tmp___0); ret = nfs_page_async_flush(pgio, page, (unsigned int )wbc->sync_mode == 0U); if (ret == -11) { redirty_page_for_writepage(wbc, page); ret = 0; } else { } return (ret); } } static int nfs_writepage_locked(struct page *page , struct writeback_control *wbc ) { struct nfs_pageio_descriptor pgio ; int err ; struct address_space *tmp ; struct nfs_rpc_ops const *tmp___0 ; int tmp___1 ; { tmp = page_file_mapping(page); tmp___0 = NFS_PROTO((struct inode const *)tmp->host); tmp___1 = wb_priority(wbc); (*(tmp___0->write_pageio_init))(& pgio, (page->mapping)->host, tmp___1, & nfs_async_write_completion_ops); err = nfs_do_writepage(page, wbc, & pgio); nfs_pageio_complete(& pgio); if (err < 0) { return (err); } else { } if (pgio.pg_error < 0) { return (pgio.pg_error); } else { } return (0); } } int nfs_writepage(struct page *page , struct writeback_control *wbc ) { int ret ; { ret = nfs_writepage_locked(page, wbc); unlock_page(page); return (ret); } } static int nfs_writepages_callback(struct page *page , struct writeback_control *wbc , void *data ) { int ret ; { ret = nfs_do_writepage(page, wbc, (struct nfs_pageio_descriptor *)data); unlock_page(page); return (ret); } } int nfs_writepages(struct address_space *mapping , struct writeback_control *wbc ) { struct inode *inode ; unsigned long *bitlock ; struct nfs_inode *tmp ; struct nfs_pageio_descriptor pgio ; int err ; struct nfs_rpc_ops const *tmp___0 ; int tmp___1 ; { inode = mapping->host; tmp = NFS_I((struct inode const *)inode); bitlock = & tmp->flags; err = wait_on_bit_lock((void *)bitlock, 4, & nfs_wait_bit_killable, 130U); if (err != 0) { goto out_err; } else { } nfs_inc_stats___4((struct inode const *)inode, 11); tmp___0 = NFS_PROTO((struct inode const *)inode); tmp___1 = wb_priority(wbc); (*(tmp___0->write_pageio_init))(& pgio, inode, tmp___1, & nfs_async_write_completion_ops); err = write_cache_pages(mapping, wbc, & nfs_writepages_callback, (void *)(& pgio)); nfs_pageio_complete(& pgio); clear_bit_unlock(4L, (unsigned long volatile *)bitlock); __asm__ volatile ("": : : "memory"); wake_up_bit((void *)bitlock, 4); if (err < 0) { goto out_err; } else { } err = pgio.pg_error; if (err < 0) { goto out_err; } else { } return (0); out_err: ; return (err); } } static void nfs_inode_add_request(struct inode *inode , struct nfs_page *req ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; struct nfs_rpc_ops const *tmp___0 ; int tmp___1 ; int tmp___2 ; long tmp___3 ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; nfs_lock_request(req); spin_lock(& inode->i_lock); if (nfsi->npages == 0UL) { tmp___0 = NFS_PROTO((struct inode const *)inode); tmp___1 = (*(tmp___0->have_delegation))(inode, 2U); if (tmp___1 != 0) { inode->i_version = inode->i_version + 1ULL; } else { } } else { } tmp___2 = PageSwapCache((struct page const *)req->wb_page); tmp___3 = ldv__builtin_expect(tmp___2 == 0, 1L); if (tmp___3 != 0L) { set_bit(1L, (unsigned long volatile *)(& req->wb_flags)); SetPagePrivate(req->wb_page); (req->wb_page)->ldv_15487.private = (unsigned long )req; } else { } nfsi->npages = nfsi->npages + 1UL; kref_get(& req->wb_kref); spin_unlock(& inode->i_lock); return; } } static void nfs_inode_remove_request(struct nfs_page *req ) { struct inode *inode ; struct nfs_inode *nfsi ; struct nfs_inode *tmp ; int tmp___0 ; long tmp___1 ; { inode = ((req->wb_context)->dentry)->d_inode; tmp = NFS_I((struct inode const *)inode); nfsi = tmp; spin_lock(& inode->i_lock); tmp___0 = PageSwapCache((struct page const *)req->wb_page); tmp___1 = ldv__builtin_expect(tmp___0 == 0, 1L); if (tmp___1 != 0L) { (req->wb_page)->ldv_15487.private = 0UL; ClearPagePrivate(req->wb_page); clear_bit(1L, (unsigned long volatile *)(& req->wb_flags)); } else { } nfsi->npages = nfsi->npages - 1UL; spin_unlock(& inode->i_lock); nfs_release_request(req); return; } } static void nfs_mark_request_dirty(struct nfs_page *req ) { { __set_page_dirty_nobuffers(req->wb_page); return; } } void nfs_request_add_commit_list(struct nfs_page *req , struct list_head *dst , struct nfs_commit_info *cinfo ) { struct address_space *tmp ; { set_bit(2L, (unsigned long volatile *)(& req->wb_flags)); spin_lock(cinfo->lock); nfs_list_add_request(req, dst); (cinfo->mds)->ncommit = (cinfo->mds)->ncommit + 1UL; spin_unlock(cinfo->lock); if ((unsigned long )cinfo->dreq == (unsigned long )((struct nfs_direct_req *)0)) { inc_zone_page_state(req->wb_page, 17); tmp = page_file_mapping(req->wb_page); inc_bdi_stat(tmp->backing_dev_info, 0); __mark_inode_dirty(((req->wb_context)->dentry)->d_inode, 2); } else { } return; } } void nfs_request_remove_commit_list(struct nfs_page *req , struct nfs_commit_info *cinfo ) { int tmp ; { tmp = test_and_clear_bit(2L, (unsigned long volatile *)(& req->wb_flags)); if (tmp == 0) { return; } else { } nfs_list_remove_request(req); (cinfo->mds)->ncommit = (cinfo->mds)->ncommit - 1UL; return; } } static void nfs_init_cinfo_from_inode(struct nfs_commit_info *cinfo , struct inode *inode ) { struct nfs_inode *tmp ; { cinfo->lock = & inode->i_lock; tmp = NFS_I((struct inode const *)inode); cinfo->mds = & tmp->commit_info; cinfo->ds = pnfs_get_ds_info(inode); cinfo->dreq = (struct nfs_direct_req *)0; cinfo->completion_ops = & nfs_commit_completion_ops; return; } } void nfs_init_cinfo(struct nfs_commit_info *cinfo , struct inode *inode , struct nfs_direct_req *dreq ) { { if ((unsigned long )dreq != (unsigned long )((struct nfs_direct_req *)0)) { nfs_init_cinfo_from_dreq(cinfo, dreq); } else { nfs_init_cinfo_from_inode(cinfo, inode); } return; } } void nfs_mark_request_commit(struct nfs_page *req , struct pnfs_layout_segment *lseg , struct nfs_commit_info *cinfo ) { bool tmp ; { tmp = pnfs_mark_request_commit(req, lseg, cinfo); if ((int )tmp) { return; } else { } nfs_request_add_commit_list(req, & (cinfo->mds)->list, cinfo); return; } } static void nfs_clear_page_commit(struct page *page ) { struct address_space *tmp ; { dec_zone_page_state(page, 17); tmp = page_file_mapping(page); dec_bdi_stat(tmp->backing_dev_info, 0); return; } } static void nfs_clear_request_commit(struct nfs_page *req ) { struct inode *inode ; struct nfs_commit_info cinfo ; bool tmp ; int tmp___0 ; int tmp___1 ; { tmp___1 = constant_test_bit(2L, (unsigned long const volatile *)(& req->wb_flags)); if (tmp___1 != 0) { inode = ((req->wb_context)->dentry)->d_inode; nfs_init_cinfo_from_inode(& cinfo, inode); tmp = pnfs_clear_request_commit(req, & cinfo); if (tmp) { tmp___0 = 0; } else { tmp___0 = 1; } if (tmp___0) { spin_lock(cinfo.lock); nfs_request_remove_commit_list(req, & cinfo); spin_unlock(cinfo.lock); } else { } nfs_clear_page_commit(req->wb_page); } else { } return; } } __inline static int nfs_write_need_commit(struct nfs_write_data *data ) { { if ((unsigned int )data->verf.committed == 1U) { return ((unsigned long )(data->header)->lseg == (unsigned long )((struct pnfs_layout_segment *)0)); } else { } return ((unsigned int )data->verf.committed != 2U); } } static void nfs_write_completion(struct nfs_pgio_header *hdr ) { struct nfs_commit_info cinfo ; unsigned long bytes ; int tmp ; struct nfs_page *req ; struct nfs_page *tmp___0 ; int tmp___1 ; int tmp___2 ; size_t __len ; void *__ret ; int tmp___3 ; int tmp___4 ; { bytes = 0UL; tmp = constant_test_bit(2L, (unsigned long const volatile *)(& hdr->flags)); if (tmp != 0) { goto out; } else { } nfs_init_cinfo_from_inode(& cinfo, hdr->inode); goto ldv_54330; ldv_54329: tmp___0 = nfs_list_entry(hdr->pages.next); req = tmp___0; bytes = (unsigned long )req->wb_bytes + bytes; nfs_list_remove_request(req); tmp___1 = constant_test_bit(0L, (unsigned long const volatile *)(& hdr->flags)); if (tmp___1 != 0 && hdr->good_bytes < bytes) { nfs_set_pageerror(req->wb_page); nfs_context_set_write_error(req->wb_context, hdr->error); goto remove_req; } else { } tmp___2 = constant_test_bit(4L, (unsigned long const volatile *)(& hdr->flags)); if (tmp___2 != 0) { nfs_mark_request_dirty(req); goto next; } else { } tmp___3 = constant_test_bit(3L, (unsigned long const volatile *)(& hdr->flags)); if (tmp___3 != 0) { __len = 8UL; if (__len > 63UL) { __ret = __memcpy((void *)(& req->wb_verf), (void const *)(& (hdr->verf)->verifier), __len); } else { __ret = __builtin_memcpy((void *)(& req->wb_verf), (void const *)(& (hdr->verf)->verifier), __len); } nfs_mark_request_commit(req, hdr->lseg, & cinfo); goto next; } else { } remove_req: nfs_inode_remove_request(req); next: nfs_unlock_request(req); nfs_end_page_writeback(req->wb_page); nfs_release_request(req); ldv_54330: tmp___4 = list_empty((struct list_head const *)(& hdr->pages)); if (tmp___4 == 0) { goto ldv_54329; } else { } out: (*(hdr->release))(hdr); return; } } static unsigned long nfs_reqs_to_commit(struct nfs_commit_info *cinfo ) { { return ((cinfo->mds)->ncommit); } } int nfs_scan_commit_list(struct list_head *src , struct list_head *dst , struct nfs_commit_info *cinfo , int max ) { struct nfs_page *req ; struct nfs_page *tmp ; int ret ; struct list_head const *__mptr ; struct list_head const *__mptr___0 ; int tmp___0 ; struct list_head const *__mptr___1 ; int tmp___1 ; struct list_head const *__mptr___2 ; { ret = 0; __mptr = (struct list_head const *)src->next; req = (struct nfs_page *)__mptr; __mptr___0 = (struct list_head const *)req->wb_list.next; tmp = (struct nfs_page *)__mptr___0; goto ldv_54356; ldv_54355: tmp___0 = nfs_lock_request(req); if (tmp___0 == 0) { goto ldv_54350; } else { } kref_get(& req->wb_kref); __might_sleep("/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/write.o.c.prepared", 874, 1); tmp___1 = __cond_resched_lock(cinfo->lock); if (tmp___1 != 0) { __mptr___1 = (struct list_head const *)req->wb_list.next; tmp = (struct nfs_page *)__mptr___1; } else { } nfs_request_remove_commit_list(req, cinfo); nfs_list_add_request(req, dst); ret = ret + 1; if (ret == max && (unsigned long )cinfo->dreq == (unsigned long )((struct nfs_direct_req *)0)) { goto ldv_54354; } else { } ldv_54350: req = tmp; __mptr___2 = (struct list_head const *)tmp->wb_list.next; tmp = (struct nfs_page *)__mptr___2; ldv_54356: ; if ((unsigned long )(& req->wb_list) != (unsigned long )src) { goto ldv_54355; } else { } ldv_54354: ; return (ret); } } int nfs_scan_commit(struct inode *inode , struct list_head *dst , struct nfs_commit_info *cinfo ) { int ret ; int max ; int tmp ; { ret = 0; spin_lock(cinfo->lock); if ((cinfo->mds)->ncommit != 0UL) { max = 2147483647; ret = nfs_scan_commit_list(& (cinfo->mds)->list, dst, cinfo, max); tmp = pnfs_scan_commit_lists(inode, cinfo, max - ret); ret = tmp + ret; } else { } spin_unlock(cinfo->lock); return (ret); } } static struct nfs_page *nfs_try_to_update_request(struct inode *inode , struct page *page , unsigned int offset , unsigned int bytes ) { struct nfs_page *req ; unsigned int rqend ; unsigned int end ; int error ; int tmp ; struct nfs_inode *tmp___0 ; int tmp___1 ; void *tmp___2 ; { tmp = PagePrivate((struct page const *)page); if (tmp == 0) { return ((struct nfs_page *)0); } else { } end = offset + bytes; spin_lock(& inode->i_lock); ldv_54378: tmp___0 = NFS_I((struct inode const *)inode); req = nfs_page_find_request_locked(tmp___0, page); if ((unsigned long )req == (unsigned long )((struct nfs_page *)0)) { goto out_unlock; } else { } rqend = req->wb_offset + req->wb_bytes; if (offset > rqend || req->wb_offset > end) { goto out_flushme; } else { } tmp___1 = nfs_lock_request(req); if (tmp___1 != 0) { goto ldv_54376; } else { } spin_unlock(& inode->i_lock); error = nfs_wait_on_request(req); nfs_release_request(req); if (error != 0) { goto out_err; } else { } spin_lock(& inode->i_lock); goto ldv_54378; ldv_54376: ; if (req->wb_offset > offset) { req->wb_offset = offset; req->wb_pgbase = offset; } else { } if (end > rqend) { req->wb_bytes = end - req->wb_offset; } else { req->wb_bytes = rqend - req->wb_offset; } out_unlock: spin_unlock(& inode->i_lock); if ((unsigned long )req != (unsigned long )((struct nfs_page *)0)) { nfs_clear_request_commit(req); } else { } return (req); out_flushme: spin_unlock(& inode->i_lock); nfs_release_request(req); error = nfs_wb_page(inode, page); out_err: tmp___2 = ERR_PTR((long )error); return ((struct nfs_page *)tmp___2); } } static struct nfs_page *nfs_setup_write_request(struct nfs_open_context *ctx , struct page *page , unsigned int offset , unsigned int bytes ) { struct inode *inode ; struct address_space *tmp ; struct nfs_page *req ; long tmp___0 ; { tmp = page_file_mapping(page); inode = tmp->host; req = nfs_try_to_update_request(inode, page, offset, bytes); if ((unsigned long )req != (unsigned long )((struct nfs_page *)0)) { goto out; } else { } req = nfs_create_request(ctx, inode, page, offset, bytes); tmp___0 = IS_ERR((void const *)req); if (tmp___0 != 0L) { goto out; } else { } nfs_inode_add_request(inode, req); out: ; return (req); } } static int nfs_writepage_setup(struct nfs_open_context *ctx , struct page *page , unsigned int offset , unsigned int count ) { struct nfs_page *req ; long tmp ; long tmp___0 ; { req = nfs_setup_write_request(ctx, page, offset, count); tmp___0 = IS_ERR((void const *)req); if (tmp___0 != 0L) { tmp = PTR_ERR((void const *)req); return ((int )tmp); } else { } nfs_grow_file(page, offset, count); nfs_mark_uptodate(page, req->wb_pgbase, req->wb_bytes); nfs_mark_request_dirty(req); nfs_unlock_and_release_request(req); return (0); } } int nfs_flush_incompatible(struct file *file , struct page *page ) { struct nfs_open_context *ctx ; struct nfs_open_context *tmp ; struct nfs_lock_context *l_ctx ; struct nfs_page *req ; int do_flush ; int status ; struct task_struct *tmp___0 ; struct task_struct *tmp___1 ; int tmp___2 ; struct address_space *tmp___3 ; { tmp = nfs_file_open_context(file); ctx = tmp; ldv_54404: req = nfs_page_find_request(page); if ((unsigned long )req == (unsigned long )((struct nfs_page *)0)) { return (0); } else { } l_ctx = req->wb_lock_context; do_flush = (unsigned long )req->wb_page != (unsigned long )page || (unsigned long )req->wb_context != (unsigned long )ctx; if ((unsigned long )l_ctx != (unsigned long )((struct nfs_lock_context *)0) && (unsigned long )((ctx->dentry)->d_inode)->i_flock != (unsigned long )((struct file_lock *)0)) { tmp___0 = get_current(); if ((unsigned long )l_ctx->lockowner.l_owner != (unsigned long )tmp___0->files) { tmp___2 = 1; } else { tmp___1 = get_current(); if (l_ctx->lockowner.l_pid != tmp___1->tgid) { tmp___2 = 1; } else { tmp___2 = 0; } } do_flush = tmp___2 | do_flush; } else { } nfs_release_request(req); if (do_flush == 0) { return (0); } else { } tmp___3 = page_file_mapping(page); status = nfs_wb_page(tmp___3->host, page); if (status == 0) { goto ldv_54404; } else { } return (status); } } int nfs_key_timeout_notify(struct file *filp , struct inode *inode ) { struct nfs_open_context *ctx ; struct nfs_open_context *tmp ; struct rpc_auth *auth ; struct nfs_server *tmp___0 ; int tmp___1 ; { tmp = nfs_file_open_context(filp); ctx = tmp; tmp___0 = NFS_SERVER((struct inode const *)inode); auth = (tmp___0->client)->cl_auth; tmp___1 = rpcauth_key_timeout_notify(auth, ctx->cred); return (tmp___1); } } bool nfs_ctx_key_to_expire(struct nfs_open_context *ctx ) { bool tmp ; { tmp = rpcauth_cred_key_to_expire(ctx->cred); return (tmp); } } static bool nfs_write_pageuptodate(struct page *page , struct inode *inode ) { int tmp ; struct nfs_inode *tmp___0 ; int tmp___1 ; { tmp = nfs_have_delegated_attributes(inode); if (tmp != 0) { goto out; } else { } tmp___0 = NFS_I((struct inode const *)inode); if ((tmp___0->cache_validity & 34UL) != 0UL) { return (0); } else { } out: tmp___1 = PageUptodate(page); return (tmp___1 != 0); } } static int nfs_can_extend_write(struct file *file , struct page *page , struct inode *inode ) { struct nfs_rpc_ops const *tmp ; int tmp___0 ; bool tmp___1 ; { if ((file->f_flags & 4096U) != 0U) { return (0); } else { } tmp = NFS_PROTO((struct inode const *)inode); tmp___0 = (*(tmp->have_delegation))(inode, 2U); if (tmp___0 != 0) { return (1); } else { } tmp___1 = nfs_write_pageuptodate(page, inode); if ((int )tmp___1 && ((unsigned long )inode->i_flock == (unsigned long )((struct file_lock *)0) || (((inode->i_flock)->fl_start == 0LL && (inode->i_flock)->fl_end == 9223372036854775807LL) && (unsigned int )(inode->i_flock)->fl_type != 0U))) { return (1); } else { } return (0); } } int nfs_updatepage(struct file *file , struct page *page , unsigned int offset , unsigned int count ) { struct nfs_open_context *ctx ; struct nfs_open_context *tmp ; struct inode *inode ; struct address_space *tmp___0 ; int status ; loff_t tmp___1 ; long tmp___2 ; unsigned int _max1 ; unsigned int _max2 ; unsigned int tmp___3 ; int tmp___4 ; loff_t tmp___5 ; long tmp___6 ; { tmp = nfs_file_open_context(file); ctx = tmp; tmp___0 = page_file_mapping(page); inode = tmp___0->host; status = 0; nfs_inc_stats___4((struct inode const *)inode, 7); tmp___2 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___2 != 0L) { tmp___1 = page_file_offset(page); printk("\001dNFS: nfs_updatepage(%s/%s %d@%lld)\n", ((file->f_path.dentry)->d_parent)->d_name.name, (file->f_path.dentry)->d_name.name, count, tmp___1 + (loff_t )offset); } else { } tmp___4 = nfs_can_extend_write(file, page, inode); if (tmp___4 != 0) { _max1 = count + offset; tmp___3 = nfs_page_length(page); _max2 = tmp___3; count = _max1 > _max2 ? _max1 : _max2; offset = 0U; } else { } status = nfs_writepage_setup(ctx, page, offset, count); if (status < 0) { nfs_set_pageerror(page); } else { __set_page_dirty_nobuffers(page); } tmp___6 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___6 != 0L) { tmp___5 = i_size_read((struct inode const *)inode); printk("\001dNFS: nfs_updatepage returns %d (isize %lld)\n", status, tmp___5); } else { } return (status); } } static int flush_task_priority(int how ) { { switch (how & 24) { case 16: ; return (1); case 8: ; return (-1); } return (0); } } int nfs_initiate_write(struct rpc_clnt *clnt , struct nfs_write_data *data , struct rpc_call_ops const *call_ops , int how , int flags ) { struct inode *inode ; int priority ; int tmp ; struct rpc_task *task ; struct rpc_message msg ; struct rpc_task_setup task_setup_data ; int ret ; struct nfs_rpc_ops const *tmp___0 ; __u64 tmp___1 ; long tmp___2 ; struct nfs_server *tmp___3 ; long tmp___4 ; long tmp___5 ; { inode = (data->header)->inode; tmp = flush_task_priority(how); priority = tmp; msg.rpc_proc = 0; msg.rpc_argp = (void *)(& data->args); msg.rpc_resp = (void *)(& data->res); msg.rpc_cred = (data->header)->cred; task_setup_data.task = & data->task; task_setup_data.rpc_client = clnt; task_setup_data.rpc_message = (struct rpc_message const *)(& msg); task_setup_data.callback_ops = call_ops; task_setup_data.callback_data = (void *)data; task_setup_data.workqueue = nfsiod_workqueue; task_setup_data.flags = (unsigned short )((int )((short )flags) | 1); task_setup_data.priority = (signed char )priority; ret = 0; tmp___0 = NFS_PROTO((struct inode const *)inode); (*(tmp___0->write_setup))(data, & msg); tmp___2 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___2 != 0L) { tmp___1 = NFS_FILEID((struct inode const *)inode); printk("\001dNFS: %5u initiated write call (req %s/%lld, %u bytes @ offset %llu)\n", (int )data->task.tk_pid, (char *)(& (inode->i_sb)->s_id), (long long )tmp___1, data->args.count, data->args.offset); } else { } tmp___3 = NFS_SERVER((struct inode const *)inode); nfs4_state_protect_write(tmp___3->nfs_client, & task_setup_data.rpc_client, & msg, data); task = rpc_run_task((struct rpc_task_setup const *)(& task_setup_data)); tmp___5 = IS_ERR((void const *)task); if (tmp___5 != 0L) { tmp___4 = PTR_ERR((void const *)task); ret = (int )tmp___4; goto out; } else { } if (how & 1) { ret = rpc_wait_for_completion_task(task); if (ret == 0) { ret = task->tk_status; } else { } } else { } rpc_put_task(task); out: ; return (ret); } } static void nfs_write_rpcsetup(struct nfs_write_data *data , unsigned int count , unsigned int offset , int how , struct nfs_commit_info *cinfo ) { struct nfs_page *req ; loff_t tmp ; unsigned long tmp___0 ; { req = (data->header)->req; data->args.fh = NFS_FH((struct inode const *)(data->header)->inode); tmp = req_offset(req); data->args.offset = (__u64 )(tmp + (loff_t )offset); data->mds_offset = data->args.offset; data->args.pgbase = req->wb_pgbase + offset; data->args.pages = data->pages.pagevec; data->args.count = count; data->args.context = get_nfs_open_context(req->wb_context); data->args.lock_context = req->wb_lock_context; data->args.stable = 0; switch (how & 36) { case 0: ; goto ldv_54475; case 32: tmp___0 = nfs_reqs_to_commit(cinfo); if (tmp___0 != 0UL) { goto ldv_54475; } else { } default: data->args.stable = 2; } ldv_54475: data->res.fattr = & data->fattr; data->res.count = count; data->res.verf = & data->verf; nfs_fattr_init(& data->fattr); return; } } static int nfs_do_write(struct nfs_write_data *data , struct rpc_call_ops const *call_ops , int how ) { struct inode *inode ; struct rpc_clnt *tmp ; int tmp___0 ; { inode = (data->header)->inode; tmp = NFS_CLIENT((struct inode const *)inode); tmp___0 = nfs_initiate_write(tmp, data, call_ops, how, 0); return (tmp___0); } } static int nfs_do_multiple_writes(struct list_head *head , struct rpc_call_ops const *call_ops , int how ) { struct nfs_write_data *data ; int ret ; int ret2 ; struct list_head const *__mptr ; int tmp ; { ret = 0; goto ldv_54495; ldv_54494: __mptr = (struct list_head const *)head->next; data = (struct nfs_write_data *)__mptr + 0xfffffffffffffff8UL; list_del_init(& data->list); ret2 = nfs_do_write(data, call_ops, how); if (ret == 0) { ret = ret2; } else { } ldv_54495: tmp = list_empty((struct list_head const *)head); if (tmp == 0) { goto ldv_54494; } else { } return (ret); } } static void nfs_redirty_request(struct nfs_page *req ) { { nfs_mark_request_dirty(req); nfs_unlock_request(req); nfs_end_page_writeback(req->wb_page); nfs_release_request(req); return; } } static void nfs_async_write_error(struct list_head *head ) { struct nfs_page *req ; int tmp ; { goto ldv_54505; ldv_54504: req = nfs_list_entry(head->next); nfs_list_remove_request(req); nfs_redirty_request(req); ldv_54505: tmp = list_empty((struct list_head const *)head); if (tmp == 0) { goto ldv_54504; } else { } return; } } static struct nfs_pgio_completion_ops const nfs_async_write_completion_ops = {& nfs_async_write_error, 0, & nfs_write_completion}; static void nfs_flush_error(struct nfs_pageio_descriptor *desc , struct nfs_pgio_header *hdr ) { struct nfs_write_data *data ; struct list_head const *__mptr ; int tmp ; { set_bit(2L, (unsigned long volatile *)(& hdr->flags)); goto ldv_54516; ldv_54515: __mptr = (struct list_head const *)hdr->rpc_list.next; data = (struct nfs_write_data *)__mptr + 0xfffffffffffffff8UL; list_del(& data->list); nfs_writedata_release(data); ldv_54516: tmp = list_empty((struct list_head const *)(& hdr->rpc_list)); if (tmp == 0) { goto ldv_54515; } else { } (*((desc->pg_completion_ops)->error_cleanup))(& desc->pg_list); return; } } static int nfs_flush_multi(struct nfs_pageio_descriptor *desc , struct nfs_pgio_header *hdr ) { struct nfs_page *req ; struct page *page ; struct nfs_write_data *data ; size_t wsize ; size_t nbytes ; unsigned int offset ; int requests ; struct nfs_commit_info cinfo ; unsigned long tmp ; size_t len ; size_t _min1 ; size_t _min2 ; { req = hdr->req; page = req->wb_page; wsize = desc->pg_bsize; requests = 0; nfs_init_cinfo(& cinfo, desc->pg_inode, desc->pg_dreq); if ((desc->pg_ioflags & 32) != 0) { if ((unsigned int )*((unsigned char *)desc + 44UL) != 0U) { desc->pg_ioflags = desc->pg_ioflags & -33; } else { tmp = nfs_reqs_to_commit(& cinfo); if (tmp != 0UL) { desc->pg_ioflags = desc->pg_ioflags & -33; } else if (desc->pg_count > wsize) { desc->pg_ioflags = desc->pg_ioflags & -33; } else { } } } else { } offset = 0U; nbytes = desc->pg_count; ldv_54534: _min1 = nbytes; _min2 = wsize; len = _min1 < _min2 ? _min1 : _min2; data = nfs_writedata_alloc(hdr, 1U); if ((unsigned long )data == (unsigned long )((struct nfs_write_data *)0)) { nfs_flush_error(desc, hdr); return (-12); } else { } *(data->pages.pagevec) = page; nfs_write_rpcsetup(data, (unsigned int )len, offset, desc->pg_ioflags, & cinfo); list_add(& data->list, & hdr->rpc_list); requests = requests + 1; nbytes = nbytes - len; offset = (unsigned int )len + offset; if (nbytes != 0UL) { goto ldv_54534; } else { } nfs_list_remove_request(req); nfs_list_add_request(req, & hdr->pages); desc->pg_rpc_callops = & nfs_write_common_ops; return (0); } } static int nfs_flush_one(struct nfs_pageio_descriptor *desc , struct nfs_pgio_header *hdr ) { struct nfs_page *req ; struct page **pages ; struct nfs_write_data *data ; struct list_head *head ; struct nfs_commit_info cinfo ; unsigned int tmp ; struct page **tmp___0 ; int tmp___1 ; unsigned long tmp___2 ; { head = & desc->pg_list; tmp = nfs_page_array_len(desc->pg_base, desc->pg_count); data = nfs_writedata_alloc(hdr, tmp); if ((unsigned long )data == (unsigned long )((struct nfs_write_data *)0)) { nfs_flush_error(desc, hdr); return (-12); } else { } nfs_init_cinfo(& cinfo, desc->pg_inode, desc->pg_dreq); pages = data->pages.pagevec; goto ldv_54546; ldv_54545: req = nfs_list_entry(head->next); nfs_list_remove_request(req); nfs_list_add_request(req, & hdr->pages); tmp___0 = pages; pages = pages + 1; *tmp___0 = req->wb_page; ldv_54546: tmp___1 = list_empty((struct list_head const *)head); if (tmp___1 == 0) { goto ldv_54545; } else { } if ((desc->pg_ioflags & 32) != 0) { if ((unsigned int )*((unsigned char *)desc + 44UL) != 0U) { desc->pg_ioflags = desc->pg_ioflags & -33; } else { tmp___2 = nfs_reqs_to_commit(& cinfo); if (tmp___2 != 0UL) { desc->pg_ioflags = desc->pg_ioflags & -33; } else { } } } else { } nfs_write_rpcsetup(data, (unsigned int )desc->pg_count, 0U, desc->pg_ioflags, & cinfo); list_add(& data->list, & hdr->rpc_list); desc->pg_rpc_callops = & nfs_write_common_ops; return (0); } } int nfs_generic_flush(struct nfs_pageio_descriptor *desc , struct nfs_pgio_header *hdr ) { int tmp ; int tmp___0 ; { if (desc->pg_bsize <= 4095UL) { tmp = nfs_flush_multi(desc, hdr); return (tmp); } else { } tmp___0 = nfs_flush_one(desc, hdr); return (tmp___0); } } static int nfs_generic_pg_writepages(struct nfs_pageio_descriptor *desc ) { struct nfs_write_header *whdr ; struct nfs_pgio_header *hdr ; int ret ; int tmp ; { whdr = nfs_writehdr_alloc(); if ((unsigned long )whdr == (unsigned long )((struct nfs_write_header *)0)) { (*((desc->pg_completion_ops)->error_cleanup))(& desc->pg_list); return (-12); } else { } hdr = & whdr->header; nfs_pgheader_init(desc, hdr, & nfs_writehdr_free); atomic_inc(& hdr->refcnt); ret = nfs_generic_flush(desc, hdr); if (ret == 0) { ret = nfs_do_multiple_writes(& hdr->rpc_list, desc->pg_rpc_callops, desc->pg_ioflags); } else { } tmp = atomic_dec_and_test(& hdr->refcnt); if (tmp != 0) { (*((hdr->completion_ops)->completion))(hdr); } else { } return (ret); } } static struct nfs_pageio_ops const nfs_pageio_write_ops = {0, & nfs_generic_pg_test, & nfs_generic_pg_writepages}; void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio , struct inode *inode , int ioflags , struct nfs_pgio_completion_ops const *compl_ops ) { struct nfs_server *tmp ; { tmp = NFS_SERVER((struct inode const *)inode); nfs_pageio_init(pgio, inode, & nfs_pageio_write_ops, compl_ops, (size_t )tmp->wsize, ioflags); return; } } void nfs_pageio_reset_write_mds(struct nfs_pageio_descriptor *pgio ) { struct nfs_server *tmp ; { pgio->pg_ops = & nfs_pageio_write_ops; tmp = NFS_SERVER((struct inode const *)pgio->pg_inode); pgio->pg_bsize = (size_t )tmp->wsize; return; } } void nfs_write_prepare(struct rpc_task *task , void *calldata ) { struct nfs_write_data *data ; int err ; struct nfs_rpc_ops const *tmp ; { data = (struct nfs_write_data *)calldata; tmp = NFS_PROTO((struct inode const *)(data->header)->inode); err = (*(tmp->write_rpc_prepare))(task, data); if (err != 0) { rpc_exit(task, err); } else { } return; } } void nfs_commit_prepare(struct rpc_task *task , void *calldata ) { struct nfs_commit_data *data ; struct nfs_rpc_ops const *tmp ; { data = (struct nfs_commit_data *)calldata; tmp = NFS_PROTO((struct inode const *)data->inode); (*(tmp->commit_rpc_prepare))(task, data); return; } } static void nfs_writeback_done_common(struct rpc_task *task , void *calldata ) { struct nfs_write_data *data ; { data = (struct nfs_write_data *)calldata; nfs_writeback_done(task, data); return; } } static void nfs_writeback_release_common(void *calldata ) { struct nfs_write_data *data ; struct nfs_pgio_header *hdr ; int status ; size_t __len ; void *__ret ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; { data = (struct nfs_write_data *)calldata; hdr = data->header; status = data->task.tk_status; if (status >= 0) { tmp___2 = nfs_write_need_commit(data); if (tmp___2 != 0) { spin_lock(& hdr->lock); tmp___1 = constant_test_bit(4L, (unsigned long const volatile *)(& hdr->flags)); if (tmp___1 != 0) { } else { tmp___0 = test_and_set_bit(3L, (unsigned long volatile *)(& hdr->flags)); if (tmp___0 == 0) { __len = 12UL; if (__len > 63UL) { __ret = __memcpy((void *)hdr->verf, (void const *)(& data->verf), __len); } else { __ret = __builtin_memcpy((void *)hdr->verf, (void const *)(& data->verf), __len); } } else { tmp = memcmp((void const *)hdr->verf, (void const *)(& data->verf), 12UL); if (tmp != 0) { set_bit(4L, (unsigned long volatile *)(& hdr->flags)); } else { } } } spin_unlock(& hdr->lock); } else { } } else { } nfs_writedata_release(data); return; } } static struct rpc_call_ops const nfs_write_common_ops = {& nfs_write_prepare, & nfs_writeback_done_common, 0, & nfs_writeback_release_common}; void nfs_writeback_done(struct rpc_task *task , struct nfs_write_data *data ) { struct nfs_writeargs *argp ; struct nfs_writeres *resp ; struct inode *inode ; int status ; long tmp ; struct nfs_rpc_ops const *tmp___0 ; unsigned long complain ; struct nfs_server *tmp___1 ; long tmp___2 ; unsigned long complain___0 ; { argp = & data->args; resp = & data->res; inode = (data->header)->inode; tmp = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: %5u nfs_writeback_done (status %d)\n", (int )task->tk_pid, task->tk_status); } else { } tmp___0 = NFS_PROTO((struct inode const *)inode); status = (*(tmp___0->write_done))(task, data); if (status != 0) { return; } else { } nfs_add_stats___2((struct inode const *)inode, 5, (long )resp->count); if ((unsigned int )(resp->verf)->committed < (unsigned int )argp->stable && task->tk_status >= 0) { if ((long )(complain - (unsigned long )jiffies) < 0L) { tmp___2 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___2 != 0L) { tmp___1 = NFS_SERVER((struct inode const *)inode); printk("\001dNFS: faulty NFS server %s: (committed = %d) != (stable = %d)\n", (tmp___1->nfs_client)->cl_hostname, (unsigned int )(resp->verf)->committed, (unsigned int )argp->stable); } else { } complain = (unsigned long )jiffies + 75000UL; } else { } } else { } if (task->tk_status < 0) { nfs_set_pgio_error(data->header, task->tk_status, (loff_t )argp->offset); } else if (resp->count < argp->count) { nfs_inc_stats___4((struct inode const *)inode, 23); if (resp->count == 0U) { if ((long )(complain___0 - (unsigned long )jiffies) < 0L) { printk("\fNFS: Server wrote zero bytes, expected %u.\n", argp->count); complain___0 = (unsigned long )jiffies + 75000UL; } else { } nfs_set_pgio_error(data->header, -5, (loff_t )argp->offset); task->tk_status = -5; return; } else { } if ((unsigned int )(resp->verf)->committed != 0U) { data->mds_offset = data->mds_offset + (__u64 )resp->count; argp->offset = argp->offset + (__u64 )resp->count; argp->pgbase = argp->pgbase + resp->count; argp->count = argp->count - resp->count; } else { argp->stable = 2; } rpc_restart_call_prepare(task); } else { } return; } } static int nfs_commit_set_lock(struct nfs_inode *nfsi , int may_wait ) { int ret ; int tmp ; { tmp = test_and_set_bit(7L, (unsigned long volatile *)(& nfsi->flags)); if (tmp == 0) { return (1); } else { } if (may_wait == 0) { return (0); } else { } ret = out_of_line_wait_on_bit_lock((void *)(& nfsi->flags), 7, & nfs_wait_bit_killable, 130U); return (ret < 0 ? ret : 1); } } static void nfs_commit_clear_lock(struct nfs_inode *nfsi ) { { clear_bit(7L, (unsigned long volatile *)(& nfsi->flags)); __asm__ volatile ("": : : "memory"); wake_up_bit((void *)(& nfsi->flags), 7); return; } } void nfs_commitdata_release(struct nfs_commit_data *data ) { { put_nfs_open_context(data->context); nfs_commit_free(data); return; } } int nfs_initiate_commit(struct rpc_clnt *clnt , struct nfs_commit_data *data , struct rpc_call_ops const *call_ops , int how , int flags ) { struct rpc_task *task ; int priority ; int tmp ; struct rpc_message msg ; struct rpc_task_setup task_setup_data ; struct nfs_rpc_ops const *tmp___0 ; long tmp___1 ; struct nfs_server *tmp___2 ; long tmp___3 ; long tmp___4 ; { tmp = flush_task_priority(how); priority = tmp; msg.rpc_proc = 0; msg.rpc_argp = (void *)(& data->args); msg.rpc_resp = (void *)(& data->res); msg.rpc_cred = data->cred; task_setup_data.task = & data->task; task_setup_data.rpc_client = clnt; task_setup_data.rpc_message = (struct rpc_message const *)(& msg); task_setup_data.callback_ops = call_ops; task_setup_data.callback_data = (void *)data; task_setup_data.workqueue = nfsiod_workqueue; task_setup_data.flags = (unsigned short )((int )((short )flags) | 1); task_setup_data.priority = (signed char )priority; tmp___0 = NFS_PROTO((struct inode const *)data->inode); (*(tmp___0->commit_setup))(data, & msg); tmp___1 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001dNFS: %5u initiated commit call\n", (int )data->task.tk_pid); } else { } tmp___2 = NFS_SERVER((struct inode const *)data->inode); nfs4_state_protect(tmp___2->nfs_client, 6UL, & task_setup_data.rpc_client, & msg); task = rpc_run_task((struct rpc_task_setup const *)(& task_setup_data)); tmp___4 = IS_ERR((void const *)task); if (tmp___4 != 0L) { tmp___3 = PTR_ERR((void const *)task); return ((int )tmp___3); } else { } if (how & 1) { rpc_wait_for_completion_task(task); } else { } rpc_put_task(task); return (0); } } void nfs_init_commit(struct nfs_commit_data *data , struct list_head *head , struct pnfs_layout_segment *lseg , struct nfs_commit_info *cinfo ) { struct nfs_page *first ; struct nfs_page *tmp ; struct inode *inode ; { tmp = nfs_list_entry(head->next); first = tmp; inode = ((first->wb_context)->dentry)->d_inode; list_splice_init(head, & data->pages); data->inode = inode; data->cred = (first->wb_context)->cred; data->lseg = lseg; data->mds_ops = & nfs_commit_ops; data->completion_ops = cinfo->completion_ops; data->dreq = cinfo->dreq; data->args.fh = NFS_FH((struct inode const *)data->inode); data->args.offset = 0ULL; data->args.count = 0U; data->context = get_nfs_open_context(first->wb_context); data->res.fattr = & data->fattr; data->res.verf = & data->verf; nfs_fattr_init(& data->fattr); return; } } void nfs_retry_commit(struct list_head *page_list , struct pnfs_layout_segment *lseg , struct nfs_commit_info *cinfo ) { struct nfs_page *req ; struct address_space *tmp ; int tmp___0 ; { goto ldv_54700; ldv_54699: req = nfs_list_entry(page_list->next); nfs_list_remove_request(req); nfs_mark_request_commit(req, lseg, cinfo); if ((unsigned long )cinfo->dreq == (unsigned long )((struct nfs_direct_req *)0)) { dec_zone_page_state(req->wb_page, 17); tmp = page_file_mapping(req->wb_page); dec_bdi_stat(tmp->backing_dev_info, 0); } else { } nfs_unlock_and_release_request(req); ldv_54700: tmp___0 = list_empty((struct list_head const *)page_list); if (tmp___0 == 0) { goto ldv_54699; } else { } return; } } static int nfs_commit_list(struct inode *inode , struct list_head *head , int how , struct nfs_commit_info *cinfo ) { struct nfs_commit_data *data ; struct rpc_clnt *tmp ; int tmp___0 ; struct nfs_inode *tmp___1 ; { data = nfs_commitdata_alloc(); if ((unsigned long )data == (unsigned long )((struct nfs_commit_data *)0)) { goto out_bad; } else { } nfs_init_commit(data, head, (struct pnfs_layout_segment *)0, cinfo); atomic_inc(& (cinfo->mds)->rpcs_out); tmp = NFS_CLIENT((struct inode const *)inode); tmp___0 = nfs_initiate_commit(tmp, data, data->mds_ops, how, 0); return (tmp___0); out_bad: nfs_retry_commit(head, (struct pnfs_layout_segment *)0, cinfo); tmp___1 = NFS_I((struct inode const *)inode); (*((cinfo->completion_ops)->error_cleanup))(tmp___1); return (-12); } } static void nfs_commit_done(struct rpc_task *task , void *calldata ) { struct nfs_commit_data *data ; long tmp ; struct nfs_rpc_ops const *tmp___0 ; { data = (struct nfs_commit_data *)calldata; tmp = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: %5u nfs_commit_done (status %d)\n", (int )task->tk_pid, task->tk_status); } else { } tmp___0 = NFS_PROTO((struct inode const *)data->inode); (*(tmp___0->commit_done))(task, data); return; } } static void nfs_commit_release_pages(struct nfs_commit_data *data ) { struct nfs_page *req ; int status ; struct nfs_commit_info cinfo ; loff_t tmp ; __u64 tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; int tmp___4 ; long tmp___5 ; int tmp___6 ; struct nfs_inode *tmp___7 ; int tmp___8 ; { status = data->task.tk_status; goto ldv_54731; ldv_54730: req = nfs_list_entry(data->pages.next); nfs_list_remove_request(req); nfs_clear_page_commit(req->wb_page); tmp___1 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___1 != 0L) { tmp = req_offset(req); tmp___0 = NFS_FILEID((struct inode const *)((req->wb_context)->dentry)->d_inode); printk("\001dNFS: commit (%s/%lld %d@%lld)", (char *)(& (((req->wb_context)->dentry)->d_sb)->s_id), (long long )tmp___0, req->wb_bytes, tmp); } else { } if (status < 0) { nfs_context_set_write_error(req->wb_context, status); nfs_inode_remove_request(req); tmp___2 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___2 != 0L) { printk("\001d, error = %d\n", status); } else { } goto next; } else { } tmp___4 = memcmp((void const *)(& req->wb_verf), (void const *)(& data->verf.verifier), 8UL); if (tmp___4 == 0) { nfs_inode_remove_request(req); tmp___3 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___3 != 0L) { printk("\001d OK\n"); } else { } goto next; } else { } tmp___5 = ldv__builtin_expect((nfs_debug & 8U) != 0U, 0L); if (tmp___5 != 0L) { printk("\001d mismatch\n"); } else { } nfs_mark_request_dirty(req); set_bit(1L, (unsigned long volatile *)(& (req->wb_context)->flags)); next: nfs_unlock_and_release_request(req); ldv_54731: tmp___6 = list_empty((struct list_head const *)(& data->pages)); if (tmp___6 == 0) { goto ldv_54730; } else { } nfs_init_cinfo(& cinfo, data->inode, data->dreq); tmp___8 = atomic_dec_and_test(& (cinfo.mds)->rpcs_out); if (tmp___8 != 0) { tmp___7 = NFS_I((struct inode const *)data->inode); nfs_commit_clear_lock(tmp___7); } else { } return; } } static void nfs_commit_release(void *calldata ) { struct nfs_commit_data *data ; { data = (struct nfs_commit_data *)calldata; (*((data->completion_ops)->completion))(data); nfs_commitdata_release((struct nfs_commit_data *)calldata); return; } } static struct rpc_call_ops const nfs_commit_ops = {& nfs_commit_prepare, & nfs_commit_done, 0, & nfs_commit_release}; static struct nfs_commit_completion_ops const nfs_commit_completion_ops = {& nfs_commit_clear_lock, & nfs_commit_release_pages}; int nfs_generic_commit_list(struct inode *inode , struct list_head *head , int how , struct nfs_commit_info *cinfo ) { int status ; { status = pnfs_commit_list(inode, head, how, cinfo); if (status == 1) { status = nfs_commit_list(inode, head, how, cinfo); } else { } return (status); } } int nfs_commit_inode(struct inode *inode , int how ) { struct list_head head ; struct nfs_commit_info cinfo ; int may_wait ; int res ; struct nfs_inode *tmp ; int error ; struct nfs_inode *tmp___0 ; struct nfs_inode *tmp___1 ; { head.next = & head; head.prev = & head; may_wait = how & 1; tmp = NFS_I((struct inode const *)inode); res = nfs_commit_set_lock(tmp, may_wait); if (res <= 0) { goto out_mark_dirty; } else { } nfs_init_cinfo_from_inode(& cinfo, inode); res = nfs_scan_commit(inode, & head, & cinfo); if (res != 0) { error = nfs_generic_commit_list(inode, & head, how, & cinfo); if (error < 0) { return (error); } else { } if (may_wait == 0) { goto out_mark_dirty; } else { } tmp___0 = NFS_I((struct inode const *)inode); error = wait_on_bit((void *)(& tmp___0->flags), 7, & nfs_wait_bit_killable, 130U); if (error < 0) { return (error); } else { } } else { tmp___1 = NFS_I((struct inode const *)inode); nfs_commit_clear_lock(tmp___1); } return (res); out_mark_dirty: __mark_inode_dirty(inode, 2); return (res); } } static int nfs_commit_unstable_pages(struct inode *inode , struct writeback_control *wbc ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; int flags ; int ret ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; flags = 1; ret = 0; if (nfsi->commit_info.ncommit == 0UL) { return (ret); } else { } if ((unsigned int )wbc->sync_mode == 0U) { if (nfsi->commit_info.ncommit <= nfsi->npages >> 1) { goto out_mark_dirty; } else { } flags = 0; } else { } ret = nfs_commit_inode(inode, flags); if (ret >= 0) { if ((unsigned int )wbc->sync_mode == 0U) { if ((long )ret < wbc->nr_to_write) { wbc->nr_to_write = wbc->nr_to_write - (long )ret; } else { wbc->nr_to_write = 0L; } } else { } return (0); } else { } out_mark_dirty: __mark_inode_dirty(inode, 2); return (ret); } } int nfs_write_inode(struct inode *inode , struct writeback_control *wbc ) { int tmp ; { tmp = nfs_commit_unstable_pages(inode, wbc); return (tmp); } } int nfs_wb_all(struct inode *inode ) { struct writeback_control wbc ; int ret ; { wbc.nr_to_write = 9223372036854775807L; wbc.pages_skipped = 0L; wbc.range_start = 0LL; wbc.range_end = 9223372036854775807LL; wbc.sync_mode = 1; wbc.for_kupdate = (unsigned char)0; wbc.for_background = (unsigned char)0; wbc.tagged_writepages = (unsigned char)0; wbc.for_reclaim = (unsigned char)0; wbc.range_cyclic = (unsigned char)0; wbc.for_sync = (unsigned char)0; trace_nfs_writeback_inode_enter((struct inode const *)inode); ret = sync_inode(inode, & wbc); trace_nfs_writeback_inode_exit((struct inode const *)inode, ret); return (ret); } } int nfs_wb_page_cancel(struct inode *inode , struct page *page ) { struct nfs_page *req ; int ret ; int tmp ; { ret = 0; ldv_54793: wait_on_page_writeback(page); req = nfs_page_find_request(page); if ((unsigned long )req == (unsigned long )((struct nfs_page *)0)) { goto ldv_54792; } else { } tmp = nfs_lock_request(req); if (tmp != 0) { nfs_clear_request_commit(req); nfs_inode_remove_request(req); cancel_dirty_page(page, 4096U); nfs_unlock_and_release_request(req); goto ldv_54792; } else { } ret = nfs_wait_on_request(req); nfs_release_request(req); if (ret < 0) { goto ldv_54792; } else { } goto ldv_54793; ldv_54792: ; return (ret); } } int nfs_wb_page(struct inode *inode , struct page *page ) { loff_t range_start ; loff_t tmp ; loff_t range_end ; struct writeback_control wbc ; int ret ; int tmp___0 ; int tmp___1 ; { tmp = page_file_offset(page); range_start = tmp; range_end = range_start + 4095LL; wbc.nr_to_write = 0L; wbc.pages_skipped = 0L; wbc.range_start = range_start; wbc.range_end = range_end; wbc.sync_mode = 1; wbc.for_kupdate = (unsigned char)0; wbc.for_background = (unsigned char)0; wbc.tagged_writepages = (unsigned char)0; wbc.for_reclaim = (unsigned char)0; wbc.range_cyclic = (unsigned char)0; wbc.for_sync = (unsigned char)0; trace_nfs_writeback_page_enter((struct inode const *)inode); ldv_54805: wait_on_page_writeback(page); tmp___0 = clear_page_dirty_for_io(page); if (tmp___0 != 0) { ret = nfs_writepage_locked(page, & wbc); if (ret < 0) { goto out_error; } else { } goto ldv_54803; } else { } ret = 0; tmp___1 = PagePrivate((struct page const *)page); if (tmp___1 == 0) { goto ldv_54804; } else { } ret = nfs_commit_inode(inode, 1); if (ret < 0) { goto out_error; } else { } ldv_54803: ; goto ldv_54805; ldv_54804: ; out_error: trace_nfs_writeback_page_exit((struct inode const *)inode, ret); return (ret); } } int nfs_migrate_page(struct address_space *mapping , struct page *newpage , struct page *page , enum migrate_mode mode ) { int tmp ; int tmp___0 ; int tmp___1 ; { tmp = PagePrivate((struct page const *)page); if (tmp != 0) { return (-16); } else { } tmp___0 = nfs_fscache_release_page(page, 208U); if (tmp___0 == 0) { return (-16); } else { } tmp___1 = migrate_page(mapping, newpage, page, mode); return (tmp___1); } } int nfs_init_writepagecache(void) { unsigned long tmp ; { nfs_wdata_cachep = kmem_cache_create("nfs_write_data", 1008UL, 0UL, 8192UL, (void (*)(void * ))0); if ((unsigned long )nfs_wdata_cachep == (unsigned long )((struct kmem_cache *)0)) { return (-12); } else { } nfs_wdata_mempool = mempool_create_slab_pool(32, nfs_wdata_cachep); if ((unsigned long )nfs_wdata_mempool == (unsigned long )((mempool_t *)0)) { goto out_destroy_write_cache; } else { } nfs_cdata_cachep = kmem_cache_create("nfs_commit_data", 688UL, 0UL, 8192UL, (void (*)(void * ))0); if ((unsigned long )nfs_cdata_cachep == (unsigned long )((struct kmem_cache *)0)) { goto out_destroy_write_mempool; } else { } nfs_commit_mempool = mempool_create_slab_pool(4, nfs_cdata_cachep); if ((unsigned long )nfs_commit_mempool == (unsigned long )((mempool_t *)0)) { goto out_destroy_commit_cache; } else { } tmp = int_sqrt(totalram_pages); nfs_congestion_kb = (int )(tmp * 16UL << 2); if (nfs_congestion_kb > 262144) { nfs_congestion_kb = 262144; } else { } return (0); out_destroy_commit_cache: kmem_cache_destroy(nfs_cdata_cachep); out_destroy_write_mempool: mempool_destroy(nfs_wdata_mempool); out_destroy_write_cache: kmem_cache_destroy(nfs_wdata_cachep); return (-12); } } void nfs_destroy_writepagecache(void) { { mempool_destroy(nfs_commit_mempool); kmem_cache_destroy(nfs_cdata_cachep); mempool_destroy(nfs_wdata_mempool); kmem_cache_destroy(nfs_wdata_cachep); return; } } void ldv_initialize_nfs_pageio_ops_40(void) { void *tmp ; { tmp = ldv_zalloc(112UL); nfs_pageio_write_ops_group0 = (struct nfs_pageio_descriptor *)tmp; return; } } void ldv_initialize_rpc_call_ops_38(void) { void *tmp ; { tmp = ldv_zalloc(240UL); nfs_commit_ops_group0 = (struct rpc_task *)tmp; return; } } void ldv_initialize_rpc_call_ops_39(void) { void *tmp ; { tmp = ldv_zalloc(240UL); nfs_write_common_ops_group0 = (struct rpc_task *)tmp; return; } } void ldv_main_exported_38(void) { void *ldvarg298 ; void *tmp ; void *ldvarg300 ; void *tmp___0 ; void *ldvarg299 ; void *tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(1UL); ldvarg298 = tmp; tmp___0 = ldv_zalloc(1UL); ldvarg300 = tmp___0; tmp___1 = ldv_zalloc(1UL); ldvarg299 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_38 == 1) { nfs_commit_done(nfs_commit_ops_group0, ldvarg300); ldv_state_variable_38 = 1; } else { } goto ldv_54837; case 1: ; if (ldv_state_variable_38 == 1) { nfs_commit_prepare(nfs_commit_ops_group0, ldvarg299); ldv_state_variable_38 = 1; } else { } goto ldv_54837; case 2: ; if (ldv_state_variable_38 == 1) { nfs_commit_release(ldvarg298); ldv_state_variable_38 = 1; } else { } goto ldv_54837; default: ldv_stop(); } ldv_54837: ; return; } } void ldv_main_exported_39(void) { void *ldvarg103 ; void *tmp ; void *ldvarg102 ; void *tmp___0 ; void *ldvarg104 ; void *tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(1UL); ldvarg103 = tmp; tmp___0 = ldv_zalloc(1UL); ldvarg102 = tmp___0; tmp___1 = ldv_zalloc(1UL); ldvarg104 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_39 == 1) { nfs_writeback_done_common(nfs_write_common_ops_group0, ldvarg104); ldv_state_variable_39 = 1; } else { } goto ldv_54848; case 1: ; if (ldv_state_variable_39 == 1) { nfs_write_prepare(nfs_write_common_ops_group0, ldvarg103); ldv_state_variable_39 = 1; } else { } goto ldv_54848; case 2: ; if (ldv_state_variable_39 == 1) { nfs_writeback_release_common(ldvarg102); ldv_state_variable_39 = 1; } else { } goto ldv_54848; default: ldv_stop(); } ldv_54848: ; return; } } void ldv_main_exported_40(void) { struct nfs_page *ldvarg251 ; void *tmp ; struct nfs_page *ldvarg250 ; void *tmp___0 ; int tmp___1 ; { tmp = ldv_zalloc(80UL); ldvarg251 = (struct nfs_page *)tmp; tmp___0 = ldv_zalloc(80UL); ldvarg250 = (struct nfs_page *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); switch (tmp___1) { case 0: ; if (ldv_state_variable_40 == 1) { nfs_generic_pg_test(nfs_pageio_write_ops_group0, ldvarg251, ldvarg250); ldv_state_variable_40 = 1; } else { } goto ldv_54858; case 1: ; if (ldv_state_variable_40 == 1) { nfs_generic_pg_writepages(nfs_pageio_write_ops_group0); ldv_state_variable_40 = 1; } else { } goto ldv_54858; default: ldv_stop(); } ldv_54858: ; return; } } void ldv_main_exported_37(void) { struct nfs_commit_data *ldvarg306 ; void *tmp ; struct nfs_inode *ldvarg307 ; void *tmp___0 ; int tmp___1 ; { tmp = ldv_zalloc(688UL); ldvarg306 = (struct nfs_commit_data *)tmp; tmp___0 = ldv_zalloc(1672UL); ldvarg307 = (struct nfs_inode *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); switch (tmp___1) { case 0: ; if (ldv_state_variable_37 == 1) { nfs_commit_clear_lock(ldvarg307); ldv_state_variable_37 = 1; } else { } goto ldv_54867; case 1: ; if (ldv_state_variable_37 == 1) { nfs_commit_release_pages(ldvarg306); ldv_state_variable_37 = 1; } else { } goto ldv_54867; default: ldv_stop(); } ldv_54867: ; return; } } void ldv_main_exported_41(void) { struct nfs_pgio_header *ldvarg135 ; void *tmp ; struct list_head *ldvarg136 ; void *tmp___0 ; int tmp___1 ; { tmp = ldv_zalloc(224UL); ldvarg135 = (struct nfs_pgio_header *)tmp; tmp___0 = ldv_zalloc(16UL); ldvarg136 = (struct list_head *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); switch (tmp___1) { case 0: ; if (ldv_state_variable_41 == 1) { nfs_async_write_error(ldvarg136); ldv_state_variable_41 = 1; } else { } goto ldv_54876; case 1: ; if (ldv_state_variable_41 == 1) { nfs_write_completion(ldvarg135); ldv_state_variable_41 = 1; } else { } goto ldv_54876; default: ldv_stop(); } ldv_54876: ; return; } } __inline static void rep_nop(void) { { __asm__ volatile ("rep; nop": : : "memory"); return; } } __inline static void cpu_relax(void) { { rep_nop(); return; } } __inline static unsigned int __read_seqcount_begin(seqcount_t const *s ) { unsigned int ret ; long tmp ; { repeat: ret = *((unsigned int const volatile *)(& s->sequence)); tmp = ldv__builtin_expect((long )((int )ret) & 1L, 0L); if (tmp != 0L) { cpu_relax(); goto repeat; } else { } return (ret); } } __inline static unsigned int read_seqcount_begin(seqcount_t const *s ) { unsigned int ret ; unsigned int tmp ; { tmp = __read_seqcount_begin(s); ret = tmp; __asm__ volatile ("": : : "memory"); return (ret); } } __inline static int __read_seqcount_retry(seqcount_t const *s , unsigned int start ) { long tmp ; { tmp = ldv__builtin_expect((unsigned int )s->sequence != start, 0L); return ((int )tmp); } } __inline static int read_seqcount_retry(seqcount_t const *s , unsigned int start ) { int tmp ; { __asm__ volatile ("": : : "memory"); tmp = __read_seqcount_retry(s, start); return (tmp); } } __inline static unsigned int read_seqbegin(seqlock_t const *sl ) { unsigned int tmp ; { tmp = read_seqcount_begin(& sl->seqcount); return (tmp); } } __inline static unsigned int read_seqretry(seqlock_t const *sl , unsigned int start ) { int tmp ; { tmp = read_seqcount_retry(& sl->seqcount, start); return ((unsigned int )tmp); } } extern struct tvec_base boot_tvec_bases ; extern void delayed_work_timer_fn(unsigned long ) ; extern bool queue_delayed_work_on(int , struct workqueue_struct * , struct delayed_work * , unsigned long ) ; extern bool cancel_delayed_work(struct delayed_work * ) ; __inline static bool queue_delayed_work(struct workqueue_struct *wq , struct delayed_work *dwork , unsigned long delay ) { bool tmp ; { tmp = queue_delayed_work_on(4096, wq, dwork, delay); return (tmp); } } __inline static bool schedule_delayed_work(struct delayed_work *dwork , unsigned long delay ) { bool tmp ; { tmp = queue_delayed_work(system_wq, dwork, delay); return (tmp); } } extern seqlock_t rename_lock ; extern struct vfsmount *mntget(struct vfsmount * ) ; extern struct vfsmount *vfs_kern_mount(struct file_system_type * , int , char const * , void * ) ; extern void mnt_set_expiry(struct vfsmount * , struct list_head * ) ; extern void mark_mounts_for_expiry(struct list_head * ) ; int nfs_mountpoint_expiry_timeout ; struct vfsmount *nfs_submount(struct nfs_server *server , struct dentry *dentry , struct nfs_fh *fh , struct nfs_fattr *fattr ) ; struct vfsmount *nfs_do_submount(struct dentry *dentry , struct nfs_fh *fh , struct nfs_fattr *fattr , rpc_authflavor_t authflavor ) ; __inline static char *nfs_devname(struct dentry *dentry , char *buffer , ssize_t buflen ) { char *dummy ; char *tmp ; { tmp = nfs_path(& dummy, dentry, buffer, buflen, 1U); return (tmp); } } static void nfs_expire_automounts(struct work_struct *work ) ; static struct list_head nfs_automount_list = {& nfs_automount_list, & nfs_automount_list}; static struct delayed_work nfs_automount_task = {{{137438953424L}, {& nfs_automount_task.work.entry, & nfs_automount_task.work.entry}, & nfs_expire_automounts, {(struct lock_class_key *)(& nfs_automount_task.work), {0, 0}, "(nfs_automount_task).work", 0, 0UL}}, {{0, (struct list_head *)1953723489}, 0UL, (struct tvec_base *)((unsigned long )(& boot_tvec_bases) + 2UL), & delayed_work_timer_fn, (unsigned long )(& nfs_automount_task), -1, 0, 0, {(char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0}, {(struct lock_class_key *)"/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/namespace.o.c.prepared:219", {0, 0}, "/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/namespace.o.c.prepared:219", 0, 0UL}}, 0, 0}; int nfs_mountpoint_expiry_timeout = 125000; char *nfs_path(char **p , struct dentry *dentry , char *buffer , ssize_t buflen , unsigned int flags ) { char *end ; int namelen ; unsigned int seq ; char const *base ; size_t __len ; void *__ret ; unsigned int tmp ; int __ret_warn_on ; long tmp___0 ; size_t tmp___1 ; size_t __len___0 ; void *__ret___0 ; unsigned int tmp___2 ; void *tmp___3 ; { rename_retry: end = buffer + (unsigned long )buflen; end = end - 1; *end = 0; buflen = buflen - 1L; seq = read_seqbegin((seqlock_t const *)(& rename_lock)); rcu_read_lock(); ldv_50865: spin_lock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); if ((unsigned long )dentry->d_parent == (unsigned long )dentry) { goto ldv_50860; } else { } namelen = (int )dentry->d_name.ldv_22580.ldv_22578.len; buflen = buflen - (ssize_t )(namelen + 1); if (buflen < 0L) { goto Elong_unlock; } else { } end = end + - ((unsigned long )namelen); __len = (size_t )namelen; __ret = __builtin_memcpy((void *)end, (void const *)dentry->d_name.name, __len); end = end - 1; *end = 47; spin_unlock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); dentry = dentry->d_parent; goto ldv_50865; ldv_50860: tmp = read_seqretry((seqlock_t const *)(& rename_lock), seq); if (tmp != 0U) { spin_unlock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); rcu_read_unlock(); goto rename_retry; } else { } if ((int )flags & 1 && (int )((signed char )*end) != 47) { buflen = buflen - 1L; if (buflen < 0L) { spin_unlock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); rcu_read_unlock(); goto Elong; } else { } end = end - 1; *end = 47; } else { } *p = end; base = (char const *)dentry->d_fsdata; if ((unsigned long )base == (unsigned long )((char const *)0)) { spin_unlock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); rcu_read_unlock(); __ret_warn_on = 1; tmp___0 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___0 != 0L) { warn_slowpath_null("/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/namespace.o.c.prepared", 289); } else { } ldv__builtin_expect(__ret_warn_on != 0, 0L); return (end); } else { } tmp___1 = strlen(base); namelen = (int )tmp___1; if ((int )flags & 1) { goto ldv_50870; ldv_50869: namelen = namelen - 1; ldv_50870: ; if (namelen > 0 && (int )((signed char )*(base + ((unsigned long )namelen + 0xffffffffffffffffUL))) == 47) { goto ldv_50869; } else { } } else { } buflen = buflen - (ssize_t )namelen; if (buflen < 0L) { spin_unlock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); rcu_read_unlock(); goto Elong; } else { } end = end + - ((unsigned long )namelen); __len___0 = (size_t )namelen; __ret___0 = __builtin_memcpy((void *)end, (void const *)base, __len___0); spin_unlock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); rcu_read_unlock(); return (end); Elong_unlock: spin_unlock(& dentry->d_lockref.ldv_22558.ldv_22557.lock); rcu_read_unlock(); tmp___2 = read_seqretry((seqlock_t const *)(& rename_lock), seq); if (tmp___2 != 0U) { goto rename_retry; } else { } Elong: tmp___3 = ERR_PTR(-36L); return ((char *)tmp___3); } } struct vfsmount *nfs_d_automount(struct path *path ) { struct vfsmount *mnt ; struct nfs_server *server ; struct nfs_server *tmp ; struct nfs_fh *fh ; struct nfs_fattr *fattr ; long tmp___0 ; void *tmp___1 ; void *tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; { tmp = NFS_SERVER((struct inode const *)(path->dentry)->d_inode); server = tmp; fh = (struct nfs_fh *)0; fattr = (struct nfs_fattr *)0; tmp___0 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___0 != 0L) { printk("\001d--> nfs_d_automount()\n"); } else { } tmp___1 = ERR_PTR(-116L); mnt = (struct vfsmount *)tmp___1; if ((unsigned long )path->dentry == (unsigned long )(path->dentry)->d_parent) { goto out_nofree; } else { } tmp___2 = ERR_PTR(-12L); mnt = (struct vfsmount *)tmp___2; fh = nfs_alloc_fhandle(); fattr = nfs_alloc_fattr(); if ((unsigned long )fh == (unsigned long )((struct nfs_fh *)0) || (unsigned long )fattr == (unsigned long )((struct nfs_fattr *)0)) { goto out; } else { } tmp___3 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___3 != 0L) { printk("\001d%s: enter\n", "nfs_d_automount"); } else { } mnt = (*(((server->nfs_client)->rpc_ops)->submount))(server, path->dentry, fh, fattr); tmp___4 = IS_ERR((void const *)mnt); if (tmp___4 != 0L) { goto out; } else { } tmp___5 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___5 != 0L) { printk("\001d%s: done, success\n", "nfs_d_automount"); } else { } mntget(mnt); mnt_set_expiry(mnt, & nfs_automount_list); schedule_delayed_work(& nfs_automount_task, (unsigned long )nfs_mountpoint_expiry_timeout); out: nfs_free_fattr((struct nfs_fattr const *)fattr); nfs_free_fhandle((struct nfs_fh const *)fh); out_nofree: tmp___9 = IS_ERR((void const *)mnt); if (tmp___9 != 0L) { tmp___7 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___7 != 0L) { tmp___6 = PTR_ERR((void const *)mnt); printk("\001d<-- %s(): error %ld\n", "nfs_d_automount", tmp___6); } else { } } else { tmp___8 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___8 != 0L) { printk("\001d<-- %s() = %p\n", "nfs_d_automount", mnt); } else { } } return (mnt); } } static int nfs_namespace_getattr(struct vfsmount *mnt , struct dentry *dentry , struct kstat *stat ) { int tmp ; struct nfs_fh *tmp___0 ; { tmp___0 = NFS_FH((struct inode const *)dentry->d_inode); if ((unsigned int )tmp___0->size != 0U) { tmp = nfs_getattr(mnt, dentry, stat); return (tmp); } else { } generic_fillattr(dentry->d_inode, stat); return (0); } } static int nfs_namespace_setattr(struct dentry *dentry , struct iattr *attr ) { int tmp ; struct nfs_fh *tmp___0 ; { tmp___0 = NFS_FH((struct inode const *)dentry->d_inode); if ((unsigned int )tmp___0->size != 0U) { tmp = nfs_setattr(dentry, attr); return (tmp); } else { } return (-13); } } struct inode_operations const nfs_mountpoint_inode_operations = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, & nfs_setattr, & nfs_getattr, 0, 0, 0, 0, 0, 0, 0, 0}; struct inode_operations const nfs_referral_inode_operations = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, & nfs_namespace_setattr, & nfs_namespace_getattr, 0, 0, 0, 0, 0, 0, 0, 0}; static void nfs_expire_automounts(struct work_struct *work ) { struct list_head *list ; int tmp ; { list = & nfs_automount_list; mark_mounts_for_expiry(list); tmp = list_empty((struct list_head const *)list); if (tmp == 0) { schedule_delayed_work(& nfs_automount_task, (unsigned long )nfs_mountpoint_expiry_timeout); } else { } return; } } void nfs_release_automount_timer(void) { int tmp ; { tmp = list_empty((struct list_head const *)(& nfs_automount_list)); if (tmp != 0) { cancel_delayed_work(& nfs_automount_task); } else { } return; } } static struct vfsmount *nfs_do_clone_mount(struct nfs_server *server , char const *devname , struct nfs_clone_mount *mountdata ) { struct vfsmount *tmp ; { tmp = vfs_kern_mount(& nfs_xdev_fs_type, 0, devname, (void *)mountdata); return (tmp); } } struct vfsmount *nfs_do_submount(struct dentry *dentry , struct nfs_fh *fh , struct nfs_fattr *fattr , rpc_authflavor_t authflavor ) { struct nfs_clone_mount mountdata ; struct vfsmount *mnt ; void *tmp ; char *page ; unsigned long tmp___0 ; char *devname ; long tmp___1 ; long tmp___2 ; long tmp___3 ; struct nfs_server *tmp___4 ; long tmp___5 ; long tmp___6 ; { mountdata.sb = (struct super_block const *)dentry->d_sb; mountdata.dentry = (struct dentry const *)dentry; mountdata.fh = fh; mountdata.fattr = fattr; mountdata.hostname = 0; mountdata.mnt_path = 0; mountdata.addr = 0; mountdata.addrlen = 0UL; mountdata.authflavor = authflavor; tmp = ERR_PTR(-12L); mnt = (struct vfsmount *)tmp; tmp___0 = __get_free_pages(131280U, 0U); page = (char *)tmp___0; tmp___1 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___1 != 0L) { printk("\001d--> nfs_do_submount()\n"); } else { } tmp___2 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___2 != 0L) { printk("\001d%s: submounting on %s/%s\n", "nfs_do_submount", (dentry->d_parent)->d_name.name, dentry->d_name.name); } else { } if ((unsigned long )page == (unsigned long )((char *)0)) { goto out; } else { } devname = nfs_devname(dentry, page, 4096L); mnt = (struct vfsmount *)devname; tmp___3 = IS_ERR((void const *)devname); if (tmp___3 != 0L) { goto free_page; } else { } tmp___4 = NFS_SB((struct super_block const *)dentry->d_sb); mnt = nfs_do_clone_mount(tmp___4, (char const *)devname, & mountdata); free_page: free_pages((unsigned long )page, 0U); out: tmp___5 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___5 != 0L) { printk("\001d%s: done\n", "nfs_do_submount"); } else { } tmp___6 = ldv__builtin_expect((long )((int )nfs_debug) & 1L, 0L); if (tmp___6 != 0L) { printk("\001d<-- nfs_do_submount() = %p\n", mnt); } else { } return (mnt); } } struct vfsmount *nfs_submount(struct nfs_server *server , struct dentry *dentry , struct nfs_fh *fh , struct nfs_fattr *fattr ) { int err ; struct dentry *parent ; struct dentry *tmp ; void *tmp___0 ; struct vfsmount *tmp___1 ; { tmp = dget_parent(dentry); parent = tmp; err = (*(((server->nfs_client)->rpc_ops)->lookup))(parent->d_inode, & dentry->d_name, fh, fattr, (struct nfs4_label *)0); dput(parent); if (err != 0) { tmp___0 = ERR_PTR((long )err); return ((struct vfsmount *)tmp___0); } else { } tmp___1 = nfs_do_submount(dentry, fh, fattr, ((server->client)->cl_auth)->au_flavor); return (tmp___1); } } void ldv_initialize_inode_operations_35(void) { void *tmp ; { tmp = ldv_zalloc(264UL); nfs_mountpoint_inode_operations_group0 = (struct dentry *)tmp; return; } } void ldv_initialize_inode_operations_34(void) { void *tmp ; { tmp = ldv_zalloc(264UL); nfs_referral_inode_operations_group0 = (struct dentry *)tmp; return; } } void ldv_main_exported_35(void) { struct iattr *ldvarg90 ; void *tmp ; struct kstat *ldvarg89 ; void *tmp___0 ; struct vfsmount *ldvarg88 ; void *tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(80UL); ldvarg90 = (struct iattr *)tmp; tmp___0 = ldv_zalloc(104UL); ldvarg89 = (struct kstat *)tmp___0; tmp___1 = __VERIFIER_nondet_pointer(); ldvarg88 = (struct vfsmount *)tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_35 == 1) { nfs_setattr(nfs_mountpoint_inode_operations_group0, ldvarg90); ldv_state_variable_35 = 1; } else { } goto ldv_50970; case 1: ; if (ldv_state_variable_35 == 1) { nfs_getattr(ldvarg88, nfs_mountpoint_inode_operations_group0, ldvarg89); ldv_state_variable_35 = 1; } else { } goto ldv_50970; default: ldv_stop(); } ldv_50970: ; return; } } void ldv_main_exported_34(void) { struct kstat *ldvarg304 ; void *tmp ; struct iattr *ldvarg305 ; void *tmp___0 ; struct vfsmount *ldvarg303 ; void *tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(104UL); ldvarg304 = (struct kstat *)tmp; tmp___0 = ldv_zalloc(80UL); ldvarg305 = (struct iattr *)tmp___0; tmp___1 = __VERIFIER_nondet_pointer(); ldvarg303 = (struct vfsmount *)tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_34 == 1) { nfs_namespace_setattr(nfs_referral_inode_operations_group0, ldvarg305); ldv_state_variable_34 = 1; } else { } goto ldv_50980; case 1: ; if (ldv_state_variable_34 == 1) { nfs_namespace_getattr(ldvarg303, nfs_referral_inode_operations_group0, ldvarg304); ldv_state_variable_34 = 1; } else { } goto ldv_50980; default: ldv_stop(); } ldv_50980: ; return; } } void ldv_main_exported_36(void) { struct work_struct *ldvarg289 ; void *tmp ; unsigned long ldvarg288 ; unsigned long tmp___0 ; int tmp___1 ; { tmp = ldv_zalloc(80UL); ldvarg289 = (struct work_struct *)tmp; tmp___0 = __VERIFIER_nondet_ulong(); ldvarg288 = tmp___0; tmp___1 = __VERIFIER_nondet_int(); switch (tmp___1) { case 0: ; if (ldv_state_variable_36 == 1) { nfs_expire_automounts(ldvarg289); ldv_state_variable_36 = 1; } else { } goto ldv_50989; case 1: ; if (ldv_state_variable_36 == 1) { delayed_work_timer_fn(ldvarg288); ldv_state_variable_36 = 1; } else { } goto ldv_50989; default: ldv_stop(); } ldv_50989: ; return; } } extern __be32 *xdr_encode_opaque(__be32 * , void const * , unsigned int ) ; extern __be32 *xdr_reserve_space(struct xdr_stream * , size_t ) ; extern __be32 *xdr_inline_decode(struct xdr_stream * , size_t ) ; extern int rpc_call_sync(struct rpc_clnt * , struct rpc_message const * , int ) ; void nfs_umount(struct nfs_mount_request const *info ) ; static struct rpc_program const mnt_program ; static struct __anonstruct_mnt_errtbl_274 mnt_errtbl[5U] = { {0U, 0}, {1U, -1}, {2U, -2}, {13U, -13}, {22U, -22}}; static struct __anonstruct_mnt3_errtbl_275 mnt3_errtbl[10U] = { {0U, 0}, {1U, -1}, {2U, -2}, {5U, -5}, {13U, -13}, {20U, -20}, {22U, -22}, {63U, -36}, {10004U, -524}, {10006U, -121}}; int nfs_mount(struct nfs_mount_request *info ) { struct mountres result ; struct rpc_message msg ; struct rpc_create_args args ; struct rpc_clnt *mnt_clnt ; int status ; long tmp ; size_t tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; { result.errno = 0; result.fh = info->fh; result.auth_count = info->auth_flav_len; result.auth_flavors = info->auth_flavs; msg.rpc_proc = 0; msg.rpc_argp = (void *)info->dirpath; msg.rpc_resp = (void *)(& result); msg.rpc_cred = 0; args.net = info->net; args.protocol = (int )info->protocol; args.address = info->sap; args.addrsize = info->salen; args.saddress = 0; args.timeout = 0; args.servername = (char const *)info->hostname; args.program = & mnt_program; args.prognumber = 0U; args.version = info->version; args.authflavor = 1U; args.flags = 0UL; args.client_name = 0; args.bc_xprt = 0; tmp = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: sending MNT request for %s:%s\n", (unsigned long )info->hostname != (unsigned long )((char *)0) ? info->hostname : (char *)"server", info->dirpath); } else { } tmp___0 = strlen((char const *)info->dirpath); if (tmp___0 > 1024UL) { return (-36); } else { } if (info->noresvport != 0) { args.flags = args.flags | 8UL; } else { } mnt_clnt = rpc_create(& args); tmp___1 = IS_ERR((void const *)mnt_clnt); if (tmp___1 != 0L) { goto out_clnt_err; } else { } if (info->version == 3U) { msg.rpc_proc = mnt_clnt->cl_procinfo + 1UL; } else { msg.rpc_proc = mnt_clnt->cl_procinfo + 1UL; } status = rpc_call_sync(mnt_clnt, (struct rpc_message const *)(& msg), 4608); rpc_shutdown_client(mnt_clnt); if (status < 0) { goto out_call_err; } else { } if (result.errno != 0) { goto out_mnt_err; } else { } tmp___2 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___2 != 0L) { printk("\001dNFS: MNT request succeeded\n"); } else { } status = 0; if (info->version != 3U || *(info->auth_flav_len) == 0U) { tmp___3 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___3 != 0L) { printk("\001dNFS: Faking up auth_flavs list\n"); } else { } *(info->auth_flavs) = 0U; *(info->auth_flav_len) = 1U; } else { } out: ; return (status); out_clnt_err: tmp___4 = PTR_ERR((void const *)mnt_clnt); status = (int )tmp___4; tmp___5 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___5 != 0L) { printk("\001dNFS: failed to create MNT RPC client, status=%d\n", status); } else { } goto out; out_call_err: tmp___6 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___6 != 0L) { printk("\001dNFS: MNT request failed, status=%d\n", status); } else { } goto out; out_mnt_err: tmp___7 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___7 != 0L) { printk("\001dNFS: MNT server returned result %d\n", result.errno); } else { } status = result.errno; goto out; } } void nfs_umount(struct nfs_mount_request const *info ) { struct rpc_timeout nfs_umnt_timeout ; struct rpc_create_args args ; struct rpc_message msg ; struct rpc_clnt *clnt ; int status ; size_t tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; { nfs_umnt_timeout.to_initval = 250UL; nfs_umnt_timeout.to_maxval = 750UL; nfs_umnt_timeout.to_increment = 0UL; nfs_umnt_timeout.to_retries = 2U; nfs_umnt_timeout.to_exponential = (unsigned char)0; args.net = info->net; args.protocol = 17; args.address = info->sap; args.addrsize = info->salen; args.saddress = 0; args.timeout = & nfs_umnt_timeout; args.servername = (char const *)info->hostname; args.program = & mnt_program; args.prognumber = 0U; args.version = info->version; args.authflavor = 1U; args.flags = 16UL; args.client_name = 0; args.bc_xprt = 0; msg.rpc_proc = 0; msg.rpc_argp = (void *)info->dirpath; msg.rpc_resp = 0; msg.rpc_cred = 0; tmp = strlen((char const *)info->dirpath); if (tmp > 1024UL) { return; } else { } if ((int )info->noresvport != 0) { args.flags = args.flags | 8UL; } else { } clnt = rpc_create(& args); tmp___0 = IS_ERR((void const *)clnt); if (tmp___0 != 0L) { goto out_clnt_err; } else { } tmp___1 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001dNFS: sending UMNT request for %s:%s\n", (unsigned long )info->hostname != (unsigned long )((char */* const */)0) ? info->hostname : (char */* const */)"server", info->dirpath); } else { } if ((unsigned int )info->version == 3U) { msg.rpc_proc = clnt->cl_procinfo + 3UL; } else { msg.rpc_proc = clnt->cl_procinfo + 3UL; } status = rpc_call_sync(clnt, (struct rpc_message const *)(& msg), 0); rpc_shutdown_client(clnt); tmp___2 = ldv__builtin_expect(status < 0, 0L); if (tmp___2 != 0L) { goto out_call_err; } else { } return; out_clnt_err: tmp___4 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___4 != 0L) { tmp___3 = PTR_ERR((void const *)clnt); printk("\001dNFS: failed to create UMNT RPC client, status=%ld\n", tmp___3); } else { } return; out_call_err: tmp___5 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___5 != 0L) { printk("\001dNFS: UMNT request failed, status=%d\n", status); } else { } return; } } static void encode_mntdirpath(struct xdr_stream *xdr , char const *pathname ) { u32 pathname_len ; size_t tmp ; __be32 *p ; { tmp = strlen(pathname); pathname_len = (u32 const )tmp; p = xdr_reserve_space(xdr, (size_t )(pathname_len + 4U)); xdr_encode_opaque(p, (void const *)pathname, pathname_len); return; } } static void mnt_xdr_enc_dirpath(struct rpc_rqst *req , struct xdr_stream *xdr , char const *dirpath ) { { encode_mntdirpath(xdr, dirpath); return; } } static int decode_status(struct xdr_stream *xdr , struct mountres *res ) { unsigned int i ; u32 status ; __be32 *p ; long tmp ; long tmp___0 ; { p = xdr_inline_decode(xdr, 4UL); tmp = ldv__builtin_expect((unsigned long )p == (unsigned long )((__be32 *)0U), 0L); if (tmp != 0L) { return (-5); } else { } status = __be32_to_cpup((__be32 const *)p); i = 0U; goto ldv_50792; ldv_50791: ; if (mnt_errtbl[i].status == status) { res->errno = mnt_errtbl[i].errno; return (0); } else { } i = i + 1U; ldv_50792: ; if (i <= 4U) { goto ldv_50791; } else { } tmp___0 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001dNFS: unrecognized MNT status code: %u\n", status); } else { } res->errno = -13; return (0); } } static int decode_fhandle(struct xdr_stream *xdr , struct mountres *res ) { struct nfs_fh *fh ; __be32 *p ; long tmp ; size_t __len ; void *__ret ; { fh = res->fh; p = xdr_inline_decode(xdr, 32UL); tmp = ldv__builtin_expect((unsigned long )p == (unsigned long )((__be32 *)0U), 0L); if (tmp != 0L) { return (-5); } else { } fh->size = 32U; __len = 32UL; if (__len > 63UL) { __ret = __memcpy((void *)(& fh->data), (void const *)p, __len); } else { __ret = __builtin_memcpy((void *)(& fh->data), (void const *)p, __len); } return (0); } } static int mnt_xdr_dec_mountres(struct rpc_rqst *req , struct xdr_stream *xdr , struct mountres *res ) { int status ; long tmp ; long tmp___0 ; int tmp___1 ; { status = decode_status(xdr, res); tmp = ldv__builtin_expect(status != 0, 0L); if (tmp != 0L) { return (status); } else { tmp___0 = ldv__builtin_expect(res->errno != 0, 0L); if (tmp___0 != 0L) { return (status); } else { } } tmp___1 = decode_fhandle(xdr, res); return (tmp___1); } } static int decode_fhs_status(struct xdr_stream *xdr , struct mountres *res ) { unsigned int i ; u32 status ; __be32 *p ; long tmp ; long tmp___0 ; { p = xdr_inline_decode(xdr, 4UL); tmp = ldv__builtin_expect((unsigned long )p == (unsigned long )((__be32 *)0U), 0L); if (tmp != 0L) { return (-5); } else { } status = __be32_to_cpup((__be32 const *)p); i = 0U; goto ldv_50819; ldv_50818: ; if (mnt3_errtbl[i].status == status) { res->errno = mnt3_errtbl[i].errno; return (0); } else { } i = i + 1U; ldv_50819: ; if (i <= 9U) { goto ldv_50818; } else { } tmp___0 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001dNFS: unrecognized MNT3 status code: %u\n", status); } else { } res->errno = -13; return (0); } } static int decode_fhandle3(struct xdr_stream *xdr , struct mountres *res ) { struct nfs_fh *fh ; u32 size ; __be32 *p ; long tmp ; long tmp___0 ; size_t __len ; void *__ret ; { fh = res->fh; p = xdr_inline_decode(xdr, 4UL); tmp = ldv__builtin_expect((unsigned long )p == (unsigned long )((__be32 *)0U), 0L); if (tmp != 0L) { return (-5); } else { } size = __be32_to_cpup((__be32 const *)p); if (size > 64U || size == 0U) { return (-5); } else { } p = xdr_inline_decode(xdr, (size_t )size); tmp___0 = ldv__builtin_expect((unsigned long )p == (unsigned long )((__be32 *)0U), 0L); if (tmp___0 != 0L) { return (-5); } else { } fh->size = (unsigned short )size; __len = (size_t )size; __ret = __builtin_memcpy((void *)(& fh->data), (void const *)p, __len); return (0); } } static int decode_auth_flavors(struct xdr_stream *xdr , struct mountres *res ) { rpc_authflavor_t *flavors ; unsigned int *count ; u32 entries ; u32 i ; __be32 *p ; long tmp ; long tmp___0 ; long tmp___1 ; __be32 *tmp___2 ; long tmp___3 ; { flavors = res->auth_flavors; count = res->auth_count; if (*count == 0U) { return (0); } else { } p = xdr_inline_decode(xdr, 4UL); tmp = ldv__builtin_expect((unsigned long )p == (unsigned long )((__be32 *)0U), 0L); if (tmp != 0L) { return (-5); } else { } entries = __be32_to_cpup((__be32 const *)p); tmp___0 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001dNFS: received %u auth flavors\n", entries); } else { } if (entries > 12U) { entries = 12U; } else { } p = xdr_inline_decode(xdr, (size_t )(entries * 4U)); tmp___1 = ldv__builtin_expect((unsigned long )p == (unsigned long )((__be32 *)0U), 0L); if (tmp___1 != 0L) { return (-5); } else { } if (*count < entries) { entries = *count; } else { } i = 0U; goto ldv_50841; ldv_50840: tmp___2 = p; p = p + 1; *(flavors + (unsigned long )i) = __be32_to_cpup((__be32 const *)tmp___2); tmp___3 = ldv__builtin_expect((nfs_debug & 1024U) != 0U, 0L); if (tmp___3 != 0L) { printk("\001dNFS: auth flavor[%u]: %d\n", i, *(flavors + (unsigned long )i)); } else { } i = i + 1U; ldv_50841: ; if (i < entries) { goto ldv_50840; } else { } *count = i; return (0); } } static int mnt_xdr_dec_mountres3(struct rpc_rqst *req , struct xdr_stream *xdr , struct mountres *res ) { int status ; long tmp ; long tmp___0 ; long tmp___1 ; int tmp___2 ; { status = decode_fhs_status(xdr, res); tmp = ldv__builtin_expect(status != 0, 0L); if (tmp != 0L) { return (status); } else { tmp___0 = ldv__builtin_expect(res->errno != 0, 0L); if (tmp___0 != 0L) { return (status); } else { } } status = decode_fhandle3(xdr, res); tmp___1 = ldv__builtin_expect(status != 0, 0L); if (tmp___1 != 0L) { res->errno = -521; return (0); } else { } tmp___2 = decode_auth_flavors(xdr, res); return (tmp___2); } } static struct rpc_procinfo mnt_procedures[4U] = { {0U, 0, 0, 0U, 0U, 0U, 0U, 0U, 0}, {1U, (void (*)(void * , struct xdr_stream * , void * ))(& mnt_xdr_enc_dirpath), (int (*)(void * , struct xdr_stream * , void * ))(& mnt_xdr_dec_mountres), 257U, 9U, 0U, 0U, 1U, "MOUNT"}, {0U, 0, 0, 0U, 0U, 0U, 0U, 0U, 0}, {3U, (void (*)(void * , struct xdr_stream * , void * ))(& mnt_xdr_enc_dirpath), 0, 257U, 0U, 0U, 0U, 3U, "UMOUNT"}}; static struct rpc_procinfo mnt3_procedures[4U] = { {0U, 0, 0, 0U, 0U, 0U, 0U, 0U, 0}, {1U, (void (*)(void * , struct xdr_stream * , void * ))(& mnt_xdr_enc_dirpath), (int (*)(void * , struct xdr_stream * , void * ))(& mnt_xdr_dec_mountres3), 257U, 22U, 0U, 0U, 1U, "MOUNT"}, {0U, 0, 0, 0U, 0U, 0U, 0U, 0U, 0}, {3U, (void (*)(void * , struct xdr_stream * , void * ))(& mnt_xdr_enc_dirpath), 0, 257U, 0U, 0U, 0U, 3U, "UMOUNT"}}; static struct rpc_version const mnt_version1 = {1U, 4U, (struct rpc_procinfo *)(& mnt_procedures)}; static struct rpc_version const mnt_version3 = {3U, 4U, (struct rpc_procinfo *)(& mnt3_procedures)}; static struct rpc_version const *mnt_version[4U] = { (struct rpc_version const *)0, & mnt_version1, (struct rpc_version const *)0, & mnt_version3}; static struct rpc_stat mnt_stats ; static struct rpc_program const mnt_program = {"mount", 100005U, 4U, (struct rpc_version const **)(& mnt_version), & mnt_stats, 0}; static char const __tpstrtab_nfs_refresh_inode_enter[24U] = { 'n', 'f', 's', '_', 'r', 'e', 'f', 'r', 'e', 's', 'h', '_', 'i', 'n', 'o', 'd', 'e', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_refresh_inode_enter = {(char const *)(& __tpstrtab_nfs_refresh_inode_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_refresh_inode_exit[23U] = { 'n', 'f', 's', '_', 'r', 'e', 'f', 'r', 'e', 's', 'h', '_', 'i', 'n', 'o', 'd', 'e', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_refresh_inode_exit = {(char const *)(& __tpstrtab_nfs_refresh_inode_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_revalidate_inode_enter[27U] = { 'n', 'f', 's', '_', 'r', 'e', 'v', 'a', 'l', 'i', 'd', 'a', 't', 'e', '_', 'i', 'n', 'o', 'd', 'e', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_revalidate_inode_enter = {(char const *)(& __tpstrtab_nfs_revalidate_inode_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_revalidate_inode_exit[26U] = { 'n', 'f', 's', '_', 'r', 'e', 'v', 'a', 'l', 'i', 'd', 'a', 't', 'e', '_', 'i', 'n', 'o', 'd', 'e', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_revalidate_inode_exit = {(char const *)(& __tpstrtab_nfs_revalidate_inode_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_invalidate_mapping_enter[29U] = { 'n', 'f', 's', '_', 'i', 'n', 'v', 'a', 'l', 'i', 'd', 'a', 't', 'e', '_', 'm', 'a', 'p', 'p', 'i', 'n', 'g', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_invalidate_mapping_enter = {(char const *)(& __tpstrtab_nfs_invalidate_mapping_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_invalidate_mapping_exit[28U] = { 'n', 'f', 's', '_', 'i', 'n', 'v', 'a', 'l', 'i', 'd', 'a', 't', 'e', '_', 'm', 'a', 'p', 'p', 'i', 'n', 'g', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_invalidate_mapping_exit = {(char const *)(& __tpstrtab_nfs_invalidate_mapping_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_getattr_enter[18U] = { 'n', 'f', 's', '_', 'g', 'e', 't', 'a', 't', 't', 'r', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_getattr_enter = {(char const *)(& __tpstrtab_nfs_getattr_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_getattr_exit[17U] = { 'n', 'f', 's', '_', 'g', 'e', 't', 'a', 't', 't', 'r', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_getattr_exit = {(char const *)(& __tpstrtab_nfs_getattr_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_setattr_enter[18U] = { 'n', 'f', 's', '_', 's', 'e', 't', 'a', 't', 't', 'r', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_setattr_enter = {(char const *)(& __tpstrtab_nfs_setattr_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_setattr_exit[17U] = { 'n', 'f', 's', '_', 's', 'e', 't', 'a', 't', 't', 'r', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_setattr_exit = {(char const *)(& __tpstrtab_nfs_setattr_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_writeback_page_enter[25U] = { 'n', 'f', 's', '_', 'w', 'r', 'i', 't', 'e', 'b', 'a', 'c', 'k', '_', 'p', 'a', 'g', 'e', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_writeback_page_enter = {(char const *)(& __tpstrtab_nfs_writeback_page_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_writeback_page_exit[24U] = { 'n', 'f', 's', '_', 'w', 'r', 'i', 't', 'e', 'b', 'a', 'c', 'k', '_', 'p', 'a', 'g', 'e', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_writeback_page_exit = {(char const *)(& __tpstrtab_nfs_writeback_page_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_writeback_inode_enter[26U] = { 'n', 'f', 's', '_', 'w', 'r', 'i', 't', 'e', 'b', 'a', 'c', 'k', '_', 'i', 'n', 'o', 'd', 'e', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_writeback_inode_enter = {(char const *)(& __tpstrtab_nfs_writeback_inode_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_writeback_inode_exit[25U] = { 'n', 'f', 's', '_', 'w', 'r', 'i', 't', 'e', 'b', 'a', 'c', 'k', '_', 'i', 'n', 'o', 'd', 'e', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_writeback_inode_exit = {(char const *)(& __tpstrtab_nfs_writeback_inode_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_fsync_enter[16U] = { 'n', 'f', 's', '_', 'f', 's', 'y', 'n', 'c', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_fsync_enter = {(char const *)(& __tpstrtab_nfs_fsync_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_fsync_exit[15U] = { 'n', 'f', 's', '_', 'f', 's', 'y', 'n', 'c', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_fsync_exit = {(char const *)(& __tpstrtab_nfs_fsync_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_access_enter[17U] = { 'n', 'f', 's', '_', 'a', 'c', 'c', 'e', 's', 's', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_access_enter = {(char const *)(& __tpstrtab_nfs_access_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_access_exit[16U] = { 'n', 'f', 's', '_', 'a', 'c', 'c', 'e', 's', 's', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_access_exit = {(char const *)(& __tpstrtab_nfs_access_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_lookup_enter[17U] = { 'n', 'f', 's', '_', 'l', 'o', 'o', 'k', 'u', 'p', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_lookup_enter = {(char const *)(& __tpstrtab_nfs_lookup_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_lookup_exit[16U] = { 'n', 'f', 's', '_', 'l', 'o', 'o', 'k', 'u', 'p', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_lookup_exit = {(char const *)(& __tpstrtab_nfs_lookup_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_lookup_revalidate_enter[28U] = { 'n', 'f', 's', '_', 'l', 'o', 'o', 'k', 'u', 'p', '_', 'r', 'e', 'v', 'a', 'l', 'i', 'd', 'a', 't', 'e', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_lookup_revalidate_enter = {(char const *)(& __tpstrtab_nfs_lookup_revalidate_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_lookup_revalidate_exit[27U] = { 'n', 'f', 's', '_', 'l', 'o', 'o', 'k', 'u', 'p', '_', 'r', 'e', 'v', 'a', 'l', 'i', 'd', 'a', 't', 'e', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_lookup_revalidate_exit = {(char const *)(& __tpstrtab_nfs_lookup_revalidate_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_atomic_open_enter[22U] = { 'n', 'f', 's', '_', 'a', 't', 'o', 'm', 'i', 'c', '_', 'o', 'p', 'e', 'n', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_atomic_open_enter = {(char const *)(& __tpstrtab_nfs_atomic_open_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_atomic_open_exit[21U] = { 'n', 'f', 's', '_', 'a', 't', 'o', 'm', 'i', 'c', '_', 'o', 'p', 'e', 'n', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_atomic_open_exit = {(char const *)(& __tpstrtab_nfs_atomic_open_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_create_enter[17U] = { 'n', 'f', 's', '_', 'c', 'r', 'e', 'a', 't', 'e', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_create_enter = {(char const *)(& __tpstrtab_nfs_create_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_create_exit[16U] = { 'n', 'f', 's', '_', 'c', 'r', 'e', 'a', 't', 'e', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_create_exit = {(char const *)(& __tpstrtab_nfs_create_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_mknod_enter[16U] = { 'n', 'f', 's', '_', 'm', 'k', 'n', 'o', 'd', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_mknod_enter = {(char const *)(& __tpstrtab_nfs_mknod_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_mknod_exit[15U] = { 'n', 'f', 's', '_', 'm', 'k', 'n', 'o', 'd', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_mknod_exit = {(char const *)(& __tpstrtab_nfs_mknod_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_mkdir_enter[16U] = { 'n', 'f', 's', '_', 'm', 'k', 'd', 'i', 'r', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_mkdir_enter = {(char const *)(& __tpstrtab_nfs_mkdir_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_mkdir_exit[15U] = { 'n', 'f', 's', '_', 'm', 'k', 'd', 'i', 'r', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_mkdir_exit = {(char const *)(& __tpstrtab_nfs_mkdir_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_rmdir_enter[16U] = { 'n', 'f', 's', '_', 'r', 'm', 'd', 'i', 'r', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_rmdir_enter = {(char const *)(& __tpstrtab_nfs_rmdir_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_rmdir_exit[15U] = { 'n', 'f', 's', '_', 'r', 'm', 'd', 'i', 'r', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_rmdir_exit = {(char const *)(& __tpstrtab_nfs_rmdir_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_remove_enter[17U] = { 'n', 'f', 's', '_', 'r', 'e', 'm', 'o', 'v', 'e', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_remove_enter = {(char const *)(& __tpstrtab_nfs_remove_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_remove_exit[16U] = { 'n', 'f', 's', '_', 'r', 'e', 'm', 'o', 'v', 'e', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_remove_exit = {(char const *)(& __tpstrtab_nfs_remove_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_unlink_enter[17U] = { 'n', 'f', 's', '_', 'u', 'n', 'l', 'i', 'n', 'k', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_unlink_enter = {(char const *)(& __tpstrtab_nfs_unlink_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_unlink_exit[16U] = { 'n', 'f', 's', '_', 'u', 'n', 'l', 'i', 'n', 'k', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_unlink_exit = {(char const *)(& __tpstrtab_nfs_unlink_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_symlink_enter[18U] = { 'n', 'f', 's', '_', 's', 'y', 'm', 'l', 'i', 'n', 'k', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_symlink_enter = {(char const *)(& __tpstrtab_nfs_symlink_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_symlink_exit[17U] = { 'n', 'f', 's', '_', 's', 'y', 'm', 'l', 'i', 'n', 'k', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_symlink_exit = {(char const *)(& __tpstrtab_nfs_symlink_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_link_enter[15U] = { 'n', 'f', 's', '_', 'l', 'i', 'n', 'k', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_link_enter = {(char const *)(& __tpstrtab_nfs_link_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_link_exit[14U] = { 'n', 'f', 's', '_', 'l', 'i', 'n', 'k', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_link_exit = {(char const *)(& __tpstrtab_nfs_link_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_rename_enter[17U] = { 'n', 'f', 's', '_', 'r', 'e', 'n', 'a', 'm', 'e', '_', 'e', 'n', 't', 'e', 'r', '\000'}; struct tracepoint __tracepoint_nfs_rename_enter = {(char const *)(& __tpstrtab_nfs_rename_enter), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_rename_exit[16U] = { 'n', 'f', 's', '_', 'r', 'e', 'n', 'a', 'm', 'e', '_', 'e', 'x', 'i', 't', '\000'}; struct tracepoint __tracepoint_nfs_rename_exit = {(char const *)(& __tpstrtab_nfs_rename_exit), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_sillyrename_rename[23U] = { 'n', 'f', 's', '_', 's', 'i', 'l', 'l', 'y', 'r', 'e', 'n', 'a', 'm', 'e', '_', 'r', 'e', 'n', 'a', 'm', 'e', '\000'}; struct tracepoint __tracepoint_nfs_sillyrename_rename = {(char const *)(& __tpstrtab_nfs_sillyrename_rename), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; static char const __tpstrtab_nfs_sillyrename_unlink[23U] = { 'n', 'f', 's', '_', 's', 'i', 'l', 'l', 'y', 'r', 'e', 'n', 'a', 'm', 'e', '_', 'u', 'n', 'l', 'i', 'n', 'k', '\000'}; struct tracepoint __tracepoint_nfs_sillyrename_unlink = {(char const *)(& __tpstrtab_nfs_sillyrename_unlink), {{0}}, (void (*)(void))0, (void (*)(void))0, (struct tracepoint_func *)0}; extern int trace_seq_printf(struct trace_seq * , char const * , ...) ; extern char const *ftrace_print_flags_seq(struct trace_seq * , char const * , unsigned long , struct trace_print_flags const * ) ; extern char const *ftrace_print_symbols_seq(struct trace_seq * , unsigned long , struct trace_print_flags const * ) ; extern int ftrace_raw_output_prep(struct trace_iterator * , struct trace_event * ) ; extern int ftrace_event_reg(struct ftrace_event_call * , enum trace_reg , void * ) ; extern int trace_event_raw_init(struct ftrace_event_call * ) ; extern int trace_define_field(struct ftrace_event_call * , char const * , char const * , int , int , int , int ) ; static enum print_line_t ftrace_raw_output_nfs_inode_event(struct trace_iterator *iter , int flags , struct trace_event *trace_event ) { struct trace_seq *s ; struct trace_seq *p ; struct ftrace_raw_nfs_inode_event *field ; int ret ; { s = & iter->seq; p = & iter->tmp_seq; field = (struct ftrace_raw_nfs_inode_event *)iter->ent; ret = ftrace_raw_output_prep(iter, trace_event); if (ret != 0) { return ((enum print_line_t )ret); } else { } ret = trace_seq_printf(s, "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu \n", field->dev >> 20, field->dev & 1048575U, field->fileid, field->fhandle, field->version); if (ret == 0) { return (0); } else { } return (1); } } static enum print_line_t ftrace_raw_output_nfs_inode_event_done(struct trace_iterator *iter , int flags , struct trace_event *trace_event ) { struct trace_seq *s ; struct trace_seq *p ; struct ftrace_raw_nfs_inode_event_done *field ; int ret ; struct trace_print_flags __flags[8U] ; char const *tmp ; struct trace_print_flags __flags___0[9U] ; char const *tmp___0 ; struct trace_print_flags symbols[10U] ; char const *tmp___1 ; { s = & iter->seq; p = & iter->tmp_seq; field = (struct ftrace_raw_nfs_inode_event_done *)iter->ent; ret = ftrace_raw_output_prep(iter, trace_event); if (ret != 0) { return ((enum print_line_t )ret); } else { } __flags[0].mask = 1UL; __flags[0].name = "ADVISE_RDPLUS"; __flags[1].mask = 2UL; __flags[1].name = "STALE"; __flags[2].mask = 16UL; __flags[2].name = "FLUSHING"; __flags[3].mask = 32UL; __flags[3].name = "FSCACHE"; __flags[4].mask = 128UL; __flags[4].name = "COMMIT"; __flags[5].mask = 512UL; __flags[5].name = "NEED_LAYOUTCOMMIT"; __flags[6].mask = 1024UL; __flags[6].name = "LAYOUTCOMMIT"; __flags[7].mask = 0xffffffffffffffffUL; __flags[7].name = (char const *)0; tmp = ftrace_print_flags_seq(p, "|", field->nfsi_flags, (struct trace_print_flags const *)(& __flags)); __flags___0[0].mask = 1UL; __flags___0[0].name = "INVALID_ATTR"; __flags___0[1].mask = 2UL; __flags___0[1].name = "INVALID_DATA"; __flags___0[2].mask = 4UL; __flags___0[2].name = "INVALID_ATIME"; __flags___0[3].mask = 8UL; __flags___0[3].name = "INVALID_ACCESS"; __flags___0[4].mask = 16UL; __flags___0[4].name = "INVALID_ACL"; __flags___0[5].mask = 32UL; __flags___0[5].name = "REVAL_PAGECACHE"; __flags___0[6].mask = 64UL; __flags___0[6].name = "REVAL_FORCED"; __flags___0[7].mask = 128UL; __flags___0[7].name = "INVALID_LABEL"; __flags___0[8].mask = 0xffffffffffffffffUL; __flags___0[8].name = (char const *)0; tmp___0 = ftrace_print_flags_seq(p, "|", field->cache_validity, (struct trace_print_flags const *)(& __flags___0)); symbols[0].mask = 0UL; symbols[0].name = "UNKNOWN"; symbols[1].mask = 1UL; symbols[1].name = "FIFO"; symbols[2].mask = 2UL; symbols[2].name = "CHR"; symbols[3].mask = 4UL; symbols[3].name = "DIR"; symbols[4].mask = 6UL; symbols[4].name = "BLK"; symbols[5].mask = 8UL; symbols[5].name = "REG"; symbols[6].mask = 10UL; symbols[6].name = "LNK"; symbols[7].mask = 12UL; symbols[7].name = "SOCK"; symbols[8].mask = 14UL; symbols[8].name = "WHT"; symbols[9].mask = 0xffffffffffffffffUL; symbols[9].name = (char const *)0; tmp___1 = ftrace_print_symbols_seq(p, (unsigned long )field->type, (struct trace_print_flags const *)(& symbols)); ret = trace_seq_printf(s, "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x type=%u (%s) version=%llu size=%lld cache_validity=%lu (%s) nfs_flags=%ld (%s)\n", field->error, field->dev >> 20, field->dev & 1048575U, field->fileid, field->fhandle, (int )field->type, tmp___1, field->version, field->size, field->cache_validity, tmp___0, field->nfsi_flags, tmp); if (ret == 0) { return (0); } else { } return (1); } } static enum print_line_t ftrace_raw_output_nfs_lookup_event(struct trace_iterator *iter , int flags , struct trace_event *trace_event ) { struct trace_seq *s ; struct trace_seq *p ; struct ftrace_raw_nfs_lookup_event *field ; int ret ; struct trace_print_flags __flags[6U] ; char const *tmp ; { s = & iter->seq; p = & iter->tmp_seq; field = (struct ftrace_raw_nfs_lookup_event *)iter->ent; ret = ftrace_raw_output_prep(iter, trace_event); if (ret != 0) { return ((enum print_line_t )ret); } else { } __flags[0].mask = 4UL; __flags[0].name = "AUTOMOUNT"; __flags[1].mask = 2UL; __flags[1].name = "DIRECTORY"; __flags[2].mask = 256UL; __flags[2].name = "OPEN"; __flags[3].mask = 512UL; __flags[3].name = "CREATE"; __flags[4].mask = 1024UL; __flags[4].name = "EXCL"; __flags[5].mask = 0xffffffffffffffffUL; __flags[5].name = (char const *)0; tmp = ftrace_print_flags_seq(p, "|", (unsigned long )field->flags, (struct trace_print_flags const *)(& __flags)); ret = trace_seq_printf(s, "flags=%u (%s) name=%02x:%02x:%llu/%s\n", field->flags, tmp, field->dev >> 20, field->dev & 1048575U, field->dir, (char *)field + ((unsigned long )field->__data_loc_name & 65535UL)); if (ret == 0) { return (0); } else { } return (1); } } static enum print_line_t ftrace_raw_output_nfs_lookup_event_done(struct trace_iterator *iter , int flags , struct trace_event *trace_event ) { struct trace_seq *s ; struct trace_seq *p ; struct ftrace_raw_nfs_lookup_event_done *field ; int ret ; struct trace_print_flags __flags[6U] ; char const *tmp ; { s = & iter->seq; p = & iter->tmp_seq; field = (struct ftrace_raw_nfs_lookup_event_done *)iter->ent; ret = ftrace_raw_output_prep(iter, trace_event); if (ret != 0) { return ((enum print_line_t )ret); } else { } __flags[0].mask = 4UL; __flags[0].name = "AUTOMOUNT"; __flags[1].mask = 2UL; __flags[1].name = "DIRECTORY"; __flags[2].mask = 256UL; __flags[2].name = "OPEN"; __flags[3].mask = 512UL; __flags[3].name = "CREATE"; __flags[4].mask = 1024UL; __flags[4].name = "EXCL"; __flags[5].mask = 0xffffffffffffffffUL; __flags[5].name = (char const *)0; tmp = ftrace_print_flags_seq(p, "|", (unsigned long )field->flags, (struct trace_print_flags const *)(& __flags)); ret = trace_seq_printf(s, "error=%d flags=%u (%s) name=%02x:%02x:%llu/%s\n", field->error, field->flags, tmp, field->dev >> 20, field->dev & 1048575U, field->dir, (char *)field + ((unsigned long )field->__data_loc_name & 65535UL)); if (ret == 0) { return (0); } else { } return (1); } } static enum print_line_t ftrace_raw_output_nfs_atomic_open_enter(struct trace_iterator *iter , int flags , struct trace_event *trace_event ) { struct trace_seq *s ; struct trace_seq *p ; struct ftrace_raw_nfs_atomic_open_enter *field ; int ret ; struct trace_print_flags __flags[4U] ; char const *tmp ; struct trace_print_flags __flags___0[8U] ; char const *tmp___0 ; { s = & iter->seq; p = & iter->tmp_seq; field = (struct ftrace_raw_nfs_atomic_open_enter *)iter->ent; ret = ftrace_raw_output_prep(iter, trace_event); if (ret != 0) { return ((enum print_line_t )ret); } else { } __flags[0].mask = 1UL; __flags[0].name = "READ"; __flags[1].mask = 2UL; __flags[1].name = "WRITE"; __flags[2].mask = 32UL; __flags[2].name = "EXEC"; __flags[3].mask = 0xffffffffffffffffUL; __flags[3].name = (char const *)0; tmp = ftrace_print_flags_seq(p, "|", (unsigned long )field->fmode, (struct trace_print_flags const *)(& __flags)); __flags___0[0].mask = 64UL; __flags___0[0].name = "O_CREAT"; __flags___0[1].mask = 128UL; __flags___0[1].name = "O_EXCL"; __flags___0[2].mask = 512UL; __flags___0[2].name = "O_TRUNC"; __flags___0[3].mask = 1024UL; __flags___0[3].name = "O_APPEND"; __flags___0[4].mask = 4096UL; __flags___0[4].name = "O_DSYNC"; __flags___0[5].mask = 16384UL; __flags___0[5].name = "O_DIRECT"; __flags___0[6].mask = 65536UL; __flags___0[6].name = "O_DIRECTORY"; __flags___0[7].mask = 0xffffffffffffffffUL; __flags___0[7].name = (char const *)0; tmp___0 = ftrace_print_flags_seq(p, "|", (unsigned long )field->flags, (struct trace_print_flags const *)(& __flags___0)); ret = trace_seq_printf(s, "flags=%u (%s) fmode=%s name=%02x:%02x:%llu/%s\n", field->flags, tmp___0, tmp, field->dev >> 20, field->dev & 1048575U, field->dir, (char *)field + ((unsigned long )field->__data_loc_name & 65535UL)); if (ret == 0) { return (0); } else { } return (1); } } static enum print_line_t ftrace_raw_output_nfs_atomic_open_exit(struct trace_iterator *iter , int flags , struct trace_event *trace_event ) { struct trace_seq *s ; struct trace_seq *p ; struct ftrace_raw_nfs_atomic_open_exit *field ; int ret ; struct trace_print_flags __flags[4U] ; char const *tmp ; struct trace_print_flags __flags___0[8U] ; char const *tmp___0 ; { s = & iter->seq; p = & iter->tmp_seq; field = (struct ftrace_raw_nfs_atomic_open_exit *)iter->ent; ret = ftrace_raw_output_prep(iter, trace_event); if (ret != 0) { return ((enum print_line_t )ret); } else { } __flags[0].mask = 1UL; __flags[0].name = "READ"; __flags[1].mask = 2UL; __flags[1].name = "WRITE"; __flags[2].mask = 32UL; __flags[2].name = "EXEC"; __flags[3].mask = 0xffffffffffffffffUL; __flags[3].name = (char const *)0; tmp = ftrace_print_flags_seq(p, "|", (unsigned long )field->fmode, (struct trace_print_flags const *)(& __flags)); __flags___0[0].mask = 64UL; __flags___0[0].name = "O_CREAT"; __flags___0[1].mask = 128UL; __flags___0[1].name = "O_EXCL"; __flags___0[2].mask = 512UL; __flags___0[2].name = "O_TRUNC"; __flags___0[3].mask = 1024UL; __flags___0[3].name = "O_APPEND"; __flags___0[4].mask = 4096UL; __flags___0[4].name = "O_DSYNC"; __flags___0[5].mask = 16384UL; __flags___0[5].name = "O_DIRECT"; __flags___0[6].mask = 65536UL; __flags___0[6].name = "O_DIRECTORY"; __flags___0[7].mask = 0xffffffffffffffffUL; __flags___0[7].name = (char const *)0; tmp___0 = ftrace_print_flags_seq(p, "|", (unsigned long )field->flags, (struct trace_print_flags const *)(& __flags___0)); ret = trace_seq_printf(s, "error=%d flags=%u (%s) fmode=%s name=%02x:%02x:%llu/%s\n", field->error, field->flags, tmp___0, tmp, field->dev >> 20, field->dev & 1048575U, field->dir, (char *)field + ((unsigned long )field->__data_loc_name & 65535UL)); if (ret == 0) { return (0); } else { } return (1); } } static enum print_line_t ftrace_raw_output_nfs_create_enter(struct trace_iterator *iter , int flags , struct trace_event *trace_event ) { struct trace_seq *s ; struct trace_seq *p ; struct ftrace_raw_nfs_create_enter *field ; int ret ; struct trace_print_flags __flags[8U] ; char const *tmp ; { s = & iter->seq; p = & iter->tmp_seq; field = (struct ftrace_raw_nfs_create_enter *)iter->ent; ret = ftrace_raw_output_prep(iter, trace_event); if (ret != 0) { return ((enum print_line_t )ret); } else { } __flags[0].mask = 64UL; __flags[0].name = "O_CREAT"; __flags[1].mask = 128UL; __flags[1].name = "O_EXCL"; __flags[2].mask = 512UL; __flags[2].name = "O_TRUNC"; __flags[3].mask = 1024UL; __flags[3].name = "O_APPEND"; __flags[4].mask = 4096UL; __flags[4].name = "O_DSYNC"; __flags[5].mask = 16384UL; __flags[5].name = "O_DIRECT"; __flags[6].mask = 65536UL; __flags[6].name = "O_DIRECTORY"; __flags[7].mask = 0xffffffffffffffffUL; __flags[7].name = (char const *)0; tmp = ftrace_print_flags_seq(p, "|", (unsigned long )field->flags, (struct trace_print_flags const *)(& __flags)); ret = trace_seq_printf(s, "flags=%u (%s) name=%02x:%02x:%llu/%s\n", field->flags, tmp, field->dev >> 20, field->dev & 1048575U, field->dir, (char *)field + ((unsigned long )field->__data_loc_name & 65535UL)); if (ret == 0) { return (0); } else { } return (1); } } static enum print_line_t ftrace_raw_output_nfs_create_exit(struct trace_iterator *iter , int flags , struct trace_event *trace_event ) { struct trace_seq *s ; struct trace_seq *p ; struct ftrace_raw_nfs_create_exit *field ; int ret ; struct trace_print_flags __flags[8U] ; char const *tmp ; { s = & iter->seq; p = & iter->tmp_seq; field = (struct ftrace_raw_nfs_create_exit *)iter->ent; ret = ftrace_raw_output_prep(iter, trace_event); if (ret != 0) { return ((enum print_line_t )ret); } else { } __flags[0].mask = 64UL; __flags[0].name = "O_CREAT"; __flags[1].mask = 128UL; __flags[1].name = "O_EXCL"; __flags[2].mask = 512UL; __flags[2].name = "O_TRUNC"; __flags[3].mask = 1024UL; __flags[3].name = "O_APPEND"; __flags[4].mask = 4096UL; __flags[4].name = "O_DSYNC"; __flags[5].mask = 16384UL; __flags[5].name = "O_DIRECT"; __flags[6].mask = 65536UL; __flags[6].name = "O_DIRECTORY"; __flags[7].mask = 0xffffffffffffffffUL; __flags[7].name = (char const *)0; tmp = ftrace_print_flags_seq(p, "|", (unsigned long )field->flags, (struct trace_print_flags const *)(& __flags)); ret = trace_seq_printf(s, "error=%d flags=%u (%s) name=%02x:%02x:%llu/%s\n", field->error, field->flags, tmp, field->dev >> 20, field->dev & 1048575U, field->dir, (char *)field + ((unsigned long )field->__data_loc_name & 65535UL)); if (ret == 0) { return (0); } else { } return (1); } } static enum print_line_t ftrace_raw_output_nfs_directory_event(struct trace_iterator *iter , int flags , struct trace_event *trace_event ) { struct trace_seq *s ; struct trace_seq *p ; struct ftrace_raw_nfs_directory_event *field ; int ret ; { s = & iter->seq; p = & iter->tmp_seq; field = (struct ftrace_raw_nfs_directory_event *)iter->ent; ret = ftrace_raw_output_prep(iter, trace_event); if (ret != 0) { return ((enum print_line_t )ret); } else { } ret = trace_seq_printf(s, "name=%02x:%02x:%llu/%s\n", field->dev >> 20, field->dev & 1048575U, field->dir, (char *)field + ((unsigned long )field->__data_loc_name & 65535UL)); if (ret == 0) { return (0); } else { } return (1); } } static enum print_line_t ftrace_raw_output_nfs_directory_event_done(struct trace_iterator *iter , int flags , struct trace_event *trace_event ) { struct trace_seq *s ; struct trace_seq *p ; struct ftrace_raw_nfs_directory_event_done *field ; int ret ; { s = & iter->seq; p = & iter->tmp_seq; field = (struct ftrace_raw_nfs_directory_event_done *)iter->ent; ret = ftrace_raw_output_prep(iter, trace_event); if (ret != 0) { return ((enum print_line_t )ret); } else { } ret = trace_seq_printf(s, "error=%d name=%02x:%02x:%llu/%s\n", field->error, field->dev >> 20, field->dev & 1048575U, field->dir, (char *)field + ((unsigned long )field->__data_loc_name & 65535UL)); if (ret == 0) { return (0); } else { } return (1); } } static enum print_line_t ftrace_raw_output_nfs_link_enter(struct trace_iterator *iter , int flags , struct trace_event *trace_event ) { struct trace_seq *s ; struct trace_seq *p ; struct ftrace_raw_nfs_link_enter *field ; int ret ; { s = & iter->seq; p = & iter->tmp_seq; field = (struct ftrace_raw_nfs_link_enter *)iter->ent; ret = ftrace_raw_output_prep(iter, trace_event); if (ret != 0) { return ((enum print_line_t )ret); } else { } ret = trace_seq_printf(s, "fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s\n", field->dev >> 20, field->dev & 1048575U, field->fileid, field->dev >> 20, field->dev & 1048575U, field->dir, (char *)field + ((unsigned long )field->__data_loc_name & 65535UL)); if (ret == 0) { return (0); } else { } return (1); } } static enum print_line_t ftrace_raw_output_nfs_link_exit(struct trace_iterator *iter , int flags , struct trace_event *trace_event ) { struct trace_seq *s ; struct trace_seq *p ; struct ftrace_raw_nfs_link_exit *field ; int ret ; { s = & iter->seq; p = & iter->tmp_seq; field = (struct ftrace_raw_nfs_link_exit *)iter->ent; ret = ftrace_raw_output_prep(iter, trace_event); if (ret != 0) { return ((enum print_line_t )ret); } else { } ret = trace_seq_printf(s, "error=%d fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s\n", field->error, field->dev >> 20, field->dev & 1048575U, field->fileid, field->dev >> 20, field->dev & 1048575U, field->dir, (char *)field + ((unsigned long )field->__data_loc_name & 65535UL)); if (ret == 0) { return (0); } else { } return (1); } } static enum print_line_t ftrace_raw_output_nfs_rename_event(struct trace_iterator *iter , int flags , struct trace_event *trace_event ) { struct trace_seq *s ; struct trace_seq *p ; struct ftrace_raw_nfs_rename_event *field ; int ret ; { s = & iter->seq; p = & iter->tmp_seq; field = (struct ftrace_raw_nfs_rename_event *)iter->ent; ret = ftrace_raw_output_prep(iter, trace_event); if (ret != 0) { return ((enum print_line_t )ret); } else { } ret = trace_seq_printf(s, "old_name=%02x:%02x:%llu/%s new_name=%02x:%02x:%llu/%s\n", field->dev >> 20, field->dev & 1048575U, field->old_dir, (char *)field + ((unsigned long )field->__data_loc_old_name & 65535UL), field->dev >> 20, field->dev & 1048575U, field->new_dir, (char *)field + ((unsigned long )field->__data_loc_new_name & 65535UL)); if (ret == 0) { return (0); } else { } return (1); } } static enum print_line_t ftrace_raw_output_nfs_rename_event_done(struct trace_iterator *iter , int flags , struct trace_event *trace_event ) { struct trace_seq *s ; struct trace_seq *p ; struct ftrace_raw_nfs_rename_event_done *field ; int ret ; { s = & iter->seq; p = & iter->tmp_seq; field = (struct ftrace_raw_nfs_rename_event_done *)iter->ent; ret = ftrace_raw_output_prep(iter, trace_event); if (ret != 0) { return ((enum print_line_t )ret); } else { } ret = trace_seq_printf(s, "error=%d old_name=%02x:%02x:%llu/%s new_name=%02x:%02x:%llu/%s\n", field->error, field->dev >> 20, field->dev & 1048575U, field->old_dir, (char *)field + ((unsigned long )field->__data_loc_old_name & 65535UL), field->dev >> 20, field->dev & 1048575U, field->new_dir, (char *)field + ((unsigned long )field->__data_loc_new_name & 65535UL)); if (ret == 0) { return (0); } else { } return (1); } } static enum print_line_t ftrace_raw_output_nfs_sillyrename_unlink(struct trace_iterator *iter , int flags , struct trace_event *trace_event ) { struct trace_seq *s ; struct trace_seq *p ; struct ftrace_raw_nfs_sillyrename_unlink *field ; int ret ; { s = & iter->seq; p = & iter->tmp_seq; field = (struct ftrace_raw_nfs_sillyrename_unlink *)iter->ent; ret = ftrace_raw_output_prep(iter, trace_event); if (ret != 0) { return ((enum print_line_t )ret); } else { } ret = trace_seq_printf(s, "error=%d name=%02x:%02x:%llu/%s\n", field->error, field->dev >> 20, field->dev & 1048575U, field->dir, (char *)field + ((unsigned long )field->__data_loc_name & 65535UL)); if (ret == 0) { return (0); } else { } return (1); } } static int ftrace_define_fields_nfs_inode_event(struct ftrace_event_call *event_call ) { int ret ; { ret = trace_define_field(event_call, "dev_t", "dev", 8, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u32", "fhandle", 12, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "fileid", 16, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "version", 24, 8, 0, 0); if (ret != 0) { return (ret); } else { } return (ret); } } static int ftrace_define_fields_nfs_inode_event_done(struct ftrace_event_call *event_call ) { int ret ; { ret = trace_define_field(event_call, "int", "error", 8, 4, 1, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "dev_t", "dev", 12, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u32", "fhandle", 16, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "unsigned char", "type", 20, 1, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "fileid", 24, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "version", 32, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "loff_t", "size", 40, 8, 1, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "unsigned long", "nfsi_flags", 48, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "unsigned long", "cache_validity", 56, 8, 0, 0); if (ret != 0) { return (ret); } else { } return (ret); } } static int ftrace_define_fields_nfs_lookup_event(struct ftrace_event_call *event_call ) { int ret ; { ret = trace_define_field(event_call, "unsigned int", "flags", 8, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "dev_t", "dev", 12, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "dir", 16, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "__data_loc char[]", "name", 24, 4, 1, 0); return (ret); } } static int ftrace_define_fields_nfs_lookup_event_done(struct ftrace_event_call *event_call ) { int ret ; { ret = trace_define_field(event_call, "int", "error", 8, 4, 1, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "unsigned int", "flags", 12, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "dev_t", "dev", 16, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "dir", 24, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "__data_loc char[]", "name", 32, 4, 1, 0); return (ret); } } static int ftrace_define_fields_nfs_atomic_open_enter(struct ftrace_event_call *event_call ) { int ret ; { ret = trace_define_field(event_call, "unsigned int", "flags", 8, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "unsigned int", "fmode", 12, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "dev_t", "dev", 16, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "dir", 24, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "__data_loc char[]", "name", 32, 4, 1, 0); return (ret); } } static int ftrace_define_fields_nfs_atomic_open_exit(struct ftrace_event_call *event_call ) { int ret ; { ret = trace_define_field(event_call, "int", "error", 8, 4, 1, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "unsigned int", "flags", 12, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "unsigned int", "fmode", 16, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "dev_t", "dev", 20, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "dir", 24, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "__data_loc char[]", "name", 32, 4, 1, 0); return (ret); } } static int ftrace_define_fields_nfs_create_enter(struct ftrace_event_call *event_call ) { int ret ; { ret = trace_define_field(event_call, "unsigned int", "flags", 8, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "dev_t", "dev", 12, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "dir", 16, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "__data_loc char[]", "name", 24, 4, 1, 0); return (ret); } } static int ftrace_define_fields_nfs_create_exit(struct ftrace_event_call *event_call ) { int ret ; { ret = trace_define_field(event_call, "int", "error", 8, 4, 1, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "unsigned int", "flags", 12, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "dev_t", "dev", 16, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "dir", 24, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "__data_loc char[]", "name", 32, 4, 1, 0); return (ret); } } static int ftrace_define_fields_nfs_directory_event(struct ftrace_event_call *event_call ) { int ret ; { ret = trace_define_field(event_call, "dev_t", "dev", 8, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "dir", 16, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "__data_loc char[]", "name", 24, 4, 1, 0); return (ret); } } static int ftrace_define_fields_nfs_directory_event_done(struct ftrace_event_call *event_call ) { int ret ; { ret = trace_define_field(event_call, "int", "error", 8, 4, 1, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "dev_t", "dev", 12, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "dir", 16, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "__data_loc char[]", "name", 24, 4, 1, 0); return (ret); } } static int ftrace_define_fields_nfs_link_enter(struct ftrace_event_call *event_call ) { int ret ; { ret = trace_define_field(event_call, "dev_t", "dev", 8, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "fileid", 16, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "dir", 24, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "__data_loc char[]", "name", 32, 4, 1, 0); return (ret); } } static int ftrace_define_fields_nfs_link_exit(struct ftrace_event_call *event_call ) { int ret ; { ret = trace_define_field(event_call, "int", "error", 8, 4, 1, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "dev_t", "dev", 12, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "fileid", 16, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "dir", 24, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "__data_loc char[]", "name", 32, 4, 1, 0); return (ret); } } static int ftrace_define_fields_nfs_rename_event(struct ftrace_event_call *event_call ) { int ret ; { ret = trace_define_field(event_call, "dev_t", "dev", 8, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "old_dir", 16, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "new_dir", 24, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "__data_loc char[]", "old_name", 32, 4, 1, 0); ret = trace_define_field(event_call, "__data_loc char[]", "new_name", 36, 4, 1, 0); return (ret); } } static int ftrace_define_fields_nfs_rename_event_done(struct ftrace_event_call *event_call ) { int ret ; { ret = trace_define_field(event_call, "dev_t", "dev", 8, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "int", "error", 12, 4, 1, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "old_dir", 16, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "__data_loc char[]", "old_name", 24, 4, 1, 0); ret = trace_define_field(event_call, "u64", "new_dir", 32, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "__data_loc char[]", "new_name", 40, 4, 1, 0); return (ret); } } static int ftrace_define_fields_nfs_sillyrename_unlink(struct ftrace_event_call *event_call ) { int ret ; { ret = trace_define_field(event_call, "dev_t", "dev", 8, 4, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "int", "error", 12, 4, 1, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "u64", "dir", 16, 8, 0, 0); if (ret != 0) { return (ret); } else { } ret = trace_define_field(event_call, "__data_loc char[]", "name", 24, 4, 1, 0); return (ret); } } void ldv_initialize_ftrace_event_class_11(void) { void *tmp ; { tmp = ldv_zalloc(136UL); event_class_nfs_create_exit_group0 = (struct ftrace_event_call *)tmp; return; } } void ldv_initialize_ftrace_event_class_4(void) { void *tmp ; { tmp = ldv_zalloc(136UL); event_class_nfs_sillyrename_unlink_group0 = (struct ftrace_event_call *)tmp; return; } } void ldv_initialize_ftrace_event_class_9(void) { void *tmp ; { tmp = ldv_zalloc(136UL); event_class_nfs_directory_event_done_group0 = (struct ftrace_event_call *)tmp; return; } } void ldv_initialize_ftrace_event_class_7(void) { void *tmp ; { tmp = ldv_zalloc(136UL); event_class_nfs_link_exit_group0 = (struct ftrace_event_call *)tmp; return; } } void ldv_initialize_ftrace_event_class_13(void) { void *tmp ; { tmp = ldv_zalloc(136UL); event_class_nfs_atomic_open_exit_group0 = (struct ftrace_event_call *)tmp; return; } } void ldv_initialize_ftrace_event_class_15(void) { void *tmp ; { tmp = ldv_zalloc(136UL); event_class_nfs_lookup_event_done_group0 = (struct ftrace_event_call *)tmp; return; } } void ldv_initialize_ftrace_event_class_18(void) { void *tmp ; { tmp = ldv_zalloc(136UL); event_class_nfs_inode_event_group0 = (struct ftrace_event_call *)tmp; return; } } void ldv_initialize_ftrace_event_class_10(void) { void *tmp ; { tmp = ldv_zalloc(136UL); event_class_nfs_directory_event_group0 = (struct ftrace_event_call *)tmp; return; } } void ldv_initialize_ftrace_event_class_17(void) { void *tmp ; { tmp = ldv_zalloc(136UL); event_class_nfs_inode_event_done_group0 = (struct ftrace_event_call *)tmp; return; } } void ldv_initialize_ftrace_event_class_5(void) { void *tmp ; { tmp = ldv_zalloc(136UL); event_class_nfs_rename_event_done_group0 = (struct ftrace_event_call *)tmp; return; } } void ldv_initialize_ftrace_event_class_16(void) { void *tmp ; { tmp = ldv_zalloc(136UL); event_class_nfs_lookup_event_group0 = (struct ftrace_event_call *)tmp; return; } } void ldv_initialize_ftrace_event_class_12(void) { void *tmp ; { tmp = ldv_zalloc(136UL); event_class_nfs_create_enter_group0 = (struct ftrace_event_call *)tmp; return; } } void ldv_initialize_ftrace_event_class_8(void) { void *tmp ; { tmp = ldv_zalloc(136UL); event_class_nfs_link_enter_group0 = (struct ftrace_event_call *)tmp; return; } } void ldv_initialize_ftrace_event_class_6(void) { void *tmp ; { tmp = ldv_zalloc(136UL); event_class_nfs_rename_event_group0 = (struct ftrace_event_call *)tmp; return; } } void ldv_initialize_ftrace_event_class_14(void) { void *tmp ; { tmp = ldv_zalloc(136UL); event_class_nfs_atomic_open_enter_group0 = (struct ftrace_event_call *)tmp; return; } } void ldv_main_exported_33(void) { int ldvarg2 ; int tmp ; struct trace_iterator *ldvarg0 ; void *tmp___0 ; struct trace_event *ldvarg1 ; void *tmp___1 ; int tmp___2 ; { tmp = __VERIFIER_nondet_int(); ldvarg2 = tmp; tmp___0 = ldv_zalloc(8512UL); ldvarg0 = (struct trace_iterator *)tmp___0; tmp___1 = ldv_zalloc(48UL); ldvarg1 = (struct trace_event *)tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_33 == 1) { ftrace_raw_output_nfs_inode_event(ldvarg0, ldvarg2, ldvarg1); ldv_state_variable_33 = 1; } else { } goto ldv_56525; default: ldv_stop(); } ldv_56525: ; return; } } void ldv_main_exported_32(void) { int ldvarg5 ; int tmp ; struct trace_iterator *ldvarg3 ; void *tmp___0 ; struct trace_event *ldvarg4 ; void *tmp___1 ; int tmp___2 ; { tmp = __VERIFIER_nondet_int(); ldvarg5 = tmp; tmp___0 = ldv_zalloc(8512UL); ldvarg3 = (struct trace_iterator *)tmp___0; tmp___1 = ldv_zalloc(48UL); ldvarg4 = (struct trace_event *)tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_32 == 1) { ftrace_raw_output_nfs_inode_event_done(ldvarg3, ldvarg5, ldvarg4); ldv_state_variable_32 = 1; } else { } goto ldv_56534; default: ldv_stop(); } ldv_56534: ; return; } } void ldv_main_exported_11(void) { enum trace_reg ldvarg92 ; void *ldvarg91 ; void *tmp ; int tmp___0 ; { tmp = ldv_zalloc(1UL); ldvarg91 = tmp; memset((void *)(& ldvarg92), 0, 4UL); tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_11 == 1) { ftrace_event_reg(event_class_nfs_create_exit_group0, ldvarg92, ldvarg91); ldv_state_variable_11 = 1; } else { } goto ldv_56542; case 1: ; if (ldv_state_variable_11 == 1) { trace_event_raw_init(event_class_nfs_create_exit_group0); ldv_state_variable_11 = 1; } else { } goto ldv_56542; case 2: ; if (ldv_state_variable_11 == 1) { ftrace_define_fields_nfs_create_exit(event_class_nfs_create_exit_group0); ldv_state_variable_11 = 1; } else { } goto ldv_56542; default: ldv_stop(); } ldv_56542: ; return; } } void ldv_main_exported_21(void) { struct trace_iterator *ldvarg9 ; void *tmp ; struct trace_event *ldvarg10 ; void *tmp___0 ; int ldvarg11 ; int tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(8512UL); ldvarg9 = (struct trace_iterator *)tmp; tmp___0 = ldv_zalloc(48UL); ldvarg10 = (struct trace_event *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); ldvarg11 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_21 == 1) { ftrace_raw_output_nfs_rename_event(ldvarg9, ldvarg11, ldvarg10); ldv_state_variable_21 = 1; } else { } goto ldv_56553; default: ldv_stop(); } ldv_56553: ; return; } } void ldv_main_exported_7(void) { void *ldvarg17 ; void *tmp ; enum trace_reg ldvarg18 ; int tmp___0 ; { tmp = ldv_zalloc(1UL); ldvarg17 = tmp; memset((void *)(& ldvarg18), 0, 4UL); tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_7 == 1) { ftrace_event_reg(event_class_nfs_link_exit_group0, ldvarg18, ldvarg17); ldv_state_variable_7 = 1; } else { } goto ldv_56561; case 1: ; if (ldv_state_variable_7 == 1) { trace_event_raw_init(event_class_nfs_link_exit_group0); ldv_state_variable_7 = 1; } else { } goto ldv_56561; case 2: ; if (ldv_state_variable_7 == 1) { ftrace_define_fields_nfs_link_exit(event_class_nfs_link_exit_group0); ldv_state_variable_7 = 1; } else { } goto ldv_56561; default: ldv_stop(); } ldv_56561: ; return; } } void ldv_main_exported_26(void) { struct trace_iterator *ldvarg19 ; void *tmp ; struct trace_event *ldvarg20 ; void *tmp___0 ; int ldvarg21 ; int tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(8512UL); ldvarg19 = (struct trace_iterator *)tmp; tmp___0 = ldv_zalloc(48UL); ldvarg20 = (struct trace_event *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); ldvarg21 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_26 == 1) { ftrace_raw_output_nfs_create_exit(ldvarg19, ldvarg21, ldvarg20); ldv_state_variable_26 = 1; } else { } goto ldv_56572; default: ldv_stop(); } ldv_56572: ; return; } } void ldv_main_exported_17(void) { void *ldvarg223 ; void *tmp ; enum trace_reg ldvarg224 ; int tmp___0 ; { tmp = ldv_zalloc(1UL); ldvarg223 = tmp; memset((void *)(& ldvarg224), 0, 4UL); tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_17 == 1) { ftrace_event_reg(event_class_nfs_inode_event_done_group0, ldvarg224, ldvarg223); ldv_state_variable_17 = 1; } else { } goto ldv_56580; case 1: ; if (ldv_state_variable_17 == 1) { trace_event_raw_init(event_class_nfs_inode_event_done_group0); ldv_state_variable_17 = 1; } else { } goto ldv_56580; case 2: ; if (ldv_state_variable_17 == 1) { ftrace_define_fields_nfs_inode_event_done(event_class_nfs_inode_event_done_group0); ldv_state_variable_17 = 1; } else { } goto ldv_56580; default: ldv_stop(); } ldv_56580: ; return; } } void ldv_main_exported_22(void) { struct trace_iterator *ldvarg270 ; void *tmp ; struct trace_event *ldvarg271 ; void *tmp___0 ; int ldvarg272 ; int tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(8512UL); ldvarg270 = (struct trace_iterator *)tmp; tmp___0 = ldv_zalloc(48UL); ldvarg271 = (struct trace_event *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); ldvarg272 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_22 == 1) { ftrace_raw_output_nfs_link_exit(ldvarg270, ldvarg272, ldvarg271); ldv_state_variable_22 = 1; } else { } goto ldv_56591; default: ldv_stop(); } ldv_56591: ; return; } } void ldv_main_exported_18(void) { void *ldvarg22 ; void *tmp ; enum trace_reg ldvarg23 ; int tmp___0 ; { tmp = ldv_zalloc(1UL); ldvarg22 = tmp; memset((void *)(& ldvarg23), 0, 4UL); tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_18 == 1) { ftrace_event_reg(event_class_nfs_inode_event_group0, ldvarg23, ldvarg22); ldv_state_variable_18 = 1; } else { } goto ldv_56599; case 1: ; if (ldv_state_variable_18 == 1) { trace_event_raw_init(event_class_nfs_inode_event_group0); ldv_state_variable_18 = 1; } else { } goto ldv_56599; case 2: ; if (ldv_state_variable_18 == 1) { ftrace_define_fields_nfs_inode_event(event_class_nfs_inode_event_group0); ldv_state_variable_18 = 1; } else { } goto ldv_56599; default: ldv_stop(); } ldv_56599: ; return; } } void ldv_main_exported_30(void) { int ldvarg243 ; int tmp ; struct trace_iterator *ldvarg241 ; void *tmp___0 ; struct trace_event *ldvarg242 ; void *tmp___1 ; int tmp___2 ; { tmp = __VERIFIER_nondet_int(); ldvarg243 = tmp; tmp___0 = ldv_zalloc(8512UL); ldvarg241 = (struct trace_iterator *)tmp___0; tmp___1 = ldv_zalloc(48UL); ldvarg242 = (struct trace_event *)tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_30 == 1) { ftrace_raw_output_nfs_lookup_event_done(ldvarg241, ldvarg243, ldvarg242); ldv_state_variable_30 = 1; } else { } goto ldv_56610; default: ldv_stop(); } ldv_56610: ; return; } } void ldv_main_exported_23(void) { struct trace_event *ldvarg279 ; void *tmp ; int ldvarg280 ; int tmp___0 ; struct trace_iterator *ldvarg278 ; void *tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(48UL); ldvarg279 = (struct trace_event *)tmp; tmp___0 = __VERIFIER_nondet_int(); ldvarg280 = tmp___0; tmp___1 = ldv_zalloc(8512UL); ldvarg278 = (struct trace_iterator *)tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_23 == 1) { ftrace_raw_output_nfs_link_enter(ldvarg278, ldvarg280, ldvarg279); ldv_state_variable_23 = 1; } else { } goto ldv_56619; default: ldv_stop(); } ldv_56619: ; return; } } void ldv_main_exported_16(void) { enum trace_reg ldvarg25 ; void *ldvarg24 ; void *tmp ; int tmp___0 ; { tmp = ldv_zalloc(1UL); ldvarg24 = tmp; memset((void *)(& ldvarg25), 0, 4UL); tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_16 == 1) { ftrace_event_reg(event_class_nfs_lookup_event_group0, ldvarg25, ldvarg24); ldv_state_variable_16 = 1; } else { } goto ldv_56627; case 1: ; if (ldv_state_variable_16 == 1) { trace_event_raw_init(event_class_nfs_lookup_event_group0); ldv_state_variable_16 = 1; } else { } goto ldv_56627; case 2: ; if (ldv_state_variable_16 == 1) { ftrace_define_fields_nfs_lookup_event(event_class_nfs_lookup_event_group0); ldv_state_variable_16 = 1; } else { } goto ldv_56627; default: ldv_stop(); } ldv_56627: ; return; } } void ldv_main_exported_13(void) { void *ldvarg281 ; void *tmp ; enum trace_reg ldvarg282 ; int tmp___0 ; { tmp = ldv_zalloc(1UL); ldvarg281 = tmp; memset((void *)(& ldvarg282), 0, 4UL); tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_13 == 1) { ftrace_event_reg(event_class_nfs_atomic_open_exit_group0, ldvarg282, ldvarg281); ldv_state_variable_13 = 1; } else { } goto ldv_56637; case 1: ; if (ldv_state_variable_13 == 1) { trace_event_raw_init(event_class_nfs_atomic_open_exit_group0); ldv_state_variable_13 = 1; } else { } goto ldv_56637; case 2: ; if (ldv_state_variable_13 == 1) { ftrace_define_fields_nfs_atomic_open_exit(event_class_nfs_atomic_open_exit_group0); ldv_state_variable_13 = 1; } else { } goto ldv_56637; default: ldv_stop(); } ldv_56637: ; return; } } void ldv_main_exported_29(void) { struct trace_event *ldvarg99 ; void *tmp ; int ldvarg100 ; int tmp___0 ; struct trace_iterator *ldvarg98 ; void *tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(48UL); ldvarg99 = (struct trace_event *)tmp; tmp___0 = __VERIFIER_nondet_int(); ldvarg100 = tmp___0; tmp___1 = ldv_zalloc(8512UL); ldvarg98 = (struct trace_iterator *)tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_29 == 1) { ftrace_raw_output_nfs_atomic_open_enter(ldvarg98, ldvarg100, ldvarg99); ldv_state_variable_29 = 1; } else { } goto ldv_56648; default: ldv_stop(); } ldv_56648: ; return; } } void ldv_main_exported_27(void) { int ldvarg38 ; int tmp ; struct trace_iterator *ldvarg36 ; void *tmp___0 ; struct trace_event *ldvarg37 ; void *tmp___1 ; int tmp___2 ; { tmp = __VERIFIER_nondet_int(); ldvarg38 = tmp; tmp___0 = ldv_zalloc(8512UL); ldvarg36 = (struct trace_iterator *)tmp___0; tmp___1 = ldv_zalloc(48UL); ldvarg37 = (struct trace_event *)tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_27 == 1) { ftrace_raw_output_nfs_create_enter(ldvarg36, ldvarg38, ldvarg37); ldv_state_variable_27 = 1; } else { } goto ldv_56657; default: ldv_stop(); } ldv_56657: ; return; } } void ldv_main_exported_25(void) { struct trace_event *ldvarg245 ; void *tmp ; struct trace_iterator *ldvarg244 ; void *tmp___0 ; int ldvarg246 ; int tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(48UL); ldvarg245 = (struct trace_event *)tmp; tmp___0 = ldv_zalloc(8512UL); ldvarg244 = (struct trace_iterator *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); ldvarg246 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_25 == 1) { ftrace_raw_output_nfs_directory_event(ldvarg244, ldvarg246, ldvarg245); ldv_state_variable_25 = 1; } else { } goto ldv_56666; default: ldv_stop(); } ldv_56666: ; return; } } void ldv_main_exported_6(void) { void *ldvarg283 ; void *tmp ; enum trace_reg ldvarg284 ; int tmp___0 ; { tmp = ldv_zalloc(1UL); ldvarg283 = tmp; memset((void *)(& ldvarg284), 0, 4UL); tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_6 == 1) { ftrace_event_reg(event_class_nfs_rename_event_group0, ldvarg284, ldvarg283); ldv_state_variable_6 = 1; } else { } goto ldv_56674; case 1: ; if (ldv_state_variable_6 == 1) { trace_event_raw_init(event_class_nfs_rename_event_group0); ldv_state_variable_6 = 1; } else { } goto ldv_56674; case 2: ; if (ldv_state_variable_6 == 1) { ftrace_define_fields_nfs_rename_event(event_class_nfs_rename_event_group0); ldv_state_variable_6 = 1; } else { } goto ldv_56674; default: ldv_stop(); } ldv_56674: ; return; } } void ldv_main_exported_28(void) { struct trace_event *ldvarg248 ; void *tmp ; struct trace_iterator *ldvarg247 ; void *tmp___0 ; int ldvarg249 ; int tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(48UL); ldvarg248 = (struct trace_event *)tmp; tmp___0 = ldv_zalloc(8512UL); ldvarg247 = (struct trace_iterator *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); ldvarg249 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_28 == 1) { ftrace_raw_output_nfs_atomic_open_exit(ldvarg247, ldvarg249, ldvarg248); ldv_state_variable_28 = 1; } else { } goto ldv_56685; default: ldv_stop(); } ldv_56685: ; return; } } void ldv_main_exported_9(void) { enum trace_reg ldvarg291 ; void *ldvarg290 ; void *tmp ; int tmp___0 ; { tmp = ldv_zalloc(1UL); ldvarg290 = tmp; memset((void *)(& ldvarg291), 0, 4UL); tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_9 == 1) { ftrace_event_reg(event_class_nfs_directory_event_done_group0, ldvarg291, ldvarg290); ldv_state_variable_9 = 1; } else { } goto ldv_56693; case 1: ; if (ldv_state_variable_9 == 1) { trace_event_raw_init(event_class_nfs_directory_event_done_group0); ldv_state_variable_9 = 1; } else { } goto ldv_56693; case 2: ; if (ldv_state_variable_9 == 1) { ftrace_define_fields_nfs_directory_event_done(event_class_nfs_directory_event_done_group0); ldv_state_variable_9 = 1; } else { } goto ldv_56693; default: ldv_stop(); } ldv_56693: ; return; } } void ldv_main_exported_12(void) { void *ldvarg137 ; void *tmp ; enum trace_reg ldvarg138 ; int tmp___0 ; { tmp = ldv_zalloc(1UL); ldvarg137 = tmp; memset((void *)(& ldvarg138), 0, 4UL); tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_12 == 1) { ftrace_event_reg(event_class_nfs_create_enter_group0, ldvarg138, ldvarg137); ldv_state_variable_12 = 1; } else { } goto ldv_56703; case 1: ; if (ldv_state_variable_12 == 1) { trace_event_raw_init(event_class_nfs_create_enter_group0); ldv_state_variable_12 = 1; } else { } goto ldv_56703; case 2: ; if (ldv_state_variable_12 == 1) { ftrace_define_fields_nfs_create_enter(event_class_nfs_create_enter_group0); ldv_state_variable_12 = 1; } else { } goto ldv_56703; default: ldv_stop(); } ldv_56703: ; return; } } void ldv_main_exported_20(void) { int ldvarg82 ; int tmp ; struct trace_iterator *ldvarg80 ; void *tmp___0 ; struct trace_event *ldvarg81 ; void *tmp___1 ; int tmp___2 ; { tmp = __VERIFIER_nondet_int(); ldvarg82 = tmp; tmp___0 = ldv_zalloc(8512UL); ldvarg80 = (struct trace_iterator *)tmp___0; tmp___1 = ldv_zalloc(48UL); ldvarg81 = (struct trace_event *)tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_20 == 1) { ftrace_raw_output_nfs_rename_event_done(ldvarg80, ldvarg82, ldvarg81); ldv_state_variable_20 = 1; } else { } goto ldv_56714; default: ldv_stop(); } ldv_56714: ; return; } } void ldv_main_exported_14(void) { enum trace_reg ldvarg253 ; void *ldvarg252 ; void *tmp ; int tmp___0 ; { tmp = ldv_zalloc(1UL); ldvarg252 = tmp; memset((void *)(& ldvarg253), 0, 4UL); tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_14 == 1) { ftrace_event_reg(event_class_nfs_atomic_open_enter_group0, ldvarg253, ldvarg252); ldv_state_variable_14 = 1; } else { } goto ldv_56722; case 1: ; if (ldv_state_variable_14 == 1) { trace_event_raw_init(event_class_nfs_atomic_open_enter_group0); ldv_state_variable_14 = 1; } else { } goto ldv_56722; case 2: ; if (ldv_state_variable_14 == 1) { ftrace_define_fields_nfs_atomic_open_enter(event_class_nfs_atomic_open_enter_group0); ldv_state_variable_14 = 1; } else { } goto ldv_56722; default: ldv_stop(); } ldv_56722: ; return; } } void ldv_main_exported_15(void) { void *ldvarg139 ; void *tmp ; enum trace_reg ldvarg140 ; int tmp___0 ; { tmp = ldv_zalloc(1UL); ldvarg139 = tmp; memset((void *)(& ldvarg140), 0, 4UL); tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_15 == 1) { ftrace_event_reg(event_class_nfs_lookup_event_done_group0, ldvarg140, ldvarg139); ldv_state_variable_15 = 1; } else { } goto ldv_56732; case 1: ; if (ldv_state_variable_15 == 1) { trace_event_raw_init(event_class_nfs_lookup_event_done_group0); ldv_state_variable_15 = 1; } else { } goto ldv_56732; case 2: ; if (ldv_state_variable_15 == 1) { ftrace_define_fields_nfs_lookup_event_done(event_class_nfs_lookup_event_done_group0); ldv_state_variable_15 = 1; } else { } goto ldv_56732; default: ldv_stop(); } ldv_56732: ; return; } } void ldv_main_exported_8(void) { void *ldvarg296 ; void *tmp ; enum trace_reg ldvarg297 ; int tmp___0 ; { tmp = ldv_zalloc(1UL); ldvarg296 = tmp; memset((void *)(& ldvarg297), 0, 4UL); tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_8 == 1) { ftrace_event_reg(event_class_nfs_link_enter_group0, ldvarg297, ldvarg296); ldv_state_variable_8 = 1; } else { } goto ldv_56742; case 1: ; if (ldv_state_variable_8 == 1) { trace_event_raw_init(event_class_nfs_link_enter_group0); ldv_state_variable_8 = 1; } else { } goto ldv_56742; case 2: ; if (ldv_state_variable_8 == 1) { ftrace_define_fields_nfs_link_enter(event_class_nfs_link_enter_group0); ldv_state_variable_8 = 1; } else { } goto ldv_56742; default: ldv_stop(); } ldv_56742: ; return; } } void ldv_main_exported_4(void) { void *ldvarg301 ; void *tmp ; enum trace_reg ldvarg302 ; int tmp___0 ; { tmp = ldv_zalloc(1UL); ldvarg301 = tmp; memset((void *)(& ldvarg302), 0, 4UL); tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_4 == 1) { ftrace_event_reg(event_class_nfs_sillyrename_unlink_group0, ldvarg302, ldvarg301); ldv_state_variable_4 = 1; } else { } goto ldv_56752; case 1: ; if (ldv_state_variable_4 == 1) { trace_event_raw_init(event_class_nfs_sillyrename_unlink_group0); ldv_state_variable_4 = 1; } else { } goto ldv_56752; case 2: ; if (ldv_state_variable_4 == 1) { ftrace_define_fields_nfs_sillyrename_unlink(event_class_nfs_sillyrename_unlink_group0); ldv_state_variable_4 = 1; } else { } goto ldv_56752; default: ldv_stop(); } ldv_56752: ; return; } } void ldv_main_exported_24(void) { struct trace_iterator *ldvarg262 ; void *tmp ; struct trace_event *ldvarg263 ; void *tmp___0 ; int ldvarg264 ; int tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(8512UL); ldvarg262 = (struct trace_iterator *)tmp; tmp___0 = ldv_zalloc(48UL); ldvarg263 = (struct trace_event *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); ldvarg264 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_24 == 1) { ftrace_raw_output_nfs_directory_event_done(ldvarg262, ldvarg264, ldvarg263); ldv_state_variable_24 = 1; } else { } goto ldv_56763; default: ldv_stop(); } ldv_56763: ; return; } } void ldv_main_exported_10(void) { void *ldvarg83 ; void *tmp ; enum trace_reg ldvarg84 ; int tmp___0 ; { tmp = ldv_zalloc(1UL); ldvarg83 = tmp; memset((void *)(& ldvarg84), 0, 4UL); tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_10 == 1) { ftrace_event_reg(event_class_nfs_directory_event_group0, ldvarg84, ldvarg83); ldv_state_variable_10 = 1; } else { } goto ldv_56771; case 1: ; if (ldv_state_variable_10 == 1) { trace_event_raw_init(event_class_nfs_directory_event_group0); ldv_state_variable_10 = 1; } else { } goto ldv_56771; case 2: ; if (ldv_state_variable_10 == 1) { ftrace_define_fields_nfs_directory_event(event_class_nfs_directory_event_group0); ldv_state_variable_10 = 1; } else { } goto ldv_56771; default: ldv_stop(); } ldv_56771: ; return; } } void ldv_main_exported_19(void) { struct trace_event *ldvarg158 ; void *tmp ; struct trace_iterator *ldvarg157 ; void *tmp___0 ; int ldvarg159 ; int tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(48UL); ldvarg158 = (struct trace_event *)tmp; tmp___0 = ldv_zalloc(8512UL); ldvarg157 = (struct trace_iterator *)tmp___0; tmp___1 = __VERIFIER_nondet_int(); ldvarg159 = tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_19 == 1) { ftrace_raw_output_nfs_sillyrename_unlink(ldvarg157, ldvarg159, ldvarg158); ldv_state_variable_19 = 1; } else { } goto ldv_56782; default: ldv_stop(); } ldv_56782: ; return; } } void ldv_main_exported_31(void) { struct trace_event *ldvarg86 ; void *tmp ; int ldvarg87 ; int tmp___0 ; struct trace_iterator *ldvarg85 ; void *tmp___1 ; int tmp___2 ; { tmp = ldv_zalloc(48UL); ldvarg86 = (struct trace_event *)tmp; tmp___0 = __VERIFIER_nondet_int(); ldvarg87 = tmp___0; tmp___1 = ldv_zalloc(8512UL); ldvarg85 = (struct trace_iterator *)tmp___1; tmp___2 = __VERIFIER_nondet_int(); switch (tmp___2) { case 0: ; if (ldv_state_variable_31 == 1) { ftrace_raw_output_nfs_lookup_event(ldvarg85, ldvarg87, ldvarg86); ldv_state_variable_31 = 1; } else { } goto ldv_56791; default: ldv_stop(); } ldv_56791: ; return; } } void ldv_main_exported_5(void) { void *ldvarg311 ; void *tmp ; enum trace_reg ldvarg312 ; int tmp___0 ; { tmp = ldv_zalloc(1UL); ldvarg311 = tmp; memset((void *)(& ldvarg312), 0, 4UL); tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: ; if (ldv_state_variable_5 == 1) { ftrace_event_reg(event_class_nfs_rename_event_done_group0, ldvarg312, ldvarg311); ldv_state_variable_5 = 1; } else { } goto ldv_56799; case 1: ; if (ldv_state_variable_5 == 1) { trace_event_raw_init(event_class_nfs_rename_event_done_group0); ldv_state_variable_5 = 1; } else { } goto ldv_56799; case 2: ; if (ldv_state_variable_5 == 1) { ftrace_define_fields_nfs_rename_event_done(event_class_nfs_rename_event_done_group0); ldv_state_variable_5 = 1; } else { } goto ldv_56799; default: ldv_stop(); } ldv_56799: ; return; } } extern int proc_dointvec(struct ctl_table * , int , void * , size_t * , loff_t * ) ; extern int proc_dointvec_jiffies(struct ctl_table * , int , void * , size_t * , loff_t * ) ; extern struct ctl_table_header *register_sysctl_table(struct ctl_table * ) ; extern void unregister_sysctl_table(struct ctl_table_header * ) ; static struct ctl_table_header *nfs_callback_sysctl_table ; static ctl_table nfs_cb_sysctls[3U] = { {"nfs_mountpoint_timeout", (void *)(& nfs_mountpoint_expiry_timeout), 4, 420U, 0, & proc_dointvec_jiffies, 0, 0, 0}, {"nfs_congestion_kb", (void *)(& nfs_congestion_kb), 4, 420U, 0, & proc_dointvec, 0, 0, 0}}; static ctl_table nfs_cb_sysctl_dir[2U] = { {"nfs", 0, 0, 365U, (struct ctl_table *)(& nfs_cb_sysctls), 0, 0, 0, 0}}; static ctl_table nfs_cb_sysctl_root[2U] = { {"fs", 0, 0, 365U, (struct ctl_table *)(& nfs_cb_sysctl_dir), 0, 0, 0, 0}}; int nfs_register_sysctl(void) { { nfs_callback_sysctl_table = register_sysctl_table((struct ctl_table *)(& nfs_cb_sysctl_root)); if ((unsigned long )nfs_callback_sysctl_table == (unsigned long )((struct ctl_table_header *)0)) { return (-12); } else { } return (0); } } void nfs_unregister_sysctl(void) { { unregister_sysctl_table(nfs_callback_sysctl_table); nfs_callback_sysctl_table = (struct ctl_table_header *)0; return; } } __inline static int PageLocked(struct page const *page ) { int tmp ; { tmp = constant_test_bit(0L, (unsigned long const volatile *)(& page->flags)); return (tmp); } } __inline static gfp_t mapping_gfp_mask(struct address_space *mapping ) { { return ((gfp_t )mapping->flags & 33554431U); } } __inline static int NFS_FSCACHE(struct inode const *inode ) { struct nfs_inode *tmp ; int tmp___0 ; { tmp = NFS_I(inode); tmp___0 = constant_test_bit(5L, (unsigned long const volatile *)(& tmp->flags)); return (tmp___0); } } __inline static void nfs_add_fscache_stats(struct inode *inode , enum nfs_stat_fscachecounters stat , long addend ) { void const *__vpp_verify ; int pao_ID__ ; struct nfs_server *tmp ; struct nfs_server *tmp___0 ; struct nfs_server *tmp___1 ; struct nfs_server *tmp___2 ; struct nfs_server *tmp___3 ; struct nfs_server *tmp___4 ; struct nfs_server *tmp___5 ; struct nfs_server *tmp___6 ; struct nfs_server *tmp___7 ; struct nfs_server *tmp___8 ; struct nfs_server *tmp___9 ; struct nfs_server *tmp___10 ; int pao_ID_____0 ; struct nfs_server *tmp___11 ; struct nfs_server *tmp___12 ; struct nfs_server *tmp___13 ; struct nfs_server *tmp___14 ; struct nfs_server *tmp___15 ; struct nfs_server *tmp___16 ; struct nfs_server *tmp___17 ; struct nfs_server *tmp___18 ; struct nfs_server *tmp___19 ; struct nfs_server *tmp___20 ; struct nfs_server *tmp___21 ; struct nfs_server *tmp___22 ; int pao_ID_____1 ; struct nfs_server *tmp___23 ; struct nfs_server *tmp___24 ; struct nfs_server *tmp___25 ; struct nfs_server *tmp___26 ; struct nfs_server *tmp___27 ; struct nfs_server *tmp___28 ; struct nfs_server *tmp___29 ; struct nfs_server *tmp___30 ; struct nfs_server *tmp___31 ; struct nfs_server *tmp___32 ; struct nfs_server *tmp___33 ; struct nfs_server *tmp___34 ; int pao_ID_____2 ; struct nfs_server *tmp___35 ; struct nfs_server *tmp___36 ; struct nfs_server *tmp___37 ; struct nfs_server *tmp___38 ; struct nfs_server *tmp___39 ; struct nfs_server *tmp___40 ; struct nfs_server *tmp___41 ; struct nfs_server *tmp___42 ; struct nfs_server *tmp___43 ; struct nfs_server *tmp___44 ; struct nfs_server *tmp___45 ; struct nfs_server *tmp___46 ; { __vpp_verify = (void const *)0; switch (8UL) { case 1UL: pao_ID__ = 0; switch (8UL) { case 1UL: ; if (pao_ID__ == 1) { tmp = NFS_SERVER((struct inode const *)inode); __asm__ ("incb %%gs:%P0": "+m" ((tmp->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID__ == -1) { tmp___0 = NFS_SERVER((struct inode const *)inode); __asm__ ("decb %%gs:%P0": "+m" ((tmp___0->io_stats)->fscache[(unsigned int )stat])); } else { tmp___1 = NFS_SERVER((struct inode const *)inode); __asm__ ("addb %1, %%gs:%P0": "+m" ((tmp___1->io_stats)->fscache[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_50865; case 2UL: ; if (pao_ID__ == 1) { tmp___2 = NFS_SERVER((struct inode const *)inode); __asm__ ("incw %%gs:%P0": "+m" ((tmp___2->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID__ == -1) { tmp___3 = NFS_SERVER((struct inode const *)inode); __asm__ ("decw %%gs:%P0": "+m" ((tmp___3->io_stats)->fscache[(unsigned int )stat])); } else { tmp___4 = NFS_SERVER((struct inode const *)inode); __asm__ ("addw %1, %%gs:%P0": "+m" ((tmp___4->io_stats)->fscache[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50865; case 4UL: ; if (pao_ID__ == 1) { tmp___5 = NFS_SERVER((struct inode const *)inode); __asm__ ("incl %%gs:%P0": "+m" ((tmp___5->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID__ == -1) { tmp___6 = NFS_SERVER((struct inode const *)inode); __asm__ ("decl %%gs:%P0": "+m" ((tmp___6->io_stats)->fscache[(unsigned int )stat])); } else { tmp___7 = NFS_SERVER((struct inode const *)inode); __asm__ ("addl %1, %%gs:%P0": "+m" ((tmp___7->io_stats)->fscache[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50865; case 8UL: ; if (pao_ID__ == 1) { tmp___8 = NFS_SERVER((struct inode const *)inode); __asm__ ("incq %%gs:%P0": "+m" ((tmp___8->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID__ == -1) { tmp___9 = NFS_SERVER((struct inode const *)inode); __asm__ ("decq %%gs:%P0": "+m" ((tmp___9->io_stats)->fscache[(unsigned int )stat])); } else { tmp___10 = NFS_SERVER((struct inode const *)inode); __asm__ ("addq %1, %%gs:%P0": "+m" ((tmp___10->io_stats)->fscache[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_50865; default: __bad_percpu_size(); } ldv_50865: ; goto ldv_50870; case 2UL: pao_ID_____0 = 0; switch (8UL) { case 1UL: ; if (pao_ID_____0 == 1) { tmp___11 = NFS_SERVER((struct inode const *)inode); __asm__ ("incb %%gs:%P0": "+m" ((tmp___11->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { tmp___12 = NFS_SERVER((struct inode const *)inode); __asm__ ("decb %%gs:%P0": "+m" ((tmp___12->io_stats)->fscache[(unsigned int )stat])); } else { tmp___13 = NFS_SERVER((struct inode const *)inode); __asm__ ("addb %1, %%gs:%P0": "+m" ((tmp___13->io_stats)->fscache[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_50876; case 2UL: ; if (pao_ID_____0 == 1) { tmp___14 = NFS_SERVER((struct inode const *)inode); __asm__ ("incw %%gs:%P0": "+m" ((tmp___14->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { tmp___15 = NFS_SERVER((struct inode const *)inode); __asm__ ("decw %%gs:%P0": "+m" ((tmp___15->io_stats)->fscache[(unsigned int )stat])); } else { tmp___16 = NFS_SERVER((struct inode const *)inode); __asm__ ("addw %1, %%gs:%P0": "+m" ((tmp___16->io_stats)->fscache[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50876; case 4UL: ; if (pao_ID_____0 == 1) { tmp___17 = NFS_SERVER((struct inode const *)inode); __asm__ ("incl %%gs:%P0": "+m" ((tmp___17->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { tmp___18 = NFS_SERVER((struct inode const *)inode); __asm__ ("decl %%gs:%P0": "+m" ((tmp___18->io_stats)->fscache[(unsigned int )stat])); } else { tmp___19 = NFS_SERVER((struct inode const *)inode); __asm__ ("addl %1, %%gs:%P0": "+m" ((tmp___19->io_stats)->fscache[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50876; case 8UL: ; if (pao_ID_____0 == 1) { tmp___20 = NFS_SERVER((struct inode const *)inode); __asm__ ("incq %%gs:%P0": "+m" ((tmp___20->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID_____0 == -1) { tmp___21 = NFS_SERVER((struct inode const *)inode); __asm__ ("decq %%gs:%P0": "+m" ((tmp___21->io_stats)->fscache[(unsigned int )stat])); } else { tmp___22 = NFS_SERVER((struct inode const *)inode); __asm__ ("addq %1, %%gs:%P0": "+m" ((tmp___22->io_stats)->fscache[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_50876; default: __bad_percpu_size(); } ldv_50876: ; goto ldv_50870; case 4UL: pao_ID_____1 = 0; switch (8UL) { case 1UL: ; if (pao_ID_____1 == 1) { tmp___23 = NFS_SERVER((struct inode const *)inode); __asm__ ("incb %%gs:%P0": "+m" ((tmp___23->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { tmp___24 = NFS_SERVER((struct inode const *)inode); __asm__ ("decb %%gs:%P0": "+m" ((tmp___24->io_stats)->fscache[(unsigned int )stat])); } else { tmp___25 = NFS_SERVER((struct inode const *)inode); __asm__ ("addb %1, %%gs:%P0": "+m" ((tmp___25->io_stats)->fscache[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_50886; case 2UL: ; if (pao_ID_____1 == 1) { tmp___26 = NFS_SERVER((struct inode const *)inode); __asm__ ("incw %%gs:%P0": "+m" ((tmp___26->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { tmp___27 = NFS_SERVER((struct inode const *)inode); __asm__ ("decw %%gs:%P0": "+m" ((tmp___27->io_stats)->fscache[(unsigned int )stat])); } else { tmp___28 = NFS_SERVER((struct inode const *)inode); __asm__ ("addw %1, %%gs:%P0": "+m" ((tmp___28->io_stats)->fscache[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50886; case 4UL: ; if (pao_ID_____1 == 1) { tmp___29 = NFS_SERVER((struct inode const *)inode); __asm__ ("incl %%gs:%P0": "+m" ((tmp___29->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { tmp___30 = NFS_SERVER((struct inode const *)inode); __asm__ ("decl %%gs:%P0": "+m" ((tmp___30->io_stats)->fscache[(unsigned int )stat])); } else { tmp___31 = NFS_SERVER((struct inode const *)inode); __asm__ ("addl %1, %%gs:%P0": "+m" ((tmp___31->io_stats)->fscache[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50886; case 8UL: ; if (pao_ID_____1 == 1) { tmp___32 = NFS_SERVER((struct inode const *)inode); __asm__ ("incq %%gs:%P0": "+m" ((tmp___32->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID_____1 == -1) { tmp___33 = NFS_SERVER((struct inode const *)inode); __asm__ ("decq %%gs:%P0": "+m" ((tmp___33->io_stats)->fscache[(unsigned int )stat])); } else { tmp___34 = NFS_SERVER((struct inode const *)inode); __asm__ ("addq %1, %%gs:%P0": "+m" ((tmp___34->io_stats)->fscache[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_50886; default: __bad_percpu_size(); } ldv_50886: ; goto ldv_50870; case 8UL: pao_ID_____2 = 0; switch (8UL) { case 1UL: ; if (pao_ID_____2 == 1) { tmp___35 = NFS_SERVER((struct inode const *)inode); __asm__ ("incb %%gs:%P0": "+m" ((tmp___35->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { tmp___36 = NFS_SERVER((struct inode const *)inode); __asm__ ("decb %%gs:%P0": "+m" ((tmp___36->io_stats)->fscache[(unsigned int )stat])); } else { tmp___37 = NFS_SERVER((struct inode const *)inode); __asm__ ("addb %1, %%gs:%P0": "+m" ((tmp___37->io_stats)->fscache[(unsigned int )stat]): "qi" ((unsigned long long )addend)); } goto ldv_50896; case 2UL: ; if (pao_ID_____2 == 1) { tmp___38 = NFS_SERVER((struct inode const *)inode); __asm__ ("incw %%gs:%P0": "+m" ((tmp___38->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { tmp___39 = NFS_SERVER((struct inode const *)inode); __asm__ ("decw %%gs:%P0": "+m" ((tmp___39->io_stats)->fscache[(unsigned int )stat])); } else { tmp___40 = NFS_SERVER((struct inode const *)inode); __asm__ ("addw %1, %%gs:%P0": "+m" ((tmp___40->io_stats)->fscache[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50896; case 4UL: ; if (pao_ID_____2 == 1) { tmp___41 = NFS_SERVER((struct inode const *)inode); __asm__ ("incl %%gs:%P0": "+m" ((tmp___41->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { tmp___42 = NFS_SERVER((struct inode const *)inode); __asm__ ("decl %%gs:%P0": "+m" ((tmp___42->io_stats)->fscache[(unsigned int )stat])); } else { tmp___43 = NFS_SERVER((struct inode const *)inode); __asm__ ("addl %1, %%gs:%P0": "+m" ((tmp___43->io_stats)->fscache[(unsigned int )stat]): "ri" ((unsigned long long )addend)); } goto ldv_50896; case 8UL: ; if (pao_ID_____2 == 1) { tmp___44 = NFS_SERVER((struct inode const *)inode); __asm__ ("incq %%gs:%P0": "+m" ((tmp___44->io_stats)->fscache[(unsigned int )stat])); } else if (pao_ID_____2 == -1) { tmp___45 = NFS_SERVER((struct inode const *)inode); __asm__ ("decq %%gs:%P0": "+m" ((tmp___45->io_stats)->fscache[(unsigned int )stat])); } else { tmp___46 = NFS_SERVER((struct inode const *)inode); __asm__ ("addq %1, %%gs:%P0": "+m" ((tmp___46->io_stats)->fscache[(unsigned int )stat]): "re" ((unsigned long long )addend)); } goto ldv_50896; default: __bad_percpu_size(); } ldv_50896: ; goto ldv_50870; default: __bad_size_call_parameter(); goto ldv_50870; } ldv_50870: ; return; } } extern struct fscache_cookie *__fscache_acquire_cookie(struct fscache_cookie * , struct fscache_cookie_def const * , void * ) ; extern void __fscache_relinquish_cookie(struct fscache_cookie * , int ) ; extern int __fscache_read_or_alloc_page(struct fscache_cookie * , struct page * , void (*)(struct page * , void * , int ) , void * , gfp_t ) ; extern int __fscache_read_or_alloc_pages(struct fscache_cookie * , struct address_space * , struct list_head * , unsigned int * , void (*)(struct page * , void * , int ) , void * , gfp_t ) ; extern int __fscache_write_page(struct fscache_cookie * , struct page * , gfp_t ) ; extern void __fscache_uncache_page(struct fscache_cookie * , struct page * ) ; extern bool __fscache_maybe_release_page(struct fscache_cookie * , struct page * , gfp_t ) ; extern void __fscache_uncache_all_inode_pages(struct fscache_cookie * , struct inode * ) ; __inline static struct fscache_cookie *fscache_acquire_cookie(struct fscache_cookie *parent , struct fscache_cookie_def const *def , void *netfs_data ) { struct fscache_cookie *tmp ; { if ((unsigned long )parent != (unsigned long )((struct fscache_cookie *)0)) { tmp = __fscache_acquire_cookie(parent, def, netfs_data); return (tmp); } else { return ((struct fscache_cookie *)0); } } } __inline static void fscache_relinquish_cookie(struct fscache_cookie *cookie , int retire ) { { if ((unsigned long )cookie != (unsigned long )((struct fscache_cookie *)0)) { __fscache_relinquish_cookie(cookie, retire); } else { } return; } } __inline static int fscache_read_or_alloc_page(struct fscache_cookie *cookie , struct page *page , void (*end_io_func)(struct page * , void * , int ) , void *context , gfp_t gfp ) { int tmp ; { if ((unsigned long )cookie != (unsigned long )((struct fscache_cookie *)0)) { tmp = __fscache_read_or_alloc_page(cookie, page, end_io_func, context, gfp); return (tmp); } else { return (-105); } } } __inline static int fscache_read_or_alloc_pages(struct fscache_cookie *cookie , struct address_space *mapping , struct list_head *pages , unsigned int *nr_pages , void (*end_io_func)(struct page * , void * , int ) , void *context , gfp_t gfp ) { int tmp ; { if ((unsigned long )cookie != (unsigned long )((struct fscache_cookie *)0)) { tmp = __fscache_read_or_alloc_pages(cookie, mapping, pages, nr_pages, end_io_func, context, gfp); return (tmp); } else { return (-105); } } } __inline static int fscache_write_page(struct fscache_cookie *cookie , struct page *page , gfp_t gfp ) { int tmp ; { if ((unsigned long )cookie != (unsigned long )((struct fscache_cookie *)0)) { tmp = __fscache_write_page(cookie, page, gfp); return (tmp); } else { return (-105); } } } __inline static void fscache_uncache_page(struct fscache_cookie *cookie , struct page *page ) { { if ((unsigned long )cookie != (unsigned long )((struct fscache_cookie *)0)) { __fscache_uncache_page(cookie, page); } else { } return; } } __inline static bool fscache_maybe_release_page(struct fscache_cookie *cookie , struct page *page , gfp_t gfp ) { bool tmp ; int tmp___0 ; { if ((unsigned long )cookie != (unsigned long )((struct fscache_cookie *)0)) { tmp___0 = PagePrivate2((struct page const *)page); if (tmp___0 != 0) { tmp = __fscache_maybe_release_page(cookie, page, gfp); return (tmp); } else { } } else { } return (0); } } __inline static void fscache_uncache_all_inode_pages(struct fscache_cookie *cookie , struct inode *inode ) { { if ((unsigned long )cookie != (unsigned long )((struct fscache_cookie *)0)) { __fscache_uncache_all_inode_pages(cookie, inode); } else { } return; } } struct fscache_netfs nfs_fscache_netfs ; struct fscache_cookie_def const nfs_fscache_server_index_def ; struct fscache_cookie_def const nfs_fscache_super_index_def ; struct fscache_cookie_def const nfs_fscache_inode_object_def ; void nfs_fscache_zap_inode_cookie(struct inode *inode ) ; void nfs_fscache_reset_inode_cookie(struct inode *inode ) ; static struct rb_root nfs_fscache_keys = {(struct rb_node *)0}; static spinlock_t nfs_fscache_keys_lock = {{{{{0U}}, 3735899821U, 4294967295U, (void *)-1, {0, {0, 0}, "nfs_fscache_keys_lock", 0, 0UL}}}}; void nfs_fscache_get_client_cookie(struct nfs_client *clp ) { long tmp ; { clp->fscache = fscache_acquire_cookie(nfs_fscache_netfs.primary_index, & nfs_fscache_server_index_def, (void *)clp); tmp = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: get client cookie (0x%p/0x%p)\n", clp, clp->fscache); } else { } return; } } void nfs_fscache_release_client_cookie(struct nfs_client *clp ) { long tmp ; { tmp = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: releasing client cookie (0x%p/0x%p)\n", clp, clp->fscache); } else { } fscache_relinquish_cookie(clp->fscache, 0); clp->fscache = (struct fscache_cookie *)0; return; } } void nfs_fscache_get_super_cookie(struct super_block *sb , char const *uniq , int ulen ) { struct nfs_fscache_key *key ; struct nfs_fscache_key *xkey ; struct nfs_server *nfss ; struct nfs_server *tmp ; struct rb_node **p ; struct rb_node *parent ; int diff ; void *tmp___0 ; size_t __len ; void *__ret ; struct rb_node const *__mptr ; long tmp___1 ; { tmp = NFS_SB((struct super_block const *)sb); nfss = tmp; if ((unsigned long )uniq == (unsigned long )((char const *)0)) { uniq = ""; ulen = 1; } else { } tmp___0 = kzalloc((unsigned long )ulen + 96UL, 208U); key = (struct nfs_fscache_key *)tmp___0; if ((unsigned long )key == (unsigned long )((struct nfs_fscache_key *)0)) { return; } else { } key->nfs_client = nfss->nfs_client; key->key.super.s_flags = sb->s_flags & 31UL; key->key.nfs_server.flags = nfss->flags; key->key.nfs_server.rsize = nfss->rsize; key->key.nfs_server.wsize = nfss->wsize; key->key.nfs_server.acregmin = nfss->acregmin; key->key.nfs_server.acregmax = nfss->acregmax; key->key.nfs_server.acdirmin = nfss->acdirmin; key->key.nfs_server.acdirmax = nfss->acdirmax; key->key.nfs_server.fsid = nfss->fsid; key->key.rpc_auth.au_flavor = ((nfss->client)->cl_auth)->au_flavor; key->key.uniq_len = (u8 )ulen; __len = (size_t )ulen; __ret = __builtin_memcpy((void *)(& key->key.uniquifier), (void const *)uniq, __len); spin_lock(& nfs_fscache_keys_lock); p = & nfs_fscache_keys.rb_node; parent = (struct rb_node *)0; goto ldv_51331; ldv_51332: parent = *p; __mptr = (struct rb_node const *)parent; xkey = (struct nfs_fscache_key *)__mptr; if ((unsigned long )key->nfs_client < (unsigned long )xkey->nfs_client) { goto go_left; } else { } if ((unsigned long )key->nfs_client > (unsigned long )xkey->nfs_client) { goto go_right; } else { } diff = memcmp((void const *)(& key->key), (void const *)(& xkey->key), 64UL); if (diff < 0) { goto go_left; } else { } if (diff > 0) { goto go_right; } else { } if ((unsigned int )key->key.uniq_len == 0U) { goto non_unique; } else { } diff = memcmp((void const *)(& key->key.uniquifier), (void const *)(& xkey->key.uniquifier), (size_t )key->key.uniq_len); if (diff < 0) { goto go_left; } else { } if (diff > 0) { goto go_right; } else { } goto non_unique; go_left: p = & (*p)->rb_left; goto ldv_51331; go_right: p = & (*p)->rb_right; ldv_51331: ; if ((unsigned long )*p != (unsigned long )((struct rb_node *)0)) { goto ldv_51332; } else { } rb_link_node(& key->node, parent, p); rb_insert_color(& key->node, & nfs_fscache_keys); spin_unlock(& nfs_fscache_keys_lock); nfss->fscache_key = key; nfss->fscache = fscache_acquire_cookie((nfss->nfs_client)->fscache, & nfs_fscache_super_index_def, (void *)nfss); tmp___1 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001dNFS: get superblock cookie (0x%p/0x%p)\n", nfss, nfss->fscache); } else { } return; non_unique: spin_unlock(& nfs_fscache_keys_lock); kfree((void const *)key); nfss->fscache_key = (struct nfs_fscache_key *)0; nfss->fscache = (struct fscache_cookie *)0; printk("\fNFS: Cache request denied due to non-unique superblock keys\n"); return; } } void nfs_fscache_release_super_cookie(struct super_block *sb ) { struct nfs_server *nfss ; struct nfs_server *tmp ; long tmp___0 ; { tmp = NFS_SB((struct super_block const *)sb); nfss = tmp; tmp___0 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001dNFS: releasing superblock cookie (0x%p/0x%p)\n", nfss, nfss->fscache); } else { } fscache_relinquish_cookie(nfss->fscache, 0); nfss->fscache = (struct fscache_cookie *)0; if ((unsigned long )nfss->fscache_key != (unsigned long )((struct nfs_fscache_key *)0)) { spin_lock(& nfs_fscache_keys_lock); rb_erase(& (nfss->fscache_key)->node, & nfs_fscache_keys); spin_unlock(& nfs_fscache_keys_lock); kfree((void const *)nfss->fscache_key); nfss->fscache_key = (struct nfs_fscache_key *)0; } else { } return; } } void nfs_fscache_init_inode_cookie(struct inode *inode ) { struct nfs_inode *tmp ; struct nfs_inode *tmp___0 ; { tmp = NFS_I((struct inode const *)inode); tmp->fscache = (struct fscache_cookie *)0; if (((int )inode->i_mode & 61440) == 32768) { tmp___0 = NFS_I((struct inode const *)inode); set_bit(5L, (unsigned long volatile *)(& tmp___0->flags)); } else { } return; } } static void nfs_fscache_enable_inode_cookie(struct inode *inode ) { struct super_block *sb ; struct nfs_inode *nfsi ; struct nfs_inode *tmp ; int tmp___0 ; struct nfs_server *tmp___1 ; long tmp___2 ; struct nfs_server *tmp___3 ; { sb = inode->i_sb; tmp = NFS_I((struct inode const *)inode); nfsi = tmp; if ((unsigned long )nfsi->fscache != (unsigned long )((struct fscache_cookie *)0)) { return; } else { tmp___0 = NFS_FSCACHE((struct inode const *)inode); if (tmp___0 == 0) { return; } else { } } tmp___3 = NFS_SB((struct super_block const *)sb); if ((int )tmp___3->options & 1) { tmp___1 = NFS_SB((struct super_block const *)sb); nfsi->fscache = fscache_acquire_cookie(tmp___1->fscache, & nfs_fscache_inode_object_def, (void *)nfsi); tmp___2 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___2 != 0L) { printk("\001dNFS: get FH cookie (0x%p/0x%p/0x%p)\n", sb, nfsi, nfsi->fscache); } else { } } else { } return; } } void nfs_fscache_release_inode_cookie(struct inode *inode ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; long tmp___0 ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; tmp___0 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001dNFS: clear cookie (0x%p/0x%p)\n", nfsi, nfsi->fscache); } else { } fscache_relinquish_cookie(nfsi->fscache, 0); nfsi->fscache = (struct fscache_cookie *)0; return; } } void nfs_fscache_zap_inode_cookie(struct inode *inode ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; long tmp___0 ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; tmp___0 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___0 != 0L) { printk("\001dNFS: zapping cookie (0x%p/0x%p)\n", nfsi, nfsi->fscache); } else { } fscache_relinquish_cookie(nfsi->fscache, 1); nfsi->fscache = (struct fscache_cookie *)0; return; } } static void nfs_fscache_disable_inode_cookie(struct inode *inode ) { struct nfs_inode *tmp ; struct nfs_inode *tmp___0 ; long tmp___1 ; struct nfs_inode *tmp___2 ; struct nfs_inode *tmp___3 ; { tmp = NFS_I((struct inode const *)inode); clear_bit(5L, (unsigned long volatile *)(& tmp->flags)); tmp___3 = NFS_I((struct inode const *)inode); if ((unsigned long )tmp___3->fscache != (unsigned long )((struct fscache_cookie *)0)) { tmp___1 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___1 != 0L) { tmp___0 = NFS_I((struct inode const *)inode); printk("\001dNFS: nfsi 0x%p turning cache off\n", tmp___0); } else { } tmp___2 = NFS_I((struct inode const *)inode); fscache_uncache_all_inode_pages(tmp___2->fscache, inode); nfs_fscache_zap_inode_cookie(inode); } else { } return; } } static int nfs_fscache_wait_bit(void *flags ) { { schedule(); return (0); } } __inline static void nfs_fscache_inode_lock(struct inode *inode ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; int tmp___0 ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; goto ldv_51365; ldv_51364: wait_on_bit((void *)(& nfsi->flags), 6, & nfs_fscache_wait_bit, 2U); ldv_51365: tmp___0 = test_and_set_bit(6L, (unsigned long volatile *)(& nfsi->flags)); if (tmp___0 != 0) { goto ldv_51364; } else { } return; } } __inline static void nfs_fscache_inode_unlock(struct inode *inode ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; __asm__ volatile ("": : : "memory"); clear_bit(6L, (unsigned long volatile *)(& nfsi->flags)); __asm__ volatile ("": : : "memory"); wake_up_bit((void *)(& nfsi->flags), 6); return; } } void nfs_fscache_set_inode_cookie(struct inode *inode , struct file *filp ) { int tmp ; { tmp = NFS_FSCACHE((struct inode const *)inode); if (tmp != 0) { nfs_fscache_inode_lock(inode); if ((filp->f_flags & 3U) != 0U) { nfs_fscache_disable_inode_cookie(inode); } else { nfs_fscache_enable_inode_cookie(inode); } nfs_fscache_inode_unlock(inode); } else { } return; } } void nfs_fscache_reset_inode_cookie(struct inode *inode ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; struct nfs_server *nfss ; struct nfs_server *tmp___0 ; struct fscache_cookie *old ; long tmp___1 ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; tmp___0 = NFS_SERVER((struct inode const *)inode); nfss = tmp___0; old = nfsi->fscache; nfs_fscache_inode_lock(inode); if ((unsigned long )nfsi->fscache != (unsigned long )((struct fscache_cookie *)0)) { fscache_relinquish_cookie(nfsi->fscache, 1); nfsi->fscache = fscache_acquire_cookie((nfss->nfs_client)->fscache, & nfs_fscache_inode_object_def, (void *)nfsi); tmp___1 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001dNFS: revalidation new cookie (0x%p/0x%p/0x%p/0x%p)\n", nfss, nfsi, old, nfsi->fscache); } else { } } else { } nfs_fscache_inode_unlock(inode); return; } } int nfs_fscache_release_page(struct page *page , gfp_t gfp ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; struct fscache_cookie *cookie ; long tmp___0 ; long tmp___1 ; bool tmp___2 ; int tmp___3 ; int tmp___4 ; { tmp___4 = PagePrivate2((struct page const *)page); if (tmp___4 != 0) { tmp = NFS_I((struct inode const *)(page->mapping)->host); nfsi = tmp; cookie = nfsi->fscache; tmp___0 = ldv__builtin_expect((unsigned long )cookie == (unsigned long )((struct fscache_cookie *)0), 0L); if (tmp___0 != 0L) { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/fscache.o.c.prepared"), "i" (542), "i" (12UL)); ldv_51394: ; goto ldv_51394; } else { } tmp___1 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001dNFS: fscache releasepage (0x%p/0x%p/0x%p)\n", cookie, page, nfsi); } else { } tmp___2 = fscache_maybe_release_page(cookie, page, gfp); if (tmp___2) { tmp___3 = 0; } else { tmp___3 = 1; } if (tmp___3) { return (0); } else { } nfs_add_fscache_stats((page->mapping)->host, 4, 1L); } else { } return (1); } } void __nfs_fscache_invalidate_page(struct page *page , struct inode *inode ) { struct nfs_inode *nfsi ; struct nfs_inode *tmp ; struct fscache_cookie *cookie ; long tmp___0 ; long tmp___1 ; int tmp___2 ; long tmp___3 ; { tmp = NFS_I((struct inode const *)inode); nfsi = tmp; cookie = nfsi->fscache; tmp___0 = ldv__builtin_expect((unsigned long )cookie == (unsigned long )((struct fscache_cookie *)0), 0L); if (tmp___0 != 0L) { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/fscache.o.c.prepared"), "i" (565), "i" (12UL)); ldv_51401: ; goto ldv_51401; } else { } tmp___1 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___1 != 0L) { printk("\001dNFS: fscache invalidatepage (0x%p/0x%p/0x%p)\n", cookie, page, nfsi); } else { } fscache_wait_on_page_write(cookie, page); tmp___2 = PageLocked((struct page const *)page); tmp___3 = ldv__builtin_expect(tmp___2 == 0, 0L); if (tmp___3 != 0L) { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/fscache.o.c.prepared"), "i" (572), "i" (12UL)); ldv_51402: ; goto ldv_51402; } else { } fscache_uncache_page(cookie, page); nfs_add_fscache_stats((page->mapping)->host, 4, 1L); return; } } static void nfs_readpage_from_fscache_complete(struct page *page , void *context , int error ) { long tmp ; { tmp = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: readpage_from_fscache_complete (0x%p/0x%p/%d)\n", page, context, error); } else { } if (error == 0) { SetPageUptodate(page); unlock_page(page); } else { error = nfs_readpage_async((struct nfs_open_context *)context, (page->mapping)->host, page); if (error != 0) { unlock_page(page); } else { } } return; } } int __nfs_readpage_from_fscache(struct nfs_open_context *ctx , struct inode *inode , struct page *page ) { int ret ; struct nfs_inode *tmp ; long tmp___0 ; struct nfs_inode *tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; { tmp___0 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___0 != 0L) { tmp = NFS_I((struct inode const *)inode); printk("\001dNFS: readpage_from_fscache(fsc:%p/p:%p(i:%lx f:%lx)/0x%p)\n", tmp->fscache, page, page->ldv_15471.ldv_15455.index, page->flags, inode); } else { } tmp___1 = NFS_I((struct inode const *)inode); ret = fscache_read_or_alloc_page(tmp___1->fscache, page, & nfs_readpage_from_fscache_complete, (void *)ctx, 208U); switch (ret) { case 0: tmp___2 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___2 != 0L) { printk("\001dNFS: readpage_from_fscache: BIO submitted\n"); } else { } nfs_add_fscache_stats(inode, 0, 1L); return (ret); case -105: ; case -61: nfs_add_fscache_stats(inode, 1, 1L); tmp___3 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___3 != 0L) { printk("\001dNFS: readpage_from_fscache %d\n", ret); } else { } return (1); default: tmp___4 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___4 != 0L) { printk("\001dNFS: readpage_from_fscache %d\n", ret); } else { } nfs_add_fscache_stats(inode, 1, 1L); } return (ret); } } int __nfs_readpages_from_fscache(struct nfs_open_context *ctx , struct inode *inode , struct address_space *mapping , struct list_head *pages , unsigned int *nr_pages ) { unsigned int npages ; int ret ; struct nfs_inode *tmp ; long tmp___0 ; gfp_t tmp___1 ; struct nfs_inode *tmp___2 ; int tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; { npages = *nr_pages; tmp___0 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___0 != 0L) { tmp = NFS_I((struct inode const *)inode); printk("\001dNFS: nfs_getpages_from_fscache (0x%p/%u/0x%p)\n", tmp->fscache, npages, inode); } else { } tmp___1 = mapping_gfp_mask(mapping); tmp___2 = NFS_I((struct inode const *)inode); ret = fscache_read_or_alloc_pages(tmp___2->fscache, mapping, pages, nr_pages, & nfs_readpage_from_fscache_complete, (void *)ctx, tmp___1); if (*nr_pages < npages) { nfs_add_fscache_stats(inode, 0, (long )npages); } else { } if (*nr_pages != 0U) { nfs_add_fscache_stats(inode, 1, (long )*nr_pages); } else { } switch (ret) { case 0: tmp___3 = list_empty((struct list_head const *)pages); tmp___4 = ldv__builtin_expect(tmp___3 == 0, 0L); if (tmp___4 != 0L) { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/fscache.o.c.prepared"), "i" (670), "i" (12UL)); ldv_51428: ; goto ldv_51428; } else { } tmp___5 = ldv__builtin_expect(*nr_pages != 0U, 0L); if (tmp___5 != 0L) { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/fscache.o.c.prepared"), "i" (671), "i" (12UL)); ldv_51429: ; goto ldv_51429; } else { } tmp___6 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___6 != 0L) { printk("\001dNFS: nfs_getpages_from_fscache: submitted\n"); } else { } return (ret); case -105: ; case -61: tmp___7 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___7 != 0L) { printk("\001dNFS: nfs_getpages_from_fscache: no page: %d\n", ret); } else { } return (1); default: tmp___8 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___8 != 0L) { printk("\001dNFS: nfs_getpages_from_fscache: ret %d\n", ret); } else { } } return (ret); } } void __nfs_readpage_to_fscache(struct inode *inode , struct page *page , int sync ) { int ret ; struct nfs_inode *tmp ; long tmp___0 ; struct nfs_inode *tmp___1 ; long tmp___2 ; struct nfs_inode *tmp___3 ; { tmp___0 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___0 != 0L) { tmp = NFS_I((struct inode const *)inode); printk("\001dNFS: readpage_to_fscache(fsc:%p/p:%p(i:%lx f:%lx)/%d)\n", tmp->fscache, page, page->ldv_15471.ldv_15455.index, page->flags, sync); } else { } tmp___1 = NFS_I((struct inode const *)inode); ret = fscache_write_page(tmp___1->fscache, page, 208U); tmp___2 = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp___2 != 0L) { printk("\001dNFS: readpage_to_fscache: p:%p(i:%lu f:%lx) ret %d\n", page, page->ldv_15471.ldv_15455.index, page->flags, ret); } else { } if (ret != 0) { tmp___3 = NFS_I((struct inode const *)inode); fscache_uncache_page(tmp___3->fscache, page); nfs_add_fscache_stats(inode, 3, 1L); nfs_add_fscache_stats(inode, 4, 1L); } else { nfs_add_fscache_stats(inode, 2, 1L); } return; } } extern int _cond_resched(void) ; __inline static void ClearPagePrivate2(struct page *page ) { { clear_bit(12L, (unsigned long volatile *)(& page->flags)); return; } } extern void __pagevec_release(struct pagevec * ) ; extern unsigned int pagevec_lookup(struct pagevec * , struct address_space * , unsigned long , unsigned int ) ; __inline static void pagevec_init(struct pagevec *pvec , int cold ) { { pvec->nr = 0UL; pvec->cold = (unsigned long )cold; return; } } __inline static unsigned int pagevec_count(struct pagevec *pvec ) { { return ((unsigned int )pvec->nr); } } __inline static void pagevec_release(struct pagevec *pvec ) { unsigned int tmp ; { tmp = pagevec_count(pvec); if (tmp != 0U) { __pagevec_release(pvec); } else { } return; } } extern int __fscache_register_netfs(struct fscache_netfs * ) ; extern void __fscache_unregister_netfs(struct fscache_netfs * ) ; __inline static int fscache_register_netfs(struct fscache_netfs *netfs ) { int tmp ; { tmp = __fscache_register_netfs(netfs); return (tmp); } } __inline static void fscache_unregister_netfs(struct fscache_netfs *netfs ) { { __fscache_unregister_netfs(netfs); return; } } struct fscache_netfs nfs_fscache_netfs = {0U, "nfs", 0, {0, 0}}; int nfs_fscache_register(void) { int tmp ; { tmp = fscache_register_netfs(& nfs_fscache_netfs); return (tmp); } } void nfs_fscache_unregister(void) { { fscache_unregister_netfs(& nfs_fscache_netfs); return; } } static uint16_t nfs_server_get_key(void const *cookie_netfs_data , void *buffer , uint16_t bufmax ) { struct nfs_client const *clp ; struct sockaddr_in6 const *sin6 ; struct sockaddr_in const *sin ; struct nfs_server_key *key ; uint16_t len ; { clp = (struct nfs_client const *)cookie_netfs_data; sin6 = (struct sockaddr_in6 const *)(& clp->cl_addr); sin = (struct sockaddr_in const *)(& clp->cl_addr); key = (struct nfs_server_key *)buffer; len = 8U; key->nfsversion = (uint16_t )(clp->rpc_ops)->version; key->family = clp->cl_addr.ss_family; memset((void *)key, 0, (size_t )len); switch ((int )clp->cl_addr.ss_family) { case 2: key->port = sin->sin_port; key->addr[0].ipv4_addr = sin->sin_addr; len = (unsigned int )len + 4U; goto ldv_51121; case 10: key->port = sin6->sin6_port; key->addr[0].ipv6_addr = sin6->sin6_addr; len = (unsigned int )len + 16U; goto ldv_51121; default: printk("\fNFS: Unknown network family \'%d\'\n", (int )clp->cl_addr.ss_family); len = 0U; goto ldv_51121; } ldv_51121: ; return (len); } } struct fscache_cookie_def const nfs_fscache_server_index_def = {{'N', 'F', 'S', '.', 's', 'e', 'r', 'v', 'e', 'r', '\000'}, 0U, 0, & nfs_server_get_key, 0, 0, 0, 0, 0, 0, 0}; static uint16_t nfs_super_get_key(void const *cookie_netfs_data , void *buffer , uint16_t bufmax ) { struct nfs_fscache_key const *key ; struct nfs_server const *nfss ; uint16_t len ; size_t __len ; void *__ret ; size_t __len___0 ; void *__ret___0 ; { nfss = (struct nfs_server const *)cookie_netfs_data; key = (struct nfs_fscache_key const *)nfss->fscache_key; len = (unsigned int )((uint16_t )key->key.uniq_len) + 64U; if ((int )len > (int )bufmax) { len = 0U; } else { __len = 64UL; if (__len > 63UL) { __ret = __memcpy(buffer, (void const *)(& key->key), __len); } else { __ret = __builtin_memcpy(buffer, (void const *)(& key->key), __len); } __len___0 = (size_t )key->key.uniq_len; __ret___0 = __builtin_memcpy(buffer + 64UL, (void const *)(& key->key.uniquifier), __len___0); } return (len); } } struct fscache_cookie_def const nfs_fscache_super_index_def = {{'N', 'F', 'S', '.', 's', 'u', 'p', 'e', 'r', '\000'}, 0U, 0, & nfs_super_get_key, 0, 0, 0, 0, 0, 0, 0}; static uint16_t nfs_fscache_inode_get_key(void const *cookie_netfs_data , void *buffer , uint16_t bufmax ) { struct nfs_inode const *nfsi ; uint16_t nsize ; size_t __len ; void *__ret ; { nfsi = (struct nfs_inode const *)cookie_netfs_data; nsize = nfsi->fh.size; __len = (size_t )nsize; __ret = __builtin_memcpy(buffer, (void const *)(& nfsi->fh.data), __len); return (nsize); } } static void nfs_fscache_inode_get_attr(void const *cookie_netfs_data , uint64_t *size ) { struct nfs_inode const *nfsi ; { nfsi = (struct nfs_inode const *)cookie_netfs_data; *size = (uint64_t )nfsi->vfs_inode.i_size; return; } } static uint16_t nfs_fscache_inode_get_aux(void const *cookie_netfs_data , void *buffer , uint16_t bufmax ) { struct nfs_fscache_inode_auxdata auxdata ; struct nfs_inode const *nfsi ; struct nfs_server *tmp ; size_t __len ; void *__ret ; { nfsi = (struct nfs_inode const *)cookie_netfs_data; memset((void *)(& auxdata), 0, 48UL); auxdata.size = nfsi->vfs_inode.i_size; auxdata.mtime = nfsi->vfs_inode.i_mtime; auxdata.ctime = nfsi->vfs_inode.i_ctime; tmp = NFS_SERVER(& nfsi->vfs_inode); if ((unsigned int )((tmp->nfs_client)->rpc_ops)->version == 4U) { auxdata.change_attr = nfsi->vfs_inode.i_version; } else { } if ((unsigned int )bufmax > 48U) { bufmax = 48U; } else { } __len = (size_t )bufmax; __ret = __builtin_memcpy(buffer, (void const *)(& auxdata), __len); return (bufmax); } } static enum fscache_checkaux nfs_fscache_inode_check_aux(void *cookie_netfs_data , void const *data , uint16_t datalen ) { struct nfs_fscache_inode_auxdata auxdata ; struct nfs_inode *nfsi ; struct nfs_server *tmp ; int tmp___0 ; { nfsi = (struct nfs_inode *)cookie_netfs_data; if ((unsigned int )datalen != 48U) { return (2); } else { } memset((void *)(& auxdata), 0, 48UL); auxdata.size = nfsi->vfs_inode.i_size; auxdata.mtime = nfsi->vfs_inode.i_mtime; auxdata.ctime = nfsi->vfs_inode.i_ctime; tmp = NFS_SERVER((struct inode const *)(& nfsi->vfs_inode)); if ((unsigned int )((tmp->nfs_client)->rpc_ops)->version == 4U) { auxdata.change_attr = nfsi->vfs_inode.i_version; } else { } tmp___0 = memcmp(data, (void const *)(& auxdata), (size_t )datalen); if (tmp___0 != 0) { return (2); } else { } return (0); } } static void nfs_fscache_inode_now_uncached(void *cookie_netfs_data ) { struct nfs_inode *nfsi ; struct pagevec pvec ; unsigned long first ; int loop ; int nr_pages ; long tmp ; unsigned int tmp___0 ; unsigned int tmp___1 ; { nfsi = (struct nfs_inode *)cookie_netfs_data; pagevec_init(& pvec, 0); first = 0UL; tmp = ldv__builtin_expect((nfs_debug & 2048U) != 0U, 0L); if (tmp != 0L) { printk("\001dNFS: nfs_inode_now_uncached: nfs_inode 0x%p\n", nfsi); } else { } ldv_51190: tmp___0 = pagevec_count(& pvec); tmp___1 = pagevec_lookup(& pvec, nfsi->vfs_inode.i_mapping, first, 14U - tmp___0); nr_pages = (int )tmp___1; if (nr_pages == 0) { goto ldv_51185; } else { } loop = 0; goto ldv_51187; ldv_51186: ClearPagePrivate2(pvec.pages[loop]); loop = loop + 1; ldv_51187: ; if (loop < nr_pages) { goto ldv_51186; } else { } first = (pvec.pages[nr_pages + -1])->ldv_15471.ldv_15455.index + 1UL; pvec.nr = (unsigned long )nr_pages; pagevec_release(& pvec); __might_sleep("/work/ldvuser/mutilin/launch/work/current--X--fs/nfs/nfs.ko--X--defaultlinux-3.12-rc1.tar.xz--X--08_1a--X--cpachecker/linux-3.12-rc1.tar.xz/csd_deg_dscv/60/dscv_tempdir/dscv/ri/08_1a/fs/nfs/fscache-index.o.c.prepared", 482, 0); _cond_resched(); goto ldv_51190; ldv_51185: ; return; } } static void nfs_fh_get_context(void *cookie_netfs_data , void *context ) { { get_nfs_open_context((struct nfs_open_context *)context); return; } } static void nfs_fh_put_context(void *cookie_netfs_data , void *context ) { { if ((unsigned long )context != (unsigned long )((void *)0)) { put_nfs_open_context((struct nfs_open_context *)context); } else { } return; } } struct fscache_cookie_def const nfs_fscache_inode_object_def = {{'N', 'F', 'S', '.', 'f', 'h', '\000'}, 1U, 0, & nfs_fscache_inode_get_key, & nfs_fscache_inode_get_attr, & nfs_fscache_inode_get_aux, & nfs_fscache_inode_check_aux, & nfs_fh_get_context, & nfs_fh_put_context, 0, & nfs_fscache_inode_now_uncached}; void ldv_main_exported_1(void) { void *ldvarg232 ; void *tmp ; void *ldvarg239 ; void *tmp___0 ; uint16_t ldvarg226 ; void *ldvarg228 ; void *tmp___1 ; void *ldvarg227 ; void *tmp___2 ; void *ldvarg234 ; void *tmp___3 ; void *ldvarg229 ; void *tmp___4 ; void *ldvarg235 ; void *tmp___5 ; void *ldvarg236 ; void *tmp___6 ; void *ldvarg233 ; void *tmp___7 ; void *ldvarg238 ; void *tmp___8 ; uint16_t ldvarg231 ; void *ldvarg225 ; void *tmp___9 ; uint64_t *ldvarg240 ; void *tmp___10 ; void *ldvarg230 ; void *tmp___11 ; uint16_t ldvarg237 ; int tmp___12 ; { tmp = ldv_zalloc(1UL); ldvarg232 = tmp; tmp___0 = ldv_zalloc(1UL); ldvarg239 = tmp___0; tmp___1 = ldv_zalloc(1UL); ldvarg228 = tmp___1; tmp___2 = ldv_zalloc(1UL); ldvarg227 = tmp___2; tmp___3 = ldv_zalloc(1UL); ldvarg234 = tmp___3; tmp___4 = ldv_zalloc(1UL); ldvarg229 = tmp___4; tmp___5 = ldv_zalloc(1UL); ldvarg235 = tmp___5; tmp___6 = ldv_zalloc(1UL); ldvarg236 = tmp___6; tmp___7 = ldv_zalloc(1UL); ldvarg233 = tmp___7; tmp___8 = ldv_zalloc(1UL); ldvarg238 = tmp___8; tmp___9 = ldv_zalloc(1UL); ldvarg225 = tmp___9; tmp___10 = ldv_zalloc(8UL); ldvarg240 = (uint64_t *)tmp___10; tmp___11 = ldv_zalloc(1UL); ldvarg230 = tmp___11; memset((void *)(& ldvarg226), 0, 2UL); memset((void *)(& ldvarg231), 0, 2UL); memset((void *)(& ldvarg237), 0, 2UL); tmp___12 = __VERIFIER_nondet_int(); switch (tmp___12) { case 0: ; if (ldv_state_variable_1 == 1) { nfs_fscache_inode_get_attr((void const *)ldvarg239, ldvarg240); ldv_state_variable_1 = 1; } else { } goto ldv_51220; case 1: ; if (ldv_state_variable_1 == 1) { nfs_fscache_inode_get_key((void const *)ldvarg236, ldvarg238, (int )ldvarg237); ldv_state_variable_1 = 1; } else { } goto ldv_51220; case 2: ; if (ldv_state_variable_1 == 1) { nfs_fh_put_context(ldvarg234, ldvarg235); ldv_state_variable_1 = 1; } else { } goto ldv_51220; case 3: ; if (ldv_state_variable_1 == 1) { nfs_fscache_inode_now_uncached(ldvarg233); ldv_state_variable_1 = 1; } else { } goto ldv_51220; case 4: ; if (ldv_state_variable_1 == 1) { nfs_fscache_inode_get_aux((void const *)ldvarg230, ldvarg232, (int )ldvarg231); ldv_state_variable_1 = 1; } else { } goto ldv_51220; case 5: ; if (ldv_state_variable_1 == 1) { nfs_fh_get_context(ldvarg228, ldvarg229); ldv_state_variable_1 = 1; } else { } goto ldv_51220; case 6: ; if (ldv_state_variable_1 == 1) { nfs_fscache_inode_check_aux(ldvarg225, (void const *)ldvarg227, (int )ldvarg226); ldv_state_variable_1 = 1; } else { } goto ldv_51220; default: ldv_stop(); } ldv_51220: ; return; } } void ldv_main_exported_3(void) { uint16_t ldvarg286 ; void *ldvarg287 ; void *tmp ; void *ldvarg285 ; void *tmp___0 ; int tmp___1 ; { tmp = ldv_zalloc(1UL); ldvarg287 = tmp; tmp___0 = ldv_zalloc(1UL); ldvarg285 = tmp___0; memset((void *)(& ldvarg286), 0, 2UL); tmp___1 = __VERIFIER_nondet_int(); switch (tmp___1) { case 0: ; if (ldv_state_variable_3 == 1) { nfs_server_get_key((void const *)ldvarg285, ldvarg287, (int )ldvarg286); ldv_state_variable_3 = 1; } else { } goto ldv_51235; default: ldv_stop(); } ldv_51235: ; return; } } void ldv_main_exported_2(void) { uint16_t ldvarg221 ; void *ldvarg222 ; void *tmp ; void *ldvarg220 ; void *tmp___0 ; int tmp___1 ; { tmp = ldv_zalloc(1UL); ldvarg222 = tmp; tmp___0 = ldv_zalloc(1UL); ldvarg220 = tmp___0; memset((void *)(& ldvarg221), 0, 2UL); tmp___1 = __VERIFIER_nondet_int(); switch (tmp___1) { case 0: ; if (ldv_state_variable_2 == 1) { nfs_super_get_key((void const *)ldvarg220, ldvarg222, (int )ldvarg221); ldv_state_variable_2 = 1; } else { } goto ldv_51244; default: ldv_stop(); } ldv_51244: ; return; } } __inline static void ldv_error(void); int ldv_module_refcounter = 1; void ldv_module_get(struct module *module ) { { if (module) { ldv_module_refcounter = ldv_module_refcounter + 1; } else { } return; } } int ldv_try_module_get(struct module *module ) { int module_get_succeeded ; { if (module) { module_get_succeeded = ldv_undef_int(); if (module_get_succeeded == 1) { ldv_module_refcounter = ldv_module_refcounter + 1; return (1); } else { return (0); } } else { } return (0); } } void ldv_module_put(struct module *module ) { { if (module) { if (ldv_module_refcounter > 1) { } else { ldv_error(); } ldv_module_refcounter = ldv_module_refcounter - 1; } else { } return; } } void ldv_module_put_and_exit(void) { { ldv_module_put((struct module *)1); LDV_STOP: goto LDV_STOP; } } unsigned int ldv_module_refcount(void) { { return (ldv_module_refcounter - 1); } } void ldv_check_final_state(void) { { if (ldv_module_refcounter == 1) { } else { ldv_error(); } return; } }