Error Trace

[Home]

Bug # 102

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()
{
19 typedef signed char __s8;
20 typedef unsigned char __u8;
22 typedef short __s16;
23 typedef unsigned short __u16;
25 typedef int __s32;
26 typedef unsigned int __u32;
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;
32 typedef __u16 __le16;
33 typedef __u16 __be16;
34 typedef __u32 __le32;
35 typedef __u32 __be32;
37 typedef __u64 __be64;
40 typedef __u32 __wsum;
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;
83 typedef unsigned char u_char;
102 typedef __s32 int32_t;
106 typedef __u8 uint8_t;
108 typedef __u32 uint32_t;
111 typedef __u64 uint64_t;
133 typedef unsigned long sector_t;
134 typedef unsigned long blkcnt_t;
146 typedef u64 dma_addr_t;
157 typedef unsigned int gfp_t;
158 typedef unsigned int fmode_t;
159 typedef unsigned int oom_flags_t;
162 typedef u64 phys_addr_t;
167 typedef phys_addr_t resource_size_t;
177 struct __anonstruct_atomic_t_6 { int counter; } ;
177 typedef struct __anonstruct_atomic_t_6 atomic_t;
182 struct __anonstruct_atomic64_t_7 { long counter; } ;
182 typedef struct __anonstruct_atomic64_t_7 atomic64_t;
183 struct list_head { struct list_head *next; struct list_head *prev; } ;
188 struct hlist_node ;
188 struct hlist_head { struct hlist_node *first; } ;
192 struct hlist_node { struct hlist_node *next; struct hlist_node **pprev; } ;
203 struct callback_head { struct callback_head *next; void (*func)(struct callback_head *); } ;
213 enum dma_data_direction { DMA_BIDIRECTIONAL = 0, DMA_TO_DEVICE = 1, DMA_FROM_DEVICE = 2, DMA_NONE = 3 } ;
5 struct device ;
5 struct page ;
7 struct dma_attrs ;
23 struct kernel_symbol { unsigned long value; const char *name; } ;
33 struct module ;
65 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; } ;
59 struct __anonstruct____missing_field_name_9 { unsigned int a; unsigned int b; } ;
59 struct __anonstruct____missing_field_name_10 { 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; } ;
59 union __anonunion____missing_field_name_8 { struct __anonstruct____missing_field_name_9 __annonCompField4; struct __anonstruct____missing_field_name_10 __annonCompField5; } ;
59 struct desc_struct { union __anonunion____missing_field_name_8 __annonCompField6; } ;
15 typedef unsigned long pgdval_t;
16 typedef unsigned long pgprotval_t;
20 struct pgprot { pgprotval_t pgprot; } ;
243 typedef struct pgprot pgprot_t;
245 struct __anonstruct_pgd_t_12 { pgdval_t pgd; } ;
245 typedef struct __anonstruct_pgd_t_12 pgd_t;
333 typedef struct page *pgtable_t;
341 struct file ;
354 struct seq_file ;
389 struct thread_struct ;
391 struct mm_struct ;
392 struct task_struct ;
393 struct cpumask ;
327 struct arch_spinlock ;
18 typedef u16 __ticket_t;
19 typedef u32 __ticketpair_t;
20 struct __raw_tickets { __ticket_t head; __ticket_t tail; } ;
32 union __anonunion____missing_field_name_15 { __ticketpair_t head_tail; struct __raw_tickets tickets; } ;
32 struct arch_spinlock { union __anonunion____missing_field_name_15 __annonCompField7; } ;
33 typedef struct arch_spinlock arch_spinlock_t;
33 struct __anonstruct____missing_field_name_17 { u32 read; s32 write; } ;
33 union __anonunion_arch_rwlock_t_16 { s64 lock; struct __anonstruct____missing_field_name_17 __annonCompField8; } ;
33 typedef union __anonunion_arch_rwlock_t_16 arch_rwlock_t;
142 typedef void (*ctor_fn_t)();
54 struct net_device ;
376 struct file_operations ;
388 struct completion ;
416 struct pid ;
527 struct bug_entry { int bug_addr_disp; int file_disp; unsigned short line; unsigned short flags; } ;
102 struct timespec ;
127 struct kernel_vm86_regs { struct pt_regs pt; unsigned short es; unsigned short __esh; unsigned short ds; unsigned short __dsh; unsigned short fs; unsigned short __fsh; unsigned short gs; unsigned short __gsh; } ;
79 union __anonunion____missing_field_name_22 { struct pt_regs *regs; struct kernel_vm86_regs *vm86; } ;
79 struct math_emu_info { long ___orig_eip; union __anonunion____missing_field_name_22 __annonCompField10; } ;
306 struct cpumask { unsigned long bits[128U]; } ;
14 typedef struct cpumask cpumask_t;
663 typedef struct cpumask *cpumask_var_t;
195 struct static_key ;
162 struct seq_operations ;
294 struct i387_fsave_struct { u32 cwd; u32 swd; u32 twd; u32 fip; u32 fcs; u32 foo; u32 fos; u32 st_space[20U]; u32 status; } ;
312 struct __anonstruct____missing_field_name_27 { u64 rip; u64 rdp; } ;
312 struct __anonstruct____missing_field_name_28 { u32 fip; u32 fcs; u32 foo; u32 fos; } ;
312 union __anonunion____missing_field_name_26 { struct __anonstruct____missing_field_name_27 __annonCompField14; struct __anonstruct____missing_field_name_28 __annonCompField15; } ;
312 union __anonunion____missing_field_name_29 { u32 padding1[12U]; u32 sw_reserved[12U]; } ;
312 struct i387_fxsave_struct { u16 cwd; u16 swd; u16 twd; u16 fop; union __anonunion____missing_field_name_26 __annonCompField16; u32 mxcsr; u32 mxcsr_mask; u32 st_space[32U]; u32 xmm_space[64U]; u32 padding[12U]; union __anonunion____missing_field_name_29 __annonCompField17; } ;
346 struct i387_soft_struct { u32 cwd; u32 swd; u32 twd; u32 fip; u32 fcs; u32 foo; u32 fos; u32 st_space[20U]; u8 ftop; u8 changed; u8 lookahead; u8 no_update; u8 rm; u8 alimit; struct math_emu_info *info; u32 entry_eip; } ;
367 struct ymmh_struct { u32 ymmh_space[64U]; } ;
372 struct lwp_struct { u8 reserved[128U]; } ;
377 struct bndregs_struct { u64 bndregs[8U]; } ;
381 struct bndcsr_struct { u64 cfg_reg_u; u64 status_reg; } ;
386 struct xsave_hdr_struct { u64 xstate_bv; u64 reserved1[2U]; u64 reserved2[5U]; } ;
392 struct xsave_struct { struct i387_fxsave_struct i387; struct xsave_hdr_struct xsave_hdr; struct ymmh_struct ymmh; struct lwp_struct lwp; struct bndregs_struct bndregs; struct bndcsr_struct bndcsr; } ;
401 union thread_xstate { struct i387_fsave_struct fsave; struct i387_fxsave_struct fxsave; struct i387_soft_struct soft; struct xsave_struct xsave; } ;
409 struct fpu { unsigned int last_cpu; unsigned int has_fpu; union thread_xstate *state; } ;
456 struct kmem_cache ;
457 struct perf_event ;
458 struct thread_struct { struct desc_struct tls_array[3U]; unsigned long sp0; unsigned long sp; unsigned long usersp; unsigned short es; unsigned short ds; unsigned short fsindex; unsigned short gsindex; unsigned long fs; unsigned long gs; struct perf_event *ptrace_bps[4U]; unsigned long debugreg6; unsigned long ptrace_dr7; unsigned long cr2; unsigned long trap_nr; unsigned long error_code; struct fpu fpu; unsigned long *io_bitmap_ptr; unsigned long iopl; unsigned int io_bitmap_max; unsigned char fpu_counter; } ;
23 typedef atomic64_t atomic_long_t;
152 struct lockdep_map ;
55 struct stack_trace { unsigned int nr_entries; unsigned int max_entries; unsigned long *entries; int skip; } ;
26 struct lockdep_subclass_key { char __one_byte; } ;
53 struct lock_class_key { struct lockdep_subclass_key subkeys[8U]; } ;
59 struct lock_class { struct list_head hash_entry; struct list_head lock_entry; struct lockdep_subclass_key *key; unsigned int subclass; unsigned int dep_gen_id; unsigned long usage_mask; struct stack_trace usage_traces[13U]; struct list_head locks_after; struct list_head locks_before; unsigned int version; unsigned long ops; 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; } ;
205 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; } ;
537 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_33 { u8 __padding[24U]; struct lockdep_map dep_map; } ;
33 union __anonunion____missing_field_name_32 { struct raw_spinlock rlock; struct __anonstruct____missing_field_name_33 __annonCompField19; } ;
33 struct spinlock { union __anonunion____missing_field_name_32 __annonCompField20; } ;
76 typedef struct spinlock spinlock_t;
23 struct __anonstruct_rwlock_t_34 { 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_34 rwlock_t;
59 struct static_key { atomic_t enabled; } ;
412 struct seqcount { unsigned int sequence; struct lockdep_map dep_map; } ;
51 typedef struct seqcount seqcount_t;
259 struct __anonstruct_seqlock_t_35 { struct seqcount seqcount; spinlock_t lock; } ;
259 typedef struct __anonstruct_seqlock_t_35 seqlock_t;
433 struct timespec { __kernel_time_t tv_sec; long tv_nsec; } ;
83 struct user_namespace ;
22 struct __anonstruct_kuid_t_36 { uid_t val; } ;
22 typedef struct __anonstruct_kuid_t_36 kuid_t;
27 struct __anonstruct_kgid_t_37 { gid_t val; } ;
27 typedef struct __anonstruct_kgid_t_37 kgid_t;
127 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; } ;
34 struct __wait_queue_head { spinlock_t lock; struct list_head task_list; } ;
39 typedef struct __wait_queue_head wait_queue_head_t;
98 struct __anonstruct_nodemask_t_38 { unsigned long bits[16U]; } ;
98 typedef struct __anonstruct_nodemask_t_38 nodemask_t;
799 struct mutex { atomic_t count; spinlock_t wait_lock; struct list_head wait_list; struct task_struct *owner; const char *name; void *magic; struct lockdep_map dep_map; } ;
67 struct mutex_waiter { struct list_head list; struct task_struct *task; void *magic; } ;
177 struct rw_semaphore ;
178 struct rw_semaphore { long count; raw_spinlock_t wait_lock; struct list_head wait_list; struct lockdep_map dep_map; } ;
155 struct completion { unsigned int done; wait_queue_head_t wait; } ;
223 struct notifier_block ;
323 union ktime { s64 tv64; } ;
59 typedef union ktime ktime_t;
388 struct tvec_base ;
389 struct timer_list { struct list_head entry; unsigned long expires; struct tvec_base *base; void (*function)(unsigned long); unsigned long data; int slack; int start_pid; void *start_site; char start_comm[16U]; struct lockdep_map lockdep_map; } ;
254 struct hrtimer ;
255 enum hrtimer_restart ;
266 struct workqueue_struct ;
267 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; } ;
51 struct notifier_block { int (*notifier_call)(struct notifier_block *, unsigned long, void *); struct notifier_block *next; int priority; } ;
63 struct blocking_notifier_head { struct rw_semaphore rwsem; struct notifier_block *head; } ;
891 struct ctl_table ;
72 struct resource { resource_size_t start; resource_size_t end; const char *name; unsigned long flags; struct resource *parent; struct resource *sibling; struct resource *child; } ;
172 struct pci_dev ;
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 *); } ;
301 enum rpm_status { RPM_ACTIVE = 0, RPM_RESUMING = 1, RPM_SUSPENDED = 2, RPM_SUSPENDING = 3 } ;
308 enum rpm_request { RPM_REQ_NONE = 0, RPM_REQ_IDLE = 1, RPM_REQ_SUSPEND = 2, RPM_REQ_AUTOSUSPEND = 3, RPM_REQ_RESUME = 4 } ;
316 struct wakeup_source ;
527 struct pm_subsys_data { spinlock_t lock; unsigned int refcount; struct list_head clock_list; } ;
534 struct dev_pm_qos ;
534 struct dev_pm_info { pm_message_t power_state; unsigned char can_wakeup; unsigned char async_suspend; bool is_prepared; bool is_suspended; bool ignore_children; bool early_init; spinlock_t lock; struct list_head entry; struct completion completion; struct wakeup_source *wakeup; bool wakeup_path; bool syscore; struct timer_list suspend_timer; unsigned long timer_expires; struct work_struct work; wait_queue_head_t wait_queue; atomic_t usage_count; atomic_t child_count; unsigned char disable_depth; unsigned char idle_notification; unsigned char request_pending; unsigned char deferred_resume; unsigned char run_wake; unsigned char runtime_auto; unsigned char no_callbacks; unsigned char irq_safe; unsigned char use_autosuspend; unsigned char timer_autosuspends; unsigned char memalloc_noio; enum rpm_request request; enum rpm_status runtime_status; int runtime_error; int autosuspend_delay; unsigned long last_busy; unsigned long active_jiffies; unsigned long suspended_jiffies; unsigned long accounting_timestamp; struct pm_subsys_data *subsys_data; struct dev_pm_qos *qos; } ;
591 struct dev_pm_domain { struct dev_pm_ops ops; } ;
133 struct pci_bus ;
22 struct __anonstruct_mm_context_t_103 { void *ldt; int size; unsigned short ia32_compat; struct mutex lock; void *vdso; } ;
22 typedef struct __anonstruct_mm_context_t_103 mm_context_t;
18 struct rb_node { unsigned long __rb_parent_color; struct rb_node *rb_right; struct rb_node *rb_left; } ;
40 struct rb_root { struct rb_node *rb_node; } ;
87 struct vm_area_struct ;
341 struct device_node ;
1276 struct llist_node ;
64 struct llist_node { struct llist_node *next; } ;
835 struct nsproxy ;
836 struct ctl_table_root ;
837 struct ctl_table_header ;
838 struct ctl_dir ;
39 typedef int proc_handler(struct ctl_table *, int, void *, size_t *, loff_t *);
59 struct ctl_table_poll { atomic_t event; wait_queue_head_t wait; } ;
98 struct ctl_table { const char *procname; void *data; int maxlen; umode_t mode; struct ctl_table *child; proc_handler *proc_handler; struct ctl_table_poll *poll; void *extra1; void *extra2; } ;
119 struct ctl_node { struct rb_node node; struct ctl_table_header *header; } ;
124 struct __anonstruct____missing_field_name_132 { struct ctl_table *ctl_table; int used; int count; int nreg; } ;
124 union __anonunion____missing_field_name_131 { struct __anonstruct____missing_field_name_132 __annonCompField32; struct callback_head rcu; } ;
124 struct ctl_table_set ;
124 struct ctl_table_header { union __anonunion____missing_field_name_131 __annonCompField33; struct completion *unregistering; struct ctl_table *ctl_table_arg; struct ctl_table_root *root; struct ctl_table_set *set; struct ctl_dir *parent; struct ctl_node *node; } ;
145 struct ctl_dir { struct ctl_table_header header; struct rb_root root; } ;
151 struct ctl_table_set { int (*is_seen)(struct ctl_table_set *); struct ctl_dir dir; } ;
156 struct ctl_table_root { struct ctl_table_set default_set; struct ctl_table_set * (*lookup)(struct ctl_table_root *, struct nsproxy *); int (*permissions)(struct ctl_table_header *, struct ctl_table *); } ;
37 struct cred ;
15 typedef __u64 Elf64_Addr;
16 typedef __u16 Elf64_Half;
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;
48 struct idr_layer { int prefix; unsigned long bitmap[4U]; struct idr_layer *ary[256U]; int count; int layer; struct callback_head callback_head; } ;
38 struct idr { struct idr_layer *hint; struct idr_layer *top; struct idr_layer *id_free; int layers; int id_free_cnt; int cur; spinlock_t lock; } ;
197 struct ida_bitmap { long nr_busy; unsigned long bitmap[15U]; } ;
213 struct ida { struct idr idr; struct ida_bitmap *free_bitmap; } ;
245 struct dentry ;
246 struct iattr ;
247 struct super_block ;
248 struct file_system_type ;
249 struct kernfs_open_node ;
250 struct kernfs_iattrs ;
266 struct kernfs_root ;
266 struct kernfs_elem_dir { unsigned long subdirs; struct rb_root children; struct kernfs_root *root; } ;
62 struct kernfs_node ;
62 struct kernfs_elem_symlink { struct kernfs_node *target_kn; } ;
66 struct kernfs_ops ;
66 struct kernfs_elem_attr { const struct kernfs_ops *ops; struct kernfs_open_node *open; loff_t size; } ;
72 union __anonunion_u_137 { struct completion *completion; struct kernfs_node *removed_list; } ;
72 union __anonunion____missing_field_name_138 { struct kernfs_elem_dir dir; struct kernfs_elem_symlink symlink; struct kernfs_elem_attr attr; } ;
72 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; union __anonunion_u_137 u; const void *ns; unsigned int hash; union __anonunion____missing_field_name_138 __annonCompField34; void *priv; unsigned short flags; umode_t mode; unsigned int ino; struct kernfs_iattrs *iattr; } ;
114 struct kernfs_dir_ops { int (*mkdir)(struct kernfs_node *, const char *, umode_t ); int (*rmdir)(struct kernfs_node *); int (*rename)(struct kernfs_node *, struct kernfs_node *, const char *); } ;
127 struct kernfs_root { struct kernfs_node *kn; struct ida ino_ida; struct kernfs_dir_ops *dir_ops; } ;
137 struct vm_operations_struct ;
137 struct kernfs_open_file { struct kernfs_node *kn; struct file *file; struct mutex mutex; int event; struct list_head list; bool mmapped; const struct vm_operations_struct *vm_ops; } ;
151 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 ); 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; } ;
376 struct sock ;
377 struct kobject ;
378 enum kobj_ns_type { KOBJ_NS_TYPE_NONE = 0, KOBJ_NS_TYPE_NET = 1, KOBJ_NS_TYPES = 2 } ;
384 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); struct attribute **attrs; struct bin_attribute **bin_attrs; } ;
67 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 *); } ;
130 struct sysfs_ops { ssize_t (*show)(struct kobject *, struct attribute *, char *); ssize_t (*store)(struct kobject *, struct attribute *, const char *, size_t ); } ;
462 struct kref { atomic_t refcount; } ;
50 struct kset ;
50 struct kobj_type ;
50 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; } ;
112 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 *); } ;
120 struct kobj_uevent_env { char *envp[32U]; int envp_idx; char buf[2048U]; int buflen; } ;
127 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 *); } ;
144 struct kset { struct list_head list; spinlock_t list_lock; struct kobject kobj; const struct kset_uevent_ops *uevent_ops; } ;
219 struct kernel_param ;
224 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 *); } ;
58 struct kparam_string ;
58 struct kparam_array ;
58 union __anonunion____missing_field_name_139 { void *arg; const struct kparam_string *str; const struct kparam_array *arr; } ;
58 struct kernel_param { const char *name; const struct kernel_param_ops *ops; u16 perm; s16 level; union __anonunion____missing_field_name_139 __annonCompField35; } ;
70 struct kparam_string { unsigned int maxlen; char *string; } ;
76 struct kparam_array { unsigned int max; unsigned int elemsize; unsigned int *num; const struct kernel_param_ops *ops; void *elem; } ;
463 struct tracepoint ;
464 struct tracepoint_func { void *func; void *data; } ;
29 struct tracepoint { const char *name; struct static_key key; void (*regfunc)(); void (*unregfunc)(); struct tracepoint_func *funcs; } ;
92 struct mod_arch_specific { } ;
36 struct module_param_attrs ;
36 struct module_kobject { struct kobject kobj; struct module *mod; struct kobject *drivers_dir; struct module_param_attrs *mp; struct completion *kobj_completion; } ;
46 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 *); } ;
72 struct exception_table_entry ;
208 enum module_state { MODULE_STATE_LIVE = 0, MODULE_STATE_COMING = 1, MODULE_STATE_GOING = 2, MODULE_STATE_UNFORMED = 3 } ;
215 struct module_ref { unsigned long incs; unsigned long decs; } ;
229 struct module_sect_attrs ;
229 struct module_notes_attrs ;
229 struct ftrace_event_call ;
229 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 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; 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)(); void *module_init; void *module_core; unsigned int init_size; unsigned int core_size; unsigned int init_text_size; unsigned int core_text_size; unsigned int init_ro_size; unsigned int core_ro_size; struct mod_arch_specific arch; unsigned int taints; unsigned int num_bugs; struct list_head bug_list; struct bug_entry *bug_table; Elf64_Sym *symtab; Elf64_Sym *core_symtab; unsigned int num_symtab; unsigned int core_num_syms; char *strtab; char *core_strtab; struct module_sect_attrs *sect_attrs; struct module_notes_attrs *notes_attrs; char *args; void *percpu; unsigned int percpu_size; unsigned int num_tracepoints; const struct tracepoint **tracepoints_ptrs; unsigned int num_trace_bprintk_fmt; const char **trace_bprintk_fmt_start; struct ftrace_event_call **trace_events; unsigned int num_trace_events; struct list_head source_list; struct list_head target_list; void (*exit)(); struct module_ref *refptr; ctor_fn_t (**ctors)(); unsigned int num_ctors; } ;
13 typedef unsigned long kernel_ulong_t;
14 struct pci_device_id { __u32 vendor; __u32 device; __u32 subvendor; __u32 subdevice; __u32 class; __u32 class_mask; kernel_ulong_t driver_data; } ;
186 struct acpi_device_id { __u8 id[9U]; kernel_ulong_t driver_data; } ;
219 struct of_device_id { char name[32U]; char type[32U]; char compatible[128U]; const void *data; } ;
601 struct klist_node ;
37 struct klist_node { void *n_klist; struct list_head n_node; struct kref n_ref; } ;
67 struct path ;
68 struct inode ;
69 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; struct user_namespace *user_ns; void *private; } ;
35 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 *); } ;
196 struct pinctrl ;
197 struct pinctrl_state ;
194 struct dev_pin_info { struct pinctrl *p; struct pinctrl_state *default_state; struct pinctrl_state *sleep_state; struct pinctrl_state *idle_state; } ;
42 struct dma_map_ops ;
42 struct dev_archdata { struct dma_map_ops *dma_ops; void *iommu; } ;
14 struct device_private ;
15 struct device_driver ;
16 struct driver_private ;
17 struct class ;
18 struct subsys_private ;
19 struct bus_type ;
20 struct iommu_ops ;
21 struct iommu_group ;
60 struct device_attribute ;
60 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; struct iommu_ops *iommu_ops; struct subsys_private *p; struct lock_class_key lock_key; } ;
138 struct device_type ;
195 struct device_driver { const char *name; struct bus_type *bus; struct module *owner; const char *mod_name; bool suppress_bind_attrs; 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; } ;
321 struct class_attribute ;
321 struct class { const char *name; struct module *owner; struct class_attribute *class_attrs; 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; } ;
414 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 ); } ;
482 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; } ;
510 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 ); } ;
637 struct device_dma_parameters { unsigned int max_segment_size; unsigned long segment_boundary_mask; } ;
646 struct acpi_device ;
647 struct acpi_dev_node { struct acpi_device *companion; } ;
653 struct dma_coherent_mem ;
653 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; struct dev_pm_info power; struct dev_pm_domain *pm_domain; struct dev_pin_info *pins; int numa_node; u64 *dma_mask; u64 coherent_dma_mask; struct device_dma_parameters *dma_parms; struct list_head dma_pools; struct dma_coherent_mem *dma_mem; struct dev_archdata archdata; struct device_node *of_node; struct acpi_dev_node acpi_node; dev_t devt; u32 id; spinlock_t devres_lock; struct list_head devres_head; struct klist_node knode_class; struct class *class; const struct attribute_group **groups; void (*release)(struct device *); struct iommu_group *iommu_group; bool offline_disabled; bool offline; } ;
795 struct wakeup_source { const char *name; struct list_head entry; spinlock_t lock; struct timer_list timer; unsigned long timer_expires; ktime_t total_time; ktime_t max_time; ktime_t last_time; ktime_t start_prevent_time; ktime_t prevent_sleep_time; unsigned long event_count; unsigned long active_count; unsigned long relax_count; unsigned long expire_count; unsigned long wakeup_count; bool active; bool autosleep_enabled; } ;
17 struct hotplug_slot ;
17 struct pci_slot { struct pci_bus *bus; struct list_head list; struct hotplug_slot *hotplug; unsigned char number; struct kobject kobj; } ;
110 typedef int pci_power_t;
137 typedef unsigned int pci_channel_state_t;
138 enum pci_channel_state { pci_channel_io_normal = 1, pci_channel_io_frozen = 2, pci_channel_io_perm_failure = 3 } ;
163 typedef unsigned short pci_dev_flags_t;
180 typedef unsigned short pci_bus_flags_t;
237 struct pcie_link_state ;
238 struct pci_vpd ;
239 struct pci_sriov ;
240 struct pci_ats ;
241 struct proc_dir_entry ;
241 struct pci_driver ;
241 union __anonunion____missing_field_name_143 { struct pci_sriov *sriov; struct pci_dev *physfn; } ;
241 struct pci_dev { struct list_head bus_list; struct pci_bus *bus; struct pci_bus *subordinate; void *sysdata; struct proc_dir_entry *procent; struct pci_slot *slot; unsigned int devfn; unsigned short vendor; unsigned short device; unsigned short subsystem_vendor; unsigned short subsystem_device; unsigned int class; u8 revision; u8 hdr_type; u8 pcie_cap; u8 msi_cap; u8 msix_cap; unsigned char pcie_mpss; u8 rom_base_reg; u8 pin; u16 pcie_flags_reg; struct pci_driver *driver; u64 dma_mask; struct device_dma_parameters dma_parms; pci_power_t current_state; u8 pm_cap; unsigned char pme_support; unsigned char pme_interrupt; unsigned char pme_poll; unsigned char d1_support; unsigned char d2_support; unsigned char no_d1d2; unsigned char no_d3cold; unsigned char d3cold_allowed; unsigned char mmio_always_on; unsigned char wakeup_prepared; unsigned char runtime_d3cold; unsigned int d3_delay; unsigned int d3cold_delay; struct pcie_link_state *link_state; pci_channel_state_t error_state; struct device dev; int cfg_size; unsigned int irq; struct resource resource[17U]; bool match_driver; unsigned char transparent; unsigned char multifunction; unsigned char is_added; unsigned char is_busmaster; unsigned char no_msi; unsigned char block_cfg_access; unsigned char broken_parity_status; unsigned char irq_reroute_variant; unsigned char msi_enabled; unsigned char msix_enabled; unsigned char ari_enabled; unsigned char is_managed; unsigned char needs_freset; unsigned char state_saved; unsigned char is_physfn; unsigned char is_virtfn; unsigned char reset_fn; unsigned char is_hotplug_bridge; unsigned char __aer_firmware_first_valid; unsigned char __aer_firmware_first; unsigned char broken_intx_masking; unsigned char io_window_1k; pci_dev_flags_t dev_flags; atomic_t enable_cnt; u32 saved_config_space[16U]; struct hlist_head saved_cap_space; struct bin_attribute *rom_attr; int rom_attr_enabled; struct bin_attribute *res_attr[17U]; struct bin_attribute *res_attr_wc[17U]; struct list_head msi_list; const struct attribute_group **msi_irq_groups; struct pci_vpd *vpd; union __anonunion____missing_field_name_143 __annonCompField36; struct pci_ats *ats; phys_addr_t rom; size_t romlen; } ;
429 struct pci_ops ;
429 struct msi_chip ;
429 struct pci_bus { struct list_head node; struct pci_bus *parent; struct list_head children; struct list_head devices; struct pci_dev *self; struct list_head slots; struct resource *resource[4U]; struct list_head resources; struct resource busn_res; struct pci_ops *ops; struct msi_chip *msi; void *sysdata; struct proc_dir_entry *procdir; unsigned char number; unsigned char primary; unsigned char max_bus_speed; unsigned char cur_bus_speed; char name[48U]; unsigned short bridge_ctl; pci_bus_flags_t bus_flags; struct device *bridge; struct device dev; struct bin_attribute *legacy_io; struct bin_attribute *legacy_mem; unsigned char is_added; } ;
534 struct pci_ops { int (*read)(struct pci_bus *, unsigned int, int, int, u32 *); int (*write)(struct pci_bus *, unsigned int, int, int, u32 ); } ;
555 struct pci_dynids { spinlock_t lock; struct list_head list; } ;
569 typedef unsigned int pci_ers_result_t;
579 struct pci_error_handlers { pci_ers_result_t (*error_detected)(struct pci_dev *, enum pci_channel_state ); pci_ers_result_t (*mmio_enabled)(struct pci_dev *); pci_ers_result_t (*link_reset)(struct pci_dev *); pci_ers_result_t (*slot_reset)(struct pci_dev *); void (*resume)(struct pci_dev *); } ;
609 struct pci_driver { struct list_head node; const char *name; const struct pci_device_id *id_table; int (*probe)(struct pci_dev *, const struct pci_device_id *); void (*remove)(struct pci_dev *); int (*suspend)(struct pci_dev *, pm_message_t ); int (*suspend_late)(struct pci_dev *, pm_message_t ); int (*resume_early)(struct pci_dev *); int (*resume)(struct pci_dev *); void (*shutdown)(struct pci_dev *); int (*sriov_configure)(struct pci_dev *, int); const struct pci_error_handlers *err_handler; struct device_driver driver; struct pci_dynids dynids; } ;
1131 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; } ;
45 struct arch_uprobe_task { unsigned long saved_scratch_register; unsigned int saved_trap_nr; unsigned int saved_tf; } ;
54 enum uprobe_task_state { UTASK_RUNNING = 0, UTASK_SSTEP = 1, UTASK_SSTEP_ACK = 2, UTASK_SSTEP_TRAPPED = 3 } ;
61 struct __anonstruct____missing_field_name_146 { struct arch_uprobe_task autask; unsigned long vaddr; } ;
61 struct __anonstruct____missing_field_name_147 { struct callback_head dup_xol_work; unsigned long dup_xol_addr; } ;
61 union __anonunion____missing_field_name_145 { struct __anonstruct____missing_field_name_146 __annonCompField38; struct __anonstruct____missing_field_name_147 __annonCompField39; } ;
61 struct uprobe ;
61 struct return_instance ;
61 struct uprobe_task { enum uprobe_task_state state; union __anonunion____missing_field_name_145 __annonCompField40; struct uprobe *active_uprobe; unsigned long xol_vaddr; struct return_instance *return_instances; unsigned int depth; } ;
93 struct xol_area ;
94 struct uprobes_state { struct xol_area *xol_area; } ;
129 struct address_space ;
130 union __anonunion____missing_field_name_148 { struct address_space *mapping; void *s_mem; } ;
130 union __anonunion____missing_field_name_150 { unsigned long index; void *freelist; bool pfmemalloc; } ;
130 struct __anonstruct____missing_field_name_154 { unsigned short inuse; unsigned short objects; unsigned char frozen; } ;
130 union __anonunion____missing_field_name_153 { atomic_t _mapcount; struct __anonstruct____missing_field_name_154 __annonCompField43; int units; } ;
130 struct __anonstruct____missing_field_name_152 { union __anonunion____missing_field_name_153 __annonCompField44; atomic_t _count; } ;
130 union __anonunion____missing_field_name_151 { unsigned long counters; struct __anonstruct____missing_field_name_152 __annonCompField45; unsigned int active; } ;
130 struct __anonstruct____missing_field_name_149 { union __anonunion____missing_field_name_150 __annonCompField42; union __anonunion____missing_field_name_151 __annonCompField46; } ;
130 struct __anonstruct____missing_field_name_156 { struct page *next; int pages; int pobjects; } ;
130 struct slab ;
130 union __anonunion____missing_field_name_155 { struct list_head lru; struct __anonstruct____missing_field_name_156 __annonCompField48; struct list_head list; struct slab *slab_page; struct callback_head callback_head; pgtable_t pmd_huge_pte; } ;
130 union __anonunion____missing_field_name_157 { unsigned long private; spinlock_t *ptl; struct kmem_cache *slab_cache; struct page *first_page; } ;
130 struct page { unsigned long flags; union __anonunion____missing_field_name_148 __annonCompField41; struct __anonstruct____missing_field_name_149 __annonCompField47; union __anonunion____missing_field_name_155 __annonCompField49; union __anonunion____missing_field_name_157 __annonCompField50; unsigned long debug_flags; } ;
186 struct page_frag { struct page *page; __u32 offset; __u32 size; } ;
238 struct __anonstruct_linear_159 { struct rb_node rb; unsigned long rb_subtree_last; } ;
238 union __anonunion_shared_158 { struct __anonstruct_linear_159 linear; struct list_head nonlinear; } ;
238 struct anon_vma ;
238 struct mempolicy ;
238 struct vm_area_struct { unsigned long vm_start; unsigned long vm_end; struct vm_area_struct *vm_next; struct vm_area_struct *vm_prev; struct rb_node vm_rb; unsigned long rb_subtree_gap; struct mm_struct *vm_mm; pgprot_t vm_page_prot; unsigned long vm_flags; union __anonunion_shared_158 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; } ;
310 struct core_thread { struct task_struct *task; struct core_thread *next; } ;
316 struct core_state { atomic_t nr_threads; struct core_thread dumper; struct completion startup; } ;
329 struct task_rss_stat { int events; int count[3U]; } ;
337 struct mm_rss_stat { atomic_long_t count[3U]; } ;
342 struct kioctx_table ;
343 struct linux_binfmt ;
343 struct mmu_notifier_mm ;
343 struct mm_struct { struct vm_area_struct *mmap; struct rb_root mm_rb; struct vm_area_struct *mmap_cache; 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; int map_count; spinlock_t page_table_lock; struct rw_semaphore mmap_sem; struct list_head mmlist; unsigned long hiwater_rss; unsigned long hiwater_vm; unsigned long total_vm; unsigned long locked_vm; unsigned long pinned_vm; unsigned long shared_vm; unsigned long exec_vm; unsigned long stack_vm; unsigned long def_flags; unsigned long 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 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; } ;
93 struct shrink_control { gfp_t gfp_mask; unsigned long nr_to_scan; nodemask_t nodes_to_scan; int nid; } ;
26 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; } ;
71 struct file_ra_state ;
72 struct user_struct ;
73 struct writeback_control ;
185 struct vm_fault { unsigned int flags; unsigned long pgoff; void *virtual_address; struct page *page; } ;
210 struct vm_operations_struct { void (*open)(struct vm_area_struct *); void (*close)(struct vm_area_struct *); int (*fault)(struct vm_area_struct *, struct vm_fault *); int (*page_mkwrite)(struct vm_area_struct *, struct vm_fault *); int (*access)(struct vm_area_struct *, unsigned long, void *, int, int); int (*set_policy)(struct vm_area_struct *, struct mempolicy *); struct mempolicy * (*get_policy)(struct vm_area_struct *, unsigned long); int (*migrate)(struct vm_area_struct *, const nodemask_t *, const nodemask_t *, unsigned long); int (*remap_pages)(struct vm_area_struct *, unsigned long, unsigned long, unsigned long); } ;
58 struct mem_cgroup ;
355 struct kmem_cache_cpu { void **freelist; unsigned long tid; struct page *page; struct page *partial; unsigned int stat[26U]; } ;
48 struct kmem_cache_order_objects { unsigned long x; } ;
58 struct memcg_cache_params ;
58 struct kmem_cache_node ;
58 struct kmem_cache { struct kmem_cache_cpu *cpu_slab; unsigned long flags; unsigned long min_partial; int size; int object_size; int offset; int cpu_partial; struct kmem_cache_order_objects oo; struct kmem_cache_order_objects max; struct kmem_cache_order_objects min; gfp_t allocflags; int refcount; void (*ctor)(void *); int inuse; int align; int reserved; const char *name; struct list_head list; struct kobject kobj; struct memcg_cache_params *memcg_params; int max_attr_size; int remote_node_defrag_ratio; struct kmem_cache_node *node[1024U]; } ;
497 struct __anonstruct____missing_field_name_161 { struct callback_head callback_head; struct kmem_cache *memcg_caches[0U]; } ;
497 struct __anonstruct____missing_field_name_162 { struct mem_cgroup *memcg; struct list_head list; struct kmem_cache *root_cache; bool dead; atomic_t nr_pages; struct work_struct destroy; } ;
497 union __anonunion____missing_field_name_160 { struct __anonstruct____missing_field_name_161 __annonCompField51; struct __anonstruct____missing_field_name_162 __annonCompField52; } ;
497 struct memcg_cache_params { bool is_root_cache; union __anonunion____missing_field_name_160 __annonCompField53; } ;
34 struct dma_attrs { unsigned long flags[1U]; } ;
70 struct sg_table { struct scatterlist *sgl; unsigned int nents; unsigned int orig_nents; } ;
351 struct dma_map_ops { void * (*alloc)(struct device *, size_t , dma_addr_t *, gfp_t , struct dma_attrs *); void (*free)(struct device *, size_t , void *, dma_addr_t , struct dma_attrs *); int (*mmap)(struct device *, struct vm_area_struct *, void *, dma_addr_t , size_t , struct dma_attrs *); int (*get_sgtable)(struct device *, struct sg_table *, void *, dma_addr_t , size_t , struct dma_attrs *); dma_addr_t (*map_page)(struct device *, struct page *, unsigned long, size_t , enum dma_data_direction , struct dma_attrs *); void (*unmap_page)(struct device *, dma_addr_t , size_t , enum dma_data_direction , struct dma_attrs *); int (*map_sg)(struct device *, struct scatterlist *, int, enum dma_data_direction , struct dma_attrs *); void (*unmap_sg)(struct device *, struct scatterlist *, int, enum dma_data_direction , struct dma_attrs *); void (*sync_single_for_cpu)(struct device *, dma_addr_t , size_t , enum dma_data_direction ); void (*sync_single_for_device)(struct device *, dma_addr_t , size_t , enum dma_data_direction ); void (*sync_sg_for_cpu)(struct device *, struct scatterlist *, int, enum dma_data_direction ); void (*sync_sg_for_device)(struct device *, struct scatterlist *, int, enum dma_data_direction ); int (*mapping_error)(struct device *, dma_addr_t ); int (*dma_supported)(struct device *, u64 ); int (*set_dma_mask)(struct device *, u64 ); int is_phys; } ;
54 struct plist_head { struct list_head node_list; } ;
84 struct plist_node { int prio; struct list_head prio_list; struct list_head node_list; } ;
83 struct pm_qos_request { struct plist_node node; int pm_qos_class; struct delayed_work work; } ;
45 struct pm_qos_flags_request { struct list_head node; s32 flags; } ;
50 enum dev_pm_qos_req_type { DEV_PM_QOS_LATENCY = 1, DEV_PM_QOS_FLAGS = 2 } ;
55 union __anonunion_data_163 { struct plist_node pnode; struct pm_qos_flags_request flr; } ;
55 struct dev_pm_qos_request { enum dev_pm_qos_req_type type; union __anonunion_data_163 data; struct device *dev; } ;
64 enum pm_qos_type { PM_QOS_UNITIALIZED = 0, PM_QOS_MAX = 1, PM_QOS_MIN = 2 } ;
70 struct pm_qos_constraints { struct plist_head list; s32 target_value; s32 default_value; enum pm_qos_type type; struct blocking_notifier_head *notifiers; } ;
83 struct pm_qos_flags { struct list_head list; s32 effective_flags; } ;
88 struct dev_pm_qos { struct pm_qos_constraints latency; struct pm_qos_flags flags; struct dev_pm_qos_request *latency_req; struct dev_pm_qos_request *flags_req; } ;
460 struct iovec { void *iov_base; __kernel_size_t iov_len; } ;
38 typedef s32 dma_cookie_t;
1156 struct dql { unsigned int num_queued; unsigned int adj_limit; unsigned int last_obj_cnt; unsigned int limit; unsigned int num_completed; unsigned int prev_ovlimit; unsigned int prev_num_queued; unsigned int prev_last_obj_cnt; unsigned int lowest_slack; unsigned long slack_start_time; unsigned int max_limit; unsigned int min_limit; unsigned int slack_hold_time; } ;
25 struct sem_undo_list ;
25 struct sysv_sem { struct sem_undo_list *undo_list; } ;
11 typedef unsigned short __kernel_sa_family_t;
23 typedef __kernel_sa_family_t sa_family_t;
24 struct sockaddr { sa_family_t sa_family; char sa_data[14U]; } ;
43 struct __anonstruct_sync_serial_settings_165 { unsigned int clock_rate; unsigned int clock_type; unsigned short loopback; } ;
43 typedef struct __anonstruct_sync_serial_settings_165 sync_serial_settings;
50 struct __anonstruct_te1_settings_166 { unsigned int clock_rate; unsigned int clock_type; unsigned short loopback; unsigned int slot_map; } ;
50 typedef struct __anonstruct_te1_settings_166 te1_settings;
55 struct __anonstruct_raw_hdlc_proto_167 { unsigned short encoding; unsigned short parity; } ;
55 typedef struct __anonstruct_raw_hdlc_proto_167 raw_hdlc_proto;
65 struct __anonstruct_fr_proto_168 { unsigned int t391; unsigned int t392; unsigned int n391; unsigned int n392; unsigned int n393; unsigned short lmi; unsigned short dce; } ;
65 typedef struct __anonstruct_fr_proto_168 fr_proto;
69 struct __anonstruct_fr_proto_pvc_169 { unsigned int dlci; } ;
69 typedef struct __anonstruct_fr_proto_pvc_169 fr_proto_pvc;
74 struct __anonstruct_fr_proto_pvc_info_170 { unsigned int dlci; char master[16U]; } ;
74 typedef struct __anonstruct_fr_proto_pvc_info_170 fr_proto_pvc_info;
79 struct __anonstruct_cisco_proto_171 { unsigned int interval; unsigned int timeout; } ;
79 typedef struct __anonstruct_cisco_proto_171 cisco_proto;
95 struct ifmap { unsigned long mem_start; unsigned long mem_end; unsigned short base_addr; unsigned char irq; unsigned char dma; unsigned char port; } ;
151 union __anonunion_ifs_ifsu_172 { raw_hdlc_proto *raw_hdlc; cisco_proto *cisco; fr_proto *fr; fr_proto_pvc *fr_pvc; fr_proto_pvc_info *fr_pvc_info; sync_serial_settings *sync; te1_settings *te1; } ;
151 struct if_settings { unsigned int type; unsigned int size; union __anonunion_ifs_ifsu_172 ifs_ifsu; } ;
169 union __anonunion_ifr_ifrn_173 { char ifrn_name[16U]; } ;
169 union __anonunion_ifr_ifru_174 { struct sockaddr ifru_addr; struct sockaddr ifru_dstaddr; struct sockaddr ifru_broadaddr; struct sockaddr ifru_netmask; struct sockaddr ifru_hwaddr; short ifru_flags; int ifru_ivalue; int ifru_mtu; struct ifmap ifru_map; char ifru_slave[16U]; char ifru_newname[16U]; void *ifru_data; struct if_settings ifru_settings; } ;
169 struct ifreq { union __anonunion_ifr_ifrn_173 ifr_ifrn; union __anonunion_ifr_ifru_174 ifr_ifru; } ;
91 struct hlist_bl_node ;
91 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_177 { spinlock_t lock; unsigned int count; } ;
114 union __anonunion____missing_field_name_176 { struct __anonstruct____missing_field_name_177 __annonCompField54; } ;
114 struct lockref { union __anonunion____missing_field_name_176 __annonCompField55; } ;
49 struct nameidata ;
50 struct vfsmount ;
51 struct __anonstruct____missing_field_name_179 { u32 hash; u32 len; } ;
51 union __anonunion____missing_field_name_178 { struct __anonstruct____missing_field_name_179 __annonCompField56; u64 hash_len; } ;
51 struct qstr { union __anonunion____missing_field_name_178 __annonCompField57; const unsigned char *name; } ;
90 struct dentry_operations ;
90 union __anonunion_d_u_180 { struct list_head d_child; struct callback_head d_rcu; } ;
90 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; struct list_head d_lru; union __anonunion_d_u_180 d_u; struct list_head d_subdirs; struct hlist_node d_alias; } ;
142 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 *, const struct dentry *, unsigned int, const char *, const struct qstr *); int (*d_delete)(const 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)(struct dentry *, bool ); } ;
469 struct path { struct vfsmount *mnt; struct dentry *dentry; } ;
26 struct list_lru_node { spinlock_t lock; struct list_head list; long nr_items; } ;
28 struct list_lru { struct list_lru_node *node; nodemask_t active_nodes; } ;
58 struct radix_tree_node ;
58 struct radix_tree_root { unsigned int height; gfp_t gfp_mask; struct radix_tree_node *rnode; } ;
381 enum pid_type { PIDTYPE_PID = 0, PIDTYPE_PGID = 1, PIDTYPE_SID = 2, PIDTYPE_MAX = 3 } ;
388 struct pid_namespace ;
388 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 } ;
30 struct block_device ;
31 struct io_context ;
32 struct cgroup_subsys_state ;
56 struct export_operations ;
58 struct kiocb ;
59 struct pipe_inode_info ;
60 struct poll_table_struct ;
61 struct kstatfs ;
62 struct swap_info_struct ;
68 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; } ;
246 struct percpu_counter { raw_spinlock_t lock; s64 count; struct list_head list; s32 *counters; } ;
176 struct fs_disk_quota { __s8 d_version; __s8 d_flags; __u16 d_fieldmask; __u32 d_id; __u64 d_blk_hardlimit; __u64 d_blk_softlimit; __u64 d_ino_hardlimit; __u64 d_ino_softlimit; __u64 d_bcount; __u64 d_icount; __s32 d_itimer; __s32 d_btimer; __u16 d_iwarns; __u16 d_bwarns; __s32 d_padding2; __u64 d_rtb_hardlimit; __u64 d_rtb_softlimit; __u64 d_rtbcount; __s32 d_rtbtimer; __u16 d_rtbwarns; __s16 d_padding3; char d_padding4[8U]; } ;
76 struct fs_qfilestat { __u64 qfs_ino; __u64 qfs_nblks; __u32 qfs_nextents; } ;
151 typedef struct fs_qfilestat fs_qfilestat_t;
152 struct fs_quota_stat { __s8 qs_version; __u16 qs_flags; __s8 qs_pad; fs_qfilestat_t qs_uquota; fs_qfilestat_t qs_gquota; __u32 qs_incoredqs; __s32 qs_btimelimit; __s32 qs_itimelimit; __s32 qs_rtbtimelimit; __u16 qs_bwarnlimit; __u16 qs_iwarnlimit; } ;
166 struct fs_qfilestatv { __u64 qfs_ino; __u64 qfs_nblks; __u32 qfs_nextents; __u32 qfs_pad; } ;
196 struct fs_quota_statv { __s8 qs_version; __u8 qs_pad1; __u16 qs_flags; __u32 qs_incoredqs; struct fs_qfilestatv qs_uquota; struct fs_qfilestatv qs_gquota; struct fs_qfilestatv qs_pquota; __s32 qs_btimelimit; __s32 qs_itimelimit; __s32 qs_rtbtimelimit; __u16 qs_bwarnlimit; __u16 qs_iwarnlimit; __u64 qs_pad2[8U]; } ;
212 struct dquot ;
19 typedef __kernel_uid32_t projid_t;
23 struct __anonstruct_kprojid_t_182 { projid_t val; } ;
23 typedef struct __anonstruct_kprojid_t_182 kprojid_t;
119 struct if_dqinfo { __u64 dqi_bgrace; __u64 dqi_igrace; __u32 dqi_flags; __u32 dqi_valid; } ;
152 enum quota_type { USRQUOTA = 0, GRPQUOTA = 1, PRJQUOTA = 2 } ;
60 typedef long long qsize_t;
61 union __anonunion____missing_field_name_183 { kuid_t uid; kgid_t gid; kprojid_t projid; } ;
61 struct kqid { union __anonunion____missing_field_name_183 __annonCompField58; enum quota_type type; } ;
178 struct mem_dqblk { qsize_t dqb_bhardlimit; qsize_t dqb_bsoftlimit; qsize_t dqb_curspace; qsize_t dqb_rsvspace; qsize_t dqb_ihardlimit; qsize_t dqb_isoftlimit; qsize_t dqb_curinodes; time_t dqb_btime; time_t dqb_itime; } ;
200 struct quota_format_type ;
201 struct mem_dqinfo { struct quota_format_type *dqi_format; int dqi_fmt_id; struct list_head dqi_dirty_list; unsigned long dqi_flags; unsigned int dqi_bgrace; unsigned int dqi_igrace; qsize_t dqi_maxblimit; qsize_t dqi_maxilimit; void *dqi_priv; } ;
264 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; } ;
291 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 *); } ;
302 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 *); } ;
316 struct quotactl_ops { int (*quota_on)(struct super_block *, int, int, struct path *); int (*quota_on_meta)(struct super_block *, int, int); int (*quota_off)(struct super_block *, int); int (*quota_sync)(struct super_block *, int); int (*get_info)(struct super_block *, int, struct if_dqinfo *); int (*set_info)(struct super_block *, int, struct if_dqinfo *); int (*get_dqblk)(struct super_block *, struct kqid , struct fs_disk_quota *); int (*set_dqblk)(struct super_block *, struct kqid , struct fs_disk_quota *); int (*get_xstate)(struct super_block *, struct fs_quota_stat *); int (*set_xstate)(struct super_block *, unsigned int, int); int (*get_xstatev)(struct super_block *, struct fs_quota_statv *); } ;
333 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; } ;
379 struct quota_info { unsigned int flags; struct mutex dqio_mutex; struct mutex dqonoff_mutex; struct rw_semaphore dqptr_sem; struct inode *files[2U]; struct mem_dqinfo info[2U]; const struct quota_format_ops *ops[2U]; } ;
345 union __anonunion_arg_185 { char *buf; void *data; } ;
345 struct __anonstruct_read_descriptor_t_184 { size_t written; size_t count; union __anonunion_arg_185 arg; int error; } ;
345 typedef struct __anonstruct_read_descriptor_t_184 read_descriptor_t;
348 struct address_space_operations { int (*writepage)(struct page *, struct writeback_control *); int (*readpage)(struct file *, struct page *); int (*writepages)(struct address_space *, struct writeback_control *); int (*set_page_dirty)(struct page *); int (*readpages)(struct file *, struct address_space *, struct list_head *, unsigned int); int (*write_begin)(struct file *, struct address_space *, loff_t , unsigned int, unsigned int, struct page **, void **); int (*write_end)(struct file *, struct address_space *, loff_t , unsigned int, unsigned int, struct page *, void *); sector_t (*bmap)(struct address_space *, sector_t ); void (*invalidatepage)(struct page *, unsigned int, unsigned int); int (*releasepage)(struct page *, gfp_t ); void (*freepage)(struct page *); ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *, loff_t , unsigned long); int (*get_xip_mem)(struct address_space *, unsigned long, int, void **, unsigned long *); int (*migratepage)(struct address_space *, struct page *, struct page *, enum migrate_mode ); int (*launder_page)(struct page *); int (*is_partially_uptodate)(struct page *, read_descriptor_t *, unsigned long); void (*is_dirty_writeback)(struct page *, bool *, bool *); int (*error_remove_page)(struct address_space *, struct page *); int (*swap_activate)(struct swap_info_struct *, struct file *, sector_t *); void (*swap_deactivate)(struct file *); } ;
408 struct backing_dev_info ;
409 struct address_space { struct inode *host; struct radix_tree_root page_tree; spinlock_t tree_lock; unsigned int i_mmap_writable; struct rb_root i_mmap; struct list_head i_mmap_nonlinear; struct mutex i_mmap_mutex; unsigned long nrpages; unsigned long writeback_index; const struct address_space_operations *a_ops; unsigned long flags; struct backing_dev_info *backing_dev_info; spinlock_t private_lock; struct list_head private_list; void *private_data; } ;
430 struct request_queue ;
431 struct hd_struct ;
431 struct gendisk ;
431 struct block_device { dev_t bd_dev; int bd_openers; struct inode *bd_inode; struct super_block *bd_super; struct mutex bd_mutex; struct list_head bd_inodes; void *bd_claiming; void *bd_holder; int bd_holders; bool bd_write_holder; struct list_head bd_holder_disks; struct block_device *bd_contains; unsigned int bd_block_size; struct hd_struct *bd_part; unsigned int bd_part_count; int bd_invalidated; struct gendisk *bd_disk; struct request_queue *bd_queue; struct list_head bd_list; unsigned long bd_private; int bd_fsfreeze_count; struct mutex bd_fsfreeze_mutex; } ;
503 struct posix_acl ;
504 struct inode_operations ;
504 union __anonunion____missing_field_name_186 { const unsigned int i_nlink; unsigned int __i_nlink; } ;
504 union __anonunion____missing_field_name_187 { struct hlist_head i_dentry; struct callback_head i_rcu; } ;
504 struct file_lock ;
504 struct cdev ;
504 union __anonunion____missing_field_name_188 { struct pipe_inode_info *i_pipe; struct block_device *i_bdev; struct cdev *i_cdev; } ;
504 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_186 __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 mutex i_mutex; unsigned long dirtied_when; struct hlist_node i_hash; struct list_head i_wb_list; struct list_head i_lru; struct list_head i_sb_list; union __anonunion____missing_field_name_187 __annonCompField60; u64 i_version; atomic_t i_count; atomic_t i_dio_count; atomic_t i_writecount; const struct file_operations *i_fop; struct file_lock *i_flock; struct address_space i_data; struct dquot *i_dquot[2U]; struct list_head i_devices; union __anonunion____missing_field_name_188 __annonCompField61; __u32 i_generation; __u32 i_fsnotify_mask; struct hlist_head i_fsnotify_marks; atomic_t i_readcount; void *i_private; } ;
740 struct fown_struct { rwlock_t lock; struct pid *pid; enum pid_type pid_type; kuid_t uid; kuid_t euid; int signum; } ;
748 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; } ;
771 union __anonunion_f_u_189 { struct llist_node fu_llist; struct callback_head fu_rcuhead; } ;
771 struct file { union __anonunion_f_u_189 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; unsigned long f_mnt_write_state; } ;
909 struct files_struct ;
909 typedef struct files_struct *fl_owner_t;
910 struct file_lock_operations { void (*fl_copy_lock)(struct file_lock *, struct file_lock *); void (*fl_release_private)(struct file_lock *); } ;
915 struct lock_manager_operations { int (*lm_compare_owner)(struct file_lock *, struct file_lock *); unsigned long int (*lm_owner_key)(struct file_lock *); void (*lm_notify)(struct file_lock *); int (*lm_grant)(struct file_lock *, struct file_lock *, int); void (*lm_break)(struct file_lock *); int (*lm_change)(struct file_lock **, int); } ;
928 struct net ;
933 struct nlm_lockowner ;
934 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_191 { struct list_head link; int state; } ;
19 union __anonunion_fl_u_190 { struct nfs_lock_info nfs_fl; struct nfs4_lock_info nfs4_fl; struct __anonstruct_afs_191 afs; } ;
19 struct file_lock { struct file_lock *fl_next; struct hlist_node fl_link; struct list_head fl_block; fl_owner_t fl_owner; unsigned int fl_flags; unsigned char fl_type; unsigned int fl_pid; int fl_link_cpu; struct pid *fl_nspid; wait_queue_head_t fl_wait; struct file *fl_file; loff_t fl_start; loff_t fl_end; struct fasync_struct *fl_fasync; unsigned long fl_break_time; unsigned long fl_downgrade_time; const struct file_lock_operations *fl_ops; const struct lock_manager_operations *fl_lmops; union __anonunion_fl_u_190 fl_u; } ;
1036 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; } ;
1228 struct sb_writers { struct percpu_counter counter[3U]; wait_queue_head_t wait; int frozen; wait_queue_head_t wait_unfrozen; struct lockdep_map lock_map[3U]; } ;
1244 struct super_operations ;
1244 struct xattr_handler ;
1244 struct mtd_info ;
1244 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_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; struct list_head s_inodes; 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; 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 list_lru s_dentry_lru; struct list_lru s_inode_lru; struct callback_head rcu; } ;
1474 struct fiemap_extent_info { unsigned int fi_flags; unsigned int fi_extents_mapped; unsigned int fi_extents_max; struct fiemap_extent *fi_extents_start; } ;
1512 struct dir_context { int (*actor)(void *, const char *, int, loff_t , u64 , unsigned int); loff_t pos; } ;
1517 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 (*aio_read)(struct kiocb *, const struct iovec *, unsigned long, loff_t ); ssize_t (*aio_write)(struct kiocb *, const struct iovec *, unsigned long, loff_t ); int (*iterate)(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 (*aio_fsync)(struct kiocb *, int); int (*fasync)(int, struct file *, int); int (*lock)(struct file *, int, struct file_lock *); ssize_t (*sendpage)(struct file *, struct page *, int, size_t , loff_t *, int); unsigned long 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 **); long int (*fallocate)(struct file *, int, loff_t , loff_t ); int (*show_fdinfo)(struct seq_file *, struct file *); } ;
1555 struct inode_operations { struct dentry * (*lookup)(struct inode *, struct dentry *, unsigned int); void * (*follow_link)(struct dentry *, struct nameidata *); int (*permission)(struct inode *, int); struct posix_acl * (*get_acl)(struct inode *, int); int (*readlink)(struct dentry *, char *, int); void (*put_link)(struct dentry *, struct nameidata *, void *); int (*create)(struct inode *, struct dentry *, umode_t , bool ); int (*link)(struct dentry *, struct inode *, struct dentry *); int (*unlink)(struct inode *, struct dentry *); int (*symlink)(struct inode *, struct dentry *, 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 *); int (*setattr)(struct dentry *, struct iattr *); int (*getattr)(struct vfsmount *, struct dentry *, struct kstat *); int (*setxattr)(struct dentry *, const char *, const void *, size_t , int); ssize_t (*getxattr)(struct dentry *, const char *, void *, size_t ); ssize_t (*listxattr)(struct dentry *, char *, size_t ); int (*removexattr)(struct dentry *, const char *); 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); } ;
1600 struct super_operations { struct inode * (*alloc_inode)(struct super_block *); void (*destroy_inode)(struct inode *); void (*dirty_inode)(struct inode *, int); int (*write_inode)(struct inode *, struct writeback_control *); int (*drop_inode)(struct inode *); void (*evict_inode)(struct inode *); void (*put_super)(struct super_block *); int (*sync_fs)(struct super_block *, int); int (*freeze_fs)(struct super_block *); int (*unfreeze_fs)(struct super_block *); int (*statfs)(struct dentry *, struct kstatfs *); int (*remount_fs)(struct super_block *, int *, char *); void (*umount_begin)(struct super_block *); int (*show_options)(struct seq_file *, struct dentry *); int (*show_devname)(struct seq_file *, struct dentry *); int (*show_path)(struct seq_file *, struct dentry *); int (*show_stats)(struct seq_file *, struct dentry *); ssize_t (*quota_read)(struct super_block *, int, char *, size_t , loff_t ); ssize_t (*quota_write)(struct super_block *, int, const char *, size_t , loff_t ); int (*bdev_try_to_free_page)(struct super_block *, struct page *, gfp_t ); long int (*nr_cached_objects)(struct super_block *, int); long int (*free_cached_objects)(struct super_block *, long, int); } ;
1814 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; } ;
4 typedef unsigned long cputime_t;
24 struct __anonstruct_sigset_t_192 { unsigned long sig[1U]; } ;
24 typedef struct __anonstruct_sigset_t_192 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;
34 union sigval { int sival_int; void *sival_ptr; } ;
10 typedef union sigval sigval_t;
11 struct __anonstruct__kill_194 { __kernel_pid_t _pid; __kernel_uid32_t _uid; } ;
11 struct __anonstruct__timer_195 { __kernel_timer_t _tid; int _overrun; char _pad[0U]; sigval_t _sigval; int _sys_private; } ;
11 struct __anonstruct__rt_196 { __kernel_pid_t _pid; __kernel_uid32_t _uid; sigval_t _sigval; } ;
11 struct __anonstruct__sigchld_197 { __kernel_pid_t _pid; __kernel_uid32_t _uid; int _status; __kernel_clock_t _utime; __kernel_clock_t _stime; } ;
11 struct __anonstruct__sigfault_198 { void *_addr; short _addr_lsb; } ;
11 struct __anonstruct__sigpoll_199 { long _band; int _fd; } ;
11 struct __anonstruct__sigsys_200 { void *_call_addr; int _syscall; unsigned int _arch; } ;
11 union __anonunion__sifields_193 { int _pad[28U]; struct __anonstruct__kill_194 _kill; struct __anonstruct__timer_195 _timer; struct __anonstruct__rt_196 _rt; struct __anonstruct__sigchld_197 _sigchld; struct __anonstruct__sigfault_198 _sigfault; struct __anonstruct__sigpoll_199 _sigpoll; struct __anonstruct__sigsys_200 _sigsys; } ;
11 struct siginfo { int si_signo; int si_errno; int si_code; union __anonunion__sifields_193 _sifields; } ;
109 typedef struct siginfo siginfo_t;
21 struct sigpending { struct list_head list; sigset_t signal; } ;
251 struct sigaction { __sighandler_t sa_handler; unsigned long sa_flags; __sigrestore_t sa_restorer; sigset_t sa_mask; } ;
265 struct k_sigaction { struct sigaction sa; } ;
46 struct seccomp_filter ;
47 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; unsigned long state; int start_pid; void *start_site; char start_comm[16U]; } ;
132 struct hrtimer_clock_base { struct hrtimer_cpu_base *cpu_base; int index; clockid_t clockid; struct timerqueue_head active; ktime_t resolution; ktime_t (*get_time)(); ktime_t softirq_time; ktime_t offset; } ;
163 struct hrtimer_cpu_base { raw_spinlock_t lock; unsigned int active_bases; unsigned int clock_was_set; ktime_t expires_next; int hres_active; int hang_detected; unsigned long nr_events; unsigned long nr_retries; unsigned long nr_hangs; ktime_t max_hang_time; struct hrtimer_clock_base clock_base[4U]; } ;
463 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; } ;
39 struct assoc_array_ptr ;
39 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 signal_struct ;
37 struct key_type ;
41 struct keyring_index_key { struct key_type *type; const char *description; size_t desc_len; } ;
123 union __anonunion____missing_field_name_203 { struct list_head graveyard_link; struct rb_node serial_node; } ;
123 struct key_user ;
123 union __anonunion____missing_field_name_204 { time_t expiry; time_t revoked_at; } ;
123 struct __anonstruct____missing_field_name_206 { struct key_type *type; char *description; } ;
123 union __anonunion____missing_field_name_205 { struct keyring_index_key index_key; struct __anonstruct____missing_field_name_206 __annonCompField64; } ;
123 union __anonunion_type_data_207 { struct list_head link; unsigned long x[2U]; void *p[2U]; int reject_error; } ;
123 union __anonunion_payload_209 { unsigned long value; void *rcudata; void *data; void *data2[2U]; } ;
123 union __anonunion____missing_field_name_208 { union __anonunion_payload_209 payload; struct assoc_array keys; } ;
123 struct key { atomic_t usage; key_serial_t serial; union __anonunion____missing_field_name_203 __annonCompField62; struct rw_semaphore sem; struct key_user *user; void *security; union __anonunion____missing_field_name_204 __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_205 __annonCompField65; union __anonunion_type_data_207 type_data; union __anonunion____missing_field_name_208 __annonCompField66; } ;
345 struct audit_context ;
27 struct group_info { atomic_t usage; int ngroups; int nblocks; kgid_t small_block[32U]; kgid_t *blocks[0U]; } ;
78 struct cred { atomic_t usage; atomic_t subscribers; void *put_addr; unsigned int magic; kuid_t uid; kgid_t gid; kuid_t suid; kgid_t sgid; kuid_t euid; kgid_t egid; kuid_t fsuid; kgid_t fsgid; unsigned int securebits; kernel_cap_t cap_inheritable; kernel_cap_t cap_permitted; kernel_cap_t cap_effective; kernel_cap_t cap_bset; unsigned char jit_keyring; struct key *session_keyring; struct key *process_keyring; struct key *thread_keyring; struct key *request_key_auth; void *security; struct user_struct *user; struct user_namespace *user_ns; struct group_info *group_info; struct callback_head rcu; } ;
123 struct futex_pi_state ;
124 struct robust_list_head ;
125 struct bio_list ;
126 struct fs_struct ;
127 struct perf_event_context ;
128 struct blk_plug ;
180 struct cfs_rq ;
181 struct task_group ;
421 struct sighand_struct { atomic_t count; struct k_sigaction action[64U]; spinlock_t siglock; wait_queue_head_t signalfd_wqh; } ;
460 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; } ;
468 struct cpu_itimer { cputime_t expires; cputime_t incr; u32 error; u32 incr_error; } ;
475 struct cputime { cputime_t utime; cputime_t stime; } ;
487 struct task_cputime { cputime_t utime; cputime_t stime; unsigned long long sum_exec_runtime; } ;
507 struct thread_group_cputimer { struct task_cputime cputime; int running; raw_spinlock_t lock; } ;
549 struct autogroup ;
550 struct tty_struct ;
550 struct taskstats ;
550 struct tty_audit_buf ;
550 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; cputime_t utime; cputime_t stime; cputime_t cutime; cputime_t cstime; cputime_t gtime; cputime_t cgtime; struct cputime prev_cputime; unsigned long nvcsw; unsigned long nivcsw; unsigned long cnvcsw; unsigned long cnivcsw; unsigned long min_flt; unsigned long maj_flt; unsigned long cmin_flt; unsigned long cmaj_flt; unsigned long inblock; unsigned long oublock; unsigned long cinblock; unsigned long coublock; unsigned long maxrss; unsigned long cmaxrss; struct task_io_accounting ioac; unsigned long long sum_sched_runtime; struct rlimit rlim[16U]; struct pacct_struct pacct; struct taskstats *stats; unsigned int audit_tty; unsigned int audit_tty_log_passwd; struct tty_audit_buf *tty_audit_buf; struct rw_semaphore group_rwsem; oom_flags_t oom_flags; short oom_score_adj; short oom_score_adj_min; struct mutex cred_guard_mutex; } ;
730 struct user_struct { atomic_t __count; atomic_t processes; atomic_t files; atomic_t sigpending; atomic_t inotify_watches; atomic_t inotify_devs; atomic_t fanotify_listeners; atomic_long_t epoll_watches; unsigned long mq_bytes; unsigned long locked_shm; struct key *uid_keyring; struct key *session_keyring; struct hlist_node uidhash_node; kuid_t uid; atomic_long_t locked_vm; } ;
774 struct reclaim_state ;
775 struct sched_info { unsigned long pcount; unsigned long long run_delay; unsigned long long last_arrival; unsigned long long last_queued; } ;
790 struct task_delay_info { spinlock_t lock; unsigned int flags; struct timespec blkio_start; struct timespec blkio_end; u64 blkio_delay; u64 swapin_delay; u32 blkio_count; u32 swapin_count; struct timespec freepages_start; struct timespec freepages_end; u64 freepages_delay; u32 freepages_count; } ;
1004 struct uts_namespace ;
1005 struct load_weight { unsigned long weight; u32 inv_weight; } ;
1013 struct sched_avg { u32 runnable_avg_sum; u32 runnable_avg_period; u64 last_runnable_update; s64 decay_count; unsigned long load_avg_contrib; } ;
1025 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; } ;
1060 struct sched_entity { struct load_weight load; struct rb_node run_node; struct list_head group_node; unsigned int on_rq; u64 exec_start; u64 sum_exec_runtime; u64 vruntime; u64 prev_sum_exec_runtime; u64 nr_migrations; struct sched_statistics statistics; struct sched_entity *parent; struct cfs_rq *cfs_rq; struct cfs_rq *my_q; struct sched_avg avg; } ;
1091 struct rt_rq ;
1091 struct sched_rt_entity { struct list_head run_list; unsigned long timeout; unsigned long watchdog_stamp; unsigned int time_slice; struct sched_rt_entity *back; struct sched_rt_entity *parent; struct rt_rq *rt_rq; struct rt_rq *my_q; } ;
1107 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_new; int dl_boosted; struct hrtimer dl_timer; } ;
1162 struct memcg_batch_info { int do_batch; struct mem_cgroup *memcg; unsigned long nr_pages; unsigned long memsw_nr_pages; } ;
1569 struct memcg_oom_info { struct mem_cgroup *memcg; gfp_t gfp_mask; int order; unsigned char may_oom; } ;
1576 struct sched_class ;
1576 struct css_set ;
1576 struct compat_robust_list_head ;
1576 struct numa_group ;
1576 struct task_struct { volatile long state; void *stack; atomic_t usage; unsigned int flags; unsigned int ptrace; struct llist_node wake_entry; int on_cpu; struct task_struct *last_wakee; unsigned long wakee_flips; unsigned long wakee_flip_decay_ts; int 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; 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; unsigned char brk_randomized; struct task_rss_stat rss_stat; int exit_state; int exit_code; int exit_signal; int pdeath_signal; unsigned int jobctl; unsigned int personality; unsigned char in_execve; unsigned char in_iowait; unsigned char no_new_privs; unsigned char sched_reset_on_fork; unsigned char sched_contributes_to_load; 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 utimescaled; cputime_t stimescaled; cputime_t gtime; struct cputime prev_cputime; unsigned long nvcsw; unsigned long nivcsw; struct timespec start_time; struct timespec real_start_time; unsigned long min_flt; unsigned long maj_flt; struct task_cputime cputime_expires; struct list_head cpu_timers[3U]; const struct cred *real_cred; const struct cred *cred; char comm[16U]; int link_count; int total_link_count; struct sysv_sem sysvsem; unsigned long last_switch_count; struct thread_struct thread; struct fs_struct *fs; struct files_struct *files; struct nsproxy *nsproxy; struct signal_struct *signal; struct sighand_struct *sighand; sigset_t blocked; sigset_t real_blocked; sigset_t saved_sigmask; struct sigpending pending; unsigned long sas_ss_sp; size_t sas_ss_size; int (*notifier)(void *); void *notifier_data; sigset_t *notifier_mask; struct callback_head *task_works; struct audit_context *audit_context; kuid_t loginuid; unsigned int sessionid; struct seccomp seccomp; u32 parent_exec_id; u32 self_exec_id; spinlock_t alloc_lock; raw_spinlock_t pi_lock; struct rb_root pi_waiters; struct rb_node *pi_waiters_leftmost; struct rt_mutex_waiter *pi_blocked_on; struct task_struct *pi_top_task; struct mutex_waiter *blocked_on; unsigned int irq_events; unsigned long hardirq_enable_ip; unsigned long hardirq_disable_ip; unsigned int hardirq_enable_event; unsigned int hardirq_disable_event; int hardirqs_enabled; int hardirq_context; unsigned long softirq_disable_ip; unsigned long softirq_enable_ip; unsigned int softirq_disable_event; unsigned int softirq_enable_event; int softirqs_enabled; int softirq_context; u64 curr_chain_key; int lockdep_depth; unsigned int lockdep_recursion; struct held_lock held_locks[48U]; gfp_t lockdep_reclaim_gfp; void *journal_info; struct bio_list *bio_list; struct blk_plug *plug; struct reclaim_state *reclaim_state; struct backing_dev_info *backing_dev_info; struct io_context *io_context; unsigned long ptrace_message; siginfo_t *last_siginfo; struct task_io_accounting ioac; u64 acct_rss_mem1; u64 acct_vm_mem1; cputime_t acct_timexpd; nodemask_t mems_allowed; seqcount_t mems_allowed_seq; int cpuset_mem_spread_rotor; int cpuset_slab_spread_rotor; struct css_set *cgroups; struct list_head cg_list; struct robust_list_head *robust_list; struct compat_robust_list_head *compat_robust_list; struct list_head pi_state_list; struct futex_pi_state *pi_state_cache; struct perf_event_context *perf_event_ctxp[2U]; struct mutex perf_event_mutex; struct list_head perf_event_list; struct mempolicy *mempolicy; short il_next; short pref_node_fork; int numa_scan_seq; unsigned int numa_scan_period; unsigned int numa_scan_period_max; int numa_preferred_nid; int numa_migrate_deferred; unsigned long numa_migrate_retry; u64 node_stamp; 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_buffer; unsigned long numa_faults_locality[2U]; unsigned long numa_pages_migrated; struct callback_head rcu; struct pipe_inode_info *splice_pipe; struct page_frag task_frag; struct task_delay_info *delays; int make_it_fail; int nr_dirtied; int nr_dirtied_pause; unsigned long dirty_paused_when; int latency_record_count; struct latency_record latency_record[32U]; unsigned long timer_slack_ns; unsigned long default_timer_slack_ns; unsigned long trace; unsigned long trace_recursion; struct memcg_batch_info memcg_batch; unsigned int memcg_kmem_skip_account; struct memcg_oom_info memcg_oom; struct uprobe_task *utask; unsigned int sequential_io; unsigned int sequential_io_avg; } ;
39 typedef s32 compat_long_t;
44 typedef u32 compat_uptr_t;
273 struct compat_robust_list { compat_uptr_t next; } ;
277 struct compat_robust_list_head { struct compat_robust_list list; compat_long_t futex_offset; compat_uptr_t list_op_pending; } ;
62 struct exception_table_entry { int insn; int fixup; } ;
119 struct sk_buff ;
15 typedef u64 netdev_features_t;
18 struct nf_conntrack { atomic_t use; } ;
136 struct nf_bridge_info { atomic_t use; unsigned int mask; struct net_device *physindev; struct net_device *physoutdev; unsigned long data[4U]; } ;
146 struct sk_buff_head { struct sk_buff *next; struct sk_buff *prev; __u32 qlen; spinlock_t lock; } ;
172 struct skb_frag_struct ;
172 typedef struct skb_frag_struct skb_frag_t;
173 struct __anonstruct_page_226 { struct page *p; } ;
173 struct skb_frag_struct { struct __anonstruct_page_226 page; __u32 page_offset; __u32 size; } ;
206 struct skb_shared_hwtstamps { ktime_t hwtstamp; ktime_t syststamp; } ;
275 struct skb_shared_info { unsigned char nr_frags; __u8 tx_flags; unsigned short gso_size; unsigned short gso_segs; unsigned short gso_type; struct sk_buff *frag_list; struct skb_shared_hwtstamps hwtstamps; __be32 ip6_frag_id; atomic_t dataref; void *destructor_arg; skb_frag_t frags[17U]; } ;
354 typedef unsigned int sk_buff_data_t;
355 struct sec_path ;
355 struct __anonstruct____missing_field_name_228 { __u16 csum_start; __u16 csum_offset; } ;
355 union __anonunion____missing_field_name_227 { __wsum csum; struct __anonstruct____missing_field_name_228 __annonCompField69; } ;
355 union __anonunion____missing_field_name_229 { unsigned int napi_id; dma_cookie_t dma_cookie; } ;
355 union __anonunion____missing_field_name_230 { __u32 mark; __u32 dropcount; __u32 reserved_tailroom; } ;
355 struct sk_buff { struct sk_buff *next; struct sk_buff *prev; ktime_t tstamp; struct sock *sk; struct net_device *dev; char cb[48U]; unsigned long _skb_refdst; struct sec_path *sp; unsigned int len; unsigned int data_len; __u16 mac_len; __u16 hdr_len; union __anonunion____missing_field_name_227 __annonCompField70; __u32 priority; unsigned char local_df; unsigned char cloned; unsigned char ip_summed; unsigned char nohdr; unsigned char nfctinfo; unsigned char pkt_type; unsigned char fclone; unsigned char ipvs_property; unsigned char peeked; unsigned char nf_trace; __be16 protocol; void (*destructor)(struct sk_buff *); struct nf_conntrack *nfct; struct nf_bridge_info *nf_bridge; int skb_iif; __u32 rxhash; __be16 vlan_proto; __u16 vlan_tci; __u16 tc_index; __u16 tc_verd; __u16 queue_mapping; unsigned char ndisc_nodetype; unsigned char pfmemalloc; unsigned char ooo_okay; unsigned char l4_rxhash; unsigned char wifi_acked_valid; unsigned char wifi_acked; unsigned char no_fcs; unsigned char head_frag; unsigned char encapsulation; union __anonunion____missing_field_name_229 __annonCompField71; __u32 secmark; union __anonunion____missing_field_name_230 __annonCompField72; __be16 inner_protocol; __u16 inner_transport_header; __u16 inner_network_header; __u16 inner_mac_header; __u16 transport_header; __u16 network_header; __u16 mac_header; sk_buff_data_t tail; sk_buff_data_t end; unsigned char *head; unsigned char *data; unsigned int truesize; atomic_t users; } ;
578 struct dst_entry ;
2939 struct ethhdr { unsigned char h_dest[6U]; unsigned char h_source[6U]; __be16 h_proto; } ;
34 struct ethtool_cmd { __u32 cmd; __u32 supported; __u32 advertising; __u16 speed; __u8 duplex; __u8 port; __u8 phy_address; __u8 transceiver; __u8 autoneg; __u8 mdio_support; __u32 maxtxpkt; __u32 maxrxpkt; __u16 speed_hi; __u8 eth_tp_mdix; __u8 eth_tp_mdix_ctrl; __u32 lp_advertising; __u32 reserved[2U]; } ;
65 struct ethtool_drvinfo { __u32 cmd; char driver[32U]; char version[32U]; char fw_version[32U]; char bus_info[32U]; char reserved1[32U]; char reserved2[12U]; __u32 n_priv_flags; __u32 n_stats; __u32 testinfo_len; __u32 eedump_len; __u32 regdump_len; } ;
105 struct ethtool_wolinfo { __u32 cmd; __u32 supported; __u32 wolopts; __u8 sopass[6U]; } ;
120 struct ethtool_regs { __u32 cmd; __u32 version; __u32 len; __u8 data[0U]; } ;
128 struct ethtool_eeprom { __u32 cmd; __u32 magic; __u32 offset; __u32 len; __u8 data[0U]; } ;
137 struct ethtool_eee { __u32 cmd; __u32 supported; __u32 advertised; __u32 lp_advertised; __u32 eee_active; __u32 eee_enabled; __u32 tx_lpi_enabled; __u32 tx_lpi_timer; __u32 reserved[2U]; } ;
166 struct ethtool_modinfo { __u32 cmd; __u32 type; __u32 eeprom_len; __u32 reserved[8U]; } ;
183 struct ethtool_coalesce { __u32 cmd; __u32 rx_coalesce_usecs; __u32 rx_max_coalesced_frames; __u32 rx_coalesce_usecs_irq; __u32 rx_max_coalesced_frames_irq; __u32 tx_coalesce_usecs; __u32 tx_max_coalesced_frames; __u32 tx_coalesce_usecs_irq; __u32 tx_max_coalesced_frames_irq; __u32 stats_block_coalesce_usecs; __u32 use_adaptive_rx_coalesce; __u32 use_adaptive_tx_coalesce; __u32 pkt_rate_low; __u32 rx_coalesce_usecs_low; __u32 rx_max_coalesced_frames_low; __u32 tx_coalesce_usecs_low; __u32 tx_max_coalesced_frames_low; __u32 pkt_rate_high; __u32 rx_coalesce_usecs_high; __u32 rx_max_coalesced_frames_high; __u32 tx_coalesce_usecs_high; __u32 tx_max_coalesced_frames_high; __u32 rate_sample_interval; } ;
281 struct ethtool_ringparam { __u32 cmd; __u32 rx_max_pending; __u32 rx_mini_max_pending; __u32 rx_jumbo_max_pending; __u32 tx_max_pending; __u32 rx_pending; __u32 rx_mini_pending; __u32 rx_jumbo_pending; __u32 tx_pending; } ;
303 struct ethtool_channels { __u32 cmd; __u32 max_rx; __u32 max_tx; __u32 max_other; __u32 max_combined; __u32 rx_count; __u32 tx_count; __u32 other_count; __u32 combined_count; } ;
331 struct ethtool_pauseparam { __u32 cmd; __u32 autoneg; __u32 rx_pause; __u32 tx_pause; } ;
382 struct ethtool_test { __u32 cmd; __u32 flags; __u32 reserved; __u32 len; __u64 data[0U]; } ;
404 struct ethtool_stats { __u32 cmd; __u32 n_stats; __u64 data[0U]; } ;
425 struct ethtool_tcpip4_spec { __be32 ip4src; __be32 ip4dst; __be16 psrc; __be16 pdst; __u8 tos; } ;
458 struct ethtool_ah_espip4_spec { __be32 ip4src; __be32 ip4dst; __be32 spi; __u8 tos; } ;
474 struct ethtool_usrip4_spec { __be32 ip4src; __be32 ip4dst; __be32 l4_4_bytes; __u8 tos; __u8 ip_ver; __u8 proto; } ;
494 union ethtool_flow_union { struct ethtool_tcpip4_spec tcp_ip4_spec; struct ethtool_tcpip4_spec udp_ip4_spec; struct ethtool_tcpip4_spec sctp_ip4_spec; struct ethtool_ah_espip4_spec ah_ip4_spec; struct ethtool_ah_espip4_spec esp_ip4_spec; struct ethtool_usrip4_spec usr_ip4_spec; struct ethhdr ether_spec; __u8 hdata[52U]; } ;
505 struct ethtool_flow_ext { __u8 padding[2U]; unsigned char h_dest[6U]; __be16 vlan_etype; __be16 vlan_tci; __be32 data[2U]; } ;
524 struct ethtool_rx_flow_spec { __u32 flow_type; union ethtool_flow_union h_u; struct ethtool_flow_ext h_ext; union ethtool_flow_union m_u; struct ethtool_flow_ext m_ext; __u64 ring_cookie; __u32 location; } ;
550 struct ethtool_rxnfc { __u32 cmd; __u32 flow_type; __u64 data; struct ethtool_rx_flow_spec fs; __u32 rule_cnt; __u32 rule_locs[0U]; } ;
684 struct ethtool_flash { __u32 cmd; __u32 region; char data[128U]; } ;
692 struct ethtool_dump { __u32 cmd; __u32 version; __u32 flag; __u32 len; __u8 data[0U]; } ;
768 struct ethtool_ts_info { __u32 cmd; __u32 so_timestamping; __s32 phc_index; __u32 tx_types; __u32 tx_reserved[3U]; __u32 rx_filters; __u32 rx_reserved[3U]; } ;
44 enum ethtool_phys_id_state { ETHTOOL_ID_INACTIVE = 0, ETHTOOL_ID_ACTIVE = 1, ETHTOOL_ID_ON = 2, ETHTOOL_ID_OFF = 3 } ;
79 struct ethtool_ops { int (*get_settings)(struct net_device *, struct ethtool_cmd *); int (*set_settings)(struct net_device *, struct ethtool_cmd *); void (*get_drvinfo)(struct net_device *, struct ethtool_drvinfo *); int (*get_regs_len)(struct net_device *); void (*get_regs)(struct net_device *, struct ethtool_regs *, void *); void (*get_wol)(struct net_device *, struct ethtool_wolinfo *); int (*set_wol)(struct net_device *, struct ethtool_wolinfo *); u32 (*get_msglevel)(struct net_device *); void (*set_msglevel)(struct net_device *, u32 ); int (*nway_reset)(struct net_device *); u32 (*get_link)(struct net_device *); int (*get_eeprom_len)(struct net_device *); int (*get_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *); int (*set_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *); int (*get_coalesce)(struct net_device *, struct ethtool_coalesce *); int (*set_coalesce)(struct net_device *, struct ethtool_coalesce *); void (*get_ringparam)(struct net_device *, struct ethtool_ringparam *); int (*set_ringparam)(struct net_device *, struct ethtool_ringparam *); void (*get_pauseparam)(struct net_device *, struct ethtool_pauseparam *); int (*set_pauseparam)(struct net_device *, struct ethtool_pauseparam *); void (*self_test)(struct net_device *, struct ethtool_test *, u64 *); void (*get_strings)(struct net_device *, u32 , u8 *); int (*set_phys_id)(struct net_device *, enum ethtool_phys_id_state ); void (*get_ethtool_stats)(struct net_device *, struct ethtool_stats *, u64 *); int (*begin)(struct net_device *); void (*complete)(struct net_device *); u32 (*get_priv_flags)(struct net_device *); int (*set_priv_flags)(struct net_device *, u32 ); int (*get_sset_count)(struct net_device *, int); int (*get_rxnfc)(struct net_device *, struct ethtool_rxnfc *, u32 *); int (*set_rxnfc)(struct net_device *, struct ethtool_rxnfc *); int (*flash_device)(struct net_device *, struct ethtool_flash *); int (*reset)(struct net_device *, u32 *); u32 (*get_rxfh_indir_size)(struct net_device *); int (*get_rxfh_indir)(struct net_device *, u32 *); int (*set_rxfh_indir)(struct net_device *, const u32 *); void (*get_channels)(struct net_device *, struct ethtool_channels *); int (*set_channels)(struct net_device *, struct ethtool_channels *); int (*get_dump_flag)(struct net_device *, struct ethtool_dump *); int (*get_dump_data)(struct net_device *, struct ethtool_dump *, void *); int (*set_dump)(struct net_device *, struct ethtool_dump *); int (*get_ts_info)(struct net_device *, struct ethtool_ts_info *); int (*get_module_info)(struct net_device *, struct ethtool_modinfo *); int (*get_module_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *); int (*get_eee)(struct net_device *, struct ethtool_eee *); int (*set_eee)(struct net_device *, struct ethtool_eee *); } ;
249 struct prot_inuse ;
250 struct netns_core { struct ctl_table_header *sysctl_hdr; int sysctl_somaxconn; struct prot_inuse *inuse; } ;
38 struct u64_stats_sync { } ;
145 struct ipstats_mib { u64 mibs[36U]; struct u64_stats_sync syncp; } ;
61 struct icmp_mib { unsigned long mibs[28U]; } ;
67 struct icmpmsg_mib { atomic_long_t mibs[512U]; } ;
72 struct icmpv6_mib { unsigned long mibs[6U]; } ;
83 struct icmpv6msg_mib { atomic_long_t mibs[512U]; } ;
93 struct tcp_mib { unsigned long mibs[16U]; } ;
100 struct udp_mib { unsigned long mibs[8U]; } ;
106 struct linux_mib { unsigned long mibs[97U]; } ;
112 struct linux_xfrm_mib { unsigned long mibs[29U]; } ;
118 struct netns_mib { struct tcp_mib *tcp_statistics[1U]; struct ipstats_mib *ip_statistics[1U]; struct linux_mib *net_statistics[1U]; struct udp_mib *udp_statistics[1U]; struct udp_mib *udplite_statistics[1U]; struct icmp_mib *icmp_statistics[1U]; struct icmpmsg_mib *icmpmsg_statistics; struct proc_dir_entry *proc_net_devsnmp6; struct udp_mib *udp_stats_in6[1U]; struct udp_mib *udplite_stats_in6[1U]; struct ipstats_mib *ipv6_statistics[1U]; struct icmpv6_mib *icmpv6_statistics[1U]; struct icmpv6msg_mib *icmpv6msg_statistics; struct linux_xfrm_mib *xfrm_statistics[1U]; } ;
26 struct netns_unix { int sysctl_max_dgram_qlen; struct ctl_table_header *ctl; } ;
12 struct netns_packet { struct mutex sklist_lock; struct hlist_head sklist; } ;
14 struct netns_frags { int nqueues; struct list_head lru_list; spinlock_t lru_lock; struct percpu_counter mem; int timeout; int high_thresh; int low_thresh; } ;
180 struct tcpm_hash_bucket ;
181 struct ipv4_devconf ;
182 struct fib_rules_ops ;
183 struct fib_table ;
184 struct local_ports { seqlock_t lock; int range[2U]; } ;
22 struct inet_peer_base ;
22 struct xt_table ;
22 struct netns_ipv4 { struct ctl_table_header *forw_hdr; struct ctl_table_header *frags_hdr; struct ctl_table_header *ipv4_hdr; struct ctl_table_header *route_hdr; struct ctl_table_header *xfrm4_hdr; struct ipv4_devconf *devconf_all; struct ipv4_devconf *devconf_dflt; struct fib_rules_ops *rules_ops; bool fib_has_custom_rules; struct fib_table *fib_local; struct fib_table *fib_main; struct fib_table *fib_default; int fib_num_tclassid_users; struct hlist_head *fib_table_hash; struct sock *fibnl; struct sock **icmp_sk; struct inet_peer_base *peers; struct tcpm_hash_bucket *tcp_metrics_hash; unsigned int tcp_metrics_hash_log; struct netns_frags frags; struct xt_table *iptable_filter; struct xt_table *iptable_mangle; struct xt_table *iptable_raw; struct xt_table *arptable_filter; struct xt_table *iptable_security; struct xt_table *nat_table; int sysctl_icmp_echo_ignore_all; int sysctl_icmp_echo_ignore_broadcasts; int sysctl_icmp_ignore_bogus_error_responses; int sysctl_icmp_ratelimit; int sysctl_icmp_ratemask; int sysctl_icmp_errors_use_inbound_ifaddr; struct local_ports sysctl_local_ports; int sysctl_tcp_ecn; int sysctl_ip_no_pmtu_disc; int sysctl_ip_fwd_use_pmtu; kgid_t sysctl_ping_group_range[2U]; atomic_t dev_addr_genid; struct list_head mr_tables; struct fib_rules_ops *mr_rules_ops; atomic_t rt_genid; } ;
90 struct neighbour ;
90 struct dst_ops { unsigned short family; __be16 protocol; unsigned int gc_thresh; int (*gc)(struct dst_ops *); struct dst_entry * (*check)(struct dst_entry *, __u32 ); unsigned int (*default_advmss)(const struct dst_entry *); unsigned int (*mtu)(const struct dst_entry *); u32 * (*cow_metrics)(struct dst_entry *, unsigned long); void (*destroy)(struct dst_entry *); void (*ifdown)(struct dst_entry *, struct net_device *, int); struct dst_entry * (*negative_advice)(struct dst_entry *); void (*link_failure)(struct sk_buff *); void (*update_pmtu)(struct dst_entry *, struct sock *, struct sk_buff *, u32 ); void (*redirect)(struct dst_entry *, struct sock *, struct sk_buff *); int (*local_out)(struct sk_buff *); struct neighbour * (*neigh_lookup)(const struct dst_entry *, struct sk_buff *, const void *); struct kmem_cache *kmem_cachep; struct percpu_counter pcpuc_entries; } ;
73 struct netns_sysctl_ipv6 { struct ctl_table_header *hdr; struct ctl_table_header *route_hdr; struct ctl_table_header *icmp_hdr; struct ctl_table_header *frags_hdr; struct ctl_table_header *xfrm6_hdr; int bindv6only; int flush_delay; int ip6_rt_max_size; int ip6_rt_gc_min_interval; int ip6_rt_gc_timeout; int ip6_rt_gc_interval; int ip6_rt_gc_elasticity; int ip6_rt_mtu_expires; int ip6_rt_min_advmss; int flowlabel_consistency; int icmpv6_time; int anycast_src_echo_reply; } ;
34 struct ipv6_devconf ;
34 struct rt6_info ;
34 struct rt6_statistics ;
34 struct fib6_table ;
34 struct netns_ipv6 { struct netns_sysctl_ipv6 sysctl; struct ipv6_devconf *devconf_all; struct ipv6_devconf *devconf_dflt; struct inet_peer_base *peers; struct netns_frags frags; struct xt_table *ip6table_filter; struct xt_table *ip6table_mangle; struct xt_table *ip6table_raw; struct xt_table *ip6table_security; struct xt_table *ip6table_nat; struct rt6_info *ip6_null_entry; struct rt6_statistics *rt6_stats; struct timer_list ip6_fib_timer; struct hlist_head *fib_table_hash; struct fib6_table *fib6_main_tbl; struct dst_ops ip6_dst_ops; unsigned int ip6_rt_gc_expire; unsigned long ip6_rt_last_gc; struct rt6_info *ip6_prohibit_entry; struct rt6_info *ip6_blk_hole_entry; struct fib6_table *fib6_local_tbl; struct fib_rules_ops *fib6_rules_ops; struct sock **icmp_sk; struct sock *ndisc_sk; struct sock *tcp_sk; struct sock *igmp_sk; struct list_head mr6_tables; struct fib_rules_ops *mr6_rules_ops; atomic_t dev_addr_genid; atomic_t rt_genid; } ;
79 struct netns_nf_frag { struct netns_sysctl_ipv6 sysctl; struct netns_frags frags; } ;
85 struct sctp_mib ;
86 struct netns_sctp { struct sctp_mib *sctp_statistics[1U]; struct proc_dir_entry *proc_net_sctp; struct ctl_table_header *sysctl_header; struct sock *ctl_sock; struct list_head local_addr_list; struct list_head addr_waitq; struct timer_list addr_wq_timer; struct list_head auto_asconf_splist; spinlock_t addr_wq_lock; spinlock_t local_addr_lock; unsigned int rto_initial; unsigned int rto_min; unsigned int rto_max; int rto_alpha; int rto_beta; int max_burst; int cookie_preserve_enable; char *sctp_hmac_alg; unsigned int valid_cookie_life; unsigned int sack_timeout; unsigned int hb_interval; int max_retrans_association; int max_retrans_path; int max_retrans_init; int pf_retrans; int sndbuf_policy; int rcvbuf_policy; int default_auto_asconf; int addip_enable; int addip_noauth; int prsctp_enable; int auth_enable; int scope_policy; int rwnd_upd_shift; unsigned long max_autoclose; } ;
133 struct netns_dccp { struct sock *v4_ctl_sk; struct sock *v6_ctl_sk; } ;
324 struct nlattr ;
337 struct nf_logger ;
338 struct netns_nf { struct proc_dir_entry *proc_netfilter; const struct nf_logger *nf_loggers[13U]; struct ctl_table_header *nf_log_dir_header; } ;
17 struct ebt_table ;
18 struct netns_xt { struct list_head tables[13U]; bool notrack_deprecated_warning; struct ebt_table *broute_table; struct ebt_table *frame_filter; struct ebt_table *frame_nat; bool ulog_warn_deprecated; bool ebt_ulog_warn_deprecated; } ;
24 struct hlist_nulls_node ;
24 struct hlist_nulls_head { struct hlist_nulls_node *first; } ;
20 struct hlist_nulls_node { struct hlist_nulls_node *next; struct hlist_nulls_node **pprev; } ;
32 struct nf_proto_net { struct ctl_table_header *ctl_table_header; struct ctl_table *ctl_table; struct ctl_table_header *ctl_compat_header; struct ctl_table *ctl_compat_table; unsigned int users; } ;
23 struct nf_generic_net { struct nf_proto_net pn; unsigned int timeout; } ;
28 struct nf_tcp_net { struct nf_proto_net pn; unsigned int timeouts[14U]; unsigned int tcp_loose; unsigned int tcp_be_liberal; unsigned int tcp_max_retrans; } ;
42 struct nf_udp_net { struct nf_proto_net pn; unsigned int timeouts[2U]; } ;
47 struct nf_icmp_net { struct nf_proto_net pn; unsigned int timeout; } ;
52 struct nf_ip_net { struct nf_generic_net generic; struct nf_tcp_net tcp; struct nf_udp_net udp; struct nf_icmp_net icmp; struct nf_icmp_net icmpv6; struct ctl_table_header *ctl_table_header; struct ctl_table *ctl_table; } ;
63 struct ip_conntrack_stat ;
63 struct nf_ct_event_notifier ;
63 struct nf_exp_event_notifier ;
63 struct netns_ct { atomic_t count; unsigned int expect_count; struct ctl_table_header *sysctl_header; struct ctl_table_header *acct_sysctl_header; struct ctl_table_header *tstamp_sysctl_header; struct ctl_table_header *event_sysctl_header; struct ctl_table_header *helper_sysctl_header; char *slabname; unsigned int sysctl_log_invalid; unsigned int sysctl_events_retry_timeout; int sysctl_events; int sysctl_acct; int sysctl_auto_assign_helper; bool auto_assign_helper_warned; int sysctl_tstamp; int sysctl_checksum; unsigned int htable_size; struct kmem_cache *nf_conntrack_cachep; struct hlist_nulls_head *hash; struct hlist_head *expect_hash; struct hlist_nulls_head unconfirmed; struct hlist_nulls_head dying; struct hlist_nulls_head tmpl; struct ip_conntrack_stat *stat; struct nf_ct_event_notifier *nf_conntrack_event_cb; struct nf_exp_event_notifier *nf_expect_event_cb; struct nf_ip_net nf_ct_proto; unsigned int labels_used; u8 label_words; struct hlist_head *nat_bysource; unsigned int nat_htable_size; } ;
104 struct nft_af_info ;
105 struct netns_nftables { struct list_head af_info; struct list_head commit_list; struct nft_af_info *ipv4; struct nft_af_info *ipv6; struct nft_af_info *inet; struct nft_af_info *arp; struct nft_af_info *bridge; u8 gencursor; u8 genctr; } ;
489 struct xfrm_policy_hash { struct hlist_head *table; unsigned int hmask; } ;
16 struct netns_xfrm { struct list_head state_all; struct hlist_head *state_bydst; struct hlist_head *state_bysrc; struct hlist_head *state_byspi; unsigned int state_hmask; unsigned int state_num; struct work_struct state_hash_work; struct hlist_head state_gc_list; struct work_struct state_gc_work; struct list_head policy_all; struct hlist_head *policy_byidx; unsigned int policy_idx_hmask; struct hlist_head policy_inexact[6U]; struct xfrm_policy_hash policy_bydst[6U]; unsigned int policy_count[6U]; struct work_struct policy_hash_work; struct sock *nlsk; struct sock *nlsk_stash; u32 sysctl_aevent_etime; u32 sysctl_aevent_rseqth; int sysctl_larval_drop; u32 sysctl_acq_expires; struct ctl_table_header *sysctl_hdr; struct dst_ops xfrm4_dst_ops; struct dst_ops xfrm6_dst_ops; spinlock_t xfrm_state_lock; spinlock_t xfrm_policy_sk_bundle_lock; rwlock_t xfrm_policy_lock; struct mutex xfrm_cfg_mutex; } ;
65 struct net_generic ;
66 struct netns_ipvs ;
67 struct net { atomic_t passive; atomic_t count; spinlock_t rules_mod_lock; struct list_head list; struct list_head cleanup_list; struct list_head exit_list; struct user_namespace *user_ns; unsigned int proc_inum; struct proc_dir_entry *proc_net; struct proc_dir_entry *proc_net_stat; struct ctl_table_set sysctls; struct sock *rtnl; struct sock *genl_sock; struct list_head dev_base_head; struct hlist_head *dev_name_head; struct hlist_head *dev_index_head; unsigned int dev_base_seq; int ifindex; unsigned int dev_unreg_count; struct list_head rules_ops; struct net_device *loopback_dev; struct netns_core core; struct netns_mib mib; struct netns_packet packet; struct netns_unix unx; struct netns_ipv4 ipv4; struct netns_ipv6 ipv6; struct netns_sctp sctp; struct netns_dccp dccp; struct netns_nf nf; struct netns_xt xt; struct netns_ct ct; struct netns_nftables nft; struct netns_nf_frag nf_frag; struct sock *nfnl; struct sock *nfnl_stash; struct sk_buff_head wext_nlevents; struct net_generic *gen; struct netns_xfrm xfrm; struct netns_ipvs *ipvs; struct sock *diag_nlsk; atomic_t fnhe_genid; } ;
395 struct dsa_chip_data { struct device *mii_bus; int sw_addr; char *port_names[12U]; s8 *rtable; } ;
46 struct dsa_platform_data { struct device *netdev; int nr_chips; struct dsa_chip_data *chip; } ;
61 struct dsa_switch ;
61 struct dsa_switch_tree { struct dsa_platform_data *pd; struct net_device *master_netdev; __be16 tag_protocol; s8 cpu_switch; s8 cpu_port; int link_poll_needed; struct work_struct link_poll_work; struct timer_list link_poll_timer; struct dsa_switch *ds[4U]; } ;
94 struct dsa_switch_driver ;
94 struct mii_bus ;
94 struct dsa_switch { struct dsa_switch_tree *dst; int index; struct dsa_chip_data *pd; struct dsa_switch_driver *drv; struct mii_bus *master_mii_bus; u32 dsa_port_mask; u32 phys_port_mask; struct mii_bus *slave_mii_bus; struct net_device *ports[12U]; } ;
146 struct dsa_switch_driver { struct list_head list; __be16 tag_protocol; int priv_size; char * (*probe)(struct mii_bus *, int); int (*setup)(struct dsa_switch *); int (*set_addr)(struct dsa_switch *, u8 *); int (*phy_read)(struct dsa_switch *, int, int); int (*phy_write)(struct dsa_switch *, int, int, u16 ); void (*poll_link)(struct dsa_switch *); void (*get_strings)(struct dsa_switch *, int, uint8_t *); void (*get_ethtool_stats)(struct dsa_switch *, int, uint64_t *); int (*get_sset_count)(struct dsa_switch *); } ;
200 struct ieee_ets { __u8 willing; __u8 ets_cap; __u8 cbs; __u8 tc_tx_bw[8U]; __u8 tc_rx_bw[8U]; __u8 tc_tsa[8U]; __u8 prio_tc[8U]; __u8 tc_reco_bw[8U]; __u8 tc_reco_tsa[8U]; __u8 reco_prio_tc[8U]; } ;
69 struct ieee_maxrate { __u64 tc_maxrate[8U]; } ;
80 struct ieee_pfc { __u8 pfc_cap; __u8 pfc_en; __u8 mbc; __u16 delay; __u64 requests[8U]; __u64 indications[8U]; } ;
100 struct cee_pg { __u8 willing; __u8 error; __u8 pg_en; __u8 tcs_supported; __u8 pg_bw[8U]; __u8 prio_pg[8U]; } ;
123 struct cee_pfc { __u8 willing; __u8 error; __u8 pfc_en; __u8 tcs_supported; } ;
138 struct dcb_app { __u8 selector; __u8 priority; __u16 protocol; } ;
167 struct dcb_peer_app_info { __u8 willing; __u8 error; } ;
40 struct dcbnl_rtnl_ops { int (*ieee_getets)(struct net_device *, struct ieee_ets *); int (*ieee_setets)(struct net_device *, struct ieee_ets *); int (*ieee_getmaxrate)(struct net_device *, struct ieee_maxrate *); int (*ieee_setmaxrate)(struct net_device *, struct ieee_maxrate *); int (*ieee_getpfc)(struct net_device *, struct ieee_pfc *); int (*ieee_setpfc)(struct net_device *, struct ieee_pfc *); int (*ieee_getapp)(struct net_device *, struct dcb_app *); int (*ieee_setapp)(struct net_device *, struct dcb_app *); int (*ieee_delapp)(struct net_device *, struct dcb_app *); int (*ieee_peer_getets)(struct net_device *, struct ieee_ets *); int (*ieee_peer_getpfc)(struct net_device *, struct ieee_pfc *); u8 (*getstate)(struct net_device *); u8 (*setstate)(struct net_device *, u8 ); void (*getpermhwaddr)(struct net_device *, u8 *); void (*setpgtccfgtx)(struct net_device *, int, u8 , u8 , u8 , u8 ); void (*setpgbwgcfgtx)(struct net_device *, int, u8 ); void (*setpgtccfgrx)(struct net_device *, int, u8 , u8 , u8 , u8 ); void (*setpgbwgcfgrx)(struct net_device *, int, u8 ); void (*getpgtccfgtx)(struct net_device *, int, u8 *, u8 *, u8 *, u8 *); void (*getpgbwgcfgtx)(struct net_device *, int, u8 *); void (*getpgtccfgrx)(struct net_device *, int, u8 *, u8 *, u8 *, u8 *); void (*getpgbwgcfgrx)(struct net_device *, int, u8 *); void (*setpfccfg)(struct net_device *, int, u8 ); void (*getpfccfg)(struct net_device *, int, u8 *); u8 (*setall)(struct net_device *); u8 (*getcap)(struct net_device *, int, u8 *); int (*getnumtcs)(struct net_device *, int, u8 *); int (*setnumtcs)(struct net_device *, int, u8 ); u8 (*getpfcstate)(struct net_device *); void (*setpfcstate)(struct net_device *, u8 ); void (*getbcncfg)(struct net_device *, int, u32 *); void (*setbcncfg)(struct net_device *, int, u32 ); void (*getbcnrp)(struct net_device *, int, u8 *); void (*setbcnrp)(struct net_device *, int, u8 ); u8 (*setapp)(struct net_device *, u8 , u16 , u8 ); u8 (*getapp)(struct net_device *, u8 , u16 ); u8 (*getfeatcfg)(struct net_device *, int, u8 *); u8 (*setfeatcfg)(struct net_device *, int, u8 ); u8 (*getdcbx)(struct net_device *); u8 (*setdcbx)(struct net_device *, u8 ); int (*peer_getappinfo)(struct net_device *, struct dcb_peer_app_info *, u16 *); int (*peer_getapptable)(struct net_device *, struct dcb_app *); int (*cee_peer_getpg)(struct net_device *, struct cee_pg *); int (*cee_peer_getpfc)(struct net_device *, struct cee_pfc *); } ;
102 struct taskstats { __u16 version; __u32 ac_exitcode; __u8 ac_flag; __u8 ac_nice; __u64 cpu_count; __u64 cpu_delay_total; __u64 blkio_count; __u64 blkio_delay_total; __u64 swapin_count; __u64 swapin_delay_total; __u64 cpu_run_real_total; __u64 cpu_run_virtual_total; char ac_comm[32U]; __u8 ac_sched; __u8 ac_pad[3U]; __u32 ac_uid; __u32 ac_gid; __u32 ac_pid; __u32 ac_ppid; __u32 ac_btime; __u64 ac_etime; __u64 ac_utime; __u64 ac_stime; __u64 ac_minflt; __u64 ac_majflt; __u64 coremem; __u64 virtmem; __u64 hiwater_rss; __u64 hiwater_vm; __u64 read_char; __u64 write_char; __u64 read_syscalls; __u64 write_syscalls; __u64 read_bytes; __u64 write_bytes; __u64 cancelled_write_bytes; __u64 nvcsw; __u64 nivcsw; __u64 ac_utimescaled; __u64 ac_stimescaled; __u64 cpu_scaled_run_real_total; __u64 freepages_count; __u64 freepages_delay_total; } ;
55 struct xattr_handler { const char *prefix; int flags; size_t (*list)(struct dentry *, char *, size_t , const char *, size_t , int); int (*get)(struct dentry *, const char *, void *, size_t , int); int (*set)(struct dentry *, const char *, const void *, size_t , int, int); } ;
53 struct simple_xattrs { struct list_head head; spinlock_t lock; } ;
98 struct percpu_ref ;
54 typedef void percpu_ref_func_t(struct percpu_ref *);
55 struct percpu_ref { atomic_t count; unsigned int *pcpu_count; percpu_ref_func_t *release; percpu_ref_func_t *confirm_kill; struct callback_head rcu; } ;
173 struct cgroupfs_root ;
174 struct cgroup_subsys ;
175 struct cgroup ;
62 struct cgroup_subsys_state { struct cgroup *cgroup; struct cgroup_subsys *ss; struct percpu_ref refcnt; struct cgroup_subsys_state *parent; unsigned long flags; struct callback_head callback_head; struct work_struct destroy_work; } ;
142 struct cgroup_name { struct callback_head callback_head; char name[]; } ;
160 struct cgroup { unsigned long flags; int id; int nr_css; struct list_head sibling; struct list_head children; struct list_head files; struct cgroup *parent; struct dentry *dentry; u64 serial_nr; struct cgroup_name *name; struct cgroup_subsys_state *subsys[12U]; struct cgroupfs_root *root; struct list_head cset_links; struct list_head release_list; struct list_head pidlists; struct mutex pidlist_mutex; struct cgroup_subsys_state dummy_css; struct callback_head callback_head; struct work_struct destroy_work; struct simple_xattrs xattrs; } ;
252 struct cgroupfs_root { struct super_block *sb; unsigned long subsys_mask; int hierarchy_id; struct cgroup top_cgroup; int number_of_cgroups; struct list_head root_list; unsigned long flags; struct idr cgroup_idr; char release_agent_path[4096U]; char name[64U]; } ;
342 struct css_set { atomic_t refcount; struct hlist_node hlist; struct list_head tasks; struct list_head cgrp_links; struct cgroup_subsys_state *subsys[12U]; struct callback_head callback_head; } ;
392 struct cftype { char name[64U]; int private; umode_t mode; size_t max_write_len; unsigned int flags; struct cgroup_subsys *ss; 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 ); int (*write_string)(struct cgroup_subsys_state *, struct cftype *, const char *); int (*trigger)(struct cgroup_subsys_state *, unsigned int); } ;
479 struct cftype_set { struct list_head node; struct cftype *cfts; } ;
546 struct cgroup_taskset ;
557 struct cgroup_subsys { struct cgroup_subsys_state * (*css_alloc)(struct cgroup_subsys_state *); int (*css_online)(struct cgroup_subsys_state *); void (*css_offline)(struct cgroup_subsys_state *); void (*css_free)(struct cgroup_subsys_state *); int (*can_attach)(struct cgroup_subsys_state *, struct cgroup_taskset *); void (*cancel_attach)(struct cgroup_subsys_state *, struct cgroup_taskset *); void (*attach)(struct cgroup_subsys_state *, struct cgroup_taskset *); void (*fork)(struct task_struct *); void (*exit)(struct cgroup_subsys_state *, struct cgroup_subsys_state *, struct task_struct *); void (*bind)(struct cgroup_subsys_state *); int subsys_id; int disabled; int early_init; bool broken_hierarchy; bool warned_broken_hierarchy; const char *name; struct cgroupfs_root *root; struct list_head cftsets; struct cftype *base_cftypes; struct cftype_set base_cftset; struct module *module; } ;
60 struct netprio_map { struct callback_head rcu; u32 priomap_len; u32 priomap[]; } ;
3157 struct mnt_namespace ;
3158 struct ipc_namespace ;
3159 struct nsproxy { atomic_t count; struct uts_namespace *uts_ns; struct ipc_namespace *ipc_ns; struct mnt_namespace *mnt_ns; struct pid_namespace *pid_ns_for_children; struct net *net_ns; } ;
41 struct nlmsghdr { __u32 nlmsg_len; __u16 nlmsg_type; __u16 nlmsg_flags; __u32 nlmsg_seq; __u32 nlmsg_pid; } ;
145 struct nlattr { __u16 nla_len; __u16 nla_type; } ;
102 struct netlink_callback { struct sk_buff *skb; const struct nlmsghdr *nlh; int (*dump)(struct sk_buff *, struct netlink_callback *); int (*done)(struct netlink_callback *); void *data; struct module *module; u16 family; u16 min_dump_alloc; unsigned int prev_seq; unsigned int seq; long args[6U]; } ;
171 struct ndmsg { __u8 ndm_family; __u8 ndm_pad1; __u16 ndm_pad2; __s32 ndm_ifindex; __u16 ndm_state; __u8 ndm_flags; __u8 ndm_type; } ;
39 struct rtnl_link_stats64 { __u64 rx_packets; __u64 tx_packets; __u64 rx_bytes; __u64 tx_bytes; __u64 rx_errors; __u64 tx_errors; __u64 rx_dropped; __u64 tx_dropped; __u64 multicast; __u64 collisions; __u64 rx_length_errors; __u64 rx_over_errors; __u64 rx_crc_errors; __u64 rx_frame_errors; __u64 rx_fifo_errors; __u64 rx_missed_errors; __u64 tx_aborted_errors; __u64 tx_carrier_errors; __u64 tx_fifo_errors; __u64 tx_heartbeat_errors; __u64 tx_window_errors; __u64 rx_compressed; __u64 tx_compressed; } ;
536 struct ifla_vf_info { __u32 vf; __u8 mac[32U]; __u32 vlan; __u32 qos; __u32 tx_rate; __u32 spoofchk; __u32 linkstate; } ;
27 struct netpoll_info ;
28 struct phy_device ;
29 struct wireless_dev ;
64 enum netdev_tx { __NETDEV_TX_MIN = -2147483648, NETDEV_TX_OK = 0, NETDEV_TX_BUSY = 16, NETDEV_TX_LOCKED = 32 } ;
116 typedef enum netdev_tx netdev_tx_t;
135 struct net_device_stats { unsigned long rx_packets; unsigned long tx_packets; unsigned long rx_bytes; unsigned long tx_bytes; unsigned long rx_errors; unsigned long tx_errors; unsigned long rx_dropped; unsigned long tx_dropped; unsigned long multicast; unsigned long collisions; unsigned long rx_length_errors; unsigned long rx_over_errors; unsigned long rx_crc_errors; unsigned long rx_frame_errors; unsigned long rx_fifo_errors; unsigned long rx_missed_errors; unsigned long tx_aborted_errors; unsigned long tx_carrier_errors; unsigned long tx_fifo_errors; unsigned long tx_heartbeat_errors; unsigned long tx_window_errors; unsigned long rx_compressed; unsigned long tx_compressed; } ;
196 struct neigh_parms ;
217 struct netdev_hw_addr_list { struct list_head list; int count; } ;
222 struct hh_cache { u16 hh_len; u16 __pad; seqlock_t hh_lock; unsigned long hh_data[16U]; } ;
251 struct header_ops { int (*create)(struct sk_buff *, struct net_device *, unsigned short, const void *, const void *, unsigned int); int (*parse)(const struct sk_buff *, unsigned char *); int (*rebuild)(struct sk_buff *); int (*cache)(const struct neighbour *, struct hh_cache *, __be16 ); void (*cache_update)(struct hh_cache *, const struct net_device *, const unsigned char *); } ;
302 struct napi_struct { struct list_head poll_list; unsigned long state; int weight; unsigned int gro_count; int (*poll)(struct napi_struct *, int); spinlock_t poll_lock; int poll_owner; struct net_device *dev; struct sk_buff *gro_list; struct sk_buff *skb; struct list_head dev_list; struct hlist_node napi_hash_node; unsigned int napi_id; } ;
346 enum rx_handler_result { RX_HANDLER_CONSUMED = 0, RX_HANDLER_ANOTHER = 1, RX_HANDLER_EXACT = 2, RX_HANDLER_PASS = 3 } ;
394 typedef enum rx_handler_result rx_handler_result_t;
395 typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **);
532 struct Qdisc ;
532 struct netdev_queue { struct net_device *dev; struct Qdisc *qdisc; struct Qdisc *qdisc_sleeping; struct kobject kobj; int numa_node; spinlock_t _xmit_lock; int xmit_lock_owner; unsigned long trans_start; unsigned long trans_timeout; unsigned long state; struct dql dql; } ;
594 struct rps_map { unsigned int len; struct callback_head rcu; u16 cpus[0U]; } ;
606 struct rps_dev_flow { u16 cpu; u16 filter; unsigned int last_qtail; } ;
618 struct rps_dev_flow_table { unsigned int mask; struct callback_head rcu; struct rps_dev_flow flows[0U]; } ;
669 struct netdev_rx_queue { struct rps_map *rps_map; struct rps_dev_flow_table *rps_flow_table; struct kobject kobj; struct net_device *dev; } ;
692 struct xps_map { unsigned int len; unsigned int alloc_len; struct callback_head rcu; u16 queues[0U]; } ;
705 struct xps_dev_maps { struct callback_head rcu; struct xps_map *cpu_map[0U]; } ;
716 struct netdev_tc_txq { u16 count; u16 offset; } ;
727 struct netdev_fcoe_hbainfo { char manufacturer[64U]; char serial_number[64U]; char hardware_version[64U]; char driver_version[64U]; char optionrom_version[64U]; char firmware_version[64U]; char model[256U]; char model_description[256U]; } ;
743 struct netdev_phys_port_id { unsigned char id[32U]; unsigned char id_len; } ;
756 struct net_device_ops { int (*ndo_init)(struct net_device *); void (*ndo_uninit)(struct net_device *); int (*ndo_open)(struct net_device *); int (*ndo_stop)(struct net_device *); netdev_tx_t (*ndo_start_xmit)(struct sk_buff *, struct net_device *); u16 (*ndo_select_queue)(struct net_device *, struct sk_buff *, void *, u16 (*)(struct net_device *, struct sk_buff *)); void (*ndo_change_rx_flags)(struct net_device *, int); void (*ndo_set_rx_mode)(struct net_device *); int (*ndo_set_mac_address)(struct net_device *, void *); int (*ndo_validate_addr)(struct net_device *); int (*ndo_do_ioctl)(struct net_device *, struct ifreq *, int); int (*ndo_set_config)(struct net_device *, struct ifmap *); int (*ndo_change_mtu)(struct net_device *, int); int (*ndo_neigh_setup)(struct net_device *, struct neigh_parms *); void (*ndo_tx_timeout)(struct net_device *); struct rtnl_link_stats64 * (*ndo_get_stats64)(struct net_device *, struct rtnl_link_stats64 *); struct net_device_stats * (*ndo_get_stats)(struct net_device *); int (*ndo_vlan_rx_add_vid)(struct net_device *, __be16 , u16 ); int (*ndo_vlan_rx_kill_vid)(struct net_device *, __be16 , u16 ); void (*ndo_poll_controller)(struct net_device *); int (*ndo_netpoll_setup)(struct net_device *, struct netpoll_info *, gfp_t ); void (*ndo_netpoll_cleanup)(struct net_device *); int (*ndo_busy_poll)(struct napi_struct *); int (*ndo_set_vf_mac)(struct net_device *, int, u8 *); int (*ndo_set_vf_vlan)(struct net_device *, int, u16 , u8 ); int (*ndo_set_vf_tx_rate)(struct net_device *, int, int); int (*ndo_set_vf_spoofchk)(struct net_device *, int, bool ); int (*ndo_get_vf_config)(struct net_device *, int, struct ifla_vf_info *); int (*ndo_set_vf_link_state)(struct net_device *, int, int); int (*ndo_set_vf_port)(struct net_device *, int, struct nlattr **); int (*ndo_get_vf_port)(struct net_device *, int, struct sk_buff *); int (*ndo_setup_tc)(struct net_device *, u8 ); int (*ndo_fcoe_enable)(struct net_device *); int (*ndo_fcoe_disable)(struct net_device *); int (*ndo_fcoe_ddp_setup)(struct net_device *, u16 , struct scatterlist *, unsigned int); int (*ndo_fcoe_ddp_done)(struct net_device *, u16 ); int (*ndo_fcoe_ddp_target)(struct net_device *, u16 , struct scatterlist *, unsigned int); int (*ndo_fcoe_get_hbainfo)(struct net_device *, struct netdev_fcoe_hbainfo *); int (*ndo_fcoe_get_wwn)(struct net_device *, u64 *, int); int (*ndo_rx_flow_steer)(struct net_device *, const struct sk_buff *, u16 , u32 ); int (*ndo_add_slave)(struct net_device *, struct net_device *); int (*ndo_del_slave)(struct net_device *, struct net_device *); netdev_features_t (*ndo_fix_features)(struct net_device *, netdev_features_t ); int (*ndo_set_features)(struct net_device *, netdev_features_t ); int (*ndo_neigh_construct)(struct neighbour *); void (*ndo_neigh_destroy)(struct neighbour *); int (*ndo_fdb_add)(struct ndmsg *, struct nlattr **, struct net_device *, const unsigned char *, u16 ); int (*ndo_fdb_del)(struct ndmsg *, struct nlattr **, struct net_device *, const unsigned char *); int (*ndo_fdb_dump)(struct sk_buff *, struct netlink_callback *, struct net_device *, int); int (*ndo_bridge_setlink)(struct net_device *, struct nlmsghdr *); int (*ndo_bridge_getlink)(struct sk_buff *, u32 , u32 , struct net_device *, u32 ); int (*ndo_bridge_dellink)(struct net_device *, struct nlmsghdr *); int (*ndo_change_carrier)(struct net_device *, bool ); int (*ndo_get_phys_port_id)(struct net_device *, struct netdev_phys_port_id *); void (*ndo_add_vxlan_port)(struct net_device *, sa_family_t , __be16 ); void (*ndo_del_vxlan_port)(struct net_device *, sa_family_t , __be16 ); void * (*ndo_dfwd_add_station)(struct net_device *, struct net_device *); void (*ndo_dfwd_del_station)(struct net_device *, void *); netdev_tx_t (*ndo_dfwd_start_xmit)(struct sk_buff *, struct net_device *, void *); } ;
1161 struct __anonstruct_adj_list_244 { struct list_head upper; struct list_head lower; } ;
1161 struct __anonstruct_all_adj_list_245 { struct list_head upper; struct list_head lower; } ;
1161 struct iw_handler_def ;
1161 struct iw_public_data ;
1161 struct forwarding_accel_ops ;
1161 struct vlan_info ;
1161 struct tipc_bearer ;
1161 struct in_device ;
1161 struct dn_dev ;
1161 struct inet6_dev ;
1161 struct cpu_rmap ;
1161 struct pcpu_lstats ;
1161 struct pcpu_sw_netstats ;
1161 struct pcpu_dstats ;
1161 struct pcpu_vstats ;
1161 union __anonunion____missing_field_name_246 { void *ml_priv; struct pcpu_lstats *lstats; struct pcpu_sw_netstats *tstats; struct pcpu_dstats *dstats; struct pcpu_vstats *vstats; } ;
1161 struct garp_port ;
1161 struct mrp_port ;
1161 struct rtnl_link_ops ;
1161 struct net_device { char name[16U]; struct hlist_node name_hlist; char *ifalias; unsigned long mem_end; unsigned long mem_start; unsigned long base_addr; int irq; unsigned long state; struct list_head dev_list; struct list_head napi_list; struct list_head unreg_list; struct list_head close_list; struct __anonstruct_adj_list_244 adj_list; struct __anonstruct_all_adj_list_245 all_adj_list; netdev_features_t features; netdev_features_t hw_features; netdev_features_t wanted_features; netdev_features_t vlan_features; netdev_features_t hw_enc_features; netdev_features_t mpls_features; int ifindex; int iflink; struct net_device_stats stats; atomic_long_t rx_dropped; const struct iw_handler_def *wireless_handlers; struct iw_public_data *wireless_data; const struct net_device_ops *netdev_ops; const struct ethtool_ops *ethtool_ops; const struct forwarding_accel_ops *fwd_ops; const struct header_ops *header_ops; unsigned int flags; unsigned int priv_flags; unsigned short gflags; unsigned short padded; unsigned char operstate; unsigned char link_mode; unsigned char if_port; unsigned char dma; unsigned int mtu; unsigned short type; unsigned short hard_header_len; unsigned short needed_headroom; unsigned short needed_tailroom; unsigned char perm_addr[32U]; unsigned char addr_assign_type; unsigned char addr_len; unsigned short neigh_priv_len; unsigned short dev_id; spinlock_t addr_list_lock; struct netdev_hw_addr_list uc; struct netdev_hw_addr_list mc; struct netdev_hw_addr_list dev_addrs; struct kset *queues_kset; bool uc_promisc; unsigned int promiscuity; unsigned int allmulti; struct vlan_info *vlan_info; struct dsa_switch_tree *dsa_ptr; struct tipc_bearer *tipc_ptr; void *atalk_ptr; struct in_device *ip_ptr; struct dn_dev *dn_ptr; struct inet6_dev *ip6_ptr; void *ax25_ptr; struct wireless_dev *ieee80211_ptr; unsigned long last_rx; unsigned char *dev_addr; struct netdev_rx_queue *_rx; unsigned int num_rx_queues; unsigned int real_num_rx_queues; rx_handler_func_t *rx_handler; void *rx_handler_data; struct netdev_queue *ingress_queue; unsigned char broadcast[32U]; struct netdev_queue *_tx; unsigned int num_tx_queues; unsigned int real_num_tx_queues; struct Qdisc *qdisc; unsigned long tx_queue_len; spinlock_t tx_global_lock; struct xps_dev_maps *xps_maps; struct cpu_rmap *rx_cpu_rmap; unsigned long trans_start; int watchdog_timeo; struct timer_list watchdog_timer; int *pcpu_refcnt; struct list_head todo_list; struct hlist_node index_hlist; struct list_head link_watch_list; unsigned char reg_state; bool dismantle; unsigned short rtnl_link_state; void (*destructor)(struct net_device *); struct netpoll_info *npinfo; struct net *nd_net; union __anonunion____missing_field_name_246 __annonCompField76; struct garp_port *garp_port; struct mrp_port *mrp_port; struct device dev; const struct attribute_group *sysfs_groups[4U]; const struct attribute_group *sysfs_rx_queue_group; const struct rtnl_link_ops *rtnl_link_ops; unsigned int gso_max_size; u16 gso_max_segs; const struct dcbnl_rtnl_ops *dcbnl_ops; u8 num_tc; struct netdev_tc_txq tc_to_txq[16U]; u8 prio_tc_map[16U]; unsigned int fcoe_ddp_xid; struct netprio_map *priomap; struct phy_device *phydev; struct lock_class_key *qdisc_tx_busylock; int group; struct pm_qos_request pm_qos_req; } ;
1722 struct pcpu_sw_netstats { u64 rx_packets; u64 rx_bytes; u64 tx_packets; u64 tx_bytes; struct u64_stats_sync syncp; } ;
2465 enum skb_free_reason { SKB_REASON_CONSUMED = 0, SKB_REASON_DROPPED = 1 } ;
143 struct __anonstruct_isl38xx_fragment_247 { __le32 address; __le16 size; __le16 flags; } ;
143 typedef struct __anonstruct_isl38xx_fragment_247 isl38xx_fragment;
144 struct isl38xx_cb { __le32 driver_curr_frag[6U]; __le32 device_curr_frag[6U]; isl38xx_fragment rx_data_low[8U]; isl38xx_fragment tx_data_low[32U]; isl38xx_fragment rx_data_high[8U]; isl38xx_fragment tx_data_high[32U]; isl38xx_fragment rx_data_mgmt[4U]; isl38xx_fragment tx_data_mgmt[4U]; } ;
156 typedef struct isl38xx_cb isl38xx_control_block;
169 struct iw_param { __s32 value; __u8 fixed; __u8 disabled; __u16 flags; } ;
680 struct iw_point { void *pointer; __u16 length; __u16 flags; } ;
691 struct iw_freq { __s32 m; __s16 e; __u8 i; __u8 flags; } ;
708 struct iw_quality { __u8 qual; __u8 level; __u8 noise; __u8 updated; } ;
720 struct iw_discarded { __u32 nwid; __u32 code; __u32 fragment; __u32 retries; __u32 misc; } ;
736 struct iw_missed { __u32 beacon; } ;
882 struct iw_statistics { __u16 status; struct iw_quality qual; struct iw_discarded discard; struct iw_missed miss; } ;
897 union iwreq_data { char name[16U]; struct iw_point essid; struct iw_param nwid; struct iw_freq freq; struct iw_param sens; struct iw_param bitrate; struct iw_param txpower; struct iw_param rts; struct iw_param frag; __u32 mode; struct iw_param retry; struct iw_point encoding; struct iw_param power; struct iw_quality qual; struct sockaddr ap_addr; struct sockaddr addr; struct iw_param param; struct iw_point data; } ;
1068 struct iw_priv_args { __u32 cmd; __u16 set_args; __u16 get_args; char name[16U]; } ;
30 struct iw_request_info { __u16 cmd; __u16 flags; } ;
314 typedef int (*iw_handler)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *);
315 struct iw_handler_def { const iw_handler (**standard)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *); __u16 num_standard; __u16 num_private; __u16 num_private_args; const iw_handler (**private)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *); const struct iw_priv_args *private_args; struct iw_statistics * (*get_wireless_stats)(struct net_device *); } ;
381 struct iw_spy_data { int spy_number; u_char spy_address[8U][6U]; struct iw_quality spy_stat[8U]; struct iw_quality spy_thr_low; struct iw_quality spy_thr_high; u_char spy_thr_under[8U]; } ;
405 struct libipw_device ;
406 struct iw_public_data { struct iw_spy_data *spy_data; struct libipw_device *libipw; } ;
104 struct __anonstruct_pimfor_header_t_249 { u8 version; u8 operation; u32 oid; u8 device_id; u8 flags; u32 length; } ;
104 typedef struct __anonstruct_pimfor_header_t_249 pimfor_header_t;
104 struct islpci_mgmtframe { struct net_device *ndev; pimfor_header_t *header; void *data; struct work_struct ws; char buf[0U]; } ;
137 enum ldv_30720 { PRV_STATE_OFF = 0, PRV_STATE_PREBOOT = 1, PRV_STATE_BOOT = 2, PRV_STATE_POSTBOOT = 3, PRV_STATE_PREINIT = 4, PRV_STATE_INIT = 5, PRV_STATE_READY = 6, PRV_STATE_SLEEP = 7 } ;
46 typedef enum ldv_30720 islpci_state_t;
53 enum ldv_30726 { MAC_POLICY_OPEN = 0, MAC_POLICY_ACCEPT = 1, MAC_POLICY_REJECT = 2 } ;
59 struct islpci_acl { enum ldv_30726 policy; struct list_head mac_list; int size; struct mutex lock; } ;
60 struct islpci_membuf { int size; void *mem; dma_addr_t pci_addr; } ;
184 struct __anonstruct_islpci_private_250 { spinlock_t slock; u32 priv_oid; u32 iw_mode; struct rw_semaphore mib_sem; void **mib; char nickname[33U]; struct work_struct stats_work; struct mutex stats_lock; unsigned long stats_timestamp; struct iw_statistics local_iwstatistics; struct iw_statistics iwstatistics; struct iw_spy_data spy_data; struct iw_public_data wireless_data; int monitor_type; struct islpci_acl acl; struct pci_dev *pdev; char firmware[33U]; void *device_base; void *driver_mem_address; dma_addr_t device_host_address; dma_addr_t device_psm_buffer; struct net_device *ndev; struct isl38xx_cb *control_block; u32 index_mgmt_rx; u32 index_mgmt_tx; u32 free_data_rx; u32 free_data_tx; u32 data_low_tx_full; struct islpci_membuf mgmt_tx[4U]; struct islpci_membuf mgmt_rx[4U]; struct sk_buff *data_low_tx[32U]; struct sk_buff *data_low_rx[8U]; dma_addr_t pci_map_tx_address[32U]; dma_addr_t pci_map_rx_address[8U]; wait_queue_head_t reset_done; struct mutex mgmt_lock; struct islpci_mgmtframe *mgmt_received; wait_queue_head_t mgmt_wqueue; islpci_state_t state; int state_off; int wpa; struct list_head bss_wpa_list; int num_bss_wpa; struct mutex wpa_lock; u8 wpa_ie[64U]; size_t wpa_ie_len; struct work_struct reset_task; int reset_task_pending; } ;
184 typedef struct __anonstruct_islpci_private_250 islpci_private;
212 struct rfmon_header { __le16 unk0; __le16 length; __le32 clock; u8 flags; u8 unk1; u8 rate; u8 unk2; __le16 freq; __le16 unk3; u8 rssi; u8 padding[3U]; } ;
37 struct rx_annex_header { u8 addr1[6U]; u8 addr2[6U]; struct rfmon_header rfmon; } ;
43 struct avs_80211_1_header { __be32 version; __be32 length; __be64 mactime; __be64 hosttime; __be32 phytype; __be32 channel; __be32 datarate; __be32 antenna; __be32 priority; __be32 ssi_type; __be32 ssi_signal; __be32 ssi_noise; __be32 preamble; __be32 encoding; } ;
12 struct __wait_queue ;
12 typedef struct __wait_queue wait_queue_t;
15 struct __wait_queue { unsigned int flags; void *private; int (*func)(wait_queue_t *, unsigned int, int, void *); struct list_head task_list; } ;
803 struct iw_encode_ext { __u32 ext_flags; __u8 tx_seq[8U]; __u8 rx_seq[8U]; struct sockaddr addr; __u16 alg; __u16 key_len; __u8 key[0U]; } ;
957 struct iw_range { __u32 throughput; __u32 min_nwid; __u32 max_nwid; __u16 old_num_channels; __u8 old_num_frequency; __u8 scan_capa; __u32 event_capa[6U]; __s32 sensitivity; struct iw_quality max_qual; struct iw_quality avg_qual; __u8 num_bitrates; __s32 bitrate[32U]; __s32 min_rts; __s32 max_rts; __s32 min_frag; __s32 max_frag; __s32 min_pmp; __s32 max_pmp; __s32 min_pmt; __s32 max_pmt; __u16 pmp_flags; __u16 pmt_flags; __u16 pm_capa; __u16 encoding_size[8U]; __u8 num_encoding_sizes; __u8 max_encoding_tokens; __u8 encoding_login_index; __u16 txpower_capa; __u8 num_txpower; __s32 txpower[8U]; __u8 we_version_compiled; __u8 we_version_source; __u16 retry_capa; __u16 retry_flags; __u16 r_time_flags; __s32 min_retry; __s32 max_retry; __s32 min_r_time; __s32 max_r_time; __u16 num_channels; __u8 num_frequency; struct iw_freq freq[32U]; __u32 enc_capa; } ;
1080 struct iw_event { __u16 len; __u16 cmd; union iwreq_data u; } ;
169 struct obj_ssid { u8 length; char octets[33U]; } ;
32 struct obj_key { u8 type; u8 length; char key[32U]; } ;
38 struct obj_mlme { u8 address[6U]; u16 id; u16 state; u16 code; } ;
45 struct obj_mlmeex { u8 address[6U]; u16 id; u16 state; u16 code; u16 size; u8 data[0U]; } ;
54 struct obj_buffer { u32 size; u32 addr; } ;
59 struct obj_bss { u8 address[6U]; short; char state; char reserved; short age; char quality; char rssi; struct obj_ssid ssid; short channel; char beacon_period; char dtim_period; short capinfo; short rates; short basic_rates; short; } ;
80 struct obj_bsslist { u32 nr; struct obj_bss bsslist[0U]; } ;
85 struct obj_frequencies { u16 nr; u16 mhz[0U]; } ;
90 struct obj_attachment { char type; char reserved; short id; short size; char data[0U]; } ;
212 enum oid_num_t { GEN_OID_MACADDRESS = 0, GEN_OID_LINKSTATE = 1, GEN_OID_WATCHDOG = 2, GEN_OID_MIBOP = 3, GEN_OID_OPTIONS = 4, GEN_OID_LEDCONFIG = 5, DOT11_OID_BSSTYPE = 6, DOT11_OID_BSSID = 7, DOT11_OID_SSID = 8, DOT11_OID_STATE = 9, DOT11_OID_AID = 10, DOT11_OID_COUNTRYSTRING = 11, DOT11_OID_SSIDOVERRIDE = 12, DOT11_OID_MEDIUMLIMIT = 13, DOT11_OID_BEACONPERIOD = 14, DOT11_OID_DTIMPERIOD = 15, DOT11_OID_ATIMWINDOW = 16, DOT11_OID_LISTENINTERVAL = 17, DOT11_OID_CFPPERIOD = 18, DOT11_OID_CFPDURATION = 19, DOT11_OID_AUTHENABLE = 20, DOT11_OID_PRIVACYINVOKED = 21, DOT11_OID_EXUNENCRYPTED = 22, DOT11_OID_DEFKEYID = 23, DOT11_OID_DEFKEYX = 24, DOT11_OID_STAKEY = 25, DOT11_OID_REKEYTHRESHOLD = 26, DOT11_OID_STASC = 27, DOT11_OID_PRIVTXREJECTED = 28, DOT11_OID_PRIVRXPLAIN = 29, DOT11_OID_PRIVRXFAILED = 30, DOT11_OID_PRIVRXNOKEY = 31, DOT11_OID_RTSTHRESH = 32, DOT11_OID_FRAGTHRESH = 33, DOT11_OID_SHORTRETRIES = 34, DOT11_OID_LONGRETRIES = 35, DOT11_OID_MAXTXLIFETIME = 36, DOT11_OID_MAXRXLIFETIME = 37, DOT11_OID_AUTHRESPTIMEOUT = 38, DOT11_OID_ASSOCRESPTIMEOUT = 39, DOT11_OID_ALOFT_TABLE = 40, DOT11_OID_ALOFT_CTRL_TABLE = 41, DOT11_OID_ALOFT_RETREAT = 42, DOT11_OID_ALOFT_PROGRESS = 43, DOT11_OID_ALOFT_FIXEDRATE = 44, DOT11_OID_ALOFT_RSSIGRAPH = 45, DOT11_OID_ALOFT_CONFIG = 46, DOT11_OID_VDCFX = 47, DOT11_OID_MAXFRAMEBURST = 48, DOT11_OID_PSM = 49, DOT11_OID_CAMTIMEOUT = 50, DOT11_OID_RECEIVEDTIMS = 51, DOT11_OID_ROAMPREFERENCE = 52, DOT11_OID_BRIDGELOCAL = 53, DOT11_OID_CLIENTS = 54, DOT11_OID_CLIENTSASSOCIATED = 55, DOT11_OID_CLIENTX = 56, DOT11_OID_CLIENTFIND = 57, DOT11_OID_WDSLINKADD = 58, DOT11_OID_WDSLINKREMOVE = 59, DOT11_OID_EAPAUTHSTA = 60, DOT11_OID_EAPUNAUTHSTA = 61, DOT11_OID_DOT1XENABLE = 62, DOT11_OID_MICFAILURE = 63, DOT11_OID_REKEYINDICATE = 64, DOT11_OID_MPDUTXSUCCESSFUL = 65, DOT11_OID_MPDUTXONERETRY = 66, DOT11_OID_MPDUTXMULTIPLERETRIES = 67, DOT11_OID_MPDUTXFAILED = 68, DOT11_OID_MPDURXSUCCESSFUL = 69, DOT11_OID_MPDURXDUPS = 70, DOT11_OID_RTSSUCCESSFUL = 71, DOT11_OID_RTSFAILED = 72, DOT11_OID_ACKFAILED = 73, DOT11_OID_FRAMERECEIVES = 74, DOT11_OID_FRAMEERRORS = 75, DOT11_OID_FRAMEABORTS = 76, DOT11_OID_FRAMEABORTSPHY = 77, DOT11_OID_SLOTTIME = 78, DOT11_OID_CWMIN = 79, DOT11_OID_CWMAX = 80, DOT11_OID_ACKWINDOW = 81, DOT11_OID_ANTENNARX = 82, DOT11_OID_ANTENNATX = 83, DOT11_OID_ANTENNADIVERSITY = 84, DOT11_OID_CHANNEL = 85, DOT11_OID_EDTHRESHOLD = 86, DOT11_OID_PREAMBLESETTINGS = 87, DOT11_OID_RATES = 88, DOT11_OID_CCAMODESUPPORTED = 89, DOT11_OID_CCAMODE = 90, DOT11_OID_RSSIVECTOR = 91, DOT11_OID_OUTPUTPOWERTABLE = 92, DOT11_OID_OUTPUTPOWER = 93, DOT11_OID_SUPPORTEDRATES = 94, DOT11_OID_FREQUENCY = 95, DOT11_OID_SUPPORTEDFREQUENCIES = 96, DOT11_OID_NOISEFLOOR = 97, DOT11_OID_FREQUENCYACTIVITY = 98, DOT11_OID_IQCALIBRATIONTABLE = 99, DOT11_OID_NONERPPROTECTION = 100, DOT11_OID_SLOTSETTINGS = 101, DOT11_OID_NONERPTIMEOUT = 102, DOT11_OID_PROFILES = 103, DOT11_OID_EXTENDEDRATES = 104, DOT11_OID_DEAUTHENTICATE = 105, DOT11_OID_AUTHENTICATE = 106, DOT11_OID_DISASSOCIATE = 107, DOT11_OID_ASSOCIATE = 108, DOT11_OID_SCAN = 109, DOT11_OID_BEACON = 110, DOT11_OID_PROBE = 111, DOT11_OID_DEAUTHENTICATEEX = 112, DOT11_OID_AUTHENTICATEEX = 113, DOT11_OID_DISASSOCIATEEX = 114, DOT11_OID_ASSOCIATEEX = 115, DOT11_OID_REASSOCIATE = 116, DOT11_OID_REASSOCIATEEX = 117, DOT11_OID_NONERPSTATUS = 118, DOT11_OID_STATIMEOUT = 119, DOT11_OID_MLMEAUTOLEVEL = 120, DOT11_OID_BSSTIMEOUT = 121, DOT11_OID_ATTACHMENT = 122, DOT11_OID_PSMBUFFER = 123, DOT11_OID_BSSS = 124, DOT11_OID_BSSX = 125, DOT11_OID_BSSFIND = 126, DOT11_OID_BSSLIST = 127, OID_INL_TUNNEL = 128, OID_INL_MEMADDR = 129, OID_INL_MEMORY = 130, OID_INL_MODE = 131, OID_INL_COMPONENT_NR = 132, OID_INL_VERSION = 133, OID_INL_INTERFACE_ID = 134, OID_INL_COMPONENT_ID = 135, OID_INL_CONFIG = 136, OID_INL_DOT11D_CONFORMANCE = 137, OID_INL_PHYCAPABILITIES = 138, OID_INL_OUTPUTPOWER = 139, OID_NUM_LAST = 140 } ;
356 struct oid_t { enum oid_num_t oid; short range; short size; char flags; } ;
492 union oid_res_t { void *ptr; u32 u; } ;
47 struct mac_entry { struct list_head _list; char addr[6U]; } ;
66 struct islpci_bss_wpa_ie { struct list_head list; unsigned long last_update; u8 bssid[6U]; u8 wpa_ie[64U]; size_t wpa_ie_len; } ;
2100 struct ieee80211_beacon_phdr { u8 timestamp[8U]; u16 beacon_int; u16 capab_info; } ;
394 struct paravirt_callee_save { void *func; } ;
196 struct pv_irq_ops { struct paravirt_callee_save save_fl; struct paravirt_callee_save restore_fl; struct paravirt_callee_save irq_disable; struct paravirt_callee_save irq_enable; void (*safe_halt)(); void (*halt)(); void (*adjust_exception_frame)(); } ;
419 enum irqreturn { IRQ_NONE = 0, IRQ_HANDLED = 1, IRQ_WAKE_THREAD = 2 } ;
16 typedef enum irqreturn irqreturn_t;
47 struct firmware { size_t size; const u8 *data; struct page **pages; void *priv; } ;
38 typedef int Set;
1 long int __builtin_expect(long, long);
1 void * __builtin_memcpy(void *, const void *, unsigned long);
7 dma_addr_t ldv_dma_map_single_attrs(struct device *dev, void *ptr, size_t size, enum dma_data_direction dir, struct dma_attrs *attrs);
71 void set_bit(long nr, volatile unsigned long *addr);
109 void clear_bit(long nr, volatile unsigned long *addr);
252 int test_and_clear_bit(long nr, volatile unsigned long *addr);
7 __u32 __arch_swab32(__u32 val);
14 __u64 __arch_swab64(__u64 val);
57 __u32 __fswab32(__u32 val);
68 __u64 __fswab64(__u64 val);
148 void le32_add_cpu(__le32 *var, u32 val);
132 int printk(const char *, ...);
71 void warn_slowpath_null(const char *, const int);
58 void * memmove(void *, const void *, size_t );
24 int atomic_read(const atomic_t *v);
32 unsigned long int _raw_spin_lock_irqsave(raw_spinlock_t *);
43 void _raw_spin_unlock_irqrestore(raw_spinlock_t *, unsigned long);
290 raw_spinlock_t * spinlock_check(spinlock_t *lock);
356 void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags);
77 extern volatile unsigned long jiffies;
375 extern struct workqueue_struct *system_wq;
464 bool queue_work_on(int, struct workqueue_struct *, struct work_struct *);
504 bool queue_work(struct workqueue_struct *wq, struct work_struct *work);
563 bool schedule_work(struct work_struct *work);
55 unsigned int readl(const volatile void *addr);
63 void writel(unsigned int val, volatile void *addr);
63 int valid_dma_direction(int dma_direction);
44 void debug_dma_unmap_page(struct device *, dma_addr_t , size_t , int, bool );
30 extern struct dma_map_ops *dma_ops;
32 struct dma_map_ops * get_dma_ops(struct device *dev);
32 dma_addr_t ldv_dma_map_single_attrs_1(struct device *dev, void *ptr, size_t size, enum dma_data_direction dir, struct dma_attrs *attrs);
33 void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr, size_t size, enum dma_data_direction dir, struct dma_attrs *attrs);
30 dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction);
36 void pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr, size_t size, int direction);
10 void __const_udelay(unsigned long);
654 void consume_skb(struct sk_buff *);
692 struct sk_buff * skb_copy_expand(const struct sk_buff *, int, int, gfp_t );
798 unsigned char * skb_end_pointer(const struct sk_buff *skb);
926 int skb_cloned(const struct sk_buff *skb);
1369 bool skb_is_nonlinear(const struct sk_buff *skb);
1494 unsigned char * skb_put(struct sk_buff *, unsigned int);
1504 unsigned char * skb_push(struct sk_buff *, unsigned int);
1512 unsigned char * skb_pull(struct sk_buff *, unsigned int);
1556 unsigned int skb_headroom(const struct sk_buff *skb);
1567 int skb_tailroom(const struct sk_buff *skb);
1595 void skb_reserve(struct sk_buff *skb, int len);
1712 void skb_reset_mac_header(struct sk_buff *skb);
1933 struct sk_buff * __netdev_alloc_skb(struct net_device *, unsigned int, gfp_t );
1949 struct sk_buff * netdev_alloc_skb(struct net_device *dev, unsigned int length);
1963 struct sk_buff * dev_alloc_skb(unsigned int length);
2504 void skb_copy_from_linear_data(const struct sk_buff *skb, void *to, const unsigned int len);
1537 struct netdev_queue * netdev_get_tx_queue(const struct net_device *dev, unsigned int index);
1603 void * netdev_priv(const struct net_device *dev);
1888 int netpoll_trap();
2050 void __netif_schedule(struct Qdisc *);
2066 void netif_tx_start_queue(struct netdev_queue *dev_queue);
2092 void netif_tx_wake_queue(struct netdev_queue *dev_queue);
2111 void netif_wake_queue(struct net_device *dev);
2126 void netif_tx_stop_queue(struct netdev_queue *dev_queue);
2142 void netif_stop_queue(struct net_device *dev);
2471 void __dev_kfree_skb_irq(struct sk_buff *, enum skb_free_reason );
2493 void dev_kfree_skb_irq(struct sk_buff *skb);
2513 int netif_rx(struct sk_buff *);
32 __be16 eth_type_trans(struct sk_buff *, struct net_device *);
75 void isl38xx_w32_flush(void *base, u32 val, unsigned long offset);
167 void isl38xx_trigger_device(int asleep, void *device_base);
459 void wireless_spy_update(struct net_device *, unsigned char *, struct iw_quality *);
33 int pc_debug;
187 islpci_state_t islpci_get_state(islpci_private *priv);
201 int islpci_reset(islpci_private *priv, int reload_firmware);
204 void islpci_trigger(islpci_private *priv);
65 void islpci_eth_cleanup_transmit(islpci_private *priv, isl38xx_control_block *control_block);
66 netdev_tx_t islpci_eth_transmit(struct sk_buff *skb, struct net_device *ndev);
67 int islpci_eth_receive(islpci_private *priv);
68 void islpci_eth_tx_timeout(struct net_device *ndev);
69 void islpci_do_reset_and_wake(struct work_struct *work);
32 int channel_of_freq(int f);
245 int islpci_monitor_rx(islpci_private *priv, struct sk_buff **skb);
167 __u32 __swab32p(const __u32 *p);
235 void __swab32s(__u32 *p);
24 void INIT_LIST_HEAD(struct list_head *list);
88 void __bad_percpu_size();
10 extern struct task_struct *current_task;
12 struct task_struct * get_current();
55 void * memset(void *, int, size_t );
11 void __xchg_wrong_size();
279 void lockdep_init_map(struct lockdep_map *, const char *, struct lock_class_key *, int);
141 int mutex_lock_interruptible_nested(struct mutex *, unsigned int);
174 void mutex_unlock(struct mutex *);
144 void __wake_up(wait_queue_head_t *, unsigned int, int, void *);
820 void prepare_to_wait(wait_queue_head_t *, wait_queue_t *, int);
823 void finish_wait(wait_queue_head_t *, wait_queue_t *);
825 int autoremove_wake_function(wait_queue_t *, unsigned int, int, void *);
303 unsigned long int msecs_to_jiffies(const unsigned int);
192 void __init_work(struct work_struct *, int);
375 long int schedule_timeout_uninterruptible(long);
142 void kfree(const void *);
302 void * __kmalloc(size_t , gfp_t );
441 void * kmalloc(size_t size, gfp_t flags);
59 void debug_dma_sync_single_for_cpu(struct device *, dma_addr_t , size_t , int);
33 void dma_unmap_single_attrs___0(struct device *dev, dma_addr_t addr, size_t size, enum dma_data_direction dir, struct dma_attrs *attrs);
109 void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr, size_t size, enum dma_data_direction dir);
30 dma_addr_t pci_map_single___0(struct pci_dev *hwdev, void *ptr, size_t size, int direction);
36 void pci_unmap_single___0(struct pci_dev *hwdev, dma_addr_t dma_addr, size_t size, int direction);
71 void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle, size_t size, int direction);
118 int islpci_mgt_receive(struct net_device *ndev);
121 int islpci_mgmt_rx_fill(struct net_device *ndev);
124 void islpci_mgt_cleanup_transmit(struct net_device *ndev);
127 int islpci_mgt_transaction(struct net_device *ndev, int operation, unsigned long oid, void *senddata, int sendlen, struct islpci_mgmtframe **recvframe);
38 void prism54_process_trap(struct work_struct *work);
39 int pc_debug = 1;
70 void pimfor_encode_header(int operation, u32 oid, u32 length, pimfor_header_t *h);
84 pimfor_header_t * pimfor_decode_header(void *data, int len);
163 int islpci_mgt_transmit(struct net_device *ndev, int operation, unsigned long oid, void *data, int length);
159 int isl38xx_in_queue(isl38xx_control_block *cb, int queue);
161 void isl38xx_disable_interrupts(void *device);
162 void isl38xx_enable_common_interrupts(void *device_base);
164 void isl38xx_handle_sleep_request(isl38xx_control_block *control_block, int *powerstate, void *device_base);
166 void isl38xx_handle_wakeup(isl38xx_control_block *control_block, int *powerstate, void *device_base);
168 void isl38xx_interface_reset(void *device_base, dma_addr_t host_address);
47 void __list_add(struct list_head *, struct list_head *, struct list_head *);
60 void list_add(struct list_head *new, struct list_head *head);
74 void list_add_tail(struct list_head *new, struct list_head *head);
111 void __list_del_entry(struct list_head *);
112 void list_del(struct list_head *);
153 void list_move(struct list_head *list, struct list_head *head);
391 int snprintf(char *, size_t , const char *, ...);
34 void * __memcpy(void *, const void *, size_t );
60 int memcmp(const void *, const void *, size_t );
61 size_t strlen(const char *);
62 char * strcpy(char *, const char *);
23 char * strncpy(char *, const char *, __kernel_size_t );
119 void __mutex_init(struct mutex *, const char *, struct lock_class_key *);
138 void mutex_lock_nested(struct mutex *, unsigned int);
173 int mutex_trylock(struct mutex *);
91 void down_read(struct rw_semaphore *);
101 void down_write(struct rw_semaphore *);
111 void up_read(struct rw_semaphore *);
116 void up_write(struct rw_semaphore *);
638 void * kzalloc(size_t size, gfp_t flags);
2610 void netif_carrier_on(struct net_device *);
2612 void netif_carrier_off(struct net_device *);
266 bool ether_addr_equal(const u8 *addr1, const u8 *addr2);
133 void islpci_mgt_release(struct islpci_mgmtframe *frame);
440 void wireless_send_event(struct net_device *, unsigned int, union iwreq_data *, const char *);
447 int iw_handler_set_spy(struct net_device *, struct iw_request_info *, union iwreq_data *, char *);
450 int iw_handler_get_spy(struct net_device *, struct iw_request_info *, union iwreq_data *, char *);
453 int iw_handler_set_thrspy(struct net_device *, struct iw_request_info *, union iwreq_data *, char *);
456 int iw_handler_get_thrspy(struct net_device *, struct iw_request_info *, union iwreq_data *, char *);
467 int iwe_stream_lcp_len(struct iw_request_info *info);
476 int iwe_stream_point_len(struct iw_request_info *info);
485 int iwe_stream_event_len_adjust(struct iw_request_info *info, int event_len);
503 char * iwe_stream_add_event(struct iw_request_info *info, char *stream, char *ends, struct iw_event *iwe, int event_len);
528 char * iwe_stream_add_point(struct iw_request_info *info, char *stream, char *ends, struct iw_event *iwe, char *extra);
555 char * iwe_stream_add_value(struct iw_request_info *info, char *event, char *value, char *ends, struct iw_event *iwe, int event_len);
30 void prism54_mib_init(islpci_private *priv);
32 struct iw_statistics * prism54_get_wireless_stats(struct net_device *ndev);
33 void prism54_update_stats(struct work_struct *work);
35 void prism54_acl_init(struct islpci_acl *acl);
36 void prism54_acl_clean(struct islpci_acl *acl);
40 void prism54_wpa_bss_ie_init(islpci_private *priv);
41 void prism54_wpa_bss_ie_clean(islpci_private *priv);
43 int prism54_set_mac_address(struct net_device *ndev, void *addr);
45 const struct iw_handler_def prism54_handler_def;
24 struct oid_t isl_oid[140U];
34 void mgt_le_to_cpu(int type, void *data);
36 int mgt_set_request(islpci_private *priv, enum oid_num_t n, int extra, void *data);
37 int mgt_set_varlen(islpci_private *priv, enum oid_num_t n, void *data, int extra_len);
40 int mgt_get_request(islpci_private *priv, enum oid_num_t n, int extra, void *data, union oid_res_t *res);
43 int mgt_commit_list(islpci_private *priv, enum oid_num_t *l, int n);
45 void mgt_set(islpci_private *priv, enum oid_num_t n, void *data);
47 void mgt_get(islpci_private *priv, enum oid_num_t n, void *res);
49 int mgt_commit(islpci_private *priv);
51 int mgt_mlme_answer(islpci_private *priv);
53 enum oid_num_t mgt_oidtonum(u32 oid);
55 int mgt_response_to_str(enum oid_num_t n, union oid_res_t *r, char *str);
45 void prism54_wpa_bss_ie_add(islpci_private *priv, u8 *bssid, u8 *wpa_ie, size_t wpa_ie_len);
47 size_t prism54_wpa_bss_ie_get(islpci_private *priv, u8 *bssid, u8 *wpa_ie);
48 int prism54_set_wpa(struct net_device *ndev, struct iw_request_info *info, __u32 *uwrq, char *extra);
52 const unsigned char scan_rate_list[12U] = { 2U, 4U, 11U, 22U, 12U, 18U, 24U, 36U, 48U, 72U, 96U, 108U };
68 int prism54_mib_mode_helper(islpci_private *priv, u32 iw_mode);
243 int prism54_commit(struct net_device *ndev, struct iw_request_info *info, char *cwrq, char *extra);
259 int prism54_get_name(struct net_device *ndev, struct iw_request_info *info, char *cwrq, char *extra);
290 int prism54_set_freq(struct net_device *ndev, struct iw_request_info *info, struct iw_freq *fwrq, char *extra);
310 int prism54_get_freq(struct net_device *ndev, struct iw_request_info *info, struct iw_freq *fwrq, char *extra);
327 int prism54_set_mode(struct net_device *ndev, struct iw_request_info *info, __u32 *uwrq, char *extra);
371 int prism54_get_mode(struct net_device *ndev, struct iw_request_info *info, __u32 *uwrq, char *extra);
389 int prism54_set_sens(struct net_device *ndev, struct iw_request_info *info, struct iw_param *vwrq, char *extra);
402 int prism54_get_sens(struct net_device *ndev, struct iw_request_info *info, struct iw_param *vwrq, char *extra);
419 int prism54_get_range(struct net_device *ndev, struct iw_request_info *info, struct iw_point *dwrq, char *extra);
524 int prism54_set_wap(struct net_device *ndev, struct iw_request_info *info, struct sockaddr *awrq, char *extra);
546 int prism54_get_wap(struct net_device *ndev, struct iw_request_info *info, struct sockaddr *awrq, char *extra);
562 int prism54_set_scan(struct net_device *dev, struct iw_request_info *info, struct iw_param *vwrq, char *extra);
575 char * prism54_translate_bss(struct net_device *ndev, struct iw_request_info *info, char *current_ev, char *end_buf, struct obj_bss *bss, char noise);
682 int prism54_get_scan(struct net_device *ndev, struct iw_request_info *info, struct iw_point *dwrq, char *extra);
736 int prism54_set_essid(struct net_device *ndev, struct iw_request_info *info, struct iw_point *dwrq, char *extra);
763 int prism54_get_essid(struct net_device *ndev, struct iw_request_info *info, struct iw_point *dwrq, char *extra);
793 int prism54_set_nick(struct net_device *ndev, struct iw_request_info *info, struct iw_point *dwrq, char *extra);
810 int prism54_get_nick(struct net_device *ndev, struct iw_request_info *info, struct iw_point *dwrq, char *extra);
828 int prism54_set_rate(struct net_device *ndev, struct iw_request_info *info, struct iw_param *vwrq, char *extra);
901 int prism54_get_rate(struct net_device *ndev, struct iw_request_info *info, struct iw_param *vwrq, char *extra);
929 int prism54_set_rts(struct net_device *ndev, struct iw_request_info *info, struct iw_param *vwrq, char *extra);
938 int prism54_get_rts(struct net_device *ndev, struct iw_request_info *info, struct iw_param *vwrq, char *extra);
953 int prism54_set_frag(struct net_device *ndev, struct iw_request_info *info, struct iw_param *vwrq, char *extra);
962 int prism54_get_frag(struct net_device *ndev, struct iw_request_info *info, struct iw_param *vwrq, char *extra);
983 int prism54_set_retry(struct net_device *ndev, struct iw_request_info *info, struct iw_param *vwrq, char *extra);
1025 int prism54_get_retry(struct net_device *ndev, struct iw_request_info *info, struct iw_param *vwrq, char *extra);
1057 int prism54_set_encode(struct net_device *ndev, struct iw_request_info *info, struct iw_point *dwrq, char *extra);
1158 int prism54_get_encode(struct net_device *ndev, struct iw_request_info *info, struct iw_point *dwrq, char *extra);
1206 int prism54_get_txpower(struct net_device *ndev, struct iw_request_info *info, struct iw_param *vwrq, char *extra);
1226 int prism54_set_txpower(struct net_device *ndev, struct iw_request_info *info, struct iw_param *vwrq, char *extra);
1251 int prism54_set_genie(struct net_device *ndev, struct iw_request_info *info, struct iw_point *data, char *extra);
1300 int prism54_get_genie(struct net_device *ndev, struct iw_request_info *info, struct iw_point *data, char *extra);
1321 int prism54_set_auth(struct net_device *ndev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra);
1448 int prism54_get_auth(struct net_device *ndev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra);
1538 int prism54_set_encodeext(struct net_device *ndev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra);
1647 int prism54_get_encodeext(struct net_device *ndev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra);
1742 int prism54_reset(struct net_device *ndev, struct iw_request_info *info, __u32 *uwrq, char *extra);
1751 int prism54_get_oid(struct net_device *ndev, struct iw_request_info *info, struct iw_point *dwrq, char *extra);
1766 int prism54_set_u32(struct net_device *ndev, struct iw_request_info *info, __u32 *uwrq, char *extra);
1775 int prism54_set_raw(struct net_device *ndev, struct iw_request_info *info, struct iw_point *dwrq, char *extra);
1793 void prism54_clear_mac(struct islpci_acl *acl);
1822 int prism54_add_mac(struct net_device *ndev, struct iw_request_info *info, struct sockaddr *awrq, char *extra);
1851 int prism54_del_mac(struct net_device *ndev, struct iw_request_info *info, struct sockaddr *awrq, char *extra);
1878 int prism54_get_mac(struct net_device *ndev, struct iw_request_info *info, struct iw_point *dwrq, char *extra);
1906 int prism54_set_policy(struct net_device *ndev, struct iw_request_info *info, __u32 *uwrq, char *extra);
1942 int prism54_get_policy(struct net_device *ndev, struct iw_request_info *info, __u32 *uwrq, char *extra);
1956 int prism54_mac_accept(struct islpci_acl *acl, char *mac);
1982 int prism54_kick_all(struct net_device *ndev, struct iw_request_info *info, struct iw_point *dwrq, char *extra);
2002 int prism54_kick_mac(struct net_device *ndev, struct iw_request_info *info, struct sockaddr *awrq, char *extra);
2030 void format_event(islpci_private *priv, char *dest, const char *str, const struct obj_mlme *mlme, u16 *length, int error);
2045 void send_formatted_event(islpci_private *priv, const char *str, const struct obj_mlme *mlme, int error);
2063 void send_simple_event(islpci_private *priv, const char *str);
2081 void link_changed(struct net_device *ndev, u32 bitrate);
2109 u8 wpa_oid[4U] = { 0U, 80U, 242U, 1U };
2217 void prism54_process_bss_data(islpci_private *priv, u32 oid, u8 *addr, u8 *payload, size_t len);
2245 void handle_request(islpci_private *priv, struct obj_mlme *mlme, enum oid_num_t oid);
2260 int prism54_process_trap_helper(islpci_private *priv, enum oid_num_t oid, char *data);
2545 int prism54_get_wpa(struct net_device *ndev, struct iw_request_info *info, __u32 *uwrq, char *extra);
2554 int prism54_set_prismhdr(struct net_device *ndev, struct iw_request_info *info, __u32 *uwrq, char *extra);
2567 int prism54_get_prismhdr(struct net_device *ndev, struct iw_request_info *info, __u32 *uwrq, char *extra);
2576 int prism54_debug_oid(struct net_device *ndev, struct iw_request_info *info, __u32 *uwrq, char *extra);
2588 int prism54_debug_get_oid(struct net_device *ndev, struct iw_request_info *info, struct iw_point *data, char *extra);
2624 int prism54_debug_set_oid(struct net_device *ndev, struct iw_request_info *info, struct iw_point *data, char *extra);
2660 int prism54_set_spy(struct net_device *ndev, struct iw_request_info *info, union iwreq_data *uwrq, char *extra);
2685 iw_handler prism54_handler[55U] = { (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_commit), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_name), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_freq), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_freq), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_mode), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_mode), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_sens), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_sens), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_range), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, &prism54_set_spy, &iw_handler_get_spy, &iw_handler_set_thrspy, &iw_handler_get_thrspy, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_wap), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_wap), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_scan), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_scan), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_essid), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_essid), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_nick), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_nick), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_rate), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_rate), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_rts), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_rts), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_frag), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_frag), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_txpower), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_txpower), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_retry), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_retry), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_encode), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_encode), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_genie), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_genie), &prism54_set_auth, &prism54_get_auth, &prism54_set_encodeext, &prism54_get_encodeext, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0 };
2783 const struct iw_priv_args prism54_private_args[100U] = { { 35808U, 0U, 0U, { 'r', 'e', 's', 'e', 't', '\x0' } }, { 35831U, 0U, 18433U, { 'g', 'e', 't', '_', 'p', 'r', 'i', 's', 'm', 'h', 'd', 'r', '\x0' } }, { 35832U, 18433U, 0U, { 's', 'e', 't', '_', 'p', 'r', 'i', 's', 'm', 'h', 'd', 'r', '\x0' } }, { 35809U, 0U, 18433U, { 'g', 'e', 't', 'P', 'o', 'l', 'i', 'c', 'y', '\x0' } }, { 35810U, 18433U, 0U, { 's', 'e', 't', 'P', 'o', 'l', 'i', 'c', 'y', '\x0' } }, { 35811U, 0U, 24640U, { 'g', 'e', 't', 'M', 'a', 'c', '\x0' } }, { 35812U, 26625U, 0U, { 'a', 'd', 'd', 'M', 'a', 'c', '\x0' } }, { 35814U, 26625U, 0U, { 'd', 'e', 'l', 'M', 'a', 'c', '\x0' } }, { 35816U, 26625U, 0U, { 'k', 'i', 'c', 'k', 'M', 'a', 'c', '\x0' } }, { 35818U, 0U, 0U, { 'k', 'i', 'c', 'k', 'A', 'l', 'l', '\x0' } }, { 35819U, 0U, 18433U, { 'g', 'e', 't', '_', 'w', 'p', 'a', '\x0' } }, { 35820U, 18433U, 0U, { 's', 'e', 't', '_', 'w', 'p', 'a', '\x0' } }, { 35822U, 18433U, 0U, { 'd', 'b', 'g', '_', 'o', 'i', 'd', '\x0' } }, { 35823U, 0U, 4352U, { 'd', 'b', 'g', '_', 'g', 'e', 't', '_', 'o', 'i', 'd', '\x0' } }, { 35824U, 4352U, 0U, { 'd', 'b', 'g', '_', 's', 'e', 't', '_', 'o', 'i', 'd', '\x0' } }, { 35825U, 0U, 11264U, { '\x0' } }, { 35826U, 18433U, 0U, { '\x0' } }, { 35828U, 10241U, 0U, { '\x0' } }, { 35830U, 26625U, 0U, { '\x0' } }, { 0U, 26625U, 0U, { 's', '_', 'a', 'd', 'd', 'r', '\x0' } }, { 0U, 0U, 11264U, { 'g', '_', 'a', 'd', 'd', 'r', '\x0' } }, { 1U, 0U, 11264U, { 'g', '_', 'l', 'i', 'n', 'k', 's', 't', 'a', 't', 'e', '\x0' } }, { 6U, 18433U, 0U, { 's', '_', 'b', 's', 's', 't', 'y', 'p', 'e', '\x0' } }, { 6U, 0U, 11264U, { 'g', '_', 'b', 's', 's', 't', 'y', 'p', 'e', '\x0' } }, { 7U, 26625U, 0U, { 's', '_', 'b', 's', 's', 'i', 'd', '\x0' } }, { 7U, 0U, 11264U, { 'g', '_', 'b', 's', 's', 'i', 'd', '\x0' } }, { 9U, 18433U, 0U, { 's', '_', 's', 't', 'a', 't', 'e', '\x0' } }, { 9U, 0U, 11264U, { 'g', '_', 's', 't', 'a', 't', 'e', '\x0' } }, { 10U, 18433U, 0U, { 's', '_', 'a', 'i', 'd', '\x0' } }, { 10U, 0U, 11264U, { 'g', '_', 'a', 'i', 'd', '\x0' } }, { 12U, 10241U, 0U, { 's', '_', 's', 's', 'i', 'd', 'o', 'v', 'e', 'r', 'r', 'i', 'd', 'e', '\x0' } }, { 12U, 0U, 11264U, { 'g', '_', 's', 's', 'i', 'd', 'o', 'v', 'e', 'r', 'r', 'i', 'd', 'e', '\x0' } }, { 13U, 18433U, 0U, { 's', '_', 'm', 'e', 'd', 'l', 'i', 'm', 'i', 't', '\x0' } }, { 13U, 0U, 11264U, { 'g', '_', 'm', 'e', 'd', 'l', 'i', 'm', 'i', 't', '\x0' } }, { 14U, 18433U, 0U, { 's', '_', 'b', 'e', 'a', 'c', 'o', 'n', '\x0' } }, { 14U, 0U, 11264U, { 'g', '_', 'b', 'e', 'a', 'c', 'o', 'n', '\x0' } }, { 15U, 18433U, 0U, { 's', '_', 'd', 't', 'i', 'm', 'p', 'e', 'r', 'i', 'o', 'd', '\x0' } }, { 15U, 0U, 11264U, { 'g', '_', 'd', 't', 'i', 'm', 'p', 'e', 'r', 'i', 'o', 'd', '\x0' } }, { 20U, 18433U, 0U, { 's', '_', 'a', 'u', 't', 'h', 'e', 'n', 'a', 'b', 'l', 'e', '\x0' } }, { 20U, 0U, 11264U, { 'g', '_', 'a', 'u', 't', 'h', 'e', 'n', 'a', 'b', 'l', 'e', '\x0' } }, { 21U, 18433U, 0U, { 's', '_', 'p', 'r', 'i', 'v', 'i', 'n', 'v', 'o', 'k', '\x0' } }, { 21U, 0U, 11264U, { 'g', '_', 'p', 'r', 'i', 'v', 'i', 'n', 'v', 'o', 'k', '\x0' } }, { 22U, 18433U, 0U, { 's', '_', 'e', 'x', 'u', 'n', 'e', 'n', 'c', 'r', 'y', 'p', 't', '\x0' } }, { 22U, 0U, 11264U, { 'g', '_', 'e', 'x', 'u', 'n', 'e', 'n', 'c', 'r', 'y', 'p', 't', '\x0' } }, { 26U, 18433U, 0U, { 's', '_', 'r', 'e', 'k', 'e', 'y', 't', 'h', 'r', 'e', 's', 'h', '\x0' } }, { 26U, 0U, 11264U, { 'g', '_', 'r', 'e', 'k', 'e', 'y', 't', 'h', 'r', 'e', 's', 'h', '\x0' } }, { 36U, 18433U, 0U, { 's', '_', 'm', 'a', 'x', 't', 'x', 'l', 'i', 'f', 'e', '\x0' } }, { 36U, 0U, 11264U, { 'g', '_', 'm', 'a', 'x', 't', 'x', 'l', 'i', 'f', 'e', '\x0' } }, { 37U, 18433U, 0U, { 's', '_', 'm', 'a', 'x', 'r', 'x', 'l', 'i', 'f', 'e', '\x0' } }, { 37U, 0U, 11264U, { 'g', '_', 'm', 'a', 'x', 'r', 'x', 'l', 'i', 'f', 'e', '\x0' } }, { 44U, 18433U, 0U, { 's', '_', 'f', 'i', 'x', 'e', 'd', 'r', 'a', 't', 'e', '\x0' } }, { 44U, 0U, 11264U, { 'g', '_', 'f', 'i', 'x', 'e', 'd', 'r', 'a', 't', 'e', '\x0' } }, { 48U, 18433U, 0U, { 's', '_', 'f', 'r', 'a', 'm', 'e', 'b', 'u', 'r', 's', 't', '\x0' } }, { 48U, 0U, 11264U, { 'g', '_', 'f', 'r', 'a', 'm', 'e', 'b', 'u', 'r', 's', 't', '\x0' } }, { 49U, 18433U, 0U, { 's', '_', 'p', 's', 'm', '\x0' } }, { 49U, 0U, 11264U, { 'g', '_', 'p', 's', 'm', '\x0' } }, { 53U, 18433U, 0U, { 's', '_', 'b', 'r', 'i', 'd', 'g', 'e', '\x0' } }, { 53U, 0U, 11264U, { 'g', '_', 'b', 'r', 'i', 'd', 'g', 'e', '\x0' } }, { 54U, 18433U, 0U, { 's', '_', 'c', 'l', 'i', 'e', 'n', 't', 's', '\x0' } }, { 54U, 0U, 11264U, { 'g', '_', 'c', 'l', 'i', 'e', 'n', 't', 's', '\x0' } }, { 55U, 18433U, 0U, { 's', '_', 'c', 'l', 'i', 'e', 'n', 't', 'a', 's', 's', 'o', 'c', '\x0' } }, { 55U, 0U, 11264U, { 'g', '_', 'c', 'l', 'i', 'e', 'n', 't', 'a', 's', 's', 'o', 'c', '\x0' } }, { 62U, 18433U, 0U, { 's', '_', 'd', 'o', 't', '1', 'x', 'e', 'n', 'a', 'b', 'l', 'e', '\x0' } }, { 62U, 0U, 11264U, { 'g', '_', 'd', 'o', 't', '1', 'x', 'e', 'n', 'a', 'b', 'l', 'e', '\x0' } }, { 82U, 18433U, 0U, { 's', '_', 'r', 'x', 'a', 'n', 't', '\x0' } }, { 82U, 0U, 11264U, { 'g', '_', 'r', 'x', 'a', 'n', 't', '\x0' } }, { 83U, 18433U, 0U, { 's', '_', 't', 'x', 'a', 'n', 't', '\x0' } }, { 83U, 0U, 11264U, { 'g', '_', 't', 'x', 'a', 'n', 't', '\x0' } }, { 84U, 18433U, 0U, { 's', '_', 'a', 'n', 't', 'd', 'i', 'v', 'e', 'r', 's', '\x0' } }, { 84U, 0U, 11264U, { 'g', '_', 'a', 'n', 't', 'd', 'i', 'v', 'e', 'r', 's', '\x0' } }, { 86U, 18433U, 0U, { 's', '_', 'e', 'd', 't', 'h', 'r', 'e', 's', 'h', '\x0' } }, { 86U, 0U, 11264U, { 'g', '_', 'e', 'd', 't', 'h', 'r', 'e', 's', 'h', '\x0' } }, { 87U, 18433U, 0U, { 's', '_', 'p', 'r', 'e', 'a', 'm', 'b', 'l', 'e', '\x0' } }, { 87U, 0U, 11264U, { 'g', '_', 'p', 'r', 'e', 'a', 'm', 'b', 'l', 'e', '\x0' } }, { 88U, 0U, 11264U, { 'g', '_', 'r', 'a', 't', 'e', 's', '\x0' } }, { 93U, 18433U, 0U, { 's', '_', '.', '1', '1', 'o', 'u', 't', 'p', 'o', 'w', 'e', 'r', '\x0' } }, { 93U, 0U, 11264U, { 'g', '_', '.', '1', '1', 'o', 'u', 't', 'p', 'o', 'w', 'e', 'r', '\x0' } }, { 94U, 0U, 11264U, { 'g', '_', 's', 'u', 'p', 'p', 'r', 'a', 't', 'e', 's', '\x0' } }, { 96U, 0U, 11264U, { 'g', '_', 's', 'u', 'p', 'p', 'f', 'r', 'e', 'q', '\x0' } }, { 97U, 18433U, 0U, { 's', '_', 'n', 'o', 'i', 's', 'e', 'f', 'l', 'o', 'o', 'r', '\x0' } }, { 97U, 0U, 11264U, { 'g', '_', 'n', 'o', 'i', 's', 'e', 'f', 'l', 'o', 'o', 'r', '\x0' } }, { 98U, 0U, 11264U, { 'g', '_', 'f', 'r', 'e', 'q', 'a', 'c', 't', 'i', 'v', 'i', 't', 'y', '\x0' } }, { 100U, 18433U, 0U, { 's', '_', 'n', 'o', 'n', 'e', 'r', 'p', 'p', 'r', 'o', 't', 'e', 'c', '\x0' } }, { 100U, 0U, 11264U, { 'g', '_', 'n', 'o', 'n', 'e', 'r', 'p', 'p', 'r', 'o', 't', 'e', 'c', '\x0' } }, { 103U, 18433U, 0U, { 's', '_', 'p', 'r', 'o', 'f', 'i', 'l', 'e', '\x0' } }, { 103U, 0U, 11264U, { 'g', '_', 'p', 'r', 'o', 'f', 'i', 'l', 'e', '\x0' } }, { 104U, 0U, 11264U, { 'g', '_', 'e', 'x', 't', 'r', 'a', 't', 'e', 's', '\x0' } }, { 120U, 18433U, 0U, { 's', '_', 'm', 'l', 'm', 'e', 'l', 'e', 'v', 'e', 'l', '\x0' } }, { 120U, 0U, 11264U, { 'g', '_', 'm', 'l', 'm', 'e', 'l', 'e', 'v', 'e', 'l', '\x0' } }, { 124U, 0U, 11264U, { 'g', '_', 'b', 's', 's', 's', '\x0' } }, { 127U, 0U, 11264U, { 'g', '_', 'b', 's', 's', 'l', 'i', 's', 't', '\x0' } }, { 131U, 18433U, 0U, { 's', '_', 'm', 'o', 'd', 'e', '\x0' } }, { 131U, 0U, 11264U, { 'g', '_', 'm', 'o', 'd', 'e', '\x0' } }, { 136U, 18433U, 0U, { 's', '_', 'c', 'o', 'n', 'f', 'i', 'g', '\x0' } }, { 136U, 0U, 11264U, { 'g', '_', 'c', 'o', 'n', 'f', 'i', 'g', '\x0' } }, { 137U, 18433U, 0U, { 's', '_', '.', '1', '1', 'd', 'c', 'o', 'n', 'f', 'o', 'r', 'm', '\x0' } }, { 137U, 0U, 11264U, { 'g', '_', '.', '1', '1', 'd', 'c', 'o', 'n', 'f', 'o', 'r', 'm', '\x0' } }, { 138U, 0U, 11264U, { 'g', '_', 'p', 'h', 'y', 'c', 'a', 'p', 'a', '\x0' } }, { 139U, 18433U, 0U, { 's', '_', 'o', 'u', 't', 'p', 'o', 'w', 'e', 'r', '\x0' } }, { 139U, 0U, 11264U, { 'g', '_', 'o', 'u', 't', 'p', 'o', 'w', 'e', 'r', '\x0' } } };
2875 iw_handler prism54_private_handler[25U] = { (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_reset), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_policy), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_policy), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_mac), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_add_mac), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_del_mac), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_kick_mac), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_kick_all), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_wpa), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_wpa), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_debug_oid), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_debug_get_oid), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_debug_set_oid), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_oid), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_u32), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_raw), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))0, (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_raw), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_get_prismhdr), (int (*)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_set_prismhdr) };
2903 const struct iw_handler_def prism54_handler_def = { (const iw_handler (**)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_handler), 55U, 25U, 100U, (const iw_handler (**)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *))(&prism54_private_handler), (const struct iw_priv_args *)(&prism54_private_args), &prism54_get_wireless_stats };
2929 void ldv_check_final_state();
2938 void ldv_initialize();
2941 void ldv_handler_precall();
2944 int nondet_int();
2947 int LDV_IN_INTERRUPT = 0;
2950 void ldv_main3_sequence_infinite_withcheck_stateful();
358 extern struct pv_irq_ops pv_irq_ops;
12 struct task_struct * get_current___0();
26 size_t strlcpy(char *, const char *, size_t );
802 unsigned long int arch_local_save_flags();
155 int arch_irqs_disabled_flags(unsigned long flags);
93 void __raw_spin_lock_init(raw_spinlock_t *, const char *, struct lock_class_key *);
22 void _raw_spin_lock(raw_spinlock_t *);
39 void _raw_spin_unlock(raw_spinlock_t *);
301 void spin_lock(spinlock_t *lock);
341 void spin_unlock(spinlock_t *lock);
68 void __init_waitqueue_head(wait_queue_head_t *, const char *, struct lock_class_key *);
67 void __writel(unsigned int val, volatile void *addr);
174 void * ioremap_nocache(resource_size_t , unsigned long);
182 void * ioremap(resource_size_t offset, unsigned long size);
187 void iounmap(volatile void *);
11 void synchronize_irq(unsigned int);
914 int dev_set_drvdata(struct device *, void *);
70 int is_device_dma_capable(struct device *dev);
53 void debug_dma_alloc_coherent(struct device *, size_t , dma_addr_t , void *);
56 void debug_dma_free_coherent(struct device *, size_t , void *, dma_addr_t );
27 extern struct device x86_dma_fallback_dev;
33 void dma_unmap_single_attrs___1(struct device *dev, dma_addr_t addr, size_t size, enum dma_data_direction dir, struct dma_attrs *attrs);
107 unsigned long int dma_alloc_coherent_mask(struct device *dev, gfp_t gfp);
119 gfp_t dma_alloc_coherent_gfp_flags(struct device *dev, gfp_t gfp);
135 void * dma_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle, gfp_t gfp, struct dma_attrs *attrs);
164 void dma_free_attrs(struct device *dev, size_t size, void *vaddr, dma_addr_t bus, struct dma_attrs *attrs);
1877 void free_netdev(struct net_device *);
2077 void netif_start_queue(struct net_device *dev);
2903 int register_netdev(struct net_device *);
16 void * pci_alloc_consistent(struct pci_dev *hwdev, size_t size, dma_addr_t *dma_handle);
23 void pci_free_consistent(struct pci_dev *hwdev, size_t size, void *vaddr, dma_addr_t dma_handle);
30 dma_addr_t pci_map_single___1(struct pci_dev *hwdev, void *ptr, size_t size, int direction);
36 void pci_unmap_single___1(struct pci_dev *hwdev, dma_addr_t dma_addr, size_t size, int direction);
1412 void pci_set_drvdata(struct pci_dev *pdev, void *data);
46 int eth_change_mtu(struct net_device *, int);
47 int eth_validate_addr(struct net_device *);
49 struct net_device * alloc_etherdev_mqs(int, unsigned int, unsigned int);
42 int request_firmware(const struct firmware **, const char *, struct device *);
49 void release_firmware(const struct firmware *);
194 islpci_state_t islpci_set_state(islpci_private *priv, islpci_state_t new_state);
198 irqreturn_t islpci_interrupt(int irq, void *config);
210 int islpci_free_memory(islpci_private *priv);
211 struct net_device * islpci_setup(struct pci_dev *pdev);
26 int mgt_init(islpci_private *priv);
28 void mgt_clean(islpci_private *priv);
50 int prism54_bring_down(islpci_private *priv);
51 int islpci_alloc_memory(islpci_private *priv);
60 const unsigned char dummy_mac[6U] = { 0U, 48U, 180U, 0U, 0U, 0U };
63 int isl_upload_firmware(islpci_private *priv);
382 int islpci_open(struct net_device *ndev);
410 int islpci_close(struct net_device *ndev);
461 int islpci_upload_fw(islpci_private *priv);
489 int islpci_reset_if(islpci_private *priv);
793 void islpci_ethtool_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info);
800 const struct ethtool_ops islpci_ethtool_ops = { 0, 0, &islpci_ethtool_get_drvinfo, 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 };
804 const struct net_device_ops islpci_netdev_ops = { 0, 0, &islpci_open, &islpci_close, &islpci_eth_transmit, 0, 0, 0, &prism54_set_mac_address, ð_validate_addr, 0, 0, ð_change_mtu, 0, &islpci_eth_tx_timeout, 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 };
814 struct device_type wlan_type = { "wlan", 0, 0, 0, 0, 0 };
985 void ldv_check_return_value(int);
1003 void ldv_main4_sequence_infinite_withcheck_stateful();
33 extern struct module __this_module;
123 int request_threaded_irq(unsigned int, irqreturn_t (*)(int, void *), irqreturn_t (*)(int, void *), unsigned long, const char *, void *);
128 int request_irq(unsigned int irq, irqreturn_t (*handler)(int, void *), unsigned long flags, const char *name, void *dev);
142 void free_irq(unsigned int, void *);
913 void * dev_get_drvdata(const struct device *);
820 int pci_bus_read_config_byte(struct pci_bus *, unsigned int, int, u8 *);
824 int pci_bus_read_config_dword(struct pci_bus *, unsigned int, int, u32 *);
826 int pci_bus_write_config_byte(struct pci_bus *, unsigned int, int, u8 );
834 int pci_read_config_byte(const struct pci_dev *dev, int where, u8 *val);
842 int pci_read_config_dword(const struct pci_dev *dev, int where, u32 *val);
847 int pci_write_config_byte(const struct pci_dev *dev, int where, u8 val);
902 int pci_enable_device(struct pci_dev *);
919 void pci_disable_device(struct pci_dev *);
922 void pci_set_master(struct pci_dev *);
929 int pci_try_set_mwi(struct pci_dev *);
930 void pci_clear_mwi(struct pci_dev *);
975 int pci_save_state(struct pci_dev *);
976 void pci_restore_state(struct pci_dev *);
1040 int pci_request_regions(struct pci_dev *, const char *);
1042 void pci_release_regions(struct pci_dev *);
1085 int __pci_register_driver(struct pci_driver *, struct module *, const char *);
1094 void pci_unregister_driver(struct pci_driver *);
65 int dma_set_mask(struct device *, u64 );
105 int pci_set_dma_mask(struct pci_dev *dev, u64 mask);
1407 void * pci_get_drvdata(struct pci_dev *pdev);
2680 void netif_device_detach(struct net_device *);
2682 void netif_device_attach(struct net_device *);
2904 void unregister_netdev(struct net_device *);
104 void __bug_on_wrong_struct_sizes();
36 int init_pcitm = 0;
43 const struct pci_device_id prism54_id_tbl[5U] = { { 4704U, 14480U, 4294967295U, 4294967295U, 0U, 0U, 0UL }, { 4279U, 24577U, 4294967295U, 4294967295U, 0U, 0U, 0UL }, { 4704U, 14455U, 4294967295U, 4294967295U, 0U, 0U, 0UL }, { 4704U, 14470U, 4294967295U, 4294967295U, 0U, 0U, 0UL }, { 0U, 0U, 0U, 0U, 0U, 0U, 0UL } };
75 const struct pci_device_id __mod_pci_device_table = { };
77 int prism54_probe(struct pci_dev *pdev, const struct pci_device_id *id);
78 void prism54_remove(struct pci_dev *pdev);
79 int prism54_suspend(struct pci_dev *pdev, pm_message_t state);
80 int prism54_resume(struct pci_dev *pdev);
82 struct pci_driver prism54_driver = { { 0, 0 }, "prism54", (const struct pci_device_id *)(&prism54_id_tbl), &prism54_probe, &prism54_remove, &prism54_suspend, 0, 0, &prism54_resume, 0, 0, 0, { 0, 0, 0, 0, (_Bool)0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { { { { { { 0U } }, 0U, 0U, 0, { 0, { 0, 0 }, 0, 0, 0UL } } } }, { 0, 0 } } };
214 volatile int __in_cleanup_module = 0;
312 int prism54_module_init();
326 void prism54_module_exit();
364 void ldv_check_return_value_probe(int);
379 void ldv_main5_sequence_infinite_withcheck_stateful();
67 void __init_rwsem(struct rw_semaphore *, const char *, struct lock_class_key *);
560 void * kmalloc_array(size_t n, size_t size, gfp_t flags);
573 void * kcalloc(size_t n, size_t size, gfp_t flags);
29 const int frequency_list_bg[14U] = { 2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484 };
57 struct oid_t isl_oid[140U] = { { 0, 0, 6, 10 }, { 1, 0, 4, 1 }, { 2, 0, 4, 0 }, { 3, 0, 4, 0 }, { 4, 0, 4, 0 }, { 5, 0, 4, 0 }, { 268435456, 0, 4, -127 }, { 268435457, 0, 6, -117 }, { 268435458, 0, 34, -126 }, { 268435459, 0, 4, 1 }, { 268435460, 0, 4, 1 }, { 268435461, 0, 4, 11 }, { 268435462, 0, 34, -126 }, { 285212672, 0, 4, 1 }, { 285212673, 0, 4, -127 }, { 285212674, 0, 4, 1 }, { 285212675, 0, 4, 1 }, { 285212676, 0, 4, 1 }, { 285212677, 0, 4, 1 }, { 285212678, 0, 4, 1 }, { 301989888, 0, 4, -127 }, { 301989889, 0, 4, -127 }, { 301989890, 0, 4, -127 }, { 301989891, 0, 4, -127 }, { 301989892, 3, 34, -125 }, { 301989896, 0, 4, 0 }, { 301989897, 0, 4, 1 }, { 301989898, 0, 4, 0 }, { 436207616, 0, 4, 1 }, { 436207617, 0, 4, 1 }, { 436207618, 0, 4, 1 }, { 436207619, 0, 4, 1 }, { 318767104, 0, 4, -127 }, { 318767105, 0, 4, -127 }, { 318767106, 0, 4, -127 }, { 318767107, 0, 4, -127 }, { 318767108, 0, 4, -127 }, { 318767109, 0, 4, 1 }, { 318767110, 0, 4, 1 }, { 318767111, 0, 4, 1 }, { 486539264, 0, 4, 0 }, { 486539265, 0, 4, 0 }, { 486539266, 0, 4, 0 }, { 486539267, 0, 4, 0 }, { 486539268, 0, 4, 1 }, { 486539269, 0, 4, 0 }, { 486539270, 0, 4, 0 }, { 452984832, 7, 0, 0 }, { 452984840, 0, 4, 1 }, { 335544320, 0, 4, 1 }, { 335544321, 0, 4, 1 }, { 335544322, 0, 4, 1 }, { 335544323, 0, 4, 1 }, { 352321536, 0, 4, 1 }, { 352321537, 0, 4, 1 }, { 352321538, 0, 4, 1 }, { 352321539, 2006, 0, 0 }, { 352323547, 0, 6, 10 }, { 352323548, 0, 6, 10 }, { 352323549, 0, 6, 10 }, { 352323550, 0, 6, 10 }, { 352323551, 0, 6, 10 }, { 352323552, 0, 4, -127 }, { 352323553, 0, 4, 0 }, { 352323554, 0, 4, 0 }, { 369098752, 0, 4, 1 }, { 369098753, 0, 4, 1 }, { 369098754, 0, 4, 1 }, { 369098755, 0, 4, 1 }, { 369098756, 0, 4, 1 }, { 369098757, 0, 4, 1 }, { 369098758, 0, 4, 1 }, { 369098759, 0, 4, 1 }, { 369098760, 0, 4, 1 }, { 369098761, 0, 4, 1 }, { 369098762, 0, 4, 1 }, { 369098763, 0, 4, 1 }, { 369098764, 0, 4, 1 }, { 385875968, 0, 4, 1 }, { 385875969, 0, 4, 1 }, { 385875970, 0, 4, 1 }, { 385875971, 0, 4, 1 }, { 385875972, 0, 4, 1 }, { 385875973, 0, 4, 1 }, { 385875974, 0, 4, 1 }, { 385875975, 0, 4, -127 }, { 385875976, 0, 4, -127 }, { 385875977, 0, 4, 1 }, { 385875978, 0, 21, 11 }, { 385875979, 0, 4, 1 }, { 385875980, 0, 4, 1 }, { 385875981, 0, 4, 0 }, { 385875982, 0, 4, 0 }, { 385875983, 0, 4, 1 }, { 385875984, 0, 21, 11 }, { 385875985, 0, 4, -127 }, { 385875986, 0, 62, 7 }, { 385875987, 0, 4, 1 }, { 385875988, 0, 31, 11 }, { 385875989, 0, 4, 0 }, { 385875990, 0, 4, 1 }, { 385875991, 0, 4, 1 }, { 385875992, 0, 4, 1 }, { 385875993, 0, 4, 1 }, { 385876000, 0, 21, 11 }, { 402653184, 0, 12, 8 }, { 402653185, 0, 12, 8 }, { 402653186, 0, 12, 8 }, { 402653187, 0, 12, 8 }, { 402653188, 0, 4, 0 }, { 402653189, 0, 14, 9 }, { 402653190, 0, 14, 9 }, { 402653191, 0, 14, 9 }, { 402653192, 0, 14, 9 }, { 402653193, 0, 14, 9 }, { 402653194, 0, 14, 9 }, { 402653195, 0, 14, 9 }, { 402653196, 0, 14, 9 }, { 503316480, 0, 4, 1 }, { 419430400, 0, 4, 1 }, { 419430401, 0, 4, -127 }, { 419430402, 0, 4, 1 }, { 419430403, 0, 6, 12 }, { 419430404, 0, 8, -124 }, { 469762048, 0, 4, 1 }, { 469762049, 63, 60, 5 }, { 469762114, 0, 60, 5 }, { 469762115, 0, 1444, 6 }, { 4278321152U, 0, 4, 0 }, { 4278321153U, 0, 4, 0 }, { 4278321154U, 0, 4, 0 }, { 4278321155U, 0, 4, -127 }, { 4278321156U, 0, 4, 0 }, { 4278321157U, 0, 8, 11 }, { 4278321158U, 0, 4, 0 }, { 4278321159U, 0, 4, 0 }, { 4278321160U, 0, 4, -127 }, { 4278321164U, 0, 4, -127 }, { 4278321165U, 0, 4, 1 }, { 4278321167U, 0, 4, -127 } };
347 void mgt_cpu_to_le(int type, void *data);
649 enum oid_num_t commit_part1[5U] = { 136, 131, 6, 85, 120 };
657 enum oid_num_t commit_part2[9U] = { 8, 123, 20, 21, 22, 24, 23, 62, 137 };
674 int mgt_update_addr(islpci_private *priv);
10 void ldv_error();
25 int ldv_undef_int();
26 void * ldv_undef_ptr();
8 int LDV_DMA_MAP_CALLS = 0;
11 dma_addr_t ldv_dma_map_page(struct device *dev, struct page *page, size_t offset, size_t size, enum dma_data_direction dir);
25 int ldv_dma_mapping_error(struct device *dev, dma_addr_t dma_addr);
41 dma_addr_t ldv_dma_map_single(struct device *dev, void *cpu_addr, size_t size, enum dma_data_direction dir);
return ;
}
-entry_point
{
1005 struct net_device *var_group1;
1006 struct ethtool_drvinfo *var_group2;
1007 int res_islpci_open_2;
1008 int res_islpci_close_3;
1009 int var_islpci_interrupt_1_p0;
1010 void *var_islpci_interrupt_1_p1;
1011 int ldv_s_islpci_netdev_ops_net_device_ops;
1012 int tmp;
1013 int tmp___0;
1163 ldv_s_islpci_netdev_ops_net_device_ops = 0;
1151 LDV_IN_INTERRUPT = 1;
1160 -ldv_initialize()
{
71 LDV_DMA_MAP_CALLS = 0;
72 return ;;
}
1168 goto ldv_43329;
1168 tmp___0 = nondet_int() { /* Function call is skipped due to function is undefined */}
1168 assume(tmp___0 != 0);
1171 goto ldv_43328;
1169 ldv_43328:;
1172 tmp = nondet_int() { /* Function call is skipped due to function is undefined */}
1172 switch (tmp)
1173 assume(!(tmp == 0));
1223 assume(!(tmp == 1));
1275 assume(!(tmp == 2));
1327 assume(tmp == 3);
1330 LDV_IN_INTERRUPT = 2;
1339 ldv_handler_precall() { /* Function call is skipped due to function is undefined */}
1340 -islpci_interrupt(var_islpci_interrupt_1_p0, var_islpci_interrupt_1_p1)
{
192 unsigned int reg;
193 islpci_private *priv;
194 struct net_device *ndev;
195 void *device;
196 int powerstate;
197 unsigned int tmp;
198 enum ldv_30720 tmp___0;
199 int tmp___1;
200 int tmp___2;
201 int tmp___3;
202 enum ldv_30720 tmp___4;
203 enum ldv_30720 tmp___5;
193 priv = (islpci_private *)config;
194 ndev = priv->ndev;
195 device = priv->device_base;
196 powerstate = 1;
199 -spin_lock(&(priv->slock))
{
303 _raw_spin_lock(&(lock->__annonCompField20.rlock)) { /* Function call is skipped due to function is undefined */}
304 return ;;
}
203 -readl(((const volatile void *)device) + 120U)
{
57 unsigned int ret;
55 Ignored inline assembler code
55 return ret;;
}
204 assume(!((reg & 512U) != 0U));
216 -readl(((const volatile void *)device) + 16U)
{
57 unsigned int ret;
55 Ignored inline assembler code
55 return ret;;
}
220 -readl(((const volatile void *)device) + 24U)
{
57 unsigned int ret;
55 Ignored inline assembler code
55 return ret;;
}
220 reg = tmp & reg;
221 reg = reg & 30U;
223 assume(reg != 0U);
224 -islpci_get_state(priv)
{
190 return priv->state;;
}
224 assume(!(((unsigned int)tmp___0) != 7U));
228 -isl38xx_w32_flush(device, reg, 20UL)
{
77 -writel(val, (volatile void *)(base + offset))
{
63 Ignored inline assembler code
64 return ;;
}
78 -readl(((const volatile void *)base) + 24U)
{
57 unsigned int ret;
55 Ignored inline assembler code
55 return ret;;
}
79 return ;;
}
236 assume((reg & 2U) != 0U);
275 -islpci_eth_cleanup_transmit(priv, priv->control_block)
{
40 struct sk_buff *skb;
41 unsigned int index;
45 goto ldv_43131;
45 assume(!((priv->free_data_tx) != ((control_block->device_curr_frag)[1])));
53 return ;;
}
279 powerstate = 0;
284 -isl38xx_in_queue(priv->control_block, 4)
{
225 int delta;
226 long tmp;
227 long tmp___0;
228 long tmp___1;
229 long tmp___2;
230 long tmp___3;
225 delta = (const s32 )(((cb->driver_curr_frag)[queue]) - ((cb->device_curr_frag)[queue]));
231 tmp = __builtin_expect(delta < 0, 0L) { /* Function call is skipped due to function is undefined */}
231 assume(!(tmp != 0L));
233 switch (queue)
234 assume(!(queue == 5));
240 assume(!(queue == 1));
241 assume(!(queue == 3));
242 assume(queue == 4);
245 tmp___2 = __builtin_expect(delta > 4, 0L) { /* Function call is skipped due to function is undefined */}
245 assume(!(tmp___2 != 0L));
246 return 4 - delta;;
}
284 assume(tmp___1 != 0);
290 -islpci_mgt_receive(ndev)
{
270 islpci_private *priv;
271 void *tmp;
272 isl38xx_control_block *cb;
273 unsigned int curr_frag;
274 pimfor_header_t *header;
275 unsigned int index;
276 struct islpci_membuf *buf;
277 unsigned short frag_len;
278 int size;
279 struct islpci_mgmtframe *frame;
280 void *tmp___0;
281 unsigned long __len;
282 void *__ret;
283 struct lock_class_key __key;
284 struct __anonstruct_atomic64_t_7 __constr_expr_0;
285 struct islpci_mgmtframe *__ret___0;
270 -netdev_priv((const struct net_device *)ndev)
{
1605 return ((void *)dev) + 3200U;;
}
270 priv = (islpci_private *)tmp;
271 cb = priv->control_block;
282 curr_frag = (cb->device_curr_frag)[4];
283 Ignored inline assembler code
285 goto ldv_42970;
285 assume(!((priv->index_mgmt_rx) < curr_frag));
401 return 0;;
}
292 -islpci_mgt_cleanup_transmit(ndev)
{
410 islpci_private *priv;
411 void *tmp;
412 isl38xx_control_block *cb;
413 unsigned int curr_frag;
414 int index;
415 struct islpci_membuf *buf;
410 -netdev_priv((const struct net_device *)ndev)
{
1605 return ((void *)dev) + 3200U;;
}
410 priv = (islpci_private *)tmp;
411 cb = priv->control_block;
423 curr_frag = (cb->device_curr_frag)[5];
424 Ignored inline assembler code
426 goto ldv_42981;
426 assume(!((priv->index_mgmt_tx) < curr_frag));
433 return ;;
}
295 -islpci_mgmt_rx_fill(ndev)
{
109 islpci_private *priv;
110 void *tmp;
111 isl38xx_control_block *cb;
112 unsigned int curr;
113 unsigned int index;
114 struct islpci_membuf *buf;
115 isl38xx_fragment *frag;
109 -netdev_priv((const struct net_device *)ndev)
{
1605 return ((void *)dev) + 3200U;;
}
109 priv = (islpci_private *)tmp;
110 cb = priv->control_block;
112 curr = (cb->driver_curr_frag)[4];
118 goto ldv_42915;
118 assume((curr - (priv->index_mgmt_rx)) <= 3U);
120 goto ldv_42914;
119 ldv_42914:;
119 index = curr & 3U;
120 buf = ((struct islpci_membuf *)(&(priv->mgmt_rx))) + ((unsigned long)index);
121 frag = ((isl38xx_fragment *)(&(cb->rx_data_mgmt))) + ((unsigned long)index);
123 unsigned long __CPAchecker_TMP_0 = (unsigned long)(buf->mem);
123 assume(!(__CPAchecker_TMP_0 == ((unsigned long)((void *)0))));
129 assume((buf->pci_addr) == 0ULL);
130 -pci_map_single___0(priv->pdev, buf->mem, 1500UL, 2)
{
33 unsigned long long tmp;
32 struct device *__CPAchecker_TMP_0;
32 assume(!(((unsigned long)hwdev) != ((unsigned long)((struct pci_dev *)0))));
32 __CPAchecker_TMP_0 = (struct device *)0;
32 -ldv_dma_map_single_attrs_1(__CPAchecker_TMP_0, ptr, size, (enum dma_data_direction )direction, (struct dma_attrs *)0)
{
14 unsigned long long tmp;
13 -ldv_dma_map_single_attrs(dev, ptr, size, dir, attrs)
{
58 unsigned long long nonedetermined;
59 void *tmp;
58 tmp = ldv_undef_ptr() { /* Function call is skipped due to function is undefined */}
58 nonedetermined = (dma_addr_t )tmp;
61 assume(!(LDV_DMA_MAP_CALLS != 0));
63 LDV_DMA_MAP_CALLS = LDV_DMA_MAP_CALLS + 1;
65 return nonedetermined;;
}
13 return tmp;;
}
32 return tmp;;
}
133 assume(!((buf->pci_addr) == 0ULL));
141 frag->size = 1500U;
142 frag->flags = 0U;
143 unsigned int __CPAchecker_TMP_2 = (unsigned int)(buf->pci_addr);
143 frag->address = __CPAchecker_TMP_2;
144 curr = curr + 1U;
149 Ignored inline assembler code
150 (cb->driver_curr_frag)[4] = curr;
151 ldv_42915:;
118 assume((curr - (priv->index_mgmt_rx)) <= 3U);
120 goto ldv_42914;
119 ldv_42914:;
119 index = curr & 3U;
120 buf = ((struct islpci_membuf *)(&(priv->mgmt_rx))) + ((unsigned long)index);
121 frag = ((isl38xx_fragment *)(&(cb->rx_data_mgmt))) + ((unsigned long)index);
123 unsigned long __CPAchecker_TMP_0 = (unsigned long)(buf->mem);
123 assume(!(__CPAchecker_TMP_0 == ((unsigned long)((void *)0))));
129 assume((buf->pci_addr) == 0ULL);
130 -pci_map_single___0(priv->pdev, buf->mem, 1500UL, 2)
{
33 unsigned long long tmp;
32 struct device *__CPAchecker_TMP_0;
32 assume(!(((unsigned long)hwdev) != ((unsigned long)((struct pci_dev *)0))));
32 __CPAchecker_TMP_0 = (struct device *)0;
32 -ldv_dma_map_single_attrs_1(__CPAchecker_TMP_0, ptr, size, (enum dma_data_direction )direction, (struct dma_attrs *)0)
{
14 unsigned long long tmp;
13 -ldv_dma_map_single_attrs(dev, ptr, size, dir, attrs)
{
58 unsigned long long nonedetermined;
59 void *tmp;
58 tmp = ldv_undef_ptr() { /* Function call is skipped due to function is undefined */}
58 nonedetermined = (dma_addr_t )tmp;
61 assume(LDV_DMA_MAP_CALLS != 0);
61 -ldv_error()
{
15 LDV_ERROR:;
}
}
}
}
}
}
}
Source code
1 /* 2 * Copyright (C) 2002 Intersil Americas Inc. 3 * Copyright (C) 2003-2004 Luis R. Rodriguez <mcgrof@ruslug.rutgers.edu>_ 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, see <http://www.gnu.org/licenses/>. 16 * 17 */ 18 19 #include <linux/module.h> 20 #include <linux/types.h> 21 #include <linux/delay.h> 22 23 #include <asm/uaccess.h> 24 #include <asm/io.h> 25 26 #include "prismcompat.h" 27 #include "isl_38xx.h" 28 #include "islpci_dev.h" 29 #include "islpci_mgt.h" 30 31 /****************************************************************************** 32 Device Interface & Control functions 33 ******************************************************************************/ 34 35 /** 36 * isl38xx_disable_interrupts - disable all interrupts 37 * @device: pci memory base address 38 * 39 * Instructs the device to disable all interrupt reporting by asserting 40 * the IRQ line. New events may still show up in the interrupt identification 41 * register located at offset %ISL38XX_INT_IDENT_REG. 42 */ 43 void 44 isl38xx_disable_interrupts(void __iomem *device) 45 { 46 isl38xx_w32_flush(device, 0x00000000, ISL38XX_INT_EN_REG); 47 udelay(ISL38XX_WRITEIO_DELAY); 48 } 49 50 void 51 isl38xx_handle_sleep_request(isl38xx_control_block *control_block, 52 int *powerstate, void __iomem *device_base) 53 { 54 /* device requests to go into sleep mode 55 * check whether the transmit queues for data and management are empty */ 56 if (isl38xx_in_queue(control_block, ISL38XX_CB_TX_DATA_LQ)) 57 /* data tx queue not empty */ 58 return; 59 60 if (isl38xx_in_queue(control_block, ISL38XX_CB_TX_MGMTQ)) 61 /* management tx queue not empty */ 62 return; 63 64 /* check also whether received frames are pending */ 65 if (isl38xx_in_queue(control_block, ISL38XX_CB_RX_DATA_LQ)) 66 /* data rx queue not empty */ 67 return; 68 69 if (isl38xx_in_queue(control_block, ISL38XX_CB_RX_MGMTQ)) 70 /* management rx queue not empty */ 71 return; 72 73 #if VERBOSE > SHOW_ERROR_MESSAGES 74 DEBUG(SHOW_TRACING, "Device going to sleep mode\n"); 75 #endif 76 77 /* all queues are empty, allow the device to go into sleep mode */ 78 *powerstate = ISL38XX_PSM_POWERSAVE_STATE; 79 80 /* assert the Sleep interrupt in the Device Interrupt Register */ 81 isl38xx_w32_flush(device_base, ISL38XX_DEV_INT_SLEEP, 82 ISL38XX_DEV_INT_REG); 83 udelay(ISL38XX_WRITEIO_DELAY); 84 } 85 86 void 87 isl38xx_handle_wakeup(isl38xx_control_block *control_block, 88 int *powerstate, void __iomem *device_base) 89 { 90 /* device is in active state, update the powerstate flag */ 91 *powerstate = ISL38XX_PSM_ACTIVE_STATE; 92 93 /* now check whether there are frames pending for the card */ 94 if (!isl38xx_in_queue(control_block, ISL38XX_CB_TX_DATA_LQ) 95 && !isl38xx_in_queue(control_block, ISL38XX_CB_TX_MGMTQ)) 96 return; 97 98 #if VERBOSE > SHOW_ERROR_MESSAGES 99 DEBUG(SHOW_ANYTHING, "Wake up handler trigger the device\n"); 100 #endif 101 102 /* either data or management transmit queue has a frame pending 103 * trigger the device by setting the Update bit in the Device Int reg */ 104 isl38xx_w32_flush(device_base, ISL38XX_DEV_INT_UPDATE, 105 ISL38XX_DEV_INT_REG); 106 udelay(ISL38XX_WRITEIO_DELAY); 107 } 108 109 void 110 isl38xx_trigger_device(int asleep, void __iomem *device_base) 111 { 112 u32 reg; 113 114 #if VERBOSE > SHOW_ERROR_MESSAGES 115 u32 counter = 0; 116 struct timeval current_time; 117 DEBUG(SHOW_FUNCTION_CALLS, "isl38xx trigger device\n"); 118 #endif 119 120 /* check whether the device is in power save mode */ 121 if (asleep) { 122 /* device is in powersave, trigger the device for wakeup */ 123 #if VERBOSE > SHOW_ERROR_MESSAGES 124 do_gettimeofday(&current_time); 125 DEBUG(SHOW_TRACING, "%08li.%08li Device wakeup triggered\n", 126 current_time.tv_sec, (long)current_time.tv_usec); 127 128 DEBUG(SHOW_TRACING, "%08li.%08li Device register read %08x\n", 129 current_time.tv_sec, (long)current_time.tv_usec, 130 readl(device_base + ISL38XX_CTRL_STAT_REG)); 131 #endif 132 133 reg = readl(device_base + ISL38XX_INT_IDENT_REG); 134 if (reg == 0xabadface) { 135 #if VERBOSE > SHOW_ERROR_MESSAGES 136 do_gettimeofday(&current_time); 137 DEBUG(SHOW_TRACING, 138 "%08li.%08li Device register abadface\n", 139 current_time.tv_sec, (long)current_time.tv_usec); 140 #endif 141 /* read the Device Status Register until Sleepmode bit is set */ 142 while (reg = readl(device_base + ISL38XX_CTRL_STAT_REG), 143 (reg & ISL38XX_CTRL_STAT_SLEEPMODE) == 0) { 144 udelay(ISL38XX_WRITEIO_DELAY); 145 #if VERBOSE > SHOW_ERROR_MESSAGES 146 counter++; 147 #endif 148 } 149 150 #if VERBOSE > SHOW_ERROR_MESSAGES 151 DEBUG(SHOW_TRACING, 152 "%08li.%08li Device register read %08x\n", 153 current_time.tv_sec, (long)current_time.tv_usec, 154 readl(device_base + ISL38XX_CTRL_STAT_REG)); 155 do_gettimeofday(&current_time); 156 DEBUG(SHOW_TRACING, 157 "%08li.%08li Device asleep counter %i\n", 158 current_time.tv_sec, (long)current_time.tv_usec, 159 counter); 160 #endif 161 } 162 /* assert the Wakeup interrupt in the Device Interrupt Register */ 163 isl38xx_w32_flush(device_base, ISL38XX_DEV_INT_WAKEUP, 164 ISL38XX_DEV_INT_REG); 165 166 #if VERBOSE > SHOW_ERROR_MESSAGES 167 udelay(ISL38XX_WRITEIO_DELAY); 168 169 /* perform another read on the Device Status Register */ 170 reg = readl(device_base + ISL38XX_CTRL_STAT_REG); 171 do_gettimeofday(&current_time); 172 DEBUG(SHOW_TRACING, "%08li.%08li Device register read %08x\n", 173 current_time.tv_sec, (long)current_time.tv_usec, reg); 174 #endif 175 } else { 176 /* device is (still) awake */ 177 #if VERBOSE > SHOW_ERROR_MESSAGES 178 DEBUG(SHOW_TRACING, "Device is in active state\n"); 179 #endif 180 /* trigger the device by setting the Update bit in the Device Int reg */ 181 182 isl38xx_w32_flush(device_base, ISL38XX_DEV_INT_UPDATE, 183 ISL38XX_DEV_INT_REG); 184 } 185 } 186 187 void 188 isl38xx_interface_reset(void __iomem *device_base, dma_addr_t host_address) 189 { 190 #if VERBOSE > SHOW_ERROR_MESSAGES 191 DEBUG(SHOW_FUNCTION_CALLS, "isl38xx_interface_reset\n"); 192 #endif 193 194 /* load the address of the control block in the device */ 195 isl38xx_w32_flush(device_base, host_address, ISL38XX_CTRL_BLK_BASE_REG); 196 udelay(ISL38XX_WRITEIO_DELAY); 197 198 /* set the reset bit in the Device Interrupt Register */ 199 isl38xx_w32_flush(device_base, ISL38XX_DEV_INT_RESET, ISL38XX_DEV_INT_REG); 200 udelay(ISL38XX_WRITEIO_DELAY); 201 202 /* enable the interrupt for detecting initialization */ 203 204 /* Note: Do not enable other interrupts here. We want the 205 * device to have come up first 100% before allowing any other 206 * interrupts. */ 207 isl38xx_w32_flush(device_base, ISL38XX_INT_IDENT_INIT, ISL38XX_INT_EN_REG); 208 udelay(ISL38XX_WRITEIO_DELAY); /* allow complete full reset */ 209 } 210 211 void 212 isl38xx_enable_common_interrupts(void __iomem *device_base) 213 { 214 u32 reg; 215 216 reg = ISL38XX_INT_IDENT_UPDATE | ISL38XX_INT_IDENT_SLEEP | 217 ISL38XX_INT_IDENT_WAKEUP; 218 isl38xx_w32_flush(device_base, reg, ISL38XX_INT_EN_REG); 219 udelay(ISL38XX_WRITEIO_DELAY); 220 } 221 222 int 223 isl38xx_in_queue(isl38xx_control_block *cb, int queue) 224 { 225 const s32 delta = (le32_to_cpu(cb->driver_curr_frag[queue]) - 226 le32_to_cpu(cb->device_curr_frag[queue])); 227 228 /* determine the amount of fragments in the queue depending on the type 229 * of the queue, either transmit or receive */ 230 231 BUG_ON(delta < 0); /* driver ptr must be ahead of device ptr */ 232 233 switch (queue) { 234 /* send queues */ 235 case ISL38XX_CB_TX_MGMTQ: 236 BUG_ON(delta > ISL38XX_CB_MGMT_QSIZE); 237 238 case ISL38XX_CB_TX_DATA_LQ: 239 case ISL38XX_CB_TX_DATA_HQ: 240 BUG_ON(delta > ISL38XX_CB_TX_QSIZE); 241 return delta; 242 243 /* receive queues */ 244 case ISL38XX_CB_RX_MGMTQ: 245 BUG_ON(delta > ISL38XX_CB_MGMT_QSIZE); 246 return ISL38XX_CB_MGMT_QSIZE - delta; 247 248 case ISL38XX_CB_RX_DATA_LQ: 249 case ISL38XX_CB_RX_DATA_HQ: 250 BUG_ON(delta > ISL38XX_CB_RX_QSIZE); 251 return ISL38XX_CB_RX_QSIZE - delta; 252 } 253 BUG(); 254 return 0; 255 }
1 2 /* 3 * Copyright (C) 2002 Intersil Americas Inc. 4 * Copyright (C) 2003 Herbert Valerio Riedel <hvr@gnu.org> 5 * Copyright (C) 2003 Luis R. Rodriguez <mcgrof@ruslug.rutgers.edu> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, see <http://www.gnu.org/licenses/>. 18 * 19 */ 20 21 #include <linux/hardirq.h> 22 #include <linux/module.h> 23 #include <linux/slab.h> 24 25 #include <linux/netdevice.h> 26 #include <linux/ethtool.h> 27 #include <linux/pci.h> 28 #include <linux/sched.h> 29 #include <linux/etherdevice.h> 30 #include <linux/delay.h> 31 #include <linux/if_arp.h> 32 33 #include <asm/io.h> 34 35 #include "prismcompat.h" 36 #include "isl_38xx.h" 37 #include "isl_ioctl.h" 38 #include "islpci_dev.h" 39 #include "islpci_mgt.h" 40 #include "islpci_eth.h" 41 #include "oid_mgt.h" 42 43 #define ISL3877_IMAGE_FILE "isl3877" 44 #define ISL3886_IMAGE_FILE "isl3886" 45 #define ISL3890_IMAGE_FILE "isl3890" 46 MODULE_FIRMWARE(ISL3877_IMAGE_FILE); 47 MODULE_FIRMWARE(ISL3886_IMAGE_FILE); 48 MODULE_FIRMWARE(ISL3890_IMAGE_FILE); 49 50 static int prism54_bring_down(islpci_private *); 51 static int islpci_alloc_memory(islpci_private *); 52 53 /* Temporary dummy MAC address to use until firmware is loaded. 54 * The idea there is that some tools (such as nameif) may query 55 * the MAC address before the netdev is 'open'. By using a valid 56 * OUI prefix, they can process the netdev properly. 57 * Of course, this is not the final/real MAC address. It doesn't 58 * matter, as you are suppose to be able to change it anytime via 59 * ndev->set_mac_address. Jean II */ 60 static const unsigned char dummy_mac[6] = { 0x00, 0x30, 0xB4, 0x00, 0x00, 0x00 }; 61 62 static int 63 isl_upload_firmware(islpci_private *priv) 64 { 65 u32 reg, rc; 66 void __iomem *device_base = priv->device_base; 67 68 /* clear the RAMBoot and the Reset bit */ 69 reg = readl(device_base + ISL38XX_CTRL_STAT_REG); 70 reg &= ~ISL38XX_CTRL_STAT_RESET; 71 reg &= ~ISL38XX_CTRL_STAT_RAMBOOT; 72 writel(reg, device_base + ISL38XX_CTRL_STAT_REG); 73 wmb(); 74 udelay(ISL38XX_WRITEIO_DELAY); 75 76 /* set the Reset bit without reading the register ! */ 77 reg |= ISL38XX_CTRL_STAT_RESET; 78 writel(reg, device_base + ISL38XX_CTRL_STAT_REG); 79 wmb(); 80 udelay(ISL38XX_WRITEIO_DELAY); 81 82 /* clear the Reset bit */ 83 reg &= ~ISL38XX_CTRL_STAT_RESET; 84 writel(reg, device_base + ISL38XX_CTRL_STAT_REG); 85 wmb(); 86 87 /* wait a while for the device to reboot */ 88 mdelay(50); 89 90 { 91 const struct firmware *fw_entry = NULL; 92 long fw_len; 93 const u32 *fw_ptr; 94 95 rc = request_firmware(&fw_entry, priv->firmware, PRISM_FW_PDEV); 96 if (rc) { 97 printk(KERN_ERR 98 "%s: request_firmware() failed for '%s'\n", 99 "prism54", priv->firmware); 100 return rc; 101 } 102 /* prepare the Direct Memory Base register */ 103 reg = ISL38XX_DEV_FIRMWARE_ADDRES; 104 105 fw_ptr = (u32 *) fw_entry->data; 106 fw_len = fw_entry->size; 107 108 if (fw_len % 4) { 109 printk(KERN_ERR 110 "%s: firmware '%s' size is not multiple of 32bit, aborting!\n", 111 "prism54", priv->firmware); 112 release_firmware(fw_entry); 113 return -EILSEQ; /* Illegal byte sequence */; 114 } 115 116 while (fw_len > 0) { 117 long _fw_len = 118 (fw_len > 119 ISL38XX_MEMORY_WINDOW_SIZE) ? 120 ISL38XX_MEMORY_WINDOW_SIZE : fw_len; 121 u32 __iomem *dev_fw_ptr = device_base + ISL38XX_DIRECT_MEM_WIN; 122 123 /* set the card's base address for writing the data */ 124 isl38xx_w32_flush(device_base, reg, 125 ISL38XX_DIR_MEM_BASE_REG); 126 wmb(); /* be paranoid */ 127 128 /* increment the write address for next iteration */ 129 reg += _fw_len; 130 fw_len -= _fw_len; 131 132 /* write the data to the Direct Memory Window 32bit-wise */ 133 /* memcpy_toio() doesn't guarantee 32bit writes :-| */ 134 while (_fw_len > 0) { 135 /* use non-swapping writel() */ 136 __raw_writel(*fw_ptr, dev_fw_ptr); 137 fw_ptr++, dev_fw_ptr++; 138 _fw_len -= 4; 139 } 140 141 /* flush PCI posting */ 142 (void) readl(device_base + ISL38XX_PCI_POSTING_FLUSH); 143 wmb(); /* be paranoid again */ 144 145 BUG_ON(_fw_len != 0); 146 } 147 148 BUG_ON(fw_len != 0); 149 150 /* Firmware version is at offset 40 (also for "newmac") */ 151 printk(KERN_DEBUG "%s: firmware version: %.8s\n", 152 priv->ndev->name, fw_entry->data + 40); 153 154 release_firmware(fw_entry); 155 } 156 157 /* now reset the device 158 * clear the Reset & ClkRun bit, set the RAMBoot bit */ 159 reg = readl(device_base + ISL38XX_CTRL_STAT_REG); 160 reg &= ~ISL38XX_CTRL_STAT_CLKRUN; 161 reg &= ~ISL38XX_CTRL_STAT_RESET; 162 reg |= ISL38XX_CTRL_STAT_RAMBOOT; 163 isl38xx_w32_flush(device_base, reg, ISL38XX_CTRL_STAT_REG); 164 wmb(); 165 udelay(ISL38XX_WRITEIO_DELAY); 166 167 /* set the reset bit latches the host override and RAMBoot bits 168 * into the device for operation when the reset bit is reset */ 169 reg |= ISL38XX_CTRL_STAT_RESET; 170 writel(reg, device_base + ISL38XX_CTRL_STAT_REG); 171 /* don't do flush PCI posting here! */ 172 wmb(); 173 udelay(ISL38XX_WRITEIO_DELAY); 174 175 /* clear the reset bit should start the whole circus */ 176 reg &= ~ISL38XX_CTRL_STAT_RESET; 177 writel(reg, device_base + ISL38XX_CTRL_STAT_REG); 178 /* don't do flush PCI posting here! */ 179 wmb(); 180 udelay(ISL38XX_WRITEIO_DELAY); 181 182 return 0; 183 } 184 185 /****************************************************************************** 186 Device Interrupt Handler 187 ******************************************************************************/ 188 189 irqreturn_t 190 islpci_interrupt(int irq, void *config) 191 { 192 u32 reg; 193 islpci_private *priv = config; 194 struct net_device *ndev = priv->ndev; 195 void __iomem *device = priv->device_base; 196 int powerstate = ISL38XX_PSM_POWERSAVE_STATE; 197 198 /* lock the interrupt handler */ 199 spin_lock(&priv->slock); 200 201 /* received an interrupt request on a shared IRQ line 202 * first check whether the device is in sleep mode */ 203 reg = readl(device + ISL38XX_CTRL_STAT_REG); 204 if (reg & ISL38XX_CTRL_STAT_SLEEPMODE) 205 /* device is in sleep mode, IRQ was generated by someone else */ 206 { 207 #if VERBOSE > SHOW_ERROR_MESSAGES 208 DEBUG(SHOW_TRACING, "Assuming someone else called the IRQ\n"); 209 #endif 210 spin_unlock(&priv->slock); 211 return IRQ_NONE; 212 } 213 214 215 /* check whether there is any source of interrupt on the device */ 216 reg = readl(device + ISL38XX_INT_IDENT_REG); 217 218 /* also check the contents of the Interrupt Enable Register, because this 219 * will filter out interrupt sources from other devices on the same irq ! */ 220 reg &= readl(device + ISL38XX_INT_EN_REG); 221 reg &= ISL38XX_INT_SOURCES; 222 223 if (reg != 0) { 224 if (islpci_get_state(priv) != PRV_STATE_SLEEP) 225 powerstate = ISL38XX_PSM_ACTIVE_STATE; 226 227 /* reset the request bits in the Identification register */ 228 isl38xx_w32_flush(device, reg, ISL38XX_INT_ACK_REG); 229 230 #if VERBOSE > SHOW_ERROR_MESSAGES 231 DEBUG(SHOW_FUNCTION_CALLS, 232 "IRQ: Identification register 0x%p 0x%x\n", device, reg); 233 #endif 234 235 /* check for each bit in the register separately */ 236 if (reg & ISL38XX_INT_IDENT_UPDATE) { 237 #if VERBOSE > SHOW_ERROR_MESSAGES 238 /* Queue has been updated */ 239 DEBUG(SHOW_TRACING, "IRQ: Update flag\n"); 240 241 DEBUG(SHOW_QUEUE_INDEXES, 242 "CB drv Qs: [%i][%i][%i][%i][%i][%i]\n", 243 le32_to_cpu(priv->control_block-> 244 driver_curr_frag[0]), 245 le32_to_cpu(priv->control_block-> 246 driver_curr_frag[1]), 247 le32_to_cpu(priv->control_block-> 248 driver_curr_frag[2]), 249 le32_to_cpu(priv->control_block-> 250 driver_curr_frag[3]), 251 le32_to_cpu(priv->control_block-> 252 driver_curr_frag[4]), 253 le32_to_cpu(priv->control_block-> 254 driver_curr_frag[5]) 255 ); 256 257 DEBUG(SHOW_QUEUE_INDEXES, 258 "CB dev Qs: [%i][%i][%i][%i][%i][%i]\n", 259 le32_to_cpu(priv->control_block-> 260 device_curr_frag[0]), 261 le32_to_cpu(priv->control_block-> 262 device_curr_frag[1]), 263 le32_to_cpu(priv->control_block-> 264 device_curr_frag[2]), 265 le32_to_cpu(priv->control_block-> 266 device_curr_frag[3]), 267 le32_to_cpu(priv->control_block-> 268 device_curr_frag[4]), 269 le32_to_cpu(priv->control_block-> 270 device_curr_frag[5]) 271 ); 272 #endif 273 274 /* cleanup the data low transmit queue */ 275 islpci_eth_cleanup_transmit(priv, priv->control_block); 276 277 /* device is in active state, update the 278 * powerstate flag if necessary */ 279 powerstate = ISL38XX_PSM_ACTIVE_STATE; 280 281 /* check all three queues in priority order 282 * call the PIMFOR receive function until the 283 * queue is empty */ 284 if (isl38xx_in_queue(priv->control_block, 285 ISL38XX_CB_RX_MGMTQ) != 0) { 286 #if VERBOSE > SHOW_ERROR_MESSAGES 287 DEBUG(SHOW_TRACING, 288 "Received frame in Management Queue\n"); 289 #endif 290 islpci_mgt_receive(ndev); 291 292 islpci_mgt_cleanup_transmit(ndev); 293 294 /* Refill slots in receive queue */ 295 islpci_mgmt_rx_fill(ndev); 296 297 /* no need to trigger the device, next 298 islpci_mgt_transaction does it */ 299 } 300 301 while (isl38xx_in_queue(priv->control_block, 302 ISL38XX_CB_RX_DATA_LQ) != 0) { 303 #if VERBOSE > SHOW_ERROR_MESSAGES 304 DEBUG(SHOW_TRACING, 305 "Received frame in Data Low Queue\n"); 306 #endif 307 islpci_eth_receive(priv); 308 } 309 310 /* check whether the data transmit queues were full */ 311 if (priv->data_low_tx_full) { 312 /* check whether the transmit is not full anymore */ 313 if (ISL38XX_CB_TX_QSIZE - 314 isl38xx_in_queue(priv->control_block, 315 ISL38XX_CB_TX_DATA_LQ) >= 316 ISL38XX_MIN_QTHRESHOLD) { 317 /* nope, the driver is ready for more network frames */ 318 netif_wake_queue(priv->ndev); 319 320 /* reset the full flag */ 321 priv->data_low_tx_full = 0; 322 } 323 } 324 } 325 326 if (reg & ISL38XX_INT_IDENT_INIT) { 327 /* Device has been initialized */ 328 #if VERBOSE > SHOW_ERROR_MESSAGES 329 DEBUG(SHOW_TRACING, 330 "IRQ: Init flag, device initialized\n"); 331 #endif 332 wake_up(&priv->reset_done); 333 } 334 335 if (reg & ISL38XX_INT_IDENT_SLEEP) { 336 /* Device intends to move to powersave state */ 337 #if VERBOSE > SHOW_ERROR_MESSAGES 338 DEBUG(SHOW_TRACING, "IRQ: Sleep flag\n"); 339 #endif 340 isl38xx_handle_sleep_request(priv->control_block, 341 &powerstate, 342 priv->device_base); 343 } 344 345 if (reg & ISL38XX_INT_IDENT_WAKEUP) { 346 /* Device has been woken up to active state */ 347 #if VERBOSE > SHOW_ERROR_MESSAGES 348 DEBUG(SHOW_TRACING, "IRQ: Wakeup flag\n"); 349 #endif 350 351 isl38xx_handle_wakeup(priv->control_block, 352 &powerstate, priv->device_base); 353 } 354 } else { 355 #if VERBOSE > SHOW_ERROR_MESSAGES 356 DEBUG(SHOW_TRACING, "Assuming someone else called the IRQ\n"); 357 #endif 358 spin_unlock(&priv->slock); 359 return IRQ_NONE; 360 } 361 362 /* sleep -> ready */ 363 if (islpci_get_state(priv) == PRV_STATE_SLEEP 364 && powerstate == ISL38XX_PSM_ACTIVE_STATE) 365 islpci_set_state(priv, PRV_STATE_READY); 366 367 /* !sleep -> sleep */ 368 if (islpci_get_state(priv) != PRV_STATE_SLEEP 369 && powerstate == ISL38XX_PSM_POWERSAVE_STATE) 370 islpci_set_state(priv, PRV_STATE_SLEEP); 371 372 /* unlock the interrupt handler */ 373 spin_unlock(&priv->slock); 374 375 return IRQ_HANDLED; 376 } 377 378 /****************************************************************************** 379 Network Interface Control & Statistical functions 380 ******************************************************************************/ 381 static int 382 islpci_open(struct net_device *ndev) 383 { 384 u32 rc; 385 islpci_private *priv = netdev_priv(ndev); 386 387 /* reset data structures, upload firmware and reset device */ 388 rc = islpci_reset(priv,1); 389 if (rc) { 390 prism54_bring_down(priv); 391 return rc; /* Returns informative message */ 392 } 393 394 netif_start_queue(ndev); 395 396 /* Turn off carrier if in STA or Ad-hoc mode. It will be turned on 397 * once the firmware receives a trap of being associated 398 * (GEN_OID_LINKSTATE). In other modes (AP or WDS or monitor) we 399 * should just leave the carrier on as its expected the firmware 400 * won't send us a trigger. */ 401 if (priv->iw_mode == IW_MODE_INFRA || priv->iw_mode == IW_MODE_ADHOC) 402 netif_carrier_off(ndev); 403 else 404 netif_carrier_on(ndev); 405 406 return 0; 407 } 408 409 static int 410 islpci_close(struct net_device *ndev) 411 { 412 islpci_private *priv = netdev_priv(ndev); 413 414 printk(KERN_DEBUG "%s: islpci_close ()\n", ndev->name); 415 416 netif_stop_queue(ndev); 417 418 return prism54_bring_down(priv); 419 } 420 421 static int 422 prism54_bring_down(islpci_private *priv) 423 { 424 void __iomem *device_base = priv->device_base; 425 u32 reg; 426 /* we are going to shutdown the device */ 427 islpci_set_state(priv, PRV_STATE_PREBOOT); 428 429 /* disable all device interrupts in case they weren't */ 430 isl38xx_disable_interrupts(priv->device_base); 431 432 /* For safety reasons, we may want to ensure that no DMA transfer is 433 * currently in progress by emptying the TX and RX queues. */ 434 435 /* wait until interrupts have finished executing on other CPUs */ 436 synchronize_irq(priv->pdev->irq); 437 438 reg = readl(device_base + ISL38XX_CTRL_STAT_REG); 439 reg &= ~(ISL38XX_CTRL_STAT_RESET | ISL38XX_CTRL_STAT_RAMBOOT); 440 writel(reg, device_base + ISL38XX_CTRL_STAT_REG); 441 wmb(); 442 udelay(ISL38XX_WRITEIO_DELAY); 443 444 reg |= ISL38XX_CTRL_STAT_RESET; 445 writel(reg, device_base + ISL38XX_CTRL_STAT_REG); 446 wmb(); 447 udelay(ISL38XX_WRITEIO_DELAY); 448 449 /* clear the Reset bit */ 450 reg &= ~ISL38XX_CTRL_STAT_RESET; 451 writel(reg, device_base + ISL38XX_CTRL_STAT_REG); 452 wmb(); 453 454 /* wait a while for the device to reset */ 455 schedule_timeout_uninterruptible(msecs_to_jiffies(50)); 456 457 return 0; 458 } 459 460 static int 461 islpci_upload_fw(islpci_private *priv) 462 { 463 islpci_state_t old_state; 464 u32 rc; 465 466 old_state = islpci_set_state(priv, PRV_STATE_BOOT); 467 468 printk(KERN_DEBUG "%s: uploading firmware...\n", priv->ndev->name); 469 470 rc = isl_upload_firmware(priv); 471 if (rc) { 472 /* error uploading the firmware */ 473 printk(KERN_ERR "%s: could not upload firmware ('%s')\n", 474 priv->ndev->name, priv->firmware); 475 476 islpci_set_state(priv, old_state); 477 return rc; 478 } 479 480 printk(KERN_DEBUG "%s: firmware upload complete\n", 481 priv->ndev->name); 482 483 islpci_set_state(priv, PRV_STATE_POSTBOOT); 484 485 return 0; 486 } 487 488 static int 489 islpci_reset_if(islpci_private *priv) 490 { 491 long remaining; 492 int result = -ETIME; 493 int count; 494 495 DEFINE_WAIT(wait); 496 prepare_to_wait(&priv->reset_done, &wait, TASK_UNINTERRUPTIBLE); 497 498 /* now the last step is to reset the interface */ 499 isl38xx_interface_reset(priv->device_base, priv->device_host_address); 500 islpci_set_state(priv, PRV_STATE_PREINIT); 501 502 for(count = 0; count < 2 && result; count++) { 503 /* The software reset acknowledge needs about 220 msec here. 504 * Be conservative and wait for up to one second. */ 505 506 remaining = schedule_timeout_uninterruptible(HZ); 507 508 if(remaining > 0) { 509 result = 0; 510 break; 511 } 512 513 /* If we're here it's because our IRQ hasn't yet gone through. 514 * Retry a bit more... 515 */ 516 printk(KERN_ERR "%s: no 'reset complete' IRQ seen - retrying\n", 517 priv->ndev->name); 518 } 519 520 finish_wait(&priv->reset_done, &wait); 521 522 if (result) { 523 printk(KERN_ERR "%s: interface reset failure\n", priv->ndev->name); 524 return result; 525 } 526 527 islpci_set_state(priv, PRV_STATE_INIT); 528 529 /* Now that the device is 100% up, let's allow 530 * for the other interrupts -- 531 * NOTE: this is not *yet* true since we've only allowed the 532 * INIT interrupt on the IRQ line. We can perhaps poll 533 * the IRQ line until we know for sure the reset went through */ 534 isl38xx_enable_common_interrupts(priv->device_base); 535 536 down_write(&priv->mib_sem); 537 result = mgt_commit(priv); 538 if (result) { 539 printk(KERN_ERR "%s: interface reset failure\n", priv->ndev->name); 540 up_write(&priv->mib_sem); 541 return result; 542 } 543 up_write(&priv->mib_sem); 544 545 islpci_set_state(priv, PRV_STATE_READY); 546 547 printk(KERN_DEBUG "%s: interface reset complete\n", priv->ndev->name); 548 return 0; 549 } 550 551 int 552 islpci_reset(islpci_private *priv, int reload_firmware) 553 { 554 isl38xx_control_block *cb = /* volatile not needed */ 555 (isl38xx_control_block *) priv->control_block; 556 unsigned counter; 557 int rc; 558 559 if (reload_firmware) 560 islpci_set_state(priv, PRV_STATE_PREBOOT); 561 else 562 islpci_set_state(priv, PRV_STATE_POSTBOOT); 563 564 printk(KERN_DEBUG "%s: resetting device...\n", priv->ndev->name); 565 566 /* disable all device interrupts in case they weren't */ 567 isl38xx_disable_interrupts(priv->device_base); 568 569 /* flush all management queues */ 570 priv->index_mgmt_tx = 0; 571 priv->index_mgmt_rx = 0; 572 573 /* clear the indexes in the frame pointer */ 574 for (counter = 0; counter < ISL38XX_CB_QCOUNT; counter++) { 575 cb->driver_curr_frag[counter] = cpu_to_le32(0); 576 cb->device_curr_frag[counter] = cpu_to_le32(0); 577 } 578 579 /* reset the mgmt receive queue */ 580 for (counter = 0; counter < ISL38XX_CB_MGMT_QSIZE; counter++) { 581 isl38xx_fragment *frag = &cb->rx_data_mgmt[counter]; 582 frag->size = cpu_to_le16(MGMT_FRAME_SIZE); 583 frag->flags = 0; 584 frag->address = cpu_to_le32(priv->mgmt_rx[counter].pci_addr); 585 } 586 587 for (counter = 0; counter < ISL38XX_CB_RX_QSIZE; counter++) { 588 cb->rx_data_low[counter].address = 589 cpu_to_le32((u32) priv->pci_map_rx_address[counter]); 590 } 591 592 /* since the receive queues are filled with empty fragments, now we can 593 * set the corresponding indexes in the Control Block */ 594 priv->control_block->driver_curr_frag[ISL38XX_CB_RX_DATA_LQ] = 595 cpu_to_le32(ISL38XX_CB_RX_QSIZE); 596 priv->control_block->driver_curr_frag[ISL38XX_CB_RX_MGMTQ] = 597 cpu_to_le32(ISL38XX_CB_MGMT_QSIZE); 598 599 /* reset the remaining real index registers and full flags */ 600 priv->free_data_rx = 0; 601 priv->free_data_tx = 0; 602 priv->data_low_tx_full = 0; 603 604 if (reload_firmware) { /* Should we load the firmware ? */ 605 /* now that the data structures are cleaned up, upload 606 * firmware and reset interface */ 607 rc = islpci_upload_fw(priv); 608 if (rc) { 609 printk(KERN_ERR "%s: islpci_reset: failure\n", 610 priv->ndev->name); 611 return rc; 612 } 613 } 614 615 /* finally reset interface */ 616 rc = islpci_reset_if(priv); 617 if (rc) 618 printk(KERN_ERR "prism54: Your card/socket may be faulty, or IRQ line too busy :(\n"); 619 return rc; 620 } 621 622 /****************************************************************************** 623 Network device configuration functions 624 ******************************************************************************/ 625 static int 626 islpci_alloc_memory(islpci_private *priv) 627 { 628 int counter; 629 630 #if VERBOSE > SHOW_ERROR_MESSAGES 631 printk(KERN_DEBUG "islpci_alloc_memory\n"); 632 #endif 633 634 /* remap the PCI device base address to accessible */ 635 if (!(priv->device_base = 636 ioremap(pci_resource_start(priv->pdev, 0), 637 ISL38XX_PCI_MEM_SIZE))) { 638 /* error in remapping the PCI device memory address range */ 639 printk(KERN_ERR "PCI memory remapping failed\n"); 640 return -1; 641 } 642 643 /* memory layout for consistent DMA region: 644 * 645 * Area 1: Control Block for the device interface 646 * Area 2: Power Save Mode Buffer for temporary frame storage. Be aware that 647 * the number of supported stations in the AP determines the minimal 648 * size of the buffer ! 649 */ 650 651 /* perform the allocation */ 652 priv->driver_mem_address = pci_alloc_consistent(priv->pdev, 653 HOST_MEM_BLOCK, 654 &priv-> 655 device_host_address); 656 657 if (!priv->driver_mem_address) { 658 /* error allocating the block of PCI memory */ 659 printk(KERN_ERR "%s: could not allocate DMA memory, aborting!", 660 "prism54"); 661 return -1; 662 } 663 664 /* assign the Control Block to the first address of the allocated area */ 665 priv->control_block = 666 (isl38xx_control_block *) priv->driver_mem_address; 667 668 /* set the Power Save Buffer pointer directly behind the CB */ 669 priv->device_psm_buffer = 670 priv->device_host_address + CONTROL_BLOCK_SIZE; 671 672 /* make sure all buffer pointers are initialized */ 673 for (counter = 0; counter < ISL38XX_CB_QCOUNT; counter++) { 674 priv->control_block->driver_curr_frag[counter] = cpu_to_le32(0); 675 priv->control_block->device_curr_frag[counter] = cpu_to_le32(0); 676 } 677 678 priv->index_mgmt_rx = 0; 679 memset(priv->mgmt_rx, 0, sizeof(priv->mgmt_rx)); 680 memset(priv->mgmt_tx, 0, sizeof(priv->mgmt_tx)); 681 682 /* allocate rx queue for management frames */ 683 if (islpci_mgmt_rx_fill(priv->ndev) < 0) 684 goto out_free; 685 686 /* now get the data rx skb's */ 687 memset(priv->data_low_rx, 0, sizeof (priv->data_low_rx)); 688 memset(priv->pci_map_rx_address, 0, sizeof (priv->pci_map_rx_address)); 689 690 for (counter = 0; counter < ISL38XX_CB_RX_QSIZE; counter++) { 691 struct sk_buff *skb; 692 693 /* allocate an sk_buff for received data frames storage 694 * each frame on receive size consists of 1 fragment 695 * include any required allignment operations */ 696 if (!(skb = dev_alloc_skb(MAX_FRAGMENT_SIZE_RX + 2))) { 697 /* error allocating an sk_buff structure elements */ 698 printk(KERN_ERR "Error allocating skb.\n"); 699 skb = NULL; 700 goto out_free; 701 } 702 skb_reserve(skb, (4 - (long) skb->data) & 0x03); 703 /* add the new allocated sk_buff to the buffer array */ 704 priv->data_low_rx[counter] = skb; 705 706 /* map the allocated skb data area to pci */ 707 priv->pci_map_rx_address[counter] = 708 pci_map_single(priv->pdev, (void *) skb->data, 709 MAX_FRAGMENT_SIZE_RX + 2, 710 PCI_DMA_FROMDEVICE); 711 if (!priv->pci_map_rx_address[counter]) { 712 /* error mapping the buffer to device 713 accessible memory address */ 714 printk(KERN_ERR "failed to map skb DMA'able\n"); 715 goto out_free; 716 } 717 } 718 719 prism54_acl_init(&priv->acl); 720 prism54_wpa_bss_ie_init(priv); 721 if (mgt_init(priv)) 722 goto out_free; 723 724 return 0; 725 out_free: 726 islpci_free_memory(priv); 727 return -1; 728 } 729 730 int 731 islpci_free_memory(islpci_private *priv) 732 { 733 int counter; 734 735 if (priv->device_base) 736 iounmap(priv->device_base); 737 priv->device_base = NULL; 738 739 /* free consistent DMA area... */ 740 if (priv->driver_mem_address) 741 pci_free_consistent(priv->pdev, HOST_MEM_BLOCK, 742 priv->driver_mem_address, 743 priv->device_host_address); 744 745 /* clear some dangling pointers */ 746 priv->driver_mem_address = NULL; 747 priv->device_host_address = 0; 748 priv->device_psm_buffer = 0; 749 priv->control_block = NULL; 750 751 /* clean up mgmt rx buffers */ 752 for (counter = 0; counter < ISL38XX_CB_MGMT_QSIZE; counter++) { 753 struct islpci_membuf *buf = &priv->mgmt_rx[counter]; 754 if (buf->pci_addr) 755 pci_unmap_single(priv->pdev, buf->pci_addr, 756 buf->size, PCI_DMA_FROMDEVICE); 757 buf->pci_addr = 0; 758 kfree(buf->mem); 759 buf->size = 0; 760 buf->mem = NULL; 761 } 762 763 /* clean up data rx buffers */ 764 for (counter = 0; counter < ISL38XX_CB_RX_QSIZE; counter++) { 765 if (priv->pci_map_rx_address[counter]) 766 pci_unmap_single(priv->pdev, 767 priv->pci_map_rx_address[counter], 768 MAX_FRAGMENT_SIZE_RX + 2, 769 PCI_DMA_FROMDEVICE); 770 priv->pci_map_rx_address[counter] = 0; 771 772 if (priv->data_low_rx[counter]) 773 dev_kfree_skb(priv->data_low_rx[counter]); 774 priv->data_low_rx[counter] = NULL; 775 } 776 777 /* Free the access control list and the WPA list */ 778 prism54_acl_clean(&priv->acl); 779 prism54_wpa_bss_ie_clean(priv); 780 mgt_clean(priv); 781 782 return 0; 783 } 784 785 #if 0 786 static void 787 islpci_set_multicast_list(struct net_device *dev) 788 { 789 /* put device into promisc mode and let network layer handle it */ 790 } 791 #endif 792 793 static void islpci_ethtool_get_drvinfo(struct net_device *dev, 794 struct ethtool_drvinfo *info) 795 { 796 strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 797 strlcpy(info->version, DRV_VERSION, sizeof(info->version)); 798 } 799 800 static const struct ethtool_ops islpci_ethtool_ops = { 801 .get_drvinfo = islpci_ethtool_get_drvinfo, 802 }; 803 804 static const struct net_device_ops islpci_netdev_ops = { 805 .ndo_open = islpci_open, 806 .ndo_stop = islpci_close, 807 .ndo_start_xmit = islpci_eth_transmit, 808 .ndo_tx_timeout = islpci_eth_tx_timeout, 809 .ndo_set_mac_address = prism54_set_mac_address, 810 .ndo_change_mtu = eth_change_mtu, 811 .ndo_validate_addr = eth_validate_addr, 812 }; 813 814 static struct device_type wlan_type = { 815 .name = "wlan", 816 }; 817 818 struct net_device * 819 islpci_setup(struct pci_dev *pdev) 820 { 821 islpci_private *priv; 822 struct net_device *ndev = alloc_etherdev(sizeof (islpci_private)); 823 824 if (!ndev) 825 return ndev; 826 827 pci_set_drvdata(pdev, ndev); 828 SET_NETDEV_DEV(ndev, &pdev->dev); 829 SET_NETDEV_DEVTYPE(ndev, &wlan_type); 830 831 /* setup the structure members */ 832 ndev->base_addr = pci_resource_start(pdev, 0); 833 ndev->irq = pdev->irq; 834 835 /* initialize the function pointers */ 836 ndev->netdev_ops = &islpci_netdev_ops; 837 ndev->wireless_handlers = &prism54_handler_def; 838 ndev->ethtool_ops = &islpci_ethtool_ops; 839 840 /* ndev->set_multicast_list = &islpci_set_multicast_list; */ 841 ndev->addr_len = ETH_ALEN; 842 /* Get a non-zero dummy MAC address for nameif. Jean II */ 843 memcpy(ndev->dev_addr, dummy_mac, ETH_ALEN); 844 845 ndev->watchdog_timeo = ISLPCI_TX_TIMEOUT; 846 847 /* allocate a private device structure to the network device */ 848 priv = netdev_priv(ndev); 849 priv->ndev = ndev; 850 priv->pdev = pdev; 851 priv->monitor_type = ARPHRD_IEEE80211; 852 priv->ndev->type = (priv->iw_mode == IW_MODE_MONITOR) ? 853 priv->monitor_type : ARPHRD_ETHER; 854 855 /* Add pointers to enable iwspy support. */ 856 priv->wireless_data.spy_data = &priv->spy_data; 857 ndev->wireless_data = &priv->wireless_data; 858 859 /* save the start and end address of the PCI memory area */ 860 ndev->mem_start = (unsigned long) priv->device_base; 861 ndev->mem_end = ndev->mem_start + ISL38XX_PCI_MEM_SIZE; 862 863 #if VERBOSE > SHOW_ERROR_MESSAGES 864 DEBUG(SHOW_TRACING, "PCI Memory remapped to 0x%p\n", priv->device_base); 865 #endif 866 867 init_waitqueue_head(&priv->reset_done); 868 869 /* init the queue read locks, process wait counter */ 870 mutex_init(&priv->mgmt_lock); 871 priv->mgmt_received = NULL; 872 init_waitqueue_head(&priv->mgmt_wqueue); 873 mutex_init(&priv->stats_lock); 874 spin_lock_init(&priv->slock); 875 876 /* init state machine with off#1 state */ 877 priv->state = PRV_STATE_OFF; 878 priv->state_off = 1; 879 880 /* initialize workqueue's */ 881 INIT_WORK(&priv->stats_work, prism54_update_stats); 882 priv->stats_timestamp = 0; 883 884 INIT_WORK(&priv->reset_task, islpci_do_reset_and_wake); 885 priv->reset_task_pending = 0; 886 887 /* allocate various memory areas */ 888 if (islpci_alloc_memory(priv)) 889 goto do_free_netdev; 890 891 /* select the firmware file depending on the device id */ 892 switch (pdev->device) { 893 case 0x3877: 894 strcpy(priv->firmware, ISL3877_IMAGE_FILE); 895 break; 896 897 case 0x3886: 898 strcpy(priv->firmware, ISL3886_IMAGE_FILE); 899 break; 900 901 default: 902 strcpy(priv->firmware, ISL3890_IMAGE_FILE); 903 break; 904 } 905 906 if (register_netdev(ndev)) { 907 DEBUG(SHOW_ERROR_MESSAGES, 908 "ERROR: register_netdev() failed\n"); 909 goto do_islpci_free_memory; 910 } 911 912 return ndev; 913 914 do_islpci_free_memory: 915 islpci_free_memory(priv); 916 do_free_netdev: 917 free_netdev(ndev); 918 priv = NULL; 919 return NULL; 920 } 921 922 islpci_state_t 923 islpci_set_state(islpci_private *priv, islpci_state_t new_state) 924 { 925 islpci_state_t old_state; 926 927 /* lock */ 928 old_state = priv->state; 929 930 /* this means either a race condition or some serious error in 931 * the driver code */ 932 switch (new_state) { 933 case PRV_STATE_OFF: 934 priv->state_off++; 935 default: 936 priv->state = new_state; 937 break; 938 939 case PRV_STATE_PREBOOT: 940 /* there are actually many off-states, enumerated by 941 * state_off */ 942 if (old_state == PRV_STATE_OFF) 943 priv->state_off--; 944 945 /* only if hw_unavailable is zero now it means we either 946 * were in off#1 state, or came here from 947 * somewhere else */ 948 if (!priv->state_off) 949 priv->state = new_state; 950 break; 951 } 952 #if 0 953 printk(KERN_DEBUG "%s: state transition %d -> %d (off#%d)\n", 954 priv->ndev->name, old_state, new_state, priv->state_off); 955 #endif 956 957 /* invariants */ 958 BUG_ON(priv->state_off < 0); 959 BUG_ON(priv->state_off && (priv->state != PRV_STATE_OFF)); 960 BUG_ON(!priv->state_off && (priv->state == PRV_STATE_OFF)); 961 962 /* unlock */ 963 return old_state; 964 } 965 966 967 968 969 970 /* LDV_COMMENT_BEGIN_MAIN */ 971 #ifdef LDV_MAIN4_sequence_infinite_withcheck_stateful 972 973 /*###########################################################################*/ 974 975 /*############## Driver Environment Generator 0.2 output ####################*/ 976 977 /*###########################################################################*/ 978 979 980 981 /* 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. */ 982 void ldv_check_final_state(void); 983 984 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result. */ 985 void ldv_check_return_value(int res); 986 987 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result of probe() function. */ 988 void ldv_check_return_value_probe(int res); 989 990 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Initializes the model. */ 991 void ldv_initialize(void); 992 993 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Reinitializes the model between distinct model function calls. */ 994 void ldv_handler_precall(void); 995 996 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Returns arbitrary interger value. */ 997 int nondet_int(void); 998 999 /* LDV_COMMENT_VAR_DECLARE_LDV Special variable for LDV verifier. */ 1000 int LDV_IN_INTERRUPT; 1001 1002 /* LDV_COMMENT_FUNCTION_MAIN Main function for LDV verifier. */ 1003 void ldv_main4_sequence_infinite_withcheck_stateful(void) { 1004 1005 1006 1007 /* LDV_COMMENT_BEGIN_VARIABLE_DECLARATION_PART */ 1008 /*============================= VARIABLE DECLARATION PART =============================*/ 1009 /** STRUCT: struct type: ethtool_ops, struct name: islpci_ethtool_ops **/ 1010 /* content: static void islpci_ethtool_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)*/ 1011 /* LDV_COMMENT_BEGIN_PREP */ 1012 #define ISL3877_IMAGE_FILE "isl3877" 1013 #define ISL3886_IMAGE_FILE "isl3886" 1014 #define ISL3890_IMAGE_FILE "isl3890" 1015 #if VERBOSE > SHOW_ERROR_MESSAGES 1016 #endif 1017 #if VERBOSE > SHOW_ERROR_MESSAGES 1018 #endif 1019 #if VERBOSE > SHOW_ERROR_MESSAGES 1020 #endif 1021 #if VERBOSE > SHOW_ERROR_MESSAGES 1022 #endif 1023 #if VERBOSE > SHOW_ERROR_MESSAGES 1024 #endif 1025 #if VERBOSE > SHOW_ERROR_MESSAGES 1026 #endif 1027 #if VERBOSE > SHOW_ERROR_MESSAGES 1028 #endif 1029 #if VERBOSE > SHOW_ERROR_MESSAGES 1030 #endif 1031 #if VERBOSE > SHOW_ERROR_MESSAGES 1032 #endif 1033 #if VERBOSE > SHOW_ERROR_MESSAGES 1034 #endif 1035 #if 0 1036 #endif 1037 /* LDV_COMMENT_END_PREP */ 1038 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "islpci_ethtool_get_drvinfo" */ 1039 struct net_device * var_group1; 1040 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "islpci_ethtool_get_drvinfo" */ 1041 struct ethtool_drvinfo * var_group2; 1042 /* LDV_COMMENT_BEGIN_PREP */ 1043 #if VERBOSE > SHOW_ERROR_MESSAGES 1044 #endif 1045 #if 0 1046 #endif 1047 /* LDV_COMMENT_END_PREP */ 1048 1049 /** STRUCT: struct type: net_device_ops, struct name: islpci_netdev_ops **/ 1050 /* content: static int islpci_open(struct net_device *ndev)*/ 1051 /* LDV_COMMENT_BEGIN_PREP */ 1052 #define ISL3877_IMAGE_FILE "isl3877" 1053 #define ISL3886_IMAGE_FILE "isl3886" 1054 #define ISL3890_IMAGE_FILE "isl3890" 1055 #if VERBOSE > SHOW_ERROR_MESSAGES 1056 #endif 1057 #if VERBOSE > SHOW_ERROR_MESSAGES 1058 #endif 1059 #if VERBOSE > SHOW_ERROR_MESSAGES 1060 #endif 1061 #if VERBOSE > SHOW_ERROR_MESSAGES 1062 #endif 1063 #if VERBOSE > SHOW_ERROR_MESSAGES 1064 #endif 1065 #if VERBOSE > SHOW_ERROR_MESSAGES 1066 #endif 1067 #if VERBOSE > SHOW_ERROR_MESSAGES 1068 #endif 1069 #if VERBOSE > SHOW_ERROR_MESSAGES 1070 #endif 1071 #if VERBOSE > SHOW_ERROR_MESSAGES 1072 #endif 1073 /* LDV_COMMENT_END_PREP */ 1074 /* LDV_COMMENT_VAR_DECLARE Variable declaration for test return result from function call "islpci_open" */ 1075 static int res_islpci_open_2; 1076 /* LDV_COMMENT_BEGIN_PREP */ 1077 #if VERBOSE > SHOW_ERROR_MESSAGES 1078 #endif 1079 #if 0 1080 #endif 1081 #if VERBOSE > SHOW_ERROR_MESSAGES 1082 #endif 1083 #if 0 1084 #endif 1085 /* LDV_COMMENT_END_PREP */ 1086 /* content: static int islpci_close(struct net_device *ndev)*/ 1087 /* LDV_COMMENT_BEGIN_PREP */ 1088 #define ISL3877_IMAGE_FILE "isl3877" 1089 #define ISL3886_IMAGE_FILE "isl3886" 1090 #define ISL3890_IMAGE_FILE "isl3890" 1091 #if VERBOSE > SHOW_ERROR_MESSAGES 1092 #endif 1093 #if VERBOSE > SHOW_ERROR_MESSAGES 1094 #endif 1095 #if VERBOSE > SHOW_ERROR_MESSAGES 1096 #endif 1097 #if VERBOSE > SHOW_ERROR_MESSAGES 1098 #endif 1099 #if VERBOSE > SHOW_ERROR_MESSAGES 1100 #endif 1101 #if VERBOSE > SHOW_ERROR_MESSAGES 1102 #endif 1103 #if VERBOSE > SHOW_ERROR_MESSAGES 1104 #endif 1105 #if VERBOSE > SHOW_ERROR_MESSAGES 1106 #endif 1107 #if VERBOSE > SHOW_ERROR_MESSAGES 1108 #endif 1109 /* LDV_COMMENT_END_PREP */ 1110 /* LDV_COMMENT_VAR_DECLARE Variable declaration for test return result from function call "islpci_close" */ 1111 static int res_islpci_close_3; 1112 /* LDV_COMMENT_BEGIN_PREP */ 1113 #if VERBOSE > SHOW_ERROR_MESSAGES 1114 #endif 1115 #if 0 1116 #endif 1117 #if VERBOSE > SHOW_ERROR_MESSAGES 1118 #endif 1119 #if 0 1120 #endif 1121 /* LDV_COMMENT_END_PREP */ 1122 1123 /** CALLBACK SECTION request_irq **/ 1124 /* content: irqreturn_t islpci_interrupt(int irq, void *config)*/ 1125 /* LDV_COMMENT_BEGIN_PREP */ 1126 #define ISL3877_IMAGE_FILE "isl3877" 1127 #define ISL3886_IMAGE_FILE "isl3886" 1128 #define ISL3890_IMAGE_FILE "isl3890" 1129 /* LDV_COMMENT_END_PREP */ 1130 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "islpci_interrupt" */ 1131 int var_islpci_interrupt_1_p0; 1132 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "islpci_interrupt" */ 1133 void * var_islpci_interrupt_1_p1; 1134 /* LDV_COMMENT_BEGIN_PREP */ 1135 #if VERBOSE > SHOW_ERROR_MESSAGES 1136 #endif 1137 #if 0 1138 #endif 1139 #if VERBOSE > SHOW_ERROR_MESSAGES 1140 #endif 1141 #if 0 1142 #endif 1143 /* LDV_COMMENT_END_PREP */ 1144 1145 1146 1147 1148 /* LDV_COMMENT_END_VARIABLE_DECLARATION_PART */ 1149 /* LDV_COMMENT_BEGIN_VARIABLE_INITIALIZING_PART */ 1150 /*============================= VARIABLE INITIALIZING PART =============================*/ 1151 LDV_IN_INTERRUPT=1; 1152 1153 1154 1155 1156 /* LDV_COMMENT_END_VARIABLE_INITIALIZING_PART */ 1157 /* LDV_COMMENT_BEGIN_FUNCTION_CALL_SECTION */ 1158 /*============================= FUNCTION CALL SECTION =============================*/ 1159 /* LDV_COMMENT_FUNCTION_CALL Initialize LDV model. */ 1160 ldv_initialize(); 1161 1162 1163 int ldv_s_islpci_netdev_ops_net_device_ops = 0; 1164 1165 1166 1167 1168 while( nondet_int() 1169 || !(ldv_s_islpci_netdev_ops_net_device_ops == 0) 1170 ) { 1171 1172 switch(nondet_int()) { 1173 1174 case 0: { 1175 1176 /** STRUCT: struct type: ethtool_ops, struct name: islpci_ethtool_ops **/ 1177 1178 1179 /* content: static void islpci_ethtool_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)*/ 1180 /* LDV_COMMENT_BEGIN_PREP */ 1181 #define ISL3877_IMAGE_FILE "isl3877" 1182 #define ISL3886_IMAGE_FILE "isl3886" 1183 #define ISL3890_IMAGE_FILE "isl3890" 1184 #if VERBOSE > SHOW_ERROR_MESSAGES 1185 #endif 1186 #if VERBOSE > SHOW_ERROR_MESSAGES 1187 #endif 1188 #if VERBOSE > SHOW_ERROR_MESSAGES 1189 #endif 1190 #if VERBOSE > SHOW_ERROR_MESSAGES 1191 #endif 1192 #if VERBOSE > SHOW_ERROR_MESSAGES 1193 #endif 1194 #if VERBOSE > SHOW_ERROR_MESSAGES 1195 #endif 1196 #if VERBOSE > SHOW_ERROR_MESSAGES 1197 #endif 1198 #if VERBOSE > SHOW_ERROR_MESSAGES 1199 #endif 1200 #if VERBOSE > SHOW_ERROR_MESSAGES 1201 #endif 1202 #if VERBOSE > SHOW_ERROR_MESSAGES 1203 #endif 1204 #if 0 1205 #endif 1206 /* LDV_COMMENT_END_PREP */ 1207 /* LDV_COMMENT_FUNCTION_CALL Function from field "get_drvinfo" from driver structure with callbacks "islpci_ethtool_ops" */ 1208 ldv_handler_precall(); 1209 islpci_ethtool_get_drvinfo( var_group1, var_group2); 1210 /* LDV_COMMENT_BEGIN_PREP */ 1211 #if VERBOSE > SHOW_ERROR_MESSAGES 1212 #endif 1213 #if 0 1214 #endif 1215 /* LDV_COMMENT_END_PREP */ 1216 1217 1218 1219 1220 } 1221 1222 break; 1223 case 1: { 1224 1225 /** STRUCT: struct type: net_device_ops, struct name: islpci_netdev_ops **/ 1226 if(ldv_s_islpci_netdev_ops_net_device_ops==0) { 1227 1228 /* content: static int islpci_open(struct net_device *ndev)*/ 1229 /* LDV_COMMENT_BEGIN_PREP */ 1230 #define ISL3877_IMAGE_FILE "isl3877" 1231 #define ISL3886_IMAGE_FILE "isl3886" 1232 #define ISL3890_IMAGE_FILE "isl3890" 1233 #if VERBOSE > SHOW_ERROR_MESSAGES 1234 #endif 1235 #if VERBOSE > SHOW_ERROR_MESSAGES 1236 #endif 1237 #if VERBOSE > SHOW_ERROR_MESSAGES 1238 #endif 1239 #if VERBOSE > SHOW_ERROR_MESSAGES 1240 #endif 1241 #if VERBOSE > SHOW_ERROR_MESSAGES 1242 #endif 1243 #if VERBOSE > SHOW_ERROR_MESSAGES 1244 #endif 1245 #if VERBOSE > SHOW_ERROR_MESSAGES 1246 #endif 1247 #if VERBOSE > SHOW_ERROR_MESSAGES 1248 #endif 1249 #if VERBOSE > SHOW_ERROR_MESSAGES 1250 #endif 1251 /* LDV_COMMENT_END_PREP */ 1252 /* LDV_COMMENT_FUNCTION_CALL Function from field "ndo_open" from driver structure with callbacks "islpci_netdev_ops". Standart function test for correct return result. */ 1253 ldv_handler_precall(); 1254 res_islpci_open_2 = islpci_open( var_group1); 1255 ldv_check_return_value(res_islpci_open_2); 1256 if(res_islpci_open_2 < 0) 1257 goto ldv_module_exit; 1258 /* LDV_COMMENT_BEGIN_PREP */ 1259 #if VERBOSE > SHOW_ERROR_MESSAGES 1260 #endif 1261 #if 0 1262 #endif 1263 #if VERBOSE > SHOW_ERROR_MESSAGES 1264 #endif 1265 #if 0 1266 #endif 1267 /* LDV_COMMENT_END_PREP */ 1268 ldv_s_islpci_netdev_ops_net_device_ops++; 1269 1270 } 1271 1272 } 1273 1274 break; 1275 case 2: { 1276 1277 /** STRUCT: struct type: net_device_ops, struct name: islpci_netdev_ops **/ 1278 if(ldv_s_islpci_netdev_ops_net_device_ops==1) { 1279 1280 /* content: static int islpci_close(struct net_device *ndev)*/ 1281 /* LDV_COMMENT_BEGIN_PREP */ 1282 #define ISL3877_IMAGE_FILE "isl3877" 1283 #define ISL3886_IMAGE_FILE "isl3886" 1284 #define ISL3890_IMAGE_FILE "isl3890" 1285 #if VERBOSE > SHOW_ERROR_MESSAGES 1286 #endif 1287 #if VERBOSE > SHOW_ERROR_MESSAGES 1288 #endif 1289 #if VERBOSE > SHOW_ERROR_MESSAGES 1290 #endif 1291 #if VERBOSE > SHOW_ERROR_MESSAGES 1292 #endif 1293 #if VERBOSE > SHOW_ERROR_MESSAGES 1294 #endif 1295 #if VERBOSE > SHOW_ERROR_MESSAGES 1296 #endif 1297 #if VERBOSE > SHOW_ERROR_MESSAGES 1298 #endif 1299 #if VERBOSE > SHOW_ERROR_MESSAGES 1300 #endif 1301 #if VERBOSE > SHOW_ERROR_MESSAGES 1302 #endif 1303 /* LDV_COMMENT_END_PREP */ 1304 /* LDV_COMMENT_FUNCTION_CALL Function from field "ndo_stop" from driver structure with callbacks "islpci_netdev_ops". Standart function test for correct return result. */ 1305 ldv_handler_precall(); 1306 res_islpci_close_3 = islpci_close( var_group1); 1307 ldv_check_return_value(res_islpci_close_3); 1308 if(res_islpci_close_3) 1309 goto ldv_module_exit; 1310 /* LDV_COMMENT_BEGIN_PREP */ 1311 #if VERBOSE > SHOW_ERROR_MESSAGES 1312 #endif 1313 #if 0 1314 #endif 1315 #if VERBOSE > SHOW_ERROR_MESSAGES 1316 #endif 1317 #if 0 1318 #endif 1319 /* LDV_COMMENT_END_PREP */ 1320 ldv_s_islpci_netdev_ops_net_device_ops=0; 1321 1322 } 1323 1324 } 1325 1326 break; 1327 case 3: { 1328 1329 /** CALLBACK SECTION request_irq **/ 1330 LDV_IN_INTERRUPT=2; 1331 1332 /* content: irqreturn_t islpci_interrupt(int irq, void *config)*/ 1333 /* LDV_COMMENT_BEGIN_PREP */ 1334 #define ISL3877_IMAGE_FILE "isl3877" 1335 #define ISL3886_IMAGE_FILE "isl3886" 1336 #define ISL3890_IMAGE_FILE "isl3890" 1337 /* LDV_COMMENT_END_PREP */ 1338 /* LDV_COMMENT_FUNCTION_CALL */ 1339 ldv_handler_precall(); 1340 islpci_interrupt( var_islpci_interrupt_1_p0, var_islpci_interrupt_1_p1); 1341 /* LDV_COMMENT_BEGIN_PREP */ 1342 #if VERBOSE > SHOW_ERROR_MESSAGES 1343 #endif 1344 #if 0 1345 #endif 1346 #if VERBOSE > SHOW_ERROR_MESSAGES 1347 #endif 1348 #if 0 1349 #endif 1350 /* LDV_COMMENT_END_PREP */ 1351 LDV_IN_INTERRUPT=1; 1352 1353 1354 1355 } 1356 1357 break; 1358 default: break; 1359 1360 } 1361 1362 } 1363 1364 ldv_module_exit: 1365 1366 /* LDV_COMMENT_FUNCTION_CALL Checks that all resources and locks are correctly released before the driver will be unloaded. */ 1367 ldv_final: ldv_check_final_state(); 1368 1369 /* LDV_COMMENT_END_FUNCTION_CALL_SECTION */ 1370 return; 1371 1372 } 1373 #endif 1374 1375 /* LDV_COMMENT_END_MAIN */
1 /* 2 * Copyright (C) 2002 Intersil Americas Inc. 3 * Copyright (C) 2004 Aurelien Alleaume <slts@free.fr> 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * along with this program; if not, see <http://www.gnu.org/licenses/>. 15 * 16 */ 17 18 #include <linux/module.h> 19 #include <linux/gfp.h> 20 21 #include <linux/pci.h> 22 #include <linux/delay.h> 23 #include <linux/netdevice.h> 24 #include <linux/etherdevice.h> 25 #include <linux/if_arp.h> 26 #include <asm/byteorder.h> 27 28 #include "prismcompat.h" 29 #include "isl_38xx.h" 30 #include "islpci_eth.h" 31 #include "islpci_mgt.h" 32 #include "oid_mgt.h" 33 34 /****************************************************************************** 35 Network Interface functions 36 ******************************************************************************/ 37 void 38 islpci_eth_cleanup_transmit(islpci_private *priv, 39 isl38xx_control_block *control_block) 40 { 41 struct sk_buff *skb; 42 u32 index; 43 44 /* compare the control block read pointer with the free pointer */ 45 while (priv->free_data_tx != 46 le32_to_cpu(control_block-> 47 device_curr_frag[ISL38XX_CB_TX_DATA_LQ])) { 48 /* read the index of the first fragment to be freed */ 49 index = priv->free_data_tx % ISL38XX_CB_TX_QSIZE; 50 51 /* check for holes in the arrays caused by multi fragment frames 52 * searching for the last fragment of a frame */ 53 if (priv->pci_map_tx_address[index]) { 54 /* entry is the last fragment of a frame 55 * free the skb structure and unmap pci memory */ 56 skb = priv->data_low_tx[index]; 57 58 #if VERBOSE > SHOW_ERROR_MESSAGES 59 DEBUG(SHOW_TRACING, 60 "cleanup skb %p skb->data %p skb->len %u truesize %u\n ", 61 skb, skb->data, skb->len, skb->truesize); 62 #endif 63 64 pci_unmap_single(priv->pdev, 65 priv->pci_map_tx_address[index], 66 skb->len, PCI_DMA_TODEVICE); 67 dev_kfree_skb_irq(skb); 68 skb = NULL; 69 } 70 /* increment the free data low queue pointer */ 71 priv->free_data_tx++; 72 } 73 } 74 75 netdev_tx_t 76 islpci_eth_transmit(struct sk_buff *skb, struct net_device *ndev) 77 { 78 islpci_private *priv = netdev_priv(ndev); 79 isl38xx_control_block *cb = priv->control_block; 80 u32 index; 81 dma_addr_t pci_map_address; 82 int frame_size; 83 isl38xx_fragment *fragment; 84 int offset; 85 struct sk_buff *newskb; 86 int newskb_offset; 87 unsigned long flags; 88 unsigned char wds_mac[6]; 89 u32 curr_frag; 90 91 #if VERBOSE > SHOW_ERROR_MESSAGES 92 DEBUG(SHOW_FUNCTION_CALLS, "islpci_eth_transmit\n"); 93 #endif 94 95 /* lock the driver code */ 96 spin_lock_irqsave(&priv->slock, flags); 97 98 /* check whether the destination queue has enough fragments for the frame */ 99 curr_frag = le32_to_cpu(cb->driver_curr_frag[ISL38XX_CB_TX_DATA_LQ]); 100 if (unlikely(curr_frag - priv->free_data_tx >= ISL38XX_CB_TX_QSIZE)) { 101 printk(KERN_ERR "%s: transmit device queue full when awake\n", 102 ndev->name); 103 netif_stop_queue(ndev); 104 105 /* trigger the device */ 106 isl38xx_w32_flush(priv->device_base, ISL38XX_DEV_INT_UPDATE, 107 ISL38XX_DEV_INT_REG); 108 udelay(ISL38XX_WRITEIO_DELAY); 109 goto drop_free; 110 } 111 /* Check alignment and WDS frame formatting. The start of the packet should 112 * be aligned on a 4-byte boundary. If WDS is enabled add another 6 bytes 113 * and add WDS address information */ 114 if (likely(((long) skb->data & 0x03) | init_wds)) { 115 /* get the number of bytes to add and re-align */ 116 offset = (4 - (long) skb->data) & 0x03; 117 offset += init_wds ? 6 : 0; 118 119 /* check whether the current skb can be used */ 120 if (!skb_cloned(skb) && (skb_tailroom(skb) >= offset)) { 121 unsigned char *src = skb->data; 122 123 #if VERBOSE > SHOW_ERROR_MESSAGES 124 DEBUG(SHOW_TRACING, "skb offset %i wds %i\n", offset, 125 init_wds); 126 #endif 127 128 /* align the buffer on 4-byte boundary */ 129 skb_reserve(skb, (4 - (long) skb->data) & 0x03); 130 if (init_wds) { 131 /* wds requires an additional address field of 6 bytes */ 132 skb_put(skb, 6); 133 #ifdef ISLPCI_ETH_DEBUG 134 printk("islpci_eth_transmit:wds_mac\n"); 135 #endif 136 memmove(skb->data + 6, src, skb->len); 137 skb_copy_to_linear_data(skb, wds_mac, 6); 138 } else { 139 memmove(skb->data, src, skb->len); 140 } 141 142 #if VERBOSE > SHOW_ERROR_MESSAGES 143 DEBUG(SHOW_TRACING, "memmove %p %p %i\n", skb->data, 144 src, skb->len); 145 #endif 146 } else { 147 newskb = 148 dev_alloc_skb(init_wds ? skb->len + 6 : skb->len); 149 if (unlikely(newskb == NULL)) { 150 printk(KERN_ERR "%s: Cannot allocate skb\n", 151 ndev->name); 152 goto drop_free; 153 } 154 newskb_offset = (4 - (long) newskb->data) & 0x03; 155 156 /* Check if newskb->data is aligned */ 157 if (newskb_offset) 158 skb_reserve(newskb, newskb_offset); 159 160 skb_put(newskb, init_wds ? skb->len + 6 : skb->len); 161 if (init_wds) { 162 skb_copy_from_linear_data(skb, 163 newskb->data + 6, 164 skb->len); 165 skb_copy_to_linear_data(newskb, wds_mac, 6); 166 #ifdef ISLPCI_ETH_DEBUG 167 printk("islpci_eth_transmit:wds_mac\n"); 168 #endif 169 } else 170 skb_copy_from_linear_data(skb, newskb->data, 171 skb->len); 172 173 #if VERBOSE > SHOW_ERROR_MESSAGES 174 DEBUG(SHOW_TRACING, "memcpy %p %p %i wds %i\n", 175 newskb->data, skb->data, skb->len, init_wds); 176 #endif 177 178 newskb->dev = skb->dev; 179 dev_kfree_skb_irq(skb); 180 skb = newskb; 181 } 182 } 183 /* display the buffer contents for debugging */ 184 #if VERBOSE > SHOW_ERROR_MESSAGES 185 DEBUG(SHOW_BUFFER_CONTENTS, "\ntx %p ", skb->data); 186 display_buffer((char *) skb->data, skb->len); 187 #endif 188 189 /* map the skb buffer to pci memory for DMA operation */ 190 pci_map_address = pci_map_single(priv->pdev, 191 (void *) skb->data, skb->len, 192 PCI_DMA_TODEVICE); 193 if (unlikely(pci_map_address == 0)) { 194 printk(KERN_WARNING "%s: cannot map buffer to PCI\n", 195 ndev->name); 196 goto drop_free; 197 } 198 /* Place the fragment in the control block structure. */ 199 index = curr_frag % ISL38XX_CB_TX_QSIZE; 200 fragment = &cb->tx_data_low[index]; 201 202 priv->pci_map_tx_address[index] = pci_map_address; 203 /* store the skb address for future freeing */ 204 priv->data_low_tx[index] = skb; 205 /* set the proper fragment start address and size information */ 206 frame_size = skb->len; 207 fragment->size = cpu_to_le16(frame_size); 208 fragment->flags = cpu_to_le16(0); /* set to 1 if more fragments */ 209 fragment->address = cpu_to_le32(pci_map_address); 210 curr_frag++; 211 212 /* The fragment address in the control block must have been 213 * written before announcing the frame buffer to device. */ 214 wmb(); 215 cb->driver_curr_frag[ISL38XX_CB_TX_DATA_LQ] = cpu_to_le32(curr_frag); 216 217 if (curr_frag - priv->free_data_tx + ISL38XX_MIN_QTHRESHOLD 218 > ISL38XX_CB_TX_QSIZE) { 219 /* stop sends from upper layers */ 220 netif_stop_queue(ndev); 221 222 /* set the full flag for the transmission queue */ 223 priv->data_low_tx_full = 1; 224 } 225 226 ndev->stats.tx_packets++; 227 ndev->stats.tx_bytes += skb->len; 228 229 /* trigger the device */ 230 islpci_trigger(priv); 231 232 /* unlock the driver code */ 233 spin_unlock_irqrestore(&priv->slock, flags); 234 235 return NETDEV_TX_OK; 236 237 drop_free: 238 ndev->stats.tx_dropped++; 239 spin_unlock_irqrestore(&priv->slock, flags); 240 dev_kfree_skb(skb); 241 return NETDEV_TX_OK; 242 } 243 244 static inline int 245 islpci_monitor_rx(islpci_private *priv, struct sk_buff **skb) 246 { 247 /* The card reports full 802.11 packets but with a 20 bytes 248 * header and without the FCS. But there a is a bit that 249 * indicates if the packet is corrupted :-) */ 250 struct rfmon_header *hdr = (struct rfmon_header *) (*skb)->data; 251 252 if (hdr->flags & 0x01) 253 /* This one is bad. Drop it ! */ 254 return -1; 255 if (priv->ndev->type == ARPHRD_IEEE80211_PRISM) { 256 struct avs_80211_1_header *avs; 257 /* extract the relevant data from the header */ 258 u32 clock = le32_to_cpu(hdr->clock); 259 u8 rate = hdr->rate; 260 u16 freq = le16_to_cpu(hdr->freq); 261 u8 rssi = hdr->rssi; 262 263 skb_pull(*skb, sizeof (struct rfmon_header)); 264 265 if (skb_headroom(*skb) < sizeof (struct avs_80211_1_header)) { 266 struct sk_buff *newskb = skb_copy_expand(*skb, 267 sizeof (struct 268 avs_80211_1_header), 269 0, GFP_ATOMIC); 270 if (newskb) { 271 dev_kfree_skb_irq(*skb); 272 *skb = newskb; 273 } else 274 return -1; 275 /* This behavior is not very subtile... */ 276 } 277 278 /* make room for the new header and fill it. */ 279 avs = 280 (struct avs_80211_1_header *) skb_push(*skb, 281 sizeof (struct 282 avs_80211_1_header)); 283 284 avs->version = cpu_to_be32(P80211CAPTURE_VERSION); 285 avs->length = cpu_to_be32(sizeof (struct avs_80211_1_header)); 286 avs->mactime = cpu_to_be64(clock); 287 avs->hosttime = cpu_to_be64(jiffies); 288 avs->phytype = cpu_to_be32(6); /*OFDM: 6 for (g), 8 for (a) */ 289 avs->channel = cpu_to_be32(channel_of_freq(freq)); 290 avs->datarate = cpu_to_be32(rate * 5); 291 avs->antenna = cpu_to_be32(0); /*unknown */ 292 avs->priority = cpu_to_be32(0); /*unknown */ 293 avs->ssi_type = cpu_to_be32(3); /*2: dBm, 3: raw RSSI */ 294 avs->ssi_signal = cpu_to_be32(rssi & 0x7f); 295 avs->ssi_noise = cpu_to_be32(priv->local_iwstatistics.qual.noise); /*better than 'undefined', I assume */ 296 avs->preamble = cpu_to_be32(0); /*unknown */ 297 avs->encoding = cpu_to_be32(0); /*unknown */ 298 } else 299 skb_pull(*skb, sizeof (struct rfmon_header)); 300 301 (*skb)->protocol = htons(ETH_P_802_2); 302 skb_reset_mac_header(*skb); 303 (*skb)->pkt_type = PACKET_OTHERHOST; 304 305 return 0; 306 } 307 308 int 309 islpci_eth_receive(islpci_private *priv) 310 { 311 struct net_device *ndev = priv->ndev; 312 isl38xx_control_block *control_block = priv->control_block; 313 struct sk_buff *skb; 314 u16 size; 315 u32 index, offset; 316 unsigned char *src; 317 int discard = 0; 318 319 #if VERBOSE > SHOW_ERROR_MESSAGES 320 DEBUG(SHOW_FUNCTION_CALLS, "islpci_eth_receive\n"); 321 #endif 322 323 /* the device has written an Ethernet frame in the data area 324 * of the sk_buff without updating the structure, do it now */ 325 index = priv->free_data_rx % ISL38XX_CB_RX_QSIZE; 326 size = le16_to_cpu(control_block->rx_data_low[index].size); 327 skb = priv->data_low_rx[index]; 328 offset = ((unsigned long) 329 le32_to_cpu(control_block->rx_data_low[index].address) - 330 (unsigned long) skb->data) & 3; 331 332 #if VERBOSE > SHOW_ERROR_MESSAGES 333 DEBUG(SHOW_TRACING, 334 "frq->addr %x skb->data %p skb->len %u offset %u truesize %u\n ", 335 control_block->rx_data_low[priv->free_data_rx].address, skb->data, 336 skb->len, offset, skb->truesize); 337 #endif 338 339 /* delete the streaming DMA mapping before processing the skb */ 340 pci_unmap_single(priv->pdev, 341 priv->pci_map_rx_address[index], 342 MAX_FRAGMENT_SIZE_RX + 2, PCI_DMA_FROMDEVICE); 343 344 /* update the skb structure and align the buffer */ 345 skb_put(skb, size); 346 if (offset) { 347 /* shift the buffer allocation offset bytes to get the right frame */ 348 skb_pull(skb, 2); 349 skb_put(skb, 2); 350 } 351 #if VERBOSE > SHOW_ERROR_MESSAGES 352 /* display the buffer contents for debugging */ 353 DEBUG(SHOW_BUFFER_CONTENTS, "\nrx %p ", skb->data); 354 display_buffer((char *) skb->data, skb->len); 355 #endif 356 357 /* check whether WDS is enabled and whether the data frame is a WDS frame */ 358 359 if (init_wds) { 360 /* WDS enabled, check for the wds address on the first 6 bytes of the buffer */ 361 src = skb->data + 6; 362 memmove(skb->data, src, skb->len - 6); 363 skb_trim(skb, skb->len - 6); 364 } 365 #if VERBOSE > SHOW_ERROR_MESSAGES 366 DEBUG(SHOW_TRACING, "Fragment size %i in skb at %p\n", size, skb); 367 DEBUG(SHOW_TRACING, "Skb data at %p, length %i\n", skb->data, skb->len); 368 369 /* display the buffer contents for debugging */ 370 DEBUG(SHOW_BUFFER_CONTENTS, "\nrx %p ", skb->data); 371 display_buffer((char *) skb->data, skb->len); 372 #endif 373 /* take care of monitor mode and spy monitoring. */ 374 if (unlikely(priv->iw_mode == IW_MODE_MONITOR)) { 375 skb->dev = ndev; 376 discard = islpci_monitor_rx(priv, &skb); 377 } else { 378 if (unlikely(skb->data[2 * ETH_ALEN] == 0)) { 379 /* The packet has a rx_annex. Read it for spy monitoring, Then 380 * remove it, while keeping the 2 leading MAC addr. 381 */ 382 struct iw_quality wstats; 383 struct rx_annex_header *annex = 384 (struct rx_annex_header *) skb->data; 385 wstats.level = annex->rfmon.rssi; 386 /* The noise value can be a bit outdated if nobody's 387 * reading wireless stats... */ 388 wstats.noise = priv->local_iwstatistics.qual.noise; 389 wstats.qual = wstats.level - wstats.noise; 390 wstats.updated = 0x07; 391 /* Update spy records */ 392 wireless_spy_update(ndev, annex->addr2, &wstats); 393 394 skb_copy_from_linear_data(skb, 395 (skb->data + 396 sizeof(struct rfmon_header)), 397 2 * ETH_ALEN); 398 skb_pull(skb, sizeof (struct rfmon_header)); 399 } 400 skb->protocol = eth_type_trans(skb, ndev); 401 } 402 skb->ip_summed = CHECKSUM_NONE; 403 ndev->stats.rx_packets++; 404 ndev->stats.rx_bytes += size; 405 406 /* deliver the skb to the network layer */ 407 #ifdef ISLPCI_ETH_DEBUG 408 printk 409 ("islpci_eth_receive:netif_rx %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n", 410 skb->data[0], skb->data[1], skb->data[2], skb->data[3], 411 skb->data[4], skb->data[5]); 412 #endif 413 if (unlikely(discard)) { 414 dev_kfree_skb_irq(skb); 415 skb = NULL; 416 } else 417 netif_rx(skb); 418 419 /* increment the read index for the rx data low queue */ 420 priv->free_data_rx++; 421 422 /* add one or more sk_buff structures */ 423 while (index = 424 le32_to_cpu(control_block-> 425 driver_curr_frag[ISL38XX_CB_RX_DATA_LQ]), 426 index - priv->free_data_rx < ISL38XX_CB_RX_QSIZE) { 427 /* allocate an sk_buff for received data frames storage 428 * include any required allignment operations */ 429 skb = dev_alloc_skb(MAX_FRAGMENT_SIZE_RX + 2); 430 if (unlikely(skb == NULL)) { 431 /* error allocating an sk_buff structure elements */ 432 DEBUG(SHOW_ERROR_MESSAGES, "Error allocating skb\n"); 433 break; 434 } 435 skb_reserve(skb, (4 - (long) skb->data) & 0x03); 436 /* store the new skb structure pointer */ 437 index = index % ISL38XX_CB_RX_QSIZE; 438 priv->data_low_rx[index] = skb; 439 440 #if VERBOSE > SHOW_ERROR_MESSAGES 441 DEBUG(SHOW_TRACING, 442 "new alloc skb %p skb->data %p skb->len %u index %u truesize %u\n ", 443 skb, skb->data, skb->len, index, skb->truesize); 444 #endif 445 446 /* set the streaming DMA mapping for proper PCI bus operation */ 447 priv->pci_map_rx_address[index] = 448 pci_map_single(priv->pdev, (void *) skb->data, 449 MAX_FRAGMENT_SIZE_RX + 2, 450 PCI_DMA_FROMDEVICE); 451 if (unlikely(!priv->pci_map_rx_address[index])) { 452 /* error mapping the buffer to device accessible memory address */ 453 DEBUG(SHOW_ERROR_MESSAGES, 454 "Error mapping DMA address\n"); 455 456 /* free the skbuf structure before aborting */ 457 dev_kfree_skb_irq(skb); 458 skb = NULL; 459 break; 460 } 461 /* update the fragment address */ 462 control_block->rx_data_low[index].address = 463 cpu_to_le32((u32)priv->pci_map_rx_address[index]); 464 wmb(); 465 466 /* increment the driver read pointer */ 467 le32_add_cpu(&control_block-> 468 driver_curr_frag[ISL38XX_CB_RX_DATA_LQ], 1); 469 } 470 471 /* trigger the device */ 472 islpci_trigger(priv); 473 474 return 0; 475 } 476 477 void 478 islpci_do_reset_and_wake(struct work_struct *work) 479 { 480 islpci_private *priv = container_of(work, islpci_private, reset_task); 481 482 islpci_reset(priv, 1); 483 priv->reset_task_pending = 0; 484 smp_wmb(); 485 netif_wake_queue(priv->ndev); 486 } 487 488 void 489 islpci_eth_tx_timeout(struct net_device *ndev) 490 { 491 islpci_private *priv = netdev_priv(ndev); 492 493 /* increment the transmit error counter */ 494 ndev->stats.tx_errors++; 495 496 if (!priv->reset_task_pending) { 497 printk(KERN_WARNING 498 "%s: tx_timeout, scheduling reset", ndev->name); 499 netif_stop_queue(ndev); 500 priv->reset_task_pending = 1; 501 schedule_work(&priv->reset_task); 502 } else { 503 printk(KERN_WARNING 504 "%s: tx_timeout, waiting for reset", ndev->name); 505 } 506 }
1 2 #include <linux/types.h> 3 #include <linux/dma-direction.h> 4 5 extern dma_addr_t ldv_dma_map_page(struct device *dev, struct page *page, size_t offset, size_t size, enum dma_data_direction dir); 6 extern dma_addr_t ldv_dma_map_single(struct device *dev, void *cpu_addr, size_t size, enum dma_data_direction dir); 7 extern dma_addr_t ldv_dma_map_single_attrs(struct device *dev, void *ptr, size_t size, enum dma_data_direction dir, struct dma_attrs *attrs); 8 extern int ldv_dma_mapping_error(struct device *dev, dma_addr_t dma_addr); 9 #line 1 "/home/druidos/temp/331_1a/work/current--X--drivers--X--defaultlinux-3.14.1.tar.xz--X--331_1a--X--cpachecker/linux-3.14.1.tar.xz/csd_deg_dscv/6673/dscv_tempdir/dscv/ri/331_1a/drivers/net/wireless/prism54/islpci_eth.c" 10 /* 11 * Copyright (C) 2002 Intersil Americas Inc. 12 * Copyright (C) 2004 Aurelien Alleaume <slts@free.fr> 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License as published by 15 * the Free Software Foundation; either version 2 of the License 16 * 17 * This program is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 * GNU General Public License for more details. 21 * 22 * You should have received a copy of the GNU General Public License 23 * along with this program; if not, see <http://www.gnu.org/licenses/>. 24 * 25 */ 26 27 #include <linux/module.h> 28 #include <linux/gfp.h> 29 30 #include <linux/pci.h> 31 #include <linux/delay.h> 32 #include <linux/netdevice.h> 33 #include <linux/etherdevice.h> 34 #include <linux/if_arp.h> 35 #include <asm/byteorder.h> 36 37 #include "prismcompat.h" 38 #include "isl_38xx.h" 39 #include "islpci_eth.h" 40 #include "islpci_mgt.h" 41 #include "oid_mgt.h" 42 43 /****************************************************************************** 44 Network Interface functions 45 ******************************************************************************/ 46 void 47 islpci_eth_cleanup_transmit(islpci_private *priv, 48 isl38xx_control_block *control_block) 49 { 50 struct sk_buff *skb; 51 u32 index; 52 53 /* compare the control block read pointer with the free pointer */ 54 while (priv->free_data_tx != 55 le32_to_cpu(control_block-> 56 device_curr_frag[ISL38XX_CB_TX_DATA_LQ])) { 57 /* read the index of the first fragment to be freed */ 58 index = priv->free_data_tx % ISL38XX_CB_TX_QSIZE; 59 60 /* check for holes in the arrays caused by multi fragment frames 61 * searching for the last fragment of a frame */ 62 if (priv->pci_map_tx_address[index]) { 63 /* entry is the last fragment of a frame 64 * free the skb structure and unmap pci memory */ 65 skb = priv->data_low_tx[index]; 66 67 #if VERBOSE > SHOW_ERROR_MESSAGES 68 DEBUG(SHOW_TRACING, 69 "cleanup skb %p skb->data %p skb->len %u truesize %u\n ", 70 skb, skb->data, skb->len, skb->truesize); 71 #endif 72 73 pci_unmap_single(priv->pdev, 74 priv->pci_map_tx_address[index], 75 skb->len, PCI_DMA_TODEVICE); 76 dev_kfree_skb_irq(skb); 77 skb = NULL; 78 } 79 /* increment the free data low queue pointer */ 80 priv->free_data_tx++; 81 } 82 } 83 84 netdev_tx_t 85 islpci_eth_transmit(struct sk_buff *skb, struct net_device *ndev) 86 { 87 islpci_private *priv = netdev_priv(ndev); 88 isl38xx_control_block *cb = priv->control_block; 89 u32 index; 90 dma_addr_t pci_map_address; 91 int frame_size; 92 isl38xx_fragment *fragment; 93 int offset; 94 struct sk_buff *newskb; 95 int newskb_offset; 96 unsigned long flags; 97 unsigned char wds_mac[6]; 98 u32 curr_frag; 99 100 #if VERBOSE > SHOW_ERROR_MESSAGES 101 DEBUG(SHOW_FUNCTION_CALLS, "islpci_eth_transmit\n"); 102 #endif 103 104 /* lock the driver code */ 105 spin_lock_irqsave(&priv->slock, flags); 106 107 /* check whether the destination queue has enough fragments for the frame */ 108 curr_frag = le32_to_cpu(cb->driver_curr_frag[ISL38XX_CB_TX_DATA_LQ]); 109 if (unlikely(curr_frag - priv->free_data_tx >= ISL38XX_CB_TX_QSIZE)) { 110 printk(KERN_ERR "%s: transmit device queue full when awake\n", 111 ndev->name); 112 netif_stop_queue(ndev); 113 114 /* trigger the device */ 115 isl38xx_w32_flush(priv->device_base, ISL38XX_DEV_INT_UPDATE, 116 ISL38XX_DEV_INT_REG); 117 udelay(ISL38XX_WRITEIO_DELAY); 118 goto drop_free; 119 } 120 /* Check alignment and WDS frame formatting. The start of the packet should 121 * be aligned on a 4-byte boundary. If WDS is enabled add another 6 bytes 122 * and add WDS address information */ 123 if (likely(((long) skb->data & 0x03) | init_wds)) { 124 /* get the number of bytes to add and re-align */ 125 offset = (4 - (long) skb->data) & 0x03; 126 offset += init_wds ? 6 : 0; 127 128 /* check whether the current skb can be used */ 129 if (!skb_cloned(skb) && (skb_tailroom(skb) >= offset)) { 130 unsigned char *src = skb->data; 131 132 #if VERBOSE > SHOW_ERROR_MESSAGES 133 DEBUG(SHOW_TRACING, "skb offset %i wds %i\n", offset, 134 init_wds); 135 #endif 136 137 /* align the buffer on 4-byte boundary */ 138 skb_reserve(skb, (4 - (long) skb->data) & 0x03); 139 if (init_wds) { 140 /* wds requires an additional address field of 6 bytes */ 141 skb_put(skb, 6); 142 #ifdef ISLPCI_ETH_DEBUG 143 printk("islpci_eth_transmit:wds_mac\n"); 144 #endif 145 memmove(skb->data + 6, src, skb->len); 146 skb_copy_to_linear_data(skb, wds_mac, 6); 147 } else { 148 memmove(skb->data, src, skb->len); 149 } 150 151 #if VERBOSE > SHOW_ERROR_MESSAGES 152 DEBUG(SHOW_TRACING, "memmove %p %p %i\n", skb->data, 153 src, skb->len); 154 #endif 155 } else { 156 newskb = 157 dev_alloc_skb(init_wds ? skb->len + 6 : skb->len); 158 if (unlikely(newskb == NULL)) { 159 printk(KERN_ERR "%s: Cannot allocate skb\n", 160 ndev->name); 161 goto drop_free; 162 } 163 newskb_offset = (4 - (long) newskb->data) & 0x03; 164 165 /* Check if newskb->data is aligned */ 166 if (newskb_offset) 167 skb_reserve(newskb, newskb_offset); 168 169 skb_put(newskb, init_wds ? skb->len + 6 : skb->len); 170 if (init_wds) { 171 skb_copy_from_linear_data(skb, 172 newskb->data + 6, 173 skb->len); 174 skb_copy_to_linear_data(newskb, wds_mac, 6); 175 #ifdef ISLPCI_ETH_DEBUG 176 printk("islpci_eth_transmit:wds_mac\n"); 177 #endif 178 } else 179 skb_copy_from_linear_data(skb, newskb->data, 180 skb->len); 181 182 #if VERBOSE > SHOW_ERROR_MESSAGES 183 DEBUG(SHOW_TRACING, "memcpy %p %p %i wds %i\n", 184 newskb->data, skb->data, skb->len, init_wds); 185 #endif 186 187 newskb->dev = skb->dev; 188 dev_kfree_skb_irq(skb); 189 skb = newskb; 190 } 191 } 192 /* display the buffer contents for debugging */ 193 #if VERBOSE > SHOW_ERROR_MESSAGES 194 DEBUG(SHOW_BUFFER_CONTENTS, "\ntx %p ", skb->data); 195 display_buffer((char *) skb->data, skb->len); 196 #endif 197 198 /* map the skb buffer to pci memory for DMA operation */ 199 pci_map_address = pci_map_single(priv->pdev, 200 (void *) skb->data, skb->len, 201 PCI_DMA_TODEVICE); 202 if (unlikely(pci_map_address == 0)) { 203 printk(KERN_WARNING "%s: cannot map buffer to PCI\n", 204 ndev->name); 205 goto drop_free; 206 } 207 /* Place the fragment in the control block structure. */ 208 index = curr_frag % ISL38XX_CB_TX_QSIZE; 209 fragment = &cb->tx_data_low[index]; 210 211 priv->pci_map_tx_address[index] = pci_map_address; 212 /* store the skb address for future freeing */ 213 priv->data_low_tx[index] = skb; 214 /* set the proper fragment start address and size information */ 215 frame_size = skb->len; 216 fragment->size = cpu_to_le16(frame_size); 217 fragment->flags = cpu_to_le16(0); /* set to 1 if more fragments */ 218 fragment->address = cpu_to_le32(pci_map_address); 219 curr_frag++; 220 221 /* The fragment address in the control block must have been 222 * written before announcing the frame buffer to device. */ 223 wmb(); 224 cb->driver_curr_frag[ISL38XX_CB_TX_DATA_LQ] = cpu_to_le32(curr_frag); 225 226 if (curr_frag - priv->free_data_tx + ISL38XX_MIN_QTHRESHOLD 227 > ISL38XX_CB_TX_QSIZE) { 228 /* stop sends from upper layers */ 229 netif_stop_queue(ndev); 230 231 /* set the full flag for the transmission queue */ 232 priv->data_low_tx_full = 1; 233 } 234 235 ndev->stats.tx_packets++; 236 ndev->stats.tx_bytes += skb->len; 237 238 /* trigger the device */ 239 islpci_trigger(priv); 240 241 /* unlock the driver code */ 242 spin_unlock_irqrestore(&priv->slock, flags); 243 244 return NETDEV_TX_OK; 245 246 drop_free: 247 ndev->stats.tx_dropped++; 248 spin_unlock_irqrestore(&priv->slock, flags); 249 dev_kfree_skb(skb); 250 return NETDEV_TX_OK; 251 } 252 253 static inline int 254 islpci_monitor_rx(islpci_private *priv, struct sk_buff **skb) 255 { 256 /* The card reports full 802.11 packets but with a 20 bytes 257 * header and without the FCS. But there a is a bit that 258 * indicates if the packet is corrupted :-) */ 259 struct rfmon_header *hdr = (struct rfmon_header *) (*skb)->data; 260 261 if (hdr->flags & 0x01) 262 /* This one is bad. Drop it ! */ 263 return -1; 264 if (priv->ndev->type == ARPHRD_IEEE80211_PRISM) { 265 struct avs_80211_1_header *avs; 266 /* extract the relevant data from the header */ 267 u32 clock = le32_to_cpu(hdr->clock); 268 u8 rate = hdr->rate; 269 u16 freq = le16_to_cpu(hdr->freq); 270 u8 rssi = hdr->rssi; 271 272 skb_pull(*skb, sizeof (struct rfmon_header)); 273 274 if (skb_headroom(*skb) < sizeof (struct avs_80211_1_header)) { 275 struct sk_buff *newskb = skb_copy_expand(*skb, 276 sizeof (struct 277 avs_80211_1_header), 278 0, GFP_ATOMIC); 279 if (newskb) { 280 dev_kfree_skb_irq(*skb); 281 *skb = newskb; 282 } else 283 return -1; 284 /* This behavior is not very subtile... */ 285 } 286 287 /* make room for the new header and fill it. */ 288 avs = 289 (struct avs_80211_1_header *) skb_push(*skb, 290 sizeof (struct 291 avs_80211_1_header)); 292 293 avs->version = cpu_to_be32(P80211CAPTURE_VERSION); 294 avs->length = cpu_to_be32(sizeof (struct avs_80211_1_header)); 295 avs->mactime = cpu_to_be64(clock); 296 avs->hosttime = cpu_to_be64(jiffies); 297 avs->phytype = cpu_to_be32(6); /*OFDM: 6 for (g), 8 for (a) */ 298 avs->channel = cpu_to_be32(channel_of_freq(freq)); 299 avs->datarate = cpu_to_be32(rate * 5); 300 avs->antenna = cpu_to_be32(0); /*unknown */ 301 avs->priority = cpu_to_be32(0); /*unknown */ 302 avs->ssi_type = cpu_to_be32(3); /*2: dBm, 3: raw RSSI */ 303 avs->ssi_signal = cpu_to_be32(rssi & 0x7f); 304 avs->ssi_noise = cpu_to_be32(priv->local_iwstatistics.qual.noise); /*better than 'undefined', I assume */ 305 avs->preamble = cpu_to_be32(0); /*unknown */ 306 avs->encoding = cpu_to_be32(0); /*unknown */ 307 } else 308 skb_pull(*skb, sizeof (struct rfmon_header)); 309 310 (*skb)->protocol = htons(ETH_P_802_2); 311 skb_reset_mac_header(*skb); 312 (*skb)->pkt_type = PACKET_OTHERHOST; 313 314 return 0; 315 } 316 317 int 318 islpci_eth_receive(islpci_private *priv) 319 { 320 struct net_device *ndev = priv->ndev; 321 isl38xx_control_block *control_block = priv->control_block; 322 struct sk_buff *skb; 323 u16 size; 324 u32 index, offset; 325 unsigned char *src; 326 int discard = 0; 327 328 #if VERBOSE > SHOW_ERROR_MESSAGES 329 DEBUG(SHOW_FUNCTION_CALLS, "islpci_eth_receive\n"); 330 #endif 331 332 /* the device has written an Ethernet frame in the data area 333 * of the sk_buff without updating the structure, do it now */ 334 index = priv->free_data_rx % ISL38XX_CB_RX_QSIZE; 335 size = le16_to_cpu(control_block->rx_data_low[index].size); 336 skb = priv->data_low_rx[index]; 337 offset = ((unsigned long) 338 le32_to_cpu(control_block->rx_data_low[index].address) - 339 (unsigned long) skb->data) & 3; 340 341 #if VERBOSE > SHOW_ERROR_MESSAGES 342 DEBUG(SHOW_TRACING, 343 "frq->addr %x skb->data %p skb->len %u offset %u truesize %u\n ", 344 control_block->rx_data_low[priv->free_data_rx].address, skb->data, 345 skb->len, offset, skb->truesize); 346 #endif 347 348 /* delete the streaming DMA mapping before processing the skb */ 349 pci_unmap_single(priv->pdev, 350 priv->pci_map_rx_address[index], 351 MAX_FRAGMENT_SIZE_RX + 2, PCI_DMA_FROMDEVICE); 352 353 /* update the skb structure and align the buffer */ 354 skb_put(skb, size); 355 if (offset) { 356 /* shift the buffer allocation offset bytes to get the right frame */ 357 skb_pull(skb, 2); 358 skb_put(skb, 2); 359 } 360 #if VERBOSE > SHOW_ERROR_MESSAGES 361 /* display the buffer contents for debugging */ 362 DEBUG(SHOW_BUFFER_CONTENTS, "\nrx %p ", skb->data); 363 display_buffer((char *) skb->data, skb->len); 364 #endif 365 366 /* check whether WDS is enabled and whether the data frame is a WDS frame */ 367 368 if (init_wds) { 369 /* WDS enabled, check for the wds address on the first 6 bytes of the buffer */ 370 src = skb->data + 6; 371 memmove(skb->data, src, skb->len - 6); 372 skb_trim(skb, skb->len - 6); 373 } 374 #if VERBOSE > SHOW_ERROR_MESSAGES 375 DEBUG(SHOW_TRACING, "Fragment size %i in skb at %p\n", size, skb); 376 DEBUG(SHOW_TRACING, "Skb data at %p, length %i\n", skb->data, skb->len); 377 378 /* display the buffer contents for debugging */ 379 DEBUG(SHOW_BUFFER_CONTENTS, "\nrx %p ", skb->data); 380 display_buffer((char *) skb->data, skb->len); 381 #endif 382 /* take care of monitor mode and spy monitoring. */ 383 if (unlikely(priv->iw_mode == IW_MODE_MONITOR)) { 384 skb->dev = ndev; 385 discard = islpci_monitor_rx(priv, &skb); 386 } else { 387 if (unlikely(skb->data[2 * ETH_ALEN] == 0)) { 388 /* The packet has a rx_annex. Read it for spy monitoring, Then 389 * remove it, while keeping the 2 leading MAC addr. 390 */ 391 struct iw_quality wstats; 392 struct rx_annex_header *annex = 393 (struct rx_annex_header *) skb->data; 394 wstats.level = annex->rfmon.rssi; 395 /* The noise value can be a bit outdated if nobody's 396 * reading wireless stats... */ 397 wstats.noise = priv->local_iwstatistics.qual.noise; 398 wstats.qual = wstats.level - wstats.noise; 399 wstats.updated = 0x07; 400 /* Update spy records */ 401 wireless_spy_update(ndev, annex->addr2, &wstats); 402 403 skb_copy_from_linear_data(skb, 404 (skb->data + 405 sizeof(struct rfmon_header)), 406 2 * ETH_ALEN); 407 skb_pull(skb, sizeof (struct rfmon_header)); 408 } 409 skb->protocol = eth_type_trans(skb, ndev); 410 } 411 skb->ip_summed = CHECKSUM_NONE; 412 ndev->stats.rx_packets++; 413 ndev->stats.rx_bytes += size; 414 415 /* deliver the skb to the network layer */ 416 #ifdef ISLPCI_ETH_DEBUG 417 printk 418 ("islpci_eth_receive:netif_rx %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n", 419 skb->data[0], skb->data[1], skb->data[2], skb->data[3], 420 skb->data[4], skb->data[5]); 421 #endif 422 if (unlikely(discard)) { 423 dev_kfree_skb_irq(skb); 424 skb = NULL; 425 } else 426 netif_rx(skb); 427 428 /* increment the read index for the rx data low queue */ 429 priv->free_data_rx++; 430 431 /* add one or more sk_buff structures */ 432 while (index = 433 le32_to_cpu(control_block-> 434 driver_curr_frag[ISL38XX_CB_RX_DATA_LQ]), 435 index - priv->free_data_rx < ISL38XX_CB_RX_QSIZE) { 436 /* allocate an sk_buff for received data frames storage 437 * include any required allignment operations */ 438 skb = dev_alloc_skb(MAX_FRAGMENT_SIZE_RX + 2); 439 if (unlikely(skb == NULL)) { 440 /* error allocating an sk_buff structure elements */ 441 DEBUG(SHOW_ERROR_MESSAGES, "Error allocating skb\n"); 442 break; 443 } 444 skb_reserve(skb, (4 - (long) skb->data) & 0x03); 445 /* store the new skb structure pointer */ 446 index = index % ISL38XX_CB_RX_QSIZE; 447 priv->data_low_rx[index] = skb; 448 449 #if VERBOSE > SHOW_ERROR_MESSAGES 450 DEBUG(SHOW_TRACING, 451 "new alloc skb %p skb->data %p skb->len %u index %u truesize %u\n ", 452 skb, skb->data, skb->len, index, skb->truesize); 453 #endif 454 455 /* set the streaming DMA mapping for proper PCI bus operation */ 456 priv->pci_map_rx_address[index] = 457 pci_map_single(priv->pdev, (void *) skb->data, 458 MAX_FRAGMENT_SIZE_RX + 2, 459 PCI_DMA_FROMDEVICE); 460 if (unlikely(!priv->pci_map_rx_address[index])) { 461 /* error mapping the buffer to device accessible memory address */ 462 DEBUG(SHOW_ERROR_MESSAGES, 463 "Error mapping DMA address\n"); 464 465 /* free the skbuf structure before aborting */ 466 dev_kfree_skb_irq(skb); 467 skb = NULL; 468 break; 469 } 470 /* update the fragment address */ 471 control_block->rx_data_low[index].address = 472 cpu_to_le32((u32)priv->pci_map_rx_address[index]); 473 wmb(); 474 475 /* increment the driver read pointer */ 476 le32_add_cpu(&control_block-> 477 driver_curr_frag[ISL38XX_CB_RX_DATA_LQ], 1); 478 } 479 480 /* trigger the device */ 481 islpci_trigger(priv); 482 483 return 0; 484 } 485 486 void 487 islpci_do_reset_and_wake(struct work_struct *work) 488 { 489 islpci_private *priv = container_of(work, islpci_private, reset_task); 490 491 islpci_reset(priv, 1); 492 priv->reset_task_pending = 0; 493 smp_wmb(); 494 netif_wake_queue(priv->ndev); 495 } 496 497 void 498 islpci_eth_tx_timeout(struct net_device *ndev) 499 { 500 islpci_private *priv = netdev_priv(ndev); 501 502 /* increment the transmit error counter */ 503 ndev->stats.tx_errors++; 504 505 if (!priv->reset_task_pending) { 506 printk(KERN_WARNING 507 "%s: tx_timeout, scheduling reset", ndev->name); 508 netif_stop_queue(ndev); 509 priv->reset_task_pending = 1; 510 schedule_work(&priv->reset_task); 511 } else { 512 printk(KERN_WARNING 513 "%s: tx_timeout, waiting for reset", ndev->name); 514 } 515 } 516 517 #line 9 "/home/druidos/temp/331_1a/work/current--X--drivers--X--defaultlinux-3.14.1.tar.xz--X--331_1a--X--cpachecker/linux-3.14.1.tar.xz/csd_deg_dscv/6673/dscv_tempdir/dscv/ri/331_1a/drivers/net/wireless/prism54/islpci_eth.o.c.prepared"
1 /* 2 * Copyright (C) 2002 Intersil Americas Inc. 3 * Copyright 2004 Jens Maurer <Jens.Maurer@gmx.net> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, see <http://www.gnu.org/licenses/>. 16 * 17 */ 18 19 #include <linux/netdevice.h> 20 #include <linux/module.h> 21 #include <linux/pci.h> 22 #include <linux/sched.h> 23 #include <linux/slab.h> 24 25 #include <asm/io.h> 26 #include <linux/if_arp.h> 27 28 #include "prismcompat.h" 29 #include "isl_38xx.h" 30 #include "islpci_mgt.h" 31 #include "isl_oid.h" /* additional types and defs for isl38xx fw */ 32 #include "isl_ioctl.h" 33 34 #include <net/iw_handler.h> 35 36 /****************************************************************************** 37 Global variable definition section 38 ******************************************************************************/ 39 int pc_debug = VERBOSE; 40 module_param(pc_debug, int, 0); 41 42 /****************************************************************************** 43 Driver general functions 44 ******************************************************************************/ 45 #if VERBOSE > SHOW_ERROR_MESSAGES 46 void 47 display_buffer(char *buffer, int length) 48 { 49 if ((pc_debug & SHOW_BUFFER_CONTENTS) == 0) 50 return; 51 52 while (length > 0) { 53 printk("[%02x]", *buffer & 255); 54 length--; 55 buffer++; 56 } 57 58 printk("\n"); 59 } 60 #endif 61 62 /***************************************************************************** 63 Queue handling for management frames 64 ******************************************************************************/ 65 66 /* 67 * Helper function to create a PIMFOR management frame header. 68 */ 69 static void 70 pimfor_encode_header(int operation, u32 oid, u32 length, pimfor_header_t *h) 71 { 72 h->version = PIMFOR_VERSION; 73 h->operation = operation; 74 h->device_id = PIMFOR_DEV_ID_MHLI_MIB; 75 h->flags = 0; 76 h->oid = cpu_to_be32(oid); 77 h->length = cpu_to_be32(length); 78 } 79 80 /* 81 * Helper function to analyze a PIMFOR management frame header. 82 */ 83 static pimfor_header_t * 84 pimfor_decode_header(void *data, int len) 85 { 86 pimfor_header_t *h = data; 87 88 while ((void *) h < data + len) { 89 if (h->flags & PIMFOR_FLAG_LITTLE_ENDIAN) { 90 le32_to_cpus(&h->oid); 91 le32_to_cpus(&h->length); 92 } else { 93 be32_to_cpus(&h->oid); 94 be32_to_cpus(&h->length); 95 } 96 if (h->oid != OID_INL_TUNNEL) 97 return h; 98 h++; 99 } 100 return NULL; 101 } 102 103 /* 104 * Fill the receive queue for management frames with fresh buffers. 105 */ 106 int 107 islpci_mgmt_rx_fill(struct net_device *ndev) 108 { 109 islpci_private *priv = netdev_priv(ndev); 110 isl38xx_control_block *cb = /* volatile not needed */ 111 (isl38xx_control_block *) priv->control_block; 112 u32 curr = le32_to_cpu(cb->driver_curr_frag[ISL38XX_CB_RX_MGMTQ]); 113 114 #if VERBOSE > SHOW_ERROR_MESSAGES 115 DEBUG(SHOW_FUNCTION_CALLS, "islpci_mgmt_rx_fill\n"); 116 #endif 117 118 while (curr - priv->index_mgmt_rx < ISL38XX_CB_MGMT_QSIZE) { 119 u32 index = curr % ISL38XX_CB_MGMT_QSIZE; 120 struct islpci_membuf *buf = &priv->mgmt_rx[index]; 121 isl38xx_fragment *frag = &cb->rx_data_mgmt[index]; 122 123 if (buf->mem == NULL) { 124 buf->mem = kmalloc(MGMT_FRAME_SIZE, GFP_ATOMIC); 125 if (!buf->mem) 126 return -ENOMEM; 127 buf->size = MGMT_FRAME_SIZE; 128 } 129 if (buf->pci_addr == 0) { 130 buf->pci_addr = pci_map_single(priv->pdev, buf->mem, 131 MGMT_FRAME_SIZE, 132 PCI_DMA_FROMDEVICE); 133 if (!buf->pci_addr) { 134 printk(KERN_WARNING 135 "Failed to make memory DMA'able.\n"); 136 return -ENOMEM; 137 } 138 } 139 140 /* be safe: always reset control block information */ 141 frag->size = cpu_to_le16(MGMT_FRAME_SIZE); 142 frag->flags = 0; 143 frag->address = cpu_to_le32(buf->pci_addr); 144 curr++; 145 146 /* The fragment address in the control block must have 147 * been written before announcing the frame buffer to 148 * device */ 149 wmb(); 150 cb->driver_curr_frag[ISL38XX_CB_RX_MGMTQ] = cpu_to_le32(curr); 151 } 152 return 0; 153 } 154 155 /* 156 * Create and transmit a management frame using "operation" and "oid", 157 * with arguments data/length. 158 * We either return an error and free the frame, or we return 0 and 159 * islpci_mgt_cleanup_transmit() frees the frame in the tx-done 160 * interrupt. 161 */ 162 static int 163 islpci_mgt_transmit(struct net_device *ndev, int operation, unsigned long oid, 164 void *data, int length) 165 { 166 islpci_private *priv = netdev_priv(ndev); 167 isl38xx_control_block *cb = 168 (isl38xx_control_block *) priv->control_block; 169 void *p; 170 int err = -EINVAL; 171 unsigned long flags; 172 isl38xx_fragment *frag; 173 struct islpci_membuf buf; 174 u32 curr_frag; 175 int index; 176 int frag_len = length + PIMFOR_HEADER_SIZE; 177 178 #if VERBOSE > SHOW_ERROR_MESSAGES 179 DEBUG(SHOW_FUNCTION_CALLS, "islpci_mgt_transmit\n"); 180 #endif 181 182 if (frag_len > MGMT_FRAME_SIZE) { 183 printk(KERN_DEBUG "%s: mgmt frame too large %d\n", 184 ndev->name, frag_len); 185 goto error; 186 } 187 188 err = -ENOMEM; 189 p = buf.mem = kmalloc(frag_len, GFP_KERNEL); 190 if (!buf.mem) 191 goto error; 192 193 buf.size = frag_len; 194 195 /* create the header directly in the fragment data area */ 196 pimfor_encode_header(operation, oid, length, (pimfor_header_t *) p); 197 p += PIMFOR_HEADER_SIZE; 198 199 if (data) 200 memcpy(p, data, length); 201 else 202 memset(p, 0, length); 203 204 #if VERBOSE > SHOW_ERROR_MESSAGES 205 { 206 pimfor_header_t *h = buf.mem; 207 DEBUG(SHOW_PIMFOR_FRAMES, 208 "PIMFOR: op %i, oid 0x%08lx, device %i, flags 0x%x length 0x%x\n", 209 h->operation, oid, h->device_id, h->flags, length); 210 211 /* display the buffer contents for debugging */ 212 display_buffer((char *) h, sizeof (pimfor_header_t)); 213 display_buffer(p, length); 214 } 215 #endif 216 217 err = -ENOMEM; 218 buf.pci_addr = pci_map_single(priv->pdev, buf.mem, frag_len, 219 PCI_DMA_TODEVICE); 220 if (!buf.pci_addr) { 221 printk(KERN_WARNING "%s: cannot map PCI memory for mgmt\n", 222 ndev->name); 223 goto error_free; 224 } 225 226 /* Protect the control block modifications against interrupts. */ 227 spin_lock_irqsave(&priv->slock, flags); 228 curr_frag = le32_to_cpu(cb->driver_curr_frag[ISL38XX_CB_TX_MGMTQ]); 229 if (curr_frag - priv->index_mgmt_tx >= ISL38XX_CB_MGMT_QSIZE) { 230 printk(KERN_WARNING "%s: mgmt tx queue is still full\n", 231 ndev->name); 232 goto error_unlock; 233 } 234 235 /* commit the frame to the tx device queue */ 236 index = curr_frag % ISL38XX_CB_MGMT_QSIZE; 237 priv->mgmt_tx[index] = buf; 238 frag = &cb->tx_data_mgmt[index]; 239 frag->size = cpu_to_le16(frag_len); 240 frag->flags = 0; /* for any other than the last fragment, set to 1 */ 241 frag->address = cpu_to_le32(buf.pci_addr); 242 243 /* The fragment address in the control block must have 244 * been written before announcing the frame buffer to 245 * device */ 246 wmb(); 247 cb->driver_curr_frag[ISL38XX_CB_TX_MGMTQ] = cpu_to_le32(curr_frag + 1); 248 spin_unlock_irqrestore(&priv->slock, flags); 249 250 /* trigger the device */ 251 islpci_trigger(priv); 252 return 0; 253 254 error_unlock: 255 spin_unlock_irqrestore(&priv->slock, flags); 256 error_free: 257 kfree(buf.mem); 258 error: 259 return err; 260 } 261 262 /* 263 * Receive a management frame from the device. 264 * This can be an arbitrary number of traps, and at most one response 265 * frame for a previous request sent via islpci_mgt_transmit(). 266 */ 267 int 268 islpci_mgt_receive(struct net_device *ndev) 269 { 270 islpci_private *priv = netdev_priv(ndev); 271 isl38xx_control_block *cb = 272 (isl38xx_control_block *) priv->control_block; 273 u32 curr_frag; 274 275 #if VERBOSE > SHOW_ERROR_MESSAGES 276 DEBUG(SHOW_FUNCTION_CALLS, "islpci_mgt_receive\n"); 277 #endif 278 279 /* Only once per interrupt, determine fragment range to 280 * process. This avoids an endless loop (i.e. lockup) if 281 * frames come in faster than we can process them. */ 282 curr_frag = le32_to_cpu(cb->device_curr_frag[ISL38XX_CB_RX_MGMTQ]); 283 barrier(); 284 285 for (; priv->index_mgmt_rx < curr_frag; priv->index_mgmt_rx++) { 286 pimfor_header_t *header; 287 u32 index = priv->index_mgmt_rx % ISL38XX_CB_MGMT_QSIZE; 288 struct islpci_membuf *buf = &priv->mgmt_rx[index]; 289 u16 frag_len; 290 int size; 291 struct islpci_mgmtframe *frame; 292 293 /* I have no idea (and no documentation) if flags != 0 294 * is possible. Drop the frame, reuse the buffer. */ 295 if (le16_to_cpu(cb->rx_data_mgmt[index].flags) != 0) { 296 printk(KERN_WARNING "%s: unknown flags 0x%04x\n", 297 ndev->name, 298 le16_to_cpu(cb->rx_data_mgmt[index].flags)); 299 continue; 300 } 301 302 /* The device only returns the size of the header(s) here. */ 303 frag_len = le16_to_cpu(cb->rx_data_mgmt[index].size); 304 305 /* 306 * We appear to have no way to tell the device the 307 * size of a receive buffer. Thus, if this check 308 * triggers, we likely have kernel heap corruption. */ 309 if (frag_len > MGMT_FRAME_SIZE) { 310 printk(KERN_WARNING 311 "%s: Bogus packet size of %d (%#x).\n", 312 ndev->name, frag_len, frag_len); 313 frag_len = MGMT_FRAME_SIZE; 314 } 315 316 /* Ensure the results of device DMA are visible to the CPU. */ 317 pci_dma_sync_single_for_cpu(priv->pdev, buf->pci_addr, 318 buf->size, PCI_DMA_FROMDEVICE); 319 320 /* Perform endianess conversion for PIMFOR header in-place. */ 321 header = pimfor_decode_header(buf->mem, frag_len); 322 if (!header) { 323 printk(KERN_WARNING "%s: no PIMFOR header found\n", 324 ndev->name); 325 continue; 326 } 327 328 /* The device ID from the PIMFOR packet received from 329 * the MVC is always 0. We forward a sensible device_id. 330 * Not that anyone upstream would care... */ 331 header->device_id = priv->ndev->ifindex; 332 333 #if VERBOSE > SHOW_ERROR_MESSAGES 334 DEBUG(SHOW_PIMFOR_FRAMES, 335 "PIMFOR: op %i, oid 0x%08x, device %i, flags 0x%x length 0x%x\n", 336 header->operation, header->oid, header->device_id, 337 header->flags, header->length); 338 339 /* display the buffer contents for debugging */ 340 display_buffer((char *) header, PIMFOR_HEADER_SIZE); 341 display_buffer((char *) header + PIMFOR_HEADER_SIZE, 342 header->length); 343 #endif 344 345 /* nobody sends these */ 346 if (header->flags & PIMFOR_FLAG_APPLIC_ORIGIN) { 347 printk(KERN_DEBUG 348 "%s: errant PIMFOR application frame\n", 349 ndev->name); 350 continue; 351 } 352 353 /* Determine frame size, skipping OID_INL_TUNNEL headers. */ 354 size = PIMFOR_HEADER_SIZE + header->length; 355 frame = kmalloc(sizeof(struct islpci_mgmtframe) + size, 356 GFP_ATOMIC); 357 if (!frame) 358 continue; 359 360 frame->ndev = ndev; 361 memcpy(&frame->buf, header, size); 362 frame->header = (pimfor_header_t *) frame->buf; 363 frame->data = frame->buf + PIMFOR_HEADER_SIZE; 364 365 #if VERBOSE > SHOW_ERROR_MESSAGES 366 DEBUG(SHOW_PIMFOR_FRAMES, 367 "frame: header: %p, data: %p, size: %d\n", 368 frame->header, frame->data, size); 369 #endif 370 371 if (header->operation == PIMFOR_OP_TRAP) { 372 #if VERBOSE > SHOW_ERROR_MESSAGES 373 printk(KERN_DEBUG 374 "TRAP: oid 0x%x, device %i, flags 0x%x length %i\n", 375 header->oid, header->device_id, header->flags, 376 header->length); 377 #endif 378 379 /* Create work to handle trap out of interrupt 380 * context. */ 381 INIT_WORK(&frame->ws, prism54_process_trap); 382 schedule_work(&frame->ws); 383 384 } else { 385 /* Signal the one waiting process that a response 386 * has been received. */ 387 if ((frame = xchg(&priv->mgmt_received, frame)) != NULL) { 388 printk(KERN_WARNING 389 "%s: mgmt response not collected\n", 390 ndev->name); 391 kfree(frame); 392 } 393 #if VERBOSE > SHOW_ERROR_MESSAGES 394 DEBUG(SHOW_TRACING, "Wake up Mgmt Queue\n"); 395 #endif 396 wake_up(&priv->mgmt_wqueue); 397 } 398 399 } 400 401 return 0; 402 } 403 404 /* 405 * Cleanup the transmit queue by freeing all frames handled by the device. 406 */ 407 void 408 islpci_mgt_cleanup_transmit(struct net_device *ndev) 409 { 410 islpci_private *priv = netdev_priv(ndev); 411 isl38xx_control_block *cb = /* volatile not needed */ 412 (isl38xx_control_block *) priv->control_block; 413 u32 curr_frag; 414 415 #if VERBOSE > SHOW_ERROR_MESSAGES 416 DEBUG(SHOW_FUNCTION_CALLS, "islpci_mgt_cleanup_transmit\n"); 417 #endif 418 419 /* Only once per cleanup, determine fragment range to 420 * process. This avoids an endless loop (i.e. lockup) if 421 * the device became confused, incrementing device_curr_frag 422 * rapidly. */ 423 curr_frag = le32_to_cpu(cb->device_curr_frag[ISL38XX_CB_TX_MGMTQ]); 424 barrier(); 425 426 for (; priv->index_mgmt_tx < curr_frag; priv->index_mgmt_tx++) { 427 int index = priv->index_mgmt_tx % ISL38XX_CB_MGMT_QSIZE; 428 struct islpci_membuf *buf = &priv->mgmt_tx[index]; 429 pci_unmap_single(priv->pdev, buf->pci_addr, buf->size, 430 PCI_DMA_TODEVICE); 431 buf->pci_addr = 0; 432 kfree(buf->mem); 433 buf->mem = NULL; 434 buf->size = 0; 435 } 436 } 437 438 /* 439 * Perform one request-response transaction to the device. 440 */ 441 int 442 islpci_mgt_transaction(struct net_device *ndev, 443 int operation, unsigned long oid, 444 void *senddata, int sendlen, 445 struct islpci_mgmtframe **recvframe) 446 { 447 islpci_private *priv = netdev_priv(ndev); 448 const long wait_cycle_jiffies = msecs_to_jiffies(ISL38XX_WAIT_CYCLE * 10); 449 long timeout_left = ISL38XX_MAX_WAIT_CYCLES * wait_cycle_jiffies; 450 int err; 451 DEFINE_WAIT(wait); 452 453 *recvframe = NULL; 454 455 if (mutex_lock_interruptible(&priv->mgmt_lock)) 456 return -ERESTARTSYS; 457 458 prepare_to_wait(&priv->mgmt_wqueue, &wait, TASK_UNINTERRUPTIBLE); 459 err = islpci_mgt_transmit(ndev, operation, oid, senddata, sendlen); 460 if (err) 461 goto out; 462 463 err = -ETIMEDOUT; 464 while (timeout_left > 0) { 465 int timeleft; 466 struct islpci_mgmtframe *frame; 467 468 timeleft = schedule_timeout_uninterruptible(wait_cycle_jiffies); 469 frame = xchg(&priv->mgmt_received, NULL); 470 if (frame) { 471 if (frame->header->oid == oid) { 472 *recvframe = frame; 473 err = 0; 474 goto out; 475 } else { 476 printk(KERN_DEBUG 477 "%s: expecting oid 0x%x, received 0x%x.\n", 478 ndev->name, (unsigned int) oid, 479 frame->header->oid); 480 kfree(frame); 481 frame = NULL; 482 } 483 } 484 if (timeleft == 0) { 485 printk(KERN_DEBUG 486 "%s: timeout waiting for mgmt response %lu, " 487 "triggering device\n", 488 ndev->name, timeout_left); 489 islpci_trigger(priv); 490 } 491 timeout_left += timeleft - wait_cycle_jiffies; 492 } 493 printk(KERN_WARNING "%s: timeout waiting for mgmt response\n", 494 ndev->name); 495 496 /* TODO: we should reset the device here */ 497 out: 498 finish_wait(&priv->mgmt_wqueue, &wait); 499 mutex_unlock(&priv->mgmt_lock); 500 return err; 501 }
1 2 #include <linux/types.h> 3 #include <linux/dma-direction.h> 4 #include <verifier/rcv.h> 5 #include <verifier/set.h> 6 #include <verifier/map.h> 7 8 Set LDV_DMA_MAP_CALLS; 9 10 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_dma_map_page') maps page */ 11 dma_addr_t ldv_dma_map_page(struct device *dev, struct page *page, size_t offset, size_t size, enum dma_data_direction dir) { 12 dma_addr_t nonedetermined; 13 14 nonedetermined = ldv_undef_ptr(); 15 16 /* LDV_COMMENT_ASSERT Check that previos dma_mapping call was checked*/ 17 ldv_assert(ldv_set_is_empty(LDV_DMA_MAP_CALLS)); 18 19 ldv_set_add(LDV_DMA_MAP_CALLS, nonedetermined); 20 21 return nonedetermined; 22 } 23 24 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_dma_mapping_error') unmaps page */ 25 int ldv_dma_mapping_error(struct device *dev, dma_addr_t dma_addr) { 26 27 /* LDV_COMMENT_ASSERT No dma_mapping calls to verify */ 28 ldv_assert(ldv_set_contains(LDV_DMA_MAP_CALLS, dma_addr)); 29 ldv_set_remove(LDV_DMA_MAP_CALLS, dma_addr); 30 31 int nonedetermined; 32 33 nonedetermined = ldv_undef_int(); 34 35 return nonedetermined; 36 } 37 38 39 40 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_dma_map_single') maps pci_dma */ 41 dma_addr_t ldv_dma_map_single(struct device *dev, void *cpu_addr, size_t size, enum dma_data_direction dir) { 42 dma_addr_t nonedetermined; 43 44 nonedetermined = ldv_undef_ptr(); 45 46 /* LDV_COMMENT_ASSERT Check that previos dma_mapping call was checked*/ 47 ldv_assert(ldv_set_is_empty(LDV_DMA_MAP_CALLS)); 48 49 ldv_set_add(LDV_DMA_MAP_CALLS, nonedetermined); 50 51 return nonedetermined; 52 } 53 54 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_dma_map_single_attrs') maps pci_dma */ 55 dma_addr_t ldv_dma_map_single_attrs(struct device *dev, void *ptr, size_t size, enum dma_data_direction dir, struct dma_attrs *attrs) { 56 dma_addr_t nonedetermined; 57 58 nonedetermined = ldv_undef_ptr(); 59 60 /* LDV_COMMENT_ASSERT Check that previos dma_mapping call was checked*/ 61 ldv_assert(ldv_set_is_empty(LDV_DMA_MAP_CALLS)); 62 63 ldv_set_add(LDV_DMA_MAP_CALLS, nonedetermined); 64 65 return nonedetermined; 66 } 67 68 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_initialize') Initialize all module reference counters at the beginning */ 69 void ldv_initialize(void) { 70 /* LDV_COMMENT_CHANGE_STATE All module reference counters have some initial value at the beginning */ 71 ldv_set_init(LDV_DMA_MAP_CALLS); 72 } 73 74 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_check_final_state') Check that all module reference counters have their initial values at the end */ 75 void ldv_check_final_state(void) { 76 /* LDV_COMMENT_ASSERT All incremented module reference counters should be decremented before module unloading*/ 77 ldv_assert(ldv_set_is_empty(LDV_DMA_MAP_CALLS)); 78 }
1 /* include this file if the platform implements the dma_ DMA Mapping API 2 * and wants to provide the pci_ DMA Mapping API in terms of it */ 3 4 #ifndef _ASM_GENERIC_PCI_DMA_COMPAT_H 5 #define _ASM_GENERIC_PCI_DMA_COMPAT_H 6 7 #include <linux/dma-mapping.h> 8 9 static inline int 10 pci_dma_supported(struct pci_dev *hwdev, u64 mask) 11 { 12 return dma_supported(hwdev == NULL ? NULL : &hwdev->dev, mask); 13 } 14 15 static inline void * 16 pci_alloc_consistent(struct pci_dev *hwdev, size_t size, 17 dma_addr_t *dma_handle) 18 { 19 return dma_alloc_coherent(hwdev == NULL ? NULL : &hwdev->dev, size, dma_handle, GFP_ATOMIC); 20 } 21 22 static inline void 23 pci_free_consistent(struct pci_dev *hwdev, size_t size, 24 void *vaddr, dma_addr_t dma_handle) 25 { 26 dma_free_coherent(hwdev == NULL ? NULL : &hwdev->dev, size, vaddr, dma_handle); 27 } 28 29 static inline dma_addr_t 30 pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction) 31 { 32 return dma_map_single(hwdev == NULL ? NULL : &hwdev->dev, ptr, size, (enum dma_data_direction)direction); 33 } 34 35 static inline void 36 pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr, 37 size_t size, int direction) 38 { 39 dma_unmap_single(hwdev == NULL ? NULL : &hwdev->dev, dma_addr, size, (enum dma_data_direction)direction); 40 } 41 42 static inline dma_addr_t 43 pci_map_page(struct pci_dev *hwdev, struct page *page, 44 unsigned long offset, size_t size, int direction) 45 { 46 return dma_map_page(hwdev == NULL ? NULL : &hwdev->dev, page, offset, size, (enum dma_data_direction)direction); 47 } 48 49 static inline void 50 pci_unmap_page(struct pci_dev *hwdev, dma_addr_t dma_address, 51 size_t size, int direction) 52 { 53 dma_unmap_page(hwdev == NULL ? NULL : &hwdev->dev, dma_address, size, (enum dma_data_direction)direction); 54 } 55 56 static inline int 57 pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg, 58 int nents, int direction) 59 { 60 return dma_map_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nents, (enum dma_data_direction)direction); 61 } 62 63 static inline void 64 pci_unmap_sg(struct pci_dev *hwdev, struct scatterlist *sg, 65 int nents, int direction) 66 { 67 dma_unmap_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nents, (enum dma_data_direction)direction); 68 } 69 70 static inline void 71 pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle, 72 size_t size, int direction) 73 { 74 dma_sync_single_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction); 75 } 76 77 static inline void 78 pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle, 79 size_t size, int direction) 80 { 81 dma_sync_single_for_device(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction); 82 } 83 84 static inline void 85 pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg, 86 int nelems, int direction) 87 { 88 dma_sync_sg_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction); 89 } 90 91 static inline void 92 pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg, 93 int nelems, int direction) 94 { 95 dma_sync_sg_for_device(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction); 96 } 97 98 static inline int 99 pci_dma_mapping_error(struct pci_dev *pdev, dma_addr_t dma_addr) 100 { 101 return dma_mapping_error(&pdev->dev, dma_addr); 102 } 103 104 #ifdef CONFIG_PCI 105 static inline int pci_set_dma_mask(struct pci_dev *dev, u64 mask) 106 { 107 return dma_set_mask(&dev->dev, mask); 108 } 109 110 static inline int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask) 111 { 112 return dma_set_coherent_mask(&dev->dev, mask); 113 } 114 #endif 115 116 #endif
1 /* 2 * INET An implementation of the TCP/IP protocol suite for the LINUX 3 * operating system. INET is implemented using the BSD Socket 4 * interface as the means of communication with the user level. 5 * 6 * Definitions for the Interfaces handler. 7 * 8 * Version: @(#)dev.h 1.0.10 08/12/93 9 * 10 * Authors: Ross Biro 11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 12 * Corey Minyard <wf-rch!minyard@relay.EU.net> 13 * Donald J. Becker, <becker@cesdis.gsfc.nasa.gov> 14 * Alan Cox, <alan@lxorguk.ukuu.org.uk> 15 * Bjorn Ekwall. <bj0rn@blox.se> 16 * Pekka Riikonen <priikone@poseidon.pspt.fi> 17 * 18 * This program is free software; you can redistribute it and/or 19 * modify it under the terms of the GNU General Public License 20 * as published by the Free Software Foundation; either version 21 * 2 of the License, or (at your option) any later version. 22 * 23 * Moved to /usr/include/linux for NET3 24 */ 25 #ifndef _LINUX_NETDEVICE_H 26 #define _LINUX_NETDEVICE_H 27 28 #include <linux/pm_qos.h> 29 #include <linux/timer.h> 30 #include <linux/bug.h> 31 #include <linux/delay.h> 32 #include <linux/atomic.h> 33 #include <asm/cache.h> 34 #include <asm/byteorder.h> 35 36 #include <linux/percpu.h> 37 #include <linux/rculist.h> 38 #include <linux/dmaengine.h> 39 #include <linux/workqueue.h> 40 #include <linux/dynamic_queue_limits.h> 41 42 #include <linux/ethtool.h> 43 #include <net/net_namespace.h> 44 #include <net/dsa.h> 45 #ifdef CONFIG_DCB 46 #include <net/dcbnl.h> 47 #endif 48 #include <net/netprio_cgroup.h> 49 50 #include <linux/netdev_features.h> 51 #include <linux/neighbour.h> 52 #include <uapi/linux/netdevice.h> 53 54 struct netpoll_info; 55 struct device; 56 struct phy_device; 57 /* 802.11 specific */ 58 struct wireless_dev; 59 /* source back-compat hooks */ 60 #define SET_ETHTOOL_OPS(netdev,ops) \ 61 ( (netdev)->ethtool_ops = (ops) ) 62 63 void netdev_set_default_ethtool_ops(struct net_device *dev, 64 const struct ethtool_ops *ops); 65 66 /* hardware address assignment types */ 67 #define NET_ADDR_PERM 0 /* address is permanent (default) */ 68 #define NET_ADDR_RANDOM 1 /* address is generated randomly */ 69 #define NET_ADDR_STOLEN 2 /* address is stolen from other device */ 70 #define NET_ADDR_SET 3 /* address is set using 71 * dev_set_mac_address() */ 72 73 /* Backlog congestion levels */ 74 #define NET_RX_SUCCESS 0 /* keep 'em coming, baby */ 75 #define NET_RX_DROP 1 /* packet dropped */ 76 77 /* 78 * Transmit return codes: transmit return codes originate from three different 79 * namespaces: 80 * 81 * - qdisc return codes 82 * - driver transmit return codes 83 * - errno values 84 * 85 * Drivers are allowed to return any one of those in their hard_start_xmit() 86 * function. Real network devices commonly used with qdiscs should only return 87 * the driver transmit return codes though - when qdiscs are used, the actual 88 * transmission happens asynchronously, so the value is not propagated to 89 * higher layers. Virtual network devices transmit synchronously, in this case 90 * the driver transmit return codes are consumed by dev_queue_xmit(), all 91 * others are propagated to higher layers. 92 */ 93 94 /* qdisc ->enqueue() return codes. */ 95 #define NET_XMIT_SUCCESS 0x00 96 #define NET_XMIT_DROP 0x01 /* skb dropped */ 97 #define NET_XMIT_CN 0x02 /* congestion notification */ 98 #define NET_XMIT_POLICED 0x03 /* skb is shot by police */ 99 #define NET_XMIT_MASK 0x0f /* qdisc flags in net/sch_generic.h */ 100 101 /* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It 102 * indicates that the device will soon be dropping packets, or already drops 103 * some packets of the same priority; prompting us to send less aggressively. */ 104 #define net_xmit_eval(e) ((e) == NET_XMIT_CN ? 0 : (e)) 105 #define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0) 106 107 /* Driver transmit return codes */ 108 #define NETDEV_TX_MASK 0xf0 109 110 enum netdev_tx { 111 __NETDEV_TX_MIN = INT_MIN, /* make sure enum is signed */ 112 NETDEV_TX_OK = 0x00, /* driver took care of packet */ 113 NETDEV_TX_BUSY = 0x10, /* driver tx path was busy*/ 114 NETDEV_TX_LOCKED = 0x20, /* driver tx lock was already taken */ 115 }; 116 typedef enum netdev_tx netdev_tx_t; 117 118 /* 119 * Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant; 120 * hard_start_xmit() return < NET_XMIT_MASK means skb was consumed. 121 */ 122 static inline bool dev_xmit_complete(int rc) 123 { 124 /* 125 * Positive cases with an skb consumed by a driver: 126 * - successful transmission (rc == NETDEV_TX_OK) 127 * - error while transmitting (rc < 0) 128 * - error while queueing to a different device (rc & NET_XMIT_MASK) 129 */ 130 if (likely(rc < NET_XMIT_MASK)) 131 return true; 132 133 return false; 134 } 135 136 /* 137 * Compute the worst case header length according to the protocols 138 * used. 139 */ 140 141 #if defined(CONFIG_WLAN) || IS_ENABLED(CONFIG_AX25) 142 # if defined(CONFIG_MAC80211_MESH) 143 # define LL_MAX_HEADER 128 144 # else 145 # define LL_MAX_HEADER 96 146 # endif 147 #else 148 # define LL_MAX_HEADER 32 149 #endif 150 151 #if !IS_ENABLED(CONFIG_NET_IPIP) && !IS_ENABLED(CONFIG_NET_IPGRE) && \ 152 !IS_ENABLED(CONFIG_IPV6_SIT) && !IS_ENABLED(CONFIG_IPV6_TUNNEL) 153 #define MAX_HEADER LL_MAX_HEADER 154 #else 155 #define MAX_HEADER (LL_MAX_HEADER + 48) 156 #endif 157 158 /* 159 * Old network device statistics. Fields are native words 160 * (unsigned long) so they can be read and written atomically. 161 */ 162 163 struct net_device_stats { 164 unsigned long rx_packets; 165 unsigned long tx_packets; 166 unsigned long rx_bytes; 167 unsigned long tx_bytes; 168 unsigned long rx_errors; 169 unsigned long tx_errors; 170 unsigned long rx_dropped; 171 unsigned long tx_dropped; 172 unsigned long multicast; 173 unsigned long collisions; 174 unsigned long rx_length_errors; 175 unsigned long rx_over_errors; 176 unsigned long rx_crc_errors; 177 unsigned long rx_frame_errors; 178 unsigned long rx_fifo_errors; 179 unsigned long rx_missed_errors; 180 unsigned long tx_aborted_errors; 181 unsigned long tx_carrier_errors; 182 unsigned long tx_fifo_errors; 183 unsigned long tx_heartbeat_errors; 184 unsigned long tx_window_errors; 185 unsigned long rx_compressed; 186 unsigned long tx_compressed; 187 }; 188 189 190 #include <linux/cache.h> 191 #include <linux/skbuff.h> 192 193 #ifdef CONFIG_RPS 194 #include <linux/static_key.h> 195 extern struct static_key rps_needed; 196 #endif 197 198 struct neighbour; 199 struct neigh_parms; 200 struct sk_buff; 201 202 struct netdev_hw_addr { 203 struct list_head list; 204 unsigned char addr[MAX_ADDR_LEN]; 205 unsigned char type; 206 #define NETDEV_HW_ADDR_T_LAN 1 207 #define NETDEV_HW_ADDR_T_SAN 2 208 #define NETDEV_HW_ADDR_T_SLAVE 3 209 #define NETDEV_HW_ADDR_T_UNICAST 4 210 #define NETDEV_HW_ADDR_T_MULTICAST 5 211 bool global_use; 212 int sync_cnt; 213 int refcount; 214 int synced; 215 struct rcu_head rcu_head; 216 }; 217 218 struct netdev_hw_addr_list { 219 struct list_head list; 220 int count; 221 }; 222 223 #define netdev_hw_addr_list_count(l) ((l)->count) 224 #define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0) 225 #define netdev_hw_addr_list_for_each(ha, l) \ 226 list_for_each_entry(ha, &(l)->list, list) 227 228 #define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc) 229 #define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc) 230 #define netdev_for_each_uc_addr(ha, dev) \ 231 netdev_hw_addr_list_for_each(ha, &(dev)->uc) 232 233 #define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc) 234 #define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc) 235 #define netdev_for_each_mc_addr(ha, dev) \ 236 netdev_hw_addr_list_for_each(ha, &(dev)->mc) 237 238 struct hh_cache { 239 u16 hh_len; 240 u16 __pad; 241 seqlock_t hh_lock; 242 243 /* cached hardware header; allow for machine alignment needs. */ 244 #define HH_DATA_MOD 16 245 #define HH_DATA_OFF(__len) \ 246 (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1)) 247 #define HH_DATA_ALIGN(__len) \ 248 (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1)) 249 unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)]; 250 }; 251 252 /* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much. 253 * Alternative is: 254 * dev->hard_header_len ? (dev->hard_header_len + 255 * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0 256 * 257 * We could use other alignment values, but we must maintain the 258 * relationship HH alignment <= LL alignment. 259 */ 260 #define LL_RESERVED_SPACE(dev) \ 261 ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD) 262 #define LL_RESERVED_SPACE_EXTRA(dev,extra) \ 263 ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD) 264 265 struct header_ops { 266 int (*create) (struct sk_buff *skb, struct net_device *dev, 267 unsigned short type, const void *daddr, 268 const void *saddr, unsigned int len); 269 int (*parse)(const struct sk_buff *skb, unsigned char *haddr); 270 int (*rebuild)(struct sk_buff *skb); 271 int (*cache)(const struct neighbour *neigh, struct hh_cache *hh, __be16 type); 272 void (*cache_update)(struct hh_cache *hh, 273 const struct net_device *dev, 274 const unsigned char *haddr); 275 }; 276 277 /* These flag bits are private to the generic network queueing 278 * layer, they may not be explicitly referenced by any other 279 * code. 280 */ 281 282 enum netdev_state_t { 283 __LINK_STATE_START, 284 __LINK_STATE_PRESENT, 285 __LINK_STATE_NOCARRIER, 286 __LINK_STATE_LINKWATCH_PENDING, 287 __LINK_STATE_DORMANT, 288 }; 289 290 291 /* 292 * This structure holds at boot time configured netdevice settings. They 293 * are then used in the device probing. 294 */ 295 struct netdev_boot_setup { 296 char name[IFNAMSIZ]; 297 struct ifmap map; 298 }; 299 #define NETDEV_BOOT_SETUP_MAX 8 300 301 int __init netdev_boot_setup(char *str); 302 303 /* 304 * Structure for NAPI scheduling similar to tasklet but with weighting 305 */ 306 struct napi_struct { 307 /* The poll_list must only be managed by the entity which 308 * changes the state of the NAPI_STATE_SCHED bit. This means 309 * whoever atomically sets that bit can add this napi_struct 310 * to the per-cpu poll_list, and whoever clears that bit 311 * can remove from the list right before clearing the bit. 312 */ 313 struct list_head poll_list; 314 315 unsigned long state; 316 int weight; 317 unsigned int gro_count; 318 int (*poll)(struct napi_struct *, int); 319 #ifdef CONFIG_NETPOLL 320 spinlock_t poll_lock; 321 int poll_owner; 322 #endif 323 struct net_device *dev; 324 struct sk_buff *gro_list; 325 struct sk_buff *skb; 326 struct list_head dev_list; 327 struct hlist_node napi_hash_node; 328 unsigned int napi_id; 329 }; 330 331 enum { 332 NAPI_STATE_SCHED, /* Poll is scheduled */ 333 NAPI_STATE_DISABLE, /* Disable pending */ 334 NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */ 335 NAPI_STATE_HASHED, /* In NAPI hash */ 336 }; 337 338 enum gro_result { 339 GRO_MERGED, 340 GRO_MERGED_FREE, 341 GRO_HELD, 342 GRO_NORMAL, 343 GRO_DROP, 344 }; 345 typedef enum gro_result gro_result_t; 346 347 /* 348 * enum rx_handler_result - Possible return values for rx_handlers. 349 * @RX_HANDLER_CONSUMED: skb was consumed by rx_handler, do not process it 350 * further. 351 * @RX_HANDLER_ANOTHER: Do another round in receive path. This is indicated in 352 * case skb->dev was changed by rx_handler. 353 * @RX_HANDLER_EXACT: Force exact delivery, no wildcard. 354 * @RX_HANDLER_PASS: Do nothing, passe the skb as if no rx_handler was called. 355 * 356 * rx_handlers are functions called from inside __netif_receive_skb(), to do 357 * special processing of the skb, prior to delivery to protocol handlers. 358 * 359 * Currently, a net_device can only have a single rx_handler registered. Trying 360 * to register a second rx_handler will return -EBUSY. 361 * 362 * To register a rx_handler on a net_device, use netdev_rx_handler_register(). 363 * To unregister a rx_handler on a net_device, use 364 * netdev_rx_handler_unregister(). 365 * 366 * Upon return, rx_handler is expected to tell __netif_receive_skb() what to 367 * do with the skb. 368 * 369 * If the rx_handler consumed to skb in some way, it should return 370 * RX_HANDLER_CONSUMED. This is appropriate when the rx_handler arranged for 371 * the skb to be delivered in some other ways. 372 * 373 * If the rx_handler changed skb->dev, to divert the skb to another 374 * net_device, it should return RX_HANDLER_ANOTHER. The rx_handler for the 375 * new device will be called if it exists. 376 * 377 * If the rx_handler consider the skb should be ignored, it should return 378 * RX_HANDLER_EXACT. The skb will only be delivered to protocol handlers that 379 * are registered on exact device (ptype->dev == skb->dev). 380 * 381 * If the rx_handler didn't changed skb->dev, but want the skb to be normally 382 * delivered, it should return RX_HANDLER_PASS. 383 * 384 * A device without a registered rx_handler will behave as if rx_handler 385 * returned RX_HANDLER_PASS. 386 */ 387 388 enum rx_handler_result { 389 RX_HANDLER_CONSUMED, 390 RX_HANDLER_ANOTHER, 391 RX_HANDLER_EXACT, 392 RX_HANDLER_PASS, 393 }; 394 typedef enum rx_handler_result rx_handler_result_t; 395 typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb); 396 397 void __napi_schedule(struct napi_struct *n); 398 399 static inline bool napi_disable_pending(struct napi_struct *n) 400 { 401 return test_bit(NAPI_STATE_DISABLE, &n->state); 402 } 403 404 /** 405 * napi_schedule_prep - check if napi can be scheduled 406 * @n: napi context 407 * 408 * Test if NAPI routine is already running, and if not mark 409 * it as running. This is used as a condition variable 410 * insure only one NAPI poll instance runs. We also make 411 * sure there is no pending NAPI disable. 412 */ 413 static inline bool napi_schedule_prep(struct napi_struct *n) 414 { 415 return !napi_disable_pending(n) && 416 !test_and_set_bit(NAPI_STATE_SCHED, &n->state); 417 } 418 419 /** 420 * napi_schedule - schedule NAPI poll 421 * @n: napi context 422 * 423 * Schedule NAPI poll routine to be called if it is not already 424 * running. 425 */ 426 static inline void napi_schedule(struct napi_struct *n) 427 { 428 if (napi_schedule_prep(n)) 429 __napi_schedule(n); 430 } 431 432 /* Try to reschedule poll. Called by dev->poll() after napi_complete(). */ 433 static inline bool napi_reschedule(struct napi_struct *napi) 434 { 435 if (napi_schedule_prep(napi)) { 436 __napi_schedule(napi); 437 return true; 438 } 439 return false; 440 } 441 442 /** 443 * napi_complete - NAPI processing complete 444 * @n: napi context 445 * 446 * Mark NAPI processing as complete. 447 */ 448 void __napi_complete(struct napi_struct *n); 449 void napi_complete(struct napi_struct *n); 450 451 /** 452 * napi_by_id - lookup a NAPI by napi_id 453 * @napi_id: hashed napi_id 454 * 455 * lookup @napi_id in napi_hash table 456 * must be called under rcu_read_lock() 457 */ 458 struct napi_struct *napi_by_id(unsigned int napi_id); 459 460 /** 461 * napi_hash_add - add a NAPI to global hashtable 462 * @napi: napi context 463 * 464 * generate a new napi_id and store a @napi under it in napi_hash 465 */ 466 void napi_hash_add(struct napi_struct *napi); 467 468 /** 469 * napi_hash_del - remove a NAPI from global table 470 * @napi: napi context 471 * 472 * Warning: caller must observe rcu grace period 473 * before freeing memory containing @napi 474 */ 475 void napi_hash_del(struct napi_struct *napi); 476 477 /** 478 * napi_disable - prevent NAPI from scheduling 479 * @n: napi context 480 * 481 * Stop NAPI from being scheduled on this context. 482 * Waits till any outstanding processing completes. 483 */ 484 static inline void napi_disable(struct napi_struct *n) 485 { 486 might_sleep(); 487 set_bit(NAPI_STATE_DISABLE, &n->state); 488 while (test_and_set_bit(NAPI_STATE_SCHED, &n->state)) 489 msleep(1); 490 clear_bit(NAPI_STATE_DISABLE, &n->state); 491 } 492 493 /** 494 * napi_enable - enable NAPI scheduling 495 * @n: napi context 496 * 497 * Resume NAPI from being scheduled on this context. 498 * Must be paired with napi_disable. 499 */ 500 static inline void napi_enable(struct napi_struct *n) 501 { 502 BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state)); 503 smp_mb__before_clear_bit(); 504 clear_bit(NAPI_STATE_SCHED, &n->state); 505 } 506 507 #ifdef CONFIG_SMP 508 /** 509 * napi_synchronize - wait until NAPI is not running 510 * @n: napi context 511 * 512 * Wait until NAPI is done being scheduled on this context. 513 * Waits till any outstanding processing completes but 514 * does not disable future activations. 515 */ 516 static inline void napi_synchronize(const struct napi_struct *n) 517 { 518 while (test_bit(NAPI_STATE_SCHED, &n->state)) 519 msleep(1); 520 } 521 #else 522 # define napi_synchronize(n) barrier() 523 #endif 524 525 enum netdev_queue_state_t { 526 __QUEUE_STATE_DRV_XOFF, 527 __QUEUE_STATE_STACK_XOFF, 528 __QUEUE_STATE_FROZEN, 529 #define QUEUE_STATE_ANY_XOFF ((1 << __QUEUE_STATE_DRV_XOFF) | \ 530 (1 << __QUEUE_STATE_STACK_XOFF)) 531 #define QUEUE_STATE_ANY_XOFF_OR_FROZEN (QUEUE_STATE_ANY_XOFF | \ 532 (1 << __QUEUE_STATE_FROZEN)) 533 }; 534 /* 535 * __QUEUE_STATE_DRV_XOFF is used by drivers to stop the transmit queue. The 536 * netif_tx_* functions below are used to manipulate this flag. The 537 * __QUEUE_STATE_STACK_XOFF flag is used by the stack to stop the transmit 538 * queue independently. The netif_xmit_*stopped functions below are called 539 * to check if the queue has been stopped by the driver or stack (either 540 * of the XOFF bits are set in the state). Drivers should not need to call 541 * netif_xmit*stopped functions, they should only be using netif_tx_*. 542 */ 543 544 struct netdev_queue { 545 /* 546 * read mostly part 547 */ 548 struct net_device *dev; 549 struct Qdisc *qdisc; 550 struct Qdisc *qdisc_sleeping; 551 #ifdef CONFIG_SYSFS 552 struct kobject kobj; 553 #endif 554 #if defined(CONFIG_XPS) && defined(CONFIG_NUMA) 555 int numa_node; 556 #endif 557 /* 558 * write mostly part 559 */ 560 spinlock_t _xmit_lock ____cacheline_aligned_in_smp; 561 int xmit_lock_owner; 562 /* 563 * please use this field instead of dev->trans_start 564 */ 565 unsigned long trans_start; 566 567 /* 568 * Number of TX timeouts for this queue 569 * (/sys/class/net/DEV/Q/trans_timeout) 570 */ 571 unsigned long trans_timeout; 572 573 unsigned long state; 574 575 #ifdef CONFIG_BQL 576 struct dql dql; 577 #endif 578 } ____cacheline_aligned_in_smp; 579 580 static inline int netdev_queue_numa_node_read(const struct netdev_queue *q) 581 { 582 #if defined(CONFIG_XPS) && defined(CONFIG_NUMA) 583 return q->numa_node; 584 #else 585 return NUMA_NO_NODE; 586 #endif 587 } 588 589 static inline void netdev_queue_numa_node_write(struct netdev_queue *q, int node) 590 { 591 #if defined(CONFIG_XPS) && defined(CONFIG_NUMA) 592 q->numa_node = node; 593 #endif 594 } 595 596 #ifdef CONFIG_RPS 597 /* 598 * This structure holds an RPS map which can be of variable length. The 599 * map is an array of CPUs. 600 */ 601 struct rps_map { 602 unsigned int len; 603 struct rcu_head rcu; 604 u16 cpus[0]; 605 }; 606 #define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + ((_num) * sizeof(u16))) 607 608 /* 609 * The rps_dev_flow structure contains the mapping of a flow to a CPU, the 610 * tail pointer for that CPU's input queue at the time of last enqueue, and 611 * a hardware filter index. 612 */ 613 struct rps_dev_flow { 614 u16 cpu; 615 u16 filter; 616 unsigned int last_qtail; 617 }; 618 #define RPS_NO_FILTER 0xffff 619 620 /* 621 * The rps_dev_flow_table structure contains a table of flow mappings. 622 */ 623 struct rps_dev_flow_table { 624 unsigned int mask; 625 struct rcu_head rcu; 626 struct rps_dev_flow flows[0]; 627 }; 628 #define RPS_DEV_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_dev_flow_table) + \ 629 ((_num) * sizeof(struct rps_dev_flow))) 630 631 /* 632 * The rps_sock_flow_table contains mappings of flows to the last CPU 633 * on which they were processed by the application (set in recvmsg). 634 */ 635 struct rps_sock_flow_table { 636 unsigned int mask; 637 u16 ents[0]; 638 }; 639 #define RPS_SOCK_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_sock_flow_table) + \ 640 ((_num) * sizeof(u16))) 641 642 #define RPS_NO_CPU 0xffff 643 644 static inline void rps_record_sock_flow(struct rps_sock_flow_table *table, 645 u32 hash) 646 { 647 if (table && hash) { 648 unsigned int cpu, index = hash & table->mask; 649 650 /* We only give a hint, preemption can change cpu under us */ 651 cpu = raw_smp_processor_id(); 652 653 if (table->ents[index] != cpu) 654 table->ents[index] = cpu; 655 } 656 } 657 658 static inline void rps_reset_sock_flow(struct rps_sock_flow_table *table, 659 u32 hash) 660 { 661 if (table && hash) 662 table->ents[hash & table->mask] = RPS_NO_CPU; 663 } 664 665 extern struct rps_sock_flow_table __rcu *rps_sock_flow_table; 666 667 #ifdef CONFIG_RFS_ACCEL 668 bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index, u32 flow_id, 669 u16 filter_id); 670 #endif 671 #endif /* CONFIG_RPS */ 672 673 /* This structure contains an instance of an RX queue. */ 674 struct netdev_rx_queue { 675 #ifdef CONFIG_RPS 676 struct rps_map __rcu *rps_map; 677 struct rps_dev_flow_table __rcu *rps_flow_table; 678 #endif 679 struct kobject kobj; 680 struct net_device *dev; 681 } ____cacheline_aligned_in_smp; 682 683 /* 684 * RX queue sysfs structures and functions. 685 */ 686 struct rx_queue_attribute { 687 struct attribute attr; 688 ssize_t (*show)(struct netdev_rx_queue *queue, 689 struct rx_queue_attribute *attr, char *buf); 690 ssize_t (*store)(struct netdev_rx_queue *queue, 691 struct rx_queue_attribute *attr, const char *buf, size_t len); 692 }; 693 694 #ifdef CONFIG_XPS 695 /* 696 * This structure holds an XPS map which can be of variable length. The 697 * map is an array of queues. 698 */ 699 struct xps_map { 700 unsigned int len; 701 unsigned int alloc_len; 702 struct rcu_head rcu; 703 u16 queues[0]; 704 }; 705 #define XPS_MAP_SIZE(_num) (sizeof(struct xps_map) + ((_num) * sizeof(u16))) 706 #define XPS_MIN_MAP_ALLOC ((L1_CACHE_BYTES - sizeof(struct xps_map)) \ 707 / sizeof(u16)) 708 709 /* 710 * This structure holds all XPS maps for device. Maps are indexed by CPU. 711 */ 712 struct xps_dev_maps { 713 struct rcu_head rcu; 714 struct xps_map __rcu *cpu_map[0]; 715 }; 716 #define XPS_DEV_MAPS_SIZE (sizeof(struct xps_dev_maps) + \ 717 (nr_cpu_ids * sizeof(struct xps_map *))) 718 #endif /* CONFIG_XPS */ 719 720 #define TC_MAX_QUEUE 16 721 #define TC_BITMASK 15 722 /* HW offloaded queuing disciplines txq count and offset maps */ 723 struct netdev_tc_txq { 724 u16 count; 725 u16 offset; 726 }; 727 728 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE) 729 /* 730 * This structure is to hold information about the device 731 * configured to run FCoE protocol stack. 732 */ 733 struct netdev_fcoe_hbainfo { 734 char manufacturer[64]; 735 char serial_number[64]; 736 char hardware_version[64]; 737 char driver_version[64]; 738 char optionrom_version[64]; 739 char firmware_version[64]; 740 char model[256]; 741 char model_description[256]; 742 }; 743 #endif 744 745 #define MAX_PHYS_PORT_ID_LEN 32 746 747 /* This structure holds a unique identifier to identify the 748 * physical port used by a netdevice. 749 */ 750 struct netdev_phys_port_id { 751 unsigned char id[MAX_PHYS_PORT_ID_LEN]; 752 unsigned char id_len; 753 }; 754 755 typedef u16 (*select_queue_fallback_t)(struct net_device *dev, 756 struct sk_buff *skb); 757 758 /* 759 * This structure defines the management hooks for network devices. 760 * The following hooks can be defined; unless noted otherwise, they are 761 * optional and can be filled with a null pointer. 762 * 763 * int (*ndo_init)(struct net_device *dev); 764 * This function is called once when network device is registered. 765 * The network device can use this to any late stage initializaton 766 * or semantic validattion. It can fail with an error code which will 767 * be propogated back to register_netdev 768 * 769 * void (*ndo_uninit)(struct net_device *dev); 770 * This function is called when device is unregistered or when registration 771 * fails. It is not called if init fails. 772 * 773 * int (*ndo_open)(struct net_device *dev); 774 * This function is called when network device transistions to the up 775 * state. 776 * 777 * int (*ndo_stop)(struct net_device *dev); 778 * This function is called when network device transistions to the down 779 * state. 780 * 781 * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb, 782 * struct net_device *dev); 783 * Called when a packet needs to be transmitted. 784 * Must return NETDEV_TX_OK , NETDEV_TX_BUSY. 785 * (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX) 786 * Required can not be NULL. 787 * 788 * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb, 789 * void *accel_priv, select_queue_fallback_t fallback); 790 * Called to decide which queue to when device supports multiple 791 * transmit queues. 792 * 793 * void (*ndo_change_rx_flags)(struct net_device *dev, int flags); 794 * This function is called to allow device receiver to make 795 * changes to configuration when multicast or promiscious is enabled. 796 * 797 * void (*ndo_set_rx_mode)(struct net_device *dev); 798 * This function is called device changes address list filtering. 799 * If driver handles unicast address filtering, it should set 800 * IFF_UNICAST_FLT to its priv_flags. 801 * 802 * int (*ndo_set_mac_address)(struct net_device *dev, void *addr); 803 * This function is called when the Media Access Control address 804 * needs to be changed. If this interface is not defined, the 805 * mac address can not be changed. 806 * 807 * int (*ndo_validate_addr)(struct net_device *dev); 808 * Test if Media Access Control address is valid for the device. 809 * 810 * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd); 811 * Called when a user request an ioctl which can't be handled by 812 * the generic interface code. If not defined ioctl's return 813 * not supported error code. 814 * 815 * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map); 816 * Used to set network devices bus interface parameters. This interface 817 * is retained for legacy reason, new devices should use the bus 818 * interface (PCI) for low level management. 819 * 820 * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu); 821 * Called when a user wants to change the Maximum Transfer Unit 822 * of a device. If not defined, any request to change MTU will 823 * will return an error. 824 * 825 * void (*ndo_tx_timeout)(struct net_device *dev); 826 * Callback uses when the transmitter has not made any progress 827 * for dev->watchdog ticks. 828 * 829 * struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev, 830 * struct rtnl_link_stats64 *storage); 831 * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev); 832 * Called when a user wants to get the network device usage 833 * statistics. Drivers must do one of the following: 834 * 1. Define @ndo_get_stats64 to fill in a zero-initialised 835 * rtnl_link_stats64 structure passed by the caller. 836 * 2. Define @ndo_get_stats to update a net_device_stats structure 837 * (which should normally be dev->stats) and return a pointer to 838 * it. The structure may be changed asynchronously only if each 839 * field is written atomically. 840 * 3. Update dev->stats asynchronously and atomically, and define 841 * neither operation. 842 * 843 * int (*ndo_vlan_rx_add_vid)(struct net_device *dev, __be16 proto, u16t vid); 844 * If device support VLAN filtering this function is called when a 845 * VLAN id is registered. 846 * 847 * int (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid); 848 * If device support VLAN filtering this function is called when a 849 * VLAN id is unregistered. 850 * 851 * void (*ndo_poll_controller)(struct net_device *dev); 852 * 853 * SR-IOV management functions. 854 * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac); 855 * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos); 856 * int (*ndo_set_vf_tx_rate)(struct net_device *dev, int vf, int rate); 857 * int (*ndo_set_vf_spoofchk)(struct net_device *dev, int vf, bool setting); 858 * int (*ndo_get_vf_config)(struct net_device *dev, 859 * int vf, struct ifla_vf_info *ivf); 860 * int (*ndo_set_vf_link_state)(struct net_device *dev, int vf, int link_state); 861 * int (*ndo_set_vf_port)(struct net_device *dev, int vf, 862 * struct nlattr *port[]); 863 * int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb); 864 * int (*ndo_setup_tc)(struct net_device *dev, u8 tc) 865 * Called to setup 'tc' number of traffic classes in the net device. This 866 * is always called from the stack with the rtnl lock held and netif tx 867 * queues stopped. This allows the netdevice to perform queue management 868 * safely. 869 * 870 * Fiber Channel over Ethernet (FCoE) offload functions. 871 * int (*ndo_fcoe_enable)(struct net_device *dev); 872 * Called when the FCoE protocol stack wants to start using LLD for FCoE 873 * so the underlying device can perform whatever needed configuration or 874 * initialization to support acceleration of FCoE traffic. 875 * 876 * int (*ndo_fcoe_disable)(struct net_device *dev); 877 * Called when the FCoE protocol stack wants to stop using LLD for FCoE 878 * so the underlying device can perform whatever needed clean-ups to 879 * stop supporting acceleration of FCoE traffic. 880 * 881 * int (*ndo_fcoe_ddp_setup)(struct net_device *dev, u16 xid, 882 * struct scatterlist *sgl, unsigned int sgc); 883 * Called when the FCoE Initiator wants to initialize an I/O that 884 * is a possible candidate for Direct Data Placement (DDP). The LLD can 885 * perform necessary setup and returns 1 to indicate the device is set up 886 * successfully to perform DDP on this I/O, otherwise this returns 0. 887 * 888 * int (*ndo_fcoe_ddp_done)(struct net_device *dev, u16 xid); 889 * Called when the FCoE Initiator/Target is done with the DDPed I/O as 890 * indicated by the FC exchange id 'xid', so the underlying device can 891 * clean up and reuse resources for later DDP requests. 892 * 893 * int (*ndo_fcoe_ddp_target)(struct net_device *dev, u16 xid, 894 * struct scatterlist *sgl, unsigned int sgc); 895 * Called when the FCoE Target wants to initialize an I/O that 896 * is a possible candidate for Direct Data Placement (DDP). The LLD can 897 * perform necessary setup and returns 1 to indicate the device is set up 898 * successfully to perform DDP on this I/O, otherwise this returns 0. 899 * 900 * int (*ndo_fcoe_get_hbainfo)(struct net_device *dev, 901 * struct netdev_fcoe_hbainfo *hbainfo); 902 * Called when the FCoE Protocol stack wants information on the underlying 903 * device. This information is utilized by the FCoE protocol stack to 904 * register attributes with Fiber Channel management service as per the 905 * FC-GS Fabric Device Management Information(FDMI) specification. 906 * 907 * int (*ndo_fcoe_get_wwn)(struct net_device *dev, u64 *wwn, int type); 908 * Called when the underlying device wants to override default World Wide 909 * Name (WWN) generation mechanism in FCoE protocol stack to pass its own 910 * World Wide Port Name (WWPN) or World Wide Node Name (WWNN) to the FCoE 911 * protocol stack to use. 912 * 913 * RFS acceleration. 914 * int (*ndo_rx_flow_steer)(struct net_device *dev, const struct sk_buff *skb, 915 * u16 rxq_index, u32 flow_id); 916 * Set hardware filter for RFS. rxq_index is the target queue index; 917 * flow_id is a flow ID to be passed to rps_may_expire_flow() later. 918 * Return the filter ID on success, or a negative error code. 919 * 920 * Slave management functions (for bridge, bonding, etc). 921 * int (*ndo_add_slave)(struct net_device *dev, struct net_device *slave_dev); 922 * Called to make another netdev an underling. 923 * 924 * int (*ndo_del_slave)(struct net_device *dev, struct net_device *slave_dev); 925 * Called to release previously enslaved netdev. 926 * 927 * Feature/offload setting functions. 928 * netdev_features_t (*ndo_fix_features)(struct net_device *dev, 929 * netdev_features_t features); 930 * Adjusts the requested feature flags according to device-specific 931 * constraints, and returns the resulting flags. Must not modify 932 * the device state. 933 * 934 * int (*ndo_set_features)(struct net_device *dev, netdev_features_t features); 935 * Called to update device configuration to new features. Passed 936 * feature set might be less than what was returned by ndo_fix_features()). 937 * Must return >0 or -errno if it changed dev->features itself. 938 * 939 * int (*ndo_fdb_add)(struct ndmsg *ndm, struct nlattr *tb[], 940 * struct net_device *dev, 941 * const unsigned char *addr, u16 flags) 942 * Adds an FDB entry to dev for addr. 943 * int (*ndo_fdb_del)(struct ndmsg *ndm, struct nlattr *tb[], 944 * struct net_device *dev, 945 * const unsigned char *addr) 946 * Deletes the FDB entry from dev coresponding to addr. 947 * int (*ndo_fdb_dump)(struct sk_buff *skb, struct netlink_callback *cb, 948 * struct net_device *dev, int idx) 949 * Used to add FDB entries to dump requests. Implementers should add 950 * entries to skb and update idx with the number of entries. 951 * 952 * int (*ndo_bridge_setlink)(struct net_device *dev, struct nlmsghdr *nlh) 953 * int (*ndo_bridge_getlink)(struct sk_buff *skb, u32 pid, u32 seq, 954 * struct net_device *dev, u32 filter_mask) 955 * 956 * int (*ndo_change_carrier)(struct net_device *dev, bool new_carrier); 957 * Called to change device carrier. Soft-devices (like dummy, team, etc) 958 * which do not represent real hardware may define this to allow their 959 * userspace components to manage their virtual carrier state. Devices 960 * that determine carrier state from physical hardware properties (eg 961 * network cables) or protocol-dependent mechanisms (eg 962 * USB_CDC_NOTIFY_NETWORK_CONNECTION) should NOT implement this function. 963 * 964 * int (*ndo_get_phys_port_id)(struct net_device *dev, 965 * struct netdev_phys_port_id *ppid); 966 * Called to get ID of physical port of this device. If driver does 967 * not implement this, it is assumed that the hw is not able to have 968 * multiple net devices on single physical port. 969 * 970 * void (*ndo_add_vxlan_port)(struct net_device *dev, 971 * sa_family_t sa_family, __be16 port); 972 * Called by vxlan to notiy a driver about the UDP port and socket 973 * address family that vxlan is listnening to. It is called only when 974 * a new port starts listening. The operation is protected by the 975 * vxlan_net->sock_lock. 976 * 977 * void (*ndo_del_vxlan_port)(struct net_device *dev, 978 * sa_family_t sa_family, __be16 port); 979 * Called by vxlan to notify the driver about a UDP port and socket 980 * address family that vxlan is not listening to anymore. The operation 981 * is protected by the vxlan_net->sock_lock. 982 * 983 * void* (*ndo_dfwd_add_station)(struct net_device *pdev, 984 * struct net_device *dev) 985 * Called by upper layer devices to accelerate switching or other 986 * station functionality into hardware. 'pdev is the lowerdev 987 * to use for the offload and 'dev' is the net device that will 988 * back the offload. Returns a pointer to the private structure 989 * the upper layer will maintain. 990 * void (*ndo_dfwd_del_station)(struct net_device *pdev, void *priv) 991 * Called by upper layer device to delete the station created 992 * by 'ndo_dfwd_add_station'. 'pdev' is the net device backing 993 * the station and priv is the structure returned by the add 994 * operation. 995 * netdev_tx_t (*ndo_dfwd_start_xmit)(struct sk_buff *skb, 996 * struct net_device *dev, 997 * void *priv); 998 * Callback to use for xmit over the accelerated station. This 999 * is used in place of ndo_start_xmit on accelerated net 1000 * devices. 1001 */ 1002 struct net_device_ops { 1003 int (*ndo_init)(struct net_device *dev); 1004 void (*ndo_uninit)(struct net_device *dev); 1005 int (*ndo_open)(struct net_device *dev); 1006 int (*ndo_stop)(struct net_device *dev); 1007 netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb, 1008 struct net_device *dev); 1009 u16 (*ndo_select_queue)(struct net_device *dev, 1010 struct sk_buff *skb, 1011 void *accel_priv, 1012 select_queue_fallback_t fallback); 1013 void (*ndo_change_rx_flags)(struct net_device *dev, 1014 int flags); 1015 void (*ndo_set_rx_mode)(struct net_device *dev); 1016 int (*ndo_set_mac_address)(struct net_device *dev, 1017 void *addr); 1018 int (*ndo_validate_addr)(struct net_device *dev); 1019 int (*ndo_do_ioctl)(struct net_device *dev, 1020 struct ifreq *ifr, int cmd); 1021 int (*ndo_set_config)(struct net_device *dev, 1022 struct ifmap *map); 1023 int (*ndo_change_mtu)(struct net_device *dev, 1024 int new_mtu); 1025 int (*ndo_neigh_setup)(struct net_device *dev, 1026 struct neigh_parms *); 1027 void (*ndo_tx_timeout) (struct net_device *dev); 1028 1029 struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev, 1030 struct rtnl_link_stats64 *storage); 1031 struct net_device_stats* (*ndo_get_stats)(struct net_device *dev); 1032 1033 int (*ndo_vlan_rx_add_vid)(struct net_device *dev, 1034 __be16 proto, u16 vid); 1035 int (*ndo_vlan_rx_kill_vid)(struct net_device *dev, 1036 __be16 proto, u16 vid); 1037 #ifdef CONFIG_NET_POLL_CONTROLLER 1038 void (*ndo_poll_controller)(struct net_device *dev); 1039 int (*ndo_netpoll_setup)(struct net_device *dev, 1040 struct netpoll_info *info, 1041 gfp_t gfp); 1042 void (*ndo_netpoll_cleanup)(struct net_device *dev); 1043 #endif 1044 #ifdef CONFIG_NET_RX_BUSY_POLL 1045 int (*ndo_busy_poll)(struct napi_struct *dev); 1046 #endif 1047 int (*ndo_set_vf_mac)(struct net_device *dev, 1048 int queue, u8 *mac); 1049 int (*ndo_set_vf_vlan)(struct net_device *dev, 1050 int queue, u16 vlan, u8 qos); 1051 int (*ndo_set_vf_tx_rate)(struct net_device *dev, 1052 int vf, int rate); 1053 int (*ndo_set_vf_spoofchk)(struct net_device *dev, 1054 int vf, bool setting); 1055 int (*ndo_get_vf_config)(struct net_device *dev, 1056 int vf, 1057 struct ifla_vf_info *ivf); 1058 int (*ndo_set_vf_link_state)(struct net_device *dev, 1059 int vf, int link_state); 1060 int (*ndo_set_vf_port)(struct net_device *dev, 1061 int vf, 1062 struct nlattr *port[]); 1063 int (*ndo_get_vf_port)(struct net_device *dev, 1064 int vf, struct sk_buff *skb); 1065 int (*ndo_setup_tc)(struct net_device *dev, u8 tc); 1066 #if IS_ENABLED(CONFIG_FCOE) 1067 int (*ndo_fcoe_enable)(struct net_device *dev); 1068 int (*ndo_fcoe_disable)(struct net_device *dev); 1069 int (*ndo_fcoe_ddp_setup)(struct net_device *dev, 1070 u16 xid, 1071 struct scatterlist *sgl, 1072 unsigned int sgc); 1073 int (*ndo_fcoe_ddp_done)(struct net_device *dev, 1074 u16 xid); 1075 int (*ndo_fcoe_ddp_target)(struct net_device *dev, 1076 u16 xid, 1077 struct scatterlist *sgl, 1078 unsigned int sgc); 1079 int (*ndo_fcoe_get_hbainfo)(struct net_device *dev, 1080 struct netdev_fcoe_hbainfo *hbainfo); 1081 #endif 1082 1083 #if IS_ENABLED(CONFIG_LIBFCOE) 1084 #define NETDEV_FCOE_WWNN 0 1085 #define NETDEV_FCOE_WWPN 1 1086 int (*ndo_fcoe_get_wwn)(struct net_device *dev, 1087 u64 *wwn, int type); 1088 #endif 1089 1090 #ifdef CONFIG_RFS_ACCEL 1091 int (*ndo_rx_flow_steer)(struct net_device *dev, 1092 const struct sk_buff *skb, 1093 u16 rxq_index, 1094 u32 flow_id); 1095 #endif 1096 int (*ndo_add_slave)(struct net_device *dev, 1097 struct net_device *slave_dev); 1098 int (*ndo_del_slave)(struct net_device *dev, 1099 struct net_device *slave_dev); 1100 netdev_features_t (*ndo_fix_features)(struct net_device *dev, 1101 netdev_features_t features); 1102 int (*ndo_set_features)(struct net_device *dev, 1103 netdev_features_t features); 1104 int (*ndo_neigh_construct)(struct neighbour *n); 1105 void (*ndo_neigh_destroy)(struct neighbour *n); 1106 1107 int (*ndo_fdb_add)(struct ndmsg *ndm, 1108 struct nlattr *tb[], 1109 struct net_device *dev, 1110 const unsigned char *addr, 1111 u16 flags); 1112 int (*ndo_fdb_del)(struct ndmsg *ndm, 1113 struct nlattr *tb[], 1114 struct net_device *dev, 1115 const unsigned char *addr); 1116 int (*ndo_fdb_dump)(struct sk_buff *skb, 1117 struct netlink_callback *cb, 1118 struct net_device *dev, 1119 int idx); 1120 1121 int (*ndo_bridge_setlink)(struct net_device *dev, 1122 struct nlmsghdr *nlh); 1123 int (*ndo_bridge_getlink)(struct sk_buff *skb, 1124 u32 pid, u32 seq, 1125 struct net_device *dev, 1126 u32 filter_mask); 1127 int (*ndo_bridge_dellink)(struct net_device *dev, 1128 struct nlmsghdr *nlh); 1129 int (*ndo_change_carrier)(struct net_device *dev, 1130 bool new_carrier); 1131 int (*ndo_get_phys_port_id)(struct net_device *dev, 1132 struct netdev_phys_port_id *ppid); 1133 void (*ndo_add_vxlan_port)(struct net_device *dev, 1134 sa_family_t sa_family, 1135 __be16 port); 1136 void (*ndo_del_vxlan_port)(struct net_device *dev, 1137 sa_family_t sa_family, 1138 __be16 port); 1139 1140 void* (*ndo_dfwd_add_station)(struct net_device *pdev, 1141 struct net_device *dev); 1142 void (*ndo_dfwd_del_station)(struct net_device *pdev, 1143 void *priv); 1144 1145 netdev_tx_t (*ndo_dfwd_start_xmit) (struct sk_buff *skb, 1146 struct net_device *dev, 1147 void *priv); 1148 }; 1149 1150 /* 1151 * The DEVICE structure. 1152 * Actually, this whole structure is a big mistake. It mixes I/O 1153 * data with strictly "high-level" data, and it has to know about 1154 * almost every data structure used in the INET module. 1155 * 1156 * FIXME: cleanup struct net_device such that network protocol info 1157 * moves out. 1158 */ 1159 1160 struct net_device { 1161 1162 /* 1163 * This is the first field of the "visible" part of this structure 1164 * (i.e. as seen by users in the "Space.c" file). It is the name 1165 * of the interface. 1166 */ 1167 char name[IFNAMSIZ]; 1168 1169 /* device name hash chain, please keep it close to name[] */ 1170 struct hlist_node name_hlist; 1171 1172 /* snmp alias */ 1173 char *ifalias; 1174 1175 /* 1176 * I/O specific fields 1177 * FIXME: Merge these and struct ifmap into one 1178 */ 1179 unsigned long mem_end; /* shared mem end */ 1180 unsigned long mem_start; /* shared mem start */ 1181 unsigned long base_addr; /* device I/O address */ 1182 int irq; /* device IRQ number */ 1183 1184 /* 1185 * Some hardware also needs these fields, but they are not 1186 * part of the usual set specified in Space.c. 1187 */ 1188 1189 unsigned long state; 1190 1191 struct list_head dev_list; 1192 struct list_head napi_list; 1193 struct list_head unreg_list; 1194 struct list_head close_list; 1195 1196 /* directly linked devices, like slaves for bonding */ 1197 struct { 1198 struct list_head upper; 1199 struct list_head lower; 1200 } adj_list; 1201 1202 /* all linked devices, *including* neighbours */ 1203 struct { 1204 struct list_head upper; 1205 struct list_head lower; 1206 } all_adj_list; 1207 1208 1209 /* currently active device features */ 1210 netdev_features_t features; 1211 /* user-changeable features */ 1212 netdev_features_t hw_features; 1213 /* user-requested features */ 1214 netdev_features_t wanted_features; 1215 /* mask of features inheritable by VLAN devices */ 1216 netdev_features_t vlan_features; 1217 /* mask of features inherited by encapsulating devices 1218 * This field indicates what encapsulation offloads 1219 * the hardware is capable of doing, and drivers will 1220 * need to set them appropriately. 1221 */ 1222 netdev_features_t hw_enc_features; 1223 /* mask of fetures inheritable by MPLS */ 1224 netdev_features_t mpls_features; 1225 1226 /* Interface index. Unique device identifier */ 1227 int ifindex; 1228 int iflink; 1229 1230 struct net_device_stats stats; 1231 atomic_long_t rx_dropped; /* dropped packets by core network 1232 * Do not use this in drivers. 1233 */ 1234 1235 #ifdef CONFIG_WIRELESS_EXT 1236 /* List of functions to handle Wireless Extensions (instead of ioctl). 1237 * See <net/iw_handler.h> for details. Jean II */ 1238 const struct iw_handler_def * wireless_handlers; 1239 /* Instance data managed by the core of Wireless Extensions. */ 1240 struct iw_public_data * wireless_data; 1241 #endif 1242 /* Management operations */ 1243 const struct net_device_ops *netdev_ops; 1244 const struct ethtool_ops *ethtool_ops; 1245 const struct forwarding_accel_ops *fwd_ops; 1246 1247 /* Hardware header description */ 1248 const struct header_ops *header_ops; 1249 1250 unsigned int flags; /* interface flags (a la BSD) */ 1251 unsigned int priv_flags; /* Like 'flags' but invisible to userspace. 1252 * See if.h for definitions. */ 1253 unsigned short gflags; 1254 unsigned short padded; /* How much padding added by alloc_netdev() */ 1255 1256 unsigned char operstate; /* RFC2863 operstate */ 1257 unsigned char link_mode; /* mapping policy to operstate */ 1258 1259 unsigned char if_port; /* Selectable AUI, TP,..*/ 1260 unsigned char dma; /* DMA channel */ 1261 1262 unsigned int mtu; /* interface MTU value */ 1263 unsigned short type; /* interface hardware type */ 1264 unsigned short hard_header_len; /* hardware hdr length */ 1265 1266 /* extra head- and tailroom the hardware may need, but not in all cases 1267 * can this be guaranteed, especially tailroom. Some cases also use 1268 * LL_MAX_HEADER instead to allocate the skb. 1269 */ 1270 unsigned short needed_headroom; 1271 unsigned short needed_tailroom; 1272 1273 /* Interface address info. */ 1274 unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */ 1275 unsigned char addr_assign_type; /* hw address assignment type */ 1276 unsigned char addr_len; /* hardware address length */ 1277 unsigned short neigh_priv_len; 1278 unsigned short dev_id; /* Used to differentiate devices 1279 * that share the same link 1280 * layer address 1281 */ 1282 spinlock_t addr_list_lock; 1283 struct netdev_hw_addr_list uc; /* Unicast mac addresses */ 1284 struct netdev_hw_addr_list mc; /* Multicast mac addresses */ 1285 struct netdev_hw_addr_list dev_addrs; /* list of device 1286 * hw addresses 1287 */ 1288 #ifdef CONFIG_SYSFS 1289 struct kset *queues_kset; 1290 #endif 1291 1292 bool uc_promisc; 1293 unsigned int promiscuity; 1294 unsigned int allmulti; 1295 1296 1297 /* Protocol specific pointers */ 1298 1299 #if IS_ENABLED(CONFIG_VLAN_8021Q) 1300 struct vlan_info __rcu *vlan_info; /* VLAN info */ 1301 #endif 1302 #if IS_ENABLED(CONFIG_NET_DSA) 1303 struct dsa_switch_tree *dsa_ptr; /* dsa specific data */ 1304 #endif 1305 #if IS_ENABLED(CONFIG_TIPC) 1306 struct tipc_bearer __rcu *tipc_ptr; /* TIPC specific data */ 1307 #endif 1308 void *atalk_ptr; /* AppleTalk link */ 1309 struct in_device __rcu *ip_ptr; /* IPv4 specific data */ 1310 struct dn_dev __rcu *dn_ptr; /* DECnet specific data */ 1311 struct inet6_dev __rcu *ip6_ptr; /* IPv6 specific data */ 1312 void *ax25_ptr; /* AX.25 specific data */ 1313 struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data, 1314 assign before registering */ 1315 1316 /* 1317 * Cache lines mostly used on receive path (including eth_type_trans()) 1318 */ 1319 unsigned long last_rx; /* Time of last Rx 1320 * This should not be set in 1321 * drivers, unless really needed, 1322 * because network stack (bonding) 1323 * use it if/when necessary, to 1324 * avoid dirtying this cache line. 1325 */ 1326 1327 /* Interface address info used in eth_type_trans() */ 1328 unsigned char *dev_addr; /* hw address, (before bcast 1329 because most packets are 1330 unicast) */ 1331 1332 1333 #ifdef CONFIG_SYSFS 1334 struct netdev_rx_queue *_rx; 1335 1336 /* Number of RX queues allocated at register_netdev() time */ 1337 unsigned int num_rx_queues; 1338 1339 /* Number of RX queues currently active in device */ 1340 unsigned int real_num_rx_queues; 1341 1342 #endif 1343 1344 rx_handler_func_t __rcu *rx_handler; 1345 void __rcu *rx_handler_data; 1346 1347 struct netdev_queue __rcu *ingress_queue; 1348 unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */ 1349 1350 1351 /* 1352 * Cache lines mostly used on transmit path 1353 */ 1354 struct netdev_queue *_tx ____cacheline_aligned_in_smp; 1355 1356 /* Number of TX queues allocated at alloc_netdev_mq() time */ 1357 unsigned int num_tx_queues; 1358 1359 /* Number of TX queues currently active in device */ 1360 unsigned int real_num_tx_queues; 1361 1362 /* root qdisc from userspace point of view */ 1363 struct Qdisc *qdisc; 1364 1365 unsigned long tx_queue_len; /* Max frames per queue allowed */ 1366 spinlock_t tx_global_lock; 1367 1368 #ifdef CONFIG_XPS 1369 struct xps_dev_maps __rcu *xps_maps; 1370 #endif 1371 #ifdef CONFIG_RFS_ACCEL 1372 /* CPU reverse-mapping for RX completion interrupts, indexed 1373 * by RX queue number. Assigned by driver. This must only be 1374 * set if the ndo_rx_flow_steer operation is defined. */ 1375 struct cpu_rmap *rx_cpu_rmap; 1376 #endif 1377 1378 /* These may be needed for future network-power-down code. */ 1379 1380 /* 1381 * trans_start here is expensive for high speed devices on SMP, 1382 * please use netdev_queue->trans_start instead. 1383 */ 1384 unsigned long trans_start; /* Time (in jiffies) of last Tx */ 1385 1386 int watchdog_timeo; /* used by dev_watchdog() */ 1387 struct timer_list watchdog_timer; 1388 1389 /* Number of references to this device */ 1390 int __percpu *pcpu_refcnt; 1391 1392 /* delayed register/unregister */ 1393 struct list_head todo_list; 1394 /* device index hash chain */ 1395 struct hlist_node index_hlist; 1396 1397 struct list_head link_watch_list; 1398 1399 /* register/unregister state machine */ 1400 enum { NETREG_UNINITIALIZED=0, 1401 NETREG_REGISTERED, /* completed register_netdevice */ 1402 NETREG_UNREGISTERING, /* called unregister_netdevice */ 1403 NETREG_UNREGISTERED, /* completed unregister todo */ 1404 NETREG_RELEASED, /* called free_netdev */ 1405 NETREG_DUMMY, /* dummy device for NAPI poll */ 1406 } reg_state:8; 1407 1408 bool dismantle; /* device is going do be freed */ 1409 1410 enum { 1411 RTNL_LINK_INITIALIZED, 1412 RTNL_LINK_INITIALIZING, 1413 } rtnl_link_state:16; 1414 1415 /* Called from unregister, can be used to call free_netdev */ 1416 void (*destructor)(struct net_device *dev); 1417 1418 #ifdef CONFIG_NETPOLL 1419 struct netpoll_info __rcu *npinfo; 1420 #endif 1421 1422 #ifdef CONFIG_NET_NS 1423 /* Network namespace this network device is inside */ 1424 struct net *nd_net; 1425 #endif 1426 1427 /* mid-layer private */ 1428 union { 1429 void *ml_priv; 1430 struct pcpu_lstats __percpu *lstats; /* loopback stats */ 1431 struct pcpu_sw_netstats __percpu *tstats; 1432 struct pcpu_dstats __percpu *dstats; /* dummy stats */ 1433 struct pcpu_vstats __percpu *vstats; /* veth stats */ 1434 }; 1435 /* GARP */ 1436 struct garp_port __rcu *garp_port; 1437 /* MRP */ 1438 struct mrp_port __rcu *mrp_port; 1439 1440 /* class/net/name entry */ 1441 struct device dev; 1442 /* space for optional device, statistics, and wireless sysfs groups */ 1443 const struct attribute_group *sysfs_groups[4]; 1444 /* space for optional per-rx queue attributes */ 1445 const struct attribute_group *sysfs_rx_queue_group; 1446 1447 /* rtnetlink link ops */ 1448 const struct rtnl_link_ops *rtnl_link_ops; 1449 1450 /* for setting kernel sock attribute on TCP connection setup */ 1451 #define GSO_MAX_SIZE 65536 1452 unsigned int gso_max_size; 1453 #define GSO_MAX_SEGS 65535 1454 u16 gso_max_segs; 1455 1456 #ifdef CONFIG_DCB 1457 /* Data Center Bridging netlink ops */ 1458 const struct dcbnl_rtnl_ops *dcbnl_ops; 1459 #endif 1460 u8 num_tc; 1461 struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE]; 1462 u8 prio_tc_map[TC_BITMASK + 1]; 1463 1464 #if IS_ENABLED(CONFIG_FCOE) 1465 /* max exchange id for FCoE LRO by ddp */ 1466 unsigned int fcoe_ddp_xid; 1467 #endif 1468 #if IS_ENABLED(CONFIG_CGROUP_NET_PRIO) 1469 struct netprio_map __rcu *priomap; 1470 #endif 1471 /* phy device may attach itself for hardware timestamping */ 1472 struct phy_device *phydev; 1473 1474 struct lock_class_key *qdisc_tx_busylock; 1475 1476 /* group the device belongs to */ 1477 int group; 1478 1479 struct pm_qos_request pm_qos_req; 1480 }; 1481 #define to_net_dev(d) container_of(d, struct net_device, dev) 1482 1483 #define NETDEV_ALIGN 32 1484 1485 static inline 1486 int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio) 1487 { 1488 return dev->prio_tc_map[prio & TC_BITMASK]; 1489 } 1490 1491 static inline 1492 int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc) 1493 { 1494 if (tc >= dev->num_tc) 1495 return -EINVAL; 1496 1497 dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK; 1498 return 0; 1499 } 1500 1501 static inline 1502 void netdev_reset_tc(struct net_device *dev) 1503 { 1504 dev->num_tc = 0; 1505 memset(dev->tc_to_txq, 0, sizeof(dev->tc_to_txq)); 1506 memset(dev->prio_tc_map, 0, sizeof(dev->prio_tc_map)); 1507 } 1508 1509 static inline 1510 int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset) 1511 { 1512 if (tc >= dev->num_tc) 1513 return -EINVAL; 1514 1515 dev->tc_to_txq[tc].count = count; 1516 dev->tc_to_txq[tc].offset = offset; 1517 return 0; 1518 } 1519 1520 static inline 1521 int netdev_set_num_tc(struct net_device *dev, u8 num_tc) 1522 { 1523 if (num_tc > TC_MAX_QUEUE) 1524 return -EINVAL; 1525 1526 dev->num_tc = num_tc; 1527 return 0; 1528 } 1529 1530 static inline 1531 int netdev_get_num_tc(struct net_device *dev) 1532 { 1533 return dev->num_tc; 1534 } 1535 1536 static inline 1537 struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev, 1538 unsigned int index) 1539 { 1540 return &dev->_tx[index]; 1541 } 1542 1543 static inline void netdev_for_each_tx_queue(struct net_device *dev, 1544 void (*f)(struct net_device *, 1545 struct netdev_queue *, 1546 void *), 1547 void *arg) 1548 { 1549 unsigned int i; 1550 1551 for (i = 0; i < dev->num_tx_queues; i++) 1552 f(dev, &dev->_tx[i], arg); 1553 } 1554 1555 struct netdev_queue *netdev_pick_tx(struct net_device *dev, 1556 struct sk_buff *skb, 1557 void *accel_priv); 1558 1559 /* 1560 * Net namespace inlines 1561 */ 1562 static inline 1563 struct net *dev_net(const struct net_device *dev) 1564 { 1565 return read_pnet(&dev->nd_net); 1566 } 1567 1568 static inline 1569 void dev_net_set(struct net_device *dev, struct net *net) 1570 { 1571 #ifdef CONFIG_NET_NS 1572 release_net(dev->nd_net); 1573 dev->nd_net = hold_net(net); 1574 #endif 1575 } 1576 1577 static inline bool netdev_uses_dsa_tags(struct net_device *dev) 1578 { 1579 #ifdef CONFIG_NET_DSA_TAG_DSA 1580 if (dev->dsa_ptr != NULL) 1581 return dsa_uses_dsa_tags(dev->dsa_ptr); 1582 #endif 1583 1584 return 0; 1585 } 1586 1587 static inline bool netdev_uses_trailer_tags(struct net_device *dev) 1588 { 1589 #ifdef CONFIG_NET_DSA_TAG_TRAILER 1590 if (dev->dsa_ptr != NULL) 1591 return dsa_uses_trailer_tags(dev->dsa_ptr); 1592 #endif 1593 1594 return 0; 1595 } 1596 1597 /** 1598 * netdev_priv - access network device private data 1599 * @dev: network device 1600 * 1601 * Get network device private data 1602 */ 1603 static inline void *netdev_priv(const struct net_device *dev) 1604 { 1605 return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN); 1606 } 1607 1608 /* Set the sysfs physical device reference for the network logical device 1609 * if set prior to registration will cause a symlink during initialization. 1610 */ 1611 #define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev)) 1612 1613 /* Set the sysfs device type for the network logical device to allow 1614 * fine-grained identification of different network device types. For 1615 * example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc. 1616 */ 1617 #define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype)) 1618 1619 /* Default NAPI poll() weight 1620 * Device drivers are strongly advised to not use bigger value 1621 */ 1622 #define NAPI_POLL_WEIGHT 64 1623 1624 /** 1625 * netif_napi_add - initialize a napi context 1626 * @dev: network device 1627 * @napi: napi context 1628 * @poll: polling function 1629 * @weight: default weight 1630 * 1631 * netif_napi_add() must be used to initialize a napi context prior to calling 1632 * *any* of the other napi related functions. 1633 */ 1634 void netif_napi_add(struct net_device *dev, struct napi_struct *napi, 1635 int (*poll)(struct napi_struct *, int), int weight); 1636 1637 /** 1638 * netif_napi_del - remove a napi context 1639 * @napi: napi context 1640 * 1641 * netif_napi_del() removes a napi context from the network device napi list 1642 */ 1643 void netif_napi_del(struct napi_struct *napi); 1644 1645 struct napi_gro_cb { 1646 /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */ 1647 void *frag0; 1648 1649 /* Length of frag0. */ 1650 unsigned int frag0_len; 1651 1652 /* This indicates where we are processing relative to skb->data. */ 1653 int data_offset; 1654 1655 /* This is non-zero if the packet cannot be merged with the new skb. */ 1656 u16 flush; 1657 1658 /* Save the IP ID here and check when we get to the transport layer */ 1659 u16 flush_id; 1660 1661 /* Number of segments aggregated. */ 1662 u16 count; 1663 1664 /* This is non-zero if the packet may be of the same flow. */ 1665 u8 same_flow; 1666 1667 /* Free the skb? */ 1668 u8 free; 1669 #define NAPI_GRO_FREE 1 1670 #define NAPI_GRO_FREE_STOLEN_HEAD 2 1671 1672 /* jiffies when first packet was created/queued */ 1673 unsigned long age; 1674 1675 /* Used in ipv6_gro_receive() */ 1676 u16 proto; 1677 1678 /* Used in udp_gro_receive */ 1679 u16 udp_mark; 1680 1681 /* used to support CHECKSUM_COMPLETE for tunneling protocols */ 1682 __wsum csum; 1683 1684 /* used in skb_gro_receive() slow path */ 1685 struct sk_buff *last; 1686 }; 1687 1688 #define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb) 1689 1690 struct packet_type { 1691 __be16 type; /* This is really htons(ether_type). */ 1692 struct net_device *dev; /* NULL is wildcarded here */ 1693 int (*func) (struct sk_buff *, 1694 struct net_device *, 1695 struct packet_type *, 1696 struct net_device *); 1697 bool (*id_match)(struct packet_type *ptype, 1698 struct sock *sk); 1699 void *af_packet_priv; 1700 struct list_head list; 1701 }; 1702 1703 struct offload_callbacks { 1704 struct sk_buff *(*gso_segment)(struct sk_buff *skb, 1705 netdev_features_t features); 1706 int (*gso_send_check)(struct sk_buff *skb); 1707 struct sk_buff **(*gro_receive)(struct sk_buff **head, 1708 struct sk_buff *skb); 1709 int (*gro_complete)(struct sk_buff *skb, int nhoff); 1710 }; 1711 1712 struct packet_offload { 1713 __be16 type; /* This is really htons(ether_type). */ 1714 struct offload_callbacks callbacks; 1715 struct list_head list; 1716 }; 1717 1718 struct udp_offload { 1719 __be16 port; 1720 struct offload_callbacks callbacks; 1721 }; 1722 1723 /* often modified stats are per cpu, other are shared (netdev->stats) */ 1724 struct pcpu_sw_netstats { 1725 u64 rx_packets; 1726 u64 rx_bytes; 1727 u64 tx_packets; 1728 u64 tx_bytes; 1729 struct u64_stats_sync syncp; 1730 }; 1731 1732 #include <linux/notifier.h> 1733 1734 /* netdevice notifier chain. Please remember to update the rtnetlink 1735 * notification exclusion list in rtnetlink_event() when adding new 1736 * types. 1737 */ 1738 #define NETDEV_UP 0x0001 /* For now you can't veto a device up/down */ 1739 #define NETDEV_DOWN 0x0002 1740 #define NETDEV_REBOOT 0x0003 /* Tell a protocol stack a network interface 1741 detected a hardware crash and restarted 1742 - we can use this eg to kick tcp sessions 1743 once done */ 1744 #define NETDEV_CHANGE 0x0004 /* Notify device state change */ 1745 #define NETDEV_REGISTER 0x0005 1746 #define NETDEV_UNREGISTER 0x0006 1747 #define NETDEV_CHANGEMTU 0x0007 /* notify after mtu change happened */ 1748 #define NETDEV_CHANGEADDR 0x0008 1749 #define NETDEV_GOING_DOWN 0x0009 1750 #define NETDEV_CHANGENAME 0x000A 1751 #define NETDEV_FEAT_CHANGE 0x000B 1752 #define NETDEV_BONDING_FAILOVER 0x000C 1753 #define NETDEV_PRE_UP 0x000D 1754 #define NETDEV_PRE_TYPE_CHANGE 0x000E 1755 #define NETDEV_POST_TYPE_CHANGE 0x000F 1756 #define NETDEV_POST_INIT 0x0010 1757 #define NETDEV_UNREGISTER_FINAL 0x0011 1758 #define NETDEV_RELEASE 0x0012 1759 #define NETDEV_NOTIFY_PEERS 0x0013 1760 #define NETDEV_JOIN 0x0014 1761 #define NETDEV_CHANGEUPPER 0x0015 1762 #define NETDEV_RESEND_IGMP 0x0016 1763 #define NETDEV_PRECHANGEMTU 0x0017 /* notify before mtu change happened */ 1764 1765 int register_netdevice_notifier(struct notifier_block *nb); 1766 int unregister_netdevice_notifier(struct notifier_block *nb); 1767 1768 struct netdev_notifier_info { 1769 struct net_device *dev; 1770 }; 1771 1772 struct netdev_notifier_change_info { 1773 struct netdev_notifier_info info; /* must be first */ 1774 unsigned int flags_changed; 1775 }; 1776 1777 static inline void netdev_notifier_info_init(struct netdev_notifier_info *info, 1778 struct net_device *dev) 1779 { 1780 info->dev = dev; 1781 } 1782 1783 static inline struct net_device * 1784 netdev_notifier_info_to_dev(const struct netdev_notifier_info *info) 1785 { 1786 return info->dev; 1787 } 1788 1789 int call_netdevice_notifiers(unsigned long val, struct net_device *dev); 1790 1791 1792 extern rwlock_t dev_base_lock; /* Device list lock */ 1793 1794 #define for_each_netdev(net, d) \ 1795 list_for_each_entry(d, &(net)->dev_base_head, dev_list) 1796 #define for_each_netdev_reverse(net, d) \ 1797 list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list) 1798 #define for_each_netdev_rcu(net, d) \ 1799 list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list) 1800 #define for_each_netdev_safe(net, d, n) \ 1801 list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list) 1802 #define for_each_netdev_continue(net, d) \ 1803 list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list) 1804 #define for_each_netdev_continue_rcu(net, d) \ 1805 list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list) 1806 #define for_each_netdev_in_bond_rcu(bond, slave) \ 1807 for_each_netdev_rcu(&init_net, slave) \ 1808 if (netdev_master_upper_dev_get_rcu(slave) == bond) 1809 #define net_device_entry(lh) list_entry(lh, struct net_device, dev_list) 1810 1811 static inline struct net_device *next_net_device(struct net_device *dev) 1812 { 1813 struct list_head *lh; 1814 struct net *net; 1815 1816 net = dev_net(dev); 1817 lh = dev->dev_list.next; 1818 return lh == &net->dev_base_head ? NULL : net_device_entry(lh); 1819 } 1820 1821 static inline struct net_device *next_net_device_rcu(struct net_device *dev) 1822 { 1823 struct list_head *lh; 1824 struct net *net; 1825 1826 net = dev_net(dev); 1827 lh = rcu_dereference(list_next_rcu(&dev->dev_list)); 1828 return lh == &net->dev_base_head ? NULL : net_device_entry(lh); 1829 } 1830 1831 static inline struct net_device *first_net_device(struct net *net) 1832 { 1833 return list_empty(&net->dev_base_head) ? NULL : 1834 net_device_entry(net->dev_base_head.next); 1835 } 1836 1837 static inline struct net_device *first_net_device_rcu(struct net *net) 1838 { 1839 struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head)); 1840 1841 return lh == &net->dev_base_head ? NULL : net_device_entry(lh); 1842 } 1843 1844 int netdev_boot_setup_check(struct net_device *dev); 1845 unsigned long netdev_boot_base(const char *prefix, int unit); 1846 struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type, 1847 const char *hwaddr); 1848 struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type); 1849 struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type); 1850 void dev_add_pack(struct packet_type *pt); 1851 void dev_remove_pack(struct packet_type *pt); 1852 void __dev_remove_pack(struct packet_type *pt); 1853 void dev_add_offload(struct packet_offload *po); 1854 void dev_remove_offload(struct packet_offload *po); 1855 1856 struct net_device *dev_get_by_flags_rcu(struct net *net, unsigned short flags, 1857 unsigned short mask); 1858 struct net_device *dev_get_by_name(struct net *net, const char *name); 1859 struct net_device *dev_get_by_name_rcu(struct net *net, const char *name); 1860 struct net_device *__dev_get_by_name(struct net *net, const char *name); 1861 int dev_alloc_name(struct net_device *dev, const char *name); 1862 int dev_open(struct net_device *dev); 1863 int dev_close(struct net_device *dev); 1864 void dev_disable_lro(struct net_device *dev); 1865 int dev_loopback_xmit(struct sk_buff *newskb); 1866 int dev_queue_xmit(struct sk_buff *skb); 1867 int dev_queue_xmit_accel(struct sk_buff *skb, void *accel_priv); 1868 int register_netdevice(struct net_device *dev); 1869 void unregister_netdevice_queue(struct net_device *dev, struct list_head *head); 1870 void unregister_netdevice_many(struct list_head *head); 1871 static inline void unregister_netdevice(struct net_device *dev) 1872 { 1873 unregister_netdevice_queue(dev, NULL); 1874 } 1875 1876 int netdev_refcnt_read(const struct net_device *dev); 1877 void free_netdev(struct net_device *dev); 1878 void netdev_freemem(struct net_device *dev); 1879 void synchronize_net(void); 1880 int init_dummy_netdev(struct net_device *dev); 1881 1882 struct net_device *dev_get_by_index(struct net *net, int ifindex); 1883 struct net_device *__dev_get_by_index(struct net *net, int ifindex); 1884 struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex); 1885 int netdev_get_name(struct net *net, char *name, int ifindex); 1886 int dev_restart(struct net_device *dev); 1887 #ifdef CONFIG_NETPOLL_TRAP 1888 int netpoll_trap(void); 1889 #endif 1890 int skb_gro_receive(struct sk_buff **head, struct sk_buff *skb); 1891 1892 static inline unsigned int skb_gro_offset(const struct sk_buff *skb) 1893 { 1894 return NAPI_GRO_CB(skb)->data_offset; 1895 } 1896 1897 static inline unsigned int skb_gro_len(const struct sk_buff *skb) 1898 { 1899 return skb->len - NAPI_GRO_CB(skb)->data_offset; 1900 } 1901 1902 static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len) 1903 { 1904 NAPI_GRO_CB(skb)->data_offset += len; 1905 } 1906 1907 static inline void *skb_gro_header_fast(struct sk_buff *skb, 1908 unsigned int offset) 1909 { 1910 return NAPI_GRO_CB(skb)->frag0 + offset; 1911 } 1912 1913 static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen) 1914 { 1915 return NAPI_GRO_CB(skb)->frag0_len < hlen; 1916 } 1917 1918 static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen, 1919 unsigned int offset) 1920 { 1921 if (!pskb_may_pull(skb, hlen)) 1922 return NULL; 1923 1924 NAPI_GRO_CB(skb)->frag0 = NULL; 1925 NAPI_GRO_CB(skb)->frag0_len = 0; 1926 return skb->data + offset; 1927 } 1928 1929 static inline void *skb_gro_mac_header(struct sk_buff *skb) 1930 { 1931 return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb); 1932 } 1933 1934 static inline void *skb_gro_network_header(struct sk_buff *skb) 1935 { 1936 return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) + 1937 skb_network_offset(skb); 1938 } 1939 1940 static inline void skb_gro_postpull_rcsum(struct sk_buff *skb, 1941 const void *start, unsigned int len) 1942 { 1943 if (skb->ip_summed == CHECKSUM_COMPLETE) 1944 NAPI_GRO_CB(skb)->csum = csum_sub(NAPI_GRO_CB(skb)->csum, 1945 csum_partial(start, len, 0)); 1946 } 1947 1948 static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev, 1949 unsigned short type, 1950 const void *daddr, const void *saddr, 1951 unsigned int len) 1952 { 1953 if (!dev->header_ops || !dev->header_ops->create) 1954 return 0; 1955 1956 return dev->header_ops->create(skb, dev, type, daddr, saddr, len); 1957 } 1958 1959 static inline int dev_parse_header(const struct sk_buff *skb, 1960 unsigned char *haddr) 1961 { 1962 const struct net_device *dev = skb->dev; 1963 1964 if (!dev->header_ops || !dev->header_ops->parse) 1965 return 0; 1966 return dev->header_ops->parse(skb, haddr); 1967 } 1968 1969 static inline int dev_rebuild_header(struct sk_buff *skb) 1970 { 1971 const struct net_device *dev = skb->dev; 1972 1973 if (!dev->header_ops || !dev->header_ops->rebuild) 1974 return 0; 1975 return dev->header_ops->rebuild(skb); 1976 } 1977 1978 typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len); 1979 int register_gifconf(unsigned int family, gifconf_func_t *gifconf); 1980 static inline int unregister_gifconf(unsigned int family) 1981 { 1982 return register_gifconf(family, NULL); 1983 } 1984 1985 #ifdef CONFIG_NET_FLOW_LIMIT 1986 #define FLOW_LIMIT_HISTORY (1 << 7) /* must be ^2 and !overflow buckets */ 1987 struct sd_flow_limit { 1988 u64 count; 1989 unsigned int num_buckets; 1990 unsigned int history_head; 1991 u16 history[FLOW_LIMIT_HISTORY]; 1992 u8 buckets[]; 1993 }; 1994 1995 extern int netdev_flow_limit_table_len; 1996 #endif /* CONFIG_NET_FLOW_LIMIT */ 1997 1998 /* 1999 * Incoming packets are placed on per-cpu queues 2000 */ 2001 struct softnet_data { 2002 struct Qdisc *output_queue; 2003 struct Qdisc **output_queue_tailp; 2004 struct list_head poll_list; 2005 struct sk_buff *completion_queue; 2006 struct sk_buff_head process_queue; 2007 2008 /* stats */ 2009 unsigned int processed; 2010 unsigned int time_squeeze; 2011 unsigned int cpu_collision; 2012 unsigned int received_rps; 2013 2014 #ifdef CONFIG_RPS 2015 struct softnet_data *rps_ipi_list; 2016 2017 /* Elements below can be accessed between CPUs for RPS */ 2018 struct call_single_data csd ____cacheline_aligned_in_smp; 2019 struct softnet_data *rps_ipi_next; 2020 unsigned int cpu; 2021 unsigned int input_queue_head; 2022 unsigned int input_queue_tail; 2023 #endif 2024 unsigned int dropped; 2025 struct sk_buff_head input_pkt_queue; 2026 struct napi_struct backlog; 2027 2028 #ifdef CONFIG_NET_FLOW_LIMIT 2029 struct sd_flow_limit __rcu *flow_limit; 2030 #endif 2031 }; 2032 2033 static inline void input_queue_head_incr(struct softnet_data *sd) 2034 { 2035 #ifdef CONFIG_RPS 2036 sd->input_queue_head++; 2037 #endif 2038 } 2039 2040 static inline void input_queue_tail_incr_save(struct softnet_data *sd, 2041 unsigned int *qtail) 2042 { 2043 #ifdef CONFIG_RPS 2044 *qtail = ++sd->input_queue_tail; 2045 #endif 2046 } 2047 2048 DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data); 2049 2050 void __netif_schedule(struct Qdisc *q); 2051 2052 static inline void netif_schedule_queue(struct netdev_queue *txq) 2053 { 2054 if (!(txq->state & QUEUE_STATE_ANY_XOFF)) 2055 __netif_schedule(txq->qdisc); 2056 } 2057 2058 static inline void netif_tx_schedule_all(struct net_device *dev) 2059 { 2060 unsigned int i; 2061 2062 for (i = 0; i < dev->num_tx_queues; i++) 2063 netif_schedule_queue(netdev_get_tx_queue(dev, i)); 2064 } 2065 2066 static inline void netif_tx_start_queue(struct netdev_queue *dev_queue) 2067 { 2068 clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state); 2069 } 2070 2071 /** 2072 * netif_start_queue - allow transmit 2073 * @dev: network device 2074 * 2075 * Allow upper layers to call the device hard_start_xmit routine. 2076 */ 2077 static inline void netif_start_queue(struct net_device *dev) 2078 { 2079 netif_tx_start_queue(netdev_get_tx_queue(dev, 0)); 2080 } 2081 2082 static inline void netif_tx_start_all_queues(struct net_device *dev) 2083 { 2084 unsigned int i; 2085 2086 for (i = 0; i < dev->num_tx_queues; i++) { 2087 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 2088 netif_tx_start_queue(txq); 2089 } 2090 } 2091 2092 static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue) 2093 { 2094 #ifdef CONFIG_NETPOLL_TRAP 2095 if (netpoll_trap()) { 2096 netif_tx_start_queue(dev_queue); 2097 return; 2098 } 2099 #endif 2100 if (test_and_clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state)) 2101 __netif_schedule(dev_queue->qdisc); 2102 } 2103 2104 /** 2105 * netif_wake_queue - restart transmit 2106 * @dev: network device 2107 * 2108 * Allow upper layers to call the device hard_start_xmit routine. 2109 * Used for flow control when transmit resources are available. 2110 */ 2111 static inline void netif_wake_queue(struct net_device *dev) 2112 { 2113 netif_tx_wake_queue(netdev_get_tx_queue(dev, 0)); 2114 } 2115 2116 static inline void netif_tx_wake_all_queues(struct net_device *dev) 2117 { 2118 unsigned int i; 2119 2120 for (i = 0; i < dev->num_tx_queues; i++) { 2121 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 2122 netif_tx_wake_queue(txq); 2123 } 2124 } 2125 2126 static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue) 2127 { 2128 if (WARN_ON(!dev_queue)) { 2129 pr_info("netif_stop_queue() cannot be called before register_netdev()\n"); 2130 return; 2131 } 2132 set_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state); 2133 } 2134 2135 /** 2136 * netif_stop_queue - stop transmitted packets 2137 * @dev: network device 2138 * 2139 * Stop upper layers calling the device hard_start_xmit routine. 2140 * Used for flow control when transmit resources are unavailable. 2141 */ 2142 static inline void netif_stop_queue(struct net_device *dev) 2143 { 2144 netif_tx_stop_queue(netdev_get_tx_queue(dev, 0)); 2145 } 2146 2147 static inline void netif_tx_stop_all_queues(struct net_device *dev) 2148 { 2149 unsigned int i; 2150 2151 for (i = 0; i < dev->num_tx_queues; i++) { 2152 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 2153 netif_tx_stop_queue(txq); 2154 } 2155 } 2156 2157 static inline bool netif_tx_queue_stopped(const struct netdev_queue *dev_queue) 2158 { 2159 return test_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state); 2160 } 2161 2162 /** 2163 * netif_queue_stopped - test if transmit queue is flowblocked 2164 * @dev: network device 2165 * 2166 * Test if transmit queue on device is currently unable to send. 2167 */ 2168 static inline bool netif_queue_stopped(const struct net_device *dev) 2169 { 2170 return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0)); 2171 } 2172 2173 static inline bool netif_xmit_stopped(const struct netdev_queue *dev_queue) 2174 { 2175 return dev_queue->state & QUEUE_STATE_ANY_XOFF; 2176 } 2177 2178 static inline bool netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue) 2179 { 2180 return dev_queue->state & QUEUE_STATE_ANY_XOFF_OR_FROZEN; 2181 } 2182 2183 static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue, 2184 unsigned int bytes) 2185 { 2186 #ifdef CONFIG_BQL 2187 dql_queued(&dev_queue->dql, bytes); 2188 2189 if (likely(dql_avail(&dev_queue->dql) >= 0)) 2190 return; 2191 2192 set_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state); 2193 2194 /* 2195 * The XOFF flag must be set before checking the dql_avail below, 2196 * because in netdev_tx_completed_queue we update the dql_completed 2197 * before checking the XOFF flag. 2198 */ 2199 smp_mb(); 2200 2201 /* check again in case another CPU has just made room avail */ 2202 if (unlikely(dql_avail(&dev_queue->dql) >= 0)) 2203 clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state); 2204 #endif 2205 } 2206 2207 /** 2208 * netdev_sent_queue - report the number of bytes queued to hardware 2209 * @dev: network device 2210 * @bytes: number of bytes queued to the hardware device queue 2211 * 2212 * Report the number of bytes queued for sending/completion to the network 2213 * device hardware queue. @bytes should be a good approximation and should 2214 * exactly match netdev_completed_queue() @bytes 2215 */ 2216 static inline void netdev_sent_queue(struct net_device *dev, unsigned int bytes) 2217 { 2218 netdev_tx_sent_queue(netdev_get_tx_queue(dev, 0), bytes); 2219 } 2220 2221 static inline void netdev_tx_completed_queue(struct netdev_queue *dev_queue, 2222 unsigned int pkts, unsigned int bytes) 2223 { 2224 #ifdef CONFIG_BQL 2225 if (unlikely(!bytes)) 2226 return; 2227 2228 dql_completed(&dev_queue->dql, bytes); 2229 2230 /* 2231 * Without the memory barrier there is a small possiblity that 2232 * netdev_tx_sent_queue will miss the update and cause the queue to 2233 * be stopped forever 2234 */ 2235 smp_mb(); 2236 2237 if (dql_avail(&dev_queue->dql) < 0) 2238 return; 2239 2240 if (test_and_clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state)) 2241 netif_schedule_queue(dev_queue); 2242 #endif 2243 } 2244 2245 /** 2246 * netdev_completed_queue - report bytes and packets completed by device 2247 * @dev: network device 2248 * @pkts: actual number of packets sent over the medium 2249 * @bytes: actual number of bytes sent over the medium 2250 * 2251 * Report the number of bytes and packets transmitted by the network device 2252 * hardware queue over the physical medium, @bytes must exactly match the 2253 * @bytes amount passed to netdev_sent_queue() 2254 */ 2255 static inline void netdev_completed_queue(struct net_device *dev, 2256 unsigned int pkts, unsigned int bytes) 2257 { 2258 netdev_tx_completed_queue(netdev_get_tx_queue(dev, 0), pkts, bytes); 2259 } 2260 2261 static inline void netdev_tx_reset_queue(struct netdev_queue *q) 2262 { 2263 #ifdef CONFIG_BQL 2264 clear_bit(__QUEUE_STATE_STACK_XOFF, &q->state); 2265 dql_reset(&q->dql); 2266 #endif 2267 } 2268 2269 /** 2270 * netdev_reset_queue - reset the packets and bytes count of a network device 2271 * @dev_queue: network device 2272 * 2273 * Reset the bytes and packet count of a network device and clear the 2274 * software flow control OFF bit for this network device 2275 */ 2276 static inline void netdev_reset_queue(struct net_device *dev_queue) 2277 { 2278 netdev_tx_reset_queue(netdev_get_tx_queue(dev_queue, 0)); 2279 } 2280 2281 /** 2282 * netdev_cap_txqueue - check if selected tx queue exceeds device queues 2283 * @dev: network device 2284 * @queue_index: given tx queue index 2285 * 2286 * Returns 0 if given tx queue index >= number of device tx queues, 2287 * otherwise returns the originally passed tx queue index. 2288 */ 2289 static inline u16 netdev_cap_txqueue(struct net_device *dev, u16 queue_index) 2290 { 2291 if (unlikely(queue_index >= dev->real_num_tx_queues)) { 2292 net_warn_ratelimited("%s selects TX queue %d, but real number of TX queues is %d\n", 2293 dev->name, queue_index, 2294 dev->real_num_tx_queues); 2295 return 0; 2296 } 2297 2298 return queue_index; 2299 } 2300 2301 /** 2302 * netif_running - test if up 2303 * @dev: network device 2304 * 2305 * Test if the device has been brought up. 2306 */ 2307 static inline bool netif_running(const struct net_device *dev) 2308 { 2309 return test_bit(__LINK_STATE_START, &dev->state); 2310 } 2311 2312 /* 2313 * Routines to manage the subqueues on a device. We only need start 2314 * stop, and a check if it's stopped. All other device m