Error Trace

[Home]

Bug # 171

Show/hide error trace
Error trace
Function bodies
Blocks
  • Others...
    Function bodies without model function calls
    Initialization function calls
    Initialization function bodies
    Entry point
    Entry point body
    Function calls
    Skipped function calls
    Formal parameter names
    Declarations
    Assumes
    Assume conditions
    Returns
    Return values
    DEG initialization
    DEG function calls
    Model function calls
    Model function bodies
    Model asserts
    Model state changes
    Model function function calls
    Model function function bodies
    Model returns
    Model others
    Identation
    Line numbers
    Expand signs
-__CPAchecker_initialize()
{
20 typedef unsigned char __u8;
23 typedef unsigned short __u16;
25 typedef int __s32;
26 typedef unsigned int __u32;
29 typedef long long __s64;
30 typedef unsigned long long __u64;
15 typedef signed char s8;
16 typedef unsigned char u8;
18 typedef short s16;
19 typedef unsigned short u16;
21 typedef int s32;
22 typedef unsigned int u32;
24 typedef long long s64;
25 typedef unsigned long long u64;
14 typedef long __kernel_long_t;
15 typedef unsigned long __kernel_ulong_t;
27 typedef int __kernel_pid_t;
48 typedef unsigned int __kernel_uid32_t;
49 typedef unsigned int __kernel_gid32_t;
71 typedef __kernel_ulong_t __kernel_size_t;
72 typedef __kernel_long_t __kernel_ssize_t;
87 typedef long long __kernel_loff_t;
88 typedef __kernel_long_t __kernel_time_t;
89 typedef __kernel_long_t __kernel_clock_t;
90 typedef int __kernel_timer_t;
91 typedef int __kernel_clockid_t;
280 struct kernel_symbol { unsigned long value; const char *name; } ;
34 struct module ;
12 typedef __u32 __kernel_dev_t;
15 typedef __kernel_dev_t dev_t;
18 typedef unsigned short umode_t;
21 typedef __kernel_pid_t pid_t;
26 typedef __kernel_clockid_t clockid_t;
29 typedef _Bool bool;
31 typedef __kernel_uid32_t uid_t;
32 typedef __kernel_gid32_t gid_t;
45 typedef __kernel_loff_t loff_t;
54 typedef __kernel_size_t size_t;
59 typedef __kernel_ssize_t ssize_t;
69 typedef __kernel_time_t time_t;
102 typedef __s32 int32_t;
108 typedef __u32 uint32_t;
133 typedef unsigned long sector_t;
134 typedef unsigned long blkcnt_t;
152 typedef u64 dma_addr_t;
157 typedef unsigned int gfp_t;
158 typedef unsigned int fmode_t;
161 typedef u64 phys_addr_t;
166 typedef phys_addr_t resource_size_t;
172 typedef unsigned long irq_hw_number_t;
176 struct __anonstruct_atomic_t_6 { int counter; } ;
176 typedef struct __anonstruct_atomic_t_6 atomic_t;
181 struct __anonstruct_atomic64_t_7 { long counter; } ;
181 typedef struct __anonstruct_atomic64_t_7 atomic64_t;
182 struct list_head { struct list_head *next; struct list_head *prev; } ;
187 struct hlist_node ;
187 struct hlist_head { struct hlist_node *first; } ;
191 struct hlist_node { struct hlist_node *next; struct hlist_node **pprev; } ;
202 struct callback_head { struct callback_head *next; void (*func)(struct callback_head *); } ;
115 typedef void (*ctor_fn_t)();
58 struct device ;
465 struct file_operations ;
477 struct completion ;
478 struct pt_regs ;
546 struct bug_entry { int bug_addr_disp; int file_disp; unsigned short line; unsigned short flags; } ;
114 struct timespec ;
115 struct compat_timespec ;
116 struct pollfd ;
117 struct __anonstruct_futex_27 { u32 *uaddr; u32 val; u32 flags; u32 bitset; u64 time; u32 *uaddr2; } ;
117 struct __anonstruct_nanosleep_28 { clockid_t clockid; struct timespec *rmtp; struct compat_timespec *compat_rmtp; u64 expires; } ;
117 struct __anonstruct_poll_29 { struct pollfd *ufds; int nfds; int has_timeout; unsigned long tv_sec; unsigned long tv_nsec; } ;
117 union __anonunion____missing_field_name_26 { struct __anonstruct_futex_27 futex; struct __anonstruct_nanosleep_28 nanosleep; struct __anonstruct_poll_29 poll; } ;
117 struct restart_block { long int (*fn)(struct restart_block *); union __anonunion____missing_field_name_26 __annonCompField4; } ;
50 struct task_struct ;
39 struct page ;
26 struct mm_struct ;
288 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; } ;
66 struct __anonstruct____missing_field_name_32 { unsigned int a; unsigned int b; } ;
66 struct __anonstruct____missing_field_name_33 { u16 limit0; u16 base0; unsigned char base1; unsigned char type; unsigned char s; unsigned char dpl; unsigned char p; unsigned char limit; unsigned char avl; unsigned char l; unsigned char d; unsigned char g; unsigned char base2; } ;
66 union __anonunion____missing_field_name_31 { struct __anonstruct____missing_field_name_32 __annonCompField5; struct __anonstruct____missing_field_name_33 __annonCompField6; } ;
66 struct desc_struct { union __anonunion____missing_field_name_31 __annonCompField7; } ;
13 typedef unsigned long pteval_t;
14 typedef unsigned long pmdval_t;
16 typedef unsigned long pgdval_t;
17 typedef unsigned long pgprotval_t;
19 struct __anonstruct_pte_t_34 { pteval_t pte; } ;
19 typedef struct __anonstruct_pte_t_34 pte_t;
21 struct pgprot { pgprotval_t pgprot; } ;
256 typedef struct pgprot pgprot_t;
258 struct __anonstruct_pgd_t_35 { pgdval_t pgd; } ;
258 typedef struct __anonstruct_pgd_t_35 pgd_t;
297 struct __anonstruct_pmd_t_37 { pmdval_t pmd; } ;
297 typedef struct __anonstruct_pmd_t_37 pmd_t;
423 typedef struct page *pgtable_t;
434 struct file ;
445 struct seq_file ;
481 struct thread_struct ;
483 struct cpumask ;
20 struct qspinlock { atomic_t val; } ;
33 typedef struct qspinlock arch_spinlock_t;
34 struct qrwlock { atomic_t cnts; arch_spinlock_t wait_lock; } ;
14 typedef struct qrwlock arch_rwlock_t;
247 struct math_emu_info { long ___orig_eip; struct pt_regs *regs; } ;
83 struct static_key { atomic_t enabled; } ;
23 typedef atomic64_t atomic_long_t;
359 struct cpumask { unsigned long bits[128U]; } ;
15 typedef struct cpumask cpumask_t;
654 typedef struct cpumask *cpumask_var_t;
22 struct tracepoint_func { void *func; void *data; int prio; } ;
28 struct tracepoint { const char *name; struct static_key key; int (*regfunc)(); void (*unregfunc)(); struct tracepoint_func *funcs; } ;
233 struct fregs_state { u32 cwd; u32 swd; u32 twd; u32 fip; u32 fcs; u32 foo; u32 fos; u32 st_space[20U]; u32 status; } ;
26 struct __anonstruct____missing_field_name_61 { u64 rip; u64 rdp; } ;
26 struct __anonstruct____missing_field_name_62 { u32 fip; u32 fcs; u32 foo; u32 fos; } ;
26 union __anonunion____missing_field_name_60 { struct __anonstruct____missing_field_name_61 __annonCompField13; struct __anonstruct____missing_field_name_62 __annonCompField14; } ;
26 union __anonunion____missing_field_name_63 { u32 padding1[12U]; u32 sw_reserved[12U]; } ;
26 struct fxregs_state { u16 cwd; u16 swd; u16 twd; u16 fop; union __anonunion____missing_field_name_60 __annonCompField15; u32 mxcsr; u32 mxcsr_mask; u32 st_space[32U]; u32 xmm_space[64U]; u32 padding[12U]; union __anonunion____missing_field_name_63 __annonCompField16; } ;
66 struct swregs_state { 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; } ;
227 struct xstate_header { u64 xfeatures; u64 xcomp_bv; u64 reserved[6U]; } ;
233 struct xregs_state { struct fxregs_state i387; struct xstate_header header; u8 extended_state_area[0U]; } ;
254 union fpregs_state { struct fregs_state fsave; struct fxregs_state fxsave; struct swregs_state soft; struct xregs_state xsave; u8 __padding[4096U]; } ;
271 struct fpu { unsigned int last_cpu; unsigned char fpstate_active; unsigned char fpregs_active; union fpregs_state state; } ;
180 struct seq_operations ;
386 struct perf_event ;
391 struct __anonstruct_mm_segment_t_75 { unsigned long seg; } ;
391 typedef struct __anonstruct_mm_segment_t_75 mm_segment_t;
392 struct thread_struct { struct desc_struct tls_array[3U]; unsigned long sp0; unsigned long sp; unsigned short es; unsigned short ds; unsigned short fsindex; unsigned short gsindex; u32 status; unsigned long fsbase; unsigned long gsbase; struct perf_event *ptrace_bps[4U]; unsigned long debugreg6; unsigned long ptrace_dr7; unsigned long cr2; unsigned long trap_nr; unsigned long error_code; unsigned long *io_bitmap_ptr; unsigned long iopl; unsigned int io_bitmap_max; mm_segment_t addr_limit; unsigned char sig_on_uaccess_err; unsigned char uaccess_err; struct fpu fpu; } ;
48 struct thread_info { unsigned long flags; } ;
33 struct lockdep_map ;
55 struct stack_trace { unsigned int nr_entries; unsigned int max_entries; unsigned long *entries; int skip; } ;
28 struct lockdep_subclass_key { char __one_byte; } ;
53 struct lock_class_key { struct lockdep_subclass_key subkeys[8U]; } ;
59 struct lock_class { struct hlist_node 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; const char *name; int name_version; unsigned long contention_point[4U]; unsigned long contending_point[4U]; } ;
144 struct lockdep_map { struct lock_class_key *key; struct lock_class *class_cache[2U]; const char *name; int cpu; unsigned long ip; } ;
207 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; unsigned char irq_context; unsigned char trylock; unsigned char read; unsigned char check; unsigned char hardirqs_off; unsigned short references; unsigned int pin_count; } ;
593 struct raw_spinlock { arch_spinlock_t raw_lock; unsigned int magic; unsigned int owner_cpu; void *owner; struct lockdep_map dep_map; } ;
32 typedef struct raw_spinlock raw_spinlock_t;
33 struct __anonstruct____missing_field_name_77 { u8 __padding[24U]; struct lockdep_map dep_map; } ;
33 union __anonunion____missing_field_name_76 { struct raw_spinlock rlock; struct __anonstruct____missing_field_name_77 __annonCompField19; } ;
33 struct spinlock { union __anonunion____missing_field_name_76 __annonCompField20; } ;
76 typedef struct spinlock spinlock_t;
23 struct __anonstruct_rwlock_t_78 { arch_rwlock_t raw_lock; unsigned int magic; unsigned int owner_cpu; void *owner; struct lockdep_map dep_map; } ;
23 typedef struct __anonstruct_rwlock_t_78 rwlock_t;
416 struct seqcount { unsigned int sequence; struct lockdep_map dep_map; } ;
52 typedef struct seqcount seqcount_t;
407 struct __anonstruct_seqlock_t_93 { struct seqcount seqcount; spinlock_t lock; } ;
407 typedef struct __anonstruct_seqlock_t_93 seqlock_t;
601 struct timespec { __kernel_time_t tv_sec; long tv_nsec; } ;
7 typedef __s64 time64_t;
83 struct user_namespace ;
22 struct __anonstruct_kuid_t_94 { uid_t val; } ;
22 typedef struct __anonstruct_kuid_t_94 kuid_t;
27 struct __anonstruct_kgid_t_95 { gid_t val; } ;
27 typedef struct __anonstruct_kgid_t_95 kgid_t;
139 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; } ;
36 struct vm_area_struct ;
38 struct __wait_queue_head { spinlock_t lock; struct list_head task_list; } ;
43 typedef struct __wait_queue_head wait_queue_head_t;
97 struct __anonstruct_nodemask_t_96 { unsigned long bits[16U]; } ;
97 typedef struct __anonstruct_nodemask_t_96 nodemask_t;
249 typedef unsigned int isolate_mode_t;
13 struct optimistic_spin_queue { atomic_t tail; } ;
39 struct mutex { atomic_long_t owner; spinlock_t wait_lock; struct optimistic_spin_queue osq; struct list_head wait_list; void *magic; struct lockdep_map dep_map; } ;
70 struct mutex_waiter { struct list_head list; struct task_struct *task; void *magic; } ;
222 struct rw_semaphore ;
223 struct rw_semaphore { atomic_long_t count; struct list_head wait_list; raw_spinlock_t wait_lock; struct optimistic_spin_queue osq; struct task_struct *owner; struct lockdep_map dep_map; } ;
178 struct completion { unsigned int done; wait_queue_head_t wait; } ;
28 typedef s64 ktime_t;
1145 struct timer_list { struct hlist_node entry; unsigned long expires; void (*function)(unsigned long); unsigned long data; u32 flags; int start_pid; void *start_site; char start_comm[16U]; struct lockdep_map lockdep_map; } ;
254 struct hrtimer ;
255 enum hrtimer_restart ;
256 struct rb_node { unsigned long __rb_parent_color; struct rb_node *rb_right; struct rb_node *rb_left; } ;
41 struct rb_root { struct rb_node *rb_node; } ;
835 struct nsproxy ;
278 struct workqueue_struct ;
279 struct work_struct ;
54 struct work_struct { atomic_long_t data; struct list_head entry; void (*func)(struct work_struct *); struct lockdep_map lockdep_map; } ;
107 struct delayed_work { struct work_struct work; struct timer_list timer; struct workqueue_struct *wq; int cpu; } ;
268 struct notifier_block ;
53 struct notifier_block { int (*notifier_call)(struct notifier_block *, unsigned long, void *); struct notifier_block *next; int priority; } ;
217 struct resource ;
70 struct resource { resource_size_t start; resource_size_t end; const char *name; unsigned long flags; unsigned long desc; struct resource *parent; struct resource *sibling; struct resource *child; } ;
58 struct pm_message { int event; } ;
64 typedef struct pm_message pm_message_t;
65 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 *); } ;
320 enum rpm_status { RPM_ACTIVE = 0, RPM_RESUMING = 1, RPM_SUSPENDED = 2, RPM_SUSPENDING = 3 } ;
327 enum rpm_request { RPM_REQ_NONE = 0, RPM_REQ_IDLE = 1, RPM_REQ_SUSPEND = 2, RPM_REQ_AUTOSUSPEND = 3, RPM_REQ_RESUME = 4 } ;
335 struct wakeup_source ;
336 struct wake_irq ;
337 struct pm_domain_data ;
338 struct pm_subsys_data { spinlock_t lock; unsigned int refcount; struct list_head clock_list; struct pm_domain_data *domain_data; } ;
556 struct dev_pm_qos ;
556 struct dev_pm_info { pm_message_t power_state; unsigned char can_wakeup; unsigned char async_suspend; bool in_dpm_list; bool is_prepared; bool is_suspended; bool is_noirq_suspended; bool is_late_suspended; bool early_init; bool direct_complete; spinlock_t lock; struct list_head entry; struct completion completion; struct wakeup_source *wakeup; bool wakeup_path; bool syscore; bool no_pm_callbacks; struct timer_list suspend_timer; unsigned long timer_expires; struct work_struct work; wait_queue_head_t wait_queue; struct wake_irq *wakeirq; atomic_t usage_count; atomic_t child_count; unsigned char disable_depth; unsigned char idle_notification; unsigned char request_pending; unsigned char deferred_resume; unsigned char run_wake; unsigned char runtime_auto; bool ignore_children; unsigned char no_callbacks; unsigned char irq_safe; unsigned char use_autosuspend; unsigned char timer_autosuspends; unsigned char memalloc_noio; unsigned int links_count; 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; void (*set_latency_tolerance)(struct device *, s32 ); struct dev_pm_qos *qos; } ;
618 struct dev_pm_domain { struct dev_pm_ops ops; void (*detach)(struct device *, bool ); int (*activate)(struct device *); void (*sync)(struct device *); void (*dismiss)(struct device *); } ;
38 struct ldt_struct ;
38 struct vdso_image ;
38 struct __anonstruct_mm_context_t_167 { struct ldt_struct *ldt; unsigned short ia32_compat; struct mutex lock; void *vdso; const struct vdso_image *vdso_image; atomic_t perf_rdpmc_allowed; u16 pkey_allocation_map; s16 execute_only_pkey; void *bd_addr; } ;
38 typedef struct __anonstruct_mm_context_t_167 mm_context_t;
1264 struct llist_node ;
64 struct llist_node { struct llist_node *next; } ;
37 struct cred ;
19 struct inode ;
58 struct arch_uprobe_task { unsigned long saved_scratch_register; unsigned int saved_trap_nr; unsigned int saved_tf; } ;
66 enum uprobe_task_state { UTASK_RUNNING = 0, UTASK_SSTEP = 1, UTASK_SSTEP_ACK = 2, UTASK_SSTEP_TRAPPED = 3 } ;
73 struct __anonstruct____missing_field_name_215 { struct arch_uprobe_task autask; unsigned long vaddr; } ;
73 struct __anonstruct____missing_field_name_216 { struct callback_head dup_xol_work; unsigned long dup_xol_addr; } ;
73 union __anonunion____missing_field_name_214 { struct __anonstruct____missing_field_name_215 __annonCompField35; struct __anonstruct____missing_field_name_216 __annonCompField36; } ;
73 struct uprobe ;
73 struct return_instance ;
73 struct uprobe_task { enum uprobe_task_state state; union __anonunion____missing_field_name_214 __annonCompField37; struct uprobe *active_uprobe; unsigned long xol_vaddr; struct return_instance *return_instances; unsigned int depth; } ;
95 struct return_instance { struct uprobe *uprobe; unsigned long func; unsigned long stack; unsigned long orig_ret_vaddr; bool chained; struct return_instance *next; } ;
111 struct xol_area ;
112 struct uprobes_state { struct xol_area *xol_area; } ;
151 struct address_space ;
152 struct mem_cgroup ;
153 union __anonunion____missing_field_name_217 { struct address_space *mapping; void *s_mem; atomic_t compound_mapcount; } ;
153 union __anonunion____missing_field_name_218 { unsigned long index; void *freelist; } ;
153 struct __anonstruct____missing_field_name_222 { unsigned short inuse; unsigned short objects; unsigned char frozen; } ;
153 union __anonunion____missing_field_name_221 { atomic_t _mapcount; unsigned int active; struct __anonstruct____missing_field_name_222 __annonCompField40; int units; } ;
153 struct __anonstruct____missing_field_name_220 { union __anonunion____missing_field_name_221 __annonCompField41; atomic_t _refcount; } ;
153 union __anonunion____missing_field_name_219 { unsigned long counters; struct __anonstruct____missing_field_name_220 __annonCompField42; } ;
153 struct dev_pagemap ;
153 struct __anonstruct____missing_field_name_224 { struct page *next; int pages; int pobjects; } ;
153 struct __anonstruct____missing_field_name_225 { unsigned long compound_head; unsigned int compound_dtor; unsigned int compound_order; } ;
153 struct __anonstruct____missing_field_name_226 { unsigned long __pad; pgtable_t pmd_huge_pte; } ;
153 union __anonunion____missing_field_name_223 { struct list_head lru; struct dev_pagemap *pgmap; struct __anonstruct____missing_field_name_224 __annonCompField44; struct callback_head callback_head; struct __anonstruct____missing_field_name_225 __annonCompField45; struct __anonstruct____missing_field_name_226 __annonCompField46; } ;
153 struct kmem_cache ;
153 union __anonunion____missing_field_name_227 { unsigned long private; spinlock_t *ptl; struct kmem_cache *slab_cache; } ;
153 struct page { unsigned long flags; union __anonunion____missing_field_name_217 __annonCompField38; union __anonunion____missing_field_name_218 __annonCompField39; union __anonunion____missing_field_name_219 __annonCompField43; union __anonunion____missing_field_name_223 __annonCompField47; union __anonunion____missing_field_name_227 __annonCompField48; struct mem_cgroup *mem_cgroup; } ;
197 struct page_frag { struct page *page; __u32 offset; __u32 size; } ;
282 struct userfaultfd_ctx ;
282 struct vm_userfaultfd_ctx { struct userfaultfd_ctx *ctx; } ;
289 struct __anonstruct_shared_228 { struct rb_node rb; unsigned long rb_subtree_last; } ;
289 struct anon_vma ;
289 struct vm_operations_struct ;
289 struct mempolicy ;
289 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; struct __anonstruct_shared_228 shared; struct list_head anon_vma_chain; struct anon_vma *anon_vma; const struct vm_operations_struct *vm_ops; unsigned long vm_pgoff; struct file *vm_file; void *vm_private_data; struct mempolicy *vm_policy; struct vm_userfaultfd_ctx vm_userfaultfd_ctx; } ;
362 struct core_thread { struct task_struct *task; struct core_thread *next; } ;
367 struct core_state { atomic_t nr_threads; struct core_thread dumper; struct completion startup; } ;
381 struct task_rss_stat { int events; int count[4U]; } ;
389 struct mm_rss_stat { atomic_long_t count[4U]; } ;
394 struct kioctx_table ;
395 struct linux_binfmt ;
395 struct mmu_notifier_mm ;
395 struct mm_struct { struct vm_area_struct *mmap; struct rb_root mm_rb; u32 vmacache_seqnum; unsigned long int (*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; atomic_long_t nr_ptes; atomic_long_t nr_pmds; 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 data_vm; unsigned long exec_vm; unsigned long stack_vm; unsigned long def_flags; 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[46U]; 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 user_namespace *user_ns; struct file *exe_file; struct mmu_notifier_mm *mmu_notifier_mm; struct cpumask cpumask_allocation; unsigned long numa_next_scan; unsigned long numa_scan_offset; int numa_scan_seq; bool tlb_flush_pending; struct uprobes_state uprobes_state; atomic_long_t hugetlb_usage; struct work_struct async_put_work; } ;
560 struct vm_fault ;
614 struct vdso_image { void *data; unsigned long size; unsigned long alt; unsigned long alt_len; long sym_vvar_start; long sym_vvar_page; long sym_hpet_page; long sym_pvclock_page; long sym_VDSO32_NOTE_MASK; long sym___kernel_sigreturn; long sym___kernel_rt_sigreturn; long sym___kernel_vsyscall; long sym_int80_landing_pad; } ;
15 typedef __u64 Elf64_Addr;
16 typedef __u16 Elf64_Half;
18 typedef __u64 Elf64_Off;
20 typedef __u32 Elf64_Word;
21 typedef __u64 Elf64_Xword;
190 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; } ;
198 typedef struct elf64_sym Elf64_Sym;
219 struct elf64_hdr { unsigned char e_ident[16U]; Elf64_Half e_type; Elf64_Half e_machine; Elf64_Word e_version; Elf64_Addr e_entry; Elf64_Off e_phoff; Elf64_Off e_shoff; Elf64_Word e_flags; Elf64_Half e_ehsize; Elf64_Half e_phentsize; Elf64_Half e_phnum; Elf64_Half e_shentsize; Elf64_Half e_shnum; Elf64_Half e_shstrndx; } ;
235 typedef struct elf64_hdr Elf64_Ehdr;
314 struct elf64_shdr { Elf64_Word sh_name; Elf64_Word sh_type; Elf64_Xword sh_flags; Elf64_Addr sh_addr; Elf64_Off sh_offset; Elf64_Xword sh_size; Elf64_Word sh_link; Elf64_Word sh_info; Elf64_Xword sh_addralign; Elf64_Xword sh_entsize; } ;
326 typedef struct elf64_shdr Elf64_Shdr;
53 union __anonunion____missing_field_name_233 { unsigned long bitmap[1U]; struct callback_head callback_head; } ;
53 struct idr_layer { int prefix; int layer; struct idr_layer *ary[64U]; int count; union __anonunion____missing_field_name_233 __annonCompField49; } ;
40 struct idr { struct idr_layer *hint; struct idr_layer *top; int layers; int cur; spinlock_t lock; int id_free_cnt; struct idr_layer *id_free; } ;
149 struct ida_bitmap { long nr_busy; unsigned long bitmap[15U]; } ;
192 struct ida { struct idr idr; struct ida_bitmap *free_bitmap; } ;
229 struct dentry ;
230 struct iattr ;
231 struct super_block ;
232 struct file_system_type ;
233 struct kernfs_open_node ;
234 struct kernfs_iattrs ;
257 struct kernfs_root ;
257 struct kernfs_elem_dir { unsigned long subdirs; struct rb_root children; struct kernfs_root *root; } ;
85 struct kernfs_node ;
85 struct kernfs_elem_symlink { struct kernfs_node *target_kn; } ;
89 struct kernfs_ops ;
89 struct kernfs_elem_attr { const struct kernfs_ops *ops; struct kernfs_open_node *open; loff_t size; struct kernfs_node *notify_next; } ;
96 union __anonunion____missing_field_name_242 { struct kernfs_elem_dir dir; struct kernfs_elem_symlink symlink; struct kernfs_elem_attr attr; } ;
96 struct kernfs_node { atomic_t count; atomic_t active; struct lockdep_map dep_map; struct kernfs_node *parent; const char *name; struct rb_node rb; const void *ns; unsigned int hash; union __anonunion____missing_field_name_242 __annonCompField50; void *priv; unsigned short flags; umode_t mode; unsigned int ino; struct kernfs_iattrs *iattr; } ;
138 struct kernfs_syscall_ops { int (*remount_fs)(struct kernfs_root *, int *, char *); int (*show_options)(struct seq_file *, struct kernfs_root *); int (*mkdir)(struct kernfs_node *, const char *, umode_t ); int (*rmdir)(struct kernfs_node *); int (*rename)(struct kernfs_node *, struct kernfs_node *, const char *); int (*show_path)(struct seq_file *, struct kernfs_node *, struct kernfs_root *); } ;
157 struct kernfs_root { struct kernfs_node *kn; unsigned int flags; struct ida ino_ida; struct kernfs_syscall_ops *syscall_ops; struct list_head supers; wait_queue_head_t deactivate_waitq; } ;
173 struct kernfs_open_file { struct kernfs_node *kn; struct file *file; void *priv; struct mutex mutex; struct mutex prealloc_mutex; int event; struct list_head list; char *prealloc_buf; size_t atomic_write_len; bool mmapped; const struct vm_operations_struct *vm_ops; } ;
191 struct kernfs_ops { int (*seq_show)(struct seq_file *, void *); void * (*seq_start)(struct seq_file *, loff_t *); void * (*seq_next)(struct seq_file *, void *, loff_t *); void (*seq_stop)(struct seq_file *, void *); ssize_t (*read)(struct kernfs_open_file *, char *, size_t , loff_t ); size_t atomic_write_len; bool prealloc; ssize_t (*write)(struct kernfs_open_file *, char *, size_t , loff_t ); int (*mmap)(struct kernfs_open_file *, struct vm_area_struct *); struct lock_class_key lockdep_key; } ;
511 struct sock ;
512 struct kobject ;
513 enum kobj_ns_type { KOBJ_NS_TYPE_NONE = 0, KOBJ_NS_TYPE_NET = 1, KOBJ_NS_TYPES = 2 } ;
519 struct kobj_ns_type_operations { enum kobj_ns_type type; bool (*current_may_mount)(); void * (*grab_current_ns)(); const void * (*netlink_ns)(struct sock *); const void * (*initial_ns)(); void (*drop_ns)(void *); } ;
59 struct bin_attribute ;
60 struct attribute { const char *name; umode_t mode; bool ignore_lockdep; struct lock_class_key *key; struct lock_class_key skey; } ;
37 struct attribute_group { const char *name; umode_t (*is_visible)(struct kobject *, struct attribute *, int); umode_t (*is_bin_visible)(struct kobject *, struct bin_attribute *, int); struct attribute **attrs; struct bin_attribute **bin_attrs; } ;
92 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 *); } ;
165 struct sysfs_ops { ssize_t (*show)(struct kobject *, struct attribute *, char *); ssize_t (*store)(struct kobject *, struct attribute *, const char *, size_t ); } ;
530 struct kref { atomic_t refcount; } ;
52 struct kset ;
52 struct kobj_type ;
52 struct kobject { const char *name; struct list_head entry; struct kobject *parent; struct kset *kset; struct kobj_type *ktype; struct kernfs_node *sd; struct kref kref; struct delayed_work release; unsigned char state_initialized; unsigned char state_in_sysfs; unsigned char state_add_uevent_sent; unsigned char state_remove_uevent_sent; unsigned char uevent_suppress; } ;
115 struct kobj_type { void (*release)(struct kobject *); const struct sysfs_ops *sysfs_ops; struct attribute **default_attrs; const struct kobj_ns_type_operations * (*child_ns_type)(struct kobject *); const void * (*namespace)(struct kobject *); } ;
123 struct kobj_uevent_env { char *argv[3U]; char *envp[32U]; int envp_idx; char buf[2048U]; int buflen; } ;
131 struct kset_uevent_ops { const int (*filter)(struct kset *, struct kobject *); const const char * (*name)(struct kset *, struct kobject *); const int (*uevent)(struct kset *, struct kobject *, struct kobj_uevent_env *); } ;
148 struct kset { struct list_head list; spinlock_t list_lock; struct kobject kobj; const struct kset_uevent_ops *uevent_ops; } ;
223 struct kernel_param ;
228 struct kernel_param_ops { unsigned int flags; int (*set)(const char *, const struct kernel_param *); int (*get)(char *, const struct kernel_param *); void (*free)(void *); } ;
62 struct kparam_string ;
62 struct kparam_array ;
62 union __anonunion____missing_field_name_245 { void *arg; const struct kparam_string *str; const struct kparam_array *arr; } ;
62 struct kernel_param { const char *name; struct module *mod; const struct kernel_param_ops *ops; const u16 perm; s8 level; u8 flags; union __anonunion____missing_field_name_245 __annonCompField51; } ;
83 struct kparam_string { unsigned int maxlen; char *string; } ;
89 struct kparam_array { unsigned int max; unsigned int elemsize; unsigned int *num; const struct kernel_param_ops *ops; void *elem; } ;
470 struct exception_table_entry ;
24 struct latch_tree_node { struct rb_node node[2U]; } ;
211 struct mod_arch_specific { } ;
39 struct module_param_attrs ;
39 struct module_kobject { struct kobject kobj; struct module *mod; struct kobject *drivers_dir; struct module_param_attrs *mp; struct completion *kobj_completion; } ;
50 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 *, const char *, size_t ); void (*setup)(struct module *, const char *); int (*test)(struct module *); void (*free)(struct module *); } ;
277 enum module_state { MODULE_STATE_LIVE = 0, MODULE_STATE_COMING = 1, MODULE_STATE_GOING = 2, MODULE_STATE_UNFORMED = 3 } ;
284 struct mod_tree_node { struct module *mod; struct latch_tree_node node; } ;
291 struct module_layout { void *base; unsigned int size; unsigned int text_size; unsigned int ro_size; unsigned int ro_after_init_size; struct mod_tree_node mtn; } ;
307 struct mod_kallsyms { Elf64_Sym *symtab; unsigned int num_symtab; char *strtab; } ;
321 struct klp_modinfo { Elf64_Ehdr hdr; Elf64_Shdr *sechdrs; char *secstrings; unsigned int symndx; } ;
329 struct module_sect_attrs ;
329 struct module_notes_attrs ;
329 struct trace_event_call ;
329 struct trace_enum_map ;
329 struct module { enum module_state state; struct list_head list; char name[56U]; struct module_kobject mkobj; struct module_attribute *modinfo_attrs; const char *version; const char *srcversion; struct kobject *holders_dir; const struct kernel_symbol *syms; const unsigned long *crcs; unsigned int num_syms; struct mutex param_lock; struct kernel_param *kp; unsigned int num_kp; unsigned int num_gpl_syms; const struct kernel_symbol *gpl_syms; const unsigned long *gpl_crcs; const struct kernel_symbol *unused_syms; const unsigned long *unused_crcs; unsigned int num_unused_syms; unsigned int num_unused_gpl_syms; const struct kernel_symbol *unused_gpl_syms; const unsigned long *unused_gpl_crcs; bool sig_ok; bool async_probe_requested; const struct kernel_symbol *gpl_future_syms; const unsigned long *gpl_future_crcs; unsigned int num_gpl_future_syms; unsigned int num_exentries; struct exception_table_entry *extable; int (*init)(); struct module_layout core_layout; struct module_layout init_layout; struct mod_arch_specific arch; unsigned long taints; unsigned int num_bugs; struct list_head bug_list; struct bug_entry *bug_table; struct mod_kallsyms *kallsyms; struct mod_kallsyms core_kallsyms; struct module_sect_attrs *sect_attrs; struct module_notes_attrs *notes_attrs; char *args; void *percpu; unsigned int percpu_size; unsigned int num_tracepoints; const struct tracepoint **tracepoints_ptrs; unsigned int num_trace_bprintk_fmt; const char **trace_bprintk_fmt_start; struct trace_event_call **trace_events; unsigned int num_trace_events; struct trace_enum_map **trace_enums; unsigned int num_trace_enums; bool klp; bool klp_alive; struct klp_modinfo *klp_info; struct list_head source_list; struct list_head target_list; void (*exit)(); atomic_t refcnt; ctor_fn_t (**ctors)(); unsigned int num_ctors; } ;
799 struct clk ;
15 struct klist_node ;
37 struct klist_node { void *n_klist; struct list_head n_node; struct kref n_ref; } ;
93 struct hlist_bl_node ;
93 struct hlist_bl_head { struct hlist_bl_node *first; } ;
36 struct hlist_bl_node { struct hlist_bl_node *next; struct hlist_bl_node **pprev; } ;
114 struct __anonstruct____missing_field_name_299 { spinlock_t lock; int count; } ;
114 union __anonunion____missing_field_name_298 { struct __anonstruct____missing_field_name_299 __annonCompField52; } ;
114 struct lockref { union __anonunion____missing_field_name_298 __annonCompField53; } ;
77 struct path ;
78 struct vfsmount ;
79 struct __anonstruct____missing_field_name_301 { u32 hash; u32 len; } ;
79 union __anonunion____missing_field_name_300 { struct __anonstruct____missing_field_name_301 __annonCompField54; u64 hash_len; } ;
79 struct qstr { union __anonunion____missing_field_name_300 __annonCompField55; const unsigned char *name; } ;
65 struct dentry_operations ;
65 union __anonunion____missing_field_name_302 { struct list_head d_lru; wait_queue_head_t *d_wait; } ;
65 union __anonunion_d_u_303 { struct hlist_node d_alias; struct hlist_bl_node d_in_lookup_hash; struct callback_head d_rcu; } ;
65 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; const struct dentry_operations *d_op; struct super_block *d_sb; unsigned long d_time; void *d_fsdata; union __anonunion____missing_field_name_302 __annonCompField56; struct list_head d_child; struct list_head d_subdirs; union __anonunion_d_u_303 d_u; } ;
121 struct dentry_operations { int (*d_revalidate)(struct dentry *, unsigned int); int (*d_weak_revalidate)(struct dentry *, unsigned int); int (*d_hash)(const struct dentry *, struct qstr *); int (*d_compare)(const struct dentry *, unsigned int, const char *, const struct qstr *); int (*d_delete)(const struct dentry *); int (*d_init)(struct dentry *); 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)(const struct path *, bool ); struct dentry * (*d_real)(struct dentry *, const struct inode *, unsigned int); } ;
592 struct path { struct vfsmount *mnt; struct dentry *dentry; } ;
19 struct shrink_control { gfp_t gfp_mask; unsigned long nr_to_scan; int nid; struct mem_cgroup *memcg; } ;
27 struct shrinker { unsigned long int (*count_objects)(struct shrinker *, struct shrink_control *); unsigned long int (*scan_objects)(struct shrinker *, struct shrink_control *); int seeks; long batch; unsigned long flags; struct list_head list; atomic_long_t *nr_deferred; } ;
80 struct list_lru_one { struct list_head list; long nr_items; } ;
32 struct list_lru_memcg { struct list_lru_one *lru[0U]; } ;
37 struct list_lru_node { spinlock_t lock; struct list_lru_one lru; struct list_lru_memcg *memcg_lrus; } ;
47 struct list_lru { struct list_lru_node *node; struct list_head list; } ;
63 union __anonunion____missing_field_name_304 { struct list_head private_list; struct callback_head callback_head; } ;
63 struct radix_tree_node { unsigned char shift; unsigned char offset; unsigned char count; unsigned char exceptional; struct radix_tree_node *parent; void *private_data; union __anonunion____missing_field_name_304 __annonCompField57; void *slots[64U]; unsigned long tags[3U][1U]; } ;
105 struct radix_tree_root { gfp_t gfp_mask; struct radix_tree_node *rnode; } ;
519 enum pid_type { PIDTYPE_PID = 0, PIDTYPE_PGID = 1, PIDTYPE_SID = 2, PIDTYPE_MAX = 3 } ;
526 struct pid_namespace ;
526 struct upid { int nr; struct pid_namespace *ns; struct hlist_node pid_chain; } ;
56 struct pid { atomic_t count; unsigned int level; struct hlist_head tasks[3U]; struct callback_head rcu; struct upid numbers[1U]; } ;
68 struct pid_link { struct hlist_node node; struct pid *pid; } ;
22 struct kernel_cap_struct { __u32 cap[2U]; } ;
25 typedef struct kernel_cap_struct kernel_cap_t;
45 struct fiemap_extent { __u64 fe_logical; __u64 fe_physical; __u64 fe_length; __u64 fe_reserved64[2U]; __u32 fe_flags; __u32 fe_reserved[3U]; } ;
38 enum migrate_mode { MIGRATE_ASYNC = 0, MIGRATE_SYNC_LIGHT = 1, MIGRATE_SYNC = 2 } ;
44 enum rcu_sync_type { RCU_SYNC = 0, RCU_SCHED_SYNC = 1, RCU_BH_SYNC = 2 } ;
50 struct rcu_sync { int gp_state; int gp_count; wait_queue_head_t gp_wait; int cb_state; struct callback_head cb_head; enum rcu_sync_type gp_type; } ;
66 struct percpu_rw_semaphore { struct rcu_sync rss; unsigned int *read_count; struct rw_semaphore rw_sem; wait_queue_head_t writer; int readers_block; } ;
144 struct delayed_call { void (*fn)(void *); void *arg; } ;
282 struct backing_dev_info ;
283 struct bdi_writeback ;
285 struct export_operations ;
288 struct kiocb ;
289 struct pipe_inode_info ;
290 struct poll_table_struct ;
291 struct kstatfs ;
292 struct swap_info_struct ;
293 struct iov_iter ;
294 struct fscrypt_info ;
295 struct fscrypt_operations ;
76 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; } ;
213 struct dquot ;
214 struct kqid ;
19 typedef __kernel_uid32_t projid_t;
23 struct __anonstruct_kprojid_t_308 { projid_t val; } ;
23 typedef struct __anonstruct_kprojid_t_308 kprojid_t;
181 enum quota_type { USRQUOTA = 0, GRPQUOTA = 1, PRJQUOTA = 2 } ;
66 typedef long long qsize_t;
67 union __anonunion____missing_field_name_309 { kuid_t uid; kgid_t gid; kprojid_t projid; } ;
67 struct kqid { union __anonunion____missing_field_name_309 __annonCompField58; enum quota_type type; } ;
194 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; time64_t dqb_btime; time64_t dqb_itime; } ;
216 struct quota_format_type ;
217 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_max_spc_limit; qsize_t dqi_max_ino_limit; void *dqi_priv; } ;
282 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; } ;
309 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 *); int (*get_next_id)(struct super_block *, struct kqid *); } ;
321 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 *); int (*get_projid)(struct inode *, kprojid_t *); int (*get_next_id)(struct super_block *, struct kqid *); } ;
338 struct qc_dqblk { int d_fieldmask; u64 d_spc_hardlimit; u64 d_spc_softlimit; u64 d_ino_hardlimit; u64 d_ino_softlimit; u64 d_space; u64 d_ino_count; s64 d_ino_timer; s64 d_spc_timer; int d_ino_warns; int d_spc_warns; u64 d_rt_spc_hardlimit; u64 d_rt_spc_softlimit; u64 d_rt_space; s64 d_rt_spc_timer; int d_rt_spc_warns; } ;
361 struct qc_type_state { unsigned int flags; unsigned int spc_timelimit; unsigned int ino_timelimit; unsigned int rt_spc_timelimit; unsigned int spc_warnlimit; unsigned int ino_warnlimit; unsigned int rt_spc_warnlimit; unsigned long long ino; blkcnt_t blocks; blkcnt_t nextents; } ;
407 struct qc_state { unsigned int s_incoredqs; struct qc_type_state s_state[3U]; } ;
418 struct qc_info { int i_fieldmask; unsigned int i_flags; unsigned int i_spc_timelimit; unsigned int i_ino_timelimit; unsigned int i_rt_spc_timelimit; unsigned int i_spc_warnlimit; unsigned int i_ino_warnlimit; unsigned int i_rt_spc_warnlimit; } ;
431 struct quotactl_ops { int (*quota_on)(struct super_block *, int, int, const struct path *); int (*quota_off)(struct super_block *, int); int (*quota_enable)(struct super_block *, unsigned int); int (*quota_disable)(struct super_block *, unsigned int); int (*quota_sync)(struct super_block *, int); int (*set_info)(struct super_block *, int, struct qc_info *); int (*get_dqblk)(struct super_block *, struct kqid , struct qc_dqblk *); int (*get_nextdqblk)(struct super_block *, struct kqid *, struct qc_dqblk *); int (*set_dqblk)(struct super_block *, struct kqid , struct qc_dqblk *); int (*get_state)(struct super_block *, struct qc_state *); int (*rm_xquota)(struct super_block *, unsigned int); } ;
447 struct quota_format_type { int qf_fmt_id; const struct quota_format_ops *qf_ops; struct module *qf_owner; struct quota_format_type *qf_next; } ;
511 struct quota_info { unsigned int flags; struct mutex dqio_mutex; struct inode *files[3U]; struct mem_dqinfo info[3U]; const struct quota_format_ops *ops[3U]; } ;
540 struct writeback_control ;
541 struct kiocb { struct file *ki_filp; loff_t ki_pos; void (*ki_complete)(struct kiocb *, long, long); void *private; int ki_flags; } ;
317 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)(struct kiocb *, struct iov_iter *); int (*migratepage)(struct address_space *, struct page *, struct page *, enum migrate_mode ); bool (*isolate_page)(struct page *, isolate_mode_t ); void (*putback_page)(struct page *); int (*launder_page)(struct page *); int (*is_partially_uptodate)(struct page *, unsigned long, 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 *); } ;
376 struct address_space { struct inode *host; struct radix_tree_root page_tree; spinlock_t tree_lock; atomic_t i_mmap_writable; struct rb_root i_mmap; struct rw_semaphore i_mmap_rwsem; unsigned long nrpages; unsigned long nrexceptional; unsigned long writeback_index; const struct address_space_operations *a_ops; unsigned long flags; spinlock_t private_lock; gfp_t gfp_mask; struct list_head private_list; void *private_data; } ;
398 struct request_queue ;
399 struct hd_struct ;
399 struct gendisk ;
399 struct block_device { dev_t bd_dev; int bd_openers; struct inode *bd_inode; struct super_block *bd_super; struct mutex bd_mutex; 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; } ;
514 struct posix_acl ;
541 struct inode_operations ;
541 union __anonunion____missing_field_name_314 { const unsigned int i_nlink; unsigned int __i_nlink; } ;
541 union __anonunion____missing_field_name_315 { struct hlist_head i_dentry; struct callback_head i_rcu; } ;
541 struct file_lock_context ;
541 struct cdev ;
541 union __anonunion____missing_field_name_316 { struct pipe_inode_info *i_pipe; struct block_device *i_bdev; struct cdev *i_cdev; char *i_link; unsigned int i_dir_seq; } ;
541 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; const struct inode_operations *i_op; struct super_block *i_sb; struct address_space *i_mapping; void *i_security; unsigned long i_ino; union __anonunion____missing_field_name_314 __annonCompField59; 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 rw_semaphore i_rwsem; unsigned long dirtied_when; unsigned long dirtied_time_when; struct hlist_node i_hash; struct list_head i_io_list; struct bdi_writeback *i_wb; int i_wb_frn_winner; u16 i_wb_frn_avg_time; u16 i_wb_frn_history; struct list_head i_lru; struct list_head i_sb_list; struct list_head i_wb_list; union __anonunion____missing_field_name_315 __annonCompField60; u64 i_version; atomic_t i_count; atomic_t i_dio_count; atomic_t i_writecount; atomic_t i_readcount; const struct file_operations *i_fop; struct file_lock_context *i_flctx; struct address_space i_data; struct list_head i_devices; union __anonunion____missing_field_name_316 __annonCompField61; __u32 i_generation; __u32 i_fsnotify_mask; struct hlist_head i_fsnotify_marks; struct fscrypt_info *i_crypt_info; void *i_private; } ;
797 struct fown_struct { rwlock_t lock; struct pid *pid; enum pid_type pid_type; kuid_t uid; kuid_t euid; int signum; } ;
805 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; } ;
828 union __anonunion_f_u_317 { struct llist_node fu_llist; struct callback_head fu_rcuhead; } ;
828 struct file { union __anonunion_f_u_317 f_u; struct path f_path; struct inode *f_inode; const struct file_operations *f_op; spinlock_t f_lock; atomic_long_t f_count; unsigned int f_flags; fmode_t f_mode; struct mutex f_pos_lock; loff_t f_pos; struct fown_struct f_owner; const struct cred *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; } ;
913 typedef void *fl_owner_t;
914 struct file_lock ;
915 struct file_lock_operations { void (*fl_copy_lock)(struct file_lock *, struct file_lock *); void (*fl_release_private)(struct file_lock *); } ;
921 struct lock_manager_operations { int (*lm_compare_owner)(struct file_lock *, struct file_lock *); unsigned long int (*lm_owner_key)(struct file_lock *); fl_owner_t (*lm_get_owner)(fl_owner_t ); void (*lm_put_owner)(fl_owner_t ); void (*lm_notify)(struct file_lock *); int (*lm_grant)(struct file_lock *, int); bool (*lm_break)(struct file_lock *); int (*lm_change)(struct file_lock *, int, struct list_head *); void (*lm_setup)(struct file_lock *, void **); } ;
948 struct nlm_lockowner ;
949 struct nfs_lock_info { u32 state; struct nlm_lockowner *owner; struct list_head list; } ;
14 struct nfs4_lock_state ;
15 struct nfs4_lock_info { struct nfs4_lock_state *owner; } ;
19 struct fasync_struct ;
19 struct __anonstruct_afs_319 { struct list_head link; int state; } ;
19 union __anonunion_fl_u_318 { struct nfs_lock_info nfs_fl; struct nfs4_lock_info nfs4_fl; struct __anonstruct_afs_319 afs; } ;
19 struct file_lock { struct file_lock *fl_next; struct list_head fl_list; 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; const struct file_lock_operations *fl_ops; const struct lock_manager_operations *fl_lmops; union __anonunion_fl_u_318 fl_u; } ;
1001 struct file_lock_context { spinlock_t flc_lock; struct list_head flc_flock; struct list_head flc_posix; struct list_head flc_lease; } ;
1068 struct files_struct ;
1221 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; } ;
1256 struct sb_writers { int frozen; wait_queue_head_t wait_unfrozen; struct percpu_rw_semaphore rw_sem[3U]; } ;
1286 struct super_operations ;
1286 struct xattr_handler ;
1286 struct mtd_info ;
1286 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; const struct super_operations *s_op; const struct dquot_operations *dq_op; const struct quotactl_ops *s_qcop; const struct export_operations *s_export_op; unsigned long s_flags; unsigned long s_iflags; unsigned long s_magic; struct dentry *s_root; struct rw_semaphore s_umount; int s_count; atomic_t s_active; void *s_security; const struct xattr_handler **s_xattr; const struct fscrypt_operations *s_cop; struct hlist_bl_head s_anon; 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; unsigned int s_quota_types; 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; const struct dentry_operations *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 hlist_head s_pins; struct user_namespace *s_user_ns; struct list_lru s_dentry_lru; struct list_lru s_inode_lru; struct callback_head rcu; struct work_struct destroy_work; struct mutex s_sync_lock; int s_stack_depth; spinlock_t s_inode_list_lock; struct list_head s_inodes; spinlock_t s_inode_wblist_lock; struct list_head s_inodes_wb; } ;
1570 struct fiemap_extent_info { unsigned int fi_flags; unsigned int fi_extents_mapped; unsigned int fi_extents_max; struct fiemap_extent *fi_extents_start; } ;
1583 struct dir_context ;
1608 struct dir_context { int (*actor)(struct dir_context *, const char *, int, loff_t , u64 , unsigned int); loff_t pos; } ;
1615 struct file_operations { struct module *owner; loff_t (*llseek)(struct file *, loff_t , int); ssize_t (*read)(struct file *, char *, size_t , loff_t *); ssize_t (*write)(struct file *, const char *, size_t , loff_t *); ssize_t (*read_iter)(struct kiocb *, struct iov_iter *); ssize_t (*write_iter)(struct kiocb *, struct iov_iter *); int (*iterate)(struct file *, struct dir_context *); int (*iterate_shared)(struct file *, struct dir_context *); unsigned int (*poll)(struct file *, struct poll_table_struct *); long int (*unlocked_ioctl)(struct file *, unsigned int, unsigned long); long int (*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 (*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 int (*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 **, void **); long int (*fallocate)(struct file *, int, loff_t , loff_t ); void (*show_fdinfo)(struct seq_file *, struct file *); ssize_t (*copy_file_range)(struct file *, loff_t , struct file *, loff_t , size_t , unsigned int); int (*clone_file_range)(struct file *, loff_t , struct file *, loff_t , u64 ); ssize_t (*dedupe_file_range)(struct file *, u64 , u64 , struct file *, u64 ); } ;
1683 struct inode_operations { struct dentry * (*lookup)(struct inode *, struct dentry *, unsigned int); const char * (*get_link)(struct dentry *, struct inode *, struct delayed_call *); int (*permission)(struct inode *, int); struct posix_acl * (*get_acl)(struct inode *, int); int (*readlink)(struct dentry *, char *, int); 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 *, const char *); 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 *, unsigned int); int (*setattr)(struct dentry *, struct iattr *); int (*getattr)(struct vfsmount *, struct dentry *, struct kstat *); ssize_t (*listxattr)(struct dentry *, char *, size_t ); 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 ); int (*set_acl)(struct inode *, struct posix_acl *, int); } ;
1753 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_super)(struct super_block *); int (*freeze_fs)(struct super_block *); int (*thaw_super)(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, const char *, size_t , loff_t ); struct dquot ** (*get_dquots)(struct inode *); int (*bdev_try_to_free_page)(struct super_block *, struct page *, gfp_t ); long int (*nr_cached_objects)(struct super_block *, struct shrink_control *); long int (*free_cached_objects)(struct super_block *, struct shrink_control *); } ;
1995 struct file_system_type { const char *name; int fs_flags; struct dentry * (*mount)(struct file_system_type *, int, const char *, 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; } ;
3167 struct assoc_array_ptr ;
3167 struct assoc_array { struct assoc_array_ptr *root; unsigned long nr_leaves_on_tree; } ;
31 typedef int32_t key_serial_t;
34 typedef uint32_t key_perm_t;
35 struct key ;
36 struct user_struct ;
37 struct signal_struct ;
38 struct key_type ;
42 struct keyring_index_key { struct key_type *type; const char *description; size_t desc_len; } ;
91 union key_payload { void *rcu_data0; void *data[4U]; } ;
128 union __anonunion____missing_field_name_320 { struct list_head graveyard_link; struct rb_node serial_node; } ;
128 struct key_user ;
128 union __anonunion____missing_field_name_321 { time_t expiry; time_t revoked_at; } ;
128 struct __anonstruct____missing_field_name_323 { struct key_type *type; char *description; } ;
128 union __anonunion____missing_field_name_322 { struct keyring_index_key index_key; struct __anonstruct____missing_field_name_323 __annonCompField64; } ;
128 struct __anonstruct____missing_field_name_325 { struct list_head name_link; struct assoc_array keys; } ;
128 union __anonunion____missing_field_name_324 { union key_payload payload; struct __anonstruct____missing_field_name_325 __annonCompField66; int reject_error; } ;
128 struct key { atomic_t usage; key_serial_t serial; union __anonunion____missing_field_name_320 __annonCompField62; struct rw_semaphore sem; struct key_user *user; void *security; union __anonunion____missing_field_name_321 __annonCompField63; time_t last_used_at; kuid_t uid; kgid_t gid; key_perm_t perm; unsigned short quotalen; unsigned short datalen; unsigned long flags; union __anonunion____missing_field_name_322 __annonCompField65; union __anonunion____missing_field_name_324 __annonCompField67; int (*restrict_link)(struct key *, const struct key_type *, const union key_payload *); } ;
377 struct audit_context ;
27 struct group_info { atomic_t usage; int ngroups; kgid_t gid[0U]; } ;
85 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; kernel_cap_t cap_ambient; 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; } ;
368 struct seq_file { char *buf; size_t size; size_t from; size_t count; size_t pad_until; loff_t index; loff_t read_pos; u64 version; struct mutex lock; const struct seq_operations *op; int poll_event; const struct file *file; void *private; } ;
30 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 *); } ;
222 struct pinctrl ;
223 struct pinctrl_state ;
194 struct dev_pin_info { struct pinctrl *p; struct pinctrl_state *default_state; struct pinctrl_state *init_state; struct pinctrl_state *sleep_state; struct pinctrl_state *idle_state; } ;
84 struct plist_node { int prio; struct list_head prio_list; struct list_head node_list; } ;
4 typedef unsigned long cputime_t;
26 struct sem_undo_list ;
26 struct sysv_sem { struct sem_undo_list *undo_list; } ;
26 struct sysv_shm { struct list_head shm_clist; } ;
24 struct __anonstruct_sigset_t_326 { unsigned long sig[1U]; } ;
24 typedef struct __anonstruct_sigset_t_326 sigset_t;
25 struct siginfo ;
17 typedef void __signalfn_t(int);
18 typedef __signalfn_t *__sighandler_t;
20 typedef void __restorefn_t();
21 typedef __restorefn_t *__sigrestore_t;
38 union sigval { int sival_int; void *sival_ptr; } ;
10 typedef union sigval sigval_t;
11 struct __anonstruct__kill_328 { __kernel_pid_t _pid; __kernel_uid32_t _uid; } ;
11 struct __anonstruct__timer_329 { __kernel_timer_t _tid; int _overrun; char _pad[0U]; sigval_t _sigval; int _sys_private; } ;
11 struct __anonstruct__rt_330 { __kernel_pid_t _pid; __kernel_uid32_t _uid; sigval_t _sigval; } ;
11 struct __anonstruct__sigchld_331 { __kernel_pid_t _pid; __kernel_uid32_t _uid; int _status; __kernel_clock_t _utime; __kernel_clock_t _stime; } ;
11 struct __anonstruct__addr_bnd_334 { void *_lower; void *_upper; } ;
11 union __anonunion____missing_field_name_333 { struct __anonstruct__addr_bnd_334 _addr_bnd; __u32 _pkey; } ;
11 struct __anonstruct__sigfault_332 { void *_addr; short _addr_lsb; union __anonunion____missing_field_name_333 __annonCompField68; } ;
11 struct __anonstruct__sigpoll_335 { long _band; int _fd; } ;
11 struct __anonstruct__sigsys_336 { void *_call_addr; int _syscall; unsigned int _arch; } ;
11 union __anonunion__sifields_327 { int _pad[28U]; struct __anonstruct__kill_328 _kill; struct __anonstruct__timer_329 _timer; struct __anonstruct__rt_330 _rt; struct __anonstruct__sigchld_331 _sigchld; struct __anonstruct__sigfault_332 _sigfault; struct __anonstruct__sigpoll_335 _sigpoll; struct __anonstruct__sigsys_336 _sigsys; } ;
11 struct siginfo { int si_signo; int si_errno; int si_code; union __anonunion__sifields_327 _sifields; } ;
118 typedef struct siginfo siginfo_t;
22 struct sigpending { struct list_head list; sigset_t signal; } ;
274 struct sigaction { __sighandler_t sa_handler; unsigned long sa_flags; __sigrestore_t sa_restorer; sigset_t sa_mask; } ;
288 struct k_sigaction { struct sigaction sa; } ;
43 struct seccomp_filter ;
44 struct seccomp { int mode; struct seccomp_filter *filter; } ;
40 struct rt_mutex_waiter ;
41 struct rlimit { __kernel_ulong_t rlim_cur; __kernel_ulong_t rlim_max; } ;
11 struct timerqueue_node { struct rb_node node; ktime_t expires; } ;
12 struct timerqueue_head { struct rb_root head; struct timerqueue_node *next; } ;
50 struct hrtimer_clock_base ;
51 struct hrtimer_cpu_base ;
60 enum hrtimer_restart { HRTIMER_NORESTART = 0, HRTIMER_RESTART = 1 } ;
65 struct hrtimer { struct timerqueue_node node; ktime_t _softexpires; enum hrtimer_restart (*function)(struct hrtimer *); struct hrtimer_clock_base *base; u8 state; u8 is_rel; int start_pid; void *start_site; char start_comm[16U]; } ;
125 struct hrtimer_clock_base { struct hrtimer_cpu_base *cpu_base; int index; clockid_t clockid; struct timerqueue_head active; ktime_t (*get_time)(); ktime_t offset; } ;
158 struct hrtimer_cpu_base { raw_spinlock_t lock; seqcount_t seq; struct hrtimer *running; unsigned int cpu; unsigned int active_bases; unsigned int clock_was_set_seq; bool migration_enabled; bool nohz_active; unsigned char in_hrtirq; unsigned char hres_active; unsigned char hang_detected; ktime_t expires_next; struct hrtimer *next_timer; unsigned int nr_events; unsigned int nr_retries; unsigned int nr_hangs; unsigned int max_hang_time; struct hrtimer_clock_base clock_base[4U]; } ;
12 enum kcov_mode { KCOV_MODE_DISABLED = 0, KCOV_MODE_TRACE = 1 } ;
17 struct task_io_accounting { u64 rchar; u64 wchar; u64 syscr; u64 syscw; u64 read_bytes; u64 write_bytes; u64 cancelled_write_bytes; } ;
45 struct latency_record { unsigned long backtrace[12U]; unsigned int count; unsigned long time; unsigned long max; } ;
41 struct percpu_ref ;
55 typedef void percpu_ref_func_t(struct percpu_ref *);
68 struct percpu_ref { atomic_long_t count; unsigned long percpu_count_ptr; percpu_ref_func_t *release; percpu_ref_func_t *confirm_switch; bool force_atomic; struct callback_head rcu; } ;
607 struct cgroup ;
14 struct bpf_prog ;
14 struct cgroup_bpf { struct bpf_prog *prog[3U]; struct bpf_prog *effective[3U]; } ;
44 struct cgroup_root ;
45 struct cgroup_subsys ;
46 struct cgroup_taskset ;
90 struct cgroup_file { struct kernfs_node *kn; } ;
91 struct cgroup_subsys_state { struct cgroup *cgroup; struct cgroup_subsys *ss; struct percpu_ref refcnt; struct cgroup_subsys_state *parent; struct list_head sibling; struct list_head children; int id; unsigned int flags; u64 serial_nr; atomic_t online_cnt; struct callback_head callback_head; struct work_struct destroy_work; } ;
142 struct css_set { atomic_t refcount; struct hlist_node hlist; struct list_head tasks; struct list_head mg_tasks; struct list_head cgrp_links; struct cgroup *dfl_cgrp; struct cgroup_subsys_state *subsys[13U]; struct list_head mg_preload_node; struct list_head mg_node; struct cgroup *mg_src_cgrp; struct cgroup *mg_dst_cgrp; struct css_set *mg_dst_cset; struct list_head e_cset_node[13U]; struct list_head task_iters; bool dead; struct callback_head callback_head; } ;
222 struct cgroup { struct cgroup_subsys_state self; unsigned long flags; int id; int level; int populated_cnt; struct kernfs_node *kn; struct cgroup_file procs_file; struct cgroup_file events_file; u16 subtree_control; u16 subtree_ss_mask; u16 old_subtree_control; u16 old_subtree_ss_mask; struct cgroup_subsys_state *subsys[13U]; struct cgroup_root *root; struct list_head cset_links; struct list_head e_csets[13U]; struct list_head pidlists; struct mutex pidlist_mutex; wait_queue_head_t offline_waitq; struct work_struct release_agent_work; struct cgroup_bpf bpf; int ancestor_ids[]; } ;
310 struct cgroup_root { struct kernfs_root *kf_root; unsigned int subsys_mask; int hierarchy_id; struct cgroup cgrp; int cgrp_ancestor_id_storage; atomic_t nr_cgrps; struct list_head root_list; unsigned int flags; struct idr cgroup_idr; char release_agent_path[4096U]; char name[64U]; } ;
349 struct cftype { char name[64U]; unsigned long private; size_t max_write_len; unsigned int flags; unsigned int file_offset; struct cgroup_subsys *ss; struct list_head node; struct kernfs_ops *kf_ops; u64 (*read_u64)(struct cgroup_subsys_state *, struct cftype *); s64 (*read_s64)(struct cgroup_subsys_state *, struct cftype *); int (*seq_show)(struct seq_file *, void *); void * (*seq_start)(struct seq_file *, loff_t *); void * (*seq_next)(struct seq_file *, void *, loff_t *); void (*seq_stop)(struct seq_file *, void *); int (*write_u64)(struct cgroup_subsys_state *, struct cftype *, u64 ); int (*write_s64)(struct cgroup_subsys_state *, struct cftype *, s64 ); ssize_t (*write)(struct kernfs_open_file *, char *, size_t , loff_t ); struct lock_class_key lockdep_key; } ;
434 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_released)(struct cgroup_subsys_state *); void (*css_free)(struct cgroup_subsys_state *); void (*css_reset)(struct cgroup_subsys_state *); int (*can_attach)(struct cgroup_taskset *); void (*cancel_attach)(struct cgroup_taskset *); void (*attach)(struct cgroup_taskset *); void (*post_attach)(); int (*can_fork)(struct task_struct *); void (*cancel_fork)(struct task_struct *); void (*fork)(struct task_struct *); void (*exit)(struct task_struct *); void (*free)(struct task_struct *); void (*bind)(struct cgroup_subsys_state *); bool early_init; bool implicit_on_dfl; bool broken_hierarchy; bool warned_broken_hierarchy; int id; const char *name; const char *legacy_name; struct cgroup_root *root; struct idr css_idr; struct list_head cfts; struct cftype *dfl_cftypes; struct cftype *legacy_cftypes; unsigned int depends_on; } ;
128 struct futex_pi_state ;
129 struct robust_list_head ;
130 struct bio_list ;
131 struct fs_struct ;
132 struct perf_event_context ;
133 struct blk_plug ;
134 struct nameidata ;
188 struct cfs_rq ;
189 struct task_group ;
515 struct sighand_struct { atomic_t count; struct k_sigaction action[64U]; spinlock_t siglock; wait_queue_head_t signalfd_wqh; } ;
563 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; } ;
571 struct cpu_itimer { cputime_t expires; cputime_t incr; u32 error; u32 incr_error; } ;
578 struct prev_cputime { cputime_t utime; cputime_t stime; raw_spinlock_t lock; } ;
603 struct task_cputime { cputime_t utime; cputime_t stime; unsigned long long sum_exec_runtime; } ;
619 struct task_cputime_atomic { atomic64_t utime; atomic64_t stime; atomic64_t sum_exec_runtime; } ;
641 struct thread_group_cputimer { struct task_cputime_atomic cputime_atomic; bool running; bool checking_timer; } ;
686 struct autogroup ;
687 struct tty_struct ;
687 struct taskstats ;
687 struct tty_audit_buf ;
687 struct signal_struct { atomic_t sigcnt; atomic_t live; int nr_threads; struct list_head thread_head; 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; unsigned char has_child_subreaper; 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; seqlock_t stats_lock; cputime_t utime; cputime_t stime; cputime_t cutime; cputime_t cstime; cputime_t gtime; cputime_t cgtime; struct prev_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; struct tty_audit_buf *tty_audit_buf; bool oom_flag_origin; short oom_score_adj; short oom_score_adj_min; struct mm_struct *oom_mm; struct mutex cred_guard_mutex; } ;
863 struct user_struct { atomic_t __count; atomic_t processes; 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; unsigned long unix_inflight; atomic_long_t pipe_bufs; struct key *uid_keyring; struct key *session_keyring; struct hlist_node uidhash_node; kuid_t uid; atomic_long_t locked_vm; } ;
908 struct reclaim_state ;
909 struct sched_info { unsigned long pcount; unsigned long long run_delay; unsigned long long last_arrival; unsigned long long last_queued; } ;
924 struct task_delay_info { spinlock_t lock; unsigned int flags; u64 blkio_start; u64 blkio_delay; u64 swapin_delay; u32 blkio_count; u32 swapin_count; u64 freepages_start; u64 freepages_delay; u32 freepages_count; } ;
981 struct wake_q_node { struct wake_q_node *next; } ;
1226 struct io_context ;
1261 struct load_weight { unsigned long weight; u32 inv_weight; } ;
1269 struct sched_avg { u64 last_update_time; u64 load_sum; u32 util_sum; u32 period_contrib; unsigned long load_avg; unsigned long util_avg; } ;
1327 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; } ;
1362 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; int depth; struct sched_entity *parent; struct cfs_rq *cfs_rq; struct cfs_rq *my_q; struct sched_avg avg; } ;
1399 struct rt_rq ;
1399 struct sched_rt_entity { struct list_head run_list; unsigned long timeout; unsigned long watchdog_stamp; unsigned int time_slice; unsigned short on_rq; unsigned short on_list; struct sched_rt_entity *back; struct sched_rt_entity *parent; struct rt_rq *rt_rq; struct rt_rq *my_q; } ;
1417 struct sched_dl_entity { struct rb_node rb_node; u64 dl_runtime; u64 dl_deadline; u64 dl_period; u64 dl_bw; s64 runtime; u64 deadline; unsigned int flags; int dl_throttled; int dl_boosted; int dl_yielded; struct hrtimer dl_timer; } ;
1481 struct tlbflush_unmap_batch { struct cpumask cpumask; bool flush_required; bool writable; } ;
1500 struct sched_class ;
1500 struct compat_robust_list_head ;
1500 struct numa_group ;
1500 struct kcov ;
1500 struct task_struct { struct thread_info thread_info; volatile long state; void *stack; atomic_t usage; unsigned int flags; unsigned int ptrace; struct llist_node wake_entry; int on_cpu; unsigned int cpu; unsigned int wakee_flips; unsigned long wakee_flip_decay_ts; struct task_struct *last_wakee; int wake_cpu; int on_rq; int prio; int static_prio; int normal_prio; unsigned int rt_priority; const struct sched_class *sched_class; struct sched_entity se; struct sched_rt_entity rt; struct task_group *sched_task_group; struct sched_dl_entity dl; struct hlist_head preempt_notifiers; unsigned int policy; int nr_cpus_allowed; cpumask_t cpus_allowed; unsigned long rcu_tasks_nvcsw; bool rcu_tasks_holdout; struct list_head rcu_tasks_holdout_list; int rcu_tasks_idle_cpu; struct sched_info sched_info; struct list_head tasks; struct plist_node pushable_tasks; struct rb_node pushable_dl_tasks; struct mm_struct *mm; struct mm_struct *active_mm; u32 vmacache_seqnum; struct vm_area_struct *vmacache[4U]; struct task_rss_stat rss_stat; int exit_state; int exit_code; int exit_signal; int pdeath_signal; unsigned long jobctl; unsigned int personality; unsigned char sched_reset_on_fork; unsigned char sched_contributes_to_load; unsigned char sched_migrated; unsigned char sched_remote_wakeup; unsigned char; unsigned char in_execve; unsigned char in_iowait; unsigned char restore_sigmask; unsigned char memcg_may_oom; unsigned char memcg_kmem_skip_account; unsigned char brk_randomized; unsigned long atomic_flags; struct restart_block restart_block; pid_t pid; pid_t tgid; 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 list_head thread_node; struct completion *vfork_done; int *set_child_tid; int *clear_child_tid; cputime_t utime; cputime_t stime; cputime_t gtime; struct prev_cputime prev_cputime; unsigned long nvcsw; unsigned long nivcsw; u64 start_time; u64 real_start_time; unsigned long min_flt; unsigned long maj_flt; struct task_cputime cputime_expires; struct list_head cpu_timers[3U]; const struct cred *ptracer_cred; const struct cred *real_cred; const struct cred *cred; char comm[16U]; struct nameidata *nameidata; struct sysv_sem sysvsem; struct sysv_shm sysvshm; unsigned long last_switch_count; 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; unsigned int sas_ss_flags; 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 wake_q_node wake_q; struct rb_root pi_waiters; struct rb_node *pi_waiters_leftmost; 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; unsigned int in_ubsan; 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; int closid; 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; unsigned int numa_scan_period; unsigned int numa_scan_period_max; int numa_preferred_nid; unsigned long numa_migrate_retry; u64 node_stamp; u64 last_task_numa_placement; u64 last_sum_exec_runtime; struct callback_head numa_work; struct list_head numa_entry; struct numa_group *numa_group; unsigned long *numa_faults; unsigned long total_numa_faults; unsigned long numa_faults_locality[3U]; unsigned long numa_pages_migrated; struct tlbflush_unmap_batch tlb_ubc; 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]; u64 timer_slack_ns; u64 default_timer_slack_ns; unsigned int kasan_depth; unsigned long trace; unsigned long trace_recursion; enum kcov_mode kcov_mode; unsigned int kcov_size; void *kcov_area; struct kcov *kcov; struct mem_cgroup *memcg_in_oom; gfp_t memcg_oom_gfp_mask; int memcg_oom_order; unsigned int memcg_nr_pages_over_high; struct uprobe_task *utask; unsigned int sequential_io; unsigned int sequential_io_avg; unsigned long task_state_change; int pagefault_disabled; struct task_struct *oom_reaper_list; atomic_t stack_refcount; struct thread_struct thread; } ;
3662 struct ratelimit_state { raw_spinlock_t lock; int interval; int burst; int printed; int missed; unsigned long begin; unsigned long flags; } ;
76 struct dma_map_ops ;
76 struct dev_archdata { struct dma_map_ops *dma_ops; void *iommu; } ;
21 struct pdev_archdata { } ;
24 struct device_private ;
25 struct device_driver ;
26 struct driver_private ;
27 struct class ;
28 struct subsys_private ;
29 struct bus_type ;
30 struct device_node ;
31 struct fwnode_handle ;
32 struct iommu_ops ;
33 struct iommu_group ;
34 struct iommu_fwspec ;
62 struct device_attribute ;
62 struct bus_type { const char *name; const char *dev_name; struct device *dev_root; struct device_attribute *dev_attrs; const struct attribute_group **bus_groups; const struct attribute_group **dev_groups; const struct attribute_group **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 *); const struct dev_pm_ops *pm; const struct iommu_ops *iommu_ops; struct subsys_private *p; struct lock_class_key lock_key; } ;
143 struct device_type ;
202 enum probe_type { PROBE_DEFAULT_STRATEGY = 0, PROBE_PREFER_ASYNCHRONOUS = 1, PROBE_FORCE_SYNCHRONOUS = 2 } ;
208 struct of_device_id ;
208 struct acpi_device_id ;
208 struct device_driver { const char *name; struct bus_type *bus; struct module *owner; const char *mod_name; bool suppress_bind_attrs; enum probe_type probe_type; const struct of_device_id *of_match_table; const struct acpi_device_id *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 *); const struct attribute_group **groups; const struct dev_pm_ops *pm; struct driver_private *p; } ;
358 struct class_attribute ;
358 struct class { const char *name; struct module *owner; struct class_attribute *class_attrs; const struct attribute_group **class_groups; const struct attribute_group **dev_groups; 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 *); const struct kobj_ns_type_operations *ns_type; const void * (*namespace)(struct device *); const struct dev_pm_ops *pm; struct subsys_private *p; } ;
453 struct class_attribute { struct attribute attr; ssize_t (*show)(struct class *, struct class_attribute *, char *); ssize_t (*store)(struct class *, struct class_attribute *, const char *, size_t ); } ;
523 struct device_type { const char *name; const struct attribute_group **groups; int (*uevent)(struct device *, struct kobj_uevent_env *); char * (*devnode)(struct device *, umode_t *, kuid_t *, kgid_t *); void (*release)(struct device *); const struct dev_pm_ops *pm; } ;
551 struct device_attribute { struct attribute attr; ssize_t (*show)(struct device *, struct device_attribute *, char *); ssize_t (*store)(struct device *, struct device_attribute *, const char *, size_t ); } ;
723 struct device_dma_parameters { unsigned int max_segment_size; unsigned long segment_boundary_mask; } ;
786 enum dl_dev_state { DL_DEV_NO_DRIVER = 0, DL_DEV_PROBING = 1, DL_DEV_DRIVER_BOUND = 2, DL_DEV_UNBINDING = 3 } ;
793 struct dev_links_info { struct list_head suppliers; struct list_head consumers; enum dl_dev_state status; } ;
813 struct irq_domain ;
813 struct dma_coherent_mem ;
813 struct cma ;
813 struct device { struct device *parent; struct device_private *p; struct kobject kobj; const char *init_name; const struct device_type *type; struct mutex mutex; struct bus_type *bus; struct device_driver *driver; void *platform_data; void *driver_data; struct dev_links_info links; struct dev_pm_info power; struct dev_pm_domain *pm_domain; struct irq_domain *msi_domain; struct dev_pin_info *pins; struct list_head msi_list; int numa_node; u64 *dma_mask; u64 coherent_dma_mask; unsigned long dma_pfn_offset; struct device_dma_parameters *dma_parms; struct list_head dma_pools; struct dma_coherent_mem *dma_mem; struct cma *cma_area; struct dev_archdata archdata; struct device_node *of_node; struct fwnode_handle *fwnode; dev_t devt; u32 id; spinlock_t devres_lock; struct list_head devres_head; struct klist_node knode_class; struct class *class; const struct attribute_group **groups; void (*release)(struct device *); struct iommu_group *iommu_group; struct iommu_fwspec *iommu_fwspec; bool offline_disabled; bool offline; } ;
971 struct wakeup_source { const char *name; struct list_head entry; spinlock_t lock; struct wake_irq *wakeirq; 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; } ;
13 typedef unsigned long kernel_ulong_t;
187 struct acpi_device_id { __u8 id[9U]; kernel_ulong_t driver_data; __u32 cls; __u32 cls_msk; } ;
230 struct of_device_id { char name[32U]; char type[32U]; char compatible[128U]; const void *data; } ;
485 struct platform_device_id { char name[20U]; kernel_ulong_t driver_data; } ;
675 struct mfd_cell ;
677 struct platform_device { const char *name; int id; bool id_auto; struct device dev; u32 num_resources; struct resource *resource; const struct platform_device_id *id_entry; char *driver_override; struct mfd_cell *mfd_cell; struct pdev_archdata archdata; } ;
44 enum fwnode_type { FWNODE_INVALID = 0, FWNODE_OF = 1, FWNODE_ACPI = 2, FWNODE_ACPI_DATA = 3, FWNODE_ACPI_STATIC = 4, FWNODE_PDATA = 5, FWNODE_IRQCHIP = 6 } ;
54 struct fwnode_handle { enum fwnode_type type; struct fwnode_handle *secondary; } ;
32 typedef u32 phandle;
34 struct property { char *name; int length; void *value; struct property *next; unsigned long _flags; unsigned int unique_id; struct bin_attribute attr; } ;
44 struct device_node { const char *name; const char *type; phandle phandle; const char *full_name; struct fwnode_handle fwnode; struct property *properties; struct property *deadprops; struct device_node *parent; struct device_node *child; struct device_node *sibling; struct kobject kobj; unsigned long _flags; void *data; } ;
1290 struct irq_desc ;
1291 struct irq_data ;
13 enum irqreturn { IRQ_NONE = 0, IRQ_HANDLED = 1, IRQ_WAKE_THREAD = 2 } ;
16 typedef enum irqreturn irqreturn_t;
30 struct msi_msg ;
31 enum irqchip_irq_state ;
63 struct msi_desc ;
64 struct irq_common_data { unsigned int state_use_accessors; unsigned int node; void *handler_data; struct msi_desc *msi_desc; cpumask_var_t affinity; } ;
151 struct irq_chip ;
151 struct irq_data { u32 mask; unsigned int irq; unsigned long hwirq; struct irq_common_data *common; struct irq_chip *chip; struct irq_domain *domain; struct irq_data *parent_data; void *chip_data; } ;
321 struct irq_chip { struct device *parent_device; const char *name; unsigned int (*irq_startup)(struct irq_data *); void (*irq_shutdown)(struct irq_data *); void (*irq_enable)(struct irq_data *); void (*irq_disable)(struct irq_data *); void (*irq_ack)(struct irq_data *); void (*irq_mask)(struct irq_data *); void (*irq_mask_ack)(struct irq_data *); void (*irq_unmask)(struct irq_data *); void (*irq_eoi)(struct irq_data *); int (*irq_set_affinity)(struct irq_data *, const struct cpumask *, bool ); int (*irq_retrigger)(struct irq_data *); int (*irq_set_type)(struct irq_data *, unsigned int); int (*irq_set_wake)(struct irq_data *, unsigned int); void (*irq_bus_lock)(struct irq_data *); void (*irq_bus_sync_unlock)(struct irq_data *); void (*irq_cpu_online)(struct irq_data *); void (*irq_cpu_offline)(struct irq_data *); void (*irq_suspend)(struct irq_data *); void (*irq_resume)(struct irq_data *); void (*irq_pm_shutdown)(struct irq_data *); void (*irq_calc_mask)(struct irq_data *); void (*irq_print_chip)(struct irq_data *, struct seq_file *); int (*irq_request_resources)(struct irq_data *); void (*irq_release_resources)(struct irq_data *); void (*irq_compose_msi_msg)(struct irq_data *, struct msi_msg *); void (*irq_write_msi_msg)(struct irq_data *, struct msi_msg *); int (*irq_get_irqchip_state)(struct irq_data *, enum irqchip_irq_state , bool *); int (*irq_set_irqchip_state)(struct irq_data *, enum irqchip_irq_state , bool ); int (*irq_set_vcpu_affinity)(struct irq_data *, void *); void (*ipi_send_single)(struct irq_data *, unsigned int); void (*ipi_send_mask)(struct irq_data *, const struct cpumask *); unsigned long flags; } ;
422 struct irq_affinity_notify ;
423 struct proc_dir_entry ;
424 struct irqaction ;
424 struct irq_desc { struct irq_common_data irq_common_data; struct irq_data irq_data; unsigned int *kstat_irqs; void (*handle_irq)(struct irq_desc *); struct irqaction *action; unsigned int status_use_accessors; unsigned int core_internal_state__do_not_mess_with_it; unsigned int depth; unsigned int wake_depth; unsigned int irq_count; unsigned long last_unhandled; unsigned int irqs_unhandled; atomic_t threads_handled; int threads_handled_last; raw_spinlock_t lock; struct cpumask *percpu_enabled; const struct cpumask *percpu_affinity; const struct cpumask *affinity_hint; struct irq_affinity_notify *affinity_notify; cpumask_var_t pending_mask; unsigned long threads_oneshot; atomic_t threads_active; wait_queue_head_t wait_for_threads; unsigned int nr_actions; unsigned int no_suspend_depth; unsigned int cond_suspend_depth; unsigned int force_resume_depth; struct proc_dir_entry *dir; struct callback_head rcu; struct kobject kobj; int parent_irq; struct module *owner; const char *name; } ;
133 struct exception_table_entry { int insn; int fixup; int handler; } ;
739 struct irq_chip_regs { unsigned long enable; unsigned long disable; unsigned long mask; unsigned long ack; unsigned long eoi; unsigned long type; unsigned long polarity; } ;
778 struct irq_chip_type { struct irq_chip chip; struct irq_chip_regs regs; void (*handler)(struct irq_desc *); u32 type; u32 mask_cache_priv; u32 *mask_cache; } ;
800 struct irq_chip_generic { raw_spinlock_t lock; void *reg_base; u32 (*reg_readl)(void *); void (*reg_writel)(u32 , void *); void (*suspend)(struct irq_chip_generic *); void (*resume)(struct irq_chip_generic *); unsigned int irq_base; unsigned int irq_cnt; u32 mask_cache; u32 type_cache; u32 polarity_cache; u32 wake_enabled; u32 wake_active; unsigned int num_ct; void *private; unsigned long installed; unsigned long unused; struct irq_domain *domain; struct list_head list; struct irq_chip_type chip_types[0U]; } ;
856 enum irq_gc_flags { IRQ_GC_INIT_MASK_CACHE = 1, IRQ_GC_INIT_NESTED_LOCK = 2, IRQ_GC_MASK_CACHE_PER_TYPE = 4, IRQ_GC_NO_MASK = 8, IRQ_GC_BE_IO = 16 } ;
864 struct irq_domain_chip_generic { unsigned int irqs_per_chip; unsigned int num_chips; unsigned int irq_flags_to_clear; unsigned int irq_flags_to_set; enum irq_gc_flags gc_flags; struct irq_chip_generic *gc[0U]; } ;
51 struct irq_fwspec { struct fwnode_handle *fwnode; int param_count; u32 param[16U]; } ;
64 enum irq_domain_bus_token { DOMAIN_BUS_ANY = 0, DOMAIN_BUS_WIRED = 1, DOMAIN_BUS_PCI_MSI = 2, DOMAIN_BUS_PLATFORM_MSI = 3, DOMAIN_BUS_NEXUS = 4, DOMAIN_BUS_IPI = 5, DOMAIN_BUS_FSL_MC_MSI = 6 } ;
74 struct irq_domain_ops { int (*match)(struct irq_domain *, struct device_node *, enum irq_domain_bus_token ); int (*select)(struct irq_domain *, struct irq_fwspec *, enum irq_domain_bus_token ); int (*map)(struct irq_domain *, unsigned int, irq_hw_number_t ); void (*unmap)(struct irq_domain *, unsigned int); int (*xlate)(struct irq_domain *, struct device_node *, const u32 *, unsigned int, unsigned long *, unsigned int *); int (*alloc)(struct irq_domain *, unsigned int, unsigned int, void *); void (*free)(struct irq_domain *, unsigned int, unsigned int); void (*activate)(struct irq_domain *, struct irq_data *); void (*deactivate)(struct irq_domain *, struct irq_data *); int (*translate)(struct irq_domain *, struct irq_fwspec *, unsigned long *, unsigned int *); } ;
122 struct irq_domain { struct list_head link; const char *name; const struct irq_domain_ops *ops; void *host_data; unsigned int flags; struct fwnode_handle *fwnode; enum irq_domain_bus_token bus_token; struct irq_domain_chip_generic *gc; struct irq_domain *parent; irq_hw_number_t hwirq_max; unsigned int revmap_direct_max_irq; unsigned int revmap_size; struct radix_tree_root revmap_tree; unsigned int linear_revmap[]; } ;
93 struct irqaction { irqreturn_t (*handler)(int, void *); void *dev_id; void *percpu_dev_id; struct irqaction *next; irqreturn_t (*thread_fn)(int, void *); struct task_struct *thread; struct irqaction *secondary; unsigned int irq; unsigned int flags; unsigned long thread_flags; unsigned long thread_mask; const char *name; struct proc_dir_entry *dir; } ;
214 struct irq_affinity_notify { unsigned int irq; struct kref kref; struct work_struct work; void (*notify)(struct irq_affinity_notify *, const cpumask_t *); void (*release)(struct kref *); } ;
404 enum irqchip_irq_state { IRQCHIP_STATE_PENDING = 0, IRQCHIP_STATE_ACTIVE = 1, IRQCHIP_STATE_MASKED = 2, IRQCHIP_STATE_LINE_LEVEL = 3 } ;
506 struct tasklet_struct { struct tasklet_struct *next; unsigned long state; atomic_t count; void (*func)(unsigned long); unsigned long data; } ;
729 struct mmc_data ;
730 struct mmc_request ;
731 enum mmc_blk_status { MMC_BLK_SUCCESS = 0, MMC_BLK_PARTIAL = 1, MMC_BLK_CMD_ERR = 2, MMC_BLK_RETRY = 3, MMC_BLK_ABORT = 4, MMC_BLK_DATA_ERR = 5, MMC_BLK_ECC_ERR = 6, MMC_BLK_NOMEDIUM = 7, MMC_BLK_NEW_REQUEST = 8 } ;
743 struct mmc_command { u32 opcode; u32 arg; u32 resp[4U]; unsigned int flags; unsigned int retries; int error; unsigned int busy_timeout; bool sanitize_busy; struct mmc_data *data; struct mmc_request *mrq; } ;
120 struct scatterlist ;
120 struct mmc_data { unsigned int timeout_ns; unsigned int timeout_clks; unsigned int blksz; unsigned int blocks; int error; unsigned int flags; unsigned int bytes_xfered; struct mmc_command *stop; struct mmc_request *mrq; unsigned int sg_len; int sg_count; struct scatterlist *sg; s32 host_cookie; } ;
142 struct mmc_host ;
143 struct mmc_request { struct mmc_command *sbc; struct mmc_command *cmd; struct mmc_data *data; struct mmc_command *stop; struct completion completion; struct completion cmd_completion; void (*done)(struct mmc_request *); struct mmc_host *host; bool cap_cmd_during_tfr; } ;
158 struct mmc_card ;
159 struct mmc_async_req ;
236 struct mmc_cid { unsigned int manfid; char prod_name[8U]; unsigned char prv; unsigned int serial; unsigned short oemid; unsigned short year; unsigned char hwrev; unsigned char fwrev; unsigned char month; } ;
28 struct mmc_csd { unsigned char structure; unsigned char mmca_vsn; unsigned short cmdclass; unsigned short tacc_clks; unsigned int tacc_ns; unsigned int c_size; unsigned int r2w_factor; unsigned int max_dtr; unsigned int erase_size; unsigned int read_blkbits; unsigned int write_blkbits; unsigned int capacity; unsigned char read_partial; unsigned char read_misalign; unsigned char write_partial; unsigned char write_misalign; unsigned char dsr_imp; } ;
48 struct mmc_ext_csd { u8 rev; u8 erase_group_def; u8 sec_feature_support; u8 rel_sectors; u8 rel_param; u8 part_config; u8 cache_ctrl; u8 rst_n_function; u8 max_packed_writes; u8 max_packed_reads; u8 packed_event_en; unsigned int part_time; unsigned int sa_timeout; unsigned int generic_cmd6_time; unsigned int power_off_longtime; u8 power_off_notification; unsigned int hs_max_dtr; unsigned int hs200_max_dtr; unsigned int sectors; unsigned int hc_erase_size; unsigned int hc_erase_timeout; unsigned int sec_trim_mult; unsigned int sec_erase_mult; unsigned int trim_timeout; bool partition_setting_completed; unsigned long long enhanced_area_offset; unsigned int enhanced_area_size; unsigned int cache_size; bool hpi_en; bool hpi; unsigned int hpi_cmd; bool bkops; bool man_bkops_en; unsigned int data_sector_size; unsigned int data_tag_unit_size; unsigned int boot_ro_lock; bool boot_ro_lockable; bool ffu_capable; bool cmdq_support; unsigned int cmdq_depth; u8 fwrev[8U]; u8 raw_exception_status; u8 raw_partition_support; u8 raw_rpmb_size_mult; u8 raw_erased_mem_count; u8 strobe_support; u8 raw_ext_csd_structure; u8 raw_card_type; u8 raw_driver_strength; u8 out_of_int_time; u8 raw_pwr_cl_52_195; u8 raw_pwr_cl_26_195; u8 raw_pwr_cl_52_360; u8 raw_pwr_cl_26_360; u8 raw_s_a_timeout; u8 raw_hc_erase_gap_size; u8 raw_erase_timeout_mult; u8 raw_hc_erase_grp_size; u8 raw_sec_trim_mult; u8 raw_sec_erase_mult; u8 raw_sec_feature_support; u8 raw_trim_mult; u8 raw_pwr_cl_200_195; u8 raw_pwr_cl_200_360; u8 raw_pwr_cl_ddr_52_195; u8 raw_pwr_cl_ddr_52_360; u8 raw_pwr_cl_ddr_200_360; u8 raw_bkops_status; u8 raw_sectors[4U]; unsigned int feature_support; } ;
127 struct sd_scr { unsigned char sda_vsn; unsigned char sda_spec3; unsigned char bus_widths; unsigned char cmds; } ;
137 struct sd_ssr { unsigned int au; unsigned int erase_timeout; unsigned int erase_offset; } ;
145 struct sd_switch_caps { unsigned int hs_max_dtr; unsigned int uhs_max_dtr; unsigned int sd3_bus_mode; unsigned int sd3_drv_type; unsigned int sd3_curr_limit; } ;
176 struct sdio_cccr { unsigned int sdio_vsn; unsigned int sd_vsn; unsigned char multi_block; unsigned char low_speed; unsigned char wide_bus; unsigned char high_power; unsigned char high_speed; unsigned char disable_cd; } ;
197 struct sdio_cis { unsigned short vendor; unsigned short device; unsigned short blksize; unsigned int max_dtr; } ;
204 struct mmc_ios ;
205 struct sdio_func ;
206 struct sdio_func_tuple ;
207 struct mmc_part { unsigned int size; unsigned int part_cfg; char name[20U]; bool force_ro; unsigned int area_type; } ;
231 struct mmc_card { struct mmc_host *host; struct device dev; u32 ocr; unsigned int rca; unsigned int type; unsigned int state; unsigned int quirks; unsigned int erase_size; unsigned int erase_shift; unsigned int pref_erase; unsigned int eg_boundary; u8 erased_byte; u32 raw_cid[4U]; u32 raw_csd[4U]; u32 raw_scr[2U]; u32 raw_ssr[16U]; struct mmc_cid cid; struct mmc_csd csd; struct mmc_ext_csd ext_csd; struct sd_scr scr; struct sd_ssr ssr; struct sd_switch_caps sw_caps; unsigned int sdio_funcs; struct sdio_cccr cccr; struct sdio_cis cis; struct sdio_func *sdio_func[7U]; struct sdio_func *sdio_single_irq; unsigned int num_info; const char **info; struct sdio_func_tuple *tuples; unsigned int sd_bus_speed; unsigned int mmc_avail_type; unsigned int drive_strength; struct dentry *debugfs_root; struct mmc_part part[7U]; unsigned int nr_parts; } ;
550 enum led_brightness { LED_OFF = 0, LED_HALF = 127, LED_FULL = 255 } ;
556 struct led_trigger ;
556 struct led_classdev { const char *name; enum led_brightness brightness; enum led_brightness max_brightness; int flags; unsigned long work_flags; void (*brightness_set)(struct led_classdev *, enum led_brightness ); int (*brightness_set_blocking)(struct led_classdev *, enum led_brightness ); enum led_brightness (*brightness_get)(struct led_classdev *); int (*blink_set)(struct led_classdev *, unsigned long *, unsigned long *); struct device *dev; const struct attribute_group **groups; struct list_head node; const char *default_trigger; unsigned long blink_delay_on; unsigned long blink_delay_off; struct timer_list blink_timer; int blink_brightness; int new_blink_brightness; void (*flash_resume)(struct led_classdev *); struct work_struct set_brightness_work; int delayed_set_value; struct rw_semaphore trigger_lock; struct led_trigger *trigger; struct list_head trig_list; void *trigger_data; bool activated; struct mutex led_access; } ;
226 struct led_trigger { const char *name; void (*activate)(struct led_classdev *); void (*deactivate)(struct led_classdev *); rwlock_t leddev_list_lock; struct list_head led_cdevs; struct list_head next_trig; } ;
172 struct fault_attr { unsigned long probability; unsigned long interval; atomic_t times; atomic_t space; unsigned long verbose; bool task_filter; unsigned long stacktrace_depth; unsigned long require_start; unsigned long require_end; unsigned long reject_start; unsigned long reject_end; unsigned long count; struct ratelimit_state ratelimit_state; struct dentry *dname; } ;
25 typedef unsigned int mmc_pm_flag_t;
26 struct mmc_ios { unsigned int clock; unsigned short vdd; unsigned char bus_mode; unsigned char chip_select; unsigned char power_mode; unsigned char bus_width; unsigned char timing; unsigned char signal_voltage; unsigned char drv_type; bool enhanced_strobe; } ;
84 struct mmc_host_ops { void (*post_req)(struct mmc_host *, struct mmc_request *, int); void (*pre_req)(struct mmc_host *, struct mmc_request *); void (*request)(struct mmc_host *, struct mmc_request *); void (*set_ios)(struct mmc_host *, struct mmc_ios *); int (*get_ro)(struct mmc_host *); int (*get_cd)(struct mmc_host *); void (*enable_sdio_irq)(struct mmc_host *, int); void (*init_card)(struct mmc_host *, struct mmc_card *); int (*start_signal_voltage_switch)(struct mmc_host *, struct mmc_ios *); int (*card_busy)(struct mmc_host *); int (*execute_tuning)(struct mmc_host *, u32 ); int (*prepare_hs400_tuning)(struct mmc_host *, struct mmc_ios *); void (*hs400_enhanced_strobe)(struct mmc_host *, struct mmc_ios *); int (*select_drive_strength)(struct mmc_card *, unsigned int, int, int, int *); void (*hw_reset)(struct mmc_host *); void (*card_event)(struct mmc_host *); int (*multi_io_quirk)(struct mmc_card *, unsigned int, int); } ;
163 struct mmc_async_req { struct mmc_request *mrq; enum mmc_blk_status (*err_check)(struct mmc_card *, struct mmc_async_req *); } ;
177 struct mmc_slot { int cd_irq; void *handler_priv; } ;
193 struct mmc_context_info { bool is_done_rcv; bool is_new_req; bool is_waiting_last_req; wait_queue_head_t wait; } ;
207 struct regulator ;
208 struct mmc_pwrseq ;
209 struct mmc_supply { struct regulator *vmmc; struct regulator *vqmmc; } ;
215 struct mmc_bus_ops ;
215 struct mmc_host { struct device *parent; struct device class_dev; int index; const struct mmc_host_ops *ops; struct mmc_pwrseq *pwrseq; unsigned int f_min; unsigned int f_max; unsigned int f_init; u32 ocr_avail; u32 ocr_avail_sdio; u32 ocr_avail_sd; u32 ocr_avail_mmc; struct notifier_block pm_notify; u32 max_current_330; u32 max_current_300; u32 max_current_180; u32 caps; u32 caps2; mmc_pm_flag_t pm_caps; unsigned int max_seg_size; unsigned short max_segs; unsigned short unused; unsigned int max_req_size; unsigned int max_blk_size; unsigned int max_blk_count; unsigned int max_busy_timeout; spinlock_t lock; struct mmc_ios ios; unsigned char use_spi_crc; unsigned char claimed; unsigned char bus_dead; unsigned char removed; unsigned char can_retune; unsigned char doing_retune; unsigned char retune_now; unsigned char retune_paused; int rescan_disable; int rescan_entered; int need_retune; int hold_retune; unsigned int retune_period; struct timer_list retune_timer; bool trigger_card_event; struct mmc_card *card; wait_queue_head_t wq; struct task_struct *claimer; int claim_cnt; struct delayed_work detect; int detect_change; struct mmc_slot slot; const struct mmc_bus_ops *bus_ops; unsigned int bus_refs; unsigned int sdio_irqs; struct task_struct *sdio_irq_thread; bool sdio_irq_pending; atomic_t sdio_irq_thread_abort; mmc_pm_flag_t pm_flags; struct led_trigger *led; bool regulator_enabled; struct mmc_supply supply; struct dentry *debugfs_root; struct mmc_async_req *areq; struct mmc_context_info context_info; struct mmc_request *ongoing_mrq; struct fault_attr fail_mmc_request; unsigned int actual_clock; unsigned int slotno; int dsr_req; u32 dsr; unsigned long private[0U]; } ;
548 struct sdhci_pxa_platdata { unsigned int flags; unsigned int clk_delay_cycles; unsigned int clk_delay_sel; bool clk_delay_enable; unsigned int ext_cd_gpio; bool ext_cd_gpio_invert; unsigned int max_speed; u32 host_caps; u32 host_caps2; unsigned int quirks; unsigned int quirks2; unsigned int pm_caps; } ;
273 struct vm_fault { struct vm_area_struct *vma; unsigned int flags; gfp_t gfp_mask; unsigned long pgoff; unsigned long address; pmd_t *pmd; pte_t orig_pte; struct page *cow_page; struct mem_cgroup *memcg; struct page *page; pte_t *pte; spinlock_t *ptl; pgtable_t prealloc_pte; } ;
322 struct vm_operations_struct { void (*open)(struct vm_area_struct *); void (*close)(struct vm_area_struct *); int (*mremap)(struct vm_area_struct *); int (*fault)(struct vm_area_struct *, struct vm_fault *); int (*pmd_fault)(struct vm_area_struct *, unsigned long, pmd_t *, unsigned int); void (*map_pages)(struct vm_fault *, unsigned long, unsigned long); int (*page_mkwrite)(struct vm_area_struct *, struct vm_fault *); int (*pfn_mkwrite)(struct vm_area_struct *, struct vm_fault *); int (*access)(struct vm_area_struct *, unsigned long, void *, int, int); const char * (*name)(struct vm_area_struct *); int (*set_policy)(struct vm_area_struct *, struct mempolicy *); struct mempolicy * (*get_policy)(struct vm_area_struct *, unsigned long); struct page * (*find_special_page)(struct vm_area_struct *, unsigned long); } ;
2439 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; } ;
310 struct sg_page_iter { struct scatterlist *sg; unsigned int sg_pgoffset; unsigned int __nents; int __pg_advance; } ;
355 struct sg_mapping_iter { struct page *page; void *addr; size_t length; size_t consumed; struct sg_page_iter piter; unsigned int __offset; unsigned int __remaining; unsigned int __flags; } ;
317 struct sdhci_ops ;
317 struct sdhci_host { const char *hw_name; unsigned int quirks; unsigned int quirks2; int irq; void *ioaddr; const struct sdhci_ops *ops; struct mmc_host *mmc; struct mmc_host_ops mmc_host_ops; u64 dma_mask; struct led_classdev led; char led_name[32U]; spinlock_t lock; int flags; unsigned int version; unsigned int max_clk; unsigned int timeout_clk; unsigned int clk_mul; unsigned int clock; u8 pwr; bool runtime_suspended; bool bus_on; bool preset_enabled; bool pending_reset; struct mmc_request *mrqs_done[2U]; struct mmc_command *cmd; struct mmc_command *data_cmd; struct mmc_data *data; unsigned char data_early; struct sg_mapping_iter sg_miter; unsigned int blocks; int sg_count; void *adma_table; void *align_buffer; size_t adma_table_sz; size_t align_buffer_sz; dma_addr_t adma_addr; dma_addr_t align_addr; unsigned int desc_sz; struct tasklet_struct finish_tasklet; struct timer_list timer; struct timer_list data_timer; u32 caps; u32 caps1; bool read_caps; unsigned int ocr_avail_sdio; unsigned int ocr_avail_sd; unsigned int ocr_avail_mmc; u32 ocr_mask; unsigned int timing; u32 thread_isr; u32 ier; wait_queue_head_t buf_ready_int; unsigned int tuning_done; unsigned int tuning_count; unsigned int tuning_mode; unsigned long private[0U]; } ;
530 struct sdhci_ops { u32 (*read_l)(struct sdhci_host *, int); u16 (*read_w)(struct sdhci_host *, int); u8 (*read_b)(struct sdhci_host *, int); void (*write_l)(struct sdhci_host *, u32 , int); void (*write_w)(struct sdhci_host *, u16 , int); void (*write_b)(struct sdhci_host *, u8 , int); void (*set_clock)(struct sdhci_host *, unsigned int); void (*set_power)(struct sdhci_host *, unsigned char, unsigned short); int (*enable_dma)(struct sdhci_host *); unsigned int (*get_max_clock)(struct sdhci_host *); unsigned int (*get_min_clock)(struct sdhci_host *); unsigned int (*get_timeout_clock)(struct sdhci_host *); unsigned int (*get_max_timeout_count)(struct sdhci_host *); void (*set_timeout)(struct sdhci_host *, struct mmc_command *); void (*set_bus_width)(struct sdhci_host *, int); void (*platform_send_init_74_clocks)(struct sdhci_host *, u8 ); unsigned int (*get_ro)(struct sdhci_host *); void (*reset)(struct sdhci_host *, u8 ); int (*platform_execute_tuning)(struct sdhci_host *, u32 ); void (*set_uhs_signaling)(struct sdhci_host *, unsigned int); void (*hw_reset)(struct sdhci_host *); void (*adma_workaround)(struct sdhci_host *, u32 ); void (*card_event)(struct sdhci_host *); void (*voltage_switch)(struct sdhci_host *); int (*select_drive_strength)(struct sdhci_host *, struct mmc_card *, unsigned int, int, int, int *); } ;
701 struct sdhci_pltfm_data { const struct sdhci_ops *ops; unsigned int quirks; unsigned int quirks2; } ;
23 struct sdhci_pltfm_host { struct clk *clk; unsigned int clock; u16 xfer_mode_shadow; unsigned long private[0U]; } ;
3 bool ldv_is_err(const void *ptr);
6 long int ldv_ptr_err(const void *ptr);
32 long int PTR_ERR(const void *ptr);
41 bool IS_ERR(const void *ptr);
56 unsigned char readb(const volatile void *addr);
57 unsigned short int readw(const volatile void *addr);
64 void writeb(unsigned char val, volatile void *addr);
65 void writew(unsigned short val, volatile void *addr);
11 void ldv_clk_disable_clk(struct clk *clk);
12 int ldv_clk_enable_clk();
13 void ldv_clk_disable_clk_of_sdhci_pltfm_host(struct clk *clk);
656 void * devm_kmalloc(struct device *, size_t , gfp_t );
662 void * devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
1021 void * dev_get_drvdata(const struct device *dev);
1026 void dev_set_drvdata(struct device *dev, void *data);
1248 void dev_err(const struct device *, const char *, ...);
211 void * platform_get_drvdata(const struct platform_device *pdev);
216 void platform_set_drvdata(struct platform_device *pdev, void *data);
230 struct clk * clk_get(struct device *, const char *);
282 int ldv_clk_enable_5(struct clk *clk);
298 void ldv_clk_disable_6(struct clk *clk);
314 void clk_put(struct clk *);
525 int ldv_clk_prepare_enable_7(struct clk *clk);
536 void ldv_clk_disable_unprepare_8(struct clk *clk);
540 void ldv_clk_disable_unprepare_9(struct clk *clk);
286 struct property * of_find_property(const struct device_node *, const char *, int *);
300 int of_property_read_variable_u32_array(const struct device_node *, const char *, u32 *, size_t , size_t );
463 int of_property_read_u32_array(const struct device_node *np, const char *propname, u32 *out_values, size_t sz);
1038 int of_property_read_u32(const struct device_node *np, const char *propname, u32 *out_value);
14 const struct of_device_id * of_match_device(const struct of_device_id *, const struct device *);
657 void * sdhci_priv(struct sdhci_host *host);
667 int sdhci_add_host(struct sdhci_host *);
668 void sdhci_remove_host(struct sdhci_host *, int);
684 void sdhci_set_clock(struct sdhci_host *, unsigned int);
691 void sdhci_reset(struct sdhci_host *, u8 );
692 void sdhci_set_uhs_signaling(struct sdhci_host *, unsigned int);
95 struct sdhci_host * sdhci_pltfm_init(struct platform_device *, const struct sdhci_pltfm_data *, size_t );
98 void sdhci_pltfm_free(struct platform_device *);
105 unsigned int sdhci_pltfm_clk_get_max_clock(struct sdhci_host *);
55 void pxav2_reset(struct sdhci_host *host, u8 mask);
94 void pxav2_mmc_set_bus_width(struct sdhci_host *host, int width);
115 const struct sdhci_ops pxav2_sdhci_ops = { 0, 0, 0, 0, 0, 0, &sdhci_set_clock, 0, 0, &sdhci_pltfm_clk_get_max_clock, 0, 0, 0, 0, &pxav2_mmc_set_bus_width, 0, 0, &pxav2_reset, 0, &sdhci_set_uhs_signaling, 0, 0, 0, 0, 0 };
124 const struct of_device_id sdhci_pxav2_of_match[2U] = { { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 'm', 'r', 'v', 'l', ',', 'p', 'x', 'a', 'v', '2', '-', 'm', 'm', 'c', '\x0' }, 0 } };
130 const struct of_device_id __mod_of__sdhci_pxav2_of_match_device_table[2U] = { };
132 struct sdhci_pxa_platdata * pxav2_get_mmc_pdata(struct device *dev);
165 int sdhci_pxav2_probe(struct platform_device *pdev);
238 int sdhci_pxav2_remove(struct platform_device *pdev);
285 void ldv_check_final_state();
288 void ldv_check_return_value(int);
291 void ldv_check_return_value_probe(int);
294 void ldv_initialize();
297 void ldv_handler_precall();
300 int nondet_int();
303 int LDV_IN_INTERRUPT = 0;
306 void ldv_main0_sequence_infinite_withcheck_stateful();
10 void ldv_error();
25 int ldv_undef_int();
14 void * ldv_err_ptr(long error);
28 bool ldv_is_err_or_null(const void *ptr);
9 int ldv_counter_clk = 0;
34 int ldv_counter_clk_of_sdhci_pltfm_host = 0;
46 int ldv_clk_enable_clk_of_sdhci_pltfm_host();
return ;
}
-entry_point
{
308 struct sdhci_host *var_group1;
309 int var_pxav2_mmc_set_bus_width_1_p1;
310 unsigned char var_pxav2_reset_0_p1;
311 struct platform_device *var_group2;
312 int res_sdhci_pxav2_probe_4;
313 int ldv_s_sdhci_pxav2_driver_platform_driver;
314 int tmp;
315 int tmp___0;
428 ldv_s_sdhci_pxav2_driver_platform_driver = 0;
416 LDV_IN_INTERRUPT = 1;
425 ldv_initialize() { /* Function call is skipped due to function is undefined */}
431 goto ldv_36436;
431 tmp___0 = nondet_int() { /* Function call is skipped due to function is undefined */}
431 assume(tmp___0 != 0);
434 goto ldv_36435;
432 ldv_36435:;
435 tmp = nondet_int() { /* Function call is skipped due to function is undefined */}
435 switch (tmp);
436 assume(!(tmp == 0));
474 assume(!(tmp == 1));
511 assume(tmp == 2);
514 assume(ldv_s_sdhci_pxav2_driver_platform_driver == 0);
537 -sdhci_pxav2_probe(var_group2)
{
167 struct sdhci_pltfm_host *pltfm_host;
168 struct sdhci_pxa_platdata *pdata;
169 struct device *dev;
170 struct sdhci_host *host;
171 const struct of_device_id *match;
172 int ret;
173 struct clk *clk;
174 long tmp;
175 _Bool tmp___0;
176 void *tmp___1;
177 long tmp___2;
178 _Bool tmp___3;
168 pdata = (struct sdhci_pxa_platdata *)(pdev->dev.platform_data);
169 dev = &(pdev->dev);
170 host = (struct sdhci_host *)0;
176 host = sdhci_pltfm_init(pdev, (const struct sdhci_pltfm_data *)0, 0UL) { /* Function call is skipped due to function is undefined */}
177 -IS_ERR((const void *)host)
{
30 _Bool tmp;
31 -ldv_is_err(ptr)
{
10 return ((unsigned long)ptr) > 2012UL;;
}
31 return tmp;;
}
177 assume(((int)tmp___0) == 0);
180 -sdhci_priv(host)
{
659 return (void *)(&(host->private));;
}
180 pltfm_host = (struct sdhci_pltfm_host *)tmp___1;
182 clk = clk_get(dev, "PXA-SDHCLK") { /* Function call is skipped due to function is undefined */}
183 -IS_ERR((const void *)clk)
{
30 _Bool tmp;
31 -ldv_is_err(ptr)
{
10 return ((unsigned long)ptr) > 2012UL;;
}
31 return tmp;;
}
183 assume(((int)tmp___3) == 0);
188 pltfm_host->clk = clk;
189 -ldv_clk_prepare_enable_7(clk)
{
54 int tmp;
55 -ldv_clk_enable_clk()
{
23 int retval;
24 int tmp;
23 tmp = ldv_undef_int() { /* Function call is skipped due to function is undefined */}
23 retval = tmp;
24 assume(!(retval == 0));
29 return retval;;
}
55 return tmp;;
}
191 host->quirks = 33558592U;
195 match = of_match_device((const struct of_device_id *)(&sdhci_pxav2_of_match), (const struct device *)(&(pdev->dev))) { /* Function call is skipped due to function is undefined */}
196 assume(!(((unsigned long)match) != ((unsigned long)((const struct of_device_id *)0))));
199 assume(((unsigned long)pdata) != ((unsigned long)((struct sdhci_pxa_platdata *)0)));
200 assume(((pdata->flags) & 2U) != 0U);
202 host->quirks = (host->quirks) | 32768U;
203 host->mmc->caps = (host->mmc->caps) | 256U;
207 assume(((pdata->flags) & 4U) != 0U);
208 host->mmc->caps = (host->mmc->caps) | 64U;
210 assume((pdata->quirks) != 0U);
211 host->quirks = (host->quirks) | (pdata->quirks);
212 assume((pdata->host_caps) != 0U);
213 host->mmc->caps = (host->mmc->caps) | (pdata->host_caps);
214 assume(!((pdata->pm_caps) != 0U));
218 host->ops = &pxav2_sdhci_ops;
220 ret = sdhci_add_host(host) { /* Function call is skipped due to function is undefined */}
221 assume(ret != 0);
222 dev_err((const struct device *)(&(pdev->dev)), "failed to add host\n") { /* Function call is skipped due to function is undefined */}
223 goto err_add_host;
229 err_add_host:;
231 -ldv_clk_disable_unprepare_8(clk)
{
61 -ldv_clk_disable_clk(clk)
{
15 assume(ldv_counter_clk != 1);
15 -ldv_error()
{
15 LDV_ERROR:;
}
}
}
}
}
Source code
1 2 /* 3 * Copyright (C) 2010 Marvell International Ltd. 4 * Zhangfei Gao <zhangfei.gao@marvell.com> 5 * Kevin Wang <dwang4@marvell.com> 6 * Jun Nie <njun@marvell.com> 7 * Qiming Wu <wuqm@marvell.com> 8 * Philip Rakity <prakity@marvell.com> 9 * 10 * This software is licensed under the terms of the GNU General Public 11 * License version 2, as published by the Free Software Foundation, and 12 * may be copied, distributed, and modified under those terms. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 */ 20 21 #include <linux/err.h> 22 #include <linux/init.h> 23 #include <linux/platform_device.h> 24 #include <linux/clk.h> 25 #include <linux/module.h> 26 #include <linux/io.h> 27 #include <linux/gpio.h> 28 #include <linux/mmc/card.h> 29 #include <linux/mmc/host.h> 30 #include <linux/platform_data/pxa_sdhci.h> 31 #include <linux/slab.h> 32 #include <linux/of.h> 33 #include <linux/of_device.h> 34 35 #include "sdhci.h" 36 #include "sdhci-pltfm.h" 37 38 #define SD_FIFO_PARAM 0xe0 39 #define DIS_PAD_SD_CLK_GATE 0x0400 /* Turn on/off Dynamic SD Clock Gating */ 40 #define CLK_GATE_ON 0x0200 /* Disable/enable Clock Gate */ 41 #define CLK_GATE_CTL 0x0100 /* Clock Gate Control */ 42 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 43 CLK_GATE_ON | CLK_GATE_CTL) 44 45 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 46 #define SDCLK_SEL_SHIFT 8 47 #define SDCLK_SEL_MASK 0x3 48 #define SDCLK_DELAY_SHIFT 10 49 #define SDCLK_DELAY_MASK 0x3c 50 51 #define SD_CE_ATA_2 0xea 52 #define MMC_CARD 0x1000 53 #define MMC_WIDTH 0x0100 54 55 static void pxav2_reset(struct sdhci_host *host, u8 mask) 56 { 57 struct platform_device *pdev = to_platform_device(mmc_dev(host->mmc)); 58 struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data; 59 60 sdhci_reset(host, mask); 61 62 if (mask == SDHCI_RESET_ALL) { 63 u16 tmp = 0; 64 65 /* 66 * tune timing of read data/command when crc error happen 67 * no performance impact 68 */ 69 if (pdata && pdata->clk_delay_sel == 1) { 70 tmp = readw(host->ioaddr + SD_CLOCK_BURST_SIZE_SETUP); 71 72 tmp &= ~(SDCLK_DELAY_MASK << SDCLK_DELAY_SHIFT); 73 tmp |= (pdata->clk_delay_cycles & SDCLK_DELAY_MASK) 74 << SDCLK_DELAY_SHIFT; 75 tmp &= ~(SDCLK_SEL_MASK << SDCLK_SEL_SHIFT); 76 tmp |= (1 & SDCLK_SEL_MASK) << SDCLK_SEL_SHIFT; 77 78 writew(tmp, host->ioaddr + SD_CLOCK_BURST_SIZE_SETUP); 79 } 80 81 if (pdata && (pdata->flags & PXA_FLAG_ENABLE_CLOCK_GATING)) { 82 tmp = readw(host->ioaddr + SD_FIFO_PARAM); 83 tmp &= ~CLK_GATE_SETTING_BITS; 84 writew(tmp, host->ioaddr + SD_FIFO_PARAM); 85 } else { 86 tmp = readw(host->ioaddr + SD_FIFO_PARAM); 87 tmp &= ~CLK_GATE_SETTING_BITS; 88 tmp |= CLK_GATE_SETTING_BITS; 89 writew(tmp, host->ioaddr + SD_FIFO_PARAM); 90 } 91 } 92 } 93 94 static void pxav2_mmc_set_bus_width(struct sdhci_host *host, int width) 95 { 96 u8 ctrl; 97 u16 tmp; 98 99 ctrl = readb(host->ioaddr + SDHCI_HOST_CONTROL); 100 tmp = readw(host->ioaddr + SD_CE_ATA_2); 101 if (width == MMC_BUS_WIDTH_8) { 102 ctrl &= ~SDHCI_CTRL_4BITBUS; 103 tmp |= MMC_CARD | MMC_WIDTH; 104 } else { 105 tmp &= ~(MMC_CARD | MMC_WIDTH); 106 if (width == MMC_BUS_WIDTH_4) 107 ctrl |= SDHCI_CTRL_4BITBUS; 108 else 109 ctrl &= ~SDHCI_CTRL_4BITBUS; 110 } 111 writew(tmp, host->ioaddr + SD_CE_ATA_2); 112 writeb(ctrl, host->ioaddr + SDHCI_HOST_CONTROL); 113 } 114 115 static const struct sdhci_ops pxav2_sdhci_ops = { 116 .set_clock = sdhci_set_clock, 117 .get_max_clock = sdhci_pltfm_clk_get_max_clock, 118 .set_bus_width = pxav2_mmc_set_bus_width, 119 .reset = pxav2_reset, 120 .set_uhs_signaling = sdhci_set_uhs_signaling, 121 }; 122 123 #ifdef CONFIG_OF 124 static const struct of_device_id sdhci_pxav2_of_match[] = { 125 { 126 .compatible = "mrvl,pxav2-mmc", 127 }, 128 {}, 129 }; 130 MODULE_DEVICE_TABLE(of, sdhci_pxav2_of_match); 131 132 static struct sdhci_pxa_platdata *pxav2_get_mmc_pdata(struct device *dev) 133 { 134 struct sdhci_pxa_platdata *pdata; 135 struct device_node *np = dev->of_node; 136 u32 bus_width; 137 u32 clk_delay_cycles; 138 139 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 140 if (!pdata) 141 return NULL; 142 143 if (of_find_property(np, "non-removable", NULL)) 144 pdata->flags |= PXA_FLAG_CARD_PERMANENT; 145 146 of_property_read_u32(np, "bus-width", &bus_width); 147 if (bus_width == 8) 148 pdata->flags |= PXA_FLAG_SD_8_BIT_CAPABLE_SLOT; 149 150 of_property_read_u32(np, "mrvl,clk-delay-cycles", &clk_delay_cycles); 151 if (clk_delay_cycles > 0) { 152 pdata->clk_delay_sel = 1; 153 pdata->clk_delay_cycles = clk_delay_cycles; 154 } 155 156 return pdata; 157 } 158 #else 159 static inline struct sdhci_pxa_platdata *pxav2_get_mmc_pdata(struct device *dev) 160 { 161 return NULL; 162 } 163 #endif 164 165 static int sdhci_pxav2_probe(struct platform_device *pdev) 166 { 167 struct sdhci_pltfm_host *pltfm_host; 168 struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data; 169 struct device *dev = &pdev->dev; 170 struct sdhci_host *host = NULL; 171 const struct of_device_id *match; 172 173 int ret; 174 struct clk *clk; 175 176 host = sdhci_pltfm_init(pdev, NULL, 0); 177 if (IS_ERR(host)) 178 return PTR_ERR(host); 179 180 pltfm_host = sdhci_priv(host); 181 182 clk = clk_get(dev, "PXA-SDHCLK"); 183 if (IS_ERR(clk)) { 184 dev_err(dev, "failed to get io clock\n"); 185 ret = PTR_ERR(clk); 186 goto err_clk_get; 187 } 188 pltfm_host->clk = clk; 189 clk_prepare_enable(clk); 190 191 host->quirks = SDHCI_QUIRK_BROKEN_ADMA 192 | SDHCI_QUIRK_BROKEN_TIMEOUT_VAL 193 | SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN; 194 195 match = of_match_device(of_match_ptr(sdhci_pxav2_of_match), &pdev->dev); 196 if (match) { 197 pdata = pxav2_get_mmc_pdata(dev); 198 } 199 if (pdata) { 200 if (pdata->flags & PXA_FLAG_CARD_PERMANENT) { 201 /* on-chip device */ 202 host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION; 203 host->mmc->caps |= MMC_CAP_NONREMOVABLE; 204 } 205 206 /* If slot design supports 8 bit data, indicate this to MMC. */ 207 if (pdata->flags & PXA_FLAG_SD_8_BIT_CAPABLE_SLOT) 208 host->mmc->caps |= MMC_CAP_8_BIT_DATA; 209 210 if (pdata->quirks) 211 host->quirks |= pdata->quirks; 212 if (pdata->host_caps) 213 host->mmc->caps |= pdata->host_caps; 214 if (pdata->pm_caps) 215 host->mmc->pm_caps |= pdata->pm_caps; 216 } 217 218 host->ops = &pxav2_sdhci_ops; 219 220 ret = sdhci_add_host(host); 221 if (ret) { 222 dev_err(&pdev->dev, "failed to add host\n"); 223 goto err_add_host; 224 } 225 226 platform_set_drvdata(pdev, host); 227 228 return 0; 229 230 err_add_host: 231 clk_disable_unprepare(clk); 232 clk_put(clk); 233 err_clk_get: 234 sdhci_pltfm_free(pdev); 235 return ret; 236 } 237 238 static int sdhci_pxav2_remove(struct platform_device *pdev) 239 { 240 struct sdhci_host *host = platform_get_drvdata(pdev); 241 struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 242 243 sdhci_remove_host(host, 1); 244 245 clk_disable_unprepare(pltfm_host->clk); 246 clk_put(pltfm_host->clk); 247 sdhci_pltfm_free(pdev); 248 249 return 0; 250 } 251 252 static struct platform_driver sdhci_pxav2_driver = { 253 .driver = { 254 .name = "sdhci-pxav2", 255 .of_match_table = of_match_ptr(sdhci_pxav2_of_match), 256 .pm = &sdhci_pltfm_pmops, 257 }, 258 .probe = sdhci_pxav2_probe, 259 .remove = sdhci_pxav2_remove, 260 }; 261 262 module_platform_driver(sdhci_pxav2_driver); 263 264 MODULE_DESCRIPTION("SDHCI driver for pxav2"); 265 MODULE_AUTHOR("Marvell International Ltd."); 266 MODULE_LICENSE("GPL v2"); 267 268 269 270 271 272 273 /* LDV_COMMENT_BEGIN_MAIN */ 274 #ifdef LDV_MAIN0_sequence_infinite_withcheck_stateful 275 276 /*###########################################################################*/ 277 278 /*############## Driver Environment Generator 0.2 output ####################*/ 279 280 /*###########################################################################*/ 281 282 283 284 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test if all kernel resources are correctly released by driver before driver will be unloaded. */ 285 void ldv_check_final_state(void); 286 287 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result. */ 288 void ldv_check_return_value(int res); 289 290 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result of probe() function. */ 291 void ldv_check_return_value_probe(int res); 292 293 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Initializes the model. */ 294 void ldv_initialize(void); 295 296 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Reinitializes the model between distinct model function calls. */ 297 void ldv_handler_precall(void); 298 299 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Returns arbitrary interger value. */ 300 int nondet_int(void); 301 302 /* LDV_COMMENT_VAR_DECLARE_LDV Special variable for LDV verifier. */ 303 int LDV_IN_INTERRUPT; 304 305 /* LDV_COMMENT_FUNCTION_MAIN Main function for LDV verifier. */ 306 void ldv_main0_sequence_infinite_withcheck_stateful(void) { 307 308 309 310 /* LDV_COMMENT_BEGIN_VARIABLE_DECLARATION_PART */ 311 /*============================= VARIABLE DECLARATION PART =============================*/ 312 /** STRUCT: struct type: sdhci_ops, struct name: pxav2_sdhci_ops **/ 313 /* content: static void pxav2_mmc_set_bus_width(struct sdhci_host *host, int width)*/ 314 /* LDV_COMMENT_BEGIN_PREP */ 315 #define SD_FIFO_PARAM 0xe0 316 #define DIS_PAD_SD_CLK_GATE 0x0400 317 #define CLK_GATE_ON 0x0200 318 #define CLK_GATE_CTL 0x0100 319 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 320 CLK_GATE_ON | CLK_GATE_CTL) 321 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 322 #define SDCLK_SEL_SHIFT 8 323 #define SDCLK_SEL_MASK 0x3 324 #define SDCLK_DELAY_SHIFT 10 325 #define SDCLK_DELAY_MASK 0x3c 326 #define SD_CE_ATA_2 0xea 327 #define MMC_CARD 0x1000 328 #define MMC_WIDTH 0x0100 329 /* LDV_COMMENT_END_PREP */ 330 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "pxav2_mmc_set_bus_width" */ 331 struct sdhci_host * var_group1; 332 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "pxav2_mmc_set_bus_width" */ 333 int var_pxav2_mmc_set_bus_width_1_p1; 334 /* LDV_COMMENT_BEGIN_PREP */ 335 #ifdef CONFIG_OF 336 #else 337 #endif 338 /* LDV_COMMENT_END_PREP */ 339 /* content: static void pxav2_reset(struct sdhci_host *host, u8 mask)*/ 340 /* LDV_COMMENT_BEGIN_PREP */ 341 #define SD_FIFO_PARAM 0xe0 342 #define DIS_PAD_SD_CLK_GATE 0x0400 343 #define CLK_GATE_ON 0x0200 344 #define CLK_GATE_CTL 0x0100 345 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 346 CLK_GATE_ON | CLK_GATE_CTL) 347 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 348 #define SDCLK_SEL_SHIFT 8 349 #define SDCLK_SEL_MASK 0x3 350 #define SDCLK_DELAY_SHIFT 10 351 #define SDCLK_DELAY_MASK 0x3c 352 #define SD_CE_ATA_2 0xea 353 #define MMC_CARD 0x1000 354 #define MMC_WIDTH 0x0100 355 /* LDV_COMMENT_END_PREP */ 356 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "pxav2_reset" */ 357 u8 var_pxav2_reset_0_p1; 358 /* LDV_COMMENT_BEGIN_PREP */ 359 #ifdef CONFIG_OF 360 #else 361 #endif 362 /* LDV_COMMENT_END_PREP */ 363 364 /** STRUCT: struct type: platform_driver, struct name: sdhci_pxav2_driver **/ 365 /* content: static int sdhci_pxav2_probe(struct platform_device *pdev)*/ 366 /* LDV_COMMENT_BEGIN_PREP */ 367 #define SD_FIFO_PARAM 0xe0 368 #define DIS_PAD_SD_CLK_GATE 0x0400 369 #define CLK_GATE_ON 0x0200 370 #define CLK_GATE_CTL 0x0100 371 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 372 CLK_GATE_ON | CLK_GATE_CTL) 373 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 374 #define SDCLK_SEL_SHIFT 8 375 #define SDCLK_SEL_MASK 0x3 376 #define SDCLK_DELAY_SHIFT 10 377 #define SDCLK_DELAY_MASK 0x3c 378 #define SD_CE_ATA_2 0xea 379 #define MMC_CARD 0x1000 380 #define MMC_WIDTH 0x0100 381 #ifdef CONFIG_OF 382 #else 383 #endif 384 /* LDV_COMMENT_END_PREP */ 385 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "sdhci_pxav2_probe" */ 386 struct platform_device * var_group2; 387 /* LDV_COMMENT_VAR_DECLARE Variable declaration for test return result from function call "sdhci_pxav2_probe" */ 388 static int res_sdhci_pxav2_probe_4; 389 /* content: static int sdhci_pxav2_remove(struct platform_device *pdev)*/ 390 /* LDV_COMMENT_BEGIN_PREP */ 391 #define SD_FIFO_PARAM 0xe0 392 #define DIS_PAD_SD_CLK_GATE 0x0400 393 #define CLK_GATE_ON 0x0200 394 #define CLK_GATE_CTL 0x0100 395 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 396 CLK_GATE_ON | CLK_GATE_CTL) 397 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 398 #define SDCLK_SEL_SHIFT 8 399 #define SDCLK_SEL_MASK 0x3 400 #define SDCLK_DELAY_SHIFT 10 401 #define SDCLK_DELAY_MASK 0x3c 402 #define SD_CE_ATA_2 0xea 403 #define MMC_CARD 0x1000 404 #define MMC_WIDTH 0x0100 405 #ifdef CONFIG_OF 406 #else 407 #endif 408 /* LDV_COMMENT_END_PREP */ 409 410 411 412 413 /* LDV_COMMENT_END_VARIABLE_DECLARATION_PART */ 414 /* LDV_COMMENT_BEGIN_VARIABLE_INITIALIZING_PART */ 415 /*============================= VARIABLE INITIALIZING PART =============================*/ 416 LDV_IN_INTERRUPT=1; 417 418 419 420 421 /* LDV_COMMENT_END_VARIABLE_INITIALIZING_PART */ 422 /* LDV_COMMENT_BEGIN_FUNCTION_CALL_SECTION */ 423 /*============================= FUNCTION CALL SECTION =============================*/ 424 /* LDV_COMMENT_FUNCTION_CALL Initialize LDV model. */ 425 ldv_initialize(); 426 427 428 int ldv_s_sdhci_pxav2_driver_platform_driver = 0; 429 430 431 while( nondet_int() 432 || !(ldv_s_sdhci_pxav2_driver_platform_driver == 0) 433 ) { 434 435 switch(nondet_int()) { 436 437 case 0: { 438 439 /** STRUCT: struct type: sdhci_ops, struct name: pxav2_sdhci_ops **/ 440 441 442 /* content: static void pxav2_mmc_set_bus_width(struct sdhci_host *host, int width)*/ 443 /* LDV_COMMENT_BEGIN_PREP */ 444 #define SD_FIFO_PARAM 0xe0 445 #define DIS_PAD_SD_CLK_GATE 0x0400 446 #define CLK_GATE_ON 0x0200 447 #define CLK_GATE_CTL 0x0100 448 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 449 CLK_GATE_ON | CLK_GATE_CTL) 450 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 451 #define SDCLK_SEL_SHIFT 8 452 #define SDCLK_SEL_MASK 0x3 453 #define SDCLK_DELAY_SHIFT 10 454 #define SDCLK_DELAY_MASK 0x3c 455 #define SD_CE_ATA_2 0xea 456 #define MMC_CARD 0x1000 457 #define MMC_WIDTH 0x0100 458 /* LDV_COMMENT_END_PREP */ 459 /* LDV_COMMENT_FUNCTION_CALL Function from field "set_bus_width" from driver structure with callbacks "pxav2_sdhci_ops" */ 460 ldv_handler_precall(); 461 pxav2_mmc_set_bus_width( var_group1, var_pxav2_mmc_set_bus_width_1_p1); 462 /* LDV_COMMENT_BEGIN_PREP */ 463 #ifdef CONFIG_OF 464 #else 465 #endif 466 /* LDV_COMMENT_END_PREP */ 467 468 469 470 471 } 472 473 break; 474 case 1: { 475 476 /** STRUCT: struct type: sdhci_ops, struct name: pxav2_sdhci_ops **/ 477 478 479 /* content: static void pxav2_reset(struct sdhci_host *host, u8 mask)*/ 480 /* LDV_COMMENT_BEGIN_PREP */ 481 #define SD_FIFO_PARAM 0xe0 482 #define DIS_PAD_SD_CLK_GATE 0x0400 483 #define CLK_GATE_ON 0x0200 484 #define CLK_GATE_CTL 0x0100 485 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 486 CLK_GATE_ON | CLK_GATE_CTL) 487 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 488 #define SDCLK_SEL_SHIFT 8 489 #define SDCLK_SEL_MASK 0x3 490 #define SDCLK_DELAY_SHIFT 10 491 #define SDCLK_DELAY_MASK 0x3c 492 #define SD_CE_ATA_2 0xea 493 #define MMC_CARD 0x1000 494 #define MMC_WIDTH 0x0100 495 /* LDV_COMMENT_END_PREP */ 496 /* LDV_COMMENT_FUNCTION_CALL Function from field "reset" from driver structure with callbacks "pxav2_sdhci_ops" */ 497 ldv_handler_precall(); 498 pxav2_reset( var_group1, var_pxav2_reset_0_p1); 499 /* LDV_COMMENT_BEGIN_PREP */ 500 #ifdef CONFIG_OF 501 #else 502 #endif 503 /* LDV_COMMENT_END_PREP */ 504 505 506 507 508 } 509 510 break; 511 case 2: { 512 513 /** STRUCT: struct type: platform_driver, struct name: sdhci_pxav2_driver **/ 514 if(ldv_s_sdhci_pxav2_driver_platform_driver==0) { 515 516 /* content: static int sdhci_pxav2_probe(struct platform_device *pdev)*/ 517 /* LDV_COMMENT_BEGIN_PREP */ 518 #define SD_FIFO_PARAM 0xe0 519 #define DIS_PAD_SD_CLK_GATE 0x0400 520 #define CLK_GATE_ON 0x0200 521 #define CLK_GATE_CTL 0x0100 522 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 523 CLK_GATE_ON | CLK_GATE_CTL) 524 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 525 #define SDCLK_SEL_SHIFT 8 526 #define SDCLK_SEL_MASK 0x3 527 #define SDCLK_DELAY_SHIFT 10 528 #define SDCLK_DELAY_MASK 0x3c 529 #define SD_CE_ATA_2 0xea 530 #define MMC_CARD 0x1000 531 #define MMC_WIDTH 0x0100 532 #ifdef CONFIG_OF 533 #else 534 #endif 535 /* LDV_COMMENT_END_PREP */ 536 /* LDV_COMMENT_FUNCTION_CALL Function from field "probe" from driver structure with callbacks "sdhci_pxav2_driver". Standart function test for correct return result. */ 537 res_sdhci_pxav2_probe_4 = sdhci_pxav2_probe( var_group2); 538 ldv_check_return_value(res_sdhci_pxav2_probe_4); 539 ldv_check_return_value_probe(res_sdhci_pxav2_probe_4); 540 if(res_sdhci_pxav2_probe_4) 541 goto ldv_module_exit; 542 ldv_s_sdhci_pxav2_driver_platform_driver++; 543 544 } 545 546 } 547 548 break; 549 case 3: { 550 551 /** STRUCT: struct type: platform_driver, struct name: sdhci_pxav2_driver **/ 552 if(ldv_s_sdhci_pxav2_driver_platform_driver==1) { 553 554 /* content: static int sdhci_pxav2_remove(struct platform_device *pdev)*/ 555 /* LDV_COMMENT_BEGIN_PREP */ 556 #define SD_FIFO_PARAM 0xe0 557 #define DIS_PAD_SD_CLK_GATE 0x0400 558 #define CLK_GATE_ON 0x0200 559 #define CLK_GATE_CTL 0x0100 560 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 561 CLK_GATE_ON | CLK_GATE_CTL) 562 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 563 #define SDCLK_SEL_SHIFT 8 564 #define SDCLK_SEL_MASK 0x3 565 #define SDCLK_DELAY_SHIFT 10 566 #define SDCLK_DELAY_MASK 0x3c 567 #define SD_CE_ATA_2 0xea 568 #define MMC_CARD 0x1000 569 #define MMC_WIDTH 0x0100 570 #ifdef CONFIG_OF 571 #else 572 #endif 573 /* LDV_COMMENT_END_PREP */ 574 /* LDV_COMMENT_FUNCTION_CALL Function from field "remove" from driver structure with callbacks "sdhci_pxav2_driver" */ 575 ldv_handler_precall(); 576 sdhci_pxav2_remove( var_group2); 577 ldv_s_sdhci_pxav2_driver_platform_driver=0; 578 579 } 580 581 } 582 583 break; 584 default: break; 585 586 } 587 588 } 589 590 ldv_module_exit: 591 592 /* LDV_COMMENT_FUNCTION_CALL Checks that all resources and locks are correctly released before the driver will be unloaded. */ 593 ldv_final: ldv_check_final_state(); 594 595 /* LDV_COMMENT_END_FUNCTION_CALL_SECTION */ 596 return; 597 598 } 599 #endif 600 601 /* LDV_COMMENT_END_MAIN */
1 2 #include <linux/kernel.h> 3 bool ldv_is_err(const void *ptr); 4 bool ldv_is_err_or_null(const void *ptr); 5 void* ldv_err_ptr(long error); 6 long ldv_ptr_err(const void *ptr); 7 8 #include <linux/module.h> 9 struct clk; 10 11 extern void ldv_clk_disable_clk(struct clk *clk); 12 extern int ldv_clk_enable_clk(void); 13 extern void ldv_clk_disable_clk_of_sdhci_pltfm_host(struct clk *clk); 14 extern int ldv_clk_enable_clk_of_sdhci_pltfm_host(void); 15 #line 1 "/home/ldvuser/ldv/ref_launches/work/current--X--drivers--X--defaultlinux-4.10-rc1.tar.xz--X--322_7a--X--cpachecker/linux-4.10-rc1.tar.xz/csd_deg_dscv/16248/dscv_tempdir/dscv/ri/322_7a/drivers/mmc/host/sdhci-pxav2.c" 16 17 /* 18 * Copyright (C) 2010 Marvell International Ltd. 19 * Zhangfei Gao <zhangfei.gao@marvell.com> 20 * Kevin Wang <dwang4@marvell.com> 21 * Jun Nie <njun@marvell.com> 22 * Qiming Wu <wuqm@marvell.com> 23 * Philip Rakity <prakity@marvell.com> 24 * 25 * This software is licensed under the terms of the GNU General Public 26 * License version 2, as published by the Free Software Foundation, and 27 * may be copied, distributed, and modified under those terms. 28 * 29 * This program is distributed in the hope that it will be useful, 30 * but WITHOUT ANY WARRANTY; without even the implied warranty of 31 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 32 * GNU General Public License for more details. 33 * 34 */ 35 36 #include <linux/err.h> 37 #include <linux/init.h> 38 #include <linux/platform_device.h> 39 #include <linux/clk.h> 40 #include <linux/module.h> 41 #include <linux/io.h> 42 #include <linux/gpio.h> 43 #include <linux/mmc/card.h> 44 #include <linux/mmc/host.h> 45 #include <linux/platform_data/pxa_sdhci.h> 46 #include <linux/slab.h> 47 #include <linux/of.h> 48 #include <linux/of_device.h> 49 50 #include "sdhci.h" 51 #include "sdhci-pltfm.h" 52 53 #define SD_FIFO_PARAM 0xe0 54 #define DIS_PAD_SD_CLK_GATE 0x0400 /* Turn on/off Dynamic SD Clock Gating */ 55 #define CLK_GATE_ON 0x0200 /* Disable/enable Clock Gate */ 56 #define CLK_GATE_CTL 0x0100 /* Clock Gate Control */ 57 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 58 CLK_GATE_ON | CLK_GATE_CTL) 59 60 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 61 #define SDCLK_SEL_SHIFT 8 62 #define SDCLK_SEL_MASK 0x3 63 #define SDCLK_DELAY_SHIFT 10 64 #define SDCLK_DELAY_MASK 0x3c 65 66 #define SD_CE_ATA_2 0xea 67 #define MMC_CARD 0x1000 68 #define MMC_WIDTH 0x0100 69 70 static void pxav2_reset(struct sdhci_host *host, u8 mask) 71 { 72 struct platform_device *pdev = to_platform_device(mmc_dev(host->mmc)); 73 struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data; 74 75 sdhci_reset(host, mask); 76 77 if (mask == SDHCI_RESET_ALL) { 78 u16 tmp = 0; 79 80 /* 81 * tune timing of read data/command when crc error happen 82 * no performance impact 83 */ 84 if (pdata && pdata->clk_delay_sel == 1) { 85 tmp = readw(host->ioaddr + SD_CLOCK_BURST_SIZE_SETUP); 86 87 tmp &= ~(SDCLK_DELAY_MASK << SDCLK_DELAY_SHIFT); 88 tmp |= (pdata->clk_delay_cycles & SDCLK_DELAY_MASK) 89 << SDCLK_DELAY_SHIFT; 90 tmp &= ~(SDCLK_SEL_MASK << SDCLK_SEL_SHIFT); 91 tmp |= (1 & SDCLK_SEL_MASK) << SDCLK_SEL_SHIFT; 92 93 writew(tmp, host->ioaddr + SD_CLOCK_BURST_SIZE_SETUP); 94 } 95 96 if (pdata && (pdata->flags & PXA_FLAG_ENABLE_CLOCK_GATING)) { 97 tmp = readw(host->ioaddr + SD_FIFO_PARAM); 98 tmp &= ~CLK_GATE_SETTING_BITS; 99 writew(tmp, host->ioaddr + SD_FIFO_PARAM); 100 } else { 101 tmp = readw(host->ioaddr + SD_FIFO_PARAM); 102 tmp &= ~CLK_GATE_SETTING_BITS; 103 tmp |= CLK_GATE_SETTING_BITS; 104 writew(tmp, host->ioaddr + SD_FIFO_PARAM); 105 } 106 } 107 } 108 109 static void pxav2_mmc_set_bus_width(struct sdhci_host *host, int width) 110 { 111 u8 ctrl; 112 u16 tmp; 113 114 ctrl = readb(host->ioaddr + SDHCI_HOST_CONTROL); 115 tmp = readw(host->ioaddr + SD_CE_ATA_2); 116 if (width == MMC_BUS_WIDTH_8) { 117 ctrl &= ~SDHCI_CTRL_4BITBUS; 118 tmp |= MMC_CARD | MMC_WIDTH; 119 } else { 120 tmp &= ~(MMC_CARD | MMC_WIDTH); 121 if (width == MMC_BUS_WIDTH_4) 122 ctrl |= SDHCI_CTRL_4BITBUS; 123 else 124 ctrl &= ~SDHCI_CTRL_4BITBUS; 125 } 126 writew(tmp, host->ioaddr + SD_CE_ATA_2); 127 writeb(ctrl, host->ioaddr + SDHCI_HOST_CONTROL); 128 } 129 130 static const struct sdhci_ops pxav2_sdhci_ops = { 131 .set_clock = sdhci_set_clock, 132 .get_max_clock = sdhci_pltfm_clk_get_max_clock, 133 .set_bus_width = pxav2_mmc_set_bus_width, 134 .reset = pxav2_reset, 135 .set_uhs_signaling = sdhci_set_uhs_signaling, 136 }; 137 138 #ifdef CONFIG_OF 139 static const struct of_device_id sdhci_pxav2_of_match[] = { 140 { 141 .compatible = "mrvl,pxav2-mmc", 142 }, 143 {}, 144 }; 145 MODULE_DEVICE_TABLE(of, sdhci_pxav2_of_match); 146 147 static struct sdhci_pxa_platdata *pxav2_get_mmc_pdata(struct device *dev) 148 { 149 struct sdhci_pxa_platdata *pdata; 150 struct device_node *np = dev->of_node; 151 u32 bus_width; 152 u32 clk_delay_cycles; 153 154 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 155 if (!pdata) 156 return NULL; 157 158 if (of_find_property(np, "non-removable", NULL)) 159 pdata->flags |= PXA_FLAG_CARD_PERMANENT; 160 161 of_property_read_u32(np, "bus-width", &bus_width); 162 if (bus_width == 8) 163 pdata->flags |= PXA_FLAG_SD_8_BIT_CAPABLE_SLOT; 164 165 of_property_read_u32(np, "mrvl,clk-delay-cycles", &clk_delay_cycles); 166 if (clk_delay_cycles > 0) { 167 pdata->clk_delay_sel = 1; 168 pdata->clk_delay_cycles = clk_delay_cycles; 169 } 170 171 return pdata; 172 } 173 #else 174 static inline struct sdhci_pxa_platdata *pxav2_get_mmc_pdata(struct device *dev) 175 { 176 return NULL; 177 } 178 #endif 179 180 static int sdhci_pxav2_probe(struct platform_device *pdev) 181 { 182 struct sdhci_pltfm_host *pltfm_host; 183 struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data; 184 struct device *dev = &pdev->dev; 185 struct sdhci_host *host = NULL; 186 const struct of_device_id *match; 187 188 int ret; 189 struct clk *clk; 190 191 host = sdhci_pltfm_init(pdev, NULL, 0); 192 if (IS_ERR(host)) 193 return PTR_ERR(host); 194 195 pltfm_host = sdhci_priv(host); 196 197 clk = clk_get(dev, "PXA-SDHCLK"); 198 if (IS_ERR(clk)) { 199 dev_err(dev, "failed to get io clock\n"); 200 ret = PTR_ERR(clk); 201 goto err_clk_get; 202 } 203 pltfm_host->clk = clk; 204 clk_prepare_enable(clk); 205 206 host->quirks = SDHCI_QUIRK_BROKEN_ADMA 207 | SDHCI_QUIRK_BROKEN_TIMEOUT_VAL 208 | SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN; 209 210 match = of_match_device(of_match_ptr(sdhci_pxav2_of_match), &pdev->dev); 211 if (match) { 212 pdata = pxav2_get_mmc_pdata(dev); 213 } 214 if (pdata) { 215 if (pdata->flags & PXA_FLAG_CARD_PERMANENT) { 216 /* on-chip device */ 217 host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION; 218 host->mmc->caps |= MMC_CAP_NONREMOVABLE; 219 } 220 221 /* If slot design supports 8 bit data, indicate this to MMC. */ 222 if (pdata->flags & PXA_FLAG_SD_8_BIT_CAPABLE_SLOT) 223 host->mmc->caps |= MMC_CAP_8_BIT_DATA; 224 225 if (pdata->quirks) 226 host->quirks |= pdata->quirks; 227 if (pdata->host_caps) 228 host->mmc->caps |= pdata->host_caps; 229 if (pdata->pm_caps) 230 host->mmc->pm_caps |= pdata->pm_caps; 231 } 232 233 host->ops = &pxav2_sdhci_ops; 234 235 ret = sdhci_add_host(host); 236 if (ret) { 237 dev_err(&pdev->dev, "failed to add host\n"); 238 goto err_add_host; 239 } 240 241 platform_set_drvdata(pdev, host); 242 243 return 0; 244 245 err_add_host: 246 clk_disable_unprepare(clk); 247 clk_put(clk); 248 err_clk_get: 249 sdhci_pltfm_free(pdev); 250 return ret; 251 } 252 253 static int sdhci_pxav2_remove(struct platform_device *pdev) 254 { 255 struct sdhci_host *host = platform_get_drvdata(pdev); 256 struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 257 258 sdhci_remove_host(host, 1); 259 260 clk_disable_unprepare(pltfm_host->clk); 261 clk_put(pltfm_host->clk); 262 sdhci_pltfm_free(pdev); 263 264 return 0; 265 } 266 267 static struct platform_driver sdhci_pxav2_driver = { 268 .driver = { 269 .name = "sdhci-pxav2", 270 .of_match_table = of_match_ptr(sdhci_pxav2_of_match), 271 .pm = &sdhci_pltfm_pmops, 272 }, 273 .probe = sdhci_pxav2_probe, 274 .remove = sdhci_pxav2_remove, 275 }; 276 277 module_platform_driver(sdhci_pxav2_driver); 278 279 MODULE_DESCRIPTION("SDHCI driver for pxav2"); 280 MODULE_AUTHOR("Marvell International Ltd."); 281 MODULE_LICENSE("GPL v2"); 282 283 284 285 286 287 288 /* LDV_COMMENT_BEGIN_MAIN */ 289 #ifdef LDV_MAIN0_sequence_infinite_withcheck_stateful 290 291 /*###########################################################################*/ 292 293 /*############## Driver Environment Generator 0.2 output ####################*/ 294 295 /*###########################################################################*/ 296 297 298 299 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test if all kernel resources are correctly released by driver before driver will be unloaded. */ 300 void ldv_check_final_state(void); 301 302 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result. */ 303 void ldv_check_return_value(int res); 304 305 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result of probe() function. */ 306 void ldv_check_return_value_probe(int res); 307 308 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Initializes the model. */ 309 void ldv_initialize(void); 310 311 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Reinitializes the model between distinct model function calls. */ 312 void ldv_handler_precall(void); 313 314 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Returns arbitrary interger value. */ 315 int nondet_int(void); 316 317 /* LDV_COMMENT_VAR_DECLARE_LDV Special variable for LDV verifier. */ 318 int LDV_IN_INTERRUPT; 319 320 /* LDV_COMMENT_FUNCTION_MAIN Main function for LDV verifier. */ 321 void ldv_main0_sequence_infinite_withcheck_stateful(void) { 322 323 324 325 /* LDV_COMMENT_BEGIN_VARIABLE_DECLARATION_PART */ 326 /*============================= VARIABLE DECLARATION PART =============================*/ 327 /** STRUCT: struct type: sdhci_ops, struct name: pxav2_sdhci_ops **/ 328 /* content: static void pxav2_mmc_set_bus_width(struct sdhci_host *host, int width)*/ 329 /* LDV_COMMENT_BEGIN_PREP */ 330 #define SD_FIFO_PARAM 0xe0 331 #define DIS_PAD_SD_CLK_GATE 0x0400 332 #define CLK_GATE_ON 0x0200 333 #define CLK_GATE_CTL 0x0100 334 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 335 CLK_GATE_ON | CLK_GATE_CTL) 336 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 337 #define SDCLK_SEL_SHIFT 8 338 #define SDCLK_SEL_MASK 0x3 339 #define SDCLK_DELAY_SHIFT 10 340 #define SDCLK_DELAY_MASK 0x3c 341 #define SD_CE_ATA_2 0xea 342 #define MMC_CARD 0x1000 343 #define MMC_WIDTH 0x0100 344 /* LDV_COMMENT_END_PREP */ 345 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "pxav2_mmc_set_bus_width" */ 346 struct sdhci_host * var_group1; 347 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "pxav2_mmc_set_bus_width" */ 348 int var_pxav2_mmc_set_bus_width_1_p1; 349 /* LDV_COMMENT_BEGIN_PREP */ 350 #ifdef CONFIG_OF 351 #else 352 #endif 353 /* LDV_COMMENT_END_PREP */ 354 /* content: static void pxav2_reset(struct sdhci_host *host, u8 mask)*/ 355 /* LDV_COMMENT_BEGIN_PREP */ 356 #define SD_FIFO_PARAM 0xe0 357 #define DIS_PAD_SD_CLK_GATE 0x0400 358 #define CLK_GATE_ON 0x0200 359 #define CLK_GATE_CTL 0x0100 360 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 361 CLK_GATE_ON | CLK_GATE_CTL) 362 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 363 #define SDCLK_SEL_SHIFT 8 364 #define SDCLK_SEL_MASK 0x3 365 #define SDCLK_DELAY_SHIFT 10 366 #define SDCLK_DELAY_MASK 0x3c 367 #define SD_CE_ATA_2 0xea 368 #define MMC_CARD 0x1000 369 #define MMC_WIDTH 0x0100 370 /* LDV_COMMENT_END_PREP */ 371 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "pxav2_reset" */ 372 u8 var_pxav2_reset_0_p1; 373 /* LDV_COMMENT_BEGIN_PREP */ 374 #ifdef CONFIG_OF 375 #else 376 #endif 377 /* LDV_COMMENT_END_PREP */ 378 379 /** STRUCT: struct type: platform_driver, struct name: sdhci_pxav2_driver **/ 380 /* content: static int sdhci_pxav2_probe(struct platform_device *pdev)*/ 381 /* LDV_COMMENT_BEGIN_PREP */ 382 #define SD_FIFO_PARAM 0xe0 383 #define DIS_PAD_SD_CLK_GATE 0x0400 384 #define CLK_GATE_ON 0x0200 385 #define CLK_GATE_CTL 0x0100 386 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 387 CLK_GATE_ON | CLK_GATE_CTL) 388 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 389 #define SDCLK_SEL_SHIFT 8 390 #define SDCLK_SEL_MASK 0x3 391 #define SDCLK_DELAY_SHIFT 10 392 #define SDCLK_DELAY_MASK 0x3c 393 #define SD_CE_ATA_2 0xea 394 #define MMC_CARD 0x1000 395 #define MMC_WIDTH 0x0100 396 #ifdef CONFIG_OF 397 #else 398 #endif 399 /* LDV_COMMENT_END_PREP */ 400 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "sdhci_pxav2_probe" */ 401 struct platform_device * var_group2; 402 /* LDV_COMMENT_VAR_DECLARE Variable declaration for test return result from function call "sdhci_pxav2_probe" */ 403 static int res_sdhci_pxav2_probe_4; 404 /* content: static int sdhci_pxav2_remove(struct platform_device *pdev)*/ 405 /* LDV_COMMENT_BEGIN_PREP */ 406 #define SD_FIFO_PARAM 0xe0 407 #define DIS_PAD_SD_CLK_GATE 0x0400 408 #define CLK_GATE_ON 0x0200 409 #define CLK_GATE_CTL 0x0100 410 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 411 CLK_GATE_ON | CLK_GATE_CTL) 412 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 413 #define SDCLK_SEL_SHIFT 8 414 #define SDCLK_SEL_MASK 0x3 415 #define SDCLK_DELAY_SHIFT 10 416 #define SDCLK_DELAY_MASK 0x3c 417 #define SD_CE_ATA_2 0xea 418 #define MMC_CARD 0x1000 419 #define MMC_WIDTH 0x0100 420 #ifdef CONFIG_OF 421 #else 422 #endif 423 /* LDV_COMMENT_END_PREP */ 424 425 426 427 428 /* LDV_COMMENT_END_VARIABLE_DECLARATION_PART */ 429 /* LDV_COMMENT_BEGIN_VARIABLE_INITIALIZING_PART */ 430 /*============================= VARIABLE INITIALIZING PART =============================*/ 431 LDV_IN_INTERRUPT=1; 432 433 434 435 436 /* LDV_COMMENT_END_VARIABLE_INITIALIZING_PART */ 437 /* LDV_COMMENT_BEGIN_FUNCTION_CALL_SECTION */ 438 /*============================= FUNCTION CALL SECTION =============================*/ 439 /* LDV_COMMENT_FUNCTION_CALL Initialize LDV model. */ 440 ldv_initialize(); 441 442 443 int ldv_s_sdhci_pxav2_driver_platform_driver = 0; 444 445 446 while( nondet_int() 447 || !(ldv_s_sdhci_pxav2_driver_platform_driver == 0) 448 ) { 449 450 switch(nondet_int()) { 451 452 case 0: { 453 454 /** STRUCT: struct type: sdhci_ops, struct name: pxav2_sdhci_ops **/ 455 456 457 /* content: static void pxav2_mmc_set_bus_width(struct sdhci_host *host, int width)*/ 458 /* LDV_COMMENT_BEGIN_PREP */ 459 #define SD_FIFO_PARAM 0xe0 460 #define DIS_PAD_SD_CLK_GATE 0x0400 461 #define CLK_GATE_ON 0x0200 462 #define CLK_GATE_CTL 0x0100 463 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 464 CLK_GATE_ON | CLK_GATE_CTL) 465 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 466 #define SDCLK_SEL_SHIFT 8 467 #define SDCLK_SEL_MASK 0x3 468 #define SDCLK_DELAY_SHIFT 10 469 #define SDCLK_DELAY_MASK 0x3c 470 #define SD_CE_ATA_2 0xea 471 #define MMC_CARD 0x1000 472 #define MMC_WIDTH 0x0100 473 /* LDV_COMMENT_END_PREP */ 474 /* LDV_COMMENT_FUNCTION_CALL Function from field "set_bus_width" from driver structure with callbacks "pxav2_sdhci_ops" */ 475 ldv_handler_precall(); 476 pxav2_mmc_set_bus_width( var_group1, var_pxav2_mmc_set_bus_width_1_p1); 477 /* LDV_COMMENT_BEGIN_PREP */ 478 #ifdef CONFIG_OF 479 #else 480 #endif 481 /* LDV_COMMENT_END_PREP */ 482 483 484 485 486 } 487 488 break; 489 case 1: { 490 491 /** STRUCT: struct type: sdhci_ops, struct name: pxav2_sdhci_ops **/ 492 493 494 /* content: static void pxav2_reset(struct sdhci_host *host, u8 mask)*/ 495 /* LDV_COMMENT_BEGIN_PREP */ 496 #define SD_FIFO_PARAM 0xe0 497 #define DIS_PAD_SD_CLK_GATE 0x0400 498 #define CLK_GATE_ON 0x0200 499 #define CLK_GATE_CTL 0x0100 500 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 501 CLK_GATE_ON | CLK_GATE_CTL) 502 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 503 #define SDCLK_SEL_SHIFT 8 504 #define SDCLK_SEL_MASK 0x3 505 #define SDCLK_DELAY_SHIFT 10 506 #define SDCLK_DELAY_MASK 0x3c 507 #define SD_CE_ATA_2 0xea 508 #define MMC_CARD 0x1000 509 #define MMC_WIDTH 0x0100 510 /* LDV_COMMENT_END_PREP */ 511 /* LDV_COMMENT_FUNCTION_CALL Function from field "reset" from driver structure with callbacks "pxav2_sdhci_ops" */ 512 ldv_handler_precall(); 513 pxav2_reset( var_group1, var_pxav2_reset_0_p1); 514 /* LDV_COMMENT_BEGIN_PREP */ 515 #ifdef CONFIG_OF 516 #else 517 #endif 518 /* LDV_COMMENT_END_PREP */ 519 520 521 522 523 } 524 525 break; 526 case 2: { 527 528 /** STRUCT: struct type: platform_driver, struct name: sdhci_pxav2_driver **/ 529 if(ldv_s_sdhci_pxav2_driver_platform_driver==0) { 530 531 /* content: static int sdhci_pxav2_probe(struct platform_device *pdev)*/ 532 /* LDV_COMMENT_BEGIN_PREP */ 533 #define SD_FIFO_PARAM 0xe0 534 #define DIS_PAD_SD_CLK_GATE 0x0400 535 #define CLK_GATE_ON 0x0200 536 #define CLK_GATE_CTL 0x0100 537 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 538 CLK_GATE_ON | CLK_GATE_CTL) 539 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 540 #define SDCLK_SEL_SHIFT 8 541 #define SDCLK_SEL_MASK 0x3 542 #define SDCLK_DELAY_SHIFT 10 543 #define SDCLK_DELAY_MASK 0x3c 544 #define SD_CE_ATA_2 0xea 545 #define MMC_CARD 0x1000 546 #define MMC_WIDTH 0x0100 547 #ifdef CONFIG_OF 548 #else 549 #endif 550 /* LDV_COMMENT_END_PREP */ 551 /* LDV_COMMENT_FUNCTION_CALL Function from field "probe" from driver structure with callbacks "sdhci_pxav2_driver". Standart function test for correct return result. */ 552 res_sdhci_pxav2_probe_4 = sdhci_pxav2_probe( var_group2); 553 ldv_check_return_value(res_sdhci_pxav2_probe_4); 554 ldv_check_return_value_probe(res_sdhci_pxav2_probe_4); 555 if(res_sdhci_pxav2_probe_4) 556 goto ldv_module_exit; 557 ldv_s_sdhci_pxav2_driver_platform_driver++; 558 559 } 560 561 } 562 563 break; 564 case 3: { 565 566 /** STRUCT: struct type: platform_driver, struct name: sdhci_pxav2_driver **/ 567 if(ldv_s_sdhci_pxav2_driver_platform_driver==1) { 568 569 /* content: static int sdhci_pxav2_remove(struct platform_device *pdev)*/ 570 /* LDV_COMMENT_BEGIN_PREP */ 571 #define SD_FIFO_PARAM 0xe0 572 #define DIS_PAD_SD_CLK_GATE 0x0400 573 #define CLK_GATE_ON 0x0200 574 #define CLK_GATE_CTL 0x0100 575 #define CLK_GATE_SETTING_BITS (DIS_PAD_SD_CLK_GATE | \ 576 CLK_GATE_ON | CLK_GATE_CTL) 577 #define SD_CLOCK_BURST_SIZE_SETUP 0xe6 578 #define SDCLK_SEL_SHIFT 8 579 #define SDCLK_SEL_MASK 0x3 580 #define SDCLK_DELAY_SHIFT 10 581 #define SDCLK_DELAY_MASK 0x3c 582 #define SD_CE_ATA_2 0xea 583 #define MMC_CARD 0x1000 584 #define MMC_WIDTH 0x0100 585 #ifdef CONFIG_OF 586 #else 587 #endif 588 /* LDV_COMMENT_END_PREP */ 589 /* LDV_COMMENT_FUNCTION_CALL Function from field "remove" from driver structure with callbacks "sdhci_pxav2_driver" */ 590 ldv_handler_precall(); 591 sdhci_pxav2_remove( var_group2); 592 ldv_s_sdhci_pxav2_driver_platform_driver=0; 593 594 } 595 596 } 597 598 break; 599 default: break; 600 601 } 602 603 } 604 605 ldv_module_exit: 606 607 /* LDV_COMMENT_FUNCTION_CALL Checks that all resources and locks are correctly released before the driver will be unloaded. */ 608 ldv_final: ldv_check_final_state(); 609 610 /* LDV_COMMENT_END_FUNCTION_CALL_SECTION */ 611 return; 612 613 } 614 #endif 615 616 /* LDV_COMMENT_END_MAIN */ 617 618 #line 15 "/home/ldvuser/ldv/ref_launches/work/current--X--drivers--X--defaultlinux-4.10-rc1.tar.xz--X--322_7a--X--cpachecker/linux-4.10-rc1.tar.xz/csd_deg_dscv/16248/dscv_tempdir/dscv/ri/322_7a/drivers/mmc/host/sdhci-pxav2.o.c.prepared"
1 2 #include <verifier/rcv.h> 3 #include <kernel-model/ERR.inc> 4 5 struct clk; 6 7 8 /* LDV_COMMENT_CHANGE_STATE Initialize counter to zero. */ 9 int ldv_counter_clk = 0; 10 11 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_clk_disable_clk') Release. */ 12 void ldv_clk_disable_clk(struct clk *clk) 13 { 14 /* LDV_COMMENT_ASSERT The clk must be freed only once. */ 15 ldv_assert(ldv_counter_clk==1); 16 /* LDV_COMMENT_CHANGE_STATE Increase counter. */ 17 ldv_counter_clk = 0; 18 } 19 20 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_clk_enable_clk') Reset counter. */ 21 int ldv_clk_enable_clk(void) 22 { 23 int retval = ldv_undef_int(); 24 if (!retval) 25 { 26 /* LDV_COMMENT_CHANGE_STATE Increase counter. */ 27 ldv_counter_clk = 1; 28 } 29 return retval; 30 } 31 32 33 /* LDV_COMMENT_CHANGE_STATE Initialize counter to zero. */ 34 int ldv_counter_clk_of_sdhci_pltfm_host = 0; 35 36 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_clk_disable_clk_of_sdhci_pltfm_host') Release. */ 37 void ldv_clk_disable_clk_of_sdhci_pltfm_host(struct clk *clk) 38 { 39 /* LDV_COMMENT_ASSERT The clk must be freed only once. */ 40 ldv_assert(ldv_counter_clk_of_sdhci_pltfm_host==1); 41 /* LDV_COMMENT_CHANGE_STATE Increase counter. */ 42 ldv_counter_clk_of_sdhci_pltfm_host = 0; 43 } 44 45 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_clk_enable_clk_of_sdhci_pltfm_host') Reset counter. */ 46 int ldv_clk_enable_clk_of_sdhci_pltfm_host(void) 47 { 48 int retval = ldv_undef_int(); 49 if (!retval) 50 { 51 /* LDV_COMMENT_CHANGE_STATE Increase counter. */ 52 ldv_counter_clk_of_sdhci_pltfm_host = 1; 53 } 54 return retval; 55 }
1 #ifndef _LDV_ERR_ 2 #define _LDV_ERR_ 3 4 #include <linux/kernel.h> 5 6 /* LDV_COMMENT_MODEL_FUNCTION_DEFENITION(name='ldv_is_err') This function return result of checking if pointer is impossible. */ 7 bool ldv_is_err(const void *ptr) 8 { 9 /*LDV_COMMENT_RETURN Return value of function ldv_is_err_val().*/ 10 return ((unsigned long)ptr > LDV_PTR_MAX); 11 } 12 13 /* LDV_COMMENT_MODEL_FUNCTION_DEFENITION(name='ldv_err_ptr') This function return pointer. */ 14 void* ldv_err_ptr(long error) 15 { 16 /*LDV_COMMENT_RETURN Return error pointer.*/ 17 return (void *)(LDV_PTR_MAX - error); 18 } 19 20 /* LDV_COMMENT_MODEL_FUNCTION_DEFENITION(name='ldv_ptr_err') This function return error if pointer is impossible. */ 21 long ldv_ptr_err(const void *ptr) 22 { 23 /*LDV_COMMENT_RETURN Return error code.*/ 24 return (long)(LDV_PTR_MAX - (unsigned long)ptr); 25 } 26 27 /* LDV_COMMENT_MODEL_FUNCTION_DEFENITION(name='ldv_is_err_or_null') This function check if pointer is impossible or null. */ 28 bool ldv_is_err_or_null(const void *ptr) 29 { 30 /*LDV_COMMENT_RETURN Return 0 if pointer is possible and not zero, and 1 in other cases*/ 31 return !ptr || ldv_is_err((unsigned long)ptr); 32 } 33 34 #endif /* _LDV_ERR_ */
1 #ifndef _LDV_RCV_H_ 2 #define _LDV_RCV_H_ 3 4 /* If expr evaluates to zero, ldv_assert() causes a program to reach the error 5 label like the standard assert(). */ 6 #define ldv_assert(expr) ((expr) ? 0 : ldv_error()) 7 8 /* The error label wrapper. It is used because of some static verifiers (like 9 BLAST) don't accept multiple error labels through a program. */ 10 static inline void ldv_error(void) 11 { 12 LDV_ERROR: goto LDV_ERROR; 13 } 14 15 /* If expr evaluates to zero, ldv_assume() causes an infinite loop that is 16 avoided by verifiers. */ 17 #define ldv_assume(expr) ((expr) ? 0 : ldv_stop()) 18 19 /* Infinite loop, that causes verifiers to skip such paths. */ 20 static inline void ldv_stop(void) { 21 LDV_STOP: goto LDV_STOP; 22 } 23 24 /* Special nondeterministic functions. */ 25 int ldv_undef_int(void); 26 void *ldv_undef_ptr(void); 27 unsigned long ldv_undef_ulong(void); 28 long ldv_undef_long(void); 29 /* Return nondeterministic negative integer number. */ 30 static inline int ldv_undef_int_negative(void) 31 { 32 int ret = ldv_undef_int(); 33 34 ldv_assume(ret < 0); 35 36 return ret; 37 } 38 /* Return nondeterministic nonpositive integer number. */ 39 static inline int ldv_undef_int_nonpositive(void) 40 { 41 int ret = ldv_undef_int(); 42 43 ldv_assume(ret <= 0); 44 45 return ret; 46 } 47 48 /* Add explicit model for __builin_expect GCC function. Without the model a 49 return value will be treated as nondetermined by verifiers. */ 50 static inline long __builtin_expect(long exp, long c) 51 { 52 return exp; 53 } 54 55 /* This function causes the program to exit abnormally. GCC implements this 56 function by using a target-dependent mechanism (such as intentionally executing 57 an illegal instruction) or by calling abort. The mechanism used may vary from 58 release to release so you should not rely on any particular implementation. 59 http://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html */ 60 static inline void __builtin_trap(void) 61 { 62 ldv_assert(0); 63 } 64 65 /* The constant is for simulating an error of ldv_undef_ptr() function. */ 66 #define LDV_PTR_MAX 2012 67 68 #endif /* _LDV_RCV_H_ */

Here is an explanation of a rule violation arisen while checking your driver against a corresponding kernel.

Note that it may be false positive, i.e. there isn't a real error indeed. Please analyze a given error trace and related source code to understand whether there is an error in your driver.

Error trace column contains a path on which the given rule is violated. You can expand/collapse some entity classes by clicking on corresponding checkboxes in a main menu or in an advanced Others menu. Also you can expand/collapse each particular entity by clicking on +/-. In hovering on some entities you can see some tips. Also the error trace is bound with related source code. Line numbers may be shown as links on the left. You can click on them to open corresponding lines in source code.

Source code column contains a content of files related with the error trace. There is source code of your driver (note that there are some LDV modifications at the end), kernel headers and rule model. Tabs show a currently opened file and other available files. In hovering on them you can see full file names. On clicking a corresponding file content will be shown.

Kernel Module Rule Verifier Verdict Status Timestamp Bug report
linux-4.10-rc1.tar.xz drivers/mmc/host/sdhci-pxav2.ko 322_7a CPAchecker Bug Fixed 2017-02-11 01:55:11 L0268

Comment

Reported: 11 Feb 2017

[Home]

»