1
2
3
4#line 19 "include/asm-generic/int-ll64.h"
5typedef signed char __s8;
6#line 22 "include/asm-generic/int-ll64.h"
7typedef short __s16;
8#line 23 "include/asm-generic/int-ll64.h"
9typedef unsigned short __u16;
10#line 25 "include/asm-generic/int-ll64.h"
11typedef int __s32;
12#line 26 "include/asm-generic/int-ll64.h"
13typedef unsigned int __u32;
14#line 30 "include/asm-generic/int-ll64.h"
15typedef unsigned long long __u64;
16#line 43 "include/asm-generic/int-ll64.h"
17typedef unsigned char u8;
18#line 45 "include/asm-generic/int-ll64.h"
19typedef short s16;
20#line 46 "include/asm-generic/int-ll64.h"
21typedef unsigned short u16;
22#line 48 "include/asm-generic/int-ll64.h"
23typedef int s32;
24#line 49 "include/asm-generic/int-ll64.h"
25typedef unsigned int u32;
26#line 51 "include/asm-generic/int-ll64.h"
27typedef long long s64;
28#line 52 "include/asm-generic/int-ll64.h"
29typedef unsigned long long u64;
30#line 14 "include/asm-generic/posix_types.h"
31typedef long __kernel_long_t;
32#line 15 "include/asm-generic/posix_types.h"
33typedef unsigned long __kernel_ulong_t;
34#line 52 "include/asm-generic/posix_types.h"
35typedef unsigned int __kernel_uid32_t;
36#line 53 "include/asm-generic/posix_types.h"
37typedef unsigned int __kernel_gid32_t;
38#line 75 "include/asm-generic/posix_types.h"
39typedef __kernel_ulong_t __kernel_size_t;
40#line 76 "include/asm-generic/posix_types.h"
41typedef __kernel_long_t __kernel_ssize_t;
42#line 91 "include/asm-generic/posix_types.h"
43typedef long long __kernel_loff_t;
44#line 92 "include/asm-generic/posix_types.h"
45typedef __kernel_long_t __kernel_time_t;
46#line 95 "include/asm-generic/posix_types.h"
47typedef int __kernel_clockid_t;
48#line 21 "include/linux/types.h"
49typedef __u32 __kernel_dev_t;
50#line 24 "include/linux/types.h"
51typedef __kernel_dev_t dev_t;
52#line 27 "include/linux/types.h"
53typedef unsigned short umode_t;
54#line 35 "include/linux/types.h"
55typedef __kernel_clockid_t clockid_t;
56#line 38 "include/linux/types.h"
57typedef _Bool bool;
58#line 40 "include/linux/types.h"
59typedef __kernel_uid32_t uid_t;
60#line 41 "include/linux/types.h"
61typedef __kernel_gid32_t gid_t;
62#line 54 "include/linux/types.h"
63typedef __kernel_loff_t loff_t;
64#line 63 "include/linux/types.h"
65typedef __kernel_size_t size_t;
66#line 68 "include/linux/types.h"
67typedef __kernel_ssize_t ssize_t;
68#line 78 "include/linux/types.h"
69typedef __kernel_time_t time_t;
70#line 142 "include/linux/types.h"
71typedef unsigned long sector_t;
72#line 143 "include/linux/types.h"
73typedef unsigned long blkcnt_t;
74#line 202 "include/linux/types.h"
75typedef unsigned int gfp_t;
76#line 203 "include/linux/types.h"
77typedef unsigned int fmode_t;
78#line 206 "include/linux/types.h"
79typedef u64 phys_addr_t;
80#line 211 "include/linux/types.h"
81typedef phys_addr_t resource_size_t;
82#line 219 "include/linux/types.h"
83struct __anonstruct_atomic_t_7 {
84 int counter ;
85};
86#line 219 "include/linux/types.h"
87typedef struct __anonstruct_atomic_t_7 atomic_t;
88#line 224 "include/linux/types.h"
89struct __anonstruct_atomic64_t_8 {
90 long counter ;
91};
92#line 224 "include/linux/types.h"
93typedef struct __anonstruct_atomic64_t_8 atomic64_t;
94#line 229 "include/linux/types.h"
95struct list_head {
96 struct list_head *next ;
97 struct list_head *prev ;
98};
99#line 233
100struct hlist_node;
101#line 233 "include/linux/types.h"
102struct hlist_head {
103 struct hlist_node *first ;
104};
105#line 237 "include/linux/types.h"
106struct hlist_node {
107 struct hlist_node *next ;
108 struct hlist_node **pprev ;
109};
110#line 253 "include/linux/types.h"
111struct rcu_head {
112 struct rcu_head *next ;
113 void (*func)(struct rcu_head *head ) ;
114};
115#line 56 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/alternative.h"
116struct module;
117#line 56
118struct module;
119#line 146 "include/linux/init.h"
120typedef void (*ctor_fn_t)(void);
121#line 9 "include/linux/dynamic_debug.h"
122struct _ddebug {
123 char const *modname ;
124 char const *function ;
125 char const *filename ;
126 char const *format ;
127 unsigned int lineno : 18 ;
128 unsigned int flags : 8 ;
129} __attribute__((__aligned__(8))) ;
130#line 47
131struct device;
132#line 47
133struct device;
134#line 135 "include/linux/kernel.h"
135struct completion;
136#line 135
137struct completion;
138#line 349
139struct pid;
140#line 349
141struct pid;
142#line 12 "include/linux/thread_info.h"
143struct timespec;
144#line 12
145struct timespec;
146#line 18 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/page.h"
147struct page;
148#line 18
149struct page;
150#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/thread_info.h"
151struct task_struct;
152#line 20
153struct task_struct;
154#line 7 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/processor.h"
155struct task_struct;
156#line 295 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/pgtable_types.h"
157struct file;
158#line 295
159struct file;
160#line 313
161struct seq_file;
162#line 313
163struct seq_file;
164#line 46 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/paravirt_types.h"
165struct page;
166#line 52
167struct task_struct;
168#line 329
169struct arch_spinlock;
170#line 329
171struct arch_spinlock;
172#line 139 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/ptrace.h"
173struct task_struct;
174#line 8 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/current.h"
175struct task_struct;
176#line 10 "include/asm-generic/bug.h"
177struct bug_entry {
178 int bug_addr_disp ;
179 int file_disp ;
180 unsigned short line ;
181 unsigned short flags ;
182};
183#line 234 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/paravirt.h"
184struct static_key;
185#line 234
186struct static_key;
187#line 153 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/processor.h"
188struct seq_operations;
189#line 23 "include/asm-generic/atomic-long.h"
190typedef atomic64_t atomic_long_t;
191#line 14 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
192typedef u16 __ticket_t;
193#line 15 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
194typedef u32 __ticketpair_t;
195#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
196struct __raw_tickets {
197 __ticket_t head ;
198 __ticket_t tail ;
199};
200#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
201union __anonunion____missing_field_name_36 {
202 __ticketpair_t head_tail ;
203 struct __raw_tickets tickets ;
204};
205#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
206struct arch_spinlock {
207 union __anonunion____missing_field_name_36 __annonCompField17 ;
208};
209#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
210typedef struct arch_spinlock arch_spinlock_t;
211#line 27 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/rwlock.h"
212struct __anonstruct____missing_field_name_38 {
213 u32 read ;
214 s32 write ;
215};
216#line 27 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/rwlock.h"
217union __anonunion_arch_rwlock_t_37 {
218 s64 lock ;
219 struct __anonstruct____missing_field_name_38 __annonCompField18 ;
220};
221#line 27 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/rwlock.h"
222typedef union __anonunion_arch_rwlock_t_37 arch_rwlock_t;
223#line 12 "include/linux/lockdep.h"
224struct task_struct;
225#line 391 "include/linux/lockdep.h"
226struct lock_class_key {
227
228};
229#line 20 "include/linux/spinlock_types.h"
230struct raw_spinlock {
231 arch_spinlock_t raw_lock ;
232 unsigned int magic ;
233 unsigned int owner_cpu ;
234 void *owner ;
235};
236#line 20 "include/linux/spinlock_types.h"
237typedef struct raw_spinlock raw_spinlock_t;
238#line 64 "include/linux/spinlock_types.h"
239union __anonunion____missing_field_name_39 {
240 struct raw_spinlock rlock ;
241};
242#line 64 "include/linux/spinlock_types.h"
243struct spinlock {
244 union __anonunion____missing_field_name_39 __annonCompField19 ;
245};
246#line 64 "include/linux/spinlock_types.h"
247typedef struct spinlock spinlock_t;
248#line 11 "include/linux/rwlock_types.h"
249struct __anonstruct_rwlock_t_40 {
250 arch_rwlock_t raw_lock ;
251 unsigned int magic ;
252 unsigned int owner_cpu ;
253 void *owner ;
254};
255#line 11 "include/linux/rwlock_types.h"
256typedef struct __anonstruct_rwlock_t_40 rwlock_t;
257#line 119 "include/linux/seqlock.h"
258struct seqcount {
259 unsigned int sequence ;
260};
261#line 119 "include/linux/seqlock.h"
262typedef struct seqcount seqcount_t;
263#line 14 "include/linux/time.h"
264struct timespec {
265 __kernel_time_t tv_sec ;
266 long tv_nsec ;
267};
268#line 62 "include/linux/stat.h"
269struct kstat {
270 u64 ino ;
271 dev_t dev ;
272 umode_t mode ;
273 unsigned int nlink ;
274 uid_t uid ;
275 gid_t gid ;
276 dev_t rdev ;
277 loff_t size ;
278 struct timespec atime ;
279 struct timespec mtime ;
280 struct timespec ctime ;
281 unsigned long blksize ;
282 unsigned long long blocks ;
283};
284#line 49 "include/linux/wait.h"
285struct __wait_queue_head {
286 spinlock_t lock ;
287 struct list_head task_list ;
288};
289#line 53 "include/linux/wait.h"
290typedef struct __wait_queue_head wait_queue_head_t;
291#line 55
292struct task_struct;
293#line 60 "include/linux/pageblock-flags.h"
294struct page;
295#line 48 "include/linux/mutex.h"
296struct mutex {
297 atomic_t count ;
298 spinlock_t wait_lock ;
299 struct list_head wait_list ;
300 struct task_struct *owner ;
301 char const *name ;
302 void *magic ;
303};
304#line 19 "include/linux/rwsem.h"
305struct rw_semaphore;
306#line 19
307struct rw_semaphore;
308#line 25 "include/linux/rwsem.h"
309struct rw_semaphore {
310 long count ;
311 raw_spinlock_t wait_lock ;
312 struct list_head wait_list ;
313};
314#line 25 "include/linux/completion.h"
315struct completion {
316 unsigned int done ;
317 wait_queue_head_t wait ;
318};
319#line 9 "include/linux/memory_hotplug.h"
320struct page;
321#line 18 "include/linux/ioport.h"
322struct resource {
323 resource_size_t start ;
324 resource_size_t end ;
325 char const *name ;
326 unsigned long flags ;
327 struct resource *parent ;
328 struct resource *sibling ;
329 struct resource *child ;
330};
331#line 202
332struct device;
333#line 103 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/mpspec.h"
334struct device;
335#line 46 "include/linux/ktime.h"
336union ktime {
337 s64 tv64 ;
338};
339#line 59 "include/linux/ktime.h"
340typedef union ktime ktime_t;
341#line 10 "include/linux/timer.h"
342struct tvec_base;
343#line 10
344struct tvec_base;
345#line 12 "include/linux/timer.h"
346struct timer_list {
347 struct list_head entry ;
348 unsigned long expires ;
349 struct tvec_base *base ;
350 void (*function)(unsigned long ) ;
351 unsigned long data ;
352 int slack ;
353 int start_pid ;
354 void *start_site ;
355 char start_comm[16] ;
356};
357#line 289
358struct hrtimer;
359#line 289
360struct hrtimer;
361#line 290
362enum hrtimer_restart;
363#line 17 "include/linux/workqueue.h"
364struct work_struct;
365#line 17
366struct work_struct;
367#line 79 "include/linux/workqueue.h"
368struct work_struct {
369 atomic_long_t data ;
370 struct list_head entry ;
371 void (*func)(struct work_struct *work ) ;
372};
373#line 42 "include/linux/pm.h"
374struct device;
375#line 50 "include/linux/pm.h"
376struct pm_message {
377 int event ;
378};
379#line 50 "include/linux/pm.h"
380typedef struct pm_message pm_message_t;
381#line 264 "include/linux/pm.h"
382struct dev_pm_ops {
383 int (*prepare)(struct device *dev ) ;
384 void (*complete)(struct device *dev ) ;
385 int (*suspend)(struct device *dev ) ;
386 int (*resume)(struct device *dev ) ;
387 int (*freeze)(struct device *dev ) ;
388 int (*thaw)(struct device *dev ) ;
389 int (*poweroff)(struct device *dev ) ;
390 int (*restore)(struct device *dev ) ;
391 int (*suspend_late)(struct device *dev ) ;
392 int (*resume_early)(struct device *dev ) ;
393 int (*freeze_late)(struct device *dev ) ;
394 int (*thaw_early)(struct device *dev ) ;
395 int (*poweroff_late)(struct device *dev ) ;
396 int (*restore_early)(struct device *dev ) ;
397 int (*suspend_noirq)(struct device *dev ) ;
398 int (*resume_noirq)(struct device *dev ) ;
399 int (*freeze_noirq)(struct device *dev ) ;
400 int (*thaw_noirq)(struct device *dev ) ;
401 int (*poweroff_noirq)(struct device *dev ) ;
402 int (*restore_noirq)(struct device *dev ) ;
403 int (*runtime_suspend)(struct device *dev ) ;
404 int (*runtime_resume)(struct device *dev ) ;
405 int (*runtime_idle)(struct device *dev ) ;
406};
407#line 458
408enum rpm_status {
409 RPM_ACTIVE = 0,
410 RPM_RESUMING = 1,
411 RPM_SUSPENDED = 2,
412 RPM_SUSPENDING = 3
413} ;
414#line 480
415enum rpm_request {
416 RPM_REQ_NONE = 0,
417 RPM_REQ_IDLE = 1,
418 RPM_REQ_SUSPEND = 2,
419 RPM_REQ_AUTOSUSPEND = 3,
420 RPM_REQ_RESUME = 4
421} ;
422#line 488
423struct wakeup_source;
424#line 488
425struct wakeup_source;
426#line 495 "include/linux/pm.h"
427struct pm_subsys_data {
428 spinlock_t lock ;
429 unsigned int refcount ;
430};
431#line 506
432struct dev_pm_qos_request;
433#line 506
434struct pm_qos_constraints;
435#line 506 "include/linux/pm.h"
436struct dev_pm_info {
437 pm_message_t power_state ;
438 unsigned int can_wakeup : 1 ;
439 unsigned int async_suspend : 1 ;
440 bool is_prepared : 1 ;
441 bool is_suspended : 1 ;
442 bool ignore_children : 1 ;
443 spinlock_t lock ;
444 struct list_head entry ;
445 struct completion completion ;
446 struct wakeup_source *wakeup ;
447 bool wakeup_path : 1 ;
448 struct timer_list suspend_timer ;
449 unsigned long timer_expires ;
450 struct work_struct work ;
451 wait_queue_head_t wait_queue ;
452 atomic_t usage_count ;
453 atomic_t child_count ;
454 unsigned int disable_depth : 3 ;
455 unsigned int idle_notification : 1 ;
456 unsigned int request_pending : 1 ;
457 unsigned int deferred_resume : 1 ;
458 unsigned int run_wake : 1 ;
459 unsigned int runtime_auto : 1 ;
460 unsigned int no_callbacks : 1 ;
461 unsigned int irq_safe : 1 ;
462 unsigned int use_autosuspend : 1 ;
463 unsigned int timer_autosuspends : 1 ;
464 enum rpm_request request ;
465 enum rpm_status runtime_status ;
466 int runtime_error ;
467 int autosuspend_delay ;
468 unsigned long last_busy ;
469 unsigned long active_jiffies ;
470 unsigned long suspended_jiffies ;
471 unsigned long accounting_timestamp ;
472 ktime_t suspend_time ;
473 s64 max_time_suspended_ns ;
474 struct dev_pm_qos_request *pq_req ;
475 struct pm_subsys_data *subsys_data ;
476 struct pm_qos_constraints *constraints ;
477};
478#line 564 "include/linux/pm.h"
479struct dev_pm_domain {
480 struct dev_pm_ops ops ;
481};
482#line 8 "include/linux/vmalloc.h"
483struct vm_area_struct;
484#line 8
485struct vm_area_struct;
486#line 994 "include/linux/mmzone.h"
487struct page;
488#line 10 "include/linux/gfp.h"
489struct vm_area_struct;
490#line 29 "include/linux/sysctl.h"
491struct completion;
492#line 100 "include/linux/rbtree.h"
493struct rb_node {
494 unsigned long rb_parent_color ;
495 struct rb_node *rb_right ;
496 struct rb_node *rb_left ;
497} __attribute__((__aligned__(sizeof(long )))) ;
498#line 110 "include/linux/rbtree.h"
499struct rb_root {
500 struct rb_node *rb_node ;
501};
502#line 48 "include/linux/kmod.h"
503struct cred;
504#line 48
505struct cred;
506#line 49
507struct file;
508#line 270 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/elf.h"
509struct task_struct;
510#line 18 "include/linux/elf.h"
511typedef __u64 Elf64_Addr;
512#line 19 "include/linux/elf.h"
513typedef __u16 Elf64_Half;
514#line 23 "include/linux/elf.h"
515typedef __u32 Elf64_Word;
516#line 24 "include/linux/elf.h"
517typedef __u64 Elf64_Xword;
518#line 194 "include/linux/elf.h"
519struct elf64_sym {
520 Elf64_Word st_name ;
521 unsigned char st_info ;
522 unsigned char st_other ;
523 Elf64_Half st_shndx ;
524 Elf64_Addr st_value ;
525 Elf64_Xword st_size ;
526};
527#line 194 "include/linux/elf.h"
528typedef struct elf64_sym Elf64_Sym;
529#line 438
530struct file;
531#line 20 "include/linux/kobject_ns.h"
532struct sock;
533#line 20
534struct sock;
535#line 21
536struct kobject;
537#line 21
538struct kobject;
539#line 27
540enum kobj_ns_type {
541 KOBJ_NS_TYPE_NONE = 0,
542 KOBJ_NS_TYPE_NET = 1,
543 KOBJ_NS_TYPES = 2
544} ;
545#line 40 "include/linux/kobject_ns.h"
546struct kobj_ns_type_operations {
547 enum kobj_ns_type type ;
548 void *(*grab_current_ns)(void) ;
549 void const *(*netlink_ns)(struct sock *sk ) ;
550 void const *(*initial_ns)(void) ;
551 void (*drop_ns)(void * ) ;
552};
553#line 22 "include/linux/sysfs.h"
554struct kobject;
555#line 23
556struct module;
557#line 24
558enum kobj_ns_type;
559#line 26 "include/linux/sysfs.h"
560struct attribute {
561 char const *name ;
562 umode_t mode ;
563};
564#line 56 "include/linux/sysfs.h"
565struct attribute_group {
566 char const *name ;
567 umode_t (*is_visible)(struct kobject * , struct attribute * , int ) ;
568 struct attribute **attrs ;
569};
570#line 85
571struct file;
572#line 86
573struct vm_area_struct;
574#line 88 "include/linux/sysfs.h"
575struct bin_attribute {
576 struct attribute attr ;
577 size_t size ;
578 void *private ;
579 ssize_t (*read)(struct file * , struct kobject * , struct bin_attribute * , char * ,
580 loff_t , size_t ) ;
581 ssize_t (*write)(struct file * , struct kobject * , struct bin_attribute * , char * ,
582 loff_t , size_t ) ;
583 int (*mmap)(struct file * , struct kobject * , struct bin_attribute *attr , struct vm_area_struct *vma ) ;
584};
585#line 112 "include/linux/sysfs.h"
586struct sysfs_ops {
587 ssize_t (*show)(struct kobject * , struct attribute * , char * ) ;
588 ssize_t (*store)(struct kobject * , struct attribute * , char const * , size_t ) ;
589 void const *(*namespace)(struct kobject * , struct attribute const * ) ;
590};
591#line 118
592struct sysfs_dirent;
593#line 118
594struct sysfs_dirent;
595#line 22 "include/linux/kref.h"
596struct kref {
597 atomic_t refcount ;
598};
599#line 60 "include/linux/kobject.h"
600struct kset;
601#line 60
602struct kobj_type;
603#line 60 "include/linux/kobject.h"
604struct kobject {
605 char const *name ;
606 struct list_head entry ;
607 struct kobject *parent ;
608 struct kset *kset ;
609 struct kobj_type *ktype ;
610 struct sysfs_dirent *sd ;
611 struct kref kref ;
612 unsigned int state_initialized : 1 ;
613 unsigned int state_in_sysfs : 1 ;
614 unsigned int state_add_uevent_sent : 1 ;
615 unsigned int state_remove_uevent_sent : 1 ;
616 unsigned int uevent_suppress : 1 ;
617};
618#line 108 "include/linux/kobject.h"
619struct kobj_type {
620 void (*release)(struct kobject *kobj ) ;
621 struct sysfs_ops const *sysfs_ops ;
622 struct attribute **default_attrs ;
623 struct kobj_ns_type_operations const *(*child_ns_type)(struct kobject *kobj ) ;
624 void const *(*namespace)(struct kobject *kobj ) ;
625};
626#line 116 "include/linux/kobject.h"
627struct kobj_uevent_env {
628 char *envp[32] ;
629 int envp_idx ;
630 char buf[2048] ;
631 int buflen ;
632};
633#line 123 "include/linux/kobject.h"
634struct kset_uevent_ops {
635 int (* const filter)(struct kset *kset , struct kobject *kobj ) ;
636 char const *(* const name)(struct kset *kset , struct kobject *kobj ) ;
637 int (* const uevent)(struct kset *kset , struct kobject *kobj , struct kobj_uevent_env *env ) ;
638};
639#line 140
640struct sock;
641#line 159 "include/linux/kobject.h"
642struct kset {
643 struct list_head list ;
644 spinlock_t list_lock ;
645 struct kobject kobj ;
646 struct kset_uevent_ops const *uevent_ops ;
647};
648#line 39 "include/linux/moduleparam.h"
649struct kernel_param;
650#line 39
651struct kernel_param;
652#line 41 "include/linux/moduleparam.h"
653struct kernel_param_ops {
654 int (*set)(char const *val , struct kernel_param const *kp ) ;
655 int (*get)(char *buffer , struct kernel_param const *kp ) ;
656 void (*free)(void *arg ) ;
657};
658#line 50
659struct kparam_string;
660#line 50
661struct kparam_array;
662#line 50 "include/linux/moduleparam.h"
663union __anonunion____missing_field_name_199 {
664 void *arg ;
665 struct kparam_string const *str ;
666 struct kparam_array const *arr ;
667};
668#line 50 "include/linux/moduleparam.h"
669struct kernel_param {
670 char const *name ;
671 struct kernel_param_ops const *ops ;
672 u16 perm ;
673 s16 level ;
674 union __anonunion____missing_field_name_199 __annonCompField32 ;
675};
676#line 63 "include/linux/moduleparam.h"
677struct kparam_string {
678 unsigned int maxlen ;
679 char *string ;
680};
681#line 69 "include/linux/moduleparam.h"
682struct kparam_array {
683 unsigned int max ;
684 unsigned int elemsize ;
685 unsigned int *num ;
686 struct kernel_param_ops const *ops ;
687 void *elem ;
688};
689#line 445
690struct module;
691#line 80 "include/linux/jump_label.h"
692struct module;
693#line 143 "include/linux/jump_label.h"
694struct static_key {
695 atomic_t enabled ;
696};
697#line 22 "include/linux/tracepoint.h"
698struct module;
699#line 23
700struct tracepoint;
701#line 23
702struct tracepoint;
703#line 25 "include/linux/tracepoint.h"
704struct tracepoint_func {
705 void *func ;
706 void *data ;
707};
708#line 30 "include/linux/tracepoint.h"
709struct tracepoint {
710 char const *name ;
711 struct static_key key ;
712 void (*regfunc)(void) ;
713 void (*unregfunc)(void) ;
714 struct tracepoint_func *funcs ;
715};
716#line 19 "include/linux/export.h"
717struct kernel_symbol {
718 unsigned long value ;
719 char const *name ;
720};
721#line 8 "include/asm-generic/module.h"
722struct mod_arch_specific {
723
724};
725#line 35 "include/linux/module.h"
726struct module;
727#line 37
728struct module_param_attrs;
729#line 37 "include/linux/module.h"
730struct module_kobject {
731 struct kobject kobj ;
732 struct module *mod ;
733 struct kobject *drivers_dir ;
734 struct module_param_attrs *mp ;
735};
736#line 44 "include/linux/module.h"
737struct module_attribute {
738 struct attribute attr ;
739 ssize_t (*show)(struct module_attribute * , struct module_kobject * , char * ) ;
740 ssize_t (*store)(struct module_attribute * , struct module_kobject * , char const * ,
741 size_t count ) ;
742 void (*setup)(struct module * , char const * ) ;
743 int (*test)(struct module * ) ;
744 void (*free)(struct module * ) ;
745};
746#line 71
747struct exception_table_entry;
748#line 71
749struct exception_table_entry;
750#line 199
751enum module_state {
752 MODULE_STATE_LIVE = 0,
753 MODULE_STATE_COMING = 1,
754 MODULE_STATE_GOING = 2
755} ;
756#line 215 "include/linux/module.h"
757struct module_ref {
758 unsigned long incs ;
759 unsigned long decs ;
760} __attribute__((__aligned__((2) * (sizeof(unsigned long )) ))) ;
761#line 220
762struct module_sect_attrs;
763#line 220
764struct module_notes_attrs;
765#line 220
766struct ftrace_event_call;
767#line 220 "include/linux/module.h"
768struct module {
769 enum module_state state ;
770 struct list_head list ;
771 char name[64UL - sizeof(unsigned long )] ;
772 struct module_kobject mkobj ;
773 struct module_attribute *modinfo_attrs ;
774 char const *version ;
775 char const *srcversion ;
776 struct kobject *holders_dir ;
777 struct kernel_symbol const *syms ;
778 unsigned long const *crcs ;
779 unsigned int num_syms ;
780 struct kernel_param *kp ;
781 unsigned int num_kp ;
782 unsigned int num_gpl_syms ;
783 struct kernel_symbol const *gpl_syms ;
784 unsigned long const *gpl_crcs ;
785 struct kernel_symbol const *unused_syms ;
786 unsigned long const *unused_crcs ;
787 unsigned int num_unused_syms ;
788 unsigned int num_unused_gpl_syms ;
789 struct kernel_symbol const *unused_gpl_syms ;
790 unsigned long const *unused_gpl_crcs ;
791 struct kernel_symbol const *gpl_future_syms ;
792 unsigned long const *gpl_future_crcs ;
793 unsigned int num_gpl_future_syms ;
794 unsigned int num_exentries ;
795 struct exception_table_entry *extable ;
796 int (*init)(void) ;
797 void *module_init ;
798 void *module_core ;
799 unsigned int init_size ;
800 unsigned int core_size ;
801 unsigned int init_text_size ;
802 unsigned int core_text_size ;
803 unsigned int init_ro_size ;
804 unsigned int core_ro_size ;
805 struct mod_arch_specific arch ;
806 unsigned int taints ;
807 unsigned int num_bugs ;
808 struct list_head bug_list ;
809 struct bug_entry *bug_table ;
810 Elf64_Sym *symtab ;
811 Elf64_Sym *core_symtab ;
812 unsigned int num_symtab ;
813 unsigned int core_num_syms ;
814 char *strtab ;
815 char *core_strtab ;
816 struct module_sect_attrs *sect_attrs ;
817 struct module_notes_attrs *notes_attrs ;
818 char *args ;
819 void *percpu ;
820 unsigned int percpu_size ;
821 unsigned int num_tracepoints ;
822 struct tracepoint * const *tracepoints_ptrs ;
823 unsigned int num_trace_bprintk_fmt ;
824 char const **trace_bprintk_fmt_start ;
825 struct ftrace_event_call **trace_events ;
826 unsigned int num_trace_events ;
827 struct list_head source_list ;
828 struct list_head target_list ;
829 struct task_struct *waiter ;
830 void (*exit)(void) ;
831 struct module_ref *refptr ;
832 ctor_fn_t *ctors ;
833 unsigned int num_ctors ;
834};
835#line 20 "include/linux/rtc.h"
836struct rtc_time {
837 int tm_sec ;
838 int tm_min ;
839 int tm_hour ;
840 int tm_mday ;
841 int tm_mon ;
842 int tm_year ;
843 int tm_wday ;
844 int tm_yday ;
845 int tm_isdst ;
846};
847#line 36 "include/linux/rtc.h"
848struct rtc_wkalrm {
849 unsigned char enabled ;
850 unsigned char pending ;
851 struct rtc_time time ;
852};
853#line 10 "include/linux/irqreturn.h"
854enum irqreturn {
855 IRQ_NONE = 0,
856 IRQ_HANDLED = 1,
857 IRQ_WAKE_THREAD = 2
858} ;
859#line 16 "include/linux/irqreturn.h"
860typedef enum irqreturn irqreturn_t;
861#line 31 "include/linux/irq.h"
862struct seq_file;
863#line 32
864struct module;
865#line 14 "include/linux/irqdesc.h"
866struct module;
867#line 65 "include/linux/profile.h"
868struct task_struct;
869#line 94 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/uaccess.h"
870struct exception_table_entry {
871 unsigned long insn ;
872 unsigned long fixup ;
873};
874#line 132 "include/linux/hardirq.h"
875struct task_struct;
876#line 8 "include/linux/timerqueue.h"
877struct timerqueue_node {
878 struct rb_node node ;
879 ktime_t expires ;
880};
881#line 13 "include/linux/timerqueue.h"
882struct timerqueue_head {
883 struct rb_root head ;
884 struct timerqueue_node *next ;
885};
886#line 27 "include/linux/hrtimer.h"
887struct hrtimer_clock_base;
888#line 27
889struct hrtimer_clock_base;
890#line 28
891struct hrtimer_cpu_base;
892#line 28
893struct hrtimer_cpu_base;
894#line 44
895enum hrtimer_restart {
896 HRTIMER_NORESTART = 0,
897 HRTIMER_RESTART = 1
898} ;
899#line 108 "include/linux/hrtimer.h"
900struct hrtimer {
901 struct timerqueue_node node ;
902 ktime_t _softexpires ;
903 enum hrtimer_restart (*function)(struct hrtimer * ) ;
904 struct hrtimer_clock_base *base ;
905 unsigned long state ;
906 int start_pid ;
907 void *start_site ;
908 char start_comm[16] ;
909};
910#line 145 "include/linux/hrtimer.h"
911struct hrtimer_clock_base {
912 struct hrtimer_cpu_base *cpu_base ;
913 int index ;
914 clockid_t clockid ;
915 struct timerqueue_head active ;
916 ktime_t resolution ;
917 ktime_t (*get_time)(void) ;
918 ktime_t softirq_time ;
919 ktime_t offset ;
920};
921#line 178 "include/linux/hrtimer.h"
922struct hrtimer_cpu_base {
923 raw_spinlock_t lock ;
924 unsigned long active_bases ;
925 ktime_t expires_next ;
926 int hres_active ;
927 int hang_detected ;
928 unsigned long nr_events ;
929 unsigned long nr_retries ;
930 unsigned long nr_hangs ;
931 ktime_t max_hang_time ;
932 struct hrtimer_clock_base clock_base[3] ;
933};
934#line 187 "include/linux/interrupt.h"
935struct device;
936#line 695
937struct seq_file;
938#line 19 "include/linux/klist.h"
939struct klist_node;
940#line 19
941struct klist_node;
942#line 39 "include/linux/klist.h"
943struct klist_node {
944 void *n_klist ;
945 struct list_head n_node ;
946 struct kref n_ref ;
947};
948#line 4 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/device.h"
949struct dma_map_ops;
950#line 4 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/device.h"
951struct dev_archdata {
952 void *acpi_handle ;
953 struct dma_map_ops *dma_ops ;
954 void *iommu ;
955};
956#line 16 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/device.h"
957struct pdev_archdata {
958
959};
960#line 28 "include/linux/device.h"
961struct device;
962#line 29
963struct device_private;
964#line 29
965struct device_private;
966#line 30
967struct device_driver;
968#line 30
969struct device_driver;
970#line 31
971struct driver_private;
972#line 31
973struct driver_private;
974#line 32
975struct module;
976#line 33
977struct class;
978#line 33
979struct class;
980#line 34
981struct subsys_private;
982#line 34
983struct subsys_private;
984#line 35
985struct bus_type;
986#line 35
987struct bus_type;
988#line 36
989struct device_node;
990#line 36
991struct device_node;
992#line 37
993struct iommu_ops;
994#line 37
995struct iommu_ops;
996#line 39 "include/linux/device.h"
997struct bus_attribute {
998 struct attribute attr ;
999 ssize_t (*show)(struct bus_type *bus , char *buf ) ;
1000 ssize_t (*store)(struct bus_type *bus , char const *buf , size_t count ) ;
1001};
1002#line 89
1003struct device_attribute;
1004#line 89
1005struct driver_attribute;
1006#line 89 "include/linux/device.h"
1007struct bus_type {
1008 char const *name ;
1009 char const *dev_name ;
1010 struct device *dev_root ;
1011 struct bus_attribute *bus_attrs ;
1012 struct device_attribute *dev_attrs ;
1013 struct driver_attribute *drv_attrs ;
1014 int (*match)(struct device *dev , struct device_driver *drv ) ;
1015 int (*uevent)(struct device *dev , struct kobj_uevent_env *env ) ;
1016 int (*probe)(struct device *dev ) ;
1017 int (*remove)(struct device *dev ) ;
1018 void (*shutdown)(struct device *dev ) ;
1019 int (*suspend)(struct device *dev , pm_message_t state ) ;
1020 int (*resume)(struct device *dev ) ;
1021 struct dev_pm_ops const *pm ;
1022 struct iommu_ops *iommu_ops ;
1023 struct subsys_private *p ;
1024};
1025#line 127
1026struct device_type;
1027#line 214
1028struct of_device_id;
1029#line 214 "include/linux/device.h"
1030struct device_driver {
1031 char const *name ;
1032 struct bus_type *bus ;
1033 struct module *owner ;
1034 char const *mod_name ;
1035 bool suppress_bind_attrs ;
1036 struct of_device_id const *of_match_table ;
1037 int (*probe)(struct device *dev ) ;
1038 int (*remove)(struct device *dev ) ;
1039 void (*shutdown)(struct device *dev ) ;
1040 int (*suspend)(struct device *dev , pm_message_t state ) ;
1041 int (*resume)(struct device *dev ) ;
1042 struct attribute_group const **groups ;
1043 struct dev_pm_ops const *pm ;
1044 struct driver_private *p ;
1045};
1046#line 249 "include/linux/device.h"
1047struct driver_attribute {
1048 struct attribute attr ;
1049 ssize_t (*show)(struct device_driver *driver , char *buf ) ;
1050 ssize_t (*store)(struct device_driver *driver , char const *buf , size_t count ) ;
1051};
1052#line 330
1053struct class_attribute;
1054#line 330 "include/linux/device.h"
1055struct class {
1056 char const *name ;
1057 struct module *owner ;
1058 struct class_attribute *class_attrs ;
1059 struct device_attribute *dev_attrs ;
1060 struct bin_attribute *dev_bin_attrs ;
1061 struct kobject *dev_kobj ;
1062 int (*dev_uevent)(struct device *dev , struct kobj_uevent_env *env ) ;
1063 char *(*devnode)(struct device *dev , umode_t *mode ) ;
1064 void (*class_release)(struct class *class ) ;
1065 void (*dev_release)(struct device *dev ) ;
1066 int (*suspend)(struct device *dev , pm_message_t state ) ;
1067 int (*resume)(struct device *dev ) ;
1068 struct kobj_ns_type_operations const *ns_type ;
1069 void const *(*namespace)(struct device *dev ) ;
1070 struct dev_pm_ops const *pm ;
1071 struct subsys_private *p ;
1072};
1073#line 397 "include/linux/device.h"
1074struct class_attribute {
1075 struct attribute attr ;
1076 ssize_t (*show)(struct class *class , struct class_attribute *attr , char *buf ) ;
1077 ssize_t (*store)(struct class *class , struct class_attribute *attr , char const *buf ,
1078 size_t count ) ;
1079 void const *(*namespace)(struct class *class , struct class_attribute const *attr ) ;
1080};
1081#line 465 "include/linux/device.h"
1082struct device_type {
1083 char const *name ;
1084 struct attribute_group const **groups ;
1085 int (*uevent)(struct device *dev , struct kobj_uevent_env *env ) ;
1086 char *(*devnode)(struct device *dev , umode_t *mode ) ;
1087 void (*release)(struct device *dev ) ;
1088 struct dev_pm_ops const *pm ;
1089};
1090#line 476 "include/linux/device.h"
1091struct device_attribute {
1092 struct attribute attr ;
1093 ssize_t (*show)(struct device *dev , struct device_attribute *attr , char *buf ) ;
1094 ssize_t (*store)(struct device *dev , struct device_attribute *attr , char const *buf ,
1095 size_t count ) ;
1096};
1097#line 559 "include/linux/device.h"
1098struct device_dma_parameters {
1099 unsigned int max_segment_size ;
1100 unsigned long segment_boundary_mask ;
1101};
1102#line 627
1103struct dma_coherent_mem;
1104#line 627 "include/linux/device.h"
1105struct device {
1106 struct device *parent ;
1107 struct device_private *p ;
1108 struct kobject kobj ;
1109 char const *init_name ;
1110 struct device_type const *type ;
1111 struct mutex mutex ;
1112 struct bus_type *bus ;
1113 struct device_driver *driver ;
1114 void *platform_data ;
1115 struct dev_pm_info power ;
1116 struct dev_pm_domain *pm_domain ;
1117 int numa_node ;
1118 u64 *dma_mask ;
1119 u64 coherent_dma_mask ;
1120 struct device_dma_parameters *dma_parms ;
1121 struct list_head dma_pools ;
1122 struct dma_coherent_mem *dma_mem ;
1123 struct dev_archdata archdata ;
1124 struct device_node *of_node ;
1125 dev_t devt ;
1126 u32 id ;
1127 spinlock_t devres_lock ;
1128 struct list_head devres_head ;
1129 struct klist_node knode_class ;
1130 struct class *class ;
1131 struct attribute_group const **groups ;
1132 void (*release)(struct device *dev ) ;
1133};
1134#line 43 "include/linux/pm_wakeup.h"
1135struct wakeup_source {
1136 char const *name ;
1137 struct list_head entry ;
1138 spinlock_t lock ;
1139 struct timer_list timer ;
1140 unsigned long timer_expires ;
1141 ktime_t total_time ;
1142 ktime_t max_time ;
1143 ktime_t last_time ;
1144 unsigned long event_count ;
1145 unsigned long active_count ;
1146 unsigned long relax_count ;
1147 unsigned long hit_count ;
1148 unsigned int active : 1 ;
1149};
1150#line 11 "include/linux/seq_file.h"
1151struct seq_operations;
1152#line 12
1153struct file;
1154#line 13
1155struct path;
1156#line 13
1157struct path;
1158#line 14
1159struct inode;
1160#line 14
1161struct inode;
1162#line 15
1163struct dentry;
1164#line 15
1165struct dentry;
1166#line 17 "include/linux/seq_file.h"
1167struct seq_file {
1168 char *buf ;
1169 size_t size ;
1170 size_t from ;
1171 size_t count ;
1172 loff_t index ;
1173 loff_t read_pos ;
1174 u64 version ;
1175 struct mutex lock ;
1176 struct seq_operations const *op ;
1177 int poll_event ;
1178 void *private ;
1179};
1180#line 31 "include/linux/seq_file.h"
1181struct seq_operations {
1182 void *(*start)(struct seq_file *m , loff_t *pos ) ;
1183 void (*stop)(struct seq_file *m , void *v ) ;
1184 void *(*next)(struct seq_file *m , void *v , loff_t *pos ) ;
1185 int (*show)(struct seq_file *m , void *v ) ;
1186};
1187#line 8 "include/linux/cdev.h"
1188struct file_operations;
1189#line 8
1190struct file_operations;
1191#line 9
1192struct inode;
1193#line 10
1194struct module;
1195#line 12 "include/linux/cdev.h"
1196struct cdev {
1197 struct kobject kobj ;
1198 struct module *owner ;
1199 struct file_operations const *ops ;
1200 struct list_head list ;
1201 dev_t dev ;
1202 unsigned int count ;
1203};
1204#line 33
1205struct backing_dev_info;
1206#line 15 "include/linux/blk_types.h"
1207struct page;
1208#line 16
1209struct block_device;
1210#line 16
1211struct block_device;
1212#line 33 "include/linux/list_bl.h"
1213struct hlist_bl_node;
1214#line 33 "include/linux/list_bl.h"
1215struct hlist_bl_head {
1216 struct hlist_bl_node *first ;
1217};
1218#line 37 "include/linux/list_bl.h"
1219struct hlist_bl_node {
1220 struct hlist_bl_node *next ;
1221 struct hlist_bl_node **pprev ;
1222};
1223#line 13 "include/linux/dcache.h"
1224struct nameidata;
1225#line 13
1226struct nameidata;
1227#line 14
1228struct path;
1229#line 15
1230struct vfsmount;
1231#line 15
1232struct vfsmount;
1233#line 35 "include/linux/dcache.h"
1234struct qstr {
1235 unsigned int hash ;
1236 unsigned int len ;
1237 unsigned char const *name ;
1238};
1239#line 88
1240struct dentry_operations;
1241#line 88
1242struct super_block;
1243#line 88 "include/linux/dcache.h"
1244union __anonunion_d_u_209 {
1245 struct list_head d_child ;
1246 struct rcu_head d_rcu ;
1247};
1248#line 88 "include/linux/dcache.h"
1249struct dentry {
1250 unsigned int d_flags ;
1251 seqcount_t d_seq ;
1252 struct hlist_bl_node d_hash ;
1253 struct dentry *d_parent ;
1254 struct qstr d_name ;
1255 struct inode *d_inode ;
1256 unsigned char d_iname[32] ;
1257 unsigned int d_count ;
1258 spinlock_t d_lock ;
1259 struct dentry_operations const *d_op ;
1260 struct super_block *d_sb ;
1261 unsigned long d_time ;
1262 void *d_fsdata ;
1263 struct list_head d_lru ;
1264 union __anonunion_d_u_209 d_u ;
1265 struct list_head d_subdirs ;
1266 struct list_head d_alias ;
1267};
1268#line 131 "include/linux/dcache.h"
1269struct dentry_operations {
1270 int (*d_revalidate)(struct dentry * , struct nameidata * ) ;
1271 int (*d_hash)(struct dentry const * , struct inode const * , struct qstr * ) ;
1272 int (*d_compare)(struct dentry const * , struct inode const * , struct dentry const * ,
1273 struct inode const * , unsigned int , char const * , struct qstr const * ) ;
1274 int (*d_delete)(struct dentry const * ) ;
1275 void (*d_release)(struct dentry * ) ;
1276 void (*d_prune)(struct dentry * ) ;
1277 void (*d_iput)(struct dentry * , struct inode * ) ;
1278 char *(*d_dname)(struct dentry * , char * , int ) ;
1279 struct vfsmount *(*d_automount)(struct path * ) ;
1280 int (*d_manage)(struct dentry * , bool ) ;
1281} __attribute__((__aligned__((1) << (6) ))) ;
1282#line 4 "include/linux/path.h"
1283struct dentry;
1284#line 5
1285struct vfsmount;
1286#line 7 "include/linux/path.h"
1287struct path {
1288 struct vfsmount *mnt ;
1289 struct dentry *dentry ;
1290};
1291#line 64 "include/linux/radix-tree.h"
1292struct radix_tree_node;
1293#line 64 "include/linux/radix-tree.h"
1294struct radix_tree_root {
1295 unsigned int height ;
1296 gfp_t gfp_mask ;
1297 struct radix_tree_node *rnode ;
1298};
1299#line 14 "include/linux/prio_tree.h"
1300struct prio_tree_node;
1301#line 20 "include/linux/prio_tree.h"
1302struct prio_tree_node {
1303 struct prio_tree_node *left ;
1304 struct prio_tree_node *right ;
1305 struct prio_tree_node *parent ;
1306 unsigned long start ;
1307 unsigned long last ;
1308};
1309#line 28 "include/linux/prio_tree.h"
1310struct prio_tree_root {
1311 struct prio_tree_node *prio_tree_node ;
1312 unsigned short index_bits ;
1313 unsigned short raw ;
1314};
1315#line 6 "include/linux/pid.h"
1316enum pid_type {
1317 PIDTYPE_PID = 0,
1318 PIDTYPE_PGID = 1,
1319 PIDTYPE_SID = 2,
1320 PIDTYPE_MAX = 3
1321} ;
1322#line 50
1323struct pid_namespace;
1324#line 50 "include/linux/pid.h"
1325struct upid {
1326 int nr ;
1327 struct pid_namespace *ns ;
1328 struct hlist_node pid_chain ;
1329};
1330#line 57 "include/linux/pid.h"
1331struct pid {
1332 atomic_t count ;
1333 unsigned int level ;
1334 struct hlist_head tasks[3] ;
1335 struct rcu_head rcu ;
1336 struct upid numbers[1] ;
1337};
1338#line 100
1339struct pid_namespace;
1340#line 18 "include/linux/capability.h"
1341struct task_struct;
1342#line 377
1343struct dentry;
1344#line 16 "include/linux/fiemap.h"
1345struct fiemap_extent {
1346 __u64 fe_logical ;
1347 __u64 fe_physical ;
1348 __u64 fe_length ;
1349 __u64 fe_reserved64[2] ;
1350 __u32 fe_flags ;
1351 __u32 fe_reserved[3] ;
1352};
1353#line 8 "include/linux/shrinker.h"
1354struct shrink_control {
1355 gfp_t gfp_mask ;
1356 unsigned long nr_to_scan ;
1357};
1358#line 31 "include/linux/shrinker.h"
1359struct shrinker {
1360 int (*shrink)(struct shrinker * , struct shrink_control *sc ) ;
1361 int seeks ;
1362 long batch ;
1363 struct list_head list ;
1364 atomic_long_t nr_in_batch ;
1365};
1366#line 10 "include/linux/migrate_mode.h"
1367enum migrate_mode {
1368 MIGRATE_ASYNC = 0,
1369 MIGRATE_SYNC_LIGHT = 1,
1370 MIGRATE_SYNC = 2
1371} ;
1372#line 408 "include/linux/fs.h"
1373struct export_operations;
1374#line 408
1375struct export_operations;
1376#line 410
1377struct iovec;
1378#line 410
1379struct iovec;
1380#line 411
1381struct nameidata;
1382#line 412
1383struct kiocb;
1384#line 412
1385struct kiocb;
1386#line 413
1387struct kobject;
1388#line 414
1389struct pipe_inode_info;
1390#line 414
1391struct pipe_inode_info;
1392#line 415
1393struct poll_table_struct;
1394#line 415
1395struct poll_table_struct;
1396#line 416
1397struct kstatfs;
1398#line 416
1399struct kstatfs;
1400#line 417
1401struct vm_area_struct;
1402#line 418
1403struct vfsmount;
1404#line 419
1405struct cred;
1406#line 469 "include/linux/fs.h"
1407struct iattr {
1408 unsigned int ia_valid ;
1409 umode_t ia_mode ;
1410 uid_t ia_uid ;
1411 gid_t ia_gid ;
1412 loff_t ia_size ;
1413 struct timespec ia_atime ;
1414 struct timespec ia_mtime ;
1415 struct timespec ia_ctime ;
1416 struct file *ia_file ;
1417};
1418#line 129 "include/linux/quota.h"
1419struct if_dqinfo {
1420 __u64 dqi_bgrace ;
1421 __u64 dqi_igrace ;
1422 __u32 dqi_flags ;
1423 __u32 dqi_valid ;
1424};
1425#line 50 "include/linux/dqblk_xfs.h"
1426struct fs_disk_quota {
1427 __s8 d_version ;
1428 __s8 d_flags ;
1429 __u16 d_fieldmask ;
1430 __u32 d_id ;
1431 __u64 d_blk_hardlimit ;
1432 __u64 d_blk_softlimit ;
1433 __u64 d_ino_hardlimit ;
1434 __u64 d_ino_softlimit ;
1435 __u64 d_bcount ;
1436 __u64 d_icount ;
1437 __s32 d_itimer ;
1438 __s32 d_btimer ;
1439 __u16 d_iwarns ;
1440 __u16 d_bwarns ;
1441 __s32 d_padding2 ;
1442 __u64 d_rtb_hardlimit ;
1443 __u64 d_rtb_softlimit ;
1444 __u64 d_rtbcount ;
1445 __s32 d_rtbtimer ;
1446 __u16 d_rtbwarns ;
1447 __s16 d_padding3 ;
1448 char d_padding4[8] ;
1449};
1450#line 146 "include/linux/dqblk_xfs.h"
1451struct fs_qfilestat {
1452 __u64 qfs_ino ;
1453 __u64 qfs_nblks ;
1454 __u32 qfs_nextents ;
1455};
1456#line 146 "include/linux/dqblk_xfs.h"
1457typedef struct fs_qfilestat fs_qfilestat_t;
1458#line 152 "include/linux/dqblk_xfs.h"
1459struct fs_quota_stat {
1460 __s8 qs_version ;
1461 __u16 qs_flags ;
1462 __s8 qs_pad ;
1463 fs_qfilestat_t qs_uquota ;
1464 fs_qfilestat_t qs_gquota ;
1465 __u32 qs_incoredqs ;
1466 __s32 qs_btimelimit ;
1467 __s32 qs_itimelimit ;
1468 __s32 qs_rtbtimelimit ;
1469 __u16 qs_bwarnlimit ;
1470 __u16 qs_iwarnlimit ;
1471};
1472#line 17 "include/linux/dqblk_qtree.h"
1473struct dquot;
1474#line 17
1475struct dquot;
1476#line 185 "include/linux/quota.h"
1477typedef __kernel_uid32_t qid_t;
1478#line 186 "include/linux/quota.h"
1479typedef long long qsize_t;
1480#line 200 "include/linux/quota.h"
1481struct mem_dqblk {
1482 qsize_t dqb_bhardlimit ;
1483 qsize_t dqb_bsoftlimit ;
1484 qsize_t dqb_curspace ;
1485 qsize_t dqb_rsvspace ;
1486 qsize_t dqb_ihardlimit ;
1487 qsize_t dqb_isoftlimit ;
1488 qsize_t dqb_curinodes ;
1489 time_t dqb_btime ;
1490 time_t dqb_itime ;
1491};
1492#line 215
1493struct quota_format_type;
1494#line 215
1495struct quota_format_type;
1496#line 217 "include/linux/quota.h"
1497struct mem_dqinfo {
1498 struct quota_format_type *dqi_format ;
1499 int dqi_fmt_id ;
1500 struct list_head dqi_dirty_list ;
1501 unsigned long dqi_flags ;
1502 unsigned int dqi_bgrace ;
1503 unsigned int dqi_igrace ;
1504 qsize_t dqi_maxblimit ;
1505 qsize_t dqi_maxilimit ;
1506 void *dqi_priv ;
1507};
1508#line 230
1509struct super_block;
1510#line 288 "include/linux/quota.h"
1511struct dquot {
1512 struct hlist_node dq_hash ;
1513 struct list_head dq_inuse ;
1514 struct list_head dq_free ;
1515 struct list_head dq_dirty ;
1516 struct mutex dq_lock ;
1517 atomic_t dq_count ;
1518 wait_queue_head_t dq_wait_unused ;
1519 struct super_block *dq_sb ;
1520 unsigned int dq_id ;
1521 loff_t dq_off ;
1522 unsigned long dq_flags ;
1523 short dq_type ;
1524 struct mem_dqblk dq_dqb ;
1525};
1526#line 305 "include/linux/quota.h"
1527struct quota_format_ops {
1528 int (*check_quota_file)(struct super_block *sb , int type ) ;
1529 int (*read_file_info)(struct super_block *sb , int type ) ;
1530 int (*write_file_info)(struct super_block *sb , int type ) ;
1531 int (*free_file_info)(struct super_block *sb , int type ) ;
1532 int (*read_dqblk)(struct dquot *dquot ) ;
1533 int (*commit_dqblk)(struct dquot *dquot ) ;
1534 int (*release_dqblk)(struct dquot *dquot ) ;
1535};
1536#line 316 "include/linux/quota.h"
1537struct dquot_operations {
1538 int (*write_dquot)(struct dquot * ) ;
1539 struct dquot *(*alloc_dquot)(struct super_block * , int ) ;
1540 void (*destroy_dquot)(struct dquot * ) ;
1541 int (*acquire_dquot)(struct dquot * ) ;
1542 int (*release_dquot)(struct dquot * ) ;
1543 int (*mark_dirty)(struct dquot * ) ;
1544 int (*write_info)(struct super_block * , int ) ;
1545 qsize_t *(*get_reserved_space)(struct inode * ) ;
1546};
1547#line 329
1548struct path;
1549#line 332 "include/linux/quota.h"
1550struct quotactl_ops {
1551 int (*quota_on)(struct super_block * , int , int , struct path * ) ;
1552 int (*quota_on_meta)(struct super_block * , int , int ) ;
1553 int (*quota_off)(struct super_block * , int ) ;
1554 int (*quota_sync)(struct super_block * , int , int ) ;
1555 int (*get_info)(struct super_block * , int , struct if_dqinfo * ) ;
1556 int (*set_info)(struct super_block * , int , struct if_dqinfo * ) ;
1557 int (*get_dqblk)(struct super_block * , int , qid_t , struct fs_disk_quota * ) ;
1558 int (*set_dqblk)(struct super_block * , int , qid_t , struct fs_disk_quota * ) ;
1559 int (*get_xstate)(struct super_block * , struct fs_quota_stat * ) ;
1560 int (*set_xstate)(struct super_block * , unsigned int , int ) ;
1561};
1562#line 345 "include/linux/quota.h"
1563struct quota_format_type {
1564 int qf_fmt_id ;
1565 struct quota_format_ops const *qf_ops ;
1566 struct module *qf_owner ;
1567 struct quota_format_type *qf_next ;
1568};
1569#line 399 "include/linux/quota.h"
1570struct quota_info {
1571 unsigned int flags ;
1572 struct mutex dqio_mutex ;
1573 struct mutex dqonoff_mutex ;
1574 struct rw_semaphore dqptr_sem ;
1575 struct inode *files[2] ;
1576 struct mem_dqinfo info[2] ;
1577 struct quota_format_ops const *ops[2] ;
1578};
1579#line 532 "include/linux/fs.h"
1580struct page;
1581#line 533
1582struct address_space;
1583#line 533
1584struct address_space;
1585#line 534
1586struct writeback_control;
1587#line 534
1588struct writeback_control;
1589#line 577 "include/linux/fs.h"
1590union __anonunion_arg_217 {
1591 char *buf ;
1592 void *data ;
1593};
1594#line 577 "include/linux/fs.h"
1595struct __anonstruct_read_descriptor_t_216 {
1596 size_t written ;
1597 size_t count ;
1598 union __anonunion_arg_217 arg ;
1599 int error ;
1600};
1601#line 577 "include/linux/fs.h"
1602typedef struct __anonstruct_read_descriptor_t_216 read_descriptor_t;
1603#line 590 "include/linux/fs.h"
1604struct address_space_operations {
1605 int (*writepage)(struct page *page , struct writeback_control *wbc ) ;
1606 int (*readpage)(struct file * , struct page * ) ;
1607 int (*writepages)(struct address_space * , struct writeback_control * ) ;
1608 int (*set_page_dirty)(struct page *page ) ;
1609 int (*readpages)(struct file *filp , struct address_space *mapping , struct list_head *pages ,
1610 unsigned int nr_pages ) ;
1611 int (*write_begin)(struct file * , struct address_space *mapping , loff_t pos ,
1612 unsigned int len , unsigned int flags , struct page **pagep ,
1613 void **fsdata ) ;
1614 int (*write_end)(struct file * , struct address_space *mapping , loff_t pos , unsigned int len ,
1615 unsigned int copied , struct page *page , void *fsdata ) ;
1616 sector_t (*bmap)(struct address_space * , sector_t ) ;
1617 void (*invalidatepage)(struct page * , unsigned long ) ;
1618 int (*releasepage)(struct page * , gfp_t ) ;
1619 void (*freepage)(struct page * ) ;
1620 ssize_t (*direct_IO)(int , struct kiocb * , struct iovec const *iov , loff_t offset ,
1621 unsigned long nr_segs ) ;
1622 int (*get_xip_mem)(struct address_space * , unsigned long , int , void ** , unsigned long * ) ;
1623 int (*migratepage)(struct address_space * , struct page * , struct page * , enum migrate_mode ) ;
1624 int (*launder_page)(struct page * ) ;
1625 int (*is_partially_uptodate)(struct page * , read_descriptor_t * , unsigned long ) ;
1626 int (*error_remove_page)(struct address_space * , struct page * ) ;
1627};
1628#line 645
1629struct backing_dev_info;
1630#line 646 "include/linux/fs.h"
1631struct address_space {
1632 struct inode *host ;
1633 struct radix_tree_root page_tree ;
1634 spinlock_t tree_lock ;
1635 unsigned int i_mmap_writable ;
1636 struct prio_tree_root i_mmap ;
1637 struct list_head i_mmap_nonlinear ;
1638 struct mutex i_mmap_mutex ;
1639 unsigned long nrpages ;
1640 unsigned long writeback_index ;
1641 struct address_space_operations const *a_ops ;
1642 unsigned long flags ;
1643 struct backing_dev_info *backing_dev_info ;
1644 spinlock_t private_lock ;
1645 struct list_head private_list ;
1646 struct address_space *assoc_mapping ;
1647} __attribute__((__aligned__(sizeof(long )))) ;
1648#line 669
1649struct request_queue;
1650#line 669
1651struct request_queue;
1652#line 671
1653struct hd_struct;
1654#line 671
1655struct gendisk;
1656#line 671 "include/linux/fs.h"
1657struct block_device {
1658 dev_t bd_dev ;
1659 int bd_openers ;
1660 struct inode *bd_inode ;
1661 struct super_block *bd_super ;
1662 struct mutex bd_mutex ;
1663 struct list_head bd_inodes ;
1664 void *bd_claiming ;
1665 void *bd_holder ;
1666 int bd_holders ;
1667 bool bd_write_holder ;
1668 struct list_head bd_holder_disks ;
1669 struct block_device *bd_contains ;
1670 unsigned int bd_block_size ;
1671 struct hd_struct *bd_part ;
1672 unsigned int bd_part_count ;
1673 int bd_invalidated ;
1674 struct gendisk *bd_disk ;
1675 struct request_queue *bd_queue ;
1676 struct list_head bd_list ;
1677 unsigned long bd_private ;
1678 int bd_fsfreeze_count ;
1679 struct mutex bd_fsfreeze_mutex ;
1680};
1681#line 749
1682struct posix_acl;
1683#line 749
1684struct posix_acl;
1685#line 761
1686struct inode_operations;
1687#line 761 "include/linux/fs.h"
1688union __anonunion____missing_field_name_218 {
1689 unsigned int const i_nlink ;
1690 unsigned int __i_nlink ;
1691};
1692#line 761 "include/linux/fs.h"
1693union __anonunion____missing_field_name_219 {
1694 struct list_head i_dentry ;
1695 struct rcu_head i_rcu ;
1696};
1697#line 761
1698struct file_lock;
1699#line 761 "include/linux/fs.h"
1700union __anonunion____missing_field_name_220 {
1701 struct pipe_inode_info *i_pipe ;
1702 struct block_device *i_bdev ;
1703 struct cdev *i_cdev ;
1704};
1705#line 761 "include/linux/fs.h"
1706struct inode {
1707 umode_t i_mode ;
1708 unsigned short i_opflags ;
1709 uid_t i_uid ;
1710 gid_t i_gid ;
1711 unsigned int i_flags ;
1712 struct posix_acl *i_acl ;
1713 struct posix_acl *i_default_acl ;
1714 struct inode_operations const *i_op ;
1715 struct super_block *i_sb ;
1716 struct address_space *i_mapping ;
1717 void *i_security ;
1718 unsigned long i_ino ;
1719 union __anonunion____missing_field_name_218 __annonCompField33 ;
1720 dev_t i_rdev ;
1721 struct timespec i_atime ;
1722 struct timespec i_mtime ;
1723 struct timespec i_ctime ;
1724 spinlock_t i_lock ;
1725 unsigned short i_bytes ;
1726 blkcnt_t i_blocks ;
1727 loff_t i_size ;
1728 unsigned long i_state ;
1729 struct mutex i_mutex ;
1730 unsigned long dirtied_when ;
1731 struct hlist_node i_hash ;
1732 struct list_head i_wb_list ;
1733 struct list_head i_lru ;
1734 struct list_head i_sb_list ;
1735 union __anonunion____missing_field_name_219 __annonCompField34 ;
1736 atomic_t i_count ;
1737 unsigned int i_blkbits ;
1738 u64 i_version ;
1739 atomic_t i_dio_count ;
1740 atomic_t i_writecount ;
1741 struct file_operations const *i_fop ;
1742 struct file_lock *i_flock ;
1743 struct address_space i_data ;
1744 struct dquot *i_dquot[2] ;
1745 struct list_head i_devices ;
1746 union __anonunion____missing_field_name_220 __annonCompField35 ;
1747 __u32 i_generation ;
1748 __u32 i_fsnotify_mask ;
1749 struct hlist_head i_fsnotify_marks ;
1750 atomic_t i_readcount ;
1751 void *i_private ;
1752};
1753#line 942 "include/linux/fs.h"
1754struct fown_struct {
1755 rwlock_t lock ;
1756 struct pid *pid ;
1757 enum pid_type pid_type ;
1758 uid_t uid ;
1759 uid_t euid ;
1760 int signum ;
1761};
1762#line 953 "include/linux/fs.h"
1763struct file_ra_state {
1764 unsigned long start ;
1765 unsigned int size ;
1766 unsigned int async_size ;
1767 unsigned int ra_pages ;
1768 unsigned int mmap_miss ;
1769 loff_t prev_pos ;
1770};
1771#line 976 "include/linux/fs.h"
1772union __anonunion_f_u_221 {
1773 struct list_head fu_list ;
1774 struct rcu_head fu_rcuhead ;
1775};
1776#line 976 "include/linux/fs.h"
1777struct file {
1778 union __anonunion_f_u_221 f_u ;
1779 struct path f_path ;
1780 struct file_operations const *f_op ;
1781 spinlock_t f_lock ;
1782 int f_sb_list_cpu ;
1783 atomic_long_t f_count ;
1784 unsigned int f_flags ;
1785 fmode_t f_mode ;
1786 loff_t f_pos ;
1787 struct fown_struct f_owner ;
1788 struct cred const *f_cred ;
1789 struct file_ra_state f_ra ;
1790 u64 f_version ;
1791 void *f_security ;
1792 void *private_data ;
1793 struct list_head f_ep_links ;
1794 struct list_head f_tfile_llink ;
1795 struct address_space *f_mapping ;
1796 unsigned long f_mnt_write_state ;
1797};
1798#line 1111
1799struct files_struct;
1800#line 1111 "include/linux/fs.h"
1801typedef struct files_struct *fl_owner_t;
1802#line 1113 "include/linux/fs.h"
1803struct file_lock_operations {
1804 void (*fl_copy_lock)(struct file_lock * , struct file_lock * ) ;
1805 void (*fl_release_private)(struct file_lock * ) ;
1806};
1807#line 1118 "include/linux/fs.h"
1808struct lock_manager_operations {
1809 int (*lm_compare_owner)(struct file_lock * , struct file_lock * ) ;
1810 void (*lm_notify)(struct file_lock * ) ;
1811 int (*lm_grant)(struct file_lock * , struct file_lock * , int ) ;
1812 void (*lm_release_private)(struct file_lock * ) ;
1813 void (*lm_break)(struct file_lock * ) ;
1814 int (*lm_change)(struct file_lock ** , int ) ;
1815};
1816#line 4 "include/linux/nfs_fs_i.h"
1817struct nlm_lockowner;
1818#line 4
1819struct nlm_lockowner;
1820#line 9 "include/linux/nfs_fs_i.h"
1821struct nfs_lock_info {
1822 u32 state ;
1823 struct nlm_lockowner *owner ;
1824 struct list_head list ;
1825};
1826#line 15
1827struct nfs4_lock_state;
1828#line 15
1829struct nfs4_lock_state;
1830#line 16 "include/linux/nfs_fs_i.h"
1831struct nfs4_lock_info {
1832 struct nfs4_lock_state *owner ;
1833};
1834#line 1138 "include/linux/fs.h"
1835struct fasync_struct;
1836#line 1138 "include/linux/fs.h"
1837struct __anonstruct_afs_223 {
1838 struct list_head link ;
1839 int state ;
1840};
1841#line 1138 "include/linux/fs.h"
1842union __anonunion_fl_u_222 {
1843 struct nfs_lock_info nfs_fl ;
1844 struct nfs4_lock_info nfs4_fl ;
1845 struct __anonstruct_afs_223 afs ;
1846};
1847#line 1138 "include/linux/fs.h"
1848struct file_lock {
1849 struct file_lock *fl_next ;
1850 struct list_head fl_link ;
1851 struct list_head fl_block ;
1852 fl_owner_t fl_owner ;
1853 unsigned int fl_flags ;
1854 unsigned char fl_type ;
1855 unsigned int fl_pid ;
1856 struct pid *fl_nspid ;
1857 wait_queue_head_t fl_wait ;
1858 struct file *fl_file ;
1859 loff_t fl_start ;
1860 loff_t fl_end ;
1861 struct fasync_struct *fl_fasync ;
1862 unsigned long fl_break_time ;
1863 unsigned long fl_downgrade_time ;
1864 struct file_lock_operations const *fl_ops ;
1865 struct lock_manager_operations const *fl_lmops ;
1866 union __anonunion_fl_u_222 fl_u ;
1867};
1868#line 1378 "include/linux/fs.h"
1869struct fasync_struct {
1870 spinlock_t fa_lock ;
1871 int magic ;
1872 int fa_fd ;
1873 struct fasync_struct *fa_next ;
1874 struct file *fa_file ;
1875 struct rcu_head fa_rcu ;
1876};
1877#line 1418
1878struct file_system_type;
1879#line 1418
1880struct super_operations;
1881#line 1418
1882struct xattr_handler;
1883#line 1418
1884struct mtd_info;
1885#line 1418 "include/linux/fs.h"
1886struct super_block {
1887 struct list_head s_list ;
1888 dev_t s_dev ;
1889 unsigned char s_dirt ;
1890 unsigned char s_blocksize_bits ;
1891 unsigned long s_blocksize ;
1892 loff_t s_maxbytes ;
1893 struct file_system_type *s_type ;
1894 struct super_operations const *s_op ;
1895 struct dquot_operations const *dq_op ;
1896 struct quotactl_ops const *s_qcop ;
1897 struct export_operations const *s_export_op ;
1898 unsigned long s_flags ;
1899 unsigned long s_magic ;
1900 struct dentry *s_root ;
1901 struct rw_semaphore s_umount ;
1902 struct mutex s_lock ;
1903 int s_count ;
1904 atomic_t s_active ;
1905 void *s_security ;
1906 struct xattr_handler const **s_xattr ;
1907 struct list_head s_inodes ;
1908 struct hlist_bl_head s_anon ;
1909 struct list_head *s_files ;
1910 struct list_head s_mounts ;
1911 struct list_head s_dentry_lru ;
1912 int s_nr_dentry_unused ;
1913 spinlock_t s_inode_lru_lock __attribute__((__aligned__((1) << (6) ))) ;
1914 struct list_head s_inode_lru ;
1915 int s_nr_inodes_unused ;
1916 struct block_device *s_bdev ;
1917 struct backing_dev_info *s_bdi ;
1918 struct mtd_info *s_mtd ;
1919 struct hlist_node s_instances ;
1920 struct quota_info s_dquot ;
1921 int s_frozen ;
1922 wait_queue_head_t s_wait_unfrozen ;
1923 char s_id[32] ;
1924 u8 s_uuid[16] ;
1925 void *s_fs_info ;
1926 unsigned int s_max_links ;
1927 fmode_t s_mode ;
1928 u32 s_time_gran ;
1929 struct mutex s_vfs_rename_mutex ;
1930 char *s_subtype ;
1931 char *s_options ;
1932 struct dentry_operations const *s_d_op ;
1933 int cleancache_poolid ;
1934 struct shrinker s_shrink ;
1935 atomic_long_t s_remove_count ;
1936 int s_readonly_remount ;
1937};
1938#line 1567 "include/linux/fs.h"
1939struct fiemap_extent_info {
1940 unsigned int fi_flags ;
1941 unsigned int fi_extents_mapped ;
1942 unsigned int fi_extents_max ;
1943 struct fiemap_extent *fi_extents_start ;
1944};
1945#line 1609 "include/linux/fs.h"
1946struct file_operations {
1947 struct module *owner ;
1948 loff_t (*llseek)(struct file * , loff_t , int ) ;
1949 ssize_t (*read)(struct file * , char * , size_t , loff_t * ) ;
1950 ssize_t (*write)(struct file * , char const * , size_t , loff_t * ) ;
1951 ssize_t (*aio_read)(struct kiocb * , struct iovec const * , unsigned long ,
1952 loff_t ) ;
1953 ssize_t (*aio_write)(struct kiocb * , struct iovec const * , unsigned long ,
1954 loff_t ) ;
1955 int (*readdir)(struct file * , void * , int (*)(void * , char const * , int ,
1956 loff_t , u64 , unsigned int ) ) ;
1957 unsigned int (*poll)(struct file * , struct poll_table_struct * ) ;
1958 long (*unlocked_ioctl)(struct file * , unsigned int , unsigned long ) ;
1959 long (*compat_ioctl)(struct file * , unsigned int , unsigned long ) ;
1960 int (*mmap)(struct file * , struct vm_area_struct * ) ;
1961 int (*open)(struct inode * , struct file * ) ;
1962 int (*flush)(struct file * , fl_owner_t id ) ;
1963 int (*release)(struct inode * , struct file * ) ;
1964 int (*fsync)(struct file * , loff_t , loff_t , int datasync ) ;
1965 int (*aio_fsync)(struct kiocb * , int datasync ) ;
1966 int (*fasync)(int , struct file * , int ) ;
1967 int (*lock)(struct file * , int , struct file_lock * ) ;
1968 ssize_t (*sendpage)(struct file * , struct page * , int , size_t , loff_t * ,
1969 int ) ;
1970 unsigned long (*get_unmapped_area)(struct file * , unsigned long , unsigned long ,
1971 unsigned long , unsigned long ) ;
1972 int (*check_flags)(int ) ;
1973 int (*flock)(struct file * , int , struct file_lock * ) ;
1974 ssize_t (*splice_write)(struct pipe_inode_info * , struct file * , loff_t * , size_t ,
1975 unsigned int ) ;
1976 ssize_t (*splice_read)(struct file * , loff_t * , struct pipe_inode_info * , size_t ,
1977 unsigned int ) ;
1978 int (*setlease)(struct file * , long , struct file_lock ** ) ;
1979 long (*fallocate)(struct file *file , int mode , loff_t offset , loff_t len ) ;
1980};
1981#line 1639 "include/linux/fs.h"
1982struct inode_operations {
1983 struct dentry *(*lookup)(struct inode * , struct dentry * , struct nameidata * ) ;
1984 void *(*follow_link)(struct dentry * , struct nameidata * ) ;
1985 int (*permission)(struct inode * , int ) ;
1986 struct posix_acl *(*get_acl)(struct inode * , int ) ;
1987 int (*readlink)(struct dentry * , char * , int ) ;
1988 void (*put_link)(struct dentry * , struct nameidata * , void * ) ;
1989 int (*create)(struct inode * , struct dentry * , umode_t , struct nameidata * ) ;
1990 int (*link)(struct dentry * , struct inode * , struct dentry * ) ;
1991 int (*unlink)(struct inode * , struct dentry * ) ;
1992 int (*symlink)(struct inode * , struct dentry * , char const * ) ;
1993 int (*mkdir)(struct inode * , struct dentry * , umode_t ) ;
1994 int (*rmdir)(struct inode * , struct dentry * ) ;
1995 int (*mknod)(struct inode * , struct dentry * , umode_t , dev_t ) ;
1996 int (*rename)(struct inode * , struct dentry * , struct inode * , struct dentry * ) ;
1997 void (*truncate)(struct inode * ) ;
1998 int (*setattr)(struct dentry * , struct iattr * ) ;
1999 int (*getattr)(struct vfsmount *mnt , struct dentry * , struct kstat * ) ;
2000 int (*setxattr)(struct dentry * , char const * , void const * , size_t , int ) ;
2001 ssize_t (*getxattr)(struct dentry * , char const * , void * , size_t ) ;
2002 ssize_t (*listxattr)(struct dentry * , char * , size_t ) ;
2003 int (*removexattr)(struct dentry * , char const * ) ;
2004 void (*truncate_range)(struct inode * , loff_t , loff_t ) ;
2005 int (*fiemap)(struct inode * , struct fiemap_extent_info * , u64 start , u64 len ) ;
2006} __attribute__((__aligned__((1) << (6) ))) ;
2007#line 1669
2008struct seq_file;
2009#line 1684 "include/linux/fs.h"
2010struct super_operations {
2011 struct inode *(*alloc_inode)(struct super_block *sb ) ;
2012 void (*destroy_inode)(struct inode * ) ;
2013 void (*dirty_inode)(struct inode * , int flags ) ;
2014 int (*write_inode)(struct inode * , struct writeback_control *wbc ) ;
2015 int (*drop_inode)(struct inode * ) ;
2016 void (*evict_inode)(struct inode * ) ;
2017 void (*put_super)(struct super_block * ) ;
2018 void (*write_super)(struct super_block * ) ;
2019 int (*sync_fs)(struct super_block *sb , int wait ) ;
2020 int (*freeze_fs)(struct super_block * ) ;
2021 int (*unfreeze_fs)(struct super_block * ) ;
2022 int (*statfs)(struct dentry * , struct kstatfs * ) ;
2023 int (*remount_fs)(struct super_block * , int * , char * ) ;
2024 void (*umount_begin)(struct super_block * ) ;
2025 int (*show_options)(struct seq_file * , struct dentry * ) ;
2026 int (*show_devname)(struct seq_file * , struct dentry * ) ;
2027 int (*show_path)(struct seq_file * , struct dentry * ) ;
2028 int (*show_stats)(struct seq_file * , struct dentry * ) ;
2029 ssize_t (*quota_read)(struct super_block * , int , char * , size_t , loff_t ) ;
2030 ssize_t (*quota_write)(struct super_block * , int , char const * , size_t ,
2031 loff_t ) ;
2032 int (*bdev_try_to_free_page)(struct super_block * , struct page * , gfp_t ) ;
2033 int (*nr_cached_objects)(struct super_block * ) ;
2034 void (*free_cached_objects)(struct super_block * , int ) ;
2035};
2036#line 1835 "include/linux/fs.h"
2037struct file_system_type {
2038 char const *name ;
2039 int fs_flags ;
2040 struct dentry *(*mount)(struct file_system_type * , int , char const * , void * ) ;
2041 void (*kill_sb)(struct super_block * ) ;
2042 struct module *owner ;
2043 struct file_system_type *next ;
2044 struct hlist_head fs_supers ;
2045 struct lock_class_key s_lock_key ;
2046 struct lock_class_key s_umount_key ;
2047 struct lock_class_key s_vfs_rename_key ;
2048 struct lock_class_key i_lock_key ;
2049 struct lock_class_key i_mutex_key ;
2050 struct lock_class_key i_mutex_dir_key ;
2051};
2052#line 28 "include/linux/poll.h"
2053struct poll_table_struct;
2054#line 39 "include/linux/poll.h"
2055struct poll_table_struct {
2056 void (*_qproc)(struct file * , wait_queue_head_t * , struct poll_table_struct * ) ;
2057 unsigned long _key ;
2058};
2059#line 143 "include/linux/rtc.h"
2060struct rtc_class_ops {
2061 int (*open)(struct device * ) ;
2062 void (*release)(struct device * ) ;
2063 int (*ioctl)(struct device * , unsigned int , unsigned long ) ;
2064 int (*read_time)(struct device * , struct rtc_time * ) ;
2065 int (*set_time)(struct device * , struct rtc_time * ) ;
2066 int (*read_alarm)(struct device * , struct rtc_wkalrm * ) ;
2067 int (*set_alarm)(struct device * , struct rtc_wkalrm * ) ;
2068 int (*proc)(struct device * , struct seq_file * ) ;
2069 int (*set_mmss)(struct device * , unsigned long secs ) ;
2070 int (*read_callback)(struct device * , int data ) ;
2071 int (*alarm_irq_enable)(struct device * , unsigned int enabled ) ;
2072};
2073#line 158 "include/linux/rtc.h"
2074struct rtc_task {
2075 void (*func)(void *private_data ) ;
2076 void *private_data ;
2077};
2078#line 164 "include/linux/rtc.h"
2079struct rtc_timer {
2080 struct rtc_task task ;
2081 struct timerqueue_node node ;
2082 ktime_t period ;
2083 int enabled ;
2084};
2085#line 175 "include/linux/rtc.h"
2086struct rtc_device {
2087 struct device dev ;
2088 struct module *owner ;
2089 int id ;
2090 char name[20] ;
2091 struct rtc_class_ops const *ops ;
2092 struct mutex ops_lock ;
2093 struct cdev char_dev ;
2094 unsigned long flags ;
2095 unsigned long irq_data ;
2096 spinlock_t irq_lock ;
2097 wait_queue_head_t irq_queue ;
2098 struct fasync_struct *async_queue ;
2099 struct rtc_task *irq_task ;
2100 spinlock_t irq_task_lock ;
2101 int irq_freq ;
2102 int max_user_freq ;
2103 struct timerqueue_head timerqueue ;
2104 struct rtc_timer aie_timer ;
2105 struct rtc_timer uie_rtctimer ;
2106 struct hrtimer pie_timer ;
2107 int pie_enabled ;
2108 struct work_struct irqwork ;
2109 int uie_unsupported ;
2110 struct work_struct uie_task ;
2111 struct timer_list uie_timer ;
2112 unsigned int oldsecs ;
2113 unsigned int uie_irq_active : 1 ;
2114 unsigned int stop_uie_polling : 1 ;
2115 unsigned int uie_task_active : 1 ;
2116 unsigned int uie_timer_active : 1 ;
2117};
2118#line 18 "include/linux/regmap.h"
2119struct module;
2120#line 19
2121struct device;
2122#line 22
2123struct regmap;
2124#line 22
2125struct regmap;
2126#line 355 "include/linux/mfd/wm831x/core.h"
2127struct wm831x;
2128#line 355
2129struct wm831x;
2130#line 356
2131enum wm831x_auxadc;
2132#line 356
2133enum wm831x_auxadc;
2134#line 361 "include/linux/mfd/wm831x/core.h"
2135struct wm831x {
2136 struct mutex io_lock ;
2137 struct device *dev ;
2138 struct regmap *regmap ;
2139 int irq ;
2140 struct mutex irq_lock ;
2141 int irq_base ;
2142 int irq_masks_cur[5] ;
2143 int irq_masks_cache[5] ;
2144 bool soft_shutdown ;
2145 unsigned int has_gpio_ena : 1 ;
2146 unsigned int has_cs_sts : 1 ;
2147 unsigned int charger_irq_wake : 1 ;
2148 int num_gpio ;
2149 int gpio_update[16] ;
2150 bool gpio_level[16] ;
2151 struct mutex auxadc_lock ;
2152 struct list_head auxadc_pending ;
2153 u16 auxadc_active ;
2154 int (*auxadc_read)(struct wm831x *wm831x , enum wm831x_auxadc input ) ;
2155 struct mutex key_lock ;
2156 unsigned int locked : 1 ;
2157};
2158#line 12 "include/linux/mod_devicetable.h"
2159typedef unsigned long kernel_ulong_t;
2160#line 219 "include/linux/mod_devicetable.h"
2161struct of_device_id {
2162 char name[32] ;
2163 char type[32] ;
2164 char compatible[128] ;
2165 void *data ;
2166};
2167#line 506 "include/linux/mod_devicetable.h"
2168struct platform_device_id {
2169 char name[20] ;
2170 kernel_ulong_t driver_data __attribute__((__aligned__(sizeof(kernel_ulong_t )))) ;
2171};
2172#line 17 "include/linux/platform_device.h"
2173struct mfd_cell;
2174#line 17
2175struct mfd_cell;
2176#line 19 "include/linux/platform_device.h"
2177struct platform_device {
2178 char const *name ;
2179 int id ;
2180 struct device dev ;
2181 u32 num_resources ;
2182 struct resource *resource ;
2183 struct platform_device_id const *id_entry ;
2184 struct mfd_cell *mfd_cell ;
2185 struct pdev_archdata archdata ;
2186};
2187#line 164 "include/linux/platform_device.h"
2188struct platform_driver {
2189 int (*probe)(struct platform_device * ) ;
2190 int (*remove)(struct platform_device * ) ;
2191 void (*shutdown)(struct platform_device * ) ;
2192 int (*suspend)(struct platform_device * , pm_message_t state ) ;
2193 int (*resume)(struct platform_device * ) ;
2194 struct device_driver driver ;
2195 struct platform_device_id const *id_table ;
2196};
2197#line 94 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
2198struct wm831x_rtc {
2199 struct wm831x *wm831x ;
2200 struct rtc_device *rtc ;
2201 unsigned int alarm_enabled : 1 ;
2202};
2203#line 1 "<compiler builtins>"
2204long __builtin_expect(long val , long res ) ;
2205#line 49 "include/linux/dynamic_debug.h"
2206extern int ( __dynamic_dev_dbg)(struct _ddebug *descriptor ,
2207 struct device const *dev ,
2208 char const *fmt , ...) ;
2209#line 60 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/string_64.h"
2210extern int memcmp(void const *cs , void const *ct , unsigned long count ) ;
2211#line 27 "include/linux/err.h"
2212__inline static long __attribute__((__warn_unused_result__)) PTR_ERR(void const *ptr ) __attribute__((__no_instrument_function__)) ;
2213#line 27 "include/linux/err.h"
2214__inline static long __attribute__((__warn_unused_result__)) PTR_ERR(void const *ptr )
2215{
2216
2217 {
2218#line 29
2219 return ((long )ptr);
2220}
2221}
2222#line 32
2223__inline static long __attribute__((__warn_unused_result__)) IS_ERR(void const *ptr ) __attribute__((__no_instrument_function__)) ;
2224#line 32 "include/linux/err.h"
2225__inline static long __attribute__((__warn_unused_result__)) IS_ERR(void const *ptr )
2226{ long tmp ;
2227 unsigned long __cil_tmp3 ;
2228 int __cil_tmp4 ;
2229 int __cil_tmp5 ;
2230 int __cil_tmp6 ;
2231 long __cil_tmp7 ;
2232
2233 {
2234 {
2235#line 34
2236 __cil_tmp3 = (unsigned long )ptr;
2237#line 34
2238 __cil_tmp4 = __cil_tmp3 >= 0xfffffffffffff001UL;
2239#line 34
2240 __cil_tmp5 = ! __cil_tmp4;
2241#line 34
2242 __cil_tmp6 = ! __cil_tmp5;
2243#line 34
2244 __cil_tmp7 = (long )__cil_tmp6;
2245#line 34
2246 tmp = __builtin_expect(__cil_tmp7, 0L);
2247 }
2248#line 34
2249 return (tmp);
2250}
2251}
2252#line 152 "include/linux/mutex.h"
2253void mutex_lock(struct mutex *lock ) ;
2254#line 153
2255int __attribute__((__warn_unused_result__)) mutex_lock_interruptible(struct mutex *lock ) ;
2256#line 154
2257int __attribute__((__warn_unused_result__)) mutex_lock_killable(struct mutex *lock ) ;
2258#line 168
2259int mutex_trylock(struct mutex *lock ) ;
2260#line 169
2261void mutex_unlock(struct mutex *lock ) ;
2262#line 170
2263int atomic_dec_and_mutex_lock(atomic_t *cnt , struct mutex *lock ) ;
2264#line 26 "include/linux/export.h"
2265extern struct module __this_module ;
2266#line 67 "include/linux/module.h"
2267int init_module(void) ;
2268#line 68
2269void cleanup_module(void) ;
2270#line 126 "include/linux/interrupt.h"
2271extern int __attribute__((__warn_unused_result__)) request_threaded_irq(unsigned int irq ,
2272 irqreturn_t (*handler)(int ,
2273 void * ) ,
2274 irqreturn_t (*thread_fn)(int ,
2275 void * ) ,
2276 unsigned long flags ,
2277 char const *name ,
2278 void *dev ) ;
2279#line 184
2280extern void free_irq(unsigned int , void * ) ;
2281#line 110 "include/linux/rtc.h"
2282extern int rtc_valid_tm(struct rtc_time *tm ) ;
2283#line 111
2284extern int rtc_tm_to_time(struct rtc_time *tm , unsigned long *time ) ;
2285#line 112
2286extern void rtc_time_to_tm(unsigned long time , struct rtc_time *tm ) ;
2287#line 553 "include/linux/device.h"
2288extern void *devm_kzalloc(struct device *dev , size_t size , gfp_t gfp ) ;
2289#line 70 "include/linux/pm_wakeup.h"
2290__inline static bool device_may_wakeup(struct device *dev ) __attribute__((__no_instrument_function__)) ;
2291#line 70 "include/linux/pm_wakeup.h"
2292__inline static bool device_may_wakeup(struct device *dev )
2293{ int tmp ;
2294 unsigned long __cil_tmp3 ;
2295 unsigned long __cil_tmp4 ;
2296 unsigned long __cil_tmp5 ;
2297 unsigned long __cil_tmp6 ;
2298 unsigned long __cil_tmp7 ;
2299 unsigned long __cil_tmp8 ;
2300 struct wakeup_source *__cil_tmp9 ;
2301 int __cil_tmp10 ;
2302
2303 {
2304 {
2305#line 72
2306 __cil_tmp3 = 192 + 4;
2307#line 72
2308 __cil_tmp4 = (unsigned long )dev;
2309#line 72
2310 __cil_tmp5 = __cil_tmp4 + __cil_tmp3;
2311#line 72
2312 if (*((unsigned int *)__cil_tmp5)) {
2313 {
2314#line 72
2315 __cil_tmp6 = 192 + 96;
2316#line 72
2317 __cil_tmp7 = (unsigned long )dev;
2318#line 72
2319 __cil_tmp8 = __cil_tmp7 + __cil_tmp6;
2320#line 72
2321 __cil_tmp9 = *((struct wakeup_source **)__cil_tmp8);
2322#line 72
2323 __cil_tmp10 = ! __cil_tmp9;
2324#line 72
2325 if (! __cil_tmp10) {
2326#line 72
2327 tmp = 1;
2328 } else {
2329#line 72
2330 tmp = 0;
2331 }
2332 }
2333 } else {
2334#line 72
2335 tmp = 0;
2336 }
2337 }
2338#line 72
2339 return ((bool )tmp);
2340}
2341}
2342#line 87
2343extern int device_init_wakeup(struct device *dev , bool val ) ;
2344#line 792 "include/linux/device.h"
2345extern void *dev_get_drvdata(struct device const *dev ) ;
2346#line 793
2347extern int dev_set_drvdata(struct device *dev , void *data ) ;
2348#line 891
2349extern int ( dev_err)(struct device const *dev , char const *fmt
2350 , ...) ;
2351#line 221 "include/linux/rtc.h"
2352extern struct rtc_device *rtc_device_register(char const *name , struct device *dev ,
2353 struct rtc_class_ops const *ops ,
2354 struct module *owner ) ;
2355#line 225
2356extern void rtc_device_unregister(struct rtc_device *rtc ) ;
2357#line 237
2358extern void rtc_update_irq(struct rtc_device *rtc , unsigned long num , unsigned long events ) ;
2359#line 402 "include/linux/mfd/wm831x/core.h"
2360extern int wm831x_reg_read(struct wm831x *wm831x , unsigned short reg ) ;
2361#line 403
2362extern int wm831x_reg_write(struct wm831x *wm831x , unsigned short reg , unsigned short val ) ;
2363#line 407
2364extern int wm831x_set_bits(struct wm831x *wm831x , unsigned short reg , unsigned short mask ,
2365 unsigned short val ) ;
2366#line 409
2367extern int wm831x_bulk_read(struct wm831x *wm831x , unsigned short reg , int count ,
2368 u16 *buf ) ;
2369#line 46 "include/linux/delay.h"
2370extern void msleep(unsigned int msecs ) ;
2371#line 49 "include/linux/platform_device.h"
2372extern int platform_get_irq_byname(struct platform_device * , char const * ) ;
2373#line 174
2374extern int platform_driver_register(struct platform_driver * ) ;
2375#line 175
2376extern void platform_driver_unregister(struct platform_driver * ) ;
2377#line 183
2378__inline static void *platform_get_drvdata(struct platform_device const *pdev ) __attribute__((__no_instrument_function__)) ;
2379#line 183 "include/linux/platform_device.h"
2380__inline static void *platform_get_drvdata(struct platform_device const *pdev )
2381{ void *tmp ;
2382 unsigned long __cil_tmp3 ;
2383 unsigned long __cil_tmp4 ;
2384 struct device const *__cil_tmp5 ;
2385
2386 {
2387 {
2388#line 185
2389 __cil_tmp3 = (unsigned long )pdev;
2390#line 185
2391 __cil_tmp4 = __cil_tmp3 + 16;
2392#line 185
2393 __cil_tmp5 = (struct device const *)__cil_tmp4;
2394#line 185
2395 tmp = dev_get_drvdata(__cil_tmp5);
2396 }
2397#line 185
2398 return (tmp);
2399}
2400}
2401#line 188
2402__inline static void platform_set_drvdata(struct platform_device *pdev , void *data ) __attribute__((__no_instrument_function__)) ;
2403#line 188 "include/linux/platform_device.h"
2404__inline static void platform_set_drvdata(struct platform_device *pdev , void *data )
2405{ unsigned long __cil_tmp3 ;
2406 unsigned long __cil_tmp4 ;
2407 struct device *__cil_tmp5 ;
2408
2409 {
2410 {
2411#line 190
2412 __cil_tmp3 = (unsigned long )pdev;
2413#line 190
2414 __cil_tmp4 = __cil_tmp3 + 16;
2415#line 190
2416 __cil_tmp5 = (struct device *)__cil_tmp4;
2417#line 190
2418 dev_set_drvdata(__cil_tmp5, data);
2419 }
2420#line 191
2421 return;
2422}
2423}
2424#line 118 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
2425static int wm831x_rtc_readtime(struct device *dev , struct rtc_time *tm ) ;
2426#line 118 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
2427static struct _ddebug __attribute__((__aligned__(8))) descriptor __attribute__((__used__,
2428__section__("__verbose"))) = {"rtc_wm831x", "wm831x_rtc_readtime", "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c",
2429 "RTC not yet configured\n", 118U, 1U};
2430#line 103 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
2431static int wm831x_rtc_readtime(struct device *dev , struct rtc_time *tm )
2432{ struct wm831x_rtc *wm831x_rtc ;
2433 void *tmp ;
2434 struct wm831x *wm831x ;
2435 u16 time1[2] ;
2436 u16 time2[2] ;
2437 int ret ;
2438 int count ;
2439 long tmp___0 ;
2440 u32 time ;
2441 int tmp___1 ;
2442 int tmp___2 ;
2443 struct device const *__cil_tmp14 ;
2444 struct device const *__cil_tmp15 ;
2445 int __cil_tmp16 ;
2446 struct _ddebug __attribute__((__aligned__(8))) *__cil_tmp17 ;
2447 unsigned int __cil_tmp18 ;
2448 unsigned int __cil_tmp19 ;
2449 int __cil_tmp20 ;
2450 int __cil_tmp21 ;
2451 long __cil_tmp22 ;
2452 struct device const *__cil_tmp23 ;
2453 unsigned long __cil_tmp24 ;
2454 unsigned long __cil_tmp25 ;
2455 u16 *__cil_tmp26 ;
2456 unsigned long __cil_tmp27 ;
2457 unsigned long __cil_tmp28 ;
2458 u16 *__cil_tmp29 ;
2459 unsigned long __cil_tmp30 ;
2460 unsigned long __cil_tmp31 ;
2461 u16 *__cil_tmp32 ;
2462 void const *__cil_tmp33 ;
2463 unsigned long __cil_tmp34 ;
2464 unsigned long __cil_tmp35 ;
2465 u16 *__cil_tmp36 ;
2466 void const *__cil_tmp37 ;
2467 unsigned long __cil_tmp38 ;
2468 unsigned long __cil_tmp39 ;
2469 u16 __cil_tmp40 ;
2470 int __cil_tmp41 ;
2471 unsigned long __cil_tmp42 ;
2472 unsigned long __cil_tmp43 ;
2473 u16 __cil_tmp44 ;
2474 int __cil_tmp45 ;
2475 int __cil_tmp46 ;
2476 int __cil_tmp47 ;
2477 unsigned long __cil_tmp48 ;
2478 struct device const *__cil_tmp49 ;
2479
2480 {
2481 {
2482#line 105
2483 __cil_tmp14 = (struct device const *)dev;
2484#line 105
2485 tmp = dev_get_drvdata(__cil_tmp14);
2486#line 105
2487 wm831x_rtc = (struct wm831x_rtc *)tmp;
2488#line 106
2489 wm831x = *((struct wm831x **)wm831x_rtc);
2490#line 109
2491 count = 0;
2492#line 112
2493 ret = wm831x_reg_read(wm831x, (unsigned short)16421);
2494 }
2495#line 113
2496 if (ret < 0) {
2497 {
2498#line 114
2499 __cil_tmp15 = (struct device const *)dev;
2500#line 114
2501 dev_err(__cil_tmp15, "Failed to read RTC control: %d\n", ret);
2502 }
2503#line 115
2504 return (ret);
2505 } else {
2506
2507 }
2508 {
2509#line 117
2510 __cil_tmp16 = ret & 32768;
2511#line 117
2512 if (! __cil_tmp16) {
2513 {
2514#line 118
2515 while (1) {
2516 while_continue: ;
2517 {
2518#line 118
2519 while (1) {
2520 while_continue___0: ;
2521 {
2522#line 118
2523 __cil_tmp17 = & descriptor;
2524#line 118
2525 __cil_tmp18 = __cil_tmp17->flags;
2526#line 118
2527 __cil_tmp19 = __cil_tmp18 & 1U;
2528#line 118
2529 __cil_tmp20 = ! __cil_tmp19;
2530#line 118
2531 __cil_tmp21 = ! __cil_tmp20;
2532#line 118
2533 __cil_tmp22 = (long )__cil_tmp21;
2534#line 118
2535 tmp___0 = __builtin_expect(__cil_tmp22, 0L);
2536 }
2537#line 118
2538 if (tmp___0) {
2539 {
2540#line 118
2541 __cil_tmp23 = (struct device const *)dev;
2542#line 118
2543 __dynamic_dev_dbg(& descriptor, __cil_tmp23, "RTC not yet configured\n");
2544 }
2545 } else {
2546
2547 }
2548#line 118
2549 goto while_break___0;
2550 }
2551 while_break___0: ;
2552 }
2553#line 118
2554 goto while_break;
2555 }
2556 while_break: ;
2557 }
2558#line 119
2559 return (-22);
2560 } else {
2561
2562 }
2563 }
2564 {
2565#line 125
2566 while (1) {
2567 while_continue___1: ;
2568 {
2569#line 126
2570 __cil_tmp24 = 0 * 2UL;
2571#line 126
2572 __cil_tmp25 = (unsigned long )(time1) + __cil_tmp24;
2573#line 126
2574 __cil_tmp26 = (u16 *)__cil_tmp25;
2575#line 126
2576 ret = wm831x_bulk_read(wm831x, (unsigned short)16417, 2, __cil_tmp26);
2577 }
2578#line 128
2579 if (ret != 0) {
2580#line 129
2581 goto __Cont;
2582 } else {
2583
2584 }
2585 {
2586#line 131
2587 __cil_tmp27 = 0 * 2UL;
2588#line 131
2589 __cil_tmp28 = (unsigned long )(time2) + __cil_tmp27;
2590#line 131
2591 __cil_tmp29 = (u16 *)__cil_tmp28;
2592#line 131
2593 ret = wm831x_bulk_read(wm831x, (unsigned short)16417, 2, __cil_tmp29);
2594 }
2595#line 133
2596 if (ret != 0) {
2597#line 134
2598 goto __Cont;
2599 } else {
2600
2601 }
2602 {
2603#line 136
2604 __cil_tmp30 = 0 * 2UL;
2605#line 136
2606 __cil_tmp31 = (unsigned long )(time1) + __cil_tmp30;
2607#line 136
2608 __cil_tmp32 = (u16 *)__cil_tmp31;
2609#line 136
2610 __cil_tmp33 = (void const *)__cil_tmp32;
2611#line 136
2612 __cil_tmp34 = 0 * 2UL;
2613#line 136
2614 __cil_tmp35 = (unsigned long )(time2) + __cil_tmp34;
2615#line 136
2616 __cil_tmp36 = (u16 *)__cil_tmp35;
2617#line 136
2618 __cil_tmp37 = (void const *)__cil_tmp36;
2619#line 136
2620 tmp___2 = memcmp(__cil_tmp33, __cil_tmp37, 4UL);
2621 }
2622#line 136
2623 if (tmp___2 == 0) {
2624 {
2625#line 137
2626 __cil_tmp38 = 1 * 2UL;
2627#line 137
2628 __cil_tmp39 = (unsigned long )(time1) + __cil_tmp38;
2629#line 137
2630 __cil_tmp40 = *((u16 *)__cil_tmp39);
2631#line 137
2632 __cil_tmp41 = (int )__cil_tmp40;
2633#line 137
2634 __cil_tmp42 = 0 * 2UL;
2635#line 137
2636 __cil_tmp43 = (unsigned long )(time1) + __cil_tmp42;
2637#line 137
2638 __cil_tmp44 = *((u16 *)__cil_tmp43);
2639#line 137
2640 __cil_tmp45 = (int )__cil_tmp44;
2641#line 137
2642 __cil_tmp46 = __cil_tmp45 << 16;
2643#line 137
2644 __cil_tmp47 = __cil_tmp46 | __cil_tmp41;
2645#line 137
2646 time = (u32 )__cil_tmp47;
2647#line 139
2648 __cil_tmp48 = (unsigned long )time;
2649#line 139
2650 rtc_time_to_tm(__cil_tmp48, tm);
2651#line 140
2652 tmp___1 = rtc_valid_tm(tm);
2653 }
2654#line 140
2655 return (tmp___1);
2656 } else {
2657
2658 }
2659 __Cont:
2660#line 125
2661 count = count + 1;
2662#line 125
2663 if (count < 5) {
2664
2665 } else {
2666#line 125
2667 goto while_break___1;
2668 }
2669 }
2670 while_break___1: ;
2671 }
2672 {
2673#line 145
2674 __cil_tmp49 = (struct device const *)dev;
2675#line 145
2676 dev_err(__cil_tmp49, "Timed out reading current time\n");
2677 }
2678#line 147
2679 return (-5);
2680}
2681}
2682#line 153 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
2683static int wm831x_rtc_set_mmss(struct device *dev , unsigned long time )
2684{ struct wm831x_rtc *wm831x_rtc ;
2685 void *tmp ;
2686 struct wm831x *wm831x ;
2687 struct rtc_time new_tm ;
2688 unsigned long new_time ;
2689 int ret ;
2690 int count ;
2691 struct device const *__cil_tmp10 ;
2692 unsigned long __cil_tmp11 ;
2693 unsigned long __cil_tmp12 ;
2694 unsigned short __cil_tmp13 ;
2695 struct device const *__cil_tmp14 ;
2696 unsigned long __cil_tmp15 ;
2697 unsigned short __cil_tmp16 ;
2698 struct device const *__cil_tmp17 ;
2699 int __cil_tmp18 ;
2700 struct device const *__cil_tmp19 ;
2701 struct device const *__cil_tmp20 ;
2702 unsigned long *__cil_tmp21 ;
2703 unsigned long __cil_tmp22 ;
2704 unsigned long __cil_tmp23 ;
2705 struct device const *__cil_tmp24 ;
2706
2707 {
2708 {
2709#line 155
2710 __cil_tmp10 = (struct device const *)dev;
2711#line 155
2712 tmp = dev_get_drvdata(__cil_tmp10);
2713#line 155
2714 wm831x_rtc = (struct wm831x_rtc *)tmp;
2715#line 156
2716 wm831x = *((struct wm831x **)wm831x_rtc);
2717#line 160
2718 count = 0;
2719#line 162
2720 __cil_tmp11 = time >> 16;
2721#line 162
2722 __cil_tmp12 = __cil_tmp11 & 65535UL;
2723#line 162
2724 __cil_tmp13 = (unsigned short )__cil_tmp12;
2725#line 162
2726 ret = wm831x_reg_write(wm831x, (unsigned short)16417, __cil_tmp13);
2727 }
2728#line 164
2729 if (ret < 0) {
2730 {
2731#line 165
2732 __cil_tmp14 = (struct device const *)dev;
2733#line 165
2734 dev_err(__cil_tmp14, "Failed to write TIME_1: %d\n", ret);
2735 }
2736#line 166
2737 return (ret);
2738 } else {
2739
2740 }
2741 {
2742#line 169
2743 __cil_tmp15 = time & 65535UL;
2744#line 169
2745 __cil_tmp16 = (unsigned short )__cil_tmp15;
2746#line 169
2747 ret = wm831x_reg_write(wm831x, (unsigned short)16418, __cil_tmp16);
2748 }
2749#line 170
2750 if (ret < 0) {
2751 {
2752#line 171
2753 __cil_tmp17 = (struct device const *)dev;
2754#line 171
2755 dev_err(__cil_tmp17, "Failed to write TIME_2: %d\n", ret);
2756 }
2757#line 172
2758 return (ret);
2759 } else {
2760
2761 }
2762 {
2763#line 178
2764 while (1) {
2765 while_continue: ;
2766 {
2767#line 179
2768 msleep(1U);
2769#line 181
2770 ret = wm831x_reg_read(wm831x, (unsigned short)16421);
2771 }
2772#line 182
2773 if (ret < 0) {
2774#line 183
2775 ret = 16384;
2776 } else {
2777
2778 }
2779 {
2780#line 178
2781 __cil_tmp18 = ret & 16384;
2782#line 178
2783 if (! __cil_tmp18) {
2784#line 178
2785 count = count + 1;
2786#line 178
2787 if (count < 5) {
2788
2789 } else {
2790#line 178
2791 goto while_break;
2792 }
2793 } else {
2794#line 178
2795 goto while_break;
2796 }
2797 }
2798 }
2799 while_break: ;
2800 }
2801#line 187
2802 if (ret & 16384) {
2803 {
2804#line 188
2805 __cil_tmp19 = (struct device const *)dev;
2806#line 188
2807 dev_err(__cil_tmp19, "Timed out writing RTC update\n");
2808 }
2809#line 189
2810 return (-5);
2811 } else {
2812
2813 }
2814 {
2815#line 195
2816 ret = wm831x_rtc_readtime(dev, & new_tm);
2817 }
2818#line 196
2819 if (ret < 0) {
2820#line 197
2821 return (ret);
2822 } else {
2823
2824 }
2825 {
2826#line 199
2827 ret = rtc_tm_to_time(& new_tm, & new_time);
2828 }
2829#line 200
2830 if (ret < 0) {
2831 {
2832#line 201
2833 __cil_tmp20 = (struct device const *)dev;
2834#line 201
2835 dev_err(__cil_tmp20, "Failed to convert time: %d\n", ret);
2836 }
2837#line 202
2838 return (ret);
2839 } else {
2840
2841 }
2842 {
2843#line 206
2844 __cil_tmp21 = & new_time;
2845#line 206
2846 __cil_tmp22 = *__cil_tmp21;
2847#line 206
2848 __cil_tmp23 = __cil_tmp22 - time;
2849#line 206
2850 if (__cil_tmp23 > 1UL) {
2851 {
2852#line 207
2853 __cil_tmp24 = (struct device const *)dev;
2854#line 207
2855 dev_err(__cil_tmp24, "RTC update not permitted by hardware\n");
2856 }
2857#line 208
2858 return (-1);
2859 } else {
2860
2861 }
2862 }
2863#line 211
2864 return (0);
2865}
2866}
2867#line 217 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
2868static int wm831x_rtc_readalarm(struct device *dev , struct rtc_wkalrm *alrm )
2869{ struct wm831x_rtc *wm831x_rtc ;
2870 void *tmp ;
2871 int ret ;
2872 u16 data[2] ;
2873 u32 time ;
2874 struct device const *__cil_tmp8 ;
2875 struct wm831x *__cil_tmp9 ;
2876 unsigned long __cil_tmp10 ;
2877 unsigned long __cil_tmp11 ;
2878 u16 *__cil_tmp12 ;
2879 struct device const *__cil_tmp13 ;
2880 unsigned long __cil_tmp14 ;
2881 unsigned long __cil_tmp15 ;
2882 u16 __cil_tmp16 ;
2883 int __cil_tmp17 ;
2884 unsigned long __cil_tmp18 ;
2885 unsigned long __cil_tmp19 ;
2886 u16 __cil_tmp20 ;
2887 int __cil_tmp21 ;
2888 int __cil_tmp22 ;
2889 int __cil_tmp23 ;
2890 unsigned long __cil_tmp24 ;
2891 unsigned long __cil_tmp25 ;
2892 unsigned long __cil_tmp26 ;
2893 struct rtc_time *__cil_tmp27 ;
2894 struct wm831x *__cil_tmp28 ;
2895 struct device const *__cil_tmp29 ;
2896
2897 {
2898 {
2899#line 219
2900 __cil_tmp8 = (struct device const *)dev;
2901#line 219
2902 tmp = dev_get_drvdata(__cil_tmp8);
2903#line 219
2904 wm831x_rtc = (struct wm831x_rtc *)tmp;
2905#line 224
2906 __cil_tmp9 = *((struct wm831x **)wm831x_rtc);
2907#line 224
2908 __cil_tmp10 = 0 * 2UL;
2909#line 224
2910 __cil_tmp11 = (unsigned long )(data) + __cil_tmp10;
2911#line 224
2912 __cil_tmp12 = (u16 *)__cil_tmp11;
2913#line 224
2914 ret = wm831x_bulk_read(__cil_tmp9, (unsigned short)16419, 2, __cil_tmp12);
2915 }
2916#line 226
2917 if (ret != 0) {
2918 {
2919#line 227
2920 __cil_tmp13 = (struct device const *)dev;
2921#line 227
2922 dev_err(__cil_tmp13, "Failed to read alarm time: %d\n", ret);
2923 }
2924#line 228
2925 return (ret);
2926 } else {
2927
2928 }
2929 {
2930#line 231
2931 __cil_tmp14 = 1 * 2UL;
2932#line 231
2933 __cil_tmp15 = (unsigned long )(data) + __cil_tmp14;
2934#line 231
2935 __cil_tmp16 = *((u16 *)__cil_tmp15);
2936#line 231
2937 __cil_tmp17 = (int )__cil_tmp16;
2938#line 231
2939 __cil_tmp18 = 0 * 2UL;
2940#line 231
2941 __cil_tmp19 = (unsigned long )(data) + __cil_tmp18;
2942#line 231
2943 __cil_tmp20 = *((u16 *)__cil_tmp19);
2944#line 231
2945 __cil_tmp21 = (int )__cil_tmp20;
2946#line 231
2947 __cil_tmp22 = __cil_tmp21 << 16;
2948#line 231
2949 __cil_tmp23 = __cil_tmp22 | __cil_tmp17;
2950#line 231
2951 time = (u32 )__cil_tmp23;
2952#line 233
2953 __cil_tmp24 = (unsigned long )time;
2954#line 233
2955 __cil_tmp25 = (unsigned long )alrm;
2956#line 233
2957 __cil_tmp26 = __cil_tmp25 + 4;
2958#line 233
2959 __cil_tmp27 = (struct rtc_time *)__cil_tmp26;
2960#line 233
2961 rtc_time_to_tm(__cil_tmp24, __cil_tmp27);
2962#line 235
2963 __cil_tmp28 = *((struct wm831x **)wm831x_rtc);
2964#line 235
2965 ret = wm831x_reg_read(__cil_tmp28, (unsigned short)16421);
2966 }
2967#line 236
2968 if (ret < 0) {
2969 {
2970#line 237
2971 __cil_tmp29 = (struct device const *)dev;
2972#line 237
2973 dev_err(__cil_tmp29, "Failed to read RTC control: %d\n", ret);
2974 }
2975#line 238
2976 return (ret);
2977 } else {
2978
2979 }
2980#line 241
2981 if (ret & 1024) {
2982#line 242
2983 *((unsigned char *)alrm) = (unsigned char)1;
2984 } else {
2985#line 244
2986 *((unsigned char *)alrm) = (unsigned char)0;
2987 }
2988#line 246
2989 return (0);
2990}
2991}
2992#line 249 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
2993static int wm831x_rtc_stop_alarm(struct wm831x_rtc *wm831x_rtc )
2994{ int tmp ;
2995 unsigned long __cil_tmp3 ;
2996 unsigned long __cil_tmp4 ;
2997 struct wm831x *__cil_tmp5 ;
2998
2999 {
3000 {
3001#line 251
3002 __cil_tmp3 = (unsigned long )wm831x_rtc;
3003#line 251
3004 __cil_tmp4 = __cil_tmp3 + 16;
3005#line 251
3006 *((unsigned int *)__cil_tmp4) = 0U;
3007#line 253
3008 __cil_tmp5 = *((struct wm831x **)wm831x_rtc);
3009#line 253
3010 tmp = wm831x_set_bits(__cil_tmp5, (unsigned short)16421, (unsigned short)1024, (unsigned short)0);
3011 }
3012#line 253
3013 return (tmp);
3014}
3015}
3016#line 257 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3017static int wm831x_rtc_start_alarm(struct wm831x_rtc *wm831x_rtc )
3018{ int tmp ;
3019 unsigned long __cil_tmp3 ;
3020 unsigned long __cil_tmp4 ;
3021 struct wm831x *__cil_tmp5 ;
3022
3023 {
3024 {
3025#line 259
3026 __cil_tmp3 = (unsigned long )wm831x_rtc;
3027#line 259
3028 __cil_tmp4 = __cil_tmp3 + 16;
3029#line 259
3030 *((unsigned int *)__cil_tmp4) = 1U;
3031#line 261
3032 __cil_tmp5 = *((struct wm831x **)wm831x_rtc);
3033#line 261
3034 tmp = wm831x_set_bits(__cil_tmp5, (unsigned short)16421, (unsigned short)1024, (unsigned short)1024);
3035 }
3036#line 261
3037 return (tmp);
3038}
3039}
3040#line 265 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3041static int wm831x_rtc_setalarm(struct device *dev , struct rtc_wkalrm *alrm )
3042{ struct wm831x_rtc *wm831x_rtc ;
3043 void *tmp ;
3044 struct wm831x *wm831x ;
3045 int ret ;
3046 unsigned long time ;
3047 struct device const *__cil_tmp8 ;
3048 unsigned long __cil_tmp9 ;
3049 unsigned long __cil_tmp10 ;
3050 struct rtc_time *__cil_tmp11 ;
3051 struct device const *__cil_tmp12 ;
3052 struct device const *__cil_tmp13 ;
3053 unsigned long *__cil_tmp14 ;
3054 unsigned long __cil_tmp15 ;
3055 unsigned long __cil_tmp16 ;
3056 unsigned long __cil_tmp17 ;
3057 unsigned short __cil_tmp18 ;
3058 struct device const *__cil_tmp19 ;
3059 unsigned long *__cil_tmp20 ;
3060 unsigned long __cil_tmp21 ;
3061 unsigned long __cil_tmp22 ;
3062 unsigned short __cil_tmp23 ;
3063 struct device const *__cil_tmp24 ;
3064 struct device const *__cil_tmp25 ;
3065
3066 {
3067 {
3068#line 267
3069 __cil_tmp8 = (struct device const *)dev;
3070#line 267
3071 tmp = dev_get_drvdata(__cil_tmp8);
3072#line 267
3073 wm831x_rtc = (struct wm831x_rtc *)tmp;
3074#line 268
3075 wm831x = *((struct wm831x **)wm831x_rtc);
3076#line 272
3077 __cil_tmp9 = (unsigned long )alrm;
3078#line 272
3079 __cil_tmp10 = __cil_tmp9 + 4;
3080#line 272
3081 __cil_tmp11 = (struct rtc_time *)__cil_tmp10;
3082#line 272
3083 ret = rtc_tm_to_time(__cil_tmp11, & time);
3084 }
3085#line 273
3086 if (ret < 0) {
3087 {
3088#line 274
3089 __cil_tmp12 = (struct device const *)dev;
3090#line 274
3091 dev_err(__cil_tmp12, "Failed to convert time: %d\n", ret);
3092 }
3093#line 275
3094 return (ret);
3095 } else {
3096
3097 }
3098 {
3099#line 278
3100 ret = wm831x_rtc_stop_alarm(wm831x_rtc);
3101 }
3102#line 279
3103 if (ret < 0) {
3104 {
3105#line 280
3106 __cil_tmp13 = (struct device const *)dev;
3107#line 280
3108 dev_err(__cil_tmp13, "Failed to stop alarm: %d\n", ret);
3109 }
3110#line 281
3111 return (ret);
3112 } else {
3113
3114 }
3115 {
3116#line 284
3117 __cil_tmp14 = & time;
3118#line 284
3119 __cil_tmp15 = *__cil_tmp14;
3120#line 284
3121 __cil_tmp16 = __cil_tmp15 >> 16;
3122#line 284
3123 __cil_tmp17 = __cil_tmp16 & 65535UL;
3124#line 284
3125 __cil_tmp18 = (unsigned short )__cil_tmp17;
3126#line 284
3127 ret = wm831x_reg_write(wm831x, (unsigned short)16419, __cil_tmp18);
3128 }
3129#line 286
3130 if (ret < 0) {
3131 {
3132#line 287
3133 __cil_tmp19 = (struct device const *)dev;
3134#line 287
3135 dev_err(__cil_tmp19, "Failed to write ALARM_1: %d\n", ret);
3136 }
3137#line 288
3138 return (ret);
3139 } else {
3140
3141 }
3142 {
3143#line 291
3144 __cil_tmp20 = & time;
3145#line 291
3146 __cil_tmp21 = *__cil_tmp20;
3147#line 291
3148 __cil_tmp22 = __cil_tmp21 & 65535UL;
3149#line 291
3150 __cil_tmp23 = (unsigned short )__cil_tmp22;
3151#line 291
3152 ret = wm831x_reg_write(wm831x, (unsigned short)16420, __cil_tmp23);
3153 }
3154#line 292
3155 if (ret < 0) {
3156 {
3157#line 293
3158 __cil_tmp24 = (struct device const *)dev;
3159#line 293
3160 dev_err(__cil_tmp24, "Failed to write ALARM_2: %d\n", ret);
3161 }
3162#line 294
3163 return (ret);
3164 } else {
3165
3166 }
3167#line 297
3168 if (*((unsigned char *)alrm)) {
3169 {
3170#line 298
3171 ret = wm831x_rtc_start_alarm(wm831x_rtc);
3172 }
3173#line 299
3174 if (ret < 0) {
3175 {
3176#line 300
3177 __cil_tmp25 = (struct device const *)dev;
3178#line 300
3179 dev_err(__cil_tmp25, "Failed to start alarm: %d\n", ret);
3180 }
3181#line 301
3182 return (ret);
3183 } else {
3184
3185 }
3186 } else {
3187
3188 }
3189#line 305
3190 return (0);
3191}
3192}
3193#line 308 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3194static int wm831x_rtc_alarm_irq_enable(struct device *dev , unsigned int enabled )
3195{ struct wm831x_rtc *wm831x_rtc ;
3196 void *tmp ;
3197 int tmp___0 ;
3198 int tmp___1 ;
3199 struct device const *__cil_tmp7 ;
3200
3201 {
3202 {
3203#line 311
3204 __cil_tmp7 = (struct device const *)dev;
3205#line 311
3206 tmp = dev_get_drvdata(__cil_tmp7);
3207#line 311
3208 wm831x_rtc = (struct wm831x_rtc *)tmp;
3209 }
3210#line 313
3211 if (enabled) {
3212 {
3213#line 314
3214 tmp___0 = wm831x_rtc_start_alarm(wm831x_rtc);
3215 }
3216#line 314
3217 return (tmp___0);
3218 } else {
3219 {
3220#line 316
3221 tmp___1 = wm831x_rtc_stop_alarm(wm831x_rtc);
3222 }
3223#line 316
3224 return (tmp___1);
3225 }
3226}
3227}
3228#line 319 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3229static irqreturn_t wm831x_alm_irq(int irq , void *data )
3230{ struct wm831x_rtc *wm831x_rtc ;
3231 unsigned long __cil_tmp4 ;
3232 unsigned long __cil_tmp5 ;
3233 struct rtc_device *__cil_tmp6 ;
3234
3235 {
3236 {
3237#line 321
3238 wm831x_rtc = (struct wm831x_rtc *)data;
3239#line 323
3240 __cil_tmp4 = (unsigned long )wm831x_rtc;
3241#line 323
3242 __cil_tmp5 = __cil_tmp4 + 8;
3243#line 323
3244 __cil_tmp6 = *((struct rtc_device **)__cil_tmp5);
3245#line 323
3246 rtc_update_irq(__cil_tmp6, 1UL, 160UL);
3247 }
3248#line 325
3249 return ((irqreturn_t )1);
3250}
3251}
3252#line 328 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3253static struct rtc_class_ops const wm831x_rtc_ops =
3254#line 328
3255 {(int (*)(struct device * ))0, (void (*)(struct device * ))0, (int (*)(struct device * ,
3256 unsigned int ,
3257 unsigned long ))0,
3258 & wm831x_rtc_readtime, (int (*)(struct device * , struct rtc_time * ))0, & wm831x_rtc_readalarm,
3259 & wm831x_rtc_setalarm, (int (*)(struct device * , struct seq_file * ))0, & wm831x_rtc_set_mmss,
3260 (int (*)(struct device * , int data ))0, & wm831x_rtc_alarm_irq_enable};
3261#line 338 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3262static int wm831x_rtc_suspend(struct device *dev )
3263{ struct platform_device *pdev ;
3264 struct device const *__mptr ;
3265 struct wm831x_rtc *wm831x_rtc ;
3266 void *tmp ;
3267 int ret ;
3268 int enable ;
3269 bool tmp___0 ;
3270 struct platform_device *__cil_tmp9 ;
3271 unsigned long __cil_tmp10 ;
3272 unsigned long __cil_tmp11 ;
3273 struct device *__cil_tmp12 ;
3274 unsigned int __cil_tmp13 ;
3275 char *__cil_tmp14 ;
3276 char *__cil_tmp15 ;
3277 unsigned long __cil_tmp16 ;
3278 unsigned long __cil_tmp17 ;
3279 struct device *__cil_tmp18 ;
3280 struct device const *__cil_tmp19 ;
3281 unsigned long __cil_tmp20 ;
3282 unsigned long __cil_tmp21 ;
3283 unsigned long __cil_tmp22 ;
3284 unsigned long __cil_tmp23 ;
3285 struct device *__cil_tmp24 ;
3286 struct wm831x *__cil_tmp25 ;
3287 unsigned short __cil_tmp26 ;
3288 unsigned long __cil_tmp27 ;
3289 unsigned long __cil_tmp28 ;
3290 struct device *__cil_tmp29 ;
3291 struct device const *__cil_tmp30 ;
3292
3293 {
3294 {
3295#line 340
3296 __mptr = (struct device const *)dev;
3297#line 340
3298 __cil_tmp9 = (struct platform_device *)0;
3299#line 340
3300 __cil_tmp10 = (unsigned long )__cil_tmp9;
3301#line 340
3302 __cil_tmp11 = __cil_tmp10 + 16;
3303#line 340
3304 __cil_tmp12 = (struct device *)__cil_tmp11;
3305#line 340
3306 __cil_tmp13 = (unsigned int )__cil_tmp12;
3307#line 340
3308 __cil_tmp14 = (char *)__mptr;
3309#line 340
3310 __cil_tmp15 = __cil_tmp14 - __cil_tmp13;
3311#line 340
3312 pdev = (struct platform_device *)__cil_tmp15;
3313#line 341
3314 __cil_tmp16 = (unsigned long )pdev;
3315#line 341
3316 __cil_tmp17 = __cil_tmp16 + 16;
3317#line 341
3318 __cil_tmp18 = (struct device *)__cil_tmp17;
3319#line 341
3320 __cil_tmp19 = (struct device const *)__cil_tmp18;
3321#line 341
3322 tmp = dev_get_drvdata(__cil_tmp19);
3323#line 341
3324 wm831x_rtc = (struct wm831x_rtc *)tmp;
3325 }
3326 {
3327#line 344
3328 __cil_tmp20 = (unsigned long )wm831x_rtc;
3329#line 344
3330 __cil_tmp21 = __cil_tmp20 + 16;
3331#line 344
3332 if (*((unsigned int *)__cil_tmp21)) {
3333 {
3334#line 344
3335 __cil_tmp22 = (unsigned long )pdev;
3336#line 344
3337 __cil_tmp23 = __cil_tmp22 + 16;
3338#line 344
3339 __cil_tmp24 = (struct device *)__cil_tmp23;
3340#line 344
3341 tmp___0 = device_may_wakeup(__cil_tmp24);
3342 }
3343#line 344
3344 if (tmp___0) {
3345#line 345
3346 enable = 1024;
3347 } else {
3348#line 347
3349 enable = 0;
3350 }
3351 } else {
3352#line 347
3353 enable = 0;
3354 }
3355 }
3356 {
3357#line 349
3358 __cil_tmp25 = *((struct wm831x **)wm831x_rtc);
3359#line 349
3360 __cil_tmp26 = (unsigned short )enable;
3361#line 349
3362 ret = wm831x_set_bits(__cil_tmp25, (unsigned short)16421, (unsigned short)1024,
3363 __cil_tmp26);
3364 }
3365#line 351
3366 if (ret != 0) {
3367 {
3368#line 352
3369 __cil_tmp27 = (unsigned long )pdev;
3370#line 352
3371 __cil_tmp28 = __cil_tmp27 + 16;
3372#line 352
3373 __cil_tmp29 = (struct device *)__cil_tmp28;
3374#line 352
3375 __cil_tmp30 = (struct device const *)__cil_tmp29;
3376#line 352
3377 dev_err(__cil_tmp30, "Failed to update RTC alarm: %d\n", ret);
3378 }
3379 } else {
3380
3381 }
3382#line 354
3383 return (0);
3384}
3385}
3386#line 360 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3387static int wm831x_rtc_resume(struct device *dev )
3388{ struct platform_device *pdev ;
3389 struct device const *__mptr ;
3390 struct wm831x_rtc *wm831x_rtc ;
3391 void *tmp ;
3392 int ret ;
3393 struct platform_device *__cil_tmp7 ;
3394 unsigned long __cil_tmp8 ;
3395 unsigned long __cil_tmp9 ;
3396 struct device *__cil_tmp10 ;
3397 unsigned int __cil_tmp11 ;
3398 char *__cil_tmp12 ;
3399 char *__cil_tmp13 ;
3400 unsigned long __cil_tmp14 ;
3401 unsigned long __cil_tmp15 ;
3402 struct device *__cil_tmp16 ;
3403 struct device const *__cil_tmp17 ;
3404 unsigned long __cil_tmp18 ;
3405 unsigned long __cil_tmp19 ;
3406 unsigned long __cil_tmp20 ;
3407 unsigned long __cil_tmp21 ;
3408 struct device *__cil_tmp22 ;
3409 struct device const *__cil_tmp23 ;
3410
3411 {
3412 {
3413#line 362
3414 __mptr = (struct device const *)dev;
3415#line 362
3416 __cil_tmp7 = (struct platform_device *)0;
3417#line 362
3418 __cil_tmp8 = (unsigned long )__cil_tmp7;
3419#line 362
3420 __cil_tmp9 = __cil_tmp8 + 16;
3421#line 362
3422 __cil_tmp10 = (struct device *)__cil_tmp9;
3423#line 362
3424 __cil_tmp11 = (unsigned int )__cil_tmp10;
3425#line 362
3426 __cil_tmp12 = (char *)__mptr;
3427#line 362
3428 __cil_tmp13 = __cil_tmp12 - __cil_tmp11;
3429#line 362
3430 pdev = (struct platform_device *)__cil_tmp13;
3431#line 363
3432 __cil_tmp14 = (unsigned long )pdev;
3433#line 363
3434 __cil_tmp15 = __cil_tmp14 + 16;
3435#line 363
3436 __cil_tmp16 = (struct device *)__cil_tmp15;
3437#line 363
3438 __cil_tmp17 = (struct device const *)__cil_tmp16;
3439#line 363
3440 tmp = dev_get_drvdata(__cil_tmp17);
3441#line 363
3442 wm831x_rtc = (struct wm831x_rtc *)tmp;
3443 }
3444 {
3445#line 366
3446 __cil_tmp18 = (unsigned long )wm831x_rtc;
3447#line 366
3448 __cil_tmp19 = __cil_tmp18 + 16;
3449#line 366
3450 if (*((unsigned int *)__cil_tmp19)) {
3451 {
3452#line 367
3453 ret = wm831x_rtc_start_alarm(wm831x_rtc);
3454 }
3455#line 368
3456 if (ret != 0) {
3457 {
3458#line 369
3459 __cil_tmp20 = (unsigned long )pdev;
3460#line 369
3461 __cil_tmp21 = __cil_tmp20 + 16;
3462#line 369
3463 __cil_tmp22 = (struct device *)__cil_tmp21;
3464#line 369
3465 __cil_tmp23 = (struct device const *)__cil_tmp22;
3466#line 369
3467 dev_err(__cil_tmp23, "Failed to restart RTC alarm: %d\n", ret);
3468 }
3469 } else {
3470
3471 }
3472 } else {
3473
3474 }
3475 }
3476#line 373
3477 return (0);
3478}
3479}
3480#line 377 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3481static int wm831x_rtc_freeze(struct device *dev )
3482{ struct platform_device *pdev ;
3483 struct device const *__mptr ;
3484 struct wm831x_rtc *wm831x_rtc ;
3485 void *tmp ;
3486 int ret ;
3487 struct platform_device *__cil_tmp7 ;
3488 unsigned long __cil_tmp8 ;
3489 unsigned long __cil_tmp9 ;
3490 struct device *__cil_tmp10 ;
3491 unsigned int __cil_tmp11 ;
3492 char *__cil_tmp12 ;
3493 char *__cil_tmp13 ;
3494 unsigned long __cil_tmp14 ;
3495 unsigned long __cil_tmp15 ;
3496 struct device *__cil_tmp16 ;
3497 struct device const *__cil_tmp17 ;
3498 struct wm831x *__cil_tmp18 ;
3499 unsigned long __cil_tmp19 ;
3500 unsigned long __cil_tmp20 ;
3501 struct device *__cil_tmp21 ;
3502 struct device const *__cil_tmp22 ;
3503
3504 {
3505 {
3506#line 379
3507 __mptr = (struct device const *)dev;
3508#line 379
3509 __cil_tmp7 = (struct platform_device *)0;
3510#line 379
3511 __cil_tmp8 = (unsigned long )__cil_tmp7;
3512#line 379
3513 __cil_tmp9 = __cil_tmp8 + 16;
3514#line 379
3515 __cil_tmp10 = (struct device *)__cil_tmp9;
3516#line 379
3517 __cil_tmp11 = (unsigned int )__cil_tmp10;
3518#line 379
3519 __cil_tmp12 = (char *)__mptr;
3520#line 379
3521 __cil_tmp13 = __cil_tmp12 - __cil_tmp11;
3522#line 379
3523 pdev = (struct platform_device *)__cil_tmp13;
3524#line 380
3525 __cil_tmp14 = (unsigned long )pdev;
3526#line 380
3527 __cil_tmp15 = __cil_tmp14 + 16;
3528#line 380
3529 __cil_tmp16 = (struct device *)__cil_tmp15;
3530#line 380
3531 __cil_tmp17 = (struct device const *)__cil_tmp16;
3532#line 380
3533 tmp = dev_get_drvdata(__cil_tmp17);
3534#line 380
3535 wm831x_rtc = (struct wm831x_rtc *)tmp;
3536#line 383
3537 __cil_tmp18 = *((struct wm831x **)wm831x_rtc);
3538#line 383
3539 ret = wm831x_set_bits(__cil_tmp18, (unsigned short)16421, (unsigned short)1024,
3540 (unsigned short)0);
3541 }
3542#line 385
3543 if (ret != 0) {
3544 {
3545#line 386
3546 __cil_tmp19 = (unsigned long )pdev;
3547#line 386
3548 __cil_tmp20 = __cil_tmp19 + 16;
3549#line 386
3550 __cil_tmp21 = (struct device *)__cil_tmp20;
3551#line 386
3552 __cil_tmp22 = (struct device const *)__cil_tmp21;
3553#line 386
3554 dev_err(__cil_tmp22, "Failed to stop RTC alarm: %d\n", ret);
3555 }
3556 } else {
3557
3558 }
3559#line 388
3560 return (0);
3561}
3562}
3563#line 396 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3564static int wm831x_rtc_probe(struct platform_device *pdev )
3565{ struct wm831x *wm831x ;
3566 void *tmp ;
3567 struct wm831x_rtc *wm831x_rtc ;
3568 int alm_irq ;
3569 int tmp___0 ;
3570 int ret ;
3571 void *tmp___1 ;
3572 long tmp___2 ;
3573 long tmp___3 ;
3574 unsigned long __cil_tmp11 ;
3575 unsigned long __cil_tmp12 ;
3576 struct device *__cil_tmp13 ;
3577 struct device const *__cil_tmp14 ;
3578 unsigned long __cil_tmp15 ;
3579 unsigned long __cil_tmp16 ;
3580 struct device *__cil_tmp17 ;
3581 void *__cil_tmp18 ;
3582 unsigned long __cil_tmp19 ;
3583 unsigned long __cil_tmp20 ;
3584 void *__cil_tmp21 ;
3585 unsigned long __cil_tmp22 ;
3586 unsigned long __cil_tmp23 ;
3587 struct device *__cil_tmp24 ;
3588 struct device const *__cil_tmp25 ;
3589 unsigned long __cil_tmp26 ;
3590 unsigned long __cil_tmp27 ;
3591 unsigned long __cil_tmp28 ;
3592 unsigned long __cil_tmp29 ;
3593 struct device *__cil_tmp30 ;
3594 bool __cil_tmp31 ;
3595 unsigned long __cil_tmp32 ;
3596 unsigned long __cil_tmp33 ;
3597 unsigned long __cil_tmp34 ;
3598 unsigned long __cil_tmp35 ;
3599 struct device *__cil_tmp36 ;
3600 unsigned long __cil_tmp37 ;
3601 unsigned long __cil_tmp38 ;
3602 struct rtc_device *__cil_tmp39 ;
3603 void const *__cil_tmp40 ;
3604 unsigned long __cil_tmp41 ;
3605 unsigned long __cil_tmp42 ;
3606 struct rtc_device *__cil_tmp43 ;
3607 void const *__cil_tmp44 ;
3608 unsigned int __cil_tmp45 ;
3609 void *__cil_tmp46 ;
3610 irqreturn_t (*__cil_tmp47)(int , void * ) ;
3611 void *__cil_tmp48 ;
3612 unsigned long __cil_tmp49 ;
3613 unsigned long __cil_tmp50 ;
3614 struct device *__cil_tmp51 ;
3615 struct device const *__cil_tmp52 ;
3616
3617 {
3618 {
3619#line 398
3620 __cil_tmp11 = (unsigned long )pdev;
3621#line 398
3622 __cil_tmp12 = __cil_tmp11 + 16;
3623#line 398
3624 __cil_tmp13 = *((struct device **)__cil_tmp12);
3625#line 398
3626 __cil_tmp14 = (struct device const *)__cil_tmp13;
3627#line 398
3628 tmp = dev_get_drvdata(__cil_tmp14);
3629#line 398
3630 wm831x = (struct wm831x *)tmp;
3631#line 400
3632 tmp___0 = platform_get_irq_byname(pdev, "ALM");
3633#line 400
3634 alm_irq = tmp___0;
3635#line 401
3636 ret = 0;
3637#line 403
3638 __cil_tmp15 = (unsigned long )pdev;
3639#line 403
3640 __cil_tmp16 = __cil_tmp15 + 16;
3641#line 403
3642 __cil_tmp17 = (struct device *)__cil_tmp16;
3643#line 403
3644 tmp___1 = devm_kzalloc(__cil_tmp17, 24UL, 208U);
3645#line 403
3646 wm831x_rtc = (struct wm831x_rtc *)tmp___1;
3647 }
3648 {
3649#line 404
3650 __cil_tmp18 = (void *)0;
3651#line 404
3652 __cil_tmp19 = (unsigned long )__cil_tmp18;
3653#line 404
3654 __cil_tmp20 = (unsigned long )wm831x_rtc;
3655#line 404
3656 if (__cil_tmp20 == __cil_tmp19) {
3657#line 405
3658 return (-12);
3659 } else {
3660
3661 }
3662 }
3663 {
3664#line 407
3665 __cil_tmp21 = (void *)wm831x_rtc;
3666#line 407
3667 platform_set_drvdata(pdev, __cil_tmp21);
3668#line 408
3669 *((struct wm831x **)wm831x_rtc) = wm831x;
3670#line 410
3671 ret = wm831x_reg_read(wm831x, (unsigned short)16421);
3672 }
3673#line 411
3674 if (ret < 0) {
3675 {
3676#line 412
3677 __cil_tmp22 = (unsigned long )pdev;
3678#line 412
3679 __cil_tmp23 = __cil_tmp22 + 16;
3680#line 412
3681 __cil_tmp24 = (struct device *)__cil_tmp23;
3682#line 412
3683 __cil_tmp25 = (struct device const *)__cil_tmp24;
3684#line 412
3685 dev_err(__cil_tmp25, "Failed to read RTC control: %d\n", ret);
3686 }
3687#line 413
3688 goto err;
3689 } else {
3690
3691 }
3692#line 415
3693 if (ret & 1024) {
3694#line 416
3695 __cil_tmp26 = (unsigned long )wm831x_rtc;
3696#line 416
3697 __cil_tmp27 = __cil_tmp26 + 16;
3698#line 416
3699 *((unsigned int *)__cil_tmp27) = 1U;
3700 } else {
3701
3702 }
3703 {
3704#line 418
3705 __cil_tmp28 = (unsigned long )pdev;
3706#line 418
3707 __cil_tmp29 = __cil_tmp28 + 16;
3708#line 418
3709 __cil_tmp30 = (struct device *)__cil_tmp29;
3710#line 418
3711 __cil_tmp31 = (bool )1;
3712#line 418
3713 device_init_wakeup(__cil_tmp30, __cil_tmp31);
3714#line 420
3715 __cil_tmp32 = (unsigned long )wm831x_rtc;
3716#line 420
3717 __cil_tmp33 = __cil_tmp32 + 8;
3718#line 420
3719 __cil_tmp34 = (unsigned long )pdev;
3720#line 420
3721 __cil_tmp35 = __cil_tmp34 + 16;
3722#line 420
3723 __cil_tmp36 = (struct device *)__cil_tmp35;
3724#line 420
3725 *((struct rtc_device **)__cil_tmp33) = rtc_device_register("wm831x", __cil_tmp36,
3726 & wm831x_rtc_ops, & __this_module);
3727#line 422
3728 __cil_tmp37 = (unsigned long )wm831x_rtc;
3729#line 422
3730 __cil_tmp38 = __cil_tmp37 + 8;
3731#line 422
3732 __cil_tmp39 = *((struct rtc_device **)__cil_tmp38);
3733#line 422
3734 __cil_tmp40 = (void const *)__cil_tmp39;
3735#line 422
3736 tmp___3 = (long )IS_ERR(__cil_tmp40);
3737 }
3738#line 422
3739 if (tmp___3) {
3740 {
3741#line 423
3742 __cil_tmp41 = (unsigned long )wm831x_rtc;
3743#line 423
3744 __cil_tmp42 = __cil_tmp41 + 8;
3745#line 423
3746 __cil_tmp43 = *((struct rtc_device **)__cil_tmp42);
3747#line 423
3748 __cil_tmp44 = (void const *)__cil_tmp43;
3749#line 423
3750 tmp___2 = (long )PTR_ERR(__cil_tmp44);
3751#line 423
3752 ret = (int )tmp___2;
3753 }
3754#line 424
3755 goto err;
3756 } else {
3757
3758 }
3759 {
3760#line 427
3761 __cil_tmp45 = (unsigned int )alm_irq;
3762#line 427
3763 __cil_tmp46 = (void *)0;
3764#line 427
3765 __cil_tmp47 = (irqreturn_t (*)(int , void * ))__cil_tmp46;
3766#line 427
3767 __cil_tmp48 = (void *)wm831x_rtc;
3768#line 427
3769 ret = (int )request_threaded_irq(__cil_tmp45, __cil_tmp47, & wm831x_alm_irq, 1UL,
3770 "RTC alarm", __cil_tmp48);
3771 }
3772#line 430
3773 if (ret != 0) {
3774 {
3775#line 431
3776 __cil_tmp49 = (unsigned long )pdev;
3777#line 431
3778 __cil_tmp50 = __cil_tmp49 + 16;
3779#line 431
3780 __cil_tmp51 = (struct device *)__cil_tmp50;
3781#line 431
3782 __cil_tmp52 = (struct device const *)__cil_tmp51;
3783#line 431
3784 dev_err(__cil_tmp52, "Failed to request alarm IRQ %d: %d\n", alm_irq, ret);
3785 }
3786 } else {
3787
3788 }
3789#line 435
3790 return (0);
3791 err:
3792#line 438
3793 return (ret);
3794}
3795}
3796#line 441
3797static int wm831x_rtc_remove(struct platform_device *pdev ) __attribute__((__section__(".devexit.text"),
3798__no_instrument_function__)) ;
3799#line 441 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3800static int wm831x_rtc_remove(struct platform_device *pdev )
3801{ struct wm831x_rtc *wm831x_rtc ;
3802 void *tmp ;
3803 int alm_irq ;
3804 int tmp___0 ;
3805 struct platform_device const *__cil_tmp6 ;
3806 unsigned int __cil_tmp7 ;
3807 void *__cil_tmp8 ;
3808 unsigned long __cil_tmp9 ;
3809 unsigned long __cil_tmp10 ;
3810 struct rtc_device *__cil_tmp11 ;
3811
3812 {
3813 {
3814#line 443
3815 __cil_tmp6 = (struct platform_device const *)pdev;
3816#line 443
3817 tmp = platform_get_drvdata(__cil_tmp6);
3818#line 443
3819 wm831x_rtc = (struct wm831x_rtc *)tmp;
3820#line 444
3821 tmp___0 = platform_get_irq_byname(pdev, "ALM");
3822#line 444
3823 alm_irq = tmp___0;
3824#line 446
3825 __cil_tmp7 = (unsigned int )alm_irq;
3826#line 446
3827 __cil_tmp8 = (void *)wm831x_rtc;
3828#line 446
3829 free_irq(__cil_tmp7, __cil_tmp8);
3830#line 447
3831 __cil_tmp9 = (unsigned long )wm831x_rtc;
3832#line 447
3833 __cil_tmp10 = __cil_tmp9 + 8;
3834#line 447
3835 __cil_tmp11 = *((struct rtc_device **)__cil_tmp10);
3836#line 447
3837 rtc_device_unregister(__cil_tmp11);
3838 }
3839#line 449
3840 return (0);
3841}
3842}
3843#line 452 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3844static struct dev_pm_ops const wm831x_rtc_pm_ops =
3845#line 452
3846 {(int (*)(struct device *dev ))0, (void (*)(struct device *dev ))0, & wm831x_rtc_suspend,
3847 & wm831x_rtc_resume, & wm831x_rtc_freeze, & wm831x_rtc_resume, & wm831x_rtc_suspend,
3848 & wm831x_rtc_resume, (int (*)(struct device *dev ))0, (int (*)(struct device *dev ))0,
3849 (int (*)(struct device *dev ))0, (int (*)(struct device *dev ))0, (int (*)(struct device *dev ))0,
3850 (int (*)(struct device *dev ))0, (int (*)(struct device *dev ))0, (int (*)(struct device *dev ))0,
3851 (int (*)(struct device *dev ))0, (int (*)(struct device *dev ))0, (int (*)(struct device *dev ))0,
3852 (int (*)(struct device *dev ))0, (int (*)(struct device *dev ))0, (int (*)(struct device *dev ))0,
3853 (int (*)(struct device *dev ))0};
3854#line 463 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3855static struct platform_driver wm831x_rtc_driver = {& wm831x_rtc_probe, & wm831x_rtc_remove, (void (*)(struct platform_device * ))0,
3856 (int (*)(struct platform_device * , pm_message_t state ))0, (int (*)(struct platform_device * ))0,
3857 {"wm831x-rtc", (struct bus_type *)0, (struct module *)0, (char const *)0, (_Bool)0,
3858 (struct of_device_id const *)0, (int (*)(struct device *dev ))0, (int (*)(struct device *dev ))0,
3859 (void (*)(struct device *dev ))0, (int (*)(struct device *dev , pm_message_t state ))0,
3860 (int (*)(struct device *dev ))0, (struct attribute_group const **)0, & wm831x_rtc_pm_ops,
3861 (struct driver_private *)0}, (struct platform_device_id const *)0};
3862#line 472
3863static int wm831x_rtc_driver_init(void) __attribute__((__section__(".init.text"),
3864__no_instrument_function__)) ;
3865#line 472 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3866static int wm831x_rtc_driver_init(void)
3867{ int tmp ;
3868
3869 {
3870 {
3871#line 472
3872 tmp = platform_driver_register(& wm831x_rtc_driver);
3873 }
3874#line 472
3875 return (tmp);
3876}
3877}
3878#line 472 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3879int init_module(void)
3880{ int tmp ;
3881
3882 {
3883 {
3884#line 472
3885 tmp = wm831x_rtc_driver_init();
3886 }
3887#line 472
3888 return (tmp);
3889}
3890}
3891#line 472
3892static void wm831x_rtc_driver_exit(void) __attribute__((__section__(".exit.text"),
3893__no_instrument_function__)) ;
3894#line 472 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3895static void wm831x_rtc_driver_exit(void)
3896{
3897
3898 {
3899 {
3900#line 472
3901 platform_driver_unregister(& wm831x_rtc_driver);
3902 }
3903#line 472
3904 return;
3905}
3906}
3907#line 472 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3908void cleanup_module(void)
3909{
3910
3911 {
3912 {
3913#line 472
3914 wm831x_rtc_driver_exit();
3915 }
3916#line 472
3917 return;
3918}
3919}
3920#line 474 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3921static char const __mod_author474[56] __attribute__((__used__, __unused__, __section__(".modinfo"),
3922__aligned__(1))) =
3923#line 474
3924 { (char const )'a', (char const )'u', (char const )'t', (char const )'h',
3925 (char const )'o', (char const )'r', (char const )'=', (char const )'M',
3926 (char const )'a', (char const )'r', (char const )'k', (char const )' ',
3927 (char const )'B', (char const )'r', (char const )'o', (char const )'w',
3928 (char const )'n', (char const )' ', (char const )'<', (char const )'b',
3929 (char const )'r', (char const )'o', (char const )'o', (char const )'n',
3930 (char const )'i', (char const )'e', (char const )'@', (char const )'o',
3931 (char const )'p', (char const )'e', (char const )'n', (char const )'s',
3932 (char const )'o', (char const )'u', (char const )'r', (char const )'c',
3933 (char const )'e', (char const )'.', (char const )'w', (char const )'o',
3934 (char const )'l', (char const )'f', (char const )'s', (char const )'o',
3935 (char const )'n', (char const )'m', (char const )'i', (char const )'c',
3936 (char const )'r', (char const )'o', (char const )'.', (char const )'c',
3937 (char const )'o', (char const )'m', (char const )'>', (char const )'\000'};
3938#line 475 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3939static char const __mod_description475[51] __attribute__((__used__, __unused__,
3940__section__(".modinfo"), __aligned__(1))) =
3941#line 475
3942 { (char const )'d', (char const )'e', (char const )'s', (char const )'c',
3943 (char const )'r', (char const )'i', (char const )'p', (char const )'t',
3944 (char const )'i', (char const )'o', (char const )'n', (char const )'=',
3945 (char const )'R', (char const )'T', (char const )'C', (char const )' ',
3946 (char const )'d', (char const )'r', (char const )'i', (char const )'v',
3947 (char const )'e', (char const )'r', (char const )' ', (char const )'f',
3948 (char const )'o', (char const )'r', (char const )' ', (char const )'t',
3949 (char const )'h', (char const )'e', (char const )' ', (char const )'W',
3950 (char const )'M', (char const )'8', (char const )'3', (char const )'1',
3951 (char const )'x', (char const )' ', (char const )'s', (char const )'e',
3952 (char const )'r', (char const )'i', (char const )'e', (char const )'s',
3953 (char const )' ', (char const )'P', (char const )'M', (char const )'I',
3954 (char const )'C', (char const )'s', (char const )'\000'};
3955#line 476 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3956static char const __mod_license476[12] __attribute__((__used__, __unused__, __section__(".modinfo"),
3957__aligned__(1))) =
3958#line 476
3959 { (char const )'l', (char const )'i', (char const )'c', (char const )'e',
3960 (char const )'n', (char const )'s', (char const )'e', (char const )'=',
3961 (char const )'G', (char const )'P', (char const )'L', (char const )'\000'};
3962#line 477 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3963static char const __mod_alias477[26] __attribute__((__used__, __unused__, __section__(".modinfo"),
3964__aligned__(1))) =
3965#line 477
3966 { (char const )'a', (char const )'l', (char const )'i', (char const )'a',
3967 (char const )'s', (char const )'=', (char const )'p', (char const )'l',
3968 (char const )'a', (char const )'t', (char const )'f', (char const )'o',
3969 (char const )'r', (char const )'m', (char const )':', (char const )'w',
3970 (char const )'m', (char const )'8', (char const )'3', (char const )'1',
3971 (char const )'x', (char const )'-', (char const )'r', (char const )'t',
3972 (char const )'c', (char const )'\000'};
3973#line 495
3974void ldv_check_final_state(void) ;
3975#line 498
3976extern void ldv_check_return_value(int res ) ;
3977#line 501
3978extern void ldv_initialize(void) ;
3979#line 504
3980extern int __VERIFIER_nondet_int(void) ;
3981#line 507 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3982int LDV_IN_INTERRUPT ;
3983#line 946 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3984static int res_wm831x_rtc_probe_11 ;
3985#line 510 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
3986void main(void)
3987{ struct device *var_group1 ;
3988 struct rtc_time *var_group2 ;
3989 unsigned long var_wm831x_rtc_set_mmss_1_p1 ;
3990 struct rtc_wkalrm *var_group3 ;
3991 unsigned int var_wm831x_rtc_alarm_irq_enable_6_p1 ;
3992 struct platform_device *var_group4 ;
3993 int var_wm831x_alm_irq_7_p0 ;
3994 void *var_wm831x_alm_irq_7_p1 ;
3995 int ldv_s_wm831x_rtc_driver_platform_driver ;
3996 int tmp ;
3997 int tmp___0 ;
3998 int __cil_tmp12 ;
3999
4000 {
4001 {
4002#line 1006
4003 LDV_IN_INTERRUPT = 1;
4004#line 1015
4005 ldv_initialize();
4006#line 1020
4007 ldv_s_wm831x_rtc_driver_platform_driver = 0;
4008 }
4009 {
4010#line 1025
4011 while (1) {
4012 while_continue: ;
4013 {
4014#line 1025
4015 tmp___0 = __VERIFIER_nondet_int();
4016 }
4017#line 1025
4018 if (tmp___0) {
4019
4020 } else {
4021 {
4022#line 1025
4023 __cil_tmp12 = ldv_s_wm831x_rtc_driver_platform_driver == 0;
4024#line 1025
4025 if (! __cil_tmp12) {
4026
4027 } else {
4028#line 1025
4029 goto while_break;
4030 }
4031 }
4032 }
4033 {
4034#line 1029
4035 tmp = __VERIFIER_nondet_int();
4036 }
4037#line 1031
4038 if (tmp == 0) {
4039#line 1031
4040 goto case_0;
4041 } else
4042#line 1091
4043 if (tmp == 1) {
4044#line 1091
4045 goto case_1;
4046 } else
4047#line 1151
4048 if (tmp == 2) {
4049#line 1151
4050 goto case_2;
4051 } else
4052#line 1211
4053 if (tmp == 3) {
4054#line 1211
4055 goto case_3;
4056 } else
4057#line 1271
4058 if (tmp == 4) {
4059#line 1271
4060 goto case_4;
4061 } else
4062#line 1331
4063 if (tmp == 5) {
4064#line 1331
4065 goto case_5;
4066 } else
4067#line 1391
4068 if (tmp == 6) {
4069#line 1391
4070 goto case_6;
4071 } else
4072#line 1451
4073 if (tmp == 7) {
4074#line 1451
4075 goto case_7;
4076 } else
4077#line 1511
4078 if (tmp == 8) {
4079#line 1511
4080 goto case_8;
4081 } else
4082#line 1572
4083 if (tmp == 9) {
4084#line 1572
4085 goto case_9;
4086 } else {
4087 {
4088#line 1632
4089 goto switch_default;
4090#line 1029
4091 if (0) {
4092 case_0:
4093 {
4094#line 1075
4095 wm831x_rtc_readtime(var_group1, var_group2);
4096 }
4097#line 1090
4098 goto switch_break;
4099 case_1:
4100 {
4101#line 1135
4102 wm831x_rtc_set_mmss(var_group1, var_wm831x_rtc_set_mmss_1_p1);
4103 }
4104#line 1150
4105 goto switch_break;
4106 case_2:
4107 {
4108#line 1195
4109 wm831x_rtc_readalarm(var_group1, var_group3);
4110 }
4111#line 1210
4112 goto switch_break;
4113 case_3:
4114 {
4115#line 1255
4116 wm831x_rtc_setalarm(var_group1, var_group3);
4117 }
4118#line 1270
4119 goto switch_break;
4120 case_4:
4121 {
4122#line 1315
4123 wm831x_rtc_alarm_irq_enable(var_group1, var_wm831x_rtc_alarm_irq_enable_6_p1);
4124 }
4125#line 1330
4126 goto switch_break;
4127 case_5:
4128 {
4129#line 1376
4130 wm831x_rtc_suspend(var_group1);
4131 }
4132#line 1390
4133 goto switch_break;
4134 case_6:
4135 {
4136#line 1436
4137 wm831x_rtc_resume(var_group1);
4138 }
4139#line 1450
4140 goto switch_break;
4141 case_7:
4142 {
4143#line 1496
4144 wm831x_rtc_freeze(var_group1);
4145 }
4146#line 1510
4147 goto switch_break;
4148 case_8:
4149#line 1514
4150 if (ldv_s_wm831x_rtc_driver_platform_driver == 0) {
4151 {
4152#line 1561
4153 res_wm831x_rtc_probe_11 = wm831x_rtc_probe(var_group4);
4154#line 1562
4155 ldv_check_return_value(res_wm831x_rtc_probe_11);
4156 }
4157#line 1563
4158 if (res_wm831x_rtc_probe_11) {
4159#line 1564
4160 goto ldv_module_exit;
4161 } else {
4162
4163 }
4164#line 1565
4165 ldv_s_wm831x_rtc_driver_platform_driver = 0;
4166 } else {
4167
4168 }
4169#line 1571
4170 goto switch_break;
4171 case_9:
4172 {
4173#line 1575
4174 LDV_IN_INTERRUPT = 2;
4175#line 1616
4176 wm831x_alm_irq(var_wm831x_alm_irq_7_p0, var_wm831x_alm_irq_7_p1);
4177#line 1625
4178 LDV_IN_INTERRUPT = 1;
4179 }
4180#line 1631
4181 goto switch_break;
4182 switch_default:
4183#line 1632
4184 goto switch_break;
4185 } else {
4186 switch_break: ;
4187 }
4188 }
4189 }
4190 }
4191 while_break: ;
4192 }
4193 ldv_module_exit:
4194 {
4195#line 1641
4196 ldv_check_final_state();
4197 }
4198#line 1644
4199 return;
4200}
4201}
4202#line 5 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/engine-blast-assert.h"
4203void ldv_blast_assert(void)
4204{
4205
4206 {
4207 ERROR:
4208#line 6
4209 goto ERROR;
4210}
4211}
4212#line 6 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/engine-blast.h"
4213extern int __VERIFIER_nondet_int(void) ;
4214#line 19 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
4215int ldv_mutex = 1;
4216#line 22 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
4217int __attribute__((__warn_unused_result__)) mutex_lock_interruptible(struct mutex *lock )
4218{ int nondetermined ;
4219
4220 {
4221#line 29
4222 if (ldv_mutex == 1) {
4223
4224 } else {
4225 {
4226#line 29
4227 ldv_blast_assert();
4228 }
4229 }
4230 {
4231#line 32
4232 nondetermined = __VERIFIER_nondet_int();
4233 }
4234#line 35
4235 if (nondetermined) {
4236#line 38
4237 ldv_mutex = 2;
4238#line 40
4239 return (0);
4240 } else {
4241#line 45
4242 return (-4);
4243 }
4244}
4245}
4246#line 50 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
4247int __attribute__((__warn_unused_result__)) mutex_lock_killable(struct mutex *lock )
4248{ int nondetermined ;
4249
4250 {
4251#line 57
4252 if (ldv_mutex == 1) {
4253
4254 } else {
4255 {
4256#line 57
4257 ldv_blast_assert();
4258 }
4259 }
4260 {
4261#line 60
4262 nondetermined = __VERIFIER_nondet_int();
4263 }
4264#line 63
4265 if (nondetermined) {
4266#line 66
4267 ldv_mutex = 2;
4268#line 68
4269 return (0);
4270 } else {
4271#line 73
4272 return (-4);
4273 }
4274}
4275}
4276#line 78 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
4277int atomic_dec_and_mutex_lock(atomic_t *cnt , struct mutex *lock )
4278{ int atomic_value_after_dec ;
4279
4280 {
4281#line 83
4282 if (ldv_mutex == 1) {
4283
4284 } else {
4285 {
4286#line 83
4287 ldv_blast_assert();
4288 }
4289 }
4290 {
4291#line 86
4292 atomic_value_after_dec = __VERIFIER_nondet_int();
4293 }
4294#line 89
4295 if (atomic_value_after_dec == 0) {
4296#line 92
4297 ldv_mutex = 2;
4298#line 94
4299 return (1);
4300 } else {
4301
4302 }
4303#line 98
4304 return (0);
4305}
4306}
4307#line 103 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
4308void mutex_lock(struct mutex *lock )
4309{
4310
4311 {
4312#line 108
4313 if (ldv_mutex == 1) {
4314
4315 } else {
4316 {
4317#line 108
4318 ldv_blast_assert();
4319 }
4320 }
4321#line 110
4322 ldv_mutex = 2;
4323#line 111
4324 return;
4325}
4326}
4327#line 114 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
4328int mutex_trylock(struct mutex *lock )
4329{ int nondetermined ;
4330
4331 {
4332#line 121
4333 if (ldv_mutex == 1) {
4334
4335 } else {
4336 {
4337#line 121
4338 ldv_blast_assert();
4339 }
4340 }
4341 {
4342#line 124
4343 nondetermined = __VERIFIER_nondet_int();
4344 }
4345#line 127
4346 if (nondetermined) {
4347#line 130
4348 ldv_mutex = 2;
4349#line 132
4350 return (1);
4351 } else {
4352#line 137
4353 return (0);
4354 }
4355}
4356}
4357#line 142 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
4358void mutex_unlock(struct mutex *lock )
4359{
4360
4361 {
4362#line 147
4363 if (ldv_mutex == 2) {
4364
4365 } else {
4366 {
4367#line 147
4368 ldv_blast_assert();
4369 }
4370 }
4371#line 149
4372 ldv_mutex = 1;
4373#line 150
4374 return;
4375}
4376}
4377#line 153 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
4378void ldv_check_final_state(void)
4379{
4380
4381 {
4382#line 156
4383 if (ldv_mutex == 1) {
4384
4385 } else {
4386 {
4387#line 156
4388 ldv_blast_assert();
4389 }
4390 }
4391#line 157
4392 return;
4393}
4394}
4395#line 1653 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6264/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-wm831x.c.common.c"
4396long s__builtin_expect(long val , long res )
4397{
4398
4399 {
4400#line 1654
4401 return (val);
4402}
4403}