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