extern void abort(void); extern void __assert_fail(const char *, const char *, unsigned int, const char *) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__)); void reach_error() { __assert_fail("0", "drivers--media--video--videobuf-vmalloc.ko_023.38a54f3.32_1.cil_true-unreach-call.i", 3, "reach_error"); } /* Generated by CIL v. 1.5.1 */ /* print_CIL_Input is false */ typedef void (*ctor_fn_t)(void); typedef signed char __s8; typedef short __s16; typedef unsigned short __u16; typedef int __s32; typedef unsigned int __u32; typedef unsigned long long __u64; typedef unsigned short u16; typedef unsigned int u32; typedef unsigned long long u64; typedef unsigned short umode_t; typedef u64 dma_addr_t; typedef unsigned int __kernel_mode_t; typedef unsigned int __kernel_uid_t; typedef unsigned int __kernel_gid_t; typedef unsigned long __kernel_size_t; typedef long __kernel_ssize_t; typedef long __kernel_time_t; typedef long __kernel_suseconds_t; typedef int __kernel_clockid_t; typedef long long __kernel_loff_t; typedef __kernel_uid_t __kernel_uid32_t; typedef __kernel_gid_t __kernel_gid32_t; typedef __u32 __kernel_dev_t; typedef __kernel_dev_t dev_t; typedef __kernel_mode_t mode_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 unsigned long sector_t; typedef unsigned long blkcnt_t; typedef unsigned int gfp_t; typedef unsigned int fmode_t; struct __anonstruct_atomic_t_7 { int volatile counter ; }; typedef struct __anonstruct_atomic_t_7 atomic_t; struct __anonstruct_atomic64_t_8 { long volatile counter ; }; typedef struct __anonstruct_atomic64_t_8 atomic64_t; struct task_struct; struct mm_struct; 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 ; }; struct module; struct bug_entry { int bug_addr_disp ; int file_disp ; unsigned short line ; unsigned short flags ; }; struct completion; struct pid; typedef unsigned long pgdval_t; typedef unsigned long pgprotval_t; struct pgprot { pgprotval_t pgprot ; }; typedef struct pgprot pgprot_t; struct __anonstruct_pgd_t_13 { pgdval_t pgd ; }; typedef struct __anonstruct_pgd_t_13 pgd_t; struct page; struct file; struct seq_file; struct cpumask; struct raw_spinlock; struct cpumask { unsigned long bits[((4096UL + 8UL * sizeof(long )) - 1UL) / (8UL * sizeof(long ))] ; }; typedef struct cpumask cpumask_t; struct exec_domain; 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 kmem_cache; struct __anonstruct_mm_segment_t_31 { unsigned long seg ; }; typedef struct __anonstruct_mm_segment_t_31 mm_segment_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 timespec; struct compat_timespec; struct __anonstruct____missing_field_name_33 { unsigned long arg0 ; unsigned long arg1 ; unsigned long arg2 ; unsigned long arg3 ; }; struct __anonstruct_futex_34 { u32 *uaddr ; u32 val ; u32 flags ; u32 bitset ; u64 time ; u32 *uaddr2 ; }; struct __anonstruct_nanosleep_35 { clockid_t index ; struct timespec *rmtp ; struct compat_timespec *compat_rmtp ; u64 expires ; }; struct pollfd; struct __anonstruct_poll_36 { struct pollfd *ufds ; int nfds ; int has_timeout ; unsigned long tv_sec ; unsigned long tv_nsec ; }; union __anonunion____missing_field_name_32 { struct __anonstruct____missing_field_name_33 __annonCompField16 ; struct __anonstruct_futex_34 futex ; struct __anonstruct_nanosleep_35 nanosleep ; struct __anonstruct_poll_36 poll ; }; struct restart_block { long (*fn)(struct restart_block * ) ; union __anonunion____missing_field_name_32 __annonCompField17 ; }; 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 ; int uaccess_err ; }; struct raw_spinlock { unsigned int slock ; }; typedef struct raw_spinlock raw_spinlock_t; struct __anonstruct_raw_rwlock_t_37 { unsigned int lock ; }; typedef struct __anonstruct_raw_rwlock_t_37 raw_rwlock_t; struct lock_class_key { }; struct __anonstruct_spinlock_t_38 { raw_spinlock_t raw_lock ; unsigned int magic ; unsigned int owner_cpu ; void *owner ; }; typedef struct __anonstruct_spinlock_t_38 spinlock_t; struct __anonstruct_rwlock_t_39 { raw_rwlock_t raw_lock ; unsigned int magic ; unsigned int owner_cpu ; void *owner ; }; typedef struct __anonstruct_rwlock_t_39 rwlock_t; struct timespec { __kernel_time_t tv_sec ; long tv_nsec ; }; struct timeval { __kernel_time_t tv_sec ; __kernel_suseconds_t tv_usec ; }; struct kstat { u64 ino ; dev_t dev ; umode_t mode ; unsigned int nlink ; uid_t uid ; gid_t gid ; dev_t rdev ; loff_t size ; struct timespec atime ; struct timespec mtime ; struct timespec ctime ; unsigned long blksize ; unsigned long long blocks ; }; 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_41 { unsigned long bits[(((unsigned long )(1 << 9) + 8UL * sizeof(long )) - 1UL) / (8UL * sizeof(long ))] ; }; typedef struct __anonstruct_nodemask_t_41 nodemask_t; struct mutex { atomic_t count ; spinlock_t wait_lock ; struct list_head wait_list ; struct thread_info *owner ; char const *name ; void *magic ; }; struct rw_semaphore; struct rw_semaphore { __s32 activity ; spinlock_t wait_lock ; struct list_head wait_list ; }; struct device; struct tvec_base; struct timer_list { struct list_head entry ; unsigned long expires ; void (*function)(unsigned long ) ; unsigned long data ; struct tvec_base *base ; void *start_site ; char start_comm[16] ; int start_pid ; }; struct work_struct; struct work_struct { atomic_long_t data ; struct list_head entry ; void (*func)(struct work_struct *work ) ; }; struct pm_message { int event ; }; typedef struct pm_message pm_message_t; struct dev_pm_ops { int (*prepare)(struct device *dev ) ; void (*complete)(struct device *dev ) ; int (*suspend)(struct device *dev ) ; int (*resume)(struct device *dev ) ; int (*freeze)(struct device *dev ) ; int (*thaw)(struct device *dev ) ; int (*poweroff)(struct device *dev ) ; int (*restore)(struct device *dev ) ; int (*suspend_noirq)(struct device *dev ) ; int (*resume_noirq)(struct device *dev ) ; int (*freeze_noirq)(struct device *dev ) ; int (*thaw_noirq)(struct device *dev ) ; int (*poweroff_noirq)(struct device *dev ) ; int (*restore_noirq)(struct device *dev ) ; int (*runtime_suspend)(struct device *dev ) ; int (*runtime_resume)(struct device *dev ) ; int (*runtime_idle)(struct device *dev ) ; }; enum dpm_state { DPM_INVALID = 0, DPM_ON = 1, DPM_PREPARING = 2, DPM_RESUMING = 3, DPM_SUSPENDING = 4, DPM_OFF = 5, DPM_OFF_IRQ = 6 } ; 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_RESUME = 3 } ; struct dev_pm_info { pm_message_t power_state ; unsigned int can_wakeup : 1 ; unsigned int should_wakeup : 1 ; enum dpm_state status ; struct list_head entry ; struct timer_list suspend_timer ; unsigned long timer_expires ; struct work_struct work ; wait_queue_head_t wait_queue ; spinlock_t lock ; atomic_t usage_count ; atomic_t child_count ; unsigned int disable_depth : 3 ; unsigned int ignore_children : 1 ; unsigned int idle_notification : 1 ; unsigned int request_pending : 1 ; unsigned int deferred_resume : 1 ; enum rpm_request request ; enum rpm_status runtime_status ; int runtime_error ; }; struct __anonstruct_mm_context_t_108 { void *ldt ; int size ; struct mutex lock ; void *vdso ; }; typedef struct __anonstruct_mm_context_t_108 mm_context_t; struct vm_area_struct; 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 kobject; struct attribute { char const *name ; struct module *owner ; mode_t mode ; }; struct attribute_group { char const *name ; mode_t (*is_visible)(struct kobject * , struct attribute * , int ) ; struct attribute **attrs ; }; struct sysfs_ops { ssize_t (*show)(struct kobject * , struct attribute * , char * ) ; ssize_t (*store)(struct kobject * , struct attribute * , char const * , size_t ) ; }; 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 ; unsigned int state_initialized : 1 ; unsigned int state_in_sysfs : 1 ; unsigned int state_add_uevent_sent : 1 ; unsigned int state_remove_uevent_sent : 1 ; unsigned int uevent_suppress : 1 ; }; struct kobj_type { void (*release)(struct kobject *kobj ) ; struct sysfs_ops *sysfs_ops ; struct attribute **default_attrs ; }; struct kobj_uevent_env { char *envp[32] ; int envp_idx ; char buf[2048] ; int buflen ; }; struct kset_uevent_ops { int (*filter)(struct kset *kset , struct kobject *kobj ) ; char const *(*name)(struct kset *kset , struct kobject *kobj ) ; int (*uevent)(struct kset *kset , struct kobject *kobj , struct kobj_uevent_env *env ) ; }; struct kset { struct list_head list ; spinlock_t list_lock ; struct kobject kobj ; struct kset_uevent_ops *uevent_ops ; }; struct kernel_param; struct kparam_string; struct kparam_array; union __anonunion____missing_field_name_118 { void *arg ; struct kparam_string const *str ; struct kparam_array const *arr ; }; struct kernel_param { char const *name ; u16 perm ; u16 flags ; int (*set)(char const *val , struct kernel_param *kp ) ; int (*get)(char *buffer , struct kernel_param *kp ) ; union __anonunion____missing_field_name_118 __annonCompField18 ; }; struct kparam_string { unsigned int maxlen ; char *string ; }; struct kparam_array { unsigned int max ; unsigned int *num ; int (*set)(char const *val , struct kernel_param *kp ) ; int (*get)(char *buffer , struct kernel_param *kp ) ; unsigned int elemsize ; void *elem ; }; struct completion { unsigned int done ; wait_queue_head_t wait ; }; struct rcu_head { struct rcu_head *next ; void (*func)(struct rcu_head *head ) ; }; struct tracepoint; struct tracepoint { char const *name ; int state ; void (*regfunc)(void) ; void (*unregfunc)(void) ; void **funcs ; } __attribute__((__aligned__(32))) ; enum stat_item { ALLOC_FASTPATH = 0, ALLOC_SLOWPATH = 1, FREE_FASTPATH = 2, FREE_SLOWPATH = 3, FREE_FROZEN = 4, FREE_ADD_PARTIAL = 5, FREE_REMOVE_PARTIAL = 6, ALLOC_FROM_PARTIAL = 7, ALLOC_SLAB = 8, ALLOC_REFILL = 9, FREE_SLAB = 10, CPUSLAB_FLUSH = 11, DEACTIVATE_FULL = 12, DEACTIVATE_EMPTY = 13, DEACTIVATE_TO_HEAD = 14, DEACTIVATE_TO_TAIL = 15, DEACTIVATE_REMOTE_FREES = 16, ORDER_FALLBACK = 17, NR_SLUB_STAT_ITEMS = 18 } ; struct kmem_cache_cpu { void **freelist ; struct page *page ; int node ; unsigned int offset ; unsigned int objsize ; unsigned int stat[NR_SLUB_STAT_ITEMS] ; }; struct kmem_cache_node { spinlock_t list_lock ; unsigned long nr_partial ; struct list_head partial ; atomic_long_t nr_slabs ; atomic_long_t total_objects ; struct list_head full ; }; struct kmem_cache_order_objects { unsigned long x ; }; struct kmem_cache { unsigned long flags ; int size ; int objsize ; int offset ; struct kmem_cache_order_objects oo ; struct kmem_cache_node local_node ; struct kmem_cache_order_objects max ; struct kmem_cache_order_objects min ; gfp_t allocflags ; int refcount ; void (*ctor)(void * ) ; int inuse ; int align ; unsigned long min_partial ; char const *name ; struct list_head list ; struct kobject kobj ; int remote_node_defrag_ratio ; struct kmem_cache_node *node[1 << 9] ; struct kmem_cache_cpu *cpu_slab[4096] ; }; struct mod_arch_specific { }; struct kernel_symbol { unsigned long value ; char const *name ; }; struct module_attribute { struct attribute attr ; ssize_t (*show)(struct module_attribute * , struct module * , char * ) ; ssize_t (*store)(struct module_attribute * , struct module * , char const * , size_t count ) ; void (*setup)(struct module * , char const * ) ; int (*test)(struct module * ) ; void (*free)(struct module * ) ; }; struct module_param_attrs; struct module_kobject { struct kobject kobj ; struct module *mod ; struct kobject *drivers_dir ; struct module_param_attrs *mp ; }; struct exception_table_entry; enum module_state { MODULE_STATE_LIVE = 0, MODULE_STATE_COMING = 1, MODULE_STATE_GOING = 2 } ; struct module_sect_attrs; struct module_notes_attrs; struct ftrace_event_call; struct module { enum module_state state ; struct list_head list ; char name[64UL - sizeof(unsigned long )] ; 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 ; 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 ; 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 ; void *percpu ; char *args ; struct tracepoint *tracepoints ; unsigned int num_tracepoints ; char const **trace_bprintk_fmt_start ; unsigned int num_trace_bprintk_fmt ; struct ftrace_event_call *trace_events ; unsigned int num_trace_events ; struct list_head modules_which_use_me ; struct task_struct *waiter ; void (*exit)(void) ; char *refptr ; ctor_fn_t *ctors ; unsigned int num_ctors ; }; struct device_driver; struct rb_node { unsigned long rb_parent_color ; struct rb_node *rb_right ; struct rb_node *rb_left ; } __attribute__((__aligned__(sizeof(long )))) ; struct rb_root { struct rb_node *rb_node ; }; struct klist_node; struct klist_node { void *n_klist ; struct list_head n_node ; struct kref n_ref ; }; struct semaphore { spinlock_t lock ; unsigned int count ; struct list_head wait_list ; }; struct dma_map_ops; struct dev_archdata { void *acpi_handle ; struct dma_map_ops *dma_ops ; void *iommu ; }; struct device_private; struct driver_private; struct class; struct class_private; struct bus_type; struct bus_type_private; struct bus_attribute { struct attribute attr ; ssize_t (*show)(struct bus_type *bus , char *buf ) ; ssize_t (*store)(struct bus_type *bus , char const *buf , size_t count ) ; }; struct device_attribute; struct driver_attribute; struct bus_type { char const *name ; struct bus_attribute *bus_attrs ; struct device_attribute *dev_attrs ; struct driver_attribute *drv_attrs ; int (*match)(struct device *dev , struct device_driver *drv ) ; int (*uevent)(struct device *dev , struct kobj_uevent_env *env ) ; int (*probe)(struct device *dev ) ; int (*remove)(struct device *dev ) ; void (*shutdown)(struct device *dev ) ; int (*suspend)(struct device *dev , pm_message_t state ) ; int (*resume)(struct device *dev ) ; struct dev_pm_ops const *pm ; struct bus_type_private *p ; }; struct device_driver { char const *name ; struct bus_type *bus ; struct module *owner ; char const *mod_name ; bool suppress_bind_attrs ; int (*probe)(struct device *dev ) ; int (*remove)(struct device *dev ) ; void (*shutdown)(struct device *dev ) ; int (*suspend)(struct device *dev , pm_message_t state ) ; int (*resume)(struct device *dev ) ; 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 *driver , char *buf ) ; ssize_t (*store)(struct device_driver *driver , char const *buf , size_t count ) ; }; struct class_attribute; struct class { char const *name ; struct module *owner ; struct class_attribute *class_attrs ; struct device_attribute *dev_attrs ; struct kobject *dev_kobj ; int (*dev_uevent)(struct device *dev , struct kobj_uevent_env *env ) ; char *(*devnode)(struct device *dev , mode_t *mode ) ; void (*class_release)(struct class *class ) ; void (*dev_release)(struct device *dev ) ; int (*suspend)(struct device *dev , pm_message_t state ) ; int (*resume)(struct device *dev ) ; struct dev_pm_ops const *pm ; struct class_private *p ; }; struct device_type; struct class_attribute { struct attribute attr ; ssize_t (*show)(struct class *class , char *buf ) ; ssize_t (*store)(struct class *class , char const *buf , size_t count ) ; }; struct device_type { char const *name ; struct attribute_group const **groups ; int (*uevent)(struct device *dev , struct kobj_uevent_env *env ) ; char *(*devnode)(struct device *dev , mode_t *mode ) ; void (*release)(struct device *dev ) ; struct dev_pm_ops const *pm ; }; struct device_attribute { struct attribute attr ; ssize_t (*show)(struct device *dev , struct device_attribute *attr , char *buf ) ; ssize_t (*store)(struct device *dev , struct device_attribute *attr , char const *buf , size_t count ) ; }; struct device_dma_parameters { unsigned int max_segment_size ; unsigned long segment_boundary_mask ; }; struct dma_coherent_mem; struct device { struct device *parent ; struct device_private *p ; struct kobject kobj ; char const *init_name ; struct device_type *type ; struct semaphore sem ; struct bus_type *bus ; struct device_driver *driver ; void *platform_data ; struct dev_pm_info power ; 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 ; dev_t devt ; 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 *dev ) ; }; 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 prio_tree_node; struct raw_prio_tree_node { struct prio_tree_node *left ; struct prio_tree_node *right ; struct prio_tree_node *parent ; }; struct prio_tree_node { struct prio_tree_node *left ; struct prio_tree_node *right ; struct prio_tree_node *parent ; unsigned long start ; unsigned long last ; }; struct prio_tree_root { struct prio_tree_node *prio_tree_node ; unsigned short index_bits ; unsigned short raw ; }; struct address_space; typedef atomic_long_t mm_counter_t; struct __anonstruct____missing_field_name_129 { u16 inuse ; u16 objects ; }; union __anonunion____missing_field_name_128 { atomic_t _mapcount ; struct __anonstruct____missing_field_name_129 __annonCompField20 ; }; struct __anonstruct____missing_field_name_131 { unsigned long private ; struct address_space *mapping ; }; union __anonunion____missing_field_name_130 { struct __anonstruct____missing_field_name_131 __annonCompField22 ; spinlock_t ptl ; struct kmem_cache *slab ; struct page *first_page ; }; union __anonunion____missing_field_name_132 { unsigned long index ; void *freelist ; }; struct page { unsigned long flags ; atomic_t _count ; union __anonunion____missing_field_name_128 __annonCompField21 ; union __anonunion____missing_field_name_130 __annonCompField23 ; union __anonunion____missing_field_name_132 __annonCompField24 ; struct list_head lru ; }; struct __anonstruct_vm_set_134 { struct list_head list ; void *parent ; struct vm_area_struct *head ; }; union __anonunion_shared_133 { struct __anonstruct_vm_set_134 vm_set ; struct raw_prio_tree_node prio_tree_node ; }; struct anon_vma; struct vm_operations_struct; struct mempolicy; struct vm_area_struct { struct mm_struct *vm_mm ; unsigned long vm_start ; unsigned long vm_end ; struct vm_area_struct *vm_next ; pgprot_t vm_page_prot ; unsigned long vm_flags ; struct rb_node vm_rb ; union __anonunion_shared_133 shared ; struct list_head anon_vma_node ; struct anon_vma *anon_vma ; struct vm_operations_struct const *vm_ops ; unsigned long vm_pgoff ; struct file *vm_file ; void *vm_private_data ; unsigned long vm_truncate_count ; 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 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 *filp , unsigned long addr , unsigned long len , unsigned long pgoff , unsigned long flags ) ; void (*unmap_area)(struct mm_struct *mm , unsigned long addr ) ; unsigned long mmap_base ; unsigned long task_size ; unsigned long cached_hole_size ; unsigned long free_area_cache ; pgd_t *pgd ; atomic_t mm_users ; atomic_t mm_count ; int map_count ; struct rw_semaphore mmap_sem ; spinlock_t page_table_lock ; struct list_head mmlist ; mm_counter_t _file_rss ; mm_counter_t _anon_rss ; unsigned long hiwater_rss ; unsigned long hiwater_vm ; unsigned long total_vm ; unsigned long locked_vm ; unsigned long shared_vm ; unsigned long exec_vm ; unsigned long stack_vm ; unsigned long reserved_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[2 * ((2 + 19) + 1)] ; struct linux_binfmt *binfmt ; cpumask_t cpu_vm_mask ; mm_context_t context ; unsigned int faultstamp ; unsigned int token_priority ; unsigned int last_interval ; unsigned long flags ; struct core_state *core_state ; spinlock_t ioctx_lock ; struct hlist_head ioctx_list ; struct task_struct *owner ; struct file *exe_file ; unsigned long num_exe_file_vmas ; struct mmu_notifier_mm *mmu_notifier_mm ; }; struct file_ra_state; struct writeback_control; 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 *area ) ; void (*close)(struct vm_area_struct *area ) ; int (*fault)(struct vm_area_struct *vma , struct vm_fault *vmf ) ; int (*page_mkwrite)(struct vm_area_struct *vma , struct vm_fault *vmf ) ; int (*access)(struct vm_area_struct *vma , unsigned long addr , void *buf , int len , int write ) ; int (*set_policy)(struct vm_area_struct *vma , struct mempolicy *new ) ; struct mempolicy *(*get_policy)(struct vm_area_struct *vma , unsigned long addr ) ; int (*migrate)(struct vm_area_struct *vma , nodemask_t const *from , nodemask_t const *to , unsigned long flags ) ; }; struct inode; enum dma_attr { DMA_ATTR_WRITE_BARRIER = 0, DMA_ATTR_WEAK_ORDERING = 1, DMA_ATTR_MAX = 2 } ; struct dma_attrs { unsigned long flags[(((unsigned long )DMA_ATTR_MAX + 8UL * sizeof(long )) - 1UL) / (8UL * sizeof(long ))] ; }; enum dma_data_direction { DMA_BIDIRECTIONAL = 0, DMA_TO_DEVICE = 1, DMA_FROM_DEVICE = 2, DMA_NONE = 3 } ; struct dma_map_ops { void *(*alloc_coherent)(struct device *dev , size_t size , dma_addr_t *dma_handle , gfp_t gfp ) ; void (*free_coherent)(struct device *dev , size_t size , void *vaddr , dma_addr_t dma_handle ) ; dma_addr_t (*map_page)(struct device *dev , struct page *page , unsigned long offset , size_t size , enum dma_data_direction dir , struct dma_attrs *attrs ) ; void (*unmap_page)(struct device *dev , dma_addr_t dma_handle , size_t size , enum dma_data_direction dir , struct dma_attrs *attrs ) ; int (*map_sg)(struct device *dev , struct scatterlist *sg , int nents , enum dma_data_direction dir , struct dma_attrs *attrs ) ; void (*unmap_sg)(struct device *dev , struct scatterlist *sg , int nents , enum dma_data_direction dir , struct dma_attrs *attrs ) ; void (*sync_single_for_cpu)(struct device *dev , dma_addr_t dma_handle , size_t size , enum dma_data_direction dir ) ; void (*sync_single_for_device)(struct device *dev , dma_addr_t dma_handle , size_t size , enum dma_data_direction dir ) ; void (*sync_single_range_for_cpu)(struct device *dev , dma_addr_t dma_handle , unsigned long offset , size_t size , enum dma_data_direction dir ) ; void (*sync_single_range_for_device)(struct device *dev , dma_addr_t dma_handle , unsigned long offset , size_t size , enum dma_data_direction dir ) ; void (*sync_sg_for_cpu)(struct device *dev , struct scatterlist *sg , int nents , enum dma_data_direction dir ) ; void (*sync_sg_for_device)(struct device *dev , struct scatterlist *sg , int nents , enum dma_data_direction dir ) ; int (*mapping_error)(struct device *dev , dma_addr_t dma_addr ) ; int (*dma_supported)(struct device *dev , u64 mask ) ; int (*set_dma_mask)(struct device *dev , u64 mask ) ; int is_phys ; }; struct nameidata; struct path; struct vfsmount; struct qstr { unsigned int hash ; unsigned int len ; unsigned char const *name ; }; union __anonunion_d_u_135 { struct list_head d_child ; struct rcu_head d_rcu ; }; struct dentry_operations; struct super_block; struct dentry { atomic_t d_count ; unsigned int d_flags ; spinlock_t d_lock ; int d_mounted ; struct inode *d_inode ; struct hlist_node d_hash ; struct dentry *d_parent ; struct qstr d_name ; struct list_head d_lru ; union __anonunion_d_u_135 d_u ; struct list_head d_subdirs ; struct list_head d_alias ; unsigned long d_time ; struct dentry_operations const *d_op ; struct super_block *d_sb ; void *d_fsdata ; unsigned char d_iname[32] ; }; struct dentry_operations { int (*d_revalidate)(struct dentry * , struct nameidata * ) ; int (*d_hash)(struct dentry * , struct qstr * ) ; int (*d_compare)(struct dentry * , struct qstr * , struct qstr * ) ; int (*d_delete)(struct dentry * ) ; void (*d_release)(struct dentry * ) ; void (*d_iput)(struct dentry * , struct inode * ) ; char *(*d_dname)(struct dentry * , char * , int ) ; }; struct path { struct vfsmount *mnt ; struct dentry *dentry ; }; struct radix_tree_node; struct radix_tree_root { unsigned int height ; gfp_t gfp_mask ; struct radix_tree_node *rnode ; }; 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[PIDTYPE_MAX] ; struct rcu_head rcu ; struct upid numbers[1] ; }; struct fiemap_extent { __u64 fe_logical ; __u64 fe_physical ; __u64 fe_length ; __u64 fe_reserved64[2] ; __u32 fe_flags ; __u32 fe_reserved[3] ; }; struct export_operations; struct iovec; struct kiocb; struct pipe_inode_info; struct poll_table_struct; struct kstatfs; struct cred; struct iattr { unsigned int ia_valid ; umode_t ia_mode ; uid_t ia_uid ; gid_t ia_gid ; loff_t ia_size ; struct timespec ia_atime ; struct timespec ia_mtime ; struct timespec ia_ctime ; struct file *ia_file ; }; struct if_dqblk { __u64 dqb_bhardlimit ; __u64 dqb_bsoftlimit ; __u64 dqb_curspace ; __u64 dqb_ihardlimit ; __u64 dqb_isoftlimit ; __u64 dqb_curinodes ; __u64 dqb_btime ; __u64 dqb_itime ; __u32 dqb_valid ; }; struct if_dqinfo { __u64 dqi_bgrace ; __u64 dqi_igrace ; __u32 dqi_flags ; __u32 dqi_valid ; }; struct fs_disk_quota { __s8 d_version ; __s8 d_flags ; __u16 d_fieldmask ; __u32 d_id ; __u64 d_blk_hardlimit ; __u64 d_blk_softlimit ; __u64 d_ino_hardlimit ; __u64 d_ino_softlimit ; __u64 d_bcount ; __u64 d_icount ; __s32 d_itimer ; __s32 d_btimer ; __u16 d_iwarns ; __u16 d_bwarns ; __s32 d_padding2 ; __u64 d_rtb_hardlimit ; __u64 d_rtb_softlimit ; __u64 d_rtbcount ; __s32 d_rtbtimer ; __u16 d_rtbwarns ; __s16 d_padding3 ; char d_padding4[8] ; }; 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 dquot; typedef __kernel_uid32_t qid_t; typedef long long qsize_t; 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 ; unsigned int dq_id ; loff_t dq_off ; unsigned long dq_flags ; short dq_type ; struct mem_dqblk dq_dqb ; }; struct quota_format_ops { int (*check_quota_file)(struct super_block *sb , int type ) ; int (*read_file_info)(struct super_block *sb , int type ) ; int (*write_file_info)(struct super_block *sb , int type ) ; int (*free_file_info)(struct super_block *sb , int type ) ; int (*read_dqblk)(struct dquot *dquot ) ; int (*commit_dqblk)(struct dquot *dquot ) ; int (*release_dqblk)(struct dquot *dquot ) ; }; struct dquot_operations { int (*initialize)(struct inode * , int ) ; int (*drop)(struct inode * ) ; int (*alloc_space)(struct inode * , qsize_t , int ) ; int (*alloc_inode)(struct inode const * , qsize_t ) ; int (*free_space)(struct inode * , qsize_t ) ; int (*free_inode)(struct inode const * , qsize_t ) ; int (*transfer)(struct inode * , struct iattr * ) ; 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 ) ; int (*reserve_space)(struct inode * , qsize_t , int ) ; int (*claim_space)(struct inode * , qsize_t ) ; void (*release_rsv)(struct inode * , qsize_t ) ; qsize_t (*get_reserved_space)(struct inode * ) ; }; struct quotactl_ops { int (*quota_on)(struct super_block * , int , int , char * , int ) ; int (*quota_off)(struct super_block * , int , int ) ; int (*quota_sync)(struct super_block * , int ) ; int (*get_info)(struct super_block * , int , struct if_dqinfo * ) ; int (*set_info)(struct super_block * , int , struct if_dqinfo * ) ; int (*get_dqblk)(struct super_block * , int , qid_t , struct if_dqblk * ) ; int (*set_dqblk)(struct super_block * , int , qid_t , struct if_dqblk * ) ; int (*get_xstate)(struct super_block * , struct fs_quota_stat * ) ; int (*set_xstate)(struct super_block * , unsigned int , int ) ; int (*get_xquota)(struct super_block * , int , qid_t , struct fs_disk_quota * ) ; int (*set_xquota)(struct super_block * , int , qid_t , struct fs_disk_quota * ) ; }; struct quota_format_type { int qf_fmt_id ; struct quota_format_ops *qf_ops ; struct module *qf_owner ; struct quota_format_type *qf_next ; }; struct quota_info { unsigned int flags ; struct mutex dqio_mutex ; struct mutex dqonoff_mutex ; struct rw_semaphore dqptr_sem ; struct inode *files[2] ; struct mem_dqinfo info[2] ; struct quota_format_ops *ops[2] ; }; union __anonunion_arg_142 { char *buf ; void *data ; }; struct __anonstruct_read_descriptor_t_141 { size_t written ; size_t count ; union __anonunion_arg_142 arg ; int error ; }; typedef struct __anonstruct_read_descriptor_t_141 read_descriptor_t; struct address_space_operations { int (*writepage)(struct page *page , struct writeback_control *wbc ) ; int (*readpage)(struct file * , struct page * ) ; void (*sync_page)(struct page * ) ; int (*writepages)(struct address_space * , struct writeback_control * ) ; int (*set_page_dirty)(struct page *page ) ; int (*readpages)(struct file *filp , struct address_space *mapping , struct list_head *pages , unsigned int nr_pages ) ; int (*write_begin)(struct file * , struct address_space *mapping , loff_t pos , unsigned int len , unsigned int flags , struct page **pagep , void **fsdata ) ; int (*write_end)(struct file * , struct address_space *mapping , loff_t pos , unsigned int len , unsigned int copied , struct page *page , void *fsdata ) ; sector_t (*bmap)(struct address_space * , sector_t ) ; void (*invalidatepage)(struct page * , unsigned long ) ; int (*releasepage)(struct page * , gfp_t ) ; ssize_t (*direct_IO)(int , struct kiocb * , struct iovec const *iov , loff_t offset , unsigned long nr_segs ) ; int (*get_xip_mem)(struct address_space * , unsigned long , int , void ** , unsigned long * ) ; int (*migratepage)(struct address_space * , struct page * , struct page * ) ; int (*launder_page)(struct page * ) ; int (*is_partially_uptodate)(struct page * , read_descriptor_t * , unsigned long ) ; int (*error_remove_page)(struct address_space * , struct page * ) ; }; struct backing_dev_info; struct address_space { struct inode *host ; struct radix_tree_root page_tree ; spinlock_t tree_lock ; unsigned int i_mmap_writable ; struct prio_tree_root i_mmap ; struct list_head i_mmap_nonlinear ; spinlock_t i_mmap_lock ; unsigned int truncate_count ; 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 ; struct address_space *assoc_mapping ; } __attribute__((__aligned__(sizeof(long )))) ; struct hd_struct; struct gendisk; struct block_device { dev_t bd_dev ; struct inode *bd_inode ; struct super_block *bd_super ; int bd_openers ; struct mutex bd_mutex ; struct list_head bd_inodes ; void *bd_holder ; int bd_holders ; struct list_head bd_holder_list ; 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 list_head bd_list ; unsigned long bd_private ; int bd_fsfreeze_count ; struct mutex bd_fsfreeze_mutex ; }; struct posix_acl; struct inode_operations; struct file_operations; struct file_lock; struct cdev; union __anonunion____missing_field_name_143 { struct pipe_inode_info *i_pipe ; struct block_device *i_bdev ; struct cdev *i_cdev ; }; struct inode { struct hlist_node i_hash ; struct list_head i_list ; struct list_head i_sb_list ; struct list_head i_dentry ; unsigned long i_ino ; atomic_t i_count ; unsigned int i_nlink ; uid_t i_uid ; gid_t i_gid ; dev_t i_rdev ; u64 i_version ; loff_t i_size ; struct timespec i_atime ; struct timespec i_mtime ; struct timespec i_ctime ; blkcnt_t i_blocks ; unsigned int i_blkbits ; unsigned short i_bytes ; umode_t i_mode ; spinlock_t i_lock ; struct mutex i_mutex ; struct rw_semaphore i_alloc_sem ; struct inode_operations const *i_op ; struct file_operations const *i_fop ; struct super_block *i_sb ; struct file_lock *i_flock ; struct address_space *i_mapping ; struct address_space i_data ; struct dquot *i_dquot[2] ; struct list_head i_devices ; union __anonunion____missing_field_name_143 __annonCompField25 ; __u32 i_generation ; __u32 i_fsnotify_mask ; struct hlist_head i_fsnotify_mark_entries ; struct list_head inotify_watches ; struct mutex inotify_mutex ; unsigned long i_state ; unsigned long dirtied_when ; unsigned int i_flags ; atomic_t i_writecount ; void *i_security ; struct posix_acl *i_acl ; struct posix_acl *i_default_acl ; void *i_private ; }; struct fown_struct { rwlock_t lock ; struct pid *pid ; enum pid_type pid_type ; uid_t uid ; uid_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_144 { struct list_head fu_list ; struct rcu_head fu_rcuhead ; }; struct file { union __anonunion_f_u_144 f_u ; struct path f_path ; struct file_operations const *f_op ; spinlock_t f_lock ; 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 address_space *f_mapping ; unsigned long f_mnt_write_state ; }; struct files_struct; 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 (*fl_compare_owner)(struct file_lock * , struct file_lock * ) ; void (*fl_notify)(struct file_lock * ) ; int (*fl_grant)(struct file_lock * , struct file_lock * , int ) ; void (*fl_copy_lock)(struct file_lock * , struct file_lock * ) ; void (*fl_release_private)(struct file_lock * ) ; void (*fl_break)(struct file_lock * ) ; int (*fl_mylease)(struct file_lock * , struct file_lock * ) ; int (*fl_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_146 { struct list_head link ; int state ; }; union __anonunion_fl_u_145 { struct nfs_lock_info nfs_fl ; struct nfs4_lock_info nfs4_fl ; struct __anonstruct_afs_146 afs ; }; struct file_lock { struct file_lock *fl_next ; struct list_head fl_link ; struct list_head fl_block ; fl_owner_t fl_owner ; unsigned char fl_flags ; unsigned char fl_type ; unsigned int fl_pid ; 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 ; struct file_lock_operations const *fl_ops ; struct lock_manager_operations const *fl_lmops ; union __anonunion_fl_u_145 fl_u ; }; struct fasync_struct { int magic ; int fa_fd ; struct fasync_struct *fa_next ; struct file *fa_file ; }; 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 long s_blocksize ; unsigned char s_blocksize_bits ; unsigned char s_dirt ; 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 ; struct mutex s_lock ; int s_count ; int s_need_sync ; atomic_t s_active ; void *s_security ; struct xattr_handler **s_xattr ; struct list_head s_inodes ; struct hlist_head s_anon ; struct list_head s_files ; struct list_head s_dentry_lru ; int s_nr_dentry_unused ; struct block_device *s_bdev ; struct backing_dev_info *s_bdi ; struct mtd_info *s_mtd ; struct list_head s_instances ; struct quota_info s_dquot ; int s_frozen ; wait_queue_head_t s_wait_unfrozen ; char s_id[32] ; void *s_fs_info ; fmode_t s_mode ; struct mutex s_vfs_rename_mutex ; u32 s_time_gran ; char *s_subtype ; char *s_options ; }; 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 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 (*readdir)(struct file * , void * , int (*)(void * , char const * , int , loff_t , u64 , unsigned int ) ) ; unsigned int (*poll)(struct file * , struct poll_table_struct * ) ; int (*ioctl)(struct inode * , struct file * , unsigned int , unsigned long ) ; 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 id ) ; int (*release)(struct inode * , struct file * ) ; int (*fsync)(struct file * , struct dentry * , int datasync ) ; int (*aio_fsync)(struct kiocb * , int datasync ) ; int (*fasync)(int , struct file * , int ) ; int (*lock)(struct file * , int , struct file_lock * ) ; ssize_t (*sendpage)(struct file * , struct page * , int , size_t , loff_t * , int ) ; unsigned long (*get_unmapped_area)(struct file * , unsigned long , unsigned long , unsigned long , unsigned long ) ; int (*check_flags)(int ) ; int (*flock)(struct file * , int , struct file_lock * ) ; ssize_t (*splice_write)(struct pipe_inode_info * , struct file * , loff_t * , size_t , unsigned int ) ; ssize_t (*splice_read)(struct file * , loff_t * , struct pipe_inode_info * , size_t , unsigned int ) ; int (*setlease)(struct file * , long , struct file_lock ** ) ; }; struct inode_operations { int (*create)(struct inode * , struct dentry * , int , struct nameidata * ) ; struct dentry *(*lookup)(struct inode * , struct dentry * , struct nameidata * ) ; 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 * , int ) ; int (*rmdir)(struct inode * , struct dentry * ) ; int (*mknod)(struct inode * , struct dentry * , int , dev_t ) ; int (*rename)(struct inode * , struct dentry * , struct inode * , struct dentry * ) ; int (*readlink)(struct dentry * , char * , int ) ; void *(*follow_link)(struct dentry * , struct nameidata * ) ; void (*put_link)(struct dentry * , struct nameidata * , void * ) ; void (*truncate)(struct inode * ) ; int (*permission)(struct inode * , int ) ; int (*check_acl)(struct inode * , int ) ; int (*setattr)(struct dentry * , struct iattr * ) ; int (*getattr)(struct vfsmount *mnt , 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 * ) ; void (*truncate_range)(struct inode * , loff_t , loff_t ) ; long (*fallocate)(struct inode *inode , int mode , loff_t offset , loff_t len ) ; int (*fiemap)(struct inode * , struct fiemap_extent_info * , u64 start , u64 len ) ; }; struct super_operations { struct inode *(*alloc_inode)(struct super_block *sb ) ; void (*destroy_inode)(struct inode * ) ; void (*dirty_inode)(struct inode * ) ; int (*write_inode)(struct inode * , int ) ; void (*drop_inode)(struct inode * ) ; void (*delete_inode)(struct inode * ) ; void (*put_super)(struct super_block * ) ; void (*write_super)(struct super_block * ) ; int (*sync_fs)(struct super_block *sb , int wait ) ; 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 (*clear_inode)(struct inode * ) ; void (*umount_begin)(struct super_block * ) ; int (*show_options)(struct seq_file * , struct vfsmount * ) ; int (*show_stats)(struct seq_file * , struct vfsmount * ) ; 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 ) ; }; struct file_system_type { char const *name ; int fs_flags ; int (*get_sb)(struct file_system_type * , int , char const * , void * , struct vfsmount * ) ; void (*kill_sb)(struct super_block * ) ; struct module *owner ; struct file_system_type *next ; struct list_head fs_supers ; struct lock_class_key s_lock_key ; struct lock_class_key s_umount_key ; struct lock_class_key i_lock_key ; struct lock_class_key i_mutex_key ; struct lock_class_key i_mutex_dir_key ; struct lock_class_key i_alloc_sem_key ; }; struct exception_table_entry { unsigned long insn ; unsigned long fixup ; }; 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 ; }; enum v4l2_field { V4L2_FIELD_ANY = 0, V4L2_FIELD_NONE = 1, V4L2_FIELD_TOP = 2, V4L2_FIELD_BOTTOM = 3, V4L2_FIELD_INTERLACED = 4, V4L2_FIELD_SEQ_TB = 5, V4L2_FIELD_SEQ_BT = 6, V4L2_FIELD_ALTERNATE = 7, V4L2_FIELD_INTERLACED_TB = 8, V4L2_FIELD_INTERLACED_BT = 9 } ; enum v4l2_buf_type { V4L2_BUF_TYPE_VIDEO_CAPTURE = 1, V4L2_BUF_TYPE_VIDEO_OUTPUT = 2, V4L2_BUF_TYPE_VIDEO_OVERLAY = 3, V4L2_BUF_TYPE_VBI_CAPTURE = 4, V4L2_BUF_TYPE_VBI_OUTPUT = 5, V4L2_BUF_TYPE_SLICED_VBI_CAPTURE = 6, V4L2_BUF_TYPE_SLICED_VBI_OUTPUT = 7, V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8, V4L2_BUF_TYPE_PRIVATE = 128 } ; enum v4l2_memory { V4L2_MEMORY_MMAP = 1, V4L2_MEMORY_USERPTR = 2, V4L2_MEMORY_OVERLAY = 3 } ; enum v4l2_colorspace { V4L2_COLORSPACE_SMPTE170M = 1, V4L2_COLORSPACE_SMPTE240M = 2, V4L2_COLORSPACE_REC709 = 3, V4L2_COLORSPACE_BT878 = 4, V4L2_COLORSPACE_470_SYSTEM_M = 5, V4L2_COLORSPACE_470_SYSTEM_BG = 6, V4L2_COLORSPACE_JPEG = 7, V4L2_COLORSPACE_SRGB = 8 } ; struct v4l2_pix_format { __u32 width ; __u32 height ; __u32 pixelformat ; enum v4l2_field field ; __u32 bytesperline ; __u32 sizeimage ; enum v4l2_colorspace colorspace ; __u32 priv ; }; struct v4l2_framebuffer { __u32 capability ; __u32 flags ; void *base ; struct v4l2_pix_format fmt ; }; struct videobuf_buffer; struct videobuf_queue; struct videobuf_mapping { unsigned int count ; unsigned long start ; unsigned long end ; struct videobuf_queue *q ; }; enum videobuf_state { VIDEOBUF_NEEDS_INIT = 0, VIDEOBUF_PREPARED = 1, VIDEOBUF_QUEUED = 2, VIDEOBUF_ACTIVE = 3, VIDEOBUF_DONE = 4, VIDEOBUF_ERROR = 5, VIDEOBUF_IDLE = 6 } ; struct videobuf_buffer { unsigned int i ; u32 magic ; unsigned int width ; unsigned int height ; unsigned int bytesperline ; unsigned long size ; unsigned int input ; enum v4l2_field field ; enum videobuf_state state ; struct list_head stream ; struct list_head queue ; wait_queue_head_t done ; unsigned int field_count ; struct timeval ts ; enum v4l2_memory memory ; size_t bsize ; size_t boff ; unsigned long baddr ; struct videobuf_mapping *map ; int privsize ; void *priv ; }; struct videobuf_queue_ops { int (*buf_setup)(struct videobuf_queue *q , unsigned int *count , unsigned int *size ) ; int (*buf_prepare)(struct videobuf_queue *q , struct videobuf_buffer *vb , enum v4l2_field field ) ; void (*buf_queue)(struct videobuf_queue *q , struct videobuf_buffer *vb ) ; void (*buf_release)(struct videobuf_queue *q , struct videobuf_buffer *vb ) ; }; struct videobuf_qtype_ops { u32 magic ; void *(*alloc)(size_t size ) ; void *(*vmalloc)(struct videobuf_buffer *buf ) ; int (*iolock)(struct videobuf_queue *q , struct videobuf_buffer *vb , struct v4l2_framebuffer *fbuf ) ; int (*mmap)(struct videobuf_queue *q , unsigned int *count , unsigned int *size , enum v4l2_memory memory ) ; int (*sync)(struct videobuf_queue *q , struct videobuf_buffer *buf ) ; int (*video_copy_to_user)(struct videobuf_queue *q , char *data , size_t count , int nonblocking ) ; int (*copy_stream)(struct videobuf_queue *q , char *data , size_t count , size_t pos , int vbihack , int nonblocking ) ; int (*mmap_free)(struct videobuf_queue *q ) ; int (*mmap_mapper)(struct videobuf_queue *q , struct vm_area_struct *vma ) ; }; struct videobuf_queue { struct mutex vb_lock ; spinlock_t *irqlock ; struct device *dev ; wait_queue_head_t wait ; enum v4l2_buf_type type ; unsigned int inputs ; unsigned int msize ; enum v4l2_field field ; enum v4l2_field last ; struct videobuf_buffer *bufs[32] ; struct videobuf_queue_ops const *ops ; struct videobuf_qtype_ops *int_ops ; unsigned int streaming : 1 ; unsigned int reading : 1 ; unsigned int is_mmapped : 1 ; struct list_head stream ; unsigned int read_off ; struct videobuf_buffer *read_buf ; void *priv_data ; }; struct videobuf_vmalloc_memory { u32 magic ; void *vmalloc ; struct vm_area_struct *vma ; }; long ldv__builtin_expect(long exp , long c ) ; extern __attribute__((__noreturn__)) int ____ilog2_NaN(void) __attribute__((__const__)) ; extern int ( /* format attribute */ printk)(char const *fmt , ...) ; __inline static int get_order(unsigned long size ) __attribute__((__const__)) ; __inline static int get_order(unsigned long size ) { int order ; { size = (size - 1UL) >> (12 - 1); order = -1; while (1) { size = size >> 1; order = order + 1; if (size) { } else { break; } } return (order); } } void mutex_lock(struct mutex *lock ) ; void mutex_unlock(struct mutex *lock ) ; extern unsigned long __get_free_pages(gfp_t gfp_mask , unsigned int order ) ; extern int param_set_int(char const *val , struct kernel_param *kp ) ; extern int param_get_int(char *buffer , struct kernel_param *kp ) ; __inline static void rcu_read_lock_sched_notrace(void) __attribute__((__no_instrument_function__)) ; __inline static void rcu_read_lock_sched_notrace(void) { { while (1) { break; } return; } } extern void kfree(void const * ) ; extern struct tracepoint __tracepoint_kmalloc ; __inline static void trace_kmalloc(unsigned long call_site , void const *ptr , size_t bytes_req , size_t bytes_alloc , gfp_t gfp_flags ) { void **it_func ; void **_________p1 ; long tmp ; { tmp = ldv__builtin_expect(! (! __tracepoint_kmalloc.state), 0); if (tmp) { while (1) { rcu_read_lock_sched_notrace(); _________p1 = *((void ** volatile *)(& __tracepoint_kmalloc.funcs)); while (1) { break; } it_func = _________p1; if (it_func) { while (1) { (*((void (*)(unsigned long call_site , void const *ptr , size_t bytes_req , size_t bytes_alloc , gfp_t gfp_flags ))*it_func))(call_site, ptr, bytes_req, bytes_alloc, gfp_flags); it_func = it_func + 1; if (*it_func) { } else { break; } } } else { } rcu_read_lock_sched_notrace(); break; } } else { } return; } } __inline static void kmemleak_alloc(void const *ptr , size_t size , int min_count , gfp_t gfp ) { { return; } } extern struct kmem_cache kmalloc_caches[12 + 2] ; __inline static int ( __attribute__((__always_inline__)) kmalloc_index)(size_t size ) { int tmp ; int tmp___0 ; int 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 ; int tmp___13 ; int tmp___14 ; int tmp___15 ; int tmp___16 ; int tmp___17 ; int tmp___18 ; int tmp___19 ; int tmp___20 ; int tmp___21 ; int tmp___22 ; int tmp___23 ; int tmp___24 ; int tmp___25 ; int tmp___26 ; int tmp___27 ; int tmp___28 ; int tmp___29 ; int tmp___30 ; int tmp___31 ; int tmp___32 ; int tmp___33 ; int tmp___34 ; int tmp___35 ; int tmp___36 ; int tmp___37 ; int tmp___38 ; int tmp___39 ; int tmp___40 ; int tmp___41 ; int tmp___42 ; int tmp___43 ; int tmp___44 ; int tmp___45 ; int tmp___46 ; int tmp___47 ; int tmp___48 ; int tmp___49 ; int tmp___50 ; int tmp___51 ; int tmp___52 ; int tmp___53 ; int tmp___54 ; int tmp___55 ; int tmp___56 ; int tmp___57 ; int tmp___58 ; int tmp___59 ; int tmp___60 ; int tmp___61 ; int tmp___62 ; int tmp___63 ; int tmp___64 ; int tmp___65 ; { if (! size) { return (0); } else { } if (size <= (size_t )8) { if (8 < 1) { tmp = ____ilog2_NaN(); tmp___65 = tmp; } else { if (8ULL & (1ULL << 63)) { tmp___64 = 63; } else { if (8ULL & (1ULL << 62)) { tmp___63 = 62; } else { if (8ULL & (1ULL << 61)) { tmp___62 = 61; } else { if (8ULL & (1ULL << 60)) { tmp___61 = 60; } else { if (8ULL & (1ULL << 59)) { tmp___60 = 59; } else { if (8ULL & (1ULL << 58)) { tmp___59 = 58; } else { if (8ULL & (1ULL << 57)) { tmp___58 = 57; } else { if (8ULL & (1ULL << 56)) { tmp___57 = 56; } else { if (8ULL & (1ULL << 55)) { tmp___56 = 55; } else { if (8ULL & (1ULL << 54)) { tmp___55 = 54; } else { if (8ULL & (1ULL << 53)) { tmp___54 = 53; } else { if (8ULL & (1ULL << 52)) { tmp___53 = 52; } else { if (8ULL & (1ULL << 51)) { tmp___52 = 51; } else { if (8ULL & (1ULL << 50)) { tmp___51 = 50; } else { if (8ULL & (1ULL << 49)) { tmp___50 = 49; } else { if (8ULL & (1ULL << 48)) { tmp___49 = 48; } else { if (8ULL & (1ULL << 47)) { tmp___48 = 47; } else { if (8ULL & (1ULL << 46)) { tmp___47 = 46; } else { if (8ULL & (1ULL << 45)) { tmp___46 = 45; } else { if (8ULL & (1ULL << 44)) { tmp___45 = 44; } else { if (8ULL & (1ULL << 43)) { tmp___44 = 43; } else { if (8ULL & (1ULL << 42)) { tmp___43 = 42; } else { if (8ULL & (1ULL << 41)) { tmp___42 = 41; } else { if (8ULL & (1ULL << 40)) { tmp___41 = 40; } else { if (8ULL & (1ULL << 39)) { tmp___40 = 39; } else { if (8ULL & (1ULL << 38)) { tmp___39 = 38; } else { if (8ULL & (1ULL << 37)) { tmp___38 = 37; } else { if (8ULL & (1ULL << 36)) { tmp___37 = 36; } else { if (8ULL & (1ULL << 35)) { tmp___36 = 35; } else { if (8ULL & (1ULL << 34)) { tmp___35 = 34; } else { if (8ULL & (1ULL << 33)) { tmp___34 = 33; } else { if (8ULL & (1ULL << 32)) { tmp___33 = 32; } else { if (8ULL & (1ULL << 31)) { tmp___32 = 31; } else { if (8ULL & (1ULL << 30)) { tmp___31 = 30; } else { if (8ULL & (1ULL << 29)) { tmp___30 = 29; } else { if (8ULL & (1ULL << 28)) { tmp___29 = 28; } else { if (8ULL & (1ULL << 27)) { tmp___28 = 27; } else { if (8ULL & (1ULL << 26)) { tmp___27 = 26; } else { if (8ULL & (1ULL << 25)) { tmp___26 = 25; } else { if (8ULL & (1ULL << 24)) { tmp___25 = 24; } else { if (8ULL & (1ULL << 23)) { tmp___24 = 23; } else { if (8ULL & (1ULL << 22)) { tmp___23 = 22; } else { if (8ULL & (1ULL << 21)) { tmp___22 = 21; } else { if (8ULL & (1ULL << 20)) { tmp___21 = 20; } else { if (8ULL & (1ULL << 19)) { tmp___20 = 19; } else { if (8ULL & (1ULL << 18)) { tmp___19 = 18; } else { if (8ULL & (1ULL << 17)) { tmp___18 = 17; } else { if (8ULL & (1ULL << 16)) { tmp___17 = 16; } else { if (8ULL & (1ULL << 15)) { tmp___16 = 15; } else { if (8ULL & (1ULL << 14)) { tmp___15 = 14; } else { if (8ULL & (1ULL << 13)) { tmp___14 = 13; } else { if (8ULL & (1ULL << 12)) { tmp___13 = 12; } else { if (8ULL & (1ULL << 11)) { tmp___12 = 11; } else { if (8ULL & (1ULL << 10)) { tmp___11 = 10; } else { if (8ULL & (1ULL << 9)) { tmp___10 = 9; } else { if (8ULL & (1ULL << 8)) { tmp___9 = 8; } else { if (8ULL & (1ULL << 7)) { tmp___8 = 7; } else { if (8ULL & (1ULL << 6)) { tmp___7 = 6; } else { if (8ULL & (1ULL << 5)) { tmp___6 = 5; } else { if (8ULL & (1ULL << 4)) { tmp___5 = 4; } else { if (8ULL & (1ULL << 3)) { tmp___4 = 3; } else { if (8ULL & (1ULL << 2)) { tmp___3 = 2; } else { if (8ULL & (1ULL << 1)) { tmp___2 = 1; } else { if (8ULL & (1ULL << 0)) { tmp___1 = 0; } else { tmp___0 = ____ilog2_NaN(); tmp___1 = tmp___0; } tmp___2 = tmp___1; } tmp___3 = tmp___2; } tmp___4 = tmp___3; } tmp___5 = tmp___4; } tmp___6 = tmp___5; } tmp___7 = tmp___6; } tmp___8 = tmp___7; } tmp___9 = tmp___8; } tmp___10 = tmp___9; } tmp___11 = tmp___10; } tmp___12 = tmp___11; } tmp___13 = tmp___12; } tmp___14 = tmp___13; } tmp___15 = tmp___14; } tmp___16 = tmp___15; } tmp___17 = tmp___16; } tmp___18 = tmp___17; } tmp___19 = tmp___18; } tmp___20 = tmp___19; } tmp___21 = tmp___20; } tmp___22 = tmp___21; } tmp___23 = tmp___22; } tmp___24 = tmp___23; } tmp___25 = tmp___24; } tmp___26 = tmp___25; } tmp___27 = tmp___26; } tmp___28 = tmp___27; } tmp___29 = tmp___28; } tmp___30 = tmp___29; } tmp___31 = tmp___30; } tmp___32 = tmp___31; } tmp___33 = tmp___32; } tmp___34 = tmp___33; } tmp___35 = tmp___34; } tmp___36 = tmp___35; } tmp___37 = tmp___36; } tmp___38 = tmp___37; } tmp___39 = tmp___38; } tmp___40 = tmp___39; } tmp___41 = tmp___40; } tmp___42 = tmp___41; } tmp___43 = tmp___42; } tmp___44 = tmp___43; } tmp___45 = tmp___44; } tmp___46 = tmp___45; } tmp___47 = tmp___46; } tmp___48 = tmp___47; } tmp___49 = tmp___48; } tmp___50 = tmp___49; } tmp___51 = tmp___50; } tmp___52 = tmp___51; } tmp___53 = tmp___52; } tmp___54 = tmp___53; } tmp___55 = tmp___54; } tmp___56 = tmp___55; } tmp___57 = tmp___56; } tmp___58 = tmp___57; } tmp___59 = tmp___58; } tmp___60 = tmp___59; } tmp___61 = tmp___60; } tmp___62 = tmp___61; } tmp___63 = tmp___62; } tmp___64 = tmp___63; } tmp___65 = tmp___64; } return (tmp___65); } else { } if ((8 <= 32 && size > (size_t )64) && size <= (size_t )96) { return (1); } else { } if ((8 <= 64 && size > (size_t )128) && size <= (size_t )192) { return (2); } else { } if (size <= (size_t )8) { return (3); } else { } if (size <= (size_t )16) { return (4); } else { } if (size <= (size_t )32) { return (5); } else { } if (size <= (size_t )64) { return (6); } else { } if (size <= (size_t )128) { return (7); } else { } if (size <= (size_t )256) { return (8); } else { } if (size <= (size_t )512) { return (9); } else { } if (size <= (size_t )1024) { return (10); } else { } if (size <= (size_t )(2 * 1024)) { return (11); } else { } if (size <= (size_t )(4 * 1024)) { return (12); } else { } if (size <= (size_t )(8 * 1024)) { return (13); } else { } if (size <= (size_t )(16 * 1024)) { return (14); } else { } if (size <= (size_t )(32 * 1024)) { return (15); } else { } if (size <= (size_t )(64 * 1024)) { return (16); } else { } if (size <= (size_t )(128 * 1024)) { return (17); } else { } if (size <= (size_t )(256 * 1024)) { return (18); } else { } if (size <= (size_t )(512 * 1024)) { return (19); } else { } if (size <= (size_t )(1024 * 1024)) { return (20); } else { } if (size <= (size_t )((2 * 1024) * 1024)) { return (21); } else { } return (-1); } } __inline static struct kmem_cache *( __attribute__((__always_inline__)) kmalloc_slab)(size_t size ) { int index ; int tmp ; { tmp = kmalloc_index(size); index = tmp; if (index == 0) { return ((void *)0); } else { } return (& kmalloc_caches[index]); } } extern void *kmem_cache_alloc(struct kmem_cache * , gfp_t ) ; extern void *__kmalloc(size_t size , gfp_t flags ) ; __inline static void *( __attribute__((__always_inline__)) kmem_cache_alloc_notrace)(struct kmem_cache *s , gfp_t gfpflags ) { void *tmp ; { tmp = kmem_cache_alloc(s, gfpflags); return (tmp); } } __inline static void *( __attribute__((__always_inline__)) kmalloc_large)(size_t size , gfp_t flags ) { unsigned int order ; int tmp ; void *ret ; unsigned long tmp___0 ; { tmp = get_order(size); order = tmp; tmp___0 = __get_free_pages(flags | 16384U, order); ret = (void *)tmp___0; kmemleak_alloc(ret, size, 1, flags); trace_kmalloc((unsigned long )((void *)0), ret, size, (1UL << 12) << order, flags); return (ret); } } __inline static void *( __attribute__((__always_inline__)) kmalloc)(size_t size , gfp_t flags ) { void *ret ; void *tmp ; struct kmem_cache *s ; struct kmem_cache *tmp___0 ; void *tmp___1 ; { if (0) { if (size > 2UL * (1UL << 12)) { tmp = kmalloc_large(size, flags); return (tmp); } else { } if (! (flags & 1U)) { tmp___0 = kmalloc_slab(size); s = tmp___0; if (! s) { return ((void *)16); } else { } ret = kmem_cache_alloc_notrace(s, flags); trace_kmalloc((unsigned long )((void *)0), ret, size, s->size, flags); return (ret); } else { } } else { } tmp___1 = __kmalloc(size, flags); return (tmp___1); } } __inline static void *kzalloc(size_t size , gfp_t flags ) { void *tmp ; { tmp = kmalloc(size, flags | 32768U); return (tmp); } } extern void *vmalloc_user(unsigned long size ) ; extern void vfree(void const *addr ) ; extern int remap_vmalloc_range(struct vm_area_struct *vma , void *addr , unsigned long pgoff ) ; extern unsigned long ( __attribute__((__warn_unused_result__)) copy_to_user)(void *to , void const *from , unsigned int len ) ; extern void videobuf_queue_core_init(struct videobuf_queue *q , struct videobuf_queue_ops const *ops , struct device *dev , spinlock_t *irqlock , enum v4l2_buf_type type , enum v4l2_field field , unsigned int msize , void *priv , struct videobuf_qtype_ops *int_ops ) ; extern void videobuf_queue_cancel(struct videobuf_queue *q ) ; void videobuf_queue_vmalloc_init(struct videobuf_queue *q , struct videobuf_queue_ops const *ops , void *dev , spinlock_t *irqlock , enum v4l2_buf_type type , enum v4l2_field field , unsigned int msize , void *priv ) ; void *videobuf_to_vmalloc(struct videobuf_buffer *buf ) ; void videobuf_vmalloc_free(struct videobuf_buffer *buf ) ; static int debug ; static char const __param_str_debug[6] = { 'd', 'e', 'b', 'u', 'g', '\000'}; static struct kernel_param const __param_debug __attribute__((__used__, __unused__, __section__("__param"), __aligned__(sizeof(void *)))) = {__param_str_debug, 420, 0, & param_set_int, & param_get_int, {& debug}}; static char const __mod_debugtype38[19] __attribute__((__used__, __unused__, __section__(".modinfo"))) = { 'p', 'a', 'r', 'm', 't', 'y', 'p', 'e', '=', 'd', 'e', 'b', 'u', 'g', ':', 'i', 'n', 't', '\000'}; static char const __mod_description40[64] __attribute__((__used__, __unused__, __section__(".modinfo"))) = { 'd', 'e', 's', 'c', 'r', 'i', 'p', 't', 'i', 'o', 'n', '=', 'h', 'e', 'l', 'p', 'e', 'r', ' ', 'm', 'o', 'd', 'u', 'l', 'e', ' ', 't', 'o', ' ', 'm', 'a', 'n', 'a', 'g', 'e', ' ', 'v', 'i', 'd', 'e', 'o', '4', 'l', 'i', 'n', 'u', 'x', ' ', 'v', 'm', 'a', 'l', 'l', 'o', 'c', ' ', 'b', 'u', 'f', 'f', 'e', 'r', 's', '\000'}; static char const __mod_author41[53] __attribute__((__used__, __unused__, __section__(".modinfo"))) = { 'a', 'u', 't', 'h', 'o', 'r', '=', 'M', 'a', 'u', 'r', 'o', ' ', 'C', 'a', 'r', 'v', 'a', 'l', 'h', 'o', ' ', 'C', 'h', 'e', 'h', 'a', 'b', ' ', '<', 'm', 'c', 'h', 'e', 'h', 'a', 'b', '@', 'i', 'n', 'f', 'r', 'a', 'd', 'e', 'a', 'd', '.', 'o', 'r', 'g', '>', '\000'}; static char const __mod_license42[12] __attribute__((__used__, __unused__, __section__(".modinfo"))) = { 'l', 'i', 'c', 'e', 'n', 's', 'e', '=', 'G', 'P', 'L', '\000'}; static void videobuf_vm_open(struct vm_area_struct *vma ) { struct videobuf_mapping *map ; { map = vma->vm_private_data; if (debug >= 2) { printk("<7>vbuf-vmalloc: vm_open %p [count=%u,vma=%08lx-%08lx]\n", map, map->count, vma->vm_start, vma->vm_end); } else { } map->count = map->count + 1U; return; } } static void videobuf_vm_close(struct vm_area_struct *vma ) { struct videobuf_mapping *map ; struct videobuf_queue *q ; int i ; struct videobuf_vmalloc_memory *mem ; long tmp ; { map = vma->vm_private_data; q = map->q; if (debug >= 2) { printk("<7>vbuf-vmalloc: vm_close %p [count=%u,vma=%08lx-%08lx]\n", map, map->count, vma->vm_start, vma->vm_end); } else { } map->count = map->count - 1U; if (0U == map->count) { if (debug >= 1) { printk("<7>vbuf-vmalloc: munmap %p q=%p\n", map, q); } else { } mutex_lock(& q->vb_lock); if (q->streaming) { videobuf_queue_cancel(q); } else { } i = 0; while (1) { if (i < 32) { } else { break; } if ((unsigned long )((void *)0) == (unsigned long )q->bufs[i]) { goto __Cont; } else { } if ((unsigned long )(q->bufs[i])->map != (unsigned long )map) { goto __Cont; } else { } mem = (q->bufs[i])->priv; if (mem) { tmp = ldv__builtin_expect(! (! (mem->magic != (u32 )404886051)), 0); if (tmp) { printk("<3>magic mismatch: %x (expected %x)\n", mem->magic, 404886051); while (1) { __asm__ volatile ("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection": : "i" ("/work/ldvuser/novikov/work/current--X--drivers/media/video/videobuf-vmalloc.ko--X--defaultlinux--X--32_1--X--cpachecker/linux/csd_deg_dscv/11/dscv_tempdir/dscv/ri/32_1/drivers/media/video/videobuf-vmalloc.c"), "i" (96), "i" (sizeof(struct bug_entry ))); while (1) { } break; } } else { } if (debug >= 1) { printk("<7>vbuf-vmalloc: %s: buf[%d] freeing (%p)\n", "videobuf_vm_close", i, mem->vmalloc); } else { } vfree(mem->vmalloc); mem->vmalloc = (void *)0; } else { } (q->bufs[i])->map = (void *)0; (q->bufs[i])->baddr = 0; __Cont: /* CIL Label */ i = i + 1; } kfree(map); mutex_unlock(& q->vb_lock); } else { } return; } } static struct vm_operations_struct const videobuf_vm_ops = {& videobuf_vm_open, & videobuf_vm_close, 0, 0, 0, 0, 0, 0}; static void *__videobuf_alloc(size_t size ) { struct videobuf_vmalloc_memory *mem ; struct videobuf_buffer *vb ; void *tmp ; void *tmp___0 ; { tmp = kzalloc(size + sizeof(*mem), (16U | 64U) | 128U); vb = tmp; tmp___0 = (char *)vb + size; vb->priv = tmp___0; mem = tmp___0; mem->magic = 404886051; if (debug >= 1) { printk("<7>vbuf-vmalloc: %s: allocated at %p(%ld+%ld) & %p(%ld)\n", "__videobuf_alloc", vb, (long )sizeof(*vb), (unsigned long )((long )size) - sizeof(*vb), mem, (long )sizeof(*mem)); } else { } return (vb); } } static int __videobuf_iolock(struct videobuf_queue *q , struct videobuf_buffer *vb , struct v4l2_framebuffer *fbuf ) { struct videobuf_vmalloc_memory *mem ; int pages ; long tmp ; long tmp___0 ; { mem = vb->priv; while (1) { tmp = ldv__builtin_expect(! (! (! mem)), 0); if (tmp) { while (1) { __asm__ volatile ("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection": : "i" ("/work/ldvuser/novikov/work/current--X--drivers/media/video/videobuf-vmalloc.ko--X--defaultlinux--X--32_1--X--cpachecker/linux/csd_deg_dscv/11/dscv_tempdir/dscv/ri/32_1/drivers/media/video/videobuf-vmalloc.c"), "i" (160), "i" (sizeof(struct bug_entry ))); while (1) { } break; } } else { } break; } tmp___0 = ldv__builtin_expect(! (! (mem->magic != (u32 )404886051)), 0); if (tmp___0) { printk("<3>magic mismatch: %x (expected %x)\n", mem->magic, 404886051); while (1) { __asm__ volatile ("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection": : "i" ("/work/ldvuser/novikov/work/current--X--drivers/media/video/videobuf-vmalloc.ko--X--defaultlinux--X--32_1--X--cpachecker/linux/csd_deg_dscv/11/dscv_tempdir/dscv/ri/32_1/drivers/media/video/videobuf-vmalloc.c"), "i" (162), "i" (sizeof(struct bug_entry ))); while (1) { } break; } } else { } switch ((unsigned int )vb->memory) { case (unsigned int )V4L2_MEMORY_MMAP: if (debug >= 1) { printk("<7>vbuf-vmalloc: %s memory method MMAP\n", "__videobuf_iolock"); } else { } if (! mem->vmalloc) { printk("<3>memory is not alloced/mmapped.\n"); return (-22); } else { } break; case (unsigned int )V4L2_MEMORY_USERPTR: pages = (vb->size + ((1UL << 12) - 1UL)) & ~ ((1UL << 12) - 1UL); if (debug >= 1) { printk("<7>vbuf-vmalloc: %s memory method USERPTR\n", "__videobuf_iolock"); } else { } if (vb->baddr) { printk("<3>USERPTR is currently not supported\n"); return (-22); } else { } mem->vmalloc = vmalloc_user(pages); if (! mem->vmalloc) { printk("<3>vmalloc (%d pages) failed\n", pages); return (-12); } else { } if (debug >= 1) { printk("<7>vbuf-vmalloc: vmalloc is at addr %p (%d pages)\n", mem->vmalloc, pages); } else { } break; default: if (debug >= 1) { printk("<7>vbuf-vmalloc: %s memory method OVERLAY/unknown\n", "__videobuf_iolock"); } else { } printk("<3>Memory method currently unsupported.\n"); return (-22); } return (0); } } static int __videobuf_sync(struct videobuf_queue *q , struct videobuf_buffer *buf ) { { return (0); } } static int __videobuf_mmap_free(struct videobuf_queue *q ) { unsigned int i ; { if (debug >= 1) { printk("<7>vbuf-vmalloc: %s\n", "__videobuf_mmap_free"); } else { } i = 0; while (1) { if (i < 32U) { } else { break; } if (q->bufs[i]) { if ((q->bufs[i])->map) { return (-16); } else { } } else { } i = i + 1U; } return (0); } } static int __videobuf_mmap_mapper(struct videobuf_queue *q , struct vm_area_struct *vma ) { struct videobuf_vmalloc_memory *mem ; struct videobuf_mapping *map ; unsigned int first ; int retval ; int pages ; unsigned long offset ; void *tmp ; long tmp___0 ; long tmp___1 ; { offset = vma->vm_pgoff << 12; if (debug >= 1) { printk("<7>vbuf-vmalloc: %s\n", "__videobuf_mmap_mapper"); } else { } if (! (vma->vm_flags & 2UL) || ! (vma->vm_flags & 8UL)) { return (-22); } else { } first = 0; while (1) { if (first < 32U) { } else { break; } if ((unsigned long )((void *)0) == (unsigned long )q->bufs[first]) { goto __Cont; } else { } if ((unsigned int )V4L2_MEMORY_MMAP != (unsigned int )(q->bufs[first])->memory) { goto __Cont; } else { } if ((q->bufs[first])->boff == offset) { break; } else { } __Cont: /* CIL Label */ first = first + 1U; } if (32U == first) { if (debug >= 1) { printk("<7>vbuf-vmalloc: mmap app bug: offset invalid [offset=0x%lx]\n", vma->vm_pgoff << 12); } else { } return (-22); } else { } tmp = kzalloc(sizeof(struct videobuf_mapping ), (16U | 64U) | 128U); map = tmp; if ((unsigned long )((void *)0) == (unsigned long )map) { return (-12); } else { } (q->bufs[first])->map = map; map->start = vma->vm_start; map->end = vma->vm_end; map->q = q; (q->bufs[first])->baddr = vma->vm_start; mem = (q->bufs[first])->priv; while (1) { tmp___0 = ldv__builtin_expect(! (! (! mem)), 0); if (tmp___0) { while (1) { __asm__ volatile ("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection": : "i" ("/work/ldvuser/novikov/work/current--X--drivers/media/video/videobuf-vmalloc.ko--X--defaultlinux--X--32_1--X--cpachecker/linux/csd_deg_dscv/11/dscv_tempdir/dscv/ri/32_1/drivers/media/video/videobuf-vmalloc.c"), "i" (293), "i" (sizeof(struct bug_entry ))); while (1) { } break; } } else { } break; } tmp___1 = ldv__builtin_expect(! (! (mem->magic != (u32 )404886051)), 0); if (tmp___1) { printk("<3>magic mismatch: %x (expected %x)\n", mem->magic, 404886051); while (1) { __asm__ volatile ("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection": : "i" ("/work/ldvuser/novikov/work/current--X--drivers/media/video/videobuf-vmalloc.ko--X--defaultlinux--X--32_1--X--cpachecker/linux/csd_deg_dscv/11/dscv_tempdir/dscv/ri/32_1/drivers/media/video/videobuf-vmalloc.c"), "i" (294), "i" (sizeof(struct bug_entry ))); while (1) { } break; } } else { } pages = ((vma->vm_end - vma->vm_start) + ((1UL << 12) - 1UL)) & ~ ((1UL << 12) - 1UL); mem->vmalloc = vmalloc_user(pages); if (! mem->vmalloc) { printk("<3>vmalloc (%d pages) failed\n", pages); goto error; } else { } if (debug >= 1) { printk("<7>vbuf-vmalloc: vmalloc is at addr %p (%d pages)\n", mem->vmalloc, pages); } else { } retval = remap_vmalloc_range(vma, mem->vmalloc, 0); if (retval < 0) { printk("<3>mmap: remap failed with error %d. ", retval); vfree(mem->vmalloc); goto error; } else { } vma->vm_ops = & videobuf_vm_ops; vma->vm_flags = vma->vm_flags | (unsigned long )(262144 | 524288); vma->vm_private_data = map; if (debug >= 1) { printk("<7>vbuf-vmalloc: mmap %p: q=%p %08lx-%08lx (%lx) pgoff %08lx buf %d\n", map, q, vma->vm_start, vma->vm_end, (long )(q->bufs[first])->bsize, vma->vm_pgoff, first); } else { } videobuf_vm_open(vma); return (0); error: mem = (void *)0; kfree(map); return (-12); } } static int __videobuf_copy_to_user(struct videobuf_queue *q , char *data , size_t count , int nonblocking ) { struct videobuf_vmalloc_memory *mem ; long tmp ; long tmp___0 ; long tmp___1 ; unsigned long tmp___2 ; { mem = (q->read_buf)->priv; while (1) { tmp = ldv__builtin_expect(! (! (! mem)), 0); if (tmp) { while (1) { __asm__ volatile ("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection": : "i" ("/work/ldvuser/novikov/work/current--X--drivers/media/video/videobuf-vmalloc.ko--X--defaultlinux--X--32_1--X--cpachecker/linux/csd_deg_dscv/11/dscv_tempdir/dscv/ri/32_1/drivers/media/video/videobuf-vmalloc.c"), "i" (337), "i" (sizeof(struct bug_entry ))); while (1) { } break; } } else { } break; } tmp___0 = ldv__builtin_expect(! (! (mem->magic != (u32 )404886051)), 0); if (tmp___0) { printk("<3>magic mismatch: %x (expected %x)\n", mem->magic, 404886051); while (1) { __asm__ volatile ("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection": : "i" ("/work/ldvuser/novikov/work/current--X--drivers/media/video/videobuf-vmalloc.ko--X--defaultlinux--X--32_1--X--cpachecker/linux/csd_deg_dscv/11/dscv_tempdir/dscv/ri/32_1/drivers/media/video/videobuf-vmalloc.c"), "i" (338), "i" (sizeof(struct bug_entry ))); while (1) { } break; } } else { } while (1) { tmp___1 = ldv__builtin_expect(! (! (! mem->vmalloc)), 0); if (tmp___1) { while (1) { __asm__ volatile ("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection": : "i" ("/work/ldvuser/novikov/work/current--X--drivers/media/video/videobuf-vmalloc.ko--X--defaultlinux--X--32_1--X--cpachecker/linux/csd_deg_dscv/11/dscv_tempdir/dscv/ri/32_1/drivers/media/video/videobuf-vmalloc.c"), "i" (340), "i" (sizeof(struct bug_entry ))); while (1) { } break; } } else { } break; } if (count > (q->read_buf)->size - (unsigned long )q->read_off) { count = (q->read_buf)->size - (unsigned long )q->read_off; } else { } tmp___2 = copy_to_user(data, mem->vmalloc + q->read_off, count); if (tmp___2) { return (-14); } else { } return (count); } } static int __videobuf_copy_stream(struct videobuf_queue *q , char *data , size_t count , size_t pos , int vbihack , int nonblocking ) { unsigned int *fc ; struct videobuf_vmalloc_memory *mem ; long tmp ; long tmp___0 ; int tmp___1 ; { mem = (q->read_buf)->priv; while (1) { tmp = ldv__builtin_expect(! (! (! mem)), 0); if (tmp) { while (1) { __asm__ volatile ("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection": : "i" ("/work/ldvuser/novikov/work/current--X--drivers/media/video/videobuf-vmalloc.ko--X--defaultlinux--X--32_1--X--cpachecker/linux/csd_deg_dscv/11/dscv_tempdir/dscv/ri/32_1/drivers/media/video/videobuf-vmalloc.c"), "i" (358), "i" (sizeof(struct bug_entry ))); while (1) { } break; } } else { } break; } tmp___0 = ldv__builtin_expect(! (! (mem->magic != (u32 )404886051)), 0); if (tmp___0) { printk("<3>magic mismatch: %x (expected %x)\n", mem->magic, 404886051); while (1) { __asm__ volatile ("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection": : "i" ("/work/ldvuser/novikov/work/current--X--drivers/media/video/videobuf-vmalloc.ko--X--defaultlinux--X--32_1--X--cpachecker/linux/csd_deg_dscv/11/dscv_tempdir/dscv/ri/32_1/drivers/media/video/videobuf-vmalloc.c"), "i" (359), "i" (sizeof(struct bug_entry ))); while (1) { } break; } } else { } if (vbihack) { fc = (unsigned int *)mem->vmalloc; fc = fc + (((q->read_buf)->size >> 2) - 1UL); *fc = (q->read_buf)->field_count >> 1; if (debug >= 1) { printk("<7>vbuf-vmalloc: vbihack: %d\n", *fc); } else { } } else { } tmp___1 = __videobuf_copy_to_user(q, data, count, nonblocking); count = tmp___1; if (count == (size_t )-14 && (size_t )0 == pos) { return (-14); } else { } return (count); } } static struct videobuf_qtype_ops qops = {304484355, & __videobuf_alloc, & videobuf_to_vmalloc, & __videobuf_iolock, 0, & __videobuf_sync, & __videobuf_copy_to_user, & __videobuf_copy_stream, & __videobuf_mmap_free, & __videobuf_mmap_mapper}; void videobuf_queue_vmalloc_init(struct videobuf_queue *q , struct videobuf_queue_ops const *ops , void *dev , spinlock_t *irqlock , enum v4l2_buf_type type , enum v4l2_field field , unsigned int msize , void *priv ) { { videobuf_queue_core_init(q, ops, dev, irqlock, type, field, msize, priv, & qops); return; } } extern void *__crc_videobuf_queue_vmalloc_init __attribute__((__weak__)) ; static unsigned long const __kcrctab_videobuf_queue_vmalloc_init __attribute__((__used__, __unused__, __section__("__kcrctab_gpl"))) = (unsigned long )(& __crc_videobuf_queue_vmalloc_init); static char const __kstrtab_videobuf_queue_vmalloc_init[28] __attribute__((__section__("__ksymtab_strings"), __aligned__(1))) = { 'v', 'i', 'd', 'e', 'o', 'b', 'u', 'f', '_', 'q', 'u', 'e', 'u', 'e', '_', 'v', 'm', 'a', 'l', 'l', 'o', 'c', '_', 'i', 'n', 'i', 't', '\000'}; static struct kernel_symbol const __ksymtab_videobuf_queue_vmalloc_init __attribute__((__used__, __unused__, __section__("__ksymtab_gpl"))) = {(unsigned long )(& videobuf_queue_vmalloc_init), __kstrtab_videobuf_queue_vmalloc_init}; void *videobuf_to_vmalloc(struct videobuf_buffer *buf ) { struct videobuf_vmalloc_memory *mem ; long tmp ; long tmp___0 ; { mem = buf->priv; while (1) { tmp = ldv__builtin_expect(! (! (! mem)), 0); if (tmp) { while (1) { __asm__ volatile ("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection": : "i" ("/work/ldvuser/novikov/work/current--X--drivers/media/video/videobuf-vmalloc.ko--X--defaultlinux--X--32_1--X--cpachecker/linux/csd_deg_dscv/11/dscv_tempdir/dscv/ri/32_1/drivers/media/video/videobuf-vmalloc.c"), "i" (412), "i" (sizeof(struct bug_entry ))); while (1) { } break; } } else { } break; } tmp___0 = ldv__builtin_expect(! (! (mem->magic != (u32 )404886051)), 0); if (tmp___0) { printk("<3>magic mismatch: %x (expected %x)\n", mem->magic, 404886051); while (1) { __asm__ volatile ("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection": : "i" ("/work/ldvuser/novikov/work/current--X--drivers/media/video/videobuf-vmalloc.ko--X--defaultlinux--X--32_1--X--cpachecker/linux/csd_deg_dscv/11/dscv_tempdir/dscv/ri/32_1/drivers/media/video/videobuf-vmalloc.c"), "i" (413), "i" (sizeof(struct bug_entry ))); while (1) { } break; } } else { } return (mem->vmalloc); } } extern void *__crc_videobuf_to_vmalloc __attribute__((__weak__)) ; static unsigned long const __kcrctab_videobuf_to_vmalloc __attribute__((__used__, __unused__, __section__("__kcrctab_gpl"))) = (unsigned long )(& __crc_videobuf_to_vmalloc); static char const __kstrtab_videobuf_to_vmalloc[20] __attribute__((__section__("__ksymtab_strings"), __aligned__(1))) = { 'v', 'i', 'd', 'e', 'o', 'b', 'u', 'f', '_', 't', 'o', '_', 'v', 'm', 'a', 'l', 'l', 'o', 'c', '\000'}; static struct kernel_symbol const __ksymtab_videobuf_to_vmalloc __attribute__((__used__, __unused__, __section__("__ksymtab_gpl"))) = {(unsigned long )(& videobuf_to_vmalloc), __kstrtab_videobuf_to_vmalloc}; void videobuf_vmalloc_free(struct videobuf_buffer *buf ) { struct videobuf_vmalloc_memory *mem ; long tmp ; { mem = buf->priv; if ((unsigned int )buf->memory != (unsigned int )V4L2_MEMORY_USERPTR || buf->baddr) { return; } else { } if (! mem) { return; } else { } tmp = ldv__builtin_expect(! (! (mem->magic != (u32 )404886051)), 0); if (tmp) { printk("<3>magic mismatch: %x (expected %x)\n", mem->magic, 404886051); while (1) { __asm__ volatile ("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection": : "i" ("/work/ldvuser/novikov/work/current--X--drivers/media/video/videobuf-vmalloc.ko--X--defaultlinux--X--32_1--X--cpachecker/linux/csd_deg_dscv/11/dscv_tempdir/dscv/ri/32_1/drivers/media/video/videobuf-vmalloc.c"), "i" (435), "i" (sizeof(struct bug_entry ))); while (1) { } break; } } else { } vfree(mem->vmalloc); mem->vmalloc = (void *)0; return; } } extern void *__crc_videobuf_vmalloc_free __attribute__((__weak__)) ; static unsigned long const __kcrctab_videobuf_vmalloc_free __attribute__((__used__, __unused__, __section__("__kcrctab_gpl"))) = (unsigned long )(& __crc_videobuf_vmalloc_free); static char const __kstrtab_videobuf_vmalloc_free[22] __attribute__((__section__("__ksymtab_strings"), __aligned__(1))) = { 'v', 'i', 'd', 'e', 'o', 'b', 'u', 'f', '_', 'v', 'm', 'a', 'l', 'l', 'o', 'c', '_', 'f', 'r', 'e', 'e', '\000'}; static struct kernel_symbol const __ksymtab_videobuf_vmalloc_free __attribute__((__used__, __unused__, __section__("__ksymtab_gpl"))) = {(unsigned long )(& videobuf_vmalloc_free), __kstrtab_videobuf_vmalloc_free}; void ldv_check_final_state(void) ; extern void ldv_initialize(void) ; extern void ldv_handler_precall(void) ; extern int nondet_int(void) ; int LDV_IN_INTERRUPT ; int main(void) { struct vm_area_struct *var_group1 ; size_t var___videobuf_alloc_2_p0 ; struct videobuf_queue *var_group2 ; struct videobuf_buffer *var_group3 ; struct v4l2_framebuffer *var___videobuf_iolock_3_p2 ; struct videobuf_queue *var_group4 ; char *var___videobuf_copy_to_user_7_p1 ; size_t var___videobuf_copy_to_user_7_p2 ; int var___videobuf_copy_to_user_7_p3 ; char *var___videobuf_copy_stream_8_p1 ; size_t var___videobuf_copy_stream_8_p2 ; size_t var___videobuf_copy_stream_8_p3 ; int var___videobuf_copy_stream_8_p4 ; int var___videobuf_copy_stream_8_p5 ; int ldv_s_videobuf_vm_ops_vm_operations_struct ; int tmp ; int tmp___0 ; { LDV_IN_INTERRUPT = 1; ldv_initialize(); ldv_s_videobuf_vm_ops_vm_operations_struct = 0; while (1) { tmp___0 = nondet_int(); if (tmp___0 || ! (ldv_s_videobuf_vm_ops_vm_operations_struct == 0)) { } else { break; } tmp = nondet_int(); switch (tmp) { case 0: if (ldv_s_videobuf_vm_ops_vm_operations_struct == 0) { ldv_handler_precall(); videobuf_vm_open(var_group1); ldv_s_videobuf_vm_ops_vm_operations_struct = ldv_s_videobuf_vm_ops_vm_operations_struct + 1; } else { } break; case 1: if (ldv_s_videobuf_vm_ops_vm_operations_struct == 1) { ldv_handler_precall(); videobuf_vm_close(var_group1); ldv_s_videobuf_vm_ops_vm_operations_struct = 0; } else { } break; case 2: ldv_handler_precall(); __videobuf_alloc(var___videobuf_alloc_2_p0); break; case 3: ldv_handler_precall(); __videobuf_iolock(var_group2, var_group3, var___videobuf_iolock_3_p2); break; case 4: ldv_handler_precall(); __videobuf_sync(var_group4, var_group3); break; case 5: ldv_handler_precall(); __videobuf_mmap_free(var_group4); break; case 6: ldv_handler_precall(); __videobuf_mmap_mapper(var_group4, var_group1); break; case 7: ldv_handler_precall(); __videobuf_copy_to_user(var_group4, var___videobuf_copy_to_user_7_p1, var___videobuf_copy_to_user_7_p2, var___videobuf_copy_to_user_7_p3); break; case 8: ldv_handler_precall(); __videobuf_copy_stream(var_group4, var___videobuf_copy_stream_8_p1, var___videobuf_copy_stream_8_p2, var___videobuf_copy_stream_8_p3, var___videobuf_copy_stream_8_p4, var___videobuf_copy_stream_8_p5); break; case 9: ldv_handler_precall(); videobuf_to_vmalloc(var_group3); break; default: break; } } ldv_check_final_state(); return 0; } } int ( __attribute__((__warn_unused_result__)) mutex_lock_interruptible)(struct mutex *lock ) ; int ( __attribute__((__warn_unused_result__)) mutex_lock_killable)(struct mutex *lock ) ; int mutex_trylock(struct mutex *lock ) ; int atomic_dec_and_mutex_lock(atomic_t *cnt , struct mutex *lock ) ; __inline static void ldv_error(void) { { LDV_ERROR: {reach_error();abort();} } } extern int ldv_undef_int(void) ; long ldv__builtin_expect(long exp , long c ) { { return (exp); } } int ldv_mutex = 1; int ( __attribute__((__warn_unused_result__)) mutex_lock_interruptible)(struct mutex *lock ) { int nondetermined ; { if (ldv_mutex == 1) { } else { ldv_error(); } nondetermined = ldv_undef_int(); if (nondetermined) { ldv_mutex = 2; return (0); } else { return (-4); } } } int ( __attribute__((__warn_unused_result__)) mutex_lock_killable)(struct mutex *lock ) { int nondetermined ; { if (ldv_mutex == 1) { } else { ldv_error(); } nondetermined = ldv_undef_int(); if (nondetermined) { ldv_mutex = 2; return (0); } else { return (-4); } } } int atomic_dec_and_mutex_lock(atomic_t *cnt , struct mutex *lock ) { int atomic_value_after_dec ; { if (ldv_mutex == 1) { } else { ldv_error(); } atomic_value_after_dec = ldv_undef_int(); if (atomic_value_after_dec == 0) { ldv_mutex = 2; return (1); } else { } return (0); } } void mutex_lock(struct mutex *lock ) { { if (ldv_mutex == 1) { } else { ldv_error(); } ldv_mutex = 2; return; } } int mutex_trylock(struct mutex *lock ) { int nondetermined ; { if (ldv_mutex == 1) { } else { ldv_error(); } nondetermined = ldv_undef_int(); if (nondetermined) { ldv_mutex = 2; return (1); } else { return (0); } } } void mutex_unlock(struct mutex *lock ) { { if (ldv_mutex == 2) { } else { ldv_error(); } ldv_mutex = 1; return; } } void ldv_check_final_state(void) { { if (ldv_mutex == 1) { } else { ldv_error(); } return; } }