Attachment 599132 Details for Bug 841571 – preprocessed Monitor.i

preprocessed Monitor.i

Monitor.i (text/plain), 276.12 KB, created by Karsten Hopp on 2012-07-19 12:45:38 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Karsten Hopp

Created: 2012-07-19 12:45:38 UTC

Size: 276.12 KB

patch

obsolete

># 1 "Monitor.c"
># 1 "/builddir/build/BUILD/mdadm-3.2.5//"
># 1 "<Kommandozeile>"
># 1 "Monitor.c"
># 25 "Monitor.c"
># 1 "mdadm.h" 1
># 27 "mdadm.h"
># 1 "/usr/include/unistd.h" 1 3 4
># 25 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/features.h" 1 3 4
># 345 "/usr/include/features.h" 3 4
># 1 "/usr/include/stdc-predef.h" 1 3 4
># 346 "/usr/include/features.h" 2 3 4
># 375 "/usr/include/features.h" 3 4
># 1 "/usr/include/sys/cdefs.h" 1 3 4
># 387 "/usr/include/sys/cdefs.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 388 "/usr/include/sys/cdefs.h" 2 3 4
># 376 "/usr/include/features.h" 2 3 4
># 399 "/usr/include/features.h" 3 4
># 1 "/usr/include/gnu/stubs.h" 1 3 4
>
>
>
>
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 6 "/usr/include/gnu/stubs.h" 2 3 4
>
>
>
>
>
># 1 "/usr/include/gnu/stubs-64.h" 1 3 4
># 12 "/usr/include/gnu/stubs.h" 2 3 4
># 400 "/usr/include/features.h" 2 3 4
># 26 "/usr/include/unistd.h" 2 3 4
>
>
># 202 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/bits/posix_opt.h" 1 3 4
># 203 "/usr/include/unistd.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/environments.h" 1 3 4
># 22 "/usr/include/bits/environments.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 23 "/usr/include/bits/environments.h" 2 3 4
># 207 "/usr/include/unistd.h" 2 3 4
># 217 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/bits/types.h" 1 3 4
># 27 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 28 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned char __u_char;
>typedef unsigned short int __u_short;
>typedef unsigned int __u_int;
>typedef unsigned long int __u_long;
>
>
>typedef signed char __int8_t;
>typedef unsigned char __uint8_t;
>typedef signed short int __int16_t;
>typedef unsigned short int __uint16_t;
>typedef signed int __int32_t;
>typedef unsigned int __uint32_t;
>
>typedef signed long int __int64_t;
>typedef unsigned long int __uint64_t;
>
>
>
>
>
>
>
>typedef long int __quad_t;
>typedef unsigned long int __u_quad_t;
># 130 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/typesizes.h" 1 3 4
># 131 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned long int __dev_t;
>typedef unsigned int __uid_t;
>typedef unsigned int __gid_t;
>typedef unsigned long int __ino_t;
>typedef unsigned long int __ino64_t;
>typedef unsigned int __mode_t;
>typedef unsigned long int __nlink_t;
>typedef long int __off_t;
>typedef long int __off64_t;
>typedef int __pid_t;
>typedef struct { int __val[2]; } __fsid_t;
>typedef long int __clock_t;
>typedef unsigned long int __rlim_t;
>typedef unsigned long int __rlim64_t;
>typedef unsigned int __id_t;
>typedef long int __time_t;
>typedef unsigned int __useconds_t;
>typedef long int __suseconds_t;
>
>typedef int __daddr_t;
>typedef long int __swblk_t;
>typedef int __key_t;
>
>
>typedef int __clockid_t;
>
>
>typedef void * __timer_t;
>
>
>typedef long int __blksize_t;
>
>
>
>
>typedef long int __blkcnt_t;
>typedef long int __blkcnt64_t;
>
>
>typedef unsigned long int __fsblkcnt_t;
>typedef unsigned long int __fsblkcnt64_t;
>
>
>typedef unsigned long int __fsfilcnt_t;
>typedef unsigned long int __fsfilcnt64_t;
>
>
>typedef long int __fsword_t;
>
>typedef long int __ssize_t;
>
>
>typedef long int __syscall_slong_t;
>
>typedef unsigned long int __syscall_ulong_t;
>
>
>
>typedef __off64_t __loff_t;
>typedef __quad_t *__qaddr_t;
>typedef char *__caddr_t;
>
>
>typedef long int __intptr_t;
>
>
>typedef unsigned int __socklen_t;
># 218 "/usr/include/unistd.h" 2 3 4
>
>
>typedef __ssize_t ssize_t;
>
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stddef.h" 1 3 4
># 213 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stddef.h" 3 4
>typedef long unsigned int size_t;
># 227 "/usr/include/unistd.h" 2 3 4
>
>
>
>
>
>typedef __gid_t gid_t;
>
>
>
>
>typedef __uid_t uid_t;
>
>
>
>
>
>
>
>typedef __off64_t off_t;
>
>
>
>
>typedef __off64_t off64_t;
>
>
>
>
>typedef __useconds_t useconds_t;
>
>
>
>
>typedef __pid_t pid_t;
>
>
>
>
>
>
>typedef __intptr_t intptr_t;
>
>
>
>
>
>
>typedef __socklen_t socklen_t;
># 287 "/usr/include/unistd.h" 3 4
>extern int access (const char *__name, int __type) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int euidaccess (const char *__name, int __type)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int eaccess (const char *__name, int __type)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int faccessat (int __fd, const char *__file, int __type, int __flag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
># 337 "/usr/include/unistd.h" 3 4
>extern __off64_t lseek (int __fd, __off64_t __offset, int __whence) __asm__ ("" "lseek64") __attribute__ ((__nothrow__ , __leaf__))
>
>             ;
>
>
>
>
>
>extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int close (int __fd);
>
>
>
>
>
>
>extern ssize_t read (int __fd, void *__buf, size_t __nbytes) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern ssize_t write (int __fd, const void *__buf, size_t __n) __attribute__ ((__warn_unused_result__));
># 388 "/usr/include/unistd.h" 3 4
>extern ssize_t pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64")
>
>               __attribute__ ((__warn_unused_result__));
>extern ssize_t pwrite (int __fd, const void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pwrite64")
>
>                __attribute__ ((__warn_unused_result__));
># 404 "/usr/include/unistd.h" 3 4
>extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
>   __off64_t __offset) __attribute__ ((__warn_unused_result__));
>
>
>extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
>    __off64_t __offset) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern int pipe (int __pipedes[2]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int pipe2 (int __pipedes[2], int __flags) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 432 "/usr/include/unistd.h" 3 4
>extern unsigned int alarm (unsigned int __seconds) __attribute__ ((__nothrow__ , __leaf__));
># 444 "/usr/include/unistd.h" 3 4
>extern unsigned int sleep (unsigned int __seconds);
>
>
>
>
>
>
>
>extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int usleep (__useconds_t __useconds);
># 469 "/usr/include/unistd.h" 3 4
>extern int pause (void);
>
>
>
>extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int fchown (int __fd, __uid_t __owner, __gid_t __group) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern int fchownat (int __fd, const char *__file, __uid_t __owner,
>       __gid_t __group, int __flag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int chdir (const char *__path) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int fchdir (int __fd) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 511 "/usr/include/unistd.h" 3 4
>extern char *getcwd (char *__buf, size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern char *get_current_dir_name (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern char *getwd (char *__buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int dup (int __fd) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>extern int dup2 (int __fd, int __fd2) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int dup3 (int __fd, int __fd2, int __flags) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern char **__environ;
>
>extern char **environ;
>
>
>
>
>
>extern int execve (const char *__path, char *const __argv[],
>     char *const __envp[]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern int execv (const char *__path, char *const __argv[])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int execle (const char *__path, const char *__arg, ...)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int execl (const char *__path, const char *__arg, ...)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int execvp (const char *__file, char *const __argv[])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int execlp (const char *__file, const char *__arg, ...)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int execvpe (const char *__file, char *const __argv[],
>      char *const __envp[])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int nice (int __inc) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern void _exit (int __status) __attribute__ ((__noreturn__));
>
>
>
>
>
># 1 "/usr/include/bits/confname.h" 1 3 4
># 25 "/usr/include/bits/confname.h" 3 4
>enum
>  {
>    _PC_LINK_MAX,
>
>    _PC_MAX_CANON,
>
>    _PC_MAX_INPUT,
>
>    _PC_NAME_MAX,
>
>    _PC_PATH_MAX,
>
>    _PC_PIPE_BUF,
>
>    _PC_CHOWN_RESTRICTED,
>
>    _PC_NO_TRUNC,
>
>    _PC_VDISABLE,
>
>    _PC_SYNC_IO,
>
>    _PC_ASYNC_IO,
>
>    _PC_PRIO_IO,
>
>    _PC_SOCK_MAXBUF,
>
>    _PC_FILESIZEBITS,
>
>    _PC_REC_INCR_XFER_SIZE,
>
>    _PC_REC_MAX_XFER_SIZE,
>
>    _PC_REC_MIN_XFER_SIZE,
>
>    _PC_REC_XFER_ALIGN,
>
>    _PC_ALLOC_SIZE_MIN,
>
>    _PC_SYMLINK_MAX,
>
>    _PC_2_SYMLINKS
>
>  };
>
>
>enum
>  {
>    _SC_ARG_MAX,
>
>    _SC_CHILD_MAX,
>
>    _SC_CLK_TCK,
>
>    _SC_NGROUPS_MAX,
>
>    _SC_OPEN_MAX,
>
>    _SC_STREAM_MAX,
>
>    _SC_TZNAME_MAX,
>
>    _SC_JOB_CONTROL,
>
>    _SC_SAVED_IDS,
>
>    _SC_REALTIME_SIGNALS,
>
>    _SC_PRIORITY_SCHEDULING,
>
>    _SC_TIMERS,
>
>    _SC_ASYNCHRONOUS_IO,
>
>    _SC_PRIORITIZED_IO,
>
>    _SC_SYNCHRONIZED_IO,
>
>    _SC_FSYNC,
>
>    _SC_MAPPED_FILES,
>
>    _SC_MEMLOCK,
>
>    _SC_MEMLOCK_RANGE,
>
>    _SC_MEMORY_PROTECTION,
>
>    _SC_MESSAGE_PASSING,
>
>    _SC_SEMAPHORES,
>
>    _SC_SHARED_MEMORY_OBJECTS,
>
>    _SC_AIO_LISTIO_MAX,
>
>    _SC_AIO_MAX,
>
>    _SC_AIO_PRIO_DELTA_MAX,
>
>    _SC_DELAYTIMER_MAX,
>
>    _SC_MQ_OPEN_MAX,
>
>    _SC_MQ_PRIO_MAX,
>
>    _SC_VERSION,
>
>    _SC_PAGESIZE,
>
>
>    _SC_RTSIG_MAX,
>
>    _SC_SEM_NSEMS_MAX,
>
>    _SC_SEM_VALUE_MAX,
>
>    _SC_SIGQUEUE_MAX,
>
>    _SC_TIMER_MAX,
>
>
>
>
>    _SC_BC_BASE_MAX,
>
>    _SC_BC_DIM_MAX,
>
>    _SC_BC_SCALE_MAX,
>
>    _SC_BC_STRING_MAX,
>
>    _SC_COLL_WEIGHTS_MAX,
>
>    _SC_EQUIV_CLASS_MAX,
>
>    _SC_EXPR_NEST_MAX,
>
>    _SC_LINE_MAX,
>
>    _SC_RE_DUP_MAX,
>
>    _SC_CHARCLASS_NAME_MAX,
>
>
>    _SC_2_VERSION,
>
>    _SC_2_C_BIND,
>
>    _SC_2_C_DEV,
>
>    _SC_2_FORT_DEV,
>
>    _SC_2_FORT_RUN,
>
>    _SC_2_SW_DEV,
>
>    _SC_2_LOCALEDEF,
>
>
>    _SC_PII,
>
>    _SC_PII_XTI,
>
>    _SC_PII_SOCKET,
>
>    _SC_PII_INTERNET,
>
>    _SC_PII_OSI,
>
>    _SC_POLL,
>
>    _SC_SELECT,
>
>    _SC_UIO_MAXIOV,
>
>    _SC_IOV_MAX = _SC_UIO_MAXIOV,
>
>    _SC_PII_INTERNET_STREAM,
>
>    _SC_PII_INTERNET_DGRAM,
>
>    _SC_PII_OSI_COTS,
>
>    _SC_PII_OSI_CLTS,
>
>    _SC_PII_OSI_M,
>
>    _SC_T_IOV_MAX,
>
>
>
>    _SC_THREADS,
>
>    _SC_THREAD_SAFE_FUNCTIONS,
>
>    _SC_GETGR_R_SIZE_MAX,
>
>    _SC_GETPW_R_SIZE_MAX,
>
>    _SC_LOGIN_NAME_MAX,
>
>    _SC_TTY_NAME_MAX,
>
>    _SC_THREAD_DESTRUCTOR_ITERATIONS,
>
>    _SC_THREAD_KEYS_MAX,
>
>    _SC_THREAD_STACK_MIN,
>
>    _SC_THREAD_THREADS_MAX,
>
>    _SC_THREAD_ATTR_STACKADDR,
>
>    _SC_THREAD_ATTR_STACKSIZE,
>
>    _SC_THREAD_PRIORITY_SCHEDULING,
>
>    _SC_THREAD_PRIO_INHERIT,
>
>    _SC_THREAD_PRIO_PROTECT,
>
>    _SC_THREAD_PROCESS_SHARED,
>
>
>    _SC_NPROCESSORS_CONF,
>
>    _SC_NPROCESSORS_ONLN,
>
>    _SC_PHYS_PAGES,
>
>    _SC_AVPHYS_PAGES,
>
>    _SC_ATEXIT_MAX,
>
>    _SC_PASS_MAX,
>
>
>    _SC_XOPEN_VERSION,
>
>    _SC_XOPEN_XCU_VERSION,
>
>    _SC_XOPEN_UNIX,
>
>    _SC_XOPEN_CRYPT,
>
>    _SC_XOPEN_ENH_I18N,
>
>    _SC_XOPEN_SHM,
>
>
>    _SC_2_CHAR_TERM,
>
>    _SC_2_C_VERSION,
>
>    _SC_2_UPE,
>
>
>    _SC_XOPEN_XPG2,
>
>    _SC_XOPEN_XPG3,
>
>    _SC_XOPEN_XPG4,
>
>
>    _SC_CHAR_BIT,
>
>    _SC_CHAR_MAX,
>
>    _SC_CHAR_MIN,
>
>    _SC_INT_MAX,
>
>    _SC_INT_MIN,
>
>    _SC_LONG_BIT,
>
>    _SC_WORD_BIT,
>
>    _SC_MB_LEN_MAX,
>
>    _SC_NZERO,
>
>    _SC_SSIZE_MAX,
>
>    _SC_SCHAR_MAX,
>
>    _SC_SCHAR_MIN,
>
>    _SC_SHRT_MAX,
>
>    _SC_SHRT_MIN,
>
>    _SC_UCHAR_MAX,
>
>    _SC_UINT_MAX,
>
>    _SC_ULONG_MAX,
>
>    _SC_USHRT_MAX,
>
>
>    _SC_NL_ARGMAX,
>
>    _SC_NL_LANGMAX,
>
>    _SC_NL_MSGMAX,
>
>    _SC_NL_NMAX,
>
>    _SC_NL_SETMAX,
>
>    _SC_NL_TEXTMAX,
>
>
>    _SC_XBS5_ILP32_OFF32,
>
>    _SC_XBS5_ILP32_OFFBIG,
>
>    _SC_XBS5_LP64_OFF64,
>
>    _SC_XBS5_LPBIG_OFFBIG,
>
>
>    _SC_XOPEN_LEGACY,
>
>    _SC_XOPEN_REALTIME,
>
>    _SC_XOPEN_REALTIME_THREADS,
>
>
>    _SC_ADVISORY_INFO,
>
>    _SC_BARRIERS,
>
>    _SC_BASE,
>
>    _SC_C_LANG_SUPPORT,
>
>    _SC_C_LANG_SUPPORT_R,
>
>    _SC_CLOCK_SELECTION,
>
>    _SC_CPUTIME,
>
>    _SC_THREAD_CPUTIME,
>
>    _SC_DEVICE_IO,
>
>    _SC_DEVICE_SPECIFIC,
>
>    _SC_DEVICE_SPECIFIC_R,
>
>    _SC_FD_MGMT,
>
>    _SC_FIFO,
>
>    _SC_PIPE,
>
>    _SC_FILE_ATTRIBUTES,
>
>    _SC_FILE_LOCKING,
>
>    _SC_FILE_SYSTEM,
>
>    _SC_MONOTONIC_CLOCK,
>
>    _SC_MULTI_PROCESS,
>
>    _SC_SINGLE_PROCESS,
>
>    _SC_NETWORKING,
>
>    _SC_READER_WRITER_LOCKS,
>
>    _SC_SPIN_LOCKS,
>
>    _SC_REGEXP,
>
>    _SC_REGEX_VERSION,
>
>    _SC_SHELL,
>
>    _SC_SIGNALS,
>
>    _SC_SPAWN,
>
>    _SC_SPORADIC_SERVER,
>
>    _SC_THREAD_SPORADIC_SERVER,
>
>    _SC_SYSTEM_DATABASE,
>
>    _SC_SYSTEM_DATABASE_R,
>
>    _SC_TIMEOUTS,
>
>    _SC_TYPED_MEMORY_OBJECTS,
>
>    _SC_USER_GROUPS,
>
>    _SC_USER_GROUPS_R,
>
>    _SC_2_PBS,
>
>    _SC_2_PBS_ACCOUNTING,
>
>    _SC_2_PBS_LOCATE,
>
>    _SC_2_PBS_MESSAGE,
>
>    _SC_2_PBS_TRACK,
>
>    _SC_SYMLOOP_MAX,
>
>    _SC_STREAMS,
>
>    _SC_2_PBS_CHECKPOINT,
>
>
>    _SC_V6_ILP32_OFF32,
>
>    _SC_V6_ILP32_OFFBIG,
>
>    _SC_V6_LP64_OFF64,
>
>    _SC_V6_LPBIG_OFFBIG,
>
>
>    _SC_HOST_NAME_MAX,
>
>    _SC_TRACE,
>
>    _SC_TRACE_EVENT_FILTER,
>
>    _SC_TRACE_INHERIT,
>
>    _SC_TRACE_LOG,
>
>
>    _SC_LEVEL1_ICACHE_SIZE,
>
>    _SC_LEVEL1_ICACHE_ASSOC,
>
>    _SC_LEVEL1_ICACHE_LINESIZE,
>
>    _SC_LEVEL1_DCACHE_SIZE,
>
>    _SC_LEVEL1_DCACHE_ASSOC,
>
>    _SC_LEVEL1_DCACHE_LINESIZE,
>
>    _SC_LEVEL2_CACHE_SIZE,
>
>    _SC_LEVEL2_CACHE_ASSOC,
>
>    _SC_LEVEL2_CACHE_LINESIZE,
>
>    _SC_LEVEL3_CACHE_SIZE,
>
>    _SC_LEVEL3_CACHE_ASSOC,
>
>    _SC_LEVEL3_CACHE_LINESIZE,
>
>    _SC_LEVEL4_CACHE_SIZE,
>
>    _SC_LEVEL4_CACHE_ASSOC,
>
>    _SC_LEVEL4_CACHE_LINESIZE,
>
>
>
>    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
>
>    _SC_RAW_SOCKETS,
>
>
>    _SC_V7_ILP32_OFF32,
>
>    _SC_V7_ILP32_OFFBIG,
>
>    _SC_V7_LP64_OFF64,
>
>    _SC_V7_LPBIG_OFFBIG,
>
>
>    _SC_SS_REPL_MAX,
>
>
>    _SC_TRACE_EVENT_NAME_MAX,
>
>    _SC_TRACE_NAME_MAX,
>
>    _SC_TRACE_SYS_MAX,
>
>    _SC_TRACE_USER_EVENT_MAX,
>
>
>    _SC_XOPEN_STREAMS,
>
>
>    _SC_THREAD_ROBUST_PRIO_INHERIT,
>
>    _SC_THREAD_ROBUST_PRIO_PROTECT
>
>  };
>
>
>enum
>  {
>    _CS_PATH,
>
>
>    _CS_V6_WIDTH_RESTRICTED_ENVS,
>
>
>
>    _CS_GNU_LIBC_VERSION,
>
>    _CS_GNU_LIBPTHREAD_VERSION,
>
>
>    _CS_V5_WIDTH_RESTRICTED_ENVS,
>
>
>
>    _CS_V7_WIDTH_RESTRICTED_ENVS,
>
>
>
>    _CS_LFS_CFLAGS = 1000,
>
>    _CS_LFS_LDFLAGS,
>
>    _CS_LFS_LIBS,
>
>    _CS_LFS_LINTFLAGS,
>
>    _CS_LFS64_CFLAGS,
>
>    _CS_LFS64_LDFLAGS,
>
>    _CS_LFS64_LIBS,
>
>    _CS_LFS64_LINTFLAGS,
>
>
>    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
>
>    _CS_XBS5_ILP32_OFF32_LDFLAGS,
>
>    _CS_XBS5_ILP32_OFF32_LIBS,
>
>    _CS_XBS5_ILP32_OFF32_LINTFLAGS,
>
>    _CS_XBS5_ILP32_OFFBIG_CFLAGS,
>
>    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,
>
>    _CS_XBS5_ILP32_OFFBIG_LIBS,
>
>    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
>
>    _CS_XBS5_LP64_OFF64_CFLAGS,
>
>    _CS_XBS5_LP64_OFF64_LDFLAGS,
>
>    _CS_XBS5_LP64_OFF64_LIBS,
>
>    _CS_XBS5_LP64_OFF64_LINTFLAGS,
>
>    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,
>
>    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
>
>    _CS_XBS5_LPBIG_OFFBIG_LIBS,
>
>    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
>
>
>    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFF32_LIBS,
>
>    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
>
>    _CS_POSIX_V6_LP64_OFF64_CFLAGS,
>
>    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,
>
>    _CS_POSIX_V6_LP64_OFF64_LIBS,
>
>    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
>
>
>    _CS_POSIX_V7_ILP32_OFF32_CFLAGS,
>
>    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
>
>    _CS_POSIX_V7_ILP32_OFF32_LIBS,
>
>    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
>
>    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
>
>    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
>
>    _CS_POSIX_V7_ILP32_OFFBIG_LIBS,
>
>    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
>
>    _CS_POSIX_V7_LP64_OFF64_CFLAGS,
>
>    _CS_POSIX_V7_LP64_OFF64_LDFLAGS,
>
>    _CS_POSIX_V7_LP64_OFF64_LIBS,
>
>    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
>
>    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
>
>    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
>
>    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
>
>    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
>
>
>    _CS_V6_ENV,
>
>    _CS_V7_ENV
>
>  };
># 610 "/usr/include/unistd.h" 2 3 4
>
>
>extern long int pathconf (const char *__path, int __name)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int fpathconf (int __fd, int __name) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long int sysconf (int __name) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern size_t confstr (int __name, char *__buf, size_t __len) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern __pid_t getpid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __pid_t getppid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern __pid_t getpgrp (void) __attribute__ ((__nothrow__ , __leaf__));
># 646 "/usr/include/unistd.h" 3 4
>extern __pid_t __getpgid (__pid_t __pid) __attribute__ ((__nothrow__ , __leaf__));
>
>extern __pid_t getpgid (__pid_t __pid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int setpgid (__pid_t __pid, __pid_t __pgid) __attribute__ ((__nothrow__ , __leaf__));
># 672 "/usr/include/unistd.h" 3 4
>extern int setpgrp (void) __attribute__ ((__nothrow__ , __leaf__));
># 689 "/usr/include/unistd.h" 3 4
>extern __pid_t setsid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern __pid_t getsid (__pid_t __pid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern __uid_t getuid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __uid_t geteuid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __gid_t getgid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __gid_t getegid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int getgroups (int __size, __gid_t __list[]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int group_member (__gid_t __gid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int setuid (__uid_t __uid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int setreuid (__uid_t __ruid, __uid_t __euid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int seteuid (__uid_t __uid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int setgid (__gid_t __gid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int setregid (__gid_t __rgid, __gid_t __egid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int setegid (__gid_t __gid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern __pid_t fork (void) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern __pid_t vfork (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern char *ttyname (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int isatty (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int ttyslot (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int link (const char *__from, const char *__to)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int linkat (int __fromfd, const char *__from, int __tofd,
>     const char *__to, int __flags)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int symlink (const char *__from, const char *__to)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern ssize_t readlink (const char *__restrict __path,
>    char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int symlinkat (const char *__from, int __tofd,
>        const char *__to) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));
>
>
>extern ssize_t readlinkat (int __fd, const char *__restrict __path,
>      char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int unlink (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int unlinkat (int __fd, const char *__name, int __flag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>extern int rmdir (const char *__path) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern __pid_t tcgetpgrp (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern char *getlogin (void);
>
>
>
>
>
>
>
>extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int setlogin (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 893 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/getopt.h" 1 3 4
># 58 "/usr/include/getopt.h" 3 4
>extern char *optarg;
># 72 "/usr/include/getopt.h" 3 4
>extern int optind;
>
>
>
>
>extern int opterr;
>
>
>
>extern int optopt;
># 151 "/usr/include/getopt.h" 3 4
>extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
>       __attribute__ ((__nothrow__ , __leaf__));
># 894 "/usr/include/unistd.h" 2 3 4
>
>
>
>
>
>
>
>extern int gethostname (char *__name, size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sethostname (const char *__name, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int sethostid (long int __id) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int getdomainname (char *__name, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>extern int setdomainname (const char *__name, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int vhangup (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int revoke (const char *__file) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern int profil (unsigned short int *__sample_buffer, size_t __size,
>     size_t __offset, unsigned int __scale)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int acct (const char *__name) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern char *getusershell (void) __attribute__ ((__nothrow__ , __leaf__));
>extern void endusershell (void) __attribute__ ((__nothrow__ , __leaf__));
>extern void setusershell (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int daemon (int __nochdir, int __noclose) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern int chroot (const char *__path) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int fsync (int __fd);
>
>
>
>
>
>extern int syncfs (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long int gethostid (void);
>
>
>extern void sync (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int getpagesize (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>extern int getdtablesize (void) __attribute__ ((__nothrow__ , __leaf__));
># 1019 "/usr/include/unistd.h" 3 4
>extern int truncate (const char *__file, __off64_t __length) __asm__ ("" "truncate64") __attribute__ ((__nothrow__ , __leaf__))
>
>                  __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int truncate64 (const char *__file, __off64_t __length)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 1041 "/usr/include/unistd.h" 3 4
>extern int ftruncate (int __fd, __off64_t __length) __asm__ ("" "ftruncate64") __attribute__ ((__nothrow__ , __leaf__))
>                   __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int ftruncate64 (int __fd, __off64_t __length) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 1059 "/usr/include/unistd.h" 3 4
>extern int brk (void *__addr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern void *sbrk (intptr_t __delta) __attribute__ ((__nothrow__ , __leaf__));
># 1080 "/usr/include/unistd.h" 3 4
>extern long int syscall (long int __sysno, ...) __attribute__ ((__nothrow__ , __leaf__));
># 1106 "/usr/include/unistd.h" 3 4
>extern int lockf (int __fd, int __cmd, __off64_t __len) __asm__ ("" "lockf64")
>                  __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int lockf64 (int __fd, int __cmd, __off64_t __len) __attribute__ ((__warn_unused_result__));
># 1134 "/usr/include/unistd.h" 3 4
>extern int fdatasync (int __fildes);
>
>
>
>
>
>
>
>extern char *crypt (const char *__key, const char *__salt)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern void encrypt (char *__block, int __edflag) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern void swab (const void *__restrict __from, void *__restrict __to,
>    ssize_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
># 1169 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/bits/unistd.h" 1 3 4
># 23 "/usr/include/bits/unistd.h" 3 4
>extern ssize_t __read_chk (int __fd, void *__buf, size_t __nbytes,
>      size_t __buflen) __attribute__ ((__warn_unused_result__));
>extern ssize_t __read_alias (int __fd, void *__buf, size_t __nbytes) __asm__ ("" "read")
>                               __attribute__ ((__warn_unused_result__));
>extern ssize_t __read_chk_warn (int __fd, void *__buf, size_t __nbytes, size_t __buflen) __asm__ ("" "__read_chk")
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("read called with bigger length than size of " "the destination buffer")))
>                                  ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
>read (int __fd, void *__buf, size_t __nbytes)
>{
>  if (__builtin_object_size (__buf, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__nbytes))
> return __read_chk (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));
>
>      if (__nbytes > __builtin_object_size (__buf, 0))
> return __read_chk_warn (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));
>    }
>  return __read_alias (__fd, __buf, __nbytes);
>}
>
>
>extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes,
>       __off_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
>extern ssize_t __pread64_chk (int __fd, void *__buf, size_t __nbytes,
>         __off64_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
>extern ssize_t __pread_alias (int __fd, void *__buf, size_t __nbytes, __off_t __offset) __asm__ ("" "pread")
>
>                                 __attribute__ ((__warn_unused_result__));
>extern ssize_t __pread64_alias (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64")
>
>                                     __attribute__ ((__warn_unused_result__));
>extern ssize_t __pread_chk_warn (int __fd, void *__buf, size_t __nbytes, __off_t __offset, size_t __bufsize) __asm__ ("" "__pread_chk")
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread called with bigger length than size of " "the destination buffer")))
>                                  ;
>extern ssize_t __pread64_chk_warn (int __fd, void *__buf, size_t __nbytes, __off64_t __offset, size_t __bufsize) __asm__ ("" "__pread64_chk")
>
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread64 called with bigger length than size of " "the destination buffer")))
>                                  ;
># 86 "/usr/include/bits/unistd.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
>pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
>{
>  if (__builtin_object_size (__buf, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__nbytes))
> return __pread64_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));
>
>      if ( __nbytes > __builtin_object_size (__buf, 0))
> return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
>       __builtin_object_size (__buf, 0));
>    }
>
>  return __pread64_alias (__fd, __buf, __nbytes, __offset);
>}
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
>pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
>{
>  if (__builtin_object_size (__buf, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__nbytes))
> return __pread64_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));
>
>      if ( __nbytes > __builtin_object_size (__buf, 0))
> return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
>       __builtin_object_size (__buf, 0));
>    }
>
>  return __pread64_alias (__fd, __buf, __nbytes, __offset);
>}
>
>
>
>
>extern ssize_t __readlink_chk (const char *__restrict __path,
>          char *__restrict __buf, size_t __len,
>          size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
>extern ssize_t __readlink_alias (const char *__restrict __path, char *__restrict __buf, size_t __len) __asm__ ("" "readlink") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
>extern ssize_t __readlink_chk_warn (const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) __asm__ ("" "__readlink_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlink called with bigger length " "than size of destination buffer")))
>                                         ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) ssize_t
>__attribute__ ((__nothrow__ , __leaf__)) readlink (const char *__restrict __path, char *__restrict __buf, size_t __len)
>
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __readlink_chk (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
>
>      if ( __len > __builtin_object_size (__buf, 2 > 1))
> return __readlink_chk_warn (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __readlink_alias (__path, __buf, __len);
>}
>
>
>
>extern ssize_t __readlinkat_chk (int __fd, const char *__restrict __path,
>     char *__restrict __buf, size_t __len,
>     size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
>extern ssize_t __readlinkat_alias (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len) __asm__ ("" "readlinkat") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
>extern ssize_t __readlinkat_chk_warn (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) __asm__ ("" "__readlinkat_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlinkat called with bigger " "length than size of destination " "buffer")))
>
>                ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) ssize_t
>__attribute__ ((__nothrow__ , __leaf__)) readlinkat (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len)
>
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __readlinkat_chk (__fd, __path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
>
>      if (__len > __builtin_object_size (__buf, 2 > 1))
> return __readlinkat_chk_warn (__fd, __path, __buf, __len,
>          __builtin_object_size (__buf, 2 > 1));
>    }
>  return __readlinkat_alias (__fd, __path, __buf, __len);
>}
>
>
>extern char *__getcwd_chk (char *__buf, size_t __size, size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern char *__getcwd_alias (char *__buf, size_t __size) __asm__ ("" "getcwd") __attribute__ ((__nothrow__ , __leaf__))
>                                              __attribute__ ((__warn_unused_result__));
>extern char *__getcwd_chk_warn (char *__buf, size_t __size, size_t __buflen) __asm__ ("" "__getcwd_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getcwd caller with bigger length than size of " "destination buffer")))
>                              ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) getcwd (char *__buf, size_t __size)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__size))
> return __getcwd_chk (__buf, __size, __builtin_object_size (__buf, 2 > 1));
>
>      if (__size > __builtin_object_size (__buf, 2 > 1))
> return __getcwd_chk_warn (__buf, __size, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __getcwd_alias (__buf, __size);
>}
>
>
>extern char *__getwd_chk (char *__buf, size_t buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>extern char *__getwd_warn (char *__buf) __asm__ ("" "getwd") __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("please use getcwd instead, as getwd " "doesn't specify buffer size")))
>                                         ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) getwd (char *__buf)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    return __getwd_chk (__buf, __builtin_object_size (__buf, 2 > 1));
>  return __getwd_warn (__buf);
>}
>
>
>extern size_t __confstr_chk (int __name, char *__buf, size_t __len,
>        size_t __buflen) __attribute__ ((__nothrow__ , __leaf__));
>extern size_t __confstr_alias (int __name, char *__buf, size_t __len) __asm__ ("" "confstr") __attribute__ ((__nothrow__ , __leaf__))
>                             ;
>extern size_t __confstr_chk_warn (int __name, char *__buf, size_t __len, size_t __buflen) __asm__ ("" "__confstr_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__((__warning__ ("confstr called with bigger length than size of destination " "buffer")))
>            ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) size_t
>__attribute__ ((__nothrow__ , __leaf__)) confstr (int __name, char *__buf, size_t __len)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __confstr_chk (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));
>
>      if (__builtin_object_size (__buf, 2 > 1) < __len)
> return __confstr_chk_warn (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __confstr_alias (__name, __buf, __len);
>}
>
>
>extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern int __getgroups_alias (int __size, __gid_t __list[]) __asm__ ("" "getgroups") __attribute__ ((__nothrow__ , __leaf__))
>                 __attribute__ ((__warn_unused_result__));
>extern int __getgroups_chk_warn (int __size, __gid_t __list[], size_t __listlen) __asm__ ("" "__getgroups_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getgroups called with bigger group count than what " "can fit into destination buffer")))
>                                           ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) getgroups (int __size, __gid_t __list[])
>{
>  if (__builtin_object_size (__list, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__size) || __size < 0)
> return __getgroups_chk (__size, __list, __builtin_object_size (__list, 2 > 1));
>
>      if (__size * sizeof (__gid_t) > __builtin_object_size (__list, 2 > 1))
> return __getgroups_chk_warn (__size, __list, __builtin_object_size (__list, 2 > 1));
>    }
>  return __getgroups_alias (__size, __list);
>}
>
>
>extern int __ttyname_r_chk (int __fd, char *__buf, size_t __buflen,
>       size_t __nreal) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>extern int __ttyname_r_alias (int __fd, char *__buf, size_t __buflen) __asm__ ("" "ttyname_r") __attribute__ ((__nothrow__ , __leaf__))
>
>     __attribute__ ((__nonnull__ (2)));
>extern int __ttyname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__ttyname_r_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ttyname_r called with bigger buflen than " "size of destination buffer")))
>                                  ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) ttyname_r (int __fd, char *__buf, size_t __buflen)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __ttyname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __ttyname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __ttyname_r_alias (__fd, __buf, __buflen);
>}
>
>
>
>extern int __getlogin_r_chk (char *__buf, size_t __buflen, size_t __nreal)
>     __attribute__ ((__nonnull__ (1)));
>extern int __getlogin_r_alias (char *__buf, size_t __buflen) __asm__ ("" "getlogin_r")
>                     __attribute__ ((__nonnull__ (1)));
>extern int __getlogin_r_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__getlogin_r_chk")
>
>
>     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("getlogin_r called with bigger buflen than " "size of destination buffer")))
>                                  ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>getlogin_r (char *__buf, size_t __buflen)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __getlogin_r_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __getlogin_r_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __getlogin_r_alias (__buf, __buflen);
>}
>
>
>
>
>extern int __gethostname_chk (char *__buf, size_t __buflen, size_t __nreal)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>extern int __gethostname_alias (char *__buf, size_t __buflen) __asm__ ("" "gethostname") __attribute__ ((__nothrow__ , __leaf__))
>                   __attribute__ ((__nonnull__ (1)));
>extern int __gethostname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__gethostname_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("gethostname called with bigger buflen than " "size of destination buffer")))
>                                  ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) gethostname (char *__buf, size_t __buflen)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __gethostname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __gethostname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __gethostname_alias (__buf, __buflen);
>}
>
>
>
>
>extern int __getdomainname_chk (char *__buf, size_t __buflen, size_t __nreal)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>extern int __getdomainname_alias (char *__buf, size_t __buflen) __asm__ ("" "getdomainname") __attribute__ ((__nothrow__ , __leaf__))
>
>                     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>extern int __getdomainname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__getdomainname_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getdomainname called with bigger " "buflen than size of destination " "buffer")))
>
>                    ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) getdomainname (char *__buf, size_t __buflen)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __getdomainname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __getdomainname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __getdomainname_alias (__buf, __buflen);
>}
># 1170 "/usr/include/unistd.h" 2 3 4
>
>
>
># 28 "mdadm.h" 2
>
>extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence);
>
>
>
>
>
>
># 1 "/usr/include/sys/types.h" 1 3 4
># 27 "/usr/include/sys/types.h" 3 4
>
>
>
>
>
>
>typedef __u_char u_char;
>typedef __u_short u_short;
>typedef __u_int u_int;
>typedef __u_long u_long;
>typedef __quad_t quad_t;
>typedef __u_quad_t u_quad_t;
>typedef __fsid_t fsid_t;
>
>
>
>
>typedef __loff_t loff_t;
>
>
>
>
>
>typedef __ino64_t ino_t;
>
>
>
>
>typedef __ino64_t ino64_t;
>
>
>
>
>typedef __dev_t dev_t;
># 70 "/usr/include/sys/types.h" 3 4
>typedef __mode_t mode_t;
>
>
>
>
>typedef __nlink_t nlink_t;
># 104 "/usr/include/sys/types.h" 3 4
>typedef __id_t id_t;
># 115 "/usr/include/sys/types.h" 3 4
>typedef __daddr_t daddr_t;
>typedef __caddr_t caddr_t;
>
>
>
>
>
>typedef __key_t key_t;
># 132 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 57 "/usr/include/time.h" 3 4
>
>
>typedef __clock_t clock_t;
>
>
>
># 73 "/usr/include/time.h" 3 4
>
>
>typedef __time_t time_t;
>
>
>
># 91 "/usr/include/time.h" 3 4
>typedef __clockid_t clockid_t;
># 103 "/usr/include/time.h" 3 4
>typedef __timer_t timer_t;
># 133 "/usr/include/sys/types.h" 2 3 4
>
>
>
>
>
>
>
>typedef __suseconds_t suseconds_t;
>
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stddef.h" 1 3 4
># 147 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef unsigned long int ulong;
>typedef unsigned short int ushort;
>typedef unsigned int uint;
># 194 "/usr/include/sys/types.h" 3 4
>typedef int int8_t __attribute__ ((__mode__ (__QI__)));
>typedef int int16_t __attribute__ ((__mode__ (__HI__)));
>typedef int int32_t __attribute__ ((__mode__ (__SI__)));
>typedef int int64_t __attribute__ ((__mode__ (__DI__)));
>
>
>typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
>typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
>
>typedef int register_t __attribute__ ((__mode__ (__word__)));
># 216 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/endian.h" 1 3 4
># 36 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/endian.h" 1 3 4
># 37 "/usr/include/endian.h" 2 3 4
># 60 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/byteswap.h" 1 3 4
># 33 "/usr/include/bits/byteswap.h" 3 4
># 1 "/usr/include/bits/byteswap-16.h" 1 3 4
># 34 "/usr/include/bits/byteswap.h" 2 3 4
># 42 "/usr/include/bits/byteswap.h" 3 4
>static __inline unsigned int
>__bswap_32 (unsigned int __bsx)
>{
>  return __builtin_bswap32 (__bsx);
>}
># 73 "/usr/include/bits/byteswap.h" 3 4
>static __inline unsigned long long int
>__bswap_64 (unsigned long long int __bsx)
>{
>  return __builtin_bswap64 (__bsx);
>}
># 61 "/usr/include/endian.h" 2 3 4
># 217 "/usr/include/sys/types.h" 2 3 4
>
>
># 1 "/usr/include/sys/select.h" 1 3 4
># 30 "/usr/include/sys/select.h" 3 4
># 1 "/usr/include/bits/select.h" 1 3 4
># 31 "/usr/include/sys/select.h" 2 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 23 "/usr/include/bits/sigset.h" 3 4
>typedef int __sig_atomic_t;
>
>
>
>
>typedef struct
>  {
>    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
>  } __sigset_t;
># 34 "/usr/include/sys/select.h" 2 3 4
>
>
>
>typedef __sigset_t sigset_t;
>
>
>
>
>
># 1 "/usr/include/time.h" 1 3 4
># 120 "/usr/include/time.h" 3 4
>struct timespec
>  {
>    __time_t tv_sec;
>    __syscall_slong_t tv_nsec;
>  };
># 44 "/usr/include/sys/select.h" 2 3 4
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 30 "/usr/include/bits/time.h" 3 4
>struct timeval
>  {
>    __time_t tv_sec;
>    __suseconds_t tv_usec;
>  };
># 46 "/usr/include/sys/select.h" 2 3 4
># 54 "/usr/include/sys/select.h" 3 4
>typedef long int __fd_mask;
># 64 "/usr/include/sys/select.h" 3 4
>typedef struct
>  {
>
>
>
>    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
>
>
>
>
>
>  } fd_set;
>
>
>
>
>
>
>typedef __fd_mask fd_mask;
># 96 "/usr/include/sys/select.h" 3 4
>
># 106 "/usr/include/sys/select.h" 3 4
>extern int select (int __nfds, fd_set *__restrict __readfds,
>     fd_set *__restrict __writefds,
>     fd_set *__restrict __exceptfds,
>     struct timeval *__restrict __timeout);
># 118 "/usr/include/sys/select.h" 3 4
>extern int pselect (int __nfds, fd_set *__restrict __readfds,
>      fd_set *__restrict __writefds,
>      fd_set *__restrict __exceptfds,
>      const struct timespec *__restrict __timeout,
>      const __sigset_t *__restrict __sigmask);
>
>
>
>
>
># 1 "/usr/include/bits/select2.h" 1 3 4
># 24 "/usr/include/bits/select2.h" 3 4
>extern long int __fdelt_chk (long int __d);
>extern long int __fdelt_warn (long int __d)
>  __attribute__((__warning__ ("bit outside of fd_set selected")));
># 129 "/usr/include/sys/select.h" 2 3 4
>
>
>
># 220 "/usr/include/sys/types.h" 2 3 4
>
>
># 1 "/usr/include/sys/sysmacros.h" 1 3 4
># 29 "/usr/include/sys/sysmacros.h" 3 4
>
>
>__extension__
>extern unsigned int gnu_dev_major (unsigned long long int __dev)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>__extension__
>extern unsigned int gnu_dev_minor (unsigned long long int __dev)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>__extension__
>extern unsigned long long int gnu_dev_makedev (unsigned int __major,
>            unsigned int __minor)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>__extension__ extern __inline __attribute__ ((__const__)) unsigned int
>__attribute__ ((__nothrow__ , __leaf__)) gnu_dev_major (unsigned long long int __dev)
>{
>  return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
>}
>
>__extension__ extern __inline __attribute__ ((__const__)) unsigned int
>__attribute__ ((__nothrow__ , __leaf__)) gnu_dev_minor (unsigned long long int __dev)
>{
>  return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
>}
>
>__extension__ extern __inline __attribute__ ((__const__)) unsigned long long int
>__attribute__ ((__nothrow__ , __leaf__)) gnu_dev_makedev (unsigned int __major, unsigned int __minor)
>{
>  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
>   | (((unsigned long long int) (__minor & ~0xff)) << 12)
>   | (((unsigned long long int) (__major & ~0xfff)) << 32));
>}
>
>
># 223 "/usr/include/sys/types.h" 2 3 4
>
>
>
>
>
>typedef __blksize_t blksize_t;
># 248 "/usr/include/sys/types.h" 3 4
>typedef __blkcnt64_t blkcnt_t;
>
>
>
>typedef __fsblkcnt64_t fsblkcnt_t;
>
>
>
>typedef __fsfilcnt64_t fsfilcnt_t;
>
>
>
>
>
>typedef __blkcnt64_t blkcnt64_t;
>typedef __fsblkcnt64_t fsblkcnt64_t;
>typedef __fsfilcnt64_t fsfilcnt64_t;
>
>
>
>
>
># 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
># 22 "/usr/include/bits/pthreadtypes.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 23 "/usr/include/bits/pthreadtypes.h" 2 3 4
># 49 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef unsigned long int pthread_t;
>
>
>union pthread_attr_t
>{
>  char __size[56];
>  long int __align;
>};
>
>typedef union pthread_attr_t pthread_attr_t;
>
>
>
>
>
>typedef struct __pthread_internal_list
>{
>  struct __pthread_internal_list *__prev;
>  struct __pthread_internal_list *__next;
>} __pthread_list_t;
># 79 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef union
>{
>  struct __pthread_mutex_s
>  {
>    int __lock;
>    unsigned int __count;
>    int __owner;
>
>    unsigned int __nusers;
>
>
>
>    int __kind;
>
>    int __spins;
>    __pthread_list_t __list;
># 104 "/usr/include/bits/pthreadtypes.h" 3 4
>  } __data;
>  char __size[40];
>  long int __align;
>} pthread_mutex_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_mutexattr_t;
>
>
>
>
>typedef union
>{
>  struct
>  {
>    int __lock;
>    unsigned int __futex;
>    __extension__ unsigned long long int __total_seq;
>    __extension__ unsigned long long int __wakeup_seq;
>    __extension__ unsigned long long int __woken_seq;
>    void *__mutex;
>    unsigned int __nwaiters;
>    unsigned int __broadcast_seq;
>  } __data;
>  char __size[48];
>  __extension__ long long int __align;
>} pthread_cond_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_condattr_t;
>
>
>
>typedef unsigned int pthread_key_t;
>
>
>
>typedef int pthread_once_t;
>
>
>
>
>
>typedef union
>{
>
>  struct
>  {
>    int __lock;
>    unsigned int __nr_readers;
>    unsigned int __readers_wakeup;
>    unsigned int __writer_wakeup;
>    unsigned int __nr_readers_queued;
>    unsigned int __nr_writers_queued;
>    int __writer;
>    int __shared;
>    unsigned long int __pad1;
>    unsigned long int __pad2;
>
>
>    unsigned int __flags;
>  } __data;
># 190 "/usr/include/bits/pthreadtypes.h" 3 4
>  char __size[56];
>  long int __align;
>} pthread_rwlock_t;
>
>typedef union
>{
>  char __size[8];
>  long int __align;
>} pthread_rwlockattr_t;
>
>
>
>
>
>typedef volatile int pthread_spinlock_t;
>
>
>
>
>typedef union
>{
>  char __size[32];
>  long int __align;
>} pthread_barrier_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_barrierattr_t;
># 271 "/usr/include/sys/types.h" 2 3 4
>
>
>
># 37 "mdadm.h" 2
># 1 "/usr/include/sys/stat.h" 1 3 4
># 38 "/usr/include/sys/stat.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 39 "/usr/include/sys/stat.h" 2 3 4
># 104 "/usr/include/sys/stat.h" 3 4
>
>
># 1 "/usr/include/bits/stat.h" 1 3 4
># 26 "/usr/include/bits/stat.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 27 "/usr/include/bits/stat.h" 2 3 4
># 142 "/usr/include/bits/stat.h" 3 4
>struct stat
>  {
>    __dev_t st_dev;
>
>
>
>    __ino64_t st_ino;
>
>    __nlink_t st_nlink;
>    __mode_t st_mode;
>    __uid_t st_uid;
>    __gid_t st_gid;
>    int __pad2;
>    __dev_t st_rdev;
>
>
>
>    __off64_t st_size;
>
>    __blksize_t st_blksize;
>
>
>
>
>    __blkcnt64_t st_blocks;
># 175 "/usr/include/bits/stat.h" 3 4
>    struct timespec st_atim;
>    struct timespec st_mtim;
>    struct timespec st_ctim;
># 189 "/usr/include/bits/stat.h" 3 4
>    unsigned long int __unused4;
>    unsigned long int __unused5;
>    unsigned long int __unused6;
>  };
>
>
>struct stat64
>  {
>    __dev_t st_dev;
>    __ino64_t st_ino;
>    __nlink_t st_nlink;
>    __mode_t st_mode;
>    __uid_t st_uid;
>    __gid_t st_gid;
>    int __pad2;
>    __dev_t st_rdev;
>    __off64_t st_size;
>    __blksize_t st_blksize;
>    __blkcnt64_t st_blocks;
>
>
>
>
>
>
>
>    struct timespec st_atim;
>    struct timespec st_mtim;
>    struct timespec st_ctim;
># 229 "/usr/include/bits/stat.h" 3 4
>    unsigned long int __unused4;
>    unsigned long int __unused5;
>    unsigned long int __unused6;
>  };
># 107 "/usr/include/sys/stat.h" 2 3 4
># 218 "/usr/include/sys/stat.h" 3 4
>extern int stat (const char *__restrict __file, struct stat *__restrict __buf) __asm__ ("" "stat64") __attribute__ ((__nothrow__ , __leaf__))
>
>     __attribute__ ((__nonnull__ (1, 2)));
>extern int fstat (int __fd, struct stat *__buf) __asm__ ("" "fstat64") __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>extern int stat64 (const char *__restrict __file,
>     struct stat64 *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int fstat64 (int __fd, struct stat64 *__buf) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
># 244 "/usr/include/sys/stat.h" 3 4
>extern int fstatat (int __fd, const char *__restrict __file, struct stat *__restrict __buf, int __flag) __asm__ ("" "fstatat64") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                 __attribute__ ((__nonnull__ (2, 3)));
>
>
>
>
>
>
>extern int fstatat64 (int __fd, const char *__restrict __file,
>        struct stat64 *__restrict __buf, int __flag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
># 268 "/usr/include/sys/stat.h" 3 4
>extern int lstat (const char *__restrict __file, struct stat *__restrict __buf) __asm__ ("" "lstat64") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int lstat64 (const char *__restrict __file,
>      struct stat64 *__restrict __buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int chmod (const char *__file, __mode_t __mode)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int lchmod (const char *__file, __mode_t __mode)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int fchmod (int __fd, __mode_t __mode) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int fchmodat (int __fd, const char *__file, __mode_t __mode,
>       int __flag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern __mode_t umask (__mode_t __mask) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern __mode_t getumask (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int mkdir (const char *__path, __mode_t __mode)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int mkdirat (int __fd, const char *__path, __mode_t __mode)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int mknodat (int __fd, const char *__path, __mode_t __mode,
>      __dev_t __dev) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int mkfifo (const char *__path, __mode_t __mode)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int mkfifoat (int __fd, const char *__path, __mode_t __mode)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int utimensat (int __fd, const char *__path,
>        const struct timespec __times[2],
>        int __flags)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern int futimens (int __fd, const struct timespec __times[2]) __attribute__ ((__nothrow__ , __leaf__));
># 411 "/usr/include/sys/stat.h" 3 4
>extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf) __asm__ ("" "__fxstat64") __attribute__ ((__nothrow__ , __leaf__))
>
>     __attribute__ ((__nonnull__ (3)));
>extern int __xstat (int __ver, const char *__filename, struct stat *__stat_buf) __asm__ ("" "__xstat64") __attribute__ ((__nothrow__ , __leaf__))
>
>     __attribute__ ((__nonnull__ (2, 3)));
>extern int __lxstat (int __ver, const char *__filename, struct stat *__stat_buf) __asm__ ("" "__lxstat64") __attribute__ ((__nothrow__ , __leaf__))
>
>     __attribute__ ((__nonnull__ (2, 3)));
>extern int __fxstatat (int __ver, int __fildes, const char *__filename, struct stat *__stat_buf, int __flag) __asm__ ("" "__fxstatat64") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                    __attribute__ ((__nonnull__ (3, 4)));
># 433 "/usr/include/sys/stat.h" 3 4
>extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3)));
>extern int __xstat64 (int __ver, const char *__filename,
>        struct stat64 *__stat_buf) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
>extern int __lxstat64 (int __ver, const char *__filename,
>         struct stat64 *__stat_buf) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
>extern int __fxstatat64 (int __ver, int __fildes, const char *__filename,
>    struct stat64 *__stat_buf, int __flag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4)));
>
>extern int __xmknod (int __ver, const char *__path, __mode_t __mode,
>       __dev_t *__dev) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4)));
>
>extern int __xmknodat (int __ver, int __fd, const char *__path,
>         __mode_t __mode, __dev_t *__dev)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 5)));
>
>
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) stat (const char *__path, struct stat *__statbuf)
>{
>  return __xstat (1, __path, __statbuf);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) lstat (const char *__path, struct stat *__statbuf)
>{
>  return __lxstat (1, __path, __statbuf);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) fstat (int __fd, struct stat *__statbuf)
>{
>  return __fxstat (1, __fd, __statbuf);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) fstatat (int __fd, const char *__filename, struct stat *__statbuf, int __flag)
>
>{
>  return __fxstatat (1, __fd, __filename, __statbuf, __flag);
>}
>
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) mknod (const char *__path, __mode_t __mode, __dev_t __dev)
>{
>  return __xmknod (1, __path, __mode, &__dev);
>}
>
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) mknodat (int __fd, const char *__path, __mode_t __mode, __dev_t __dev)
>
>{
>  return __xmknodat (1, __fd, __path, __mode, &__dev);
>}
>
>
>
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) stat64 (const char *__path, struct stat64 *__statbuf)
>{
>  return __xstat64 (1, __path, __statbuf);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) lstat64 (const char *__path, struct stat64 *__statbuf)
>{
>  return __lxstat64 (1, __path, __statbuf);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) fstat64 (int __fd, struct stat64 *__statbuf)
>{
>  return __fxstat64 (1, __fd, __statbuf);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) fstatat64 (int __fd, const char *__filename, struct stat64 *__statbuf, int __flag)
>
>{
>  return __fxstatat64 (1, __fd, __filename, __statbuf, __flag);
>}
>
>
>
>
>
>
>
># 38 "mdadm.h" 2
># 1 "/usr/include/stdlib.h" 1 3 4
># 32 "/usr/include/stdlib.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stddef.h" 1 3 4
># 325 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stddef.h" 3 4
>typedef int wchar_t;
># 33 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>
>
>
># 1 "/usr/include/bits/waitflags.h" 1 3 4
># 42 "/usr/include/stdlib.h" 2 3 4
># 1 "/usr/include/bits/waitstatus.h" 1 3 4
># 66 "/usr/include/bits/waitstatus.h" 3 4
>union wait
>  {
>    int w_status;
>    struct
>      {
>
>
>
>
>
>
>
> unsigned int:16;
> unsigned int __w_retcode:8;
> unsigned int __w_coredump:1;
> unsigned int __w_termsig:7;
>
>      } __wait_terminated;
>    struct
>      {
>
>
>
>
>
>
> unsigned int:16;
> unsigned int __w_stopsig:8;
> unsigned int __w_stopval:8;
>
>      } __wait_stopped;
>  };
># 43 "/usr/include/stdlib.h" 2 3 4
># 67 "/usr/include/stdlib.h" 3 4
>typedef union
>  {
>    union wait *__uptr;
>    int *__iptr;
>  } __WAIT_STATUS __attribute__ ((__transparent_union__));
># 95 "/usr/include/stdlib.h" 3 4
>
>
>typedef struct
>  {
>    int quot;
>    int rem;
>  } div_t;
>
>
>
>typedef struct
>  {
>    long int quot;
>    long int rem;
>  } ldiv_t;
>
>
>
>
>
>
>
>__extension__ typedef struct
>  {
>    long long int quot;
>    long long int rem;
>  } lldiv_t;
>
>
># 139 "/usr/include/stdlib.h" 3 4
>extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern double atof (const char *__nptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>extern int atoi (const char *__nptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>extern long int atol (const char *__nptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>__extension__ extern long long int atoll (const char *__nptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern double strtod (const char *__restrict __nptr,
>        char **__restrict __endptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern float strtof (const char *__restrict __nptr,
>       char **__restrict __endptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>extern long double strtold (const char *__restrict __nptr,
>       char **__restrict __endptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern long int strtol (const char *__restrict __nptr,
>   char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>extern unsigned long int strtoul (const char *__restrict __nptr,
>      char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>__extension__
>extern long long int strtoq (const char *__restrict __nptr,
>        char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>__extension__
>extern unsigned long long int strtouq (const char *__restrict __nptr,
>           char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>__extension__
>extern long long int strtoll (const char *__restrict __nptr,
>         char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>__extension__
>extern unsigned long long int strtoull (const char *__restrict __nptr,
>     char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
># 235 "/usr/include/stdlib.h" 3 4
># 1 "/usr/include/xlocale.h" 1 3 4
># 27 "/usr/include/xlocale.h" 3 4
>typedef struct __locale_struct
>{
>
>  struct __locale_data *__locales[13];
>
>
>  const unsigned short int *__ctype_b;
>  const int *__ctype_tolower;
>  const int *__ctype_toupper;
>
>
>  const char *__names[13];
>} *__locale_t;
>
>
>typedef __locale_t locale_t;
># 236 "/usr/include/stdlib.h" 2 3 4
>
>
>
>extern long int strtol_l (const char *__restrict __nptr,
>     char **__restrict __endptr, int __base,
>     __locale_t __loc) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 4)));
>
>extern unsigned long int strtoul_l (const char *__restrict __nptr,
>        char **__restrict __endptr,
>        int __base, __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 4)));
>
>__extension__
>extern long long int strtoll_l (const char *__restrict __nptr,
>    char **__restrict __endptr, int __base,
>    __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 4)));
>
>__extension__
>extern unsigned long long int strtoull_l (const char *__restrict __nptr,
>       char **__restrict __endptr,
>       int __base, __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 4)));
>
>extern double strtod_l (const char *__restrict __nptr,
>   char **__restrict __endptr, __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>extern float strtof_l (const char *__restrict __nptr,
>         char **__restrict __endptr, __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>extern long double strtold_l (const char *__restrict __nptr,
>         char **__restrict __endptr,
>         __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>
>extern __inline double
>__attribute__ ((__nothrow__ , __leaf__)) atof (const char *__nptr)
>{
>  return strtod (__nptr, (char **) ((void *)0));
>}
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) atoi (const char *__nptr)
>{
>  return (int) strtol (__nptr, (char **) ((void *)0), 10);
>}
>extern __inline long int
>__attribute__ ((__nothrow__ , __leaf__)) atol (const char *__nptr)
>{
>  return strtol (__nptr, (char **) ((void *)0), 10);
>}
>
>
>
>
>__extension__ extern __inline long long int
>__attribute__ ((__nothrow__ , __leaf__)) atoll (const char *__nptr)
>{
>  return strtoll (__nptr, (char **) ((void *)0), 10);
>}
>
># 310 "/usr/include/stdlib.h" 3 4
>extern char *l64a (long int __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>extern long int a64l (const char *__s)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 326 "/usr/include/stdlib.h" 3 4
>extern long int random (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern void srandom (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern char *initstate (unsigned int __seed, char *__statebuf,
>   size_t __statelen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>extern char *setstate (char *__statebuf) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>struct random_data
>  {
>    int32_t *fptr;
>    int32_t *rptr;
>    int32_t *state;
>    int rand_type;
>    int rand_deg;
>    int rand_sep;
>    int32_t *end_ptr;
>  };
>
>extern int random_r (struct random_data *__restrict __buf,
>       int32_t *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int srandom_r (unsigned int __seed, struct random_data *__buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
>   size_t __statelen,
>   struct random_data *__restrict __buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4)));
>
>extern int setstate_r (char *__restrict __statebuf,
>         struct random_data *__restrict __buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int rand (void) __attribute__ ((__nothrow__ , __leaf__));
>
>extern void srand (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern double drand48 (void) __attribute__ ((__nothrow__ , __leaf__));
>extern double erand48 (unsigned short int __xsubi[3]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int lrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
>extern long int nrand48 (unsigned short int __xsubi[3])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int mrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
>extern long int jrand48 (unsigned short int __xsubi[3])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern void srand48 (long int __seedval) __attribute__ ((__nothrow__ , __leaf__));
>extern unsigned short int *seed48 (unsigned short int __seed16v[3])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>extern void lcong48 (unsigned short int __param[7]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>struct drand48_data
>  {
>    unsigned short int __x[3];
>    unsigned short int __old_x[3];
>    unsigned short int __c;
>    unsigned short int __init;
>    unsigned long long int __a;
>  };
>
>
>extern int drand48_r (struct drand48_data *__restrict __buffer,
>        double *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int erand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        double *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int lrand48_r (struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int nrand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int mrand48_r (struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int jrand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>extern int seed48_r (unsigned short int __seed16v[3],
>       struct drand48_data *__buffer) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int lcong48_r (unsigned short int __param[7],
>        struct drand48_data *__buffer)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>
>
>
>extern void *malloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>extern void *calloc (size_t __nmemb, size_t __size)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>
>
>extern void *realloc (void *__ptr, size_t __size)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>extern void free (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern void cfree (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
># 1 "/usr/include/alloca.h" 1 3 4
># 24 "/usr/include/alloca.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stddef.h" 1 3 4
># 25 "/usr/include/alloca.h" 2 3 4
>
>
>
>
>
>
>
>extern void *alloca (size_t __size) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
># 497 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>extern void *valloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern void *aligned_alloc (size_t __alignment, size_t __size)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)) __attribute__ ((__malloc__, __alloc_size__ (2)));
>
>
>
>
>extern void abort (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
>extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int at_quick_exit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern void exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>extern void quick_exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>
>extern void _Exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>extern char *getenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern char *__secure_getenv (const char *__name)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int putenv (char *__string) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int setenv (const char *__name, const char *__value, int __replace)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>extern int unsetenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int clearenv (void) __attribute__ ((__nothrow__ , __leaf__));
># 608 "/usr/include/stdlib.h" 3 4
>extern char *mktemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 625 "/usr/include/stdlib.h" 3 4
>extern int mkstemp (char *__template) __asm__ ("" "mkstemp64")
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 647 "/usr/include/stdlib.h" 3 4
>extern int mkstemps (char *__template, int __suffixlen) __asm__ ("" "mkstemps64")
>                     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int mkstemps64 (char *__template, int __suffixlen)
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 665 "/usr/include/stdlib.h" 3 4
>extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 679 "/usr/include/stdlib.h" 3 4
>extern int mkostemp (char *__template, int __flags) __asm__ ("" "mkostemp64")
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 700 "/usr/include/stdlib.h" 3 4
>extern int mkostemps (char *__template, int __suffixlen, int __flags) __asm__ ("" "mkostemps64")
>
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>
>extern int system (const char *__command) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern char *canonicalize_file_name (const char *__name)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 736 "/usr/include/stdlib.h" 3 4
>extern char *realpath (const char *__restrict __name,
>         char *__restrict __resolved) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>typedef int (*__compar_fn_t) (const void *, const void *);
>
>
>typedef __compar_fn_t comparison_fn_t;
>
>
>
>typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
>
>
>
>
>
>extern void *bsearch (const void *__key, const void *__base,
>        size_t __nmemb, size_t __size, __compar_fn_t __compar)
>     __attribute__ ((__nonnull__ (1, 2, 5))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern void qsort (void *__base, size_t __nmemb, size_t __size,
>     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
>
>extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
>       __compar_d_fn_t __compar, void *__arg)
>  __attribute__ ((__nonnull__ (1, 4)));
>
>
>
>
>extern int abs (int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>extern long int labs (long int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
>
>
>__extension__ extern long long int llabs (long long int __x)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern div_t div (int __numer, int __denom)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>extern ldiv_t ldiv (long int __numer, long int __denom)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>__extension__ extern lldiv_t lldiv (long long int __numer,
>        long long int __denom)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
># 810 "/usr/include/stdlib.h" 3 4
>extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern char *gcvt (double __value, int __ndigit, char *__buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern char *qecvt (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>extern char *qfcvt (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>extern char *qgcvt (long double __value, int __ndigit, char *__buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign, char *__restrict __buf,
>     size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign, char *__restrict __buf,
>     size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>
>extern int qecvt_r (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign,
>      char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int qfcvt_r (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign,
>      char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>
>
>
>
>
>
>
>extern int mblen (const char *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>extern int mbtowc (wchar_t *__restrict __pwc,
>     const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>extern int wctomb (char *__s, wchar_t __wchar) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>extern size_t mbstowcs (wchar_t *__restrict __pwcs,
>   const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
>
>extern size_t wcstombs (char *__restrict __s,
>   const wchar_t *__restrict __pwcs, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern int rpmatch (const char *__response) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 898 "/usr/include/stdlib.h" 3 4
>extern int getsubopt (char **__restrict __optionp,
>        char *const *__restrict __tokens,
>        char **__restrict __valuep)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern void setkey (const char *__key) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int posix_openpt (int __oflag) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern int grantpt (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int unlockpt (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern char *ptsname (int __fd) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>extern int getpt (void);
>
>
>
>
>
>
>extern int getloadavg (double __loadavg[], int __nelem)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
># 1 "/usr/include/bits/stdlib.h" 1 3 4
># 23 "/usr/include/bits/stdlib.h" 3 4
>extern char *__realpath_chk (const char *__restrict __name,
>        char *__restrict __resolved,
>        size_t __resolvedlen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern char *__realpath_alias (const char *__restrict __name, char *__restrict __resolved) __asm__ ("" "realpath") __attribute__ ((__nothrow__ , __leaf__))
>
>                                                 __attribute__ ((__warn_unused_result__));
>extern char *__realpath_chk_warn (const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen) __asm__ ("" "__realpath_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                                                __attribute__ ((__warn_unused_result__))
>     __attribute__((__warning__ ("second argument of realpath must be either NULL or at " "least PATH_MAX bytes long buffer")))
>                                      ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) realpath (const char *__restrict __name, char *__restrict __resolved)
>{
>  if (__builtin_object_size (__resolved, 2 > 1) != (size_t) -1)
>    {
>
>
>
>
>      return __realpath_chk (__name, __resolved, __builtin_object_size (__resolved, 2 > 1));
>    }
>
>  return __realpath_alias (__name, __resolved);
>}
>
>
>extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen,
>       size_t __nreal) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>extern int __ptsname_r_alias (int __fd, char *__buf, size_t __buflen) __asm__ ("" "ptsname_r") __attribute__ ((__nothrow__ , __leaf__))
>
>     __attribute__ ((__nonnull__ (2)));
>extern int __ptsname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__ptsname_r_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ptsname_r called with buflen bigger than " "size of buf")))
>                   ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) ptsname_r (int __fd, char *__buf, size_t __buflen)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __ptsname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __ptsname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __ptsname_r_alias (__fd, __buf, __buflen);
>}
>
>
>extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen)
>  __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern int __wctomb_alias (char *__s, wchar_t __wchar) __asm__ ("" "wctomb") __attribute__ ((__nothrow__ , __leaf__))
>              __attribute__ ((__warn_unused_result__));
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) int
>__attribute__ ((__nothrow__ , __leaf__)) wctomb (char *__s, wchar_t __wchar)
>{
>
>
>
>
>
>
>
>  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 && 16 > __builtin_object_size (__s, 2 > 1))
>    return __wctomb_chk (__s, __wchar, __builtin_object_size (__s, 2 > 1));
>  return __wctomb_alias (__s, __wchar);
>}
>
>
>extern size_t __mbstowcs_chk (wchar_t *__restrict __dst,
>         const char *__restrict __src,
>         size_t __len, size_t __dstlen) __attribute__ ((__nothrow__ , __leaf__));
>extern size_t __mbstowcs_alias (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len) __asm__ ("" "mbstowcs") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                                  ;
>extern size_t __mbstowcs_chk_warn (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len, size_t __dstlen) __asm__ ("" "__mbstowcs_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__((__warning__ ("mbstowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
>                        ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) size_t
>__attribute__ ((__nothrow__ , __leaf__)) mbstowcs (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len)
>
>{
>  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __mbstowcs_chk (__dst, __src, __len,
>          __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
>
>      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
> return __mbstowcs_chk_warn (__dst, __src, __len,
>         __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
>    }
>  return __mbstowcs_alias (__dst, __src, __len);
>}
>
>
>extern size_t __wcstombs_chk (char *__restrict __dst,
>         const wchar_t *__restrict __src,
>         size_t __len, size_t __dstlen) __attribute__ ((__nothrow__ , __leaf__));
>extern size_t __wcstombs_alias (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len) __asm__ ("" "wcstombs") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                                  ;
>extern size_t __wcstombs_chk_warn (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len, size_t __dstlen) __asm__ ("" "__wcstombs_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__((__warning__ ("wcstombs called with dst buffer smaller than len")));
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) size_t
>__attribute__ ((__nothrow__ , __leaf__)) wcstombs (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len)
>
>{
>  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __wcstombs_chk (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
>      if (__len > __builtin_object_size (__dst, 2 > 1))
> return __wcstombs_chk_warn (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
>    }
>  return __wcstombs_alias (__dst, __src, __len);
>}
># 958 "/usr/include/stdlib.h" 2 3 4
># 966 "/usr/include/stdlib.h" 3 4
>
># 39 "mdadm.h" 2
># 1 "/usr/include/time.h" 1 3 4
># 29 "/usr/include/time.h" 3 4
>
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stddef.h" 1 3 4
># 38 "/usr/include/time.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 86 "/usr/include/bits/time.h" 3 4
># 1 "/usr/include/bits/timex.h" 1 3 4
># 25 "/usr/include/bits/timex.h" 3 4
>struct timex
>{
>  unsigned int modes;
>  __syscall_slong_t offset;
>  __syscall_slong_t freq;
>  __syscall_slong_t maxerror;
>  __syscall_slong_t esterror;
>  int status;
>  __syscall_slong_t constant;
>  __syscall_slong_t precision;
>  __syscall_slong_t tolerance;
>  struct timeval time;
>  __syscall_slong_t tick;
>  __syscall_slong_t ppsfreq;
>  __syscall_slong_t jitter;
>  int shift;
>  __syscall_slong_t stabil;
>  __syscall_slong_t jitcnt;
>  __syscall_slong_t calcnt;
>  __syscall_slong_t errcnt;
>  __syscall_slong_t stbcnt;
>
>  int tai;
>
>
>  int :32; int :32; int :32; int :32;
>  int :32; int :32; int :32; int :32;
>  int :32; int :32; int :32;
>};
># 87 "/usr/include/bits/time.h" 2 3 4
>
>
>
>
>extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) __attribute__ ((__nothrow__ , __leaf__));
>
>
># 42 "/usr/include/time.h" 2 3 4
># 131 "/usr/include/time.h" 3 4
>
>
>struct tm
>{
>  int tm_sec;
>  int tm_min;
>  int tm_hour;
>  int tm_mday;
>  int tm_mon;
>  int tm_year;
>  int tm_wday;
>  int tm_yday;
>  int tm_isdst;
>
>
>  long int tm_gmtoff;
>  const char *tm_zone;
>
>
>
>
>};
>
>
>
>
>
>
>
>
>struct itimerspec
>  {
>    struct timespec it_interval;
>    struct timespec it_value;
>  };
>
>
>struct sigevent;
># 186 "/usr/include/time.h" 3 4
>
>
>
>extern clock_t clock (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern time_t time (time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double difftime (time_t __time1, time_t __time0)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern time_t mktime (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern size_t strftime (char *__restrict __s, size_t __maxsize,
>   const char *__restrict __format,
>   const struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern char *strptime (const char *__restrict __s,
>         const char *__restrict __fmt, struct tm *__tp)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
>     const char *__restrict __format,
>     const struct tm *__restrict __tp,
>     __locale_t __loc) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern char *strptime_l (const char *__restrict __s,
>    const char *__restrict __fmt, struct tm *__tp,
>    __locale_t __loc) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern struct tm *gmtime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern struct tm *localtime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern struct tm *gmtime_r (const time_t *__restrict __timer,
>       struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern struct tm *localtime_r (const time_t *__restrict __timer,
>          struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern char *asctime (const struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern char *ctime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern char *asctime_r (const struct tm *__restrict __tp,
>   char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern char *ctime_r (const time_t *__restrict __timer,
>        char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern char *__tzname[2];
>extern int __daylight;
>extern long int __timezone;
>
>
>
>
>extern char *tzname[2];
>
>
>
>extern void tzset (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int daylight;
>extern long int timezone;
>
>
>
>
>
>extern int stime (const time_t *__when) __attribute__ ((__nothrow__ , __leaf__));
># 319 "/usr/include/time.h" 3 4
>extern time_t timegm (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern time_t timelocal (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int dysize (int __year) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
># 334 "/usr/include/time.h" 3 4
>extern int nanosleep (const struct timespec *__requested_time,
>        struct timespec *__remaining);
>
>
>
>extern int clock_getres (clockid_t __clock_id, struct timespec *__res) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int clock_nanosleep (clockid_t __clock_id, int __flags,
>       const struct timespec *__req,
>       struct timespec *__rem);
>
>
>extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int timer_create (clockid_t __clock_id,
>    struct sigevent *__restrict __evp,
>    timer_t *__restrict __timerid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int timer_delete (timer_t __timerid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int timer_settime (timer_t __timerid, int __flags,
>     const struct itimerspec *__restrict __value,
>     struct itimerspec *__restrict __ovalue) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int timer_getoverrun (timer_t __timerid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int timespec_get (struct timespec *__ts, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 403 "/usr/include/time.h" 3 4
>extern int getdate_err;
># 412 "/usr/include/time.h" 3 4
>extern struct tm *getdate (const char *__string);
># 426 "/usr/include/time.h" 3 4
>extern int getdate_r (const char *__restrict __string,
>        struct tm *__restrict __resbufp);
>
>
>
># 40 "mdadm.h" 2
># 1 "/usr/include/sys/time.h" 1 3 4
># 28 "/usr/include/sys/time.h" 3 4
># 1 "/usr/include/bits/time.h" 1 3 4
># 29 "/usr/include/sys/time.h" 2 3 4
># 38 "/usr/include/sys/time.h" 3 4
>
># 56 "/usr/include/sys/time.h" 3 4
>struct timezone
>  {
>    int tz_minuteswest;
>    int tz_dsttime;
>  };
>
>typedef struct timezone *__restrict __timezone_ptr_t;
># 72 "/usr/include/sys/time.h" 3 4
>extern int gettimeofday (struct timeval *__restrict __tv,
>    __timezone_ptr_t __tz) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int settimeofday (const struct timeval *__tv,
>    const struct timezone *__tz)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int adjtime (const struct timeval *__delta,
>      struct timeval *__olddelta) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>enum __itimer_which
>  {
>
>    ITIMER_REAL = 0,
>
>
>    ITIMER_VIRTUAL = 1,
>
>
>
>    ITIMER_PROF = 2
>
>  };
>
>
>
>struct itimerval
>  {
>
>    struct timeval it_interval;
>
>    struct timeval it_value;
>  };
>
>
>
>
>typedef enum __itimer_which __itimer_which_t;
>
>
>
>
>
>
>extern int getitimer (__itimer_which_t __which,
>        struct itimerval *__value) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int setitimer (__itimer_which_t __which,
>        const struct itimerval *__restrict __new,
>        struct itimerval *__restrict __old) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int utimes (const char *__file, const struct timeval __tvp[2])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int lutimes (const char *__file, const struct timeval __tvp[2])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int futimes (int __fd, const struct timeval __tvp[2]) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int futimesat (int __fd, const char *__file,
>        const struct timeval __tvp[2]) __attribute__ ((__nothrow__ , __leaf__));
># 190 "/usr/include/sys/time.h" 3 4
>
># 41 "mdadm.h" 2
># 1 "/usr/include/getopt.h" 1 3 4
># 58 "/usr/include/getopt.h" 3 4
>extern char *optarg;
># 72 "/usr/include/getopt.h" 3 4
>extern int optind;
>
>
>
>
>extern int opterr;
>
>
>
>extern int optopt;
># 105 "/usr/include/getopt.h" 3 4
>struct option
>{
>  const char *name;
>
>
>  int has_arg;
>  int *flag;
>  int val;
>};
># 151 "/usr/include/getopt.h" 3 4
>extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
>       __attribute__ ((__nothrow__ , __leaf__));
># 174 "/usr/include/getopt.h" 3 4
>extern int getopt_long (int ___argc, char *const *___argv,
>   const char *__shortopts,
>          const struct option *__longopts, int *__longind)
>       __attribute__ ((__nothrow__ , __leaf__));
>extern int getopt_long_only (int ___argc, char *const *___argv,
>        const char *__shortopts,
>               const struct option *__longopts, int *__longind)
>       __attribute__ ((__nothrow__ , __leaf__));
># 42 "mdadm.h" 2
># 1 "/usr/include/fcntl.h" 1 3 4
># 28 "/usr/include/fcntl.h" 3 4
>
>
>
>
># 1 "/usr/include/bits/fcntl.h" 1 3 4
># 26 "/usr/include/bits/fcntl.h" 3 4
># 1 "/usr/include/bits/uio.h" 1 3 4
># 43 "/usr/include/bits/uio.h" 3 4
>struct iovec
>  {
>    void *iov_base;
>    size_t iov_len;
>  };
># 27 "/usr/include/bits/fcntl.h" 2 3 4
># 152 "/usr/include/bits/fcntl.h" 3 4
>struct flock
>  {
>    short int l_type;
>    short int l_whence;
>
>
>
>
>    __off64_t l_start;
>    __off64_t l_len;
>
>    __pid_t l_pid;
>  };
>
>
>struct flock64
>  {
>    short int l_type;
>    short int l_whence;
>    __off64_t l_start;
>    __off64_t l_len;
>    __pid_t l_pid;
>  };
>
>
>
>
>enum __pid_type
>  {
>    F_OWNER_TID = 0,
>    F_OWNER_PID,
>    F_OWNER_PGRP,
>    F_OWNER_GID = F_OWNER_PGRP
>  };
>
>
>struct f_owner_ex
>  {
>    enum __pid_type type;
>    __pid_t pid;
>  };
># 237 "/usr/include/bits/fcntl.h" 3 4
>
>
>
>
>
>extern ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
>    __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int sync_file_range (int __fd, __off64_t __offset, __off64_t __count,
>       unsigned int __flags);
>
>
>
>extern ssize_t vmsplice (int __fdout, const struct iovec *__iov,
>    size_t __count, unsigned int __flags);
>
>
>extern ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
>         __off64_t *__offout, size_t __len,
>         unsigned int __flags);
>
>
>extern ssize_t tee (int __fdin, int __fdout, size_t __len,
>      unsigned int __flags);
>
>
>
>
>
>
>extern int fallocate (int __fd, int __mode, __off64_t __offset, __off64_t __len) __asm__ ("" "fallocate64")
>
>                     ;
>
>
>
>
>
>extern int fallocate64 (int __fd, int __mode, __off64_t __offset,
>   __off64_t __len);
>
>
>
>
>
># 33 "/usr/include/fcntl.h" 2 3 4
># 62 "/usr/include/fcntl.h" 3 4
># 1 "/usr/include/bits/stat.h" 1 3 4
># 63 "/usr/include/fcntl.h" 2 3 4
># 148 "/usr/include/fcntl.h" 3 4
>extern int fcntl (int __fd, int __cmd, ...);
># 160 "/usr/include/fcntl.h" 3 4
>extern int open (const char *__file, int __oflag, ...) __asm__ ("" "open64")
>     __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int open64 (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
># 185 "/usr/include/fcntl.h" 3 4
>extern int openat (int __fd, const char *__file, int __oflag, ...) __asm__ ("" "openat64")
>                    __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int openat64 (int __fd, const char *__file, int __oflag, ...)
>     __attribute__ ((__nonnull__ (2)));
># 206 "/usr/include/fcntl.h" 3 4
>extern int creat (const char *__file, __mode_t __mode) __asm__ ("" "creat64")
>                  __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int creat64 (const char *__file, __mode_t __mode) __attribute__ ((__nonnull__ (1)));
># 253 "/usr/include/fcntl.h" 3 4
>extern int posix_fadvise (int __fd, __off64_t __offset, __off64_t __len, int __advise) __asm__ ("" "posix_fadvise64") __attribute__ ((__nothrow__ , __leaf__))
>
>                      ;
>
>
>
>
>
>extern int posix_fadvise64 (int __fd, __off64_t __offset, __off64_t __len,
>       int __advise) __attribute__ ((__nothrow__ , __leaf__));
># 274 "/usr/include/fcntl.h" 3 4
>extern int posix_fallocate (int __fd, __off64_t __offset, __off64_t __len) __asm__ ("" "posix_fallocate64")
>
>                           ;
>
>
>
>
>
>extern int posix_fallocate64 (int __fd, __off64_t __offset, __off64_t __len);
>
>
>
>
>
>
>
># 1 "/usr/include/bits/fcntl2.h" 1 3 4
># 30 "/usr/include/bits/fcntl2.h" 3 4
>extern int __open_2 (const char *__path, int __oflag) __asm__ ("" "__open64_2")
>                     __attribute__ ((__nonnull__ (1)));
>extern int __open_alias (const char *__path, int __oflag, ...) __asm__ ("" "open64")
>                 __attribute__ ((__nonnull__ (1)));
>
>extern void __open_too_many_args (void) __attribute__((__error__ ("open can be called either with 2 or 3 arguments, not more")))
>                                                                  ;
>extern void __open_missing_mode (void) __attribute__((__error__ ("open with O_CREAT in second argument needs 3 arguments")))
>                                                               ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>open (const char *__path, int __oflag, ...)
>{
>  if (__builtin_va_arg_pack_len () > 1)
>    __open_too_many_args ();
>
>  if (__builtin_constant_p (__oflag))
>    {
>      if ((__oflag & 0100) != 0 && __builtin_va_arg_pack_len () < 1)
> {
>   __open_missing_mode ();
>   return __open_2 (__path, __oflag);
> }
>      return __open_alias (__path, __oflag, __builtin_va_arg_pack ());
>    }
>
>  if (__builtin_va_arg_pack_len () < 1)
>    return __open_2 (__path, __oflag);
>
>  return __open_alias (__path, __oflag, __builtin_va_arg_pack ());
>}
>
>
>
>extern int __open64_2 (const char *__path, int __oflag) __attribute__ ((__nonnull__ (1)));
>extern int __open64_alias (const char *__path, int __oflag, ...) __asm__ ("" "open64")
>                   __attribute__ ((__nonnull__ (1)));
>extern void __open64_too_many_args (void) __attribute__((__error__ ("open64 can be called either with 2 or 3 arguments, not more")))
>                                                                    ;
>extern void __open64_missing_mode (void) __attribute__((__error__ ("open64 with O_CREAT in second argument needs 3 arguments")))
>                                                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>open64 (const char *__path, int __oflag, ...)
>{
>  if (__builtin_va_arg_pack_len () > 1)
>    __open64_too_many_args ();
>
>  if (__builtin_constant_p (__oflag))
>    {
>      if ((__oflag & 0100) != 0 && __builtin_va_arg_pack_len () < 1)
> {
>   __open64_missing_mode ();
>   return __open64_2 (__path, __oflag);
> }
>      return __open64_alias (__path, __oflag, __builtin_va_arg_pack ());
>    }
>
>  if (__builtin_va_arg_pack_len () < 1)
>    return __open64_2 (__path, __oflag);
>
>  return __open64_alias (__path, __oflag, __builtin_va_arg_pack ());
>}
># 104 "/usr/include/bits/fcntl2.h" 3 4
>extern int __openat_2 (int __fd, const char *__path, int __oflag) __asm__ ("" "__openat64_2")
>
>     __attribute__ ((__nonnull__ (2)));
>extern int __openat_alias (int __fd, const char *__path, int __oflag, ...) __asm__ ("" "openat64")
>
>     __attribute__ ((__nonnull__ (2)));
>
>extern void __openat_too_many_args (void) __attribute__((__error__ ("openat can be called either with 3 or 4 arguments, not more")))
>                                                                    ;
>extern void __openat_missing_mode (void) __attribute__((__error__ ("openat with O_CREAT in third argument needs 4 arguments")))
>                                                                ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>openat (int __fd, const char *__path, int __oflag, ...)
>{
>  if (__builtin_va_arg_pack_len () > 1)
>    __openat_too_many_args ();
>
>  if (__builtin_constant_p (__oflag))
>    {
>      if ((__oflag & 0100) != 0 && __builtin_va_arg_pack_len () < 1)
> {
>   __openat_missing_mode ();
>   return __openat_2 (__fd, __path, __oflag);
> }
>      return __openat_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
>    }
>
>  if (__builtin_va_arg_pack_len () < 1)
>    return __openat_2 (__fd, __path, __oflag);
>
>  return __openat_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
>}
>
>
>
>extern int __openat64_2 (int __fd, const char *__path, int __oflag)
>     __attribute__ ((__nonnull__ (2)));
>extern int __openat64_alias (int __fd, const char *__path, int __oflag, ...) __asm__ ("" "openat64")
>
>     __attribute__ ((__nonnull__ (2)));
>extern void __openat64_too_many_args (void) __attribute__((__error__ ("openat64 can be called either with 3 or 4 arguments, not more")))
>                                                                      ;
>extern void __openat64_missing_mode (void) __attribute__((__error__ ("openat64 with O_CREAT in third argument needs 4 arguments")))
>                                                                  ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>openat64 (int __fd, const char *__path, int __oflag, ...)
>{
>  if (__builtin_va_arg_pack_len () > 1)
>    __openat64_too_many_args ();
>
>  if (__builtin_constant_p (__oflag))
>    {
>      if ((__oflag & 0100) != 0 && __builtin_va_arg_pack_len () < 1)
> {
>   __openat64_missing_mode ();
>   return __openat64_2 (__fd, __path, __oflag);
> }
>      return __openat64_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
>    }
>
>  if (__builtin_va_arg_pack_len () < 1)
>    return __openat64_2 (__fd, __path, __oflag);
>
>  return __openat64_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
>}
># 291 "/usr/include/fcntl.h" 2 3 4
>
>
>
># 43 "mdadm.h" 2
># 1 "/usr/include/stdio.h" 1 3 4
># 29 "/usr/include/stdio.h" 3 4
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stddef.h" 1 3 4
># 34 "/usr/include/stdio.h" 2 3 4
># 44 "/usr/include/stdio.h" 3 4
>struct _IO_FILE;
>
>
>
>typedef struct _IO_FILE FILE;
>
>
>
>
>
># 64 "/usr/include/stdio.h" 3 4
>typedef struct _IO_FILE __FILE;
># 74 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/libio.h" 1 3 4
># 32 "/usr/include/libio.h" 3 4
># 1 "/usr/include/_G_config.h" 1 3 4
># 15 "/usr/include/_G_config.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stddef.h" 1 3 4
># 16 "/usr/include/_G_config.h" 2 3 4
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 82 "/usr/include/wchar.h" 3 4
>typedef struct
>{
>  int __count;
>  union
>  {
>
>    unsigned int __wch;
>
>
>
>    char __wchb[4];
>  } __value;
>} __mbstate_t;
># 21 "/usr/include/_G_config.h" 2 3 4
>
>typedef struct
>{
>  __off_t __pos;
>  __mbstate_t __state;
>} _G_fpos_t;
>typedef struct
>{
>  __off64_t __pos;
>  __mbstate_t __state;
>} _G_fpos64_t;
># 53 "/usr/include/_G_config.h" 3 4
>typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
># 33 "/usr/include/libio.h" 2 3 4
># 53 "/usr/include/libio.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stdarg.h" 1 3 4
># 40 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 54 "/usr/include/libio.h" 2 3 4
># 152 "/usr/include/libio.h" 3 4
>struct _IO_jump_t; struct _IO_FILE;
># 162 "/usr/include/libio.h" 3 4
>typedef void _IO_lock_t;
>
>
>
>
>
>struct _IO_marker {
>  struct _IO_marker *_next;
>  struct _IO_FILE *_sbuf;
>
>
>
>  int _pos;
># 185 "/usr/include/libio.h" 3 4
>};
>
>
>enum __codecvt_result
>{
>  __codecvt_ok,
>  __codecvt_partial,
>  __codecvt_error,
>  __codecvt_noconv
>};
># 253 "/usr/include/libio.h" 3 4
>struct _IO_FILE {
>  int _flags;
>
>
>
>
>  char* _IO_read_ptr;
>  char* _IO_read_end;
>  char* _IO_read_base;
>  char* _IO_write_base;
>  char* _IO_write_ptr;
>  char* _IO_write_end;
>  char* _IO_buf_base;
>  char* _IO_buf_end;
>
>  char *_IO_save_base;
>  char *_IO_backup_base;
>  char *_IO_save_end;
>
>  struct _IO_marker *_markers;
>
>  struct _IO_FILE *_chain;
>
>  int _fileno;
>
>
>
>  int _flags2;
>
>  __off_t _old_offset;
>
>
>
>  unsigned short _cur_column;
>  signed char _vtable_offset;
>  char _shortbuf[1];
>
>
>
>  _IO_lock_t *_lock;
># 301 "/usr/include/libio.h" 3 4
>  __off64_t _offset;
># 310 "/usr/include/libio.h" 3 4
>  void *__pad1;
>  void *__pad2;
>  void *__pad3;
>  void *__pad4;
>  size_t __pad5;
>
>  int _mode;
>
>  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
>
>};
>
>
>typedef struct _IO_FILE _IO_FILE;
>
>
>struct _IO_FILE_plus;
>
>extern struct _IO_FILE_plus _IO_2_1_stdin_;
>extern struct _IO_FILE_plus _IO_2_1_stdout_;
>extern struct _IO_FILE_plus _IO_2_1_stderr_;
># 346 "/usr/include/libio.h" 3 4
>typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
>
>
>
>
>
>
>
>typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
>     size_t __n);
>
>
>
>
>
>
>
>typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
>
>
>typedef int __io_close_fn (void *__cookie);
>
>
>
>
>typedef __io_read_fn cookie_read_function_t;
>typedef __io_write_fn cookie_write_function_t;
>typedef __io_seek_fn cookie_seek_function_t;
>typedef __io_close_fn cookie_close_function_t;
>
>
>typedef struct
>{
>  __io_read_fn *read;
>  __io_write_fn *write;
>  __io_seek_fn *seek;
>  __io_close_fn *close;
>} _IO_cookie_io_functions_t;
>typedef _IO_cookie_io_functions_t cookie_io_functions_t;
>
>struct _IO_cookie_file;
>
>
>extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
>        void *__cookie, _IO_cookie_io_functions_t __fns);
>
>
>
>
>
>
>
>extern int __underflow (_IO_FILE *);
>extern int __uflow (_IO_FILE *);
>extern int __overflow (_IO_FILE *, int);
># 442 "/usr/include/libio.h" 3 4
>extern int _IO_getc (_IO_FILE *__fp);
>extern int _IO_putc (int __c, _IO_FILE *__fp);
>extern int _IO_feof (_IO_FILE *__fp) __attribute__ ((__nothrow__ , __leaf__));
>extern int _IO_ferror (_IO_FILE *__fp) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int _IO_peekc_locked (_IO_FILE *__fp);
>
>
>
>
>
>extern void _IO_flockfile (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));
>extern void _IO_funlockfile (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));
>extern int _IO_ftrylockfile (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));
># 472 "/usr/include/libio.h" 3 4
>extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
>   __gnuc_va_list, int *__restrict);
>extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
>    __gnuc_va_list);
>extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
>extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
>
>extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
>extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
>
>extern void _IO_free_backup_area (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));
># 75 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>typedef __gnuc_va_list va_list;
># 108 "/usr/include/stdio.h" 3 4
>
>
>
>
>typedef _G_fpos64_t fpos_t;
>
>
>
>typedef _G_fpos64_t fpos64_t;
># 164 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 165 "/usr/include/stdio.h" 2 3 4
>
>
>
>extern struct _IO_FILE *stdin;
>extern struct _IO_FILE *stdout;
>extern struct _IO_FILE *stderr;
>
>
>
>
>
>
>
>
>
>extern int remove (const char *__filename) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int rename (const char *__old, const char *__new) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int renameat (int __oldfd, const char *__old, int __newfd,
>       const char *__new) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
># 200 "/usr/include/stdio.h" 3 4
>extern FILE *tmpfile (void) __asm__ ("" "tmpfile64") __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern FILE *tmpfile64 (void) __attribute__ ((__warn_unused_result__));
>
>
>
>extern char *tmpnam (char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 229 "/usr/include/stdio.h" 3 4
>extern char *tempnam (const char *__dir, const char *__pfx)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>extern int fclose (FILE *__stream);
>
>
>
>
>extern int fflush (FILE *__stream);
>
># 254 "/usr/include/stdio.h" 3 4
>extern int fflush_unlocked (FILE *__stream);
># 264 "/usr/include/stdio.h" 3 4
>extern int fcloseall (void);
>
>
>
>
># 285 "/usr/include/stdio.h" 3 4
>extern FILE *fopen (const char *__restrict __filename, const char *__restrict __modes) __asm__ ("" "fopen64")
>
>  __attribute__ ((__warn_unused_result__));
>extern FILE *freopen (const char *__restrict __filename, const char *__restrict __modes, FILE *__restrict __stream) __asm__ ("" "freopen64")
>
>
>  __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern FILE *fopen64 (const char *__restrict __filename,
>        const char *__restrict __modes) __attribute__ ((__warn_unused_result__));
>extern FILE *freopen64 (const char *__restrict __filename,
>   const char *__restrict __modes,
>   FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern FILE *fdopen (int __fd, const char *__modes) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern FILE *fopencookie (void *__restrict __magic_cookie,
>     const char *__restrict __modes,
>     _IO_cookie_io_functions_t __io_funcs) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
>  __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
>      int __modes, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
>         size_t __size) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern int fprintf (FILE *__restrict __stream,
>      const char *__restrict __format, ...);
>
>
>
>
>extern int printf (const char *__restrict __format, ...);
>
>extern int sprintf (char *__restrict __s,
>      const char *__restrict __format, ...) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
>       __gnuc_va_list __arg);
>
>
>
>
>extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
>
>extern int vsprintf (char *__restrict __s, const char *__restrict __format,
>       __gnuc_va_list __arg) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int snprintf (char *__restrict __s, size_t __maxlen,
>       const char *__restrict __format, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));
>
>extern int vsnprintf (char *__restrict __s, size_t __maxlen,
>        const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));
>
>
>
>
>
>
>extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
>        __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 0))) __attribute__ ((__warn_unused_result__));
>extern int __asprintf (char **__restrict __ptr,
>         const char *__restrict __fmt, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));
>extern int asprintf (char **__restrict __ptr,
>       const char *__restrict __fmt, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int vdprintf (int __fd, const char *__restrict __fmt,
>       __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__printf__, 2, 0)));
>extern int dprintf (int __fd, const char *__restrict __fmt, ...)
>     __attribute__ ((__format__ (__printf__, 2, 3)));
>
>
>
>
>
>
>
>
>extern int fscanf (FILE *__restrict __stream,
>     const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int scanf (const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__));
>
>extern int sscanf (const char *__restrict __s,
>     const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__));
># 465 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>
>
>extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
>      __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__scanf__, 1, 0))) __attribute__ ((__warn_unused_result__));
>
>
>extern int vsscanf (const char *__restrict __s,
>      const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0)));
># 524 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>
>
>
>extern int fgetc (FILE *__stream);
>extern int getc (FILE *__stream);
>
>
>
>
>
>extern int getchar (void);
>
># 552 "/usr/include/stdio.h" 3 4
>extern int getc_unlocked (FILE *__stream);
>extern int getchar_unlocked (void);
># 563 "/usr/include/stdio.h" 3 4
>extern int fgetc_unlocked (FILE *__stream);
>
>
>
>
>
>
>
>
>
>
>
>extern int fputc (int __c, FILE *__stream);
>extern int putc (int __c, FILE *__stream);
>
>
>
>
>
>extern int putchar (int __c);
>
># 596 "/usr/include/stdio.h" 3 4
>extern int fputc_unlocked (int __c, FILE *__stream);
>
>
>
>
>
>
>
>extern int putc_unlocked (int __c, FILE *__stream);
>extern int putchar_unlocked (int __c);
>
>
>
>
>
>
>extern int getw (FILE *__stream);
>
>
>extern int putw (int __w, FILE *__stream);
>
>
>
>
>
>
>
>
>extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
>     __attribute__ ((__warn_unused_result__));
># 642 "/usr/include/stdio.h" 3 4
>
># 651 "/usr/include/stdio.h" 3 4
>extern char *fgets_unlocked (char *__restrict __s, int __n,
>        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
># 667 "/usr/include/stdio.h" 3 4
>extern __ssize_t __getdelim (char **__restrict __lineptr,
>          size_t *__restrict __n, int __delimiter,
>          FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern __ssize_t getdelim (char **__restrict __lineptr,
>        size_t *__restrict __n, int __delimiter,
>        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern __ssize_t getline (char **__restrict __lineptr,
>       size_t *__restrict __n,
>       FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
>
>
>
>
>
>extern int puts (const char *__s);
>
>
>
>
>
>
>extern int ungetc (int __c, FILE *__stream);
>
>
>
>
>
>
>extern size_t fread (void *__restrict __ptr, size_t __size,
>       size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern size_t fwrite (const void *__restrict __ptr, size_t __size,
>        size_t __n, FILE *__restrict __s);
>
># 728 "/usr/include/stdio.h" 3 4
>extern int fputs_unlocked (const char *__restrict __s,
>      FILE *__restrict __stream);
># 739 "/usr/include/stdio.h" 3 4
>extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
>         size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
>          size_t __n, FILE *__restrict __stream);
>
>
>
>
>
>
>
>
>extern int fseek (FILE *__stream, long int __off, int __whence);
>
>
>
>
>extern long int ftell (FILE *__stream) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern void rewind (FILE *__stream);
>
># 783 "/usr/include/stdio.h" 3 4
>extern int fseeko (FILE *__stream, __off64_t __off, int __whence) __asm__ ("" "fseeko64")
>
>                  ;
>extern __off64_t ftello (FILE *__stream) __asm__ ("" "ftello64");
>
>
>
>
>
>
>
>
># 808 "/usr/include/stdio.h" 3 4
>extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) __asm__ ("" "fgetpos64")
>                                          ;
>extern int fsetpos (FILE *__stream, const fpos_t *__pos) __asm__ ("" "fsetpos64")
>                                                          ;
>
>
>
>
>
>
>
>
>extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
>extern __off64_t ftello64 (FILE *__stream) __attribute__ ((__warn_unused_result__));
>extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
>extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
>
>
>
>
>extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int feof (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>extern int ferror (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
>extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>extern void perror (const char *__s);
>
>
>
>
>
>
># 1 "/usr/include/bits/sys_errlist.h" 1 3 4
># 26 "/usr/include/bits/sys_errlist.h" 3 4
>extern int sys_nerr;
>extern const char *const sys_errlist[];
>
>
>extern int _sys_nerr;
>extern const char *const _sys_errlist[];
># 856 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>extern int fileno (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 875 "/usr/include/stdio.h" 3 4
>extern FILE *popen (const char *__command, const char *__modes) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int pclose (FILE *__stream);
>
>
>
>
>
>extern char *ctermid (char *__s) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern char *cuserid (char *__s);
>
>
>
>
>struct obstack;
>
>
>extern int obstack_printf (struct obstack *__restrict __obstack,
>      const char *__restrict __format, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3)));
>extern int obstack_vprintf (struct obstack *__restrict __obstack,
>       const char *__restrict __format,
>       __gnuc_va_list __args)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 0)));
>
>
>
>
>
>
>
>extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
># 936 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio.h" 1 3 4
># 43 "/usr/include/bits/stdio.h" 3 4
>extern __inline int
>getchar (void)
>{
>  return _IO_getc (stdin);
>}
>
>
>
>
>extern __inline int
>fgetc_unlocked (FILE *__fp)
>{
>  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
>}
>
>
>
>
>
>extern __inline int
>getc_unlocked (FILE *__fp)
>{
>  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
>}
>
>
>extern __inline int
>getchar_unlocked (void)
>{
>  return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
>}
>
>
>
>
>extern __inline int
>putchar (int __c)
>{
>  return _IO_putc (__c, stdout);
>}
>
>
>
>
>extern __inline int
>fputc_unlocked (int __c, FILE *__stream)
>{
>  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>extern __inline int
>putc_unlocked (int __c, FILE *__stream)
>{
>  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>extern __inline int
>putchar_unlocked (int __c)
>{
>  return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>extern __inline __ssize_t
>getline (char **__lineptr, size_t *__n, FILE *__stream)
>{
>  return __getdelim (__lineptr, __n, '\n', __stream);
>}
>
>
>
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) feof_unlocked (FILE *__stream)
>{
>  return (((__stream)->_flags & 0x10) != 0);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) ferror_unlocked (FILE *__stream)
>{
>  return (((__stream)->_flags & 0x20) != 0);
>}
># 937 "/usr/include/stdio.h" 2 3 4
>
>
># 1 "/usr/include/bits/stdio2.h" 1 3 4
># 23 "/usr/include/bits/stdio2.h" 3 4
>extern int __sprintf_chk (char *__restrict __s, int __flag, size_t __slen,
>     const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__));
>extern int __vsprintf_chk (char *__restrict __s, int __flag, size_t __slen,
>      const char *__restrict __format,
>      __gnuc_va_list __ap) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) sprintf (char *__restrict __s, const char *__restrict __fmt, ...)
>{
>  return __builtin___sprintf_chk (__s, 2 - 1,
>      __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
>}
>
>
>
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) vsprintf (char *__restrict __s, const char *__restrict __fmt, __gnuc_va_list __ap)
>
>{
>  return __builtin___vsprintf_chk (__s, 2 - 1,
>       __builtin_object_size (__s, 2 > 1), __fmt, __ap);
>}
>
>
>
>extern int __snprintf_chk (char *__restrict __s, size_t __n, int __flag,
>      size_t __slen, const char *__restrict __format,
>      ...) __attribute__ ((__nothrow__ , __leaf__));
>extern int __vsnprintf_chk (char *__restrict __s, size_t __n, int __flag,
>       size_t __slen, const char *__restrict __format,
>       __gnuc_va_list __ap) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) snprintf (char *__restrict __s, size_t __n, const char *__restrict __fmt, ...)
>
>{
>  return __builtin___snprintf_chk (__s, __n, 2 - 1,
>       __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
>}
>
>
>
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) vsnprintf (char *__restrict __s, size_t __n, const char *__restrict __fmt, __gnuc_va_list __ap)
>
>{
>  return __builtin___vsnprintf_chk (__s, __n, 2 - 1,
>        __builtin_object_size (__s, 2 > 1), __fmt, __ap);
>}
>
>
>
>
>
>extern int __fprintf_chk (FILE *__restrict __stream, int __flag,
>     const char *__restrict __format, ...);
>extern int __printf_chk (int __flag, const char *__restrict __format, ...);
>extern int __vfprintf_chk (FILE *__restrict __stream, int __flag,
>      const char *__restrict __format, __gnuc_va_list __ap);
>extern int __vprintf_chk (int __flag, const char *__restrict __format,
>     __gnuc_va_list __ap);
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>fprintf (FILE *__restrict __stream, const char *__restrict __fmt, ...)
>{
>  return __fprintf_chk (__stream, 2 - 1, __fmt,
>   __builtin_va_arg_pack ());
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>printf (const char *__restrict __fmt, ...)
>{
>  return __printf_chk (2 - 1, __fmt, __builtin_va_arg_pack ());
>}
>
>
>
>
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>vprintf (const char *__restrict __fmt, __gnuc_va_list __ap)
>{
>
>  return __vfprintf_chk (stdout, 2 - 1, __fmt, __ap);
>
>
>
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>vfprintf (FILE *__restrict __stream,
>   const char *__restrict __fmt, __gnuc_va_list __ap)
>{
>  return __vfprintf_chk (__stream, 2 - 1, __fmt, __ap);
>}
>
>
>extern int __dprintf_chk (int __fd, int __flag, const char *__restrict __fmt,
>     ...) __attribute__ ((__format__ (__printf__, 3, 4)));
>extern int __vdprintf_chk (int __fd, int __flag,
>      const char *__restrict __fmt, __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__printf__, 3, 0)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>dprintf (int __fd, const char *__restrict __fmt, ...)
>{
>  return __dprintf_chk (__fd, 2 - 1, __fmt,
>   __builtin_va_arg_pack ());
>}
>
>
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>vdprintf (int __fd, const char *__restrict __fmt, __gnuc_va_list __ap)
>{
>  return __vdprintf_chk (__fd, 2 - 1, __fmt, __ap);
>}
>
>
>
>
>extern int __asprintf_chk (char **__restrict __ptr, int __flag,
>      const char *__restrict __fmt, ...)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__printf__, 3, 4))) __attribute__ ((__warn_unused_result__));
>extern int __vasprintf_chk (char **__restrict __ptr, int __flag,
>       const char *__restrict __fmt, __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__printf__, 3, 0))) __attribute__ ((__warn_unused_result__));
>extern int __obstack_printf_chk (struct obstack *__restrict __obstack,
>     int __flag, const char *__restrict __format,
>     ...)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__printf__, 3, 4)));
>extern int __obstack_vprintf_chk (struct obstack *__restrict __obstack,
>      int __flag,
>      const char *__restrict __format,
>      __gnuc_va_list __args)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__printf__, 3, 0)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...)
>{
>  return __asprintf_chk (__ptr, 2 - 1, __fmt,
>    __builtin_va_arg_pack ());
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) __asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...)
>
>{
>  return __asprintf_chk (__ptr, 2 - 1, __fmt,
>    __builtin_va_arg_pack ());
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) obstack_printf (struct obstack *__restrict __obstack, const char *__restrict __fmt, ...)
>
>{
>  return __obstack_printf_chk (__obstack, 2 - 1, __fmt,
>          __builtin_va_arg_pack ());
>}
># 206 "/usr/include/bits/stdio2.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) vasprintf (char **__restrict __ptr, const char *__restrict __fmt, __gnuc_va_list __ap)
>
>{
>  return __vasprintf_chk (__ptr, 2 - 1, __fmt, __ap);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) obstack_vprintf (struct obstack *__restrict __obstack, const char *__restrict __fmt, __gnuc_va_list __ap)
>
>{
>  return __obstack_vprintf_chk (__obstack, 2 - 1, __fmt,
>    __ap);
>}
># 241 "/usr/include/bits/stdio2.h" 3 4
>extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n,
>     FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern char *__fgets_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets")
>
>                                        __attribute__ ((__warn_unused_result__));
>extern char *__fgets_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_chk")
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets called with bigger size than length " "of destination buffer")))
>                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
>fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
>{
>  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n) || __n <= 0)
> return __fgets_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
>
>      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
> return __fgets_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
>    }
>  return __fgets_alias (__s, __n, __stream);
>}
>
>extern size_t __fread_chk (void *__restrict __ptr, size_t __ptrlen,
>      size_t __size, size_t __n,
>      FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern size_t __fread_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread")
>
>
>            __attribute__ ((__warn_unused_result__));
>extern size_t __fread_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_chk")
>
>
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread called with bigger size * nmemb than length " "of destination buffer")))
>                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) size_t
>fread (void *__restrict __ptr, size_t __size, size_t __n,
>       FILE *__restrict __stream)
>{
>  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__size)
>   || !__builtin_constant_p (__n)
>   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
> return __fread_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);
>
>      if (__size * __n > __builtin_object_size (__ptr, 0))
> return __fread_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);
>    }
>  return __fread_alias (__ptr, __size, __n, __stream);
>}
>
>
>extern char *__fgets_unlocked_chk (char *__restrict __s, size_t __size,
>       int __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern char *__fgets_unlocked_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets_unlocked")
>
>                                                 __attribute__ ((__warn_unused_result__));
>extern char *__fgets_unlocked_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_unlocked_chk")
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets_unlocked called with bigger size than length " "of destination buffer")))
>                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
>fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream)
>{
>  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n) || __n <= 0)
> return __fgets_unlocked_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
>
>      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
> return __fgets_unlocked_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
>    }
>  return __fgets_unlocked_alias (__s, __n, __stream);
>}
>
>
>
>
>extern size_t __fread_unlocked_chk (void *__restrict __ptr, size_t __ptrlen,
>        size_t __size, size_t __n,
>        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern size_t __fread_unlocked_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread_unlocked")
>
>
>                     __attribute__ ((__warn_unused_result__));
>extern size_t __fread_unlocked_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_unlocked_chk")
>
>
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread_unlocked called with bigger size * nmemb than " "length of destination buffer")))
>                                        ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) size_t
>fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n,
>  FILE *__restrict __stream)
>{
>  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__size)
>   || !__builtin_constant_p (__n)
>   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
> return __fread_unlocked_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
>         __stream);
>
>      if (__size * __n > __builtin_object_size (__ptr, 0))
> return __fread_unlocked_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
>       __stream);
>    }
>
>
>  if (__builtin_constant_p (__size)
>      && __builtin_constant_p (__n)
>      && (__size | __n) < (((size_t) 1) << (8 * sizeof (size_t) / 2))
>      && __size * __n <= 8)
>    {
>      size_t __cnt = __size * __n;
>      char *__cptr = (char *) __ptr;
>      if (__cnt == 0)
> return 0;
>
>      for (; __cnt > 0; --__cnt)
> {
>   int __c = (__builtin_expect (((__stream)->_IO_read_ptr >= (__stream)->_IO_read_end), 0) ? __uflow (__stream) : *(unsigned char *) (__stream)->_IO_read_ptr++);
>   if (__c == (-1))
>     break;
>   *__cptr++ = __c;
> }
>      return (__cptr - (char *) __ptr) / __size;
>    }
>
>  return __fread_unlocked_alias (__ptr, __size, __n, __stream);
>}
># 940 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>
>
># 44 "mdadm.h" 2
># 1 "/usr/include/errno.h" 1 3 4
># 31 "/usr/include/errno.h" 3 4
>
>
>
>
># 1 "/usr/include/bits/errno.h" 1 3 4
># 24 "/usr/include/bits/errno.h" 3 4
># 1 "/usr/include/linux/errno.h" 1 3 4
>
>
>
># 1 "/usr/include/asm/errno.h" 1 3 4
>
>
>
># 1 "/usr/include/asm-generic/errno.h" 1 3 4
>
>
>
># 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
># 5 "/usr/include/asm-generic/errno.h" 2 3 4
># 5 "/usr/include/asm/errno.h" 2 3 4
># 5 "/usr/include/linux/errno.h" 2 3 4
># 25 "/usr/include/bits/errno.h" 2 3 4
># 50 "/usr/include/bits/errno.h" 3 4
>extern int *__errno_location (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
># 36 "/usr/include/errno.h" 2 3 4
># 54 "/usr/include/errno.h" 3 4
>extern char *program_invocation_name, *program_invocation_short_name;
>
>
>
>
># 68 "/usr/include/errno.h" 3 4
>typedef int error_t;
># 45 "mdadm.h" 2
># 1 "/usr/include/string.h" 1 3 4
># 27 "/usr/include/string.h" 3 4
>
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stddef.h" 1 3 4
># 33 "/usr/include/string.h" 2 3 4
>
>
>
>
>
>
>
>
>
>extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
>       size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memmove (void *__dest, const void *__src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
>        int __c, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern void *memset (void *__s, int __c, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int memcmp (const void *__s1, const void *__s2, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 92 "/usr/include/string.h" 3 4
>extern void *memchr (const void *__s, int __c, size_t __n)
>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
># 106 "/usr/include/string.h" 3 4
>extern void *rawmemchr (const void *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
># 117 "/usr/include/string.h" 3 4
>extern void *memrchr (const void *__s, int __c, size_t __n)
>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncpy (char *__restrict __dest,
>        const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strcat (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncat (char *__restrict __dest, const char *__restrict __src,
>        size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcmp (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int strncmp (const char *__s1, const char *__s2, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcoll (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern size_t strxfrm (char *__restrict __dest,
>         const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
># 162 "/usr/include/string.h" 3 4
>extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
>    __locale_t __l) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4)));
>
>
>
>
>
>extern char *strdup (const char *__s)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *strndup (const char *__string, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
># 207 "/usr/include/string.h" 3 4
>
># 232 "/usr/include/string.h" 3 4
>extern char *strchr (const char *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
># 259 "/usr/include/string.h" 3 4
>extern char *strrchr (const char *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
># 273 "/usr/include/string.h" 3 4
>extern char *strchrnul (const char *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern size_t strcspn (const char *__s, const char *__reject)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern size_t strspn (const char *__s, const char *__accept)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 311 "/usr/include/string.h" 3 4
>extern char *strpbrk (const char *__s, const char *__accept)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 338 "/usr/include/string.h" 3 4
>extern char *strstr (const char *__haystack, const char *__needle)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern char *strtok (char *__restrict __s, const char *__restrict __delim)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern char *__strtok_r (char *__restrict __s,
>    const char *__restrict __delim,
>    char **__restrict __save_ptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
>
>extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
>         char **__restrict __save_ptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
># 369 "/usr/include/string.h" 3 4
>extern char *strcasestr (const char *__haystack, const char *__needle)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>
>extern void *memmem (const void *__haystack, size_t __haystacklen,
>       const void *__needle, size_t __needlelen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern void *__mempcpy (void *__restrict __dest,
>   const void *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern void *mempcpy (void *__restrict __dest,
>        const void *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern size_t strlen (const char *__s)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern size_t strnlen (const char *__string, size_t __maxlen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern char *strerror (int __errnum) __attribute__ ((__nothrow__ , __leaf__));
>
># 434 "/usr/include/string.h" 3 4
>extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern char *strerror_l (int __errnum, __locale_t __l) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern void __bzero (void *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern void bcopy (const void *__src, void *__dest, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void bzero (void *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int bcmp (const void *__s1, const void *__s2, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 485 "/usr/include/string.h" 3 4
>extern char *index (const char *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
># 513 "/usr/include/string.h" 3 4
>extern char *rindex (const char *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int ffs (int __i) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>extern int ffsl (long int __l) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>__extension__ extern int ffsll (long long int __ll)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>extern int strcasecmp (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int strcasecmp_l (const char *__s1, const char *__s2,
>    __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>extern int strncasecmp_l (const char *__s1, const char *__s2,
>     size_t __n, __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
>
>
>
>
>
>extern char *strsep (char **__restrict __stringp,
>       const char *__restrict __delim)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern char *strsignal (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern char *__stpncpy (char *__restrict __dest,
>   const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpncpy (char *__restrict __dest,
>        const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int strverscmp (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strfry (char *__string) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern void *memfrob (void *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 602 "/usr/include/string.h" 3 4
>extern char *basename (const char *__filename) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 630 "/usr/include/string.h" 3 4
># 1 "/usr/include/bits/string.h" 1 3 4
># 631 "/usr/include/string.h" 2 3 4
>
>
># 1 "/usr/include/bits/string2.h" 1 3 4
># 79 "/usr/include/bits/string2.h" 3 4
>typedef struct { unsigned char __arr[2]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR2;
>typedef struct { unsigned char __arr[3]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR3;
>typedef struct { unsigned char __arr[4]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR4;
>typedef struct { unsigned char __arr[5]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR5;
>typedef struct { unsigned char __arr[6]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR6;
>typedef struct { unsigned char __arr[7]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR7;
>typedef struct { unsigned char __arr[8]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR8;
># 393 "/usr/include/bits/string2.h" 3 4
>extern void *__rawmemchr (const void *__s, int __c);
># 968 "/usr/include/bits/string2.h" 3 4
>extern __inline size_t __strcspn_c1 (const char *__s, int __reject);
>extern __inline size_t
>__strcspn_c1 (const char *__s, int __reject)
>{
>  register size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strcspn_c2 (const char *__s, int __reject1,
>         int __reject2);
>extern __inline size_t
>__strcspn_c2 (const char *__s, int __reject1, int __reject2)
>{
>  register size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject1
>  && __s[__result] != __reject2)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strcspn_c3 (const char *__s, int __reject1,
>         int __reject2, int __reject3);
>extern __inline size_t
>__strcspn_c3 (const char *__s, int __reject1, int __reject2,
>       int __reject3)
>{
>  register size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject1
>  && __s[__result] != __reject2 && __s[__result] != __reject3)
>    ++__result;
>  return __result;
>}
># 1044 "/usr/include/bits/string2.h" 3 4
>extern __inline size_t __strspn_c1 (const char *__s, int __accept);
>extern __inline size_t
>__strspn_c1 (const char *__s, int __accept)
>{
>  register size_t __result = 0;
>
>  while (__s[__result] == __accept)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strspn_c2 (const char *__s, int __accept1,
>        int __accept2);
>extern __inline size_t
>__strspn_c2 (const char *__s, int __accept1, int __accept2)
>{
>  register size_t __result = 0;
>
>  while (__s[__result] == __accept1 || __s[__result] == __accept2)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strspn_c3 (const char *__s, int __accept1,
>        int __accept2, int __accept3);
>extern __inline size_t
>__strspn_c3 (const char *__s, int __accept1, int __accept2, int __accept3)
>{
>  register size_t __result = 0;
>
>  while (__s[__result] == __accept1 || __s[__result] == __accept2
>  || __s[__result] == __accept3)
>    ++__result;
>  return __result;
>}
># 1120 "/usr/include/bits/string2.h" 3 4
>extern __inline char *__strpbrk_c2 (const char *__s, int __accept1,
>        int __accept2);
>extern __inline char *
>__strpbrk_c2 (const char *__s, int __accept1, int __accept2)
>{
>
>  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2)
>    ++__s;
>  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
>}
>
>extern __inline char *__strpbrk_c3 (const char *__s, int __accept1,
>        int __accept2, int __accept3);
>extern __inline char *
>__strpbrk_c3 (const char *__s, int __accept1, int __accept2, int __accept3)
>{
>
>  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
>  && *__s != __accept3)
>    ++__s;
>  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
>}
># 1170 "/usr/include/bits/string2.h" 3 4
>extern __inline char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
>extern __inline char *
>__strtok_r_1c (char *__s, char __sep, char **__nextp)
>{
>  char *__result;
>  if (__s == ((void *)0))
>    __s = *__nextp;
>  while (*__s == __sep)
>    ++__s;
>  __result = ((void *)0);
>  if (*__s != '\0')
>    {
>      __result = __s++;
>      while (*__s != '\0')
> if (*__s++ == __sep)
>   {
>     __s[-1] = '\0';
>     break;
>   }
>    }
>  *__nextp = __s;
>  return __result;
>}
># 1202 "/usr/include/bits/string2.h" 3 4
>extern char *__strsep_g (char **__stringp, const char *__delim);
># 1220 "/usr/include/bits/string2.h" 3 4
>extern __inline char *__strsep_1c (char **__s, char __reject);
>extern __inline char *
>__strsep_1c (char **__s, char __reject)
>{
>  register char *__retval = *__s;
>  if (__retval != ((void *)0) && (*__s = (__extension__ (__builtin_constant_p (__reject) && !__builtin_constant_p (__retval) && (__reject) == '\0' ? (char *) __rawmemchr (__retval, __reject) : __builtin_strchr (__retval, __reject)))) != ((void *)0))
>    *(*__s)++ = '\0';
>  return __retval;
>}
>
>extern __inline char *__strsep_2c (char **__s, char __reject1, char __reject2);
>extern __inline char *
>__strsep_2c (char **__s, char __reject1, char __reject2)
>{
>  register char *__retval = *__s;
>  if (__retval != ((void *)0))
>    {
>      register char *__cp = __retval;
>      while (1)
> {
>   if (*__cp == '\0')
>     {
>       __cp = ((void *)0);
>   break;
>     }
>   if (*__cp == __reject1 || *__cp == __reject2)
>     {
>       *__cp++ = '\0';
>       break;
>     }
>   ++__cp;
> }
>      *__s = __cp;
>    }
>  return __retval;
>}
>
>extern __inline char *__strsep_3c (char **__s, char __reject1, char __reject2,
>       char __reject3);
>extern __inline char *
>__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
>{
>  register char *__retval = *__s;
>  if (__retval != ((void *)0))
>    {
>      register char *__cp = __retval;
>      while (1)
> {
>   if (*__cp == '\0')
>     {
>       __cp = ((void *)0);
>   break;
>     }
>   if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3)
>     {
>       *__cp++ = '\0';
>       break;
>     }
>   ++__cp;
> }
>      *__s = __cp;
>    }
>  return __retval;
>}
># 1301 "/usr/include/bits/string2.h" 3 4
>extern char *__strdup (const char *__string) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__));
># 1320 "/usr/include/bits/string2.h" 3 4
>extern char *__strndup (const char *__string, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__));
># 634 "/usr/include/string.h" 2 3 4
>
>
>
>
># 1 "/usr/include/bits/string3.h" 1 3 4
># 22 "/usr/include/bits/string3.h" 3 4
>extern void __warn_memset_zero_len (void) __attribute__((__warning__ ("memset used with constant zero length parameter; this could be due to transposed parameters")))
>                                                                                                   ;
># 47 "/usr/include/bits/string3.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__nothrow__ , __leaf__)) memcpy (void *__restrict __dest, const void *__restrict __src, size_t __len)
>
>{
>  return __builtin___memcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__nothrow__ , __leaf__)) memmove (void *__dest, const void *__src, size_t __len)
>{
>  return __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__nothrow__ , __leaf__)) mempcpy (void *__restrict __dest, const void *__restrict __src, size_t __len)
>
>{
>  return __builtin___mempcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
># 75 "/usr/include/bits/string3.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__nothrow__ , __leaf__)) memset (void *__dest, int __ch, size_t __len)
>{
>  if (__builtin_constant_p (__len) && __len == 0
>      && (!__builtin_constant_p (__ch) || __ch != 0))
>    {
>      __warn_memset_zero_len ();
>      return __dest;
>    }
>  return __builtin___memset_chk (__dest, __ch, __len, __builtin_object_size (__dest, 0));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void
>__attribute__ ((__nothrow__ , __leaf__)) bcopy (const void *__src, void *__dest, size_t __len)
>{
>  (void) __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void
>__attribute__ ((__nothrow__ , __leaf__)) bzero (void *__dest, size_t __len)
>{
>  (void) __builtin___memset_chk (__dest, '\0', __len, __builtin_object_size (__dest, 0));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) strcpy (char *__restrict __dest, const char *__restrict __src)
>{
>  return __builtin___strcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) stpcpy (char *__restrict __dest, const char *__restrict __src)
>{
>  return __builtin___stpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) strncpy (char *__restrict __dest, const char *__restrict __src, size_t __len)
>
>{
>  return __builtin___strncpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>extern char *__stpncpy_chk (char *__dest, const char *__src, size_t __n,
>       size_t __destlen) __attribute__ ((__nothrow__ , __leaf__));
>extern char *__stpncpy_alias (char *__dest, const char *__src, size_t __n) __asm__ ("" "stpncpy") __attribute__ ((__nothrow__ , __leaf__))
>                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) stpncpy (char *__dest, const char *__src, size_t __n)
>{
>  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1
>      && (!__builtin_constant_p (__n) || __n <= __builtin_object_size (__dest, 2 > 1)))
>    return __stpncpy_chk (__dest, __src, __n, __builtin_object_size (__dest, 2 > 1));
>  return __stpncpy_alias (__dest, __src, __n);
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) strcat (char *__restrict __dest, const char *__restrict __src)
>{
>  return __builtin___strcat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) strncat (char *__restrict __dest, const char *__restrict __src, size_t __len)
>
>{
>  return __builtin___strncat_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
>}
># 639 "/usr/include/string.h" 2 3 4
>
>
>
>
># 46 "mdadm.h" 2
># 1 "/usr/include/syslog.h" 1 3 4
># 1 "/usr/include/sys/syslog.h" 1 3 4
># 37 "/usr/include/sys/syslog.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stdarg.h" 1 3 4
># 38 "/usr/include/sys/syslog.h" 2 3 4
>
>
># 1 "/usr/include/bits/syslog-path.h" 1 3 4
># 41 "/usr/include/sys/syslog.h" 2 3 4
># 169 "/usr/include/sys/syslog.h" 3 4
>
>
>
>
>
>
>extern void closelog (void);
>
>
>
>
>
>extern void openlog (const char *__ident, int __option, int __facility);
>
>
>extern int setlogmask (int __mask) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern void syslog (int __pri, const char *__fmt, ...)
>     __attribute__ ((__format__ (__printf__, 2, 3)));
># 200 "/usr/include/sys/syslog.h" 3 4
>extern void vsyslog (int __pri, const char *__fmt, __gnuc_va_list __ap)
>     __attribute__ ((__format__ (__printf__, 2, 0)));
>
>
>
>
>
># 1 "/usr/include/bits/syslog.h" 1 3 4
># 24 "/usr/include/bits/syslog.h" 3 4
>extern void __syslog_chk (int __pri, int __flag, const char *__fmt, ...)
>     __attribute__ ((__format__ (__printf__, 3, 4)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void
>syslog (int __pri, const char *__fmt, ...)
>{
>  __syslog_chk (__pri, 2 - 1, __fmt, __builtin_va_arg_pack ());
>}
>
>
>
>
>
>
>
>extern void __vsyslog_chk (int __pri, int __flag, const char *__fmt,
>      __gnuc_va_list __ap)
>     __attribute__ ((__format__ (__printf__, 3, 0)));
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void
>vsyslog (int __pri, const char *__fmt, __gnuc_va_list __ap)
>{
>  __vsyslog_chk (__pri, 2 - 1, __fmt, __ap);
>}
># 208 "/usr/include/sys/syslog.h" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/syslog.h" 2 3 4
># 47 "mdadm.h" 2
># 55 "mdadm.h"
># 1 "/usr/include/linux/kdev_t.h" 1 3 4
># 56 "mdadm.h" 2
>
># 1 "/usr/include/sys/mount.h" 1 3 4
># 25 "/usr/include/sys/mount.h" 3 4
># 1 "/usr/include/sys/ioctl.h" 1 3 4
># 23 "/usr/include/sys/ioctl.h" 3 4
>
>
>
># 1 "/usr/include/bits/ioctls.h" 1 3 4
># 23 "/usr/include/bits/ioctls.h" 3 4
># 1 "/usr/include/asm/ioctls.h" 1 3 4
>
>
>
># 1 "/usr/include/asm/ioctl.h" 1 3 4
># 11 "/usr/include/asm/ioctl.h" 3 4
># 1 "/usr/include/asm-generic/ioctl.h" 1 3 4
># 12 "/usr/include/asm/ioctl.h" 2 3 4
># 5 "/usr/include/asm/ioctls.h" 2 3 4
># 24 "/usr/include/bits/ioctls.h" 2 3 4
># 27 "/usr/include/sys/ioctl.h" 2 3 4
>
>
># 1 "/usr/include/bits/ioctl-types.h" 1 3 4
>
>
>
>
># 1 "/usr/include/termios.h" 1 3 4
># 36 "/usr/include/termios.h" 3 4
>
>
>
>
># 1 "/usr/include/bits/termios.h" 1 3 4
># 22 "/usr/include/bits/termios.h" 3 4
>typedef unsigned char cc_t;
>typedef unsigned int speed_t;
>typedef unsigned int tcflag_t;
># 33 "/usr/include/bits/termios.h" 3 4
>struct termios {
> tcflag_t c_iflag;
> tcflag_t c_oflag;
> tcflag_t c_cflag;
> tcflag_t c_lflag;
> cc_t c_line;
> cc_t c_cc[32];
> speed_t c_ispeed;
> speed_t c_ospeed;
>
>
>};
># 225 "/usr/include/bits/termios.h" 3 4
>struct sgttyb {
> char sg_ispeed;
> char sg_ospeed;
> char sg_erase;
> char sg_kill;
> short sg_flags;
>};
>
>struct tchars {
> char t_intrc;
> char t_quitc;
> char t_startc;
> char t_stopc;
> char t_eofc;
> char t_brkc;
>};
>
>struct ltchars {
> char t_suspc;
> char t_dsuspc;
> char t_rprntc;
> char t_flushc;
> char t_werasc;
> char t_lnextc;
>};
># 260 "/usr/include/bits/termios.h" 3 4
>struct winsize {
> unsigned short ws_row;
> unsigned short ws_col;
> unsigned short ws_xpixel;
> unsigned short ws_ypixel;
>};
>
>
>struct termio {
> unsigned short c_iflag;
> unsigned short c_oflag;
> unsigned short c_cflag;
> unsigned short c_lflag;
> unsigned char c_line;
> unsigned char c_cc[10];
>};
># 41 "/usr/include/termios.h" 2 3 4
># 49 "/usr/include/termios.h" 3 4
>extern speed_t cfgetospeed (const struct termios *__termios_p) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern speed_t cfgetispeed (const struct termios *__termios_p) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int cfsetospeed (struct termios *__termios_p, speed_t __speed) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int cfsetispeed (struct termios *__termios_p, speed_t __speed) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int cfsetspeed (struct termios *__termios_p, speed_t __speed) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int tcgetattr (int __fd, struct termios *__termios_p) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int tcsetattr (int __fd, int __optional_actions,
>        const struct termios *__termios_p) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern void cfmakeraw (struct termios *__termios_p) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int tcsendbreak (int __fd, int __duration) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int tcdrain (int __fd);
>
>
>
>extern int tcflush (int __fd, int __queue_selector) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int tcflow (int __fd, int __action) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern __pid_t tcgetsid (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
># 1 "/usr/include/sys/ttydefaults.h" 1 3 4
># 106 "/usr/include/termios.h" 2 3 4
>
>
>
># 5 "/usr/include/bits/ioctl-types.h" 2 3 4
># 30 "/usr/include/sys/ioctl.h" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/sys/ttydefaults.h" 1 3 4
># 37 "/usr/include/sys/ioctl.h" 2 3 4
>
>
>
>
>extern int ioctl (int __fd, unsigned long int __request, ...) __attribute__ ((__nothrow__ , __leaf__));
>
>
># 26 "/usr/include/sys/mount.h" 2 3 4
>
>
>
>
>
>
>
>enum
>{
>  MS_RDONLY = 1,
>
>  MS_NOSUID = 2,
>
>  MS_NODEV = 4,
>
>  MS_NOEXEC = 8,
>
>  MS_SYNCHRONOUS = 16,
>
>  MS_REMOUNT = 32,
>
>  MS_MANDLOCK = 64,
>
>  MS_DIRSYNC = 128,
>
>  MS_NOATIME = 1024,
>
>  MS_NODIRATIME = 2048,
>
>  MS_BIND = 4096,
>
>  MS_MOVE = 8192,
>
>  MS_REC = 16384,
>
>  MS_SILENT = 32768,
>
>  MS_POSIXACL = 1 << 16,
>
>  MS_UNBINDABLE = 1 << 17,
>
>  MS_PRIVATE = 1 << 18,
>
>  MS_SLAVE = 1 << 19,
>
>  MS_SHARED = 1 << 20,
>
>  MS_RELATIME = 1 << 21,
>
>  MS_KERNMOUNT = 1 << 22,
>
>  MS_I_VERSION = 1 << 23,
>
>  MS_STRICTATIME = 1 << 24,
>
>  MS_ACTIVE = 1 << 30,
>
>  MS_NOUSER = 1 << 31
>
>};
># 119 "/usr/include/sys/mount.h" 3 4
>enum
>{
>  MNT_FORCE = 1,
>
>  MNT_DETACH = 2,
>
>  MNT_EXPIRE = 4,
>
>  UMOUNT_NOFOLLOW = 8
>
>};
>
>
>
>
>
>extern int mount (const char *__special_file, const char *__dir,
>    const char *__fstype, unsigned long int __rwflag,
>    const void *__data) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int umount (const char *__special_file) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int umount2 (const char *__special_file, int __flags) __attribute__ ((__nothrow__ , __leaf__));
>
>
># 58 "mdadm.h" 2
># 1 "/usr/include/asm/types.h" 1 3 4
># 13 "/usr/include/asm/types.h" 3 4
># 1 "/usr/include/asm-generic/int-l64.h" 1 3 4
># 11 "/usr/include/asm-generic/int-l64.h" 3 4
># 1 "/usr/include/asm/bitsperlong.h" 1 3 4
># 10 "/usr/include/asm/bitsperlong.h" 3 4
># 1 "/usr/include/asm-generic/bitsperlong.h" 1 3 4
># 11 "/usr/include/asm/bitsperlong.h" 2 3 4
># 12 "/usr/include/asm-generic/int-l64.h" 2 3 4
>
>
>
>
>
>
>
>typedef __signed__ char __s8;
>typedef unsigned char __u8;
>
>typedef __signed__ short __s16;
>typedef unsigned short __u16;
>
>typedef __signed__ int __s32;
>typedef unsigned int __u32;
>
>typedef __signed__ long __s64;
>typedef unsigned long __u64;
># 14 "/usr/include/asm/types.h" 2 3 4
># 33 "/usr/include/asm/types.h" 3 4
>typedef struct {
> __u32 u[4];
>} __attribute__((aligned(16))) __vector128;
># 59 "mdadm.h" 2
># 105 "mdadm.h"
># 1 "md_u.h" 1
># 48 "md_u.h"
>typedef struct mdu_version_s {
> int major;
> int minor;
> int patchlevel;
>} mdu_version_t;
>
>typedef struct mdu_array_info_s {
>
>
>
> int major_version;
> int minor_version;
> int patch_version;
> int ctime;
> int level;
> int size;
> int nr_disks;
> int raid_disks;
> int md_minor;
> int not_persistent;
>
>
>
>
> int utime;
> int state;
> int active_disks;
> int working_disks;
> int failed_disks;
> int spare_disks;
>
>
>
>
> int layout;
> int chunk_size;
>
>} mdu_array_info_t;
>
>typedef struct mdu_disk_info_s {
>
>
>
> int number;
> int major;
> int minor;
> int raid_disk;
> int state;
>
>} mdu_disk_info_t;
>
>typedef struct mdu_start_info_s {
>
>
>
> int major;
> int minor;
> int raid_disk;
> int state;
>
>} mdu_start_info_t;
>
>typedef struct mdu_bitmap_file_s
>{
> char pathname[4096];
>} mdu_bitmap_file_t;
>
>typedef struct mdu_param_s
>{
> int personality;
> int chunk_size;
> int max_fault;
>} mdu_param_t;
># 106 "mdadm.h" 2
># 1 "md_p.h" 1
># 87 "md_p.h"
>typedef struct mdp_device_descriptor_s {
> __u32 number;
> __u32 major;
> __u32 minor;
> __u32 raid_disk;
> __u32 state;
> __u32 reserved[32 - 5];
>} mdp_disk_t;
># 109 "md_p.h"
>typedef struct mdp_superblock_s {
>
>
>
> __u32 md_magic;
> __u32 major_version;
> __u32 minor_version;
> __u32 patch_version;
> __u32 gvalid_words;
> __u32 set_uuid0;
> __u32 ctime;
> __u32 level;
> __u32 size;
> __u32 nr_disks;
> __u32 raid_disks;
> __u32 md_minor;
> __u32 not_persistent;
> __u32 set_uuid1;
> __u32 set_uuid2;
> __u32 set_uuid3;
> __u32 gstate_creserved[32 - 16];
>
>
>
>
> __u32 utime;
> __u32 state;
> __u32 active_disks;
> __u32 working_disks;
> __u32 failed_disks;
> __u32 spare_disks;
> __u32 sb_csum;
>
> __u32 events_hi;
> __u32 events_lo;
> __u32 cp_events_hi;
> __u32 cp_events_lo;
>
>
>
>
>
>
> __u32 recovery_cp;
>
> __u64 reshape_position;
> __u32 new_level;
> __u32 delta_disks;
> __u32 new_layout;
> __u32 new_chunk;
> __u32 gstate_sreserved[32 - 18];
>
>
>
>
> __u32 layout;
> __u32 chunk_size;
> __u32 root_pv;
> __u32 root_block;
> __u32 pstate_reserved[64 - 4];
>
>
>
>
> mdp_disk_t disks[27];
>
>
>
>
> __u32 reserved[(1024 - (32 + 32) - 64 - (27*32) - 32)];
>
>
>
>
> mdp_disk_t this_disk;
>
>} mdp_super_t;
>
>
>
>
>
>static inline __u64 md_event(mdp_super_t *sb) {
> __u64 ev = sb->events_hi;
> return (ev<<32)| sb->events_lo;
>}
># 107 "mdadm.h" 2
># 1 "bitmap.h" 1
># 140 "bitmap.h"
>enum bitmap_state {
> BITMAP_ACTIVE = 0x001,
> BITMAP_STALE = 0x002
>};
>
>
>typedef struct bitmap_super_s {
> __u32 magic;
> __u32 version;
> __u8 uuid[16];
> __u64 events;
> __u64 events_cleared;
> __u64 sync_size;
> __u32 state;
> __u32 chunksize;
> __u32 daemon_sleep;
> __u32 write_behind;
>
> __u8 pad[256 - 64];
>} bitmap_super_t;
># 108 "mdadm.h" 2
># 1 "msg.h" 1
># 21 "msg.h"
>struct mdinfo;
>struct metadata_update;
>
>extern int receive_message(int fd, struct metadata_update *msg, int tmo);
>extern int send_message(int fd, struct metadata_update *msg, int tmo);
>extern int ack(int fd, int tmo);
>extern int wait_reply(int fd, int tmo);
>extern int connect_monitor(char *devname);
>extern int ping_monitor(char *devname);
>extern int ping_monitor_by_id(int devnum);
>extern int block_subarray(struct mdinfo *sra);
>extern int unblock_subarray(struct mdinfo *sra, const int unfreeze);
>extern int block_monitor(char *container, const int freeze);
>extern void unblock_monitor(char *container, const int unfreeze);
>extern int fping_monitor(int sock);
>extern int ping_manager(char *devname);
>extern void flush_mdmon(char *container);
># 109 "mdadm.h" 2
># 184 "mdadm.h"
>struct mdinfo {
> mdu_array_info_t array;
> mdu_disk_info_t disk;
> __u64 events;
> int uuid[4];
> char name[33];
> unsigned long long data_offset;
> unsigned long long component_size;
>
>
> unsigned long long custom_array_size;
>
>
>
>
>
> int reshape_active;
> unsigned long long reshape_progress;
> int recovery_blocked;
>
>
>
>
>
>
> union {
>  unsigned long long resync_start;
>  unsigned long long recovery_start;
>
> };
> long bitmap_offset;
> unsigned long safe_mode_delay;
> int new_level, delta_disks, new_layout, new_chunk;
> int errors;
> unsigned long cache_size;
> int mismatch_cnt;
> char text_version[50];
>
> int container_member;
>
>
> int container_enough;
>
>
> char sys_name[20];
> struct mdinfo *devs;
> struct mdinfo *next;
>
>
> int recovery_fd;
> int state_fd;
>
>
>
>
>
>
>
> int prev_state, curr_state, next_state;
>
>};
>
>struct createinfo {
> int uid;
> int gid;
> int autof;
> int mode;
> int symlinks;
> struct supertype *supertype;
>};
>
>
>
>enum mode {
> ASSEMBLE=1,
> BUILD,
> CREATE,
> MANAGE,
> MISC,
> MONITOR,
> GROW,
> INCREMENTAL,
> AUTODETECT,
>};
>
>extern char short_options[];
>extern char short_bitmap_options[];
>extern char short_bitmap_auto_options[];
>extern struct option long_options[];
>extern char Version[], Usage[], Help[], OptionHelp[],
> Help_create[], Help_build[], Help_assemble[], Help_grow[],
> Help_incr[],
> Help_manage[], Help_misc[], Help_monitor[], Help_config[];
>
>
>
>
>enum special_options {
> AssumeClean = 300,
> BitmapChunk,
> WriteBehind,
> ReAdd,
> NoDegraded,
> Sparc22,
> BackupFile,
> HomeHost,
> AutoHomeHost,
> Symlinks,
> AutoDetect,
> Waitclean,
> DetailPlatform,
> KillSubarray,
> UpdateSubarray,
> IncrementalPath,
> NoSharing,
> HelpOptions,
> Brief,
> ManageOpt,
> Add,
> Remove,
> Fail,
> MiscOpt,
> WaitOpt,
> ConfigFile,
> ChunkSize,
> WriteMostly,
> Layout,
> Auto,
> Force,
> SuperMinor,
> EMail,
> ProgramOpt,
> Increment,
> Fork,
> Bitmap,
> RebuildMapOpt,
> InvalidBackup,
> UdevRules,
> FreezeReshape,
> Continue,
> OffRootOpt,
> Prefer,
>};
># 339 "mdadm.h"
>struct mddev_ident {
> char *devname;
>
> int uuid_set;
> int uuid[4];
> char name[33];
>
> int super_minor;
>
> char *devices;
>
>
> int level;
> int raid_disks;
> int spare_disks;
> struct supertype *st;
> int autof;
> char *spare_group;
> char *bitmap_file;
> int bitmap_fd;
>
> char *container;
>
>
>
>
> char *member;
>
> struct mddev_ident *next;
> union {
>
>  int assembled;
> };
>};
>
>
>struct mddev_dev {
> char *devname;
> int disposition;
>
>
> char writemostly;
> char re_add;
> char used;
> struct mddev_dev *next;
>};
>
>typedef struct mapping {
> char *name;
> int num;
>} mapping_t;
>
>
>struct mdstat_ent {
> char *dev;
> int devnum;
> int active;
> char *level;
> char *pattern;
> int percent;
> int resync;
> int devcnt;
> int raid_disks;
> char * metadata_version;
> struct dev_member {
>  char *name;
>  struct dev_member *next;
> } *members;
> struct mdstat_ent *next;
>};
>
>extern struct mdstat_ent *mdstat_read(int hold, int start);
>extern void free_mdstat(struct mdstat_ent *ms);
>extern void mdstat_wait(int seconds);
>extern void mdstat_wait_fd(int fd, const sigset_t *sigmask);
>extern int mddev_busy(int devnum);
>extern struct mdstat_ent *mdstat_by_component(char *name);
>extern struct mdstat_ent *mdstat_by_subdev(char *subdev, int container);
>
>struct map_ent {
> struct map_ent *next;
> int devnum;
> char metadata[20];
> int uuid[4];
> int bad;
> char *path;
>};
>extern int map_update(struct map_ent **mpp, int devnum, char *metadata,
>        int uuid[4], char *path);
>extern void map_remove(struct map_ent **map, int devnum);
>extern struct map_ent *map_by_uuid(struct map_ent **map, int uuid[4]);
>extern struct map_ent *map_by_devnum(struct map_ent **map, int devnum);
>extern struct map_ent *map_by_name(struct map_ent **map, char *name);
>extern void map_read(struct map_ent **melp);
>extern int map_write(struct map_ent *mel);
>extern void map_delete(struct map_ent **mapp, int devnum);
>extern void map_free(struct map_ent *map);
>extern void map_add(struct map_ent **melp,
>      int devnum, char *metadata, int uuid[4], char *path);
>extern int map_lock(struct map_ent **melp);
>extern void map_unlock(struct map_ent **melp);
>extern void map_fork(void);
>
>
>enum sysfs_read_flags {
> GET_LEVEL = (1 << 0),
> GET_LAYOUT = (1 << 1),
> GET_COMPONENT = (1 << 2),
> GET_CHUNK = (1 << 3),
> GET_CACHE = (1 << 4),
> GET_MISMATCH = (1 << 5),
> GET_VERSION = (1 << 6),
> GET_DISKS = (1 << 7),
> GET_DEGRADED = (1 << 8),
> GET_SAFEMODE = (1 << 9),
> GET_BITMAP_LOCATION = (1 << 10),
>
> GET_DEVS = (1 << 20),
> GET_OFFSET = (1 << 21),
> GET_SIZE = (1 << 22),
> GET_STATE = (1 << 23),
> GET_ERROR = (1 << 24),
>};
>
>
>
>
>extern int sysfs_open(int devnum, char *devname, char *attr);
>extern void sysfs_init(struct mdinfo *mdi, int fd, int devnum);
>extern void sysfs_free(struct mdinfo *sra);
>extern struct mdinfo *sysfs_read(int fd, int devnum, unsigned long options);
>extern int sysfs_attr_match(const char *attr, const char *str);
>extern int sysfs_match_word(const char *word, char **list);
>extern int sysfs_set_str(struct mdinfo *sra, struct mdinfo *dev,
>    char *name, char *val);
>extern int sysfs_set_num(struct mdinfo *sra, struct mdinfo *dev,
>    char *name, unsigned long long val);
>extern int sysfs_set_num_signed(struct mdinfo *sra, struct mdinfo *dev,
>    char *name, long long val);
>extern int sysfs_uevent(struct mdinfo *sra, char *event);
>extern int sysfs_get_fd(struct mdinfo *sra, struct mdinfo *dev,
>   char *name);
>extern int sysfs_fd_get_ll(int fd, unsigned long long *val);
>extern int sysfs_get_ll(struct mdinfo *sra, struct mdinfo *dev,
>   char *name, unsigned long long *val);
>extern int sysfs_fd_get_str(int fd, char *val, int size);
>extern int sysfs_attribute_available(struct mdinfo *sra, struct mdinfo *dev,
>         char *name);
>extern int sysfs_get_str(struct mdinfo *sra, struct mdinfo *dev,
>    char *name, char *val, int size);
>extern int sysfs_set_safemode(struct mdinfo *sra, unsigned long ms);
>extern int sysfs_set_array(struct mdinfo *info, int vers);
>extern int sysfs_add_disk(struct mdinfo *sra, struct mdinfo *sd, int resume);
>extern int sysfs_disk_to_scsi_id(int fd, __u32 *id);
>extern int sysfs_unique_holder(int devnum, long rdev);
>extern int sysfs_freeze_array(struct mdinfo *sra);
>extern int load_sys(char *path, char *buf);
>extern int reshape_prepare_fdlist(char *devname,
>      struct mdinfo *sra,
>      int raid_disks,
>      int nrdisks,
>      unsigned long blocks,
>      char *backup_file,
>      int *fdlist,
>      unsigned long long *offsets);
>extern void reshape_free_fdlist(int *fdlist,
>    unsigned long long *offsets,
>    int size);
>extern int reshape_open_backup_file(char *backup,
>        int fd,
>        char *devname,
>        long blocks,
>        int *fdlist,
>        unsigned long long *offsets,
>        int restart);
>extern unsigned long compute_backup_blocks(int nchunk, int ochunk,
>        unsigned int ndata, unsigned int odata);
>
>extern int save_stripes(int *source, unsigned long long *offsets,
>   int raid_disks, int chunk_size, int level, int layout,
>   int nwrites, int *dest,
>   unsigned long long start, unsigned long long length,
>   char *buf);
>extern int restore_stripes(int *dest, unsigned long long *offsets,
>      int raid_disks, int chunk_size, int level, int layout,
>      int source, unsigned long long read_offset,
>      unsigned long long start, unsigned long long length,
>      char *src_buf);
>
>
>
>
>
>
>
>extern char *map_num(mapping_t *map, int num);
>extern int map_name(mapping_t *map, char *name);
>extern mapping_t r5layout[], r6layout[], pers[], modes[], faultylayout[];
>
>extern char *map_dev_preferred(int major, int minor, int create,
>          char *prefer);
>static inline char *map_dev(int major, int minor, int create)
>{
> return map_dev_preferred(major, minor, create, ((void *)0));
>}
>
>struct active_array;
>struct metadata_update;
># 561 "mdadm.h"
>struct reshape {
> int level;
> int parity;
> struct {
>  int layout;
>  int data_disks;
> } before, after;
> unsigned long long backup_blocks;
> unsigned long long stripes;
> unsigned long long new_size;
>};
># 600 "mdadm.h"
>extern struct superswitch {
>
>
>
>
> void (*examine_super)(struct supertype *st, char *homehost);
> void (*brief_examine_super)(struct supertype *st, int verbose);
> void (*brief_examine_subarrays)(struct supertype *st, int verbose);
> void (*export_examine_super)(struct supertype *st);
>
>
>
>
> void (*detail_super)(struct supertype *st, char *homehost);
> void (*brief_detail_super)(struct supertype *st);
> void (*export_detail_super)(struct supertype *st);
>
>
> int (*detail_platform)(int verbose, int enumerate_only);
>
>
>
>
>
>
> void (*uuid_from_super)(struct supertype *st, int uuid[4]);
># 642 "mdadm.h"
> void (*getinfo_super)(struct supertype *st, struct mdinfo *info, char *map);
> struct mdinfo *(*getinfo_super_disks)(struct supertype *st);
>
>
>
> int (*match_home)(struct supertype *st, char *homehost);
># 672 "mdadm.h"
> int (*update_super)(struct supertype *st, struct mdinfo *info,
>       char *update,
>       char *devname, int verbose,
>       int uuid_set, char *homehost);
>
>
>
>
>
>
> int (*init_super)(struct supertype *st, mdu_array_info_t *info,
>     unsigned long long size, char *name,
>     char *homehost, int *uuid);
>
>
>
>
> int (*add_to_super)(struct supertype *st, mdu_disk_info_t *dinfo,
>       int fd, char *devname);
>
>
>
> int (*remove_from_super)(struct supertype *st, mdu_disk_info_t *dinfo);
>
>
>
>
> int (*store_super)(struct supertype *st, int fd);
>
>
>
> int (*write_init_super)(struct supertype *st);
> int (*compare_super)(struct supertype *st, struct supertype *tst);
> int (*load_super)(struct supertype *st, int fd, char *devname);
> int (*load_container)(struct supertype *st, int fd, char *devname);
> struct supertype * (*match_metadata_desc)(char *arg);
> __u64 (*avail_size)(struct supertype *st, __u64 size);
> unsigned long long (*min_acceptable_spare_size)(struct supertype *st);
> int (*add_internal_bitmap)(struct supertype *st, int *chunkp,
>       int delay, int write_behind,
>       unsigned long long size, int may_change, int major);
> void (*locate_bitmap)(struct supertype *st, int fd);
> int (*write_bitmap)(struct supertype *st, int fd);
> void (*free_super)(struct supertype *st);
># 732 "mdadm.h"
> int (*validate_geometry)(struct supertype *st, int level, int layout,
>     int raiddisks,
>     int *chunk, unsigned long long size,
>     char *subdev, unsigned long long *freesize,
>     int verbose);
>
> struct mdinfo *(*container_content)(struct supertype *st, char *subarray);
>
> void (*default_geometry)(struct supertype *st, int *level, int *layout, int *chunk);
>
> int (*kill_subarray)(struct supertype *st);
>
> int (*update_subarray)(struct supertype *st, char *subarray,
>          char *update, struct mddev_ident *ident);
># 754 "mdadm.h"
> int (*reshape_super)(struct supertype *st, long long size, int level,
>        int layout, int chunksize, int raid_disks,
>        int delta_disks, char *backup, char *dev,
>        int direction,
>        int verbose);
> int (*manage_reshape)(
>  int afd, struct mdinfo *sra, struct reshape *reshape,
>  struct supertype *st, unsigned long blocks,
>  int *fds, unsigned long long *offsets,
>  int dests, int *destfd, unsigned long long *destoffsets);
>
>
> int (*open_new)(struct supertype *c, struct active_array *a,
>   char *inst);
># 780 "mdadm.h"
> int (*set_array_state)(struct active_array *a, int consistent);
># 789 "mdadm.h"
> void (*set_disk)(struct active_array *a, int n, int state);
> void (*sync_metadata)(struct supertype *st);
> void (*process_update)(struct supertype *st,
>          struct metadata_update *update);
> void (*prepare_update)(struct supertype *st,
>          struct metadata_update *update);
># 803 "mdadm.h"
> struct mdinfo *(*activate_spare)(struct active_array *a,
>      struct metadata_update **updates);
># 819 "mdadm.h"
> const char *(*get_disk_controller_domain)(const char *path);
>
>
> int (*recover_backup)(struct supertype *st, struct mdinfo *info);
>
> int swapuuid;
> int external;
> const char *name;
>} *superlist[];
>
>extern struct superswitch super0, super1;
>extern struct superswitch super_imsm, super_ddf;
>extern struct superswitch mbr, gpt;
>
>struct metadata_update {
> int len;
> char *buf;
> void *space;
> void **space_list;
>
>
> struct metadata_update *next;
>};
># 860 "mdadm.h"
>struct supertype {
> struct superswitch *ss;
> int minor_version;
> int max_devs;
> int container_dev;
> void *sb;
> void *info;
> int ignore_hw_compat;
>
>
>
>
> struct metadata_update *updates;
> struct metadata_update **update_tail;
>
>
> struct active_array *arrays;
> int sock;
> int devnum;
> char *devname;
>
>
> int devcnt;
> int retry_soon;
>
> struct mdinfo *devs;
>
>};
>
>extern struct supertype *super_by_fd(int fd, char **subarray);
>enum guess_types { guess_any, guess_array, guess_partitions };
>extern struct supertype *guess_super_type(int fd, enum guess_types guess_type);
>static inline struct supertype *guess_super(int fd) {
> return guess_super_type(fd, guess_any);
>}
>extern struct supertype *dup_super(struct supertype *st);
>extern int get_dev_size(int fd, char *dname, unsigned long long *sizep);
>extern int must_be_container(int fd);
>extern int dev_size_from_id(dev_t id, unsigned long long *size);
>extern void get_one_disk(int mdfd, mdu_array_info_t *ainf,
>    mdu_disk_info_t *disk);
>void wait_for(char *dev, int fd);
>
>
>
>
>
>
>
>struct dev_policy {
> struct dev_policy *next;
> char *name;
>
>
>
>
> const char *metadata;
> const char *value;
>};
>
>extern char pol_act[], pol_domain[], pol_metadata[], pol_auto[];
># 937 "mdadm.h"
>struct pol_rule {
> struct pol_rule *next;
> char *type;
> struct rule {
>  struct rule *next;
>  char *name;
>  char *value;
>  char *dups;
> } *rule;
>};
>
>extern char rule_policy[], rule_part[];
>extern char rule_path[], rule_type[];
>extern char type_part[], type_disk[];
>
>extern void policyline(char *line, char *type);
>extern void policy_add(char *type, ...);
>extern void policy_free(void);
>
>extern struct dev_policy *path_policy(char *path, char *type);
>extern struct dev_policy *disk_policy(struct mdinfo *disk);
>extern struct dev_policy *devnum_policy(int dev);
>extern void dev_policy_free(struct dev_policy *p);
>
>
>extern void pol_add(struct dev_policy **pol, char *name, char *val, char *metadata);
>extern struct dev_policy *pol_find(struct dev_policy *pol, char *name);
>
>enum policy_action {
> act_default,
> act_include,
> act_re_add,
> act_spare,
> act_spare_same_slot,
>
> act_force_spare,
> act_err
>};
>
>extern int policy_action_allows(struct dev_policy *plist, const char *metadata,
>    enum policy_action want);
>extern int disk_action_allows(struct mdinfo *disk, const char *metadata,
>         enum policy_action want);
>
>struct domainlist {
> struct domainlist *next;
> const char *dom;
>};
>
>extern int domain_test(struct domainlist *dom, struct dev_policy *pol,
>         const char *metadata);
>extern struct domainlist *domain_from_array(struct mdinfo *mdi,
>         const char *metadata);
>extern void domainlist_add_dev(struct domainlist **dom, int devnum,
>          const char *metadata);
>extern void domain_free(struct domainlist *dl);
>extern void domain_merge(struct domainlist **domp, struct dev_policy *pol,
>    const char *metadata);
>void domain_add(struct domainlist **domp, char *domain);
>
>extern void policy_save_path(char *id_path, struct map_ent *array);
>extern int policy_check_path(struct mdinfo *disk, struct map_ent *array);
># 1035 "mdadm.h"
># 1 "/usr/include/ftw.h" 1 3 4
># 31 "/usr/include/ftw.h" 3 4
>
>
>
>
>enum
>{
>  FTW_F,
>
>  FTW_D,
>
>  FTW_DNR,
>
>  FTW_NS,
>
>
>
>
>  FTW_SL,
>
>
>
>
>
>  FTW_DP,
>
>  FTW_SLN
>
>
>
>};
>
>
>
>
>enum
>{
>  FTW_PHYS = 1,
>
>  FTW_MOUNT = 2,
>
>
>  FTW_CHDIR = 4,
>
>  FTW_DEPTH = 8
>
>
>  ,
>  FTW_ACTIONRETVAL = 16
>
>
>
>};
>
>
>
>enum
>{
>  FTW_CONTINUE = 0,
>
>
>  FTW_STOP = 1,
>
>
>  FTW_SKIP_SUBTREE = 2,
>
>
>
>  FTW_SKIP_SIBLINGS = 3,
>
>
>};
>
>
>
>struct FTW
>  {
>    int base;
>    int level;
>  };
>
>
>
>
>typedef int (*__ftw_func_t) (const char *__filename,
>        const struct stat *__status, int __flag);
>
>typedef int (*__ftw64_func_t) (const char *__filename,
>          const struct stat64 *__status, int __flag);
>
>
>typedef int (*__nftw_func_t) (const char *__filename,
>         const struct stat *__status, int __flag,
>         struct FTW *__info);
>
>typedef int (*__nftw64_func_t) (const char *__filename,
>    const struct stat64 *__status,
>    int __flag, struct FTW *__info);
># 140 "/usr/include/ftw.h" 3 4
>extern int ftw (const char *__dir, __ftw_func_t __func, int __descriptors) __asm__ ("" "ftw64")
>                                   __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int ftw64 (const char *__dir, __ftw64_func_t __func,
>    int __descriptors) __attribute__ ((__nonnull__ (1, 2)));
># 162 "/usr/include/ftw.h" 3 4
>extern int nftw (const char *__dir, __nftw_func_t __func, int __descriptors, int __flag) __asm__ ("" "nftw64")
>
>     __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int nftw64 (const char *__dir, __nftw64_func_t __func,
>     int __descriptors, int __flag) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
># 1036 "mdadm.h" 2
>
>
>extern int add_dev(const char *name, const struct stat *stb, int flag, struct FTW *s);
>
>
>extern int Manage_ro(char *devname, int fd, int readonly);
>extern int Manage_runstop(char *devname, int fd, int runstop, int quiet);
>extern int Manage_resize(char *devname, int fd, long long size, int raid_disks);
>extern int Manage_subdevs(char *devname, int fd,
>     struct mddev_dev *devlist, int verbose, int test,
>     char *update, int force);
>extern int autodetect(void);
>extern int Grow_Add_device(char *devname, int fd, char *newdev);
>extern int Grow_addbitmap(char *devname, int fd, char *file, int chunk, int delay, int write_behind, int force);
>extern int Grow_reshape(char *devname, int fd, int quiet, char *backup_file,
>   long long size,
>   int level, char *layout_str, int chunksize, int raid_disks,
>   struct mddev_dev *devlist,
>   int assume_clean, int force);
>extern int Grow_restart(struct supertype *st, struct mdinfo *info,
>   int *fdlist, int cnt, char *backup_file, int verbose);
>extern int Grow_continue(int mdfd, struct supertype *st,
>    struct mdinfo *info, char *backup_file,
>    int freeze_reshape);
>
>extern int restore_backup(struct supertype *st,
>     struct mdinfo *content,
>     int working_disks,
>     int spares,
>     char *backup_file,
>     int verbose);
>extern int Grow_continue_command(char *devname, int fd,
>     char *backup_file, int verbose);
>
>extern int Assemble(struct supertype *st, char *mddev,
>      struct mddev_ident *ident,
>      struct mddev_dev *devlist,
>      char *backup_file, int invalid_backup,
>      int readonly, int runstop,
>      char *update, char *homehost, int require_homehost,
>      int verbose, int force, int freeze_reshape);
>
>extern int Build(char *mddev, int chunk, int level, int layout,
>   int raiddisks, struct mddev_dev *devlist, int assume_clean,
>   char *bitmap_file, int bitmap_chunk, int write_behind,
>   int delay, int verbose, int autof, unsigned long long size);
>
>
>extern int Create(struct supertype *st, char *mddev,
>    int chunk, int level, int layout, unsigned long long size, int raiddisks, int sparedisks,
>    char *name, char *homehost, int *uuid,
>    int subdevs, struct mddev_dev *devlist,
>    int runstop, int verbose, int force, int assume_clean,
>    char *bitmap_file, int bitmap_chunk, int write_behind, int delay, int autof);
>
>extern int Detail(char *dev, int brief, int export, int test, char *homehost, char *prefer);
>extern int Detail_Platform(struct superswitch *ss, int scan, int verbose);
>extern int Query(char *dev);
>extern int Examine(struct mddev_dev *devlist, int brief, int export, int scan,
>     int SparcAdjust, struct supertype *forcest, char *homehost);
>extern int Monitor(struct mddev_dev *devlist,
>     char *mailaddr, char *alert_cmd,
>     int period, int daemonise, int scan, int oneshot,
>     int dosyslog, int test, char *pidfile, int increments,
>     int share, char *prefer);
>
>extern int Kill(char *dev, struct supertype *st, int force, int quiet, int noexcl);
>extern int Kill_subarray(char *dev, char *subarray, int quiet);
>extern int Update_subarray(char *dev, char *subarray, char *update, struct mddev_ident *ident, int quiet);
>extern int Wait(char *dev);
>extern int WaitClean(char *dev, int sock, int verbose);
>
>extern int Incremental(char *devname, int verbose, int runstop,
>         struct supertype *st, char *homehost, int require_homehost,
>         int autof, int freeze_reshape);
>extern void RebuildMap(void);
>extern int IncrementalScan(int verbose);
>extern int IncrementalRemove(char *devname, char *path, int verbose);
>extern int CreateBitmap(char *filename, int force, char uuid[16],
>   unsigned long chunksize, unsigned long daemon_sleep,
>   unsigned long write_behind,
>   unsigned long long array_size,
>   int major);
>extern int ExamineBitmap(char *filename, int brief, struct supertype *st);
>extern int Write_rules(char *rule_name);
>extern int bitmap_update_uuid(int fd, int *uuid, int swap);
>extern unsigned long bitmap_sectors(struct bitmap_super_s *bsb);
>
>extern int md_get_version(int fd);
>extern int get_linux_version(void);
>extern int mdadm_version(char *version);
>extern long long parse_size(char *size);
>extern int parse_uuid(char *str, int uuid[4]);
>extern int parse_layout_10(char *layout);
>extern int parse_layout_faulty(char *layout);
>extern int check_ext2(int fd, char *name);
>extern int check_reiser(int fd, char *name);
>extern int check_raid(int fd, char *name);
>extern int check_partitions(int fd, char *dname,
>       unsigned long long freesize,
>       unsigned long long size);
>
>extern int get_mdp_major(void);
>extern int dev_open(char *dev, int flags);
>extern int open_dev(int devnum);
>extern int open_dev_flags(int devnum, int flags);
>extern int open_dev_excl(int devnum);
>extern int is_standard(char *dev, int *nump);
>extern int same_dev(char *one, char *two);
>
>extern int parse_auto(char *str, char *msg, int config);
>extern struct mddev_ident *conf_get_ident(char *dev);
>extern struct mddev_dev *conf_get_devs(void);
>extern int conf_test_dev(char *devname);
>extern int conf_test_metadata(const char *version, struct dev_policy *pol, int is_homehost);
>extern struct createinfo *conf_get_create_info(void);
>extern void set_conffile(char *file);
>extern char *conf_get_mailaddr(void);
>extern char *conf_get_mailfrom(void);
>extern char *conf_get_program(void);
>extern char *conf_get_homehost(int *require_homehostp);
>extern char *conf_line(FILE *file);
>extern char *conf_word(FILE *file, int allow_key);
>extern int conf_name_is_free(char *name);
>extern int conf_verify_devnames(struct mddev_ident *array_list);
>extern int devname_matches(char *name, char *match);
>extern struct mddev_ident *conf_match(struct supertype *st,
>          struct mdinfo *info,
>          char *devname,
>          int verbose, int *rvp);
>extern int experimental(void);
>
>extern void free_line(char *line);
>extern int match_oneof(char *devices, char *devname);
>extern void uuid_from_super(int uuid[4], mdp_super_t *super);
>extern const int uuid_zero[4];
>extern int same_uuid(int a[4], int b[4], int swapuuid);
>extern void copy_uuid(void *a, int b[4], int swapuuid);
>extern char *__fname_from_uuid(int id[4], int swap, char *buf, char sep);
>extern char *fname_from_uuid(struct supertype *st,
>        struct mdinfo *info, char *buf, char sep);
>extern unsigned long calc_csum(void *super, int bytes);
>extern int enough(int level, int raid_disks, int layout, int clean,
>     char *avail);
>extern int enough_fd(int fd);
>extern int ask(char *mesg);
>extern unsigned long long get_component_size(int fd);
>extern void remove_partitions(int fd);
>extern int test_partition(int fd);
>extern int test_partition_from_id(dev_t id);
>extern int get_data_disks(int level, int layout, int raid_disks);
>extern unsigned long long calc_array_size(int level, int raid_disks, int layout,
>       int chunksize, unsigned long long devsize);
>extern int flush_metadata_updates(struct supertype *st);
>extern void append_metadata_update(struct supertype *st, void *buf, int len);
>extern int assemble_container_content(struct supertype *st, int mdfd,
>          struct mdinfo *content, int runstop,
>          char *chosen_name, int verbose,
>          char *backup_file, int freeze_reshape);
>extern struct mdinfo *container_choose_spares(struct supertype *st,
>           unsigned long long min_size,
>           struct domainlist *domlist,
>           char *spare_group,
>           const char *metadata, int get_one);
>extern int move_spare(char *from_devname, char *to_devname, dev_t devid);
>extern int add_disk(int mdfd, struct supertype *st,
>      struct mdinfo *sra, struct mdinfo *info);
>extern int remove_disk(int mdfd, struct supertype *st,
>         struct mdinfo *sra, struct mdinfo *info);
>extern int set_array_info(int mdfd, struct supertype *st, struct mdinfo *info);
>unsigned long long min_recovery_start(struct mdinfo *array);
>
>extern char *human_size(long long bytes);
>extern char *human_size_brief(long long bytes);
>extern void print_r10_layout(int layout);
>
>
>extern int find_free_devnum(int use_partitions);
>
>extern void put_md_name(char *name);
>extern char *get_md_name(int dev);
>
>extern char DefaultConfFile[];
>
>extern int create_mddev(char *dev, char *name, int autof, int trustworthy,
>   char *chosen);
>
>
>
>
>
>extern int open_mddev(char *dev, int report_errors);
>extern int open_container(int fd);
>extern int is_container_member(struct mdstat_ent *ent, char *devname);
>extern int is_subarray_active(char *subarray, char *devname);
>extern int open_subarray(char *dev, char *subarray, struct supertype *st, int quiet);
>extern struct superswitch *version_to_superswitch(char *vers);
>
>extern int mdmon_running(int devnum);
>extern int mdmon_pid(int devnum);
>extern int check_env(char *name);
>extern __u32 random32(void);
>extern int start_mdmon(int devnum);
>
>extern int child_monitor(int afd, struct mdinfo *sra, struct reshape *reshape,
>    struct supertype *st, unsigned long stripes,
>    int *fds, unsigned long long *offsets,
>    int dests, int *destfd, unsigned long long *destoffsets);
>void abort_reshape(struct mdinfo *sra);
>
>extern char *devnum2devname(int num);
>extern void fmt_devname(char *name, int num);
>extern int devname2devnum(char *name);
>extern int stat2devnum(struct stat *st);
>extern int fd2devnum(int fd);
>
>static inline int dev2major(int d)
>{
> if (d >= 0)
>  return 9;
> else
>  return get_mdp_major();
>}
>
>static inline int dev2minor(int d)
>{
> if (d >= 0)
>  return d;
> return (-1-d) << 6;
>}
>
>
>
>
>
>
>static inline int is_subarray(char *vers)
>{
># 1283 "mdadm.h"
> return (*vers == '/' || *vers == '-');
>}
>
>static inline char *to_subarray(struct mdstat_ent *ent, char *container)
>{
> return &ent->metadata_version[10+strlen(container)+1];
>}
># 1298 "mdadm.h"
># 1 "/usr/include/assert.h" 1 3 4
># 65 "/usr/include/assert.h" 3 4
>
>
>
>extern void __assert_fail (const char *__assertion, const char *__file,
>      unsigned int __line, const char *__function)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, const char *__file,
>      unsigned int __line, const char *__function)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
># 1299 "mdadm.h" 2
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stdarg.h" 1 3 4
># 1300 "mdadm.h" 2
>static inline int xasprintf(char **strp, const char *fmt, ...) {
> va_list ap;
> int ret;
> __builtin_va_start(ap,fmt);
> ret = vasprintf(strp, fmt, ap);
> __builtin_va_end(ap);
> ((ret >= 0) ? (void) (0) : __assert_fail ("ret >= 0", "mdadm.h", 1306, __PRETTY_FUNCTION__));
> return ret;
>}
># 1407 "mdadm.h"
>extern int __offroot;
># 26 "Monitor.c" 2
>
>
># 1 "/usr/include/sys/wait.h" 1 3 4
># 28 "/usr/include/sys/wait.h" 3 4
>
>
># 1 "/usr/include/signal.h" 1 3 4
># 30 "/usr/include/signal.h" 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 103 "/usr/include/bits/sigset.h" 3 4
>extern int __sigismember (const __sigset_t *, int);
>extern int __sigaddset (__sigset_t *, int);
>extern int __sigdelset (__sigset_t *, int);
># 117 "/usr/include/bits/sigset.h" 3 4
>extern __inline int __sigismember (const __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return (__set->__val[__word] & __mask) ? 1 : 0; }
>extern __inline int __sigaddset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] |= __mask), 0); }
>extern __inline int __sigdelset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] &= ~__mask), 0); }
># 33 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>
>
>typedef __sig_atomic_t sig_atomic_t;
>
># 57 "/usr/include/signal.h" 3 4
># 1 "/usr/include/bits/signum.h" 1 3 4
># 58 "/usr/include/signal.h" 2 3 4
># 78 "/usr/include/signal.h" 3 4
># 1 "/usr/include/bits/siginfo.h" 1 3 4
># 24 "/usr/include/bits/siginfo.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 25 "/usr/include/bits/siginfo.h" 2 3 4
>
>
>
>
>
>
>
>typedef union sigval
>  {
>    int sival_int;
>    void *sival_ptr;
>  } sigval_t;
># 50 "/usr/include/bits/siginfo.h" 3 4
>typedef struct
>  {
>    int si_signo;
>    int si_errno;
>
>    int si_code;
>
>    union
>      {
> int _pad[((128 / sizeof (int)) - 4)];
>
>
> struct
>   {
>     __pid_t si_pid;
>     __uid_t si_uid;
>   } _kill;
>
>
> struct
>   {
>     int si_tid;
>     int si_overrun;
>     sigval_t si_sigval;
>   } _timer;
>
>
> struct
>   {
>     __pid_t si_pid;
>     __uid_t si_uid;
>     sigval_t si_sigval;
>   } _rt;
>
>
> struct
>   {
>     __pid_t si_pid;
>     __uid_t si_uid;
>     int si_status;
>     __clock_t si_utime;
>     __clock_t si_stime;
>   } _sigchld;
>
>
> struct
>   {
>     void *si_addr;
>   } _sigfault;
>
>
> struct
>   {
>     long int si_band;
>     int si_fd;
>   } _sigpoll;
>      } _sifields;
>  } siginfo_t;
># 128 "/usr/include/bits/siginfo.h" 3 4
>enum
>{
>  SI_ASYNCNL = -60,
>
>  SI_TKILL = -6,
>
>  SI_SIGIO,
>
>  SI_ASYNCIO,
>
>  SI_MESGQ,
>
>  SI_TIMER,
>
>  SI_QUEUE,
>
>  SI_USER,
>
>  SI_KERNEL = 0x80
>
>};
>
>
>
>enum
>{
>  ILL_ILLOPC = 1,
>
>  ILL_ILLOPN,
>
>  ILL_ILLADR,
>
>  ILL_ILLTRP,
>
>  ILL_PRVOPC,
>
>  ILL_PRVREG,
>
>  ILL_COPROC,
>
>  ILL_BADSTK
>
>};
>
>
>enum
>{
>  FPE_INTDIV = 1,
>
>  FPE_INTOVF,
>
>  FPE_FLTDIV,
>
>  FPE_FLTOVF,
>
>  FPE_FLTUND,
>
>  FPE_FLTRES,
>
>  FPE_FLTINV,
>
>  FPE_FLTSUB
>
>};
>
>
>enum
>{
>  SEGV_MAPERR = 1,
>
>  SEGV_ACCERR
>
>};
>
>
>enum
>{
>  BUS_ADRALN = 1,
>
>  BUS_ADRERR,
>
>  BUS_OBJERR
>
>};
>
>
>enum
>{
>  TRAP_BRKPT = 1,
>
>  TRAP_TRACE
>
>};
>
>
>enum
>{
>  CLD_EXITED = 1,
>
>  CLD_KILLED,
>
>  CLD_DUMPED,
>
>  CLD_TRAPPED,
>
>  CLD_STOPPED,
>
>  CLD_CONTINUED
>
>};
>
>
>enum
>{
>  POLL_IN = 1,
>
>  POLL_OUT,
>
>  POLL_MSG,
>
>  POLL_ERR,
>
>  POLL_PRI,
>
>  POLL_HUP
>
>};
># 278 "/usr/include/bits/siginfo.h" 3 4
>typedef struct sigevent
>  {
>    sigval_t sigev_value;
>    int sigev_signo;
>    int sigev_notify;
>
>    union
>      {
> int _pad[((64 / sizeof (int)) - 4)];
>
>
>
> __pid_t _tid;
>
> struct
>   {
>     void (*_function) (sigval_t);
>     pthread_attr_t *_attribute;
>   } _sigev_thread;
>      } _sigev_un;
>  } sigevent_t;
>
>
>
>
>
>
>enum
>{
>  SIGEV_SIGNAL = 0,
>
>  SIGEV_NONE,
>
>  SIGEV_THREAD,
>
>
>  SIGEV_THREAD_ID = 4
>
>};
># 79 "/usr/include/signal.h" 2 3 4
>
>
>
>
>typedef void (*__sighandler_t) (int);
>
>
>
>
>extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern __sighandler_t signal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__ , __leaf__));
># 112 "/usr/include/signal.h" 3 4
>
>
>
>
>
>extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int kill (__pid_t __pid, int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int killpg (__pid_t __pgrp, int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int raise (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__ , __leaf__));
>extern int gsignal (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern void psignal (int __sig, const char *__s);
>
>
>
>
>extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
># 167 "/usr/include/signal.h" 3 4
>extern int __sigpause (int __sig_or_mask, int __is_sig);
># 176 "/usr/include/signal.h" 3 4
>extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
># 195 "/usr/include/signal.h" 3 4
>extern int sigblock (int __mask) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>
>
>extern int sigsetmask (int __mask) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>
>
>extern int siggetmask (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
># 210 "/usr/include/signal.h" 3 4
>typedef __sighandler_t sighandler_t;
>
>
>
>
>typedef __sighandler_t sig_t;
>
>
>
>
>
>extern int sigemptyset (sigset_t *__set) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigfillset (sigset_t *__set) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigaddset (sigset_t *__set, int __signo) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigdelset (sigset_t *__set, int __signo) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigismember (const sigset_t *__set, int __signo)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int sigisemptyset (const sigset_t *__set) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigandset (sigset_t *__set, const sigset_t *__left,
>        const sigset_t *__right) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>extern int sigorset (sigset_t *__set, const sigset_t *__left,
>       const sigset_t *__right) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
># 1 "/usr/include/bits/sigaction.h" 1 3 4
># 24 "/usr/include/bits/sigaction.h" 3 4
>struct sigaction
>  {
>
>
>    union
>      {
>
> __sighandler_t sa_handler;
>
> void (*sa_sigaction) (int, siginfo_t *, void *);
>      }
>    __sigaction_handler;
>
>
>
>
>
>
>
>    __sigset_t sa_mask;
>
>
>    int sa_flags;
>
>
>    void (*sa_restorer) (void);
>  };
># 252 "/usr/include/signal.h" 2 3 4
>
>
>extern int sigprocmask (int __how, const sigset_t *__restrict __set,
>   sigset_t *__restrict __oset) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigaction (int __sig, const struct sigaction *__restrict __act,
>        struct sigaction *__restrict __oact) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sigpending (sigset_t *__set) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
>     __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int sigwaitinfo (const sigset_t *__restrict __set,
>   siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sigtimedwait (const sigset_t *__restrict __set,
>    siginfo_t *__restrict __info,
>    const struct timespec *__restrict __timeout)
>     __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
>     __attribute__ ((__nothrow__ , __leaf__));
># 309 "/usr/include/signal.h" 3 4
>extern const char *const _sys_siglist[65];
>extern const char *const sys_siglist[65];
>
>
>struct sigvec
>  {
>    __sighandler_t sv_handler;
>    int sv_mask;
>
>    int sv_flags;
>
>  };
># 333 "/usr/include/signal.h" 3 4
>extern int sigvec (int __sig, const struct sigvec *__vec,
>     struct sigvec *__ovec) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
># 1 "/usr/include/bits/sigcontext.h" 1 3 4
># 27 "/usr/include/bits/sigcontext.h" 3 4
># 1 "/usr/include/asm/sigcontext.h" 1 3 4
># 11 "/usr/include/asm/sigcontext.h" 3 4
># 1 "/usr/include/asm/ptrace.h" 1 3 4
># 27 "/usr/include/asm/ptrace.h" 3 4
># 1 "/usr/include/linux/types.h" 1 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/linux/posix_types.h" 1 3 4
>
>
>
># 1 "/usr/include/linux/stddef.h" 1 3 4
># 5 "/usr/include/linux/posix_types.h" 2 3 4
># 36 "/usr/include/linux/posix_types.h" 3 4
>typedef struct {
> unsigned long fds_bits [(1024/(8 * sizeof(unsigned long)))];
>} __kernel_fd_set;
>
>
>typedef void (*__kernel_sighandler_t)(int);
>
>
>typedef int __kernel_key_t;
>typedef int __kernel_mqd_t;
>
># 1 "/usr/include/asm/posix_types.h" 1 3 4
># 11 "/usr/include/asm/posix_types.h" 3 4
>typedef unsigned long __kernel_old_dev_t;
># 23 "/usr/include/asm/posix_types.h" 3 4
># 1 "/usr/include/asm-generic/posix_types.h" 1 3 4
># 14 "/usr/include/asm-generic/posix_types.h" 3 4
>typedef long __kernel_long_t;
>typedef unsigned long __kernel_ulong_t;
>
>
>
>typedef __kernel_ulong_t __kernel_ino_t;
>
>
>
>typedef unsigned int __kernel_mode_t;
>
>
>
>typedef int __kernel_pid_t;
>
>
>
>typedef int __kernel_ipc_pid_t;
>
>
>
>typedef unsigned int __kernel_uid_t;
>typedef unsigned int __kernel_gid_t;
>
>
>
>typedef __kernel_long_t __kernel_suseconds_t;
>
>
>
>typedef int __kernel_daddr_t;
>
>
>
>typedef unsigned int __kernel_uid32_t;
>typedef unsigned int __kernel_gid32_t;
>
>
>
>typedef __kernel_uid_t __kernel_old_uid_t;
>typedef __kernel_gid_t __kernel_old_gid_t;
># 71 "/usr/include/asm-generic/posix_types.h" 3 4
>typedef __kernel_ulong_t __kernel_size_t;
>typedef __kernel_long_t __kernel_ssize_t;
>typedef __kernel_long_t __kernel_ptrdiff_t;
>
>
>
>
>typedef struct {
> int val[2];
>} __kernel_fsid_t;
>
>
>
>
>
>typedef __kernel_long_t __kernel_off_t;
>typedef long long __kernel_loff_t;
>typedef __kernel_long_t __kernel_time_t;
>typedef __kernel_long_t __kernel_clock_t;
>typedef int __kernel_timer_t;
>typedef int __kernel_clockid_t;
>typedef char * __kernel_caddr_t;
>typedef unsigned short __kernel_uid16_t;
>typedef unsigned short __kernel_gid16_t;
># 24 "/usr/include/asm/posix_types.h" 2 3 4
># 48 "/usr/include/linux/posix_types.h" 2 3 4
># 9 "/usr/include/linux/types.h" 2 3 4
># 27 "/usr/include/linux/types.h" 3 4
>typedef __u16 __le16;
>typedef __u16 __be16;
>typedef __u32 __le32;
>typedef __u32 __be32;
>typedef __u64 __le64;
>typedef __u64 __be64;
>
>typedef __u16 __sum16;
>typedef __u32 __wsum;
># 28 "/usr/include/asm/ptrace.h" 2 3 4
>
>
>
>struct pt_regs {
> unsigned long gpr[32];
> unsigned long nip;
> unsigned long msr;
> unsigned long orig_gpr3;
> unsigned long ctr;
> unsigned long link;
> unsigned long xer;
> unsigned long ccr;
>
> unsigned long softe;
>
>
>
>
> unsigned long trap;
>
>
> unsigned long dar;
> unsigned long dsisr;
> unsigned long result;
>};
># 194 "/usr/include/asm/ptrace.h" 3 4
>struct ppc_debug_info {
> __u32 version;
> __u32 num_instruction_bps;
> __u32 num_data_bps;
> __u32 num_condition_regs;
> __u32 data_bp_alignment;
> __u32 sizeof_condition;
> __u64 features;
>};
># 216 "/usr/include/asm/ptrace.h" 3 4
>struct ppc_hw_breakpoint {
> __u32 version;
> __u32 trigger_type;
> __u32 addr_mode;
> __u32 condition_mode;
> __u64 addr;
> __u64 addr2;
> __u64 condition_value;
>};
># 12 "/usr/include/asm/sigcontext.h" 2 3 4
>
># 1 "/usr/include/asm/elf.h" 1 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/asm/cputable.h" 1 3 4
># 9 "/usr/include/asm/elf.h" 2 3 4
># 1 "/usr/include/asm/auxvec.h" 1 3 4
># 10 "/usr/include/asm/elf.h" 2 3 4
># 95 "/usr/include/asm/elf.h" 3 4
>typedef unsigned long elf_greg_t64;
>typedef elf_greg_t64 elf_gregset_t64[48];
>
>typedef unsigned int elf_greg_t32;
>typedef elf_greg_t32 elf_gregset_t32[48];
>typedef elf_gregset_t32 compat_elf_gregset_t;
># 123 "/usr/include/asm/elf.h" 3 4
>  typedef elf_greg_t64 elf_greg_t;
>  typedef elf_gregset_t64 elf_gregset_t;
>
>
>
>
>
>
>
>typedef double elf_fpreg_t;
>typedef elf_fpreg_t elf_fpregset_t[33];
># 154 "/usr/include/asm/elf.h" 3 4
>typedef __vector128 elf_vrreg_t;
>typedef elf_vrreg_t elf_vrregset_t[34];
>
>typedef elf_vrreg_t elf_vrregset_t32[33];
>typedef elf_fpreg_t elf_vsrreghalf_t32[32];
># 300 "/usr/include/asm/elf.h" 3 4
>struct ppc64_opd_entry
>{
> unsigned long funcaddr;
> unsigned long r2;
>};
># 14 "/usr/include/asm/sigcontext.h" 2 3 4
>
>
>struct sigcontext {
> unsigned long _unused[4];
> int signal;
>
> int _pad0;
>
> unsigned long handler;
> unsigned long oldmask;
> struct pt_regs *regs;
>
> elf_gregset_t gp_regs;
> elf_fpregset_t fp_regs;
># 82 "/usr/include/asm/sigcontext.h" 3 4
> elf_vrreg_t *v_regs;
> long vmx_reserve[34 +34 +32+1];
>
>};
># 28 "/usr/include/bits/sigcontext.h" 2 3 4
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stddef.h" 1 3 4
># 32 "/usr/include/bits/sigcontext.h" 2 3 4
># 339 "/usr/include/signal.h" 2 3 4
>
>
>extern int sigreturn (struct sigcontext *__scp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/stddef.h" 1 3 4
># 349 "/usr/include/signal.h" 2 3 4
>
>
>
>
>extern int siginterrupt (int __sig, int __interrupt) __attribute__ ((__nothrow__ , __leaf__));
>
># 1 "/usr/include/bits/sigstack.h" 1 3 4
># 25 "/usr/include/bits/sigstack.h" 3 4
>struct sigstack
>  {
>    void *ss_sp;
>    int ss_onstack;
>  };
>
>
>
>enum
>{
>  SS_ONSTACK = 1,
>
>  SS_DISABLE
>
>};
># 49 "/usr/include/bits/sigstack.h" 3 4
>typedef struct sigaltstack
>  {
>    void *ss_sp;
>    int ss_flags;
>    size_t ss_size;
>  } stack_t;
># 356 "/usr/include/signal.h" 2 3 4
>
>
># 1 "/usr/include/sys/ucontext.h" 1 3 4
># 22 "/usr/include/sys/ucontext.h" 3 4
># 1 "/usr/include/signal.h" 1 3 4
># 23 "/usr/include/sys/ucontext.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/sigcontext.h" 1 3 4
># 27 "/usr/include/sys/ucontext.h" 2 3 4
># 77 "/usr/include/sys/ucontext.h" 3 4
>typedef unsigned long gregset_t[48];
>typedef double fpregset_t[33];
>
>
>
>
>typedef struct _libc_vscr
>{
> unsigned int __pad[3];
> unsigned int vscr_word;
>} vscr_t;
>
>
>
>typedef struct _libc_vrstate
>{
> unsigned int vrregs[32][4];
> vscr_t vscr;
> unsigned int vrsave;
> unsigned int __pad[3];
>} vrregset_t __attribute__((__aligned__(16)));
>
>typedef struct {
> unsigned long __unused[4];
> int signal;
> int __pad0;
> unsigned long handler;
> unsigned long oldmask;
> struct pt_regs *regs;
> gregset_t gp_regs;
> fpregset_t fp_regs;
># 127 "/usr/include/sys/ucontext.h" 3 4
> vrregset_t *v_regs;
> long vmx_reserve[34 +34 +1];
>} mcontext_t;
>
>
>
>
>typedef struct ucontext
>  {
>    unsigned long int uc_flags;
>    struct ucontext *uc_link;
>    stack_t uc_stack;
># 171 "/usr/include/sys/ucontext.h" 3 4
>    sigset_t uc_sigmask;
>    mcontext_t uc_mcontext;
>
>  } ucontext_t;
># 359 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>
>
>
>extern int sigaltstack (const struct sigaltstack *__restrict __ss,
>   struct sigaltstack *__restrict __oss) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern int sighold (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sigrelse (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sigignore (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __sighandler_t sigset (int __sig, __sighandler_t __disp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
># 1 "/usr/include/bits/sigthread.h" 1 3 4
># 30 "/usr/include/bits/sigthread.h" 3 4
>extern int pthread_sigmask (int __how,
>       const __sigset_t *__restrict __newmask,
>       __sigset_t *__restrict __oldmask)__attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int pthread_kill (pthread_t __threadid, int __signo) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int pthread_sigqueue (pthread_t __threadid, int __signo,
>        const union sigval __value) __attribute__ ((__nothrow__ , __leaf__));
># 395 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>
>extern int __libc_current_sigrtmin (void) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int __libc_current_sigrtmax (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
># 31 "/usr/include/sys/wait.h" 2 3 4
># 100 "/usr/include/sys/wait.h" 3 4
>typedef enum
>{
>  P_ALL,
>  P_PID,
>  P_PGID
>} idtype_t;
># 114 "/usr/include/sys/wait.h" 3 4
>extern __pid_t wait (__WAIT_STATUS __stat_loc);
># 137 "/usr/include/sys/wait.h" 3 4
>extern __pid_t waitpid (__pid_t __pid, int *__stat_loc, int __options);
># 147 "/usr/include/sys/wait.h" 3 4
># 1 "/usr/include/bits/siginfo.h" 1 3 4
># 24 "/usr/include/bits/siginfo.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 25 "/usr/include/bits/siginfo.h" 2 3 4
># 148 "/usr/include/sys/wait.h" 2 3 4
># 160 "/usr/include/sys/wait.h" 3 4
>extern int waitid (idtype_t __idtype, __id_t __id, siginfo_t *__infop,
>     int __options);
>
>
>
>
>
>struct rusage;
>
>
>
>
>
>
>extern __pid_t wait3 (__WAIT_STATUS __stat_loc, int __options,
>        struct rusage * __usage) __attribute__ ((__nothrow__));
>
>
>
>
>extern __pid_t wait4 (__pid_t __pid, __WAIT_STATUS __stat_loc, int __options,
>        struct rusage *__usage) __attribute__ ((__nothrow__));
>
>
>
>
># 29 "Monitor.c" 2
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/limits.h" 1 3 4
># 34 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/limits.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/syslimits.h" 1 3 4
>
>
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/limits.h" 1 3 4
># 169 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/limits.h" 3 4
># 1 "/usr/include/limits.h" 1 3 4
># 144 "/usr/include/limits.h" 3 4
># 1 "/usr/include/bits/posix1_lim.h" 1 3 4
># 156 "/usr/include/bits/posix1_lim.h" 3 4
># 1 "/usr/include/bits/local_lim.h" 1 3 4
># 39 "/usr/include/bits/local_lim.h" 3 4
># 1 "/usr/include/linux/limits.h" 1 3 4
># 40 "/usr/include/bits/local_lim.h" 2 3 4
># 157 "/usr/include/bits/posix1_lim.h" 2 3 4
># 145 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/posix2_lim.h" 1 3 4
># 149 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/xopen_lim.h" 1 3 4
># 33 "/usr/include/bits/xopen_lim.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 34 "/usr/include/bits/xopen_lim.h" 2 3 4
># 153 "/usr/include/limits.h" 2 3 4
># 170 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/limits.h" 2 3 4
># 8 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/syslimits.h" 2 3 4
># 35 "/usr/lib/gcc/ppc64-redhat-linux/4.7.1/include/limits.h" 2 3 4
># 31 "Monitor.c" 2
># 1 "/usr/include/syslog.h" 1 3 4
># 32 "Monitor.c" 2
>
>
>
>
>
>
>struct state {
> char *devname;
> int devnum;
> long utime;
> int err;
> char *spare_group;
> int active, working, failed, spare, raid;
> int expected_spares;
> int devstate[384];
> dev_t devid[384];
> int percent;
> int parent_dev;
>
>
> struct supertype *metadata;
> struct state *subarray;
>
>
> struct state *parent;
>
> struct state *next;
>};
>
>struct alert_info {
> char *mailaddr;
> char *mailfrom;
> char *alert_cmd;
> int dosyslog;
>};
>static int make_daemon(char *pidfile);
>static int check_one_sharer(int scan);
>static void alert(char *event, char *dev, char *disc, struct alert_info *info);
>static int check_array(struct state *st, struct mdstat_ent *mdstat,
>         int test, struct alert_info *info,
>         int increments, char *prefer);
>static int add_new_arrays(struct mdstat_ent *mdstat, struct state **statelist,
>     int test, struct alert_info *info);
>static void try_spare_migration(struct state *statelist, struct alert_info *info);
>static void link_containers_with_subarrays(struct state *list);
>
>int Monitor(struct mddev_dev *devlist,
>     char *mailaddr, char *alert_cmd,
>     int period, int daemonise, int scan, int oneshot,
>     int dosyslog, int test, char *pidfile, int increments,
>     int share, char *prefer)
>{
># 126 "Monitor.c"
> struct state *statelist = ((void *)0);
> struct state *st2;
> int finished = 0;
> struct mdstat_ent *mdstat = ((void *)0);
> char *mailfrom = ((void *)0);
> struct alert_info info;
>
> if (!mailaddr) {
>  mailaddr = conf_get_mailaddr();
>  if (mailaddr && ! scan)
>   fprintf(stderr, "mdadm" ": Monitor using email address \"%s\" from config file\n",
>          mailaddr);
> }
> mailfrom = conf_get_mailfrom();
>
> if (!alert_cmd) {
>  alert_cmd = conf_get_program();
>  if (alert_cmd && ! scan)
>   fprintf(stderr, "mdadm" ": Monitor using program \"%s\" from config file\n",
>          alert_cmd);
> }
> if (scan && !mailaddr && !alert_cmd && !dosyslog) {
>  fprintf(stderr, "mdadm" ": No mail address or alert command - not monitoring.\n");
>  return 1;
> }
> info.alert_cmd = alert_cmd;
> info.mailaddr = mailaddr;
> info.mailfrom = mailfrom;
> info.dosyslog = dosyslog;
>
> if (daemonise) {
>  int rv = make_daemon(pidfile);
>  if (rv >= 0)
>   return rv;
> }
>
> if (share)
>  if (check_one_sharer(scan))
>   return 1;
>
> if (devlist == ((void *)0)) {
>  struct mddev_ident *mdlist = conf_get_ident(((void *)0));
>  for (; mdlist; mdlist=mdlist->next) {
>   struct state *st;
>   if (mdlist->devname == ((void *)0))
>    continue;
>   if (strcasecmp(mdlist->devname, "<ignore>") == 0)
>    continue;
>   st = calloc(1, sizeof *st);
>   if (st == ((void *)0))
>    continue;
>   if (mdlist->devname[0] == '/')
>    st->devname = (__extension__ (__builtin_constant_p (mdlist->devname) && ((size_t)(const void *)((mdlist->devname) + 1) - (size_t)(const void *)(mdlist->devname) == 1) ? (((const char *) (mdlist->devname))[0] == '\0' ? (char *) calloc ((size_t) 1, (size_t) 1) : ({ size_t __len = strlen (mdlist->devname) + 1; char *__retval = (char *) malloc (__len); if (__retval != ((void *)0)) __retval = (char *) memcpy (__retval, mdlist->devname, __len); __retval; })) : __strdup (mdlist->devname)));
>   else {
>    st->devname = malloc(8+strlen(mdlist->devname)+1);
>    strcpy(strcpy(st->devname, "/dev/md/"),
>           mdlist->devname);
>   }
>   st->next = statelist;
>   st->devnum = 2147483647;
>   st->percent = -2;
>   st->expected_spares = mdlist->spare_disks;
>   if (mdlist->spare_group)
>    st->spare_group = (__extension__ (__builtin_constant_p (mdlist->spare_group) && ((size_t)(const void *)((mdlist->spare_group) + 1) - (size_t)(const void *)(mdlist->spare_group) == 1) ? (((const char *) (mdlist->spare_group))[0] == '\0' ? (char *) calloc ((size_t) 1, (size_t) 1) : ({ size_t __len = strlen (mdlist->spare_group) + 1; char *__retval = (char *) malloc (__len); if (__retval != ((void *)0)) __retval = (char *) memcpy (__retval, mdlist->spare_group, __len); __retval; })) : __strdup (mdlist->spare_group)));
>   statelist = st;
>  }
> } else {
>  struct mddev_dev *dv;
>  for (dv=devlist ; dv; dv=dv->next) {
>   struct mddev_ident *mdlist = conf_get_ident(dv->devname);
>   struct state *st = calloc(1, sizeof *st);
>   if (st == ((void *)0))
>    continue;
>   st->devname = (__extension__ (__builtin_constant_p (dv->devname) && ((size_t)(const void *)((dv->devname) + 1) - (size_t)(const void *)(dv->devname) == 1) ? (((const char *) (dv->devname))[0] == '\0' ? (char *) calloc ((size_t) 1, (size_t) 1) : ({ size_t __len = strlen (dv->devname) + 1; char *__retval = (char *) malloc (__len); if (__retval != ((void *)0)) __retval = (char *) memcpy (__retval, dv->devname, __len); __retval; })) : __strdup (dv->devname)));
>   st->next = statelist;
>   st->devnum = 2147483647;
>   st->percent = -2;
>   st->expected_spares = -1;
>   if (mdlist) {
>    st->expected_spares = mdlist->spare_disks;
>    if (mdlist->spare_group)
>     st->spare_group = (__extension__ (__builtin_constant_p (mdlist->spare_group) && ((size_t)(const void *)((mdlist->spare_group) + 1) - (size_t)(const void *)(mdlist->spare_group) == 1) ? (((const char *) (mdlist->spare_group))[0] == '\0' ? (char *) calloc ((size_t) 1, (size_t) 1) : ({ size_t __len = strlen (mdlist->spare_group) + 1; char *__retval = (char *) malloc (__len); if (__retval != ((void *)0)) __retval = (char *) memcpy (__retval, mdlist->spare_group, __len); __retval; })) : __strdup (mdlist->spare_group)));
>   }
>   statelist = st;
>  }
> }
>
>
> while (! finished) {
>  int new_found = 0;
>  struct state *st;
>  int anydegraded = 0;
>
>  if (mdstat)
>   free_mdstat(mdstat);
>  mdstat = mdstat_read(oneshot?0:1, 0);
>
>  for (st=statelist; st; st=st->next)
>   if (check_array(st, mdstat, test, &info,
>     increments, prefer))
>    anydegraded = 1;
>
>
>  if (scan)
>   new_found = add_new_arrays(mdstat, &statelist, test,
>         &info);
>
>
>
>
>
>  if (share && anydegraded)
>   try_spare_migration(statelist, &info);
>  if (!new_found) {
>   if (oneshot)
>    break;
>   else
>    mdstat_wait(period);
>  }
>  test = 0;
> }
> for (st2 = statelist; st2; st2 = statelist) {
>  statelist = st2->next;
>  free(st2);
> }
>
> if (pidfile)
>  unlink(pidfile);
> return 0;
>}
>
>static int make_daemon(char *pidfile)
>{
>
>
>
>
>
>
> int pid = fork();
> if (pid > 0) {
>  if (!pidfile)
>   printf("%d\n", pid);
>  else {
>   FILE *pid_file;
>   pid_file=fopen(pidfile, "w");
>   if (!pid_file)
>    perror("cannot create pid file");
>   else {
>    fprintf(pid_file,"%d\n", pid);
>    fclose(pid_file);
>   }
>  }
>  return 0;
> }
> if (pid < 0) {
>  perror("daemonise");
>  return 1;
> }
> close(0);
> open("/dev/null", 02);
> dup2(0,1);
> dup2(0,2);
> setsid();
> return -1;
>}
>
>static int check_one_sharer(int scan)
>{
> int pid, rv;
> FILE *fp;
> char dir[20];
> char path[100];
> struct stat buf;
> sprintf(path, "%s/autorebuild.pid", "/run/mdadm");
> fp = fopen(path, "r");
> if (fp) {
>  if (fscanf(fp, "%d", &pid) != 1)
>   pid = -1;
>  sprintf(dir, "/proc/%d", pid);
>  rv = stat(dir, &buf);
>  if (rv != -1) {
>   if (scan) {
>    fprintf(stderr, "mdadm" ": Only one "
>     "autorebuild process allowed"
>     " in scan mode, aborting\n");
>    fclose(fp);
>    return 1;
>   } else {
>    fprintf(stderr, "mdadm" ": Warning: One"
>     " autorebuild process already"
>     " running.\n");
>   }
>  }
>  fclose(fp);
> }
> if (scan) {
>  if (mkdir("/run/mdadm", (0400|0200|0100)) < 0 &&
>      (*__errno_location ()) != 17) {
>   fprintf(stderr, "mdadm" ": Can't create "
>    "autorebuild.pid file\n");
>  } else {
>   fp = fopen(path, "w");
>   if (!fp)
>    fprintf(stderr, "mdadm" ": Cannot create"
>     " autorebuild.pid"
>     "file\n");
>   else {
>    pid = getpid();
>    fprintf(fp, "%d\n", pid);
>    fclose(fp);
>   }
>  }
> }
> return 0;
>}
>
>static void alert(char *event, char *dev, char *disc, struct alert_info *info)
>{
> int priority;
>
> if (!info->alert_cmd && !info->mailaddr && !info->dosyslog) {
>  time_t now = time(0);
>
>  printf("%1.15s: %s on %s %s\n", ctime(&now)+4, event, dev, disc?disc:"unknown device");
> }
> if (info->alert_cmd) {
>  int pid = fork();
>  switch(pid) {
>  default:
>   waitpid(pid, ((void *)0), 0);
>   break;
>  case -1:
>   break;
>  case 0:
>   execl(info->alert_cmd, info->alert_cmd,
>         event, dev, disc, ((void *)0));
>   exit(2);
>  }
> }
> if (info->mailaddr &&
>     ((__extension__ (__builtin_constant_p (4) && ((__builtin_constant_p (event) && strlen (event) < ((size_t) (4))) || (__builtin_constant_p ("Fail") && strlen ("Fail") < ((size_t) (4)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (event) && __builtin_constant_p ("Fail") && (__s1_len = strlen (event), __s2_len = strlen ("Fail"), (!((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Fail") + 1) - (size_t)(const void *)("Fail") == 1) || __s2_len >= 4)) ? __builtin_strcmp (event, "Fail") : (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) && (__s1_len = strlen (event), __s1_len < 4) ? (__builtin_constant_p ("Fail") && ((size_t)(const void *)(("Fail") + 1) - (size_t)(const void *)("Fail") == 1) ? __builtin_strcmp (event, "Fail") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Fail"); register int __result = (((const unsigned char *) (const char *) (event))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (event))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Fail") && ((size_t)(const void *)(("Fail") + 1) - (size_t)(const void *)("Fail") == 1) && (__s2_len = strlen ("Fail"), __s2_len < 4) ? (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) ? __builtin_strcmp (event, "Fail") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (event); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("Fail"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("Fail"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("Fail"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("Fail"))[3]); } } __result; }))) : __builtin_strcmp (event, "Fail")))); }) : strncmp (event, "Fail", 4)))==0 ||
>      (__extension__ (__builtin_constant_p (4) && ((__builtin_constant_p (event) && strlen (event) < ((size_t) (4))) || (__builtin_constant_p ("Test") && strlen ("Test") < ((size_t) (4)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (event) && __builtin_constant_p ("Test") && (__s1_len = strlen (event), __s2_len = strlen ("Test"), (!((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Test") + 1) - (size_t)(const void *)("Test") == 1) || __s2_len >= 4)) ? __builtin_strcmp (event, "Test") : (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) && (__s1_len = strlen (event), __s1_len < 4) ? (__builtin_constant_p ("Test") && ((size_t)(const void *)(("Test") + 1) - (size_t)(const void *)("Test") == 1) ? __builtin_strcmp (event, "Test") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Test"); register int __result = (((const unsigned char *) (const char *) (event))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (event))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Test") && ((size_t)(const void *)(("Test") + 1) - (size_t)(const void *)("Test") == 1) && (__s2_len = strlen ("Test"), __s2_len < 4) ? (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) ? __builtin_strcmp (event, "Test") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (event); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("Test"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("Test"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("Test"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("Test"))[3]); } } __result; }))) : __builtin_strcmp (event, "Test")))); }) : strncmp (event, "Test", 4)))==0 ||
>      (__extension__ (__builtin_constant_p (6) && ((__builtin_constant_p (event) && strlen (event) < ((size_t) (6))) || (__builtin_constant_p ("Spares") && strlen ("Spares") < ((size_t) (6)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (event) && __builtin_constant_p ("Spares") && (__s1_len = strlen (event), __s2_len = strlen ("Spares"), (!((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Spares") + 1) - (size_t)(const void *)("Spares") == 1) || __s2_len >= 4)) ? __builtin_strcmp (event, "Spares") : (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) && (__s1_len = strlen (event), __s1_len < 4) ? (__builtin_constant_p ("Spares") && ((size_t)(const void *)(("Spares") + 1) - (size_t)(const void *)("Spares") == 1) ? __builtin_strcmp (event, "Spares") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Spares"); register int __result = (((const unsigned char *) (const char *) (event))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (event))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Spares") && ((size_t)(const void *)(("Spares") + 1) - (size_t)(const void *)("Spares") == 1) && (__s2_len = strlen ("Spares"), __s2_len < 4) ? (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) ? __builtin_strcmp (event, "Spares") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (event); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("Spares"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("Spares"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("Spares"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("Spares"))[3]); } } __result; }))) : __builtin_strcmp (event, "Spares")))); }) : strncmp (event, "Spares", 6)))==0 ||
>      (__extension__ (__builtin_constant_p (7) && ((__builtin_constant_p (event) && strlen (event) < ((size_t) (7))) || (__builtin_constant_p ("Degrade") && strlen ("Degrade") < ((size_t) (7)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (event) && __builtin_constant_p ("Degrade") && (__s1_len = strlen (event), __s2_len = strlen ("Degrade"), (!((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Degrade") + 1) - (size_t)(const void *)("Degrade") == 1) || __s2_len >= 4)) ? __builtin_strcmp (event, "Degrade") : (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) && (__s1_len = strlen (event), __s1_len < 4) ? (__builtin_constant_p ("Degrade") && ((size_t)(const void *)(("Degrade") + 1) - (size_t)(const void *)("Degrade") == 1) ? __builtin_strcmp (event, "Degrade") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Degrade"); register int __result = (((const unsigned char *) (const char *) (event))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (event))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Degrade") && ((size_t)(const void *)(("Degrade") + 1) - (size_t)(const void *)("Degrade") == 1) && (__s2_len = strlen ("Degrade"), __s2_len < 4) ? (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) ? __builtin_strcmp (event, "Degrade") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (event); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("Degrade"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("Degrade"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("Degrade"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("Degrade"))[3]); } } __result; }))) : __builtin_strcmp (event, "Degrade")))); }) : strncmp (event, "Degrade", 7)))==0)) {
>  FILE *mp = popen("/usr/sbin/sendmail -t", "w");
>  if (mp) {
>   FILE *mdstat;
>   char hname[256];
>   gethostname(hname, sizeof(hname));
>   signal(13, ((__sighandler_t) 1));
>   if (info->mailfrom)
>    fprintf(mp, "From: %s\n", info->mailfrom);
>   else
>    fprintf(mp, "From: " "mdadm" " monitoring <root>\n");
>   fprintf(mp, "To: %s\n", info->mailaddr);
>   fprintf(mp, "Subject: %s event on %s:%s\n\n",
>    event, dev, hname);
>
>   fprintf(mp,
>    "This is an automatically generated"
>    " mail message from " "mdadm" "\n");
>   fprintf(mp, "running on %s\n\n", hname);
>
>   fprintf(mp,
>    "A %s event had been detected on"
>    " md device %s.\n\n", event, dev);
>
>   if (disc && disc[0] != ' ')
>    fprintf(mp,
>     "It could be related to"
>     " component device %s.\n\n", disc);
>   if (disc && disc[0] == ' ')
>    fprintf(mp, "Extra information:%s.\n\n", disc);
>
>   fprintf(mp, "Faithfully yours, etc.\n");
>
>   mdstat = fopen("/proc/mdstat", "r");
>   if (mdstat) {
>    char buf[8192];
>    int n;
>    fprintf(mp,
>     "\nP.S. The /proc/mdstat file"
>     " currently contains the following:\n\n");
>    while ( (n=fread(buf, 1, sizeof(buf), mdstat)) > 0)
>     n=fwrite(buf, 1, n, mp);
>    fclose(mdstat);
>   }
>   pclose(mp);
>  }
> }
>
>
> if (info->dosyslog) {
>
>
>
>  if ((__extension__ (__builtin_constant_p (4) && ((__builtin_constant_p (event) && strlen (event) < ((size_t) (4))) || (__builtin_constant_p ("Fail") && strlen ("Fail") < ((size_t) (4)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (event) && __builtin_constant_p ("Fail") && (__s1_len = strlen (event), __s2_len = strlen ("Fail"), (!((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Fail") + 1) - (size_t)(const void *)("Fail") == 1) || __s2_len >= 4)) ? __builtin_strcmp (event, "Fail") : (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) && (__s1_len = strlen (event), __s1_len < 4) ? (__builtin_constant_p ("Fail") && ((size_t)(const void *)(("Fail") + 1) - (size_t)(const void *)("Fail") == 1) ? __builtin_strcmp (event, "Fail") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Fail"); register int __result = (((const unsigned char *) (const char *) (event))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (event))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Fail") && ((size_t)(const void *)(("Fail") + 1) - (size_t)(const void *)("Fail") == 1) && (__s2_len = strlen ("Fail"), __s2_len < 4) ? (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) ? __builtin_strcmp (event, "Fail") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (event); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("Fail"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("Fail"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("Fail"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("Fail"))[3]); } } __result; }))) : __builtin_strcmp (event, "Fail")))); }) : strncmp (event, "Fail", 4)))==0 ||
>      (__extension__ (__builtin_constant_p (7) && ((__builtin_constant_p (event) && strlen (event) < ((size_t) (7))) || (__builtin_constant_p ("Degrade") && strlen ("Degrade") < ((size_t) (7)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (event) && __builtin_constant_p ("Degrade") && (__s1_len = strlen (event), __s2_len = strlen ("Degrade"), (!((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Degrade") + 1) - (size_t)(const void *)("Degrade") == 1) || __s2_len >= 4)) ? __builtin_strcmp (event, "Degrade") : (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) && (__s1_len = strlen (event), __s1_len < 4) ? (__builtin_constant_p ("Degrade") && ((size_t)(const void *)(("Degrade") + 1) - (size_t)(const void *)("Degrade") == 1) ? __builtin_strcmp (event, "Degrade") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Degrade"); register int __result = (((const unsigned char *) (const char *) (event))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (event))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Degrade") && ((size_t)(const void *)(("Degrade") + 1) - (size_t)(const void *)("Degrade") == 1) && (__s2_len = strlen ("Degrade"), __s2_len < 4) ? (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) ? __builtin_strcmp (event, "Degrade") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (event); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("Degrade"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("Degrade"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("Degrade"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("Degrade"))[3]); } } __result; }))) : __builtin_strcmp (event, "Degrade")))); }) : strncmp (event, "Degrade", 7)))==0 ||
>      (__extension__ (__builtin_constant_p (17) && ((__builtin_constant_p (event) && strlen (event) < ((size_t) (17))) || (__builtin_constant_p ("DeviceDisappeared") && strlen ("DeviceDisappeared") < ((size_t) (17)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (event) && __builtin_constant_p ("DeviceDisappeared") && (__s1_len = strlen (event), __s2_len = strlen ("DeviceDisappeared"), (!((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("DeviceDisappeared") + 1) - (size_t)(const void *)("DeviceDisappeared") == 1) || __s2_len >= 4)) ? __builtin_strcmp (event, "DeviceDisappeared") : (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) && (__s1_len = strlen (event), __s1_len < 4) ? (__builtin_constant_p ("DeviceDisappeared") && ((size_t)(const void *)(("DeviceDisappeared") + 1) - (size_t)(const void *)("DeviceDisappeared") == 1) ? __builtin_strcmp (event, "DeviceDisappeared") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("DeviceDisappeared"); register int __result = (((const unsigned char *) (const char *) (event))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (event))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("DeviceDisappeared") && ((size_t)(const void *)(("DeviceDisappeared") + 1) - (size_t)(const void *)("DeviceDisappeared") == 1) && (__s2_len = strlen ("DeviceDisappeared"), __s2_len < 4) ? (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) ? __builtin_strcmp (event, "DeviceDisappeared") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (event); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("DeviceDisappeared"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("DeviceDisappeared"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("DeviceDisappeared"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("DeviceDisappeared"))[3]); } } __result; }))) : __builtin_strcmp (event, "DeviceDisappeared")))); }) : strncmp (event, "DeviceDisappeared", 17)))==0)
>   priority = 2;
>
>  else if ((__extension__ (__builtin_constant_p (7) && ((__builtin_constant_p (event) && strlen (event) < ((size_t) (7))) || (__builtin_constant_p ("Rebuild") && strlen ("Rebuild") < ((size_t) (7)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (event) && __builtin_constant_p ("Rebuild") && (__s1_len = strlen (event), __s2_len = strlen ("Rebuild"), (!((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Rebuild") + 1) - (size_t)(const void *)("Rebuild") == 1) || __s2_len >= 4)) ? __builtin_strcmp (event, "Rebuild") : (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) && (__s1_len = strlen (event), __s1_len < 4) ? (__builtin_constant_p ("Rebuild") && ((size_t)(const void *)(("Rebuild") + 1) - (size_t)(const void *)("Rebuild") == 1) ? __builtin_strcmp (event, "Rebuild") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Rebuild"); register int __result = (((const unsigned char *) (const char *) (event))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (event))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Rebuild") && ((size_t)(const void *)(("Rebuild") + 1) - (size_t)(const void *)("Rebuild") == 1) && (__s2_len = strlen ("Rebuild"), __s2_len < 4) ? (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) ? __builtin_strcmp (event, "Rebuild") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (event); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("Rebuild"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("Rebuild"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("Rebuild"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("Rebuild"))[3]); } } __result; }))) : __builtin_strcmp (event, "Rebuild")))); }) : strncmp (event, "Rebuild", 7)))==0 ||
>    (__extension__ (__builtin_constant_p (9) && ((__builtin_constant_p (event) && strlen (event) < ((size_t) (9))) || (__builtin_constant_p ("MoveSpare") && strlen ("MoveSpare") < ((size_t) (9)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (event) && __builtin_constant_p ("MoveSpare") && (__s1_len = strlen (event), __s2_len = strlen ("MoveSpare"), (!((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("MoveSpare") + 1) - (size_t)(const void *)("MoveSpare") == 1) || __s2_len >= 4)) ? __builtin_strcmp (event, "MoveSpare") : (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) && (__s1_len = strlen (event), __s1_len < 4) ? (__builtin_constant_p ("MoveSpare") && ((size_t)(const void *)(("MoveSpare") + 1) - (size_t)(const void *)("MoveSpare") == 1) ? __builtin_strcmp (event, "MoveSpare") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("MoveSpare"); register int __result = (((const unsigned char *) (const char *) (event))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (event))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("MoveSpare") && ((size_t)(const void *)(("MoveSpare") + 1) - (size_t)(const void *)("MoveSpare") == 1) && (__s2_len = strlen ("MoveSpare"), __s2_len < 4) ? (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) ? __builtin_strcmp (event, "MoveSpare") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (event); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("MoveSpare"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("MoveSpare"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("MoveSpare"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("MoveSpare"))[3]); } } __result; }))) : __builtin_strcmp (event, "MoveSpare")))); }) : strncmp (event, "MoveSpare", 9)))==0 ||
>    (__extension__ (__builtin_constant_p (6) && ((__builtin_constant_p (event) && strlen (event) < ((size_t) (6))) || (__builtin_constant_p ("Spares") && strlen ("Spares") < ((size_t) (6)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (event) && __builtin_constant_p ("Spares") && (__s1_len = strlen (event), __s2_len = strlen ("Spares"), (!((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Spares") + 1) - (size_t)(const void *)("Spares") == 1) || __s2_len >= 4)) ? __builtin_strcmp (event, "Spares") : (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) && (__s1_len = strlen (event), __s1_len < 4) ? (__builtin_constant_p ("Spares") && ((size_t)(const void *)(("Spares") + 1) - (size_t)(const void *)("Spares") == 1) ? __builtin_strcmp (event, "Spares") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Spares"); register int __result = (((const unsigned char *) (const char *) (event))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (event))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (event))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Spares") && ((size_t)(const void *)(("Spares") + 1) - (size_t)(const void *)("Spares") == 1) && (__s2_len = strlen ("Spares"), __s2_len < 4) ? (__builtin_constant_p (event) && ((size_t)(const void *)((event) + 1) - (size_t)(const void *)(event) == 1) ? __builtin_strcmp (event, "Spares") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (event); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("Spares"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("Spares"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("Spares"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("Spares"))[3]); } } __result; }))) : __builtin_strcmp (event, "Spares")))); }) : strncmp (event, "Spares", 6))) != 0)
>   priority = 4;
>
>  else
>   priority = 6;
>
>  if (disc)
>   syslog(priority,
>          "%s event detected on md device %s,"
>          " component device %s", event, dev, disc);
>  else
>   syslog(priority,
>          "%s event detected on md device %s",
>          event, dev);
> }
>}
>
>static int check_array(struct state *st, struct mdstat_ent *mdstat,
>         int test, struct alert_info *ainfo,
>         int increments, char *prefer)
>{
>
>
>
>
> struct { int state, major, minor; } info[384];
> mdu_array_info_t array;
> struct mdstat_ent *mse = ((void *)0), *mse2;
> char *dev = st->devname;
> int fd;
> int i;
> int remaining_disks;
> int last_disk;
>
> if (test)
>  alert("TestMessage", dev, ((void *)0), ainfo);
> fd = open(dev, 00);
> if (fd < 0) {
>  if (!st->err)
>   alert("DeviceDisappeared", dev, ((void *)0), ainfo);
>  st->err=1;
>  return 0;
> }
> fcntl(fd, 2, 1);
> if (ioctl(fd, (((2U) << (((0 +8)+8)+13)) | (((9)) << (0 +8)) | (((0x11)) << 0) | ((((sizeof(mdu_array_info_t)))) << ((0 +8)+8))), &array)<0) {
>  if (!st->err)
>   alert("DeviceDisappeared", dev, ((void *)0), ainfo);
>  st->err=1;
>  close(fd);
>  return 0;
> }
>
>
>
> if (array.level == 0 || array.level == -1) {
>  if (!st->err)
>   alert("DeviceDisappeared", dev, "Wrong-Level", ainfo);
>  st->err = 1;
>  close(fd);
>  return 0;
> }
> if (st->devnum == 2147483647) {
>  struct stat stb;
>  if (fstat(fd, &stb) == 0 &&
>      (0170000&stb.st_mode)==0060000) {
>   if (gnu_dev_major (stb.st_rdev) == 9)
>    st->devnum = gnu_dev_minor (stb.st_rdev);
>   else
>    st->devnum = -1- (gnu_dev_minor (stb.st_rdev)>>6);
>  }
> }
>
> for (mse2 = mdstat ; mse2 ; mse2=mse2->next)
>  if (mse2->devnum == st->devnum) {
>   mse2->devnum = 2147483647;
>   mse = mse2;
>  }
>
> if (!mse) {
>
>
>  st->err = 1;
>  close(fd);
>  return 0;
> }
>
> if (array.utime == 0)
>
>
>  array.utime = st->utime + 1;;
>
> if (st->utime == array.utime &&
>     st->failed == array.failed_disks &&
>     st->working == array.working_disks &&
>     st->spare == array.spare_disks &&
>     (mse == ((void *)0) || (
>      mse->percent == st->percent
>      ))) {
>  close(fd);
>  st->err = 0;
>  if ((st->active < st->raid) && st->spare == 0)
>   return 1;
>  else
>   return 0;
> }
> if (st->utime == 0 &&
>     mse->pattern && (__extension__ (__builtin_constant_p ('_') && !__builtin_constant_p (mse->pattern) && ('_') == '\0' ? (char *) __rawmemchr (mse->pattern, '_') : __builtin_strchr (mse->pattern, '_')))
>  )
>  alert("DegradedArray", dev, ((void *)0), ainfo);
>
> if (st->utime == 0 &&
>     st->expected_spares > 0 &&
>     array.spare_disks < st->expected_spares)
>  alert("SparesMissing", dev, ((void *)0), ainfo);
> if (st->percent == -1 &&
>     mse->percent >= 0)
>  alert("RebuildStarted", dev, ((void *)0), ainfo);
> if (st->percent >= 0 &&
>     mse->percent >= 0 &&
>     (mse->percent / increments) > (st->percent / increments)) {
>  char percentalert[15];
>
>  if((mse->percent / increments) == 0)
>   snprintf(percentalert, sizeof(percentalert), "RebuildStarted");
>  else
>   snprintf(percentalert, sizeof(percentalert), "Rebuild%02d", mse->percent);
>
>  alert(percentalert, dev, ((void *)0), ainfo);
> }
>
> if (mse->percent == -1 &&
>     st->percent >= 0) {
>
>
>
>
>  struct mdinfo *sra =
>   sysfs_read(-1, st->devnum, GET_MISMATCH);
>  if (sra && sra->mismatch_cnt > 0) {
>   char cnt[80];
>   snprintf(cnt, sizeof(cnt),
>     " mismatches found: %d (on raid level %d)",
>    sra->mismatch_cnt, array.level);
>   alert("RebuildFinished", dev, cnt, ainfo);
>  } else
>   alert("RebuildFinished", dev, ((void *)0), ainfo);
>  if (sra)
>   free(sra);
> }
> st->percent = mse->percent;
>
> remaining_disks = array.nr_disks;
> for (i=0; i<384 && remaining_disks > 0;
>      i++) {
>  mdu_disk_info_t disc;
>  disc.number = i;
>  if (ioctl(fd, (((2U) << (((0 +8)+8)+13)) | (((9)) << (0 +8)) | (((0x12)) << 0) | ((((sizeof(mdu_disk_info_t)))) << ((0 +8)+8))), &disc) >= 0) {
>   info[i].state = disc.state;
>   info[i].major = disc.major;
>   info[i].minor = disc.minor;
>   if (disc.major || disc.minor)
>    remaining_disks --;
>  } else
>   info[i].major = info[i].minor = 0;
> }
> last_disk = i;
>
> if (mse->metadata_version &&
>     (__extension__ (__builtin_constant_p (9) && ((__builtin_constant_p (mse->metadata_version) && strlen (mse->metadata_version) < ((size_t) (9))) || (__builtin_constant_p ("external:") && strlen ("external:") < ((size_t) (9)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (mse->metadata_version) && __builtin_constant_p ("external:") && (__s1_len = strlen (mse->metadata_version), __s2_len = strlen ("external:"), (!((size_t)(const void *)((mse->metadata_version) + 1) - (size_t)(const void *)(mse->metadata_version) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("external:") + 1) - (size_t)(const void *)("external:") == 1) || __s2_len >= 4)) ? __builtin_strcmp (mse->metadata_version, "external:") : (__builtin_constant_p (mse->metadata_version) && ((size_t)(const void *)((mse->metadata_version) + 1) - (size_t)(const void *)(mse->metadata_version) == 1) && (__s1_len = strlen (mse->metadata_version), __s1_len < 4) ? (__builtin_constant_p ("external:") && ((size_t)(const void *)(("external:") + 1) - (size_t)(const void *)("external:") == 1) ? __builtin_strcmp (mse->metadata_version, "external:") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("external:"); register int __result = (((const unsigned char *) (const char *) (mse->metadata_version))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (mse->metadata_version))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (mse->metadata_version))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (mse->metadata_version))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("external:") && ((size_t)(const void *)(("external:") + 1) - (size_t)(const void *)("external:") == 1) && (__s2_len = strlen ("external:"), __s2_len < 4) ? (__builtin_constant_p (mse->metadata_version) && ((size_t)(const void *)((mse->metadata_version) + 1) - (size_t)(const void *)(mse->metadata_version) == 1) ? __builtin_strcmp (mse->metadata_version, "external:") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (mse->metadata_version); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("external:"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("external:"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("external:"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("external:"))[3]); } } __result; }))) : __builtin_strcmp (mse->metadata_version, "external:")))); }) : strncmp (mse->metadata_version, "external:", 9))) == 0 &&
>     is_subarray(mse->metadata_version+9))
>  st->parent_dev =
>   devname2devnum(mse->metadata_version+10);
> else
>  st->parent_dev = (1<<23);
> if (st->metadata == ((void *)0) &&
>     st->parent_dev == (1<<23))
>  st->metadata = super_by_fd(fd, ((void *)0));
>
> close(fd);
>
> for (i=0; i<384; i++) {
>  mdu_disk_info_t disc = {0,0,0,0,0};
>  int newstate=0;
>  int change;
>  char *dv = ((void *)0);
>  disc.number = i;
>  if (i >= last_disk) {
>   newstate = 0;
>   disc.major = disc.minor = 0;
>  } else if (info[i].major || info[i].minor) {
>   newstate = info[i].state;
>   dv = map_dev_preferred(
>    info[i].major, info[i].minor, 1,
>    prefer);
>   disc.state = newstate;
>   disc.major = info[i].major;
>   disc.minor = info[i].minor;
>  } else if (mse && mse->pattern && i < (int)strlen(mse->pattern)) {
>   switch(mse->pattern[i]) {
>   case 'U': newstate = 6 ; break;
>   case '_': newstate = 8 ; break;
>   }
>   disc.major = disc.minor = 0;
>  }
>  if (dv == ((void *)0) && st->devid[i])
>   dv = map_dev_preferred(
>    gnu_dev_major (st->devid[i]),
>    gnu_dev_minor (st->devid[i]), 1, prefer);
>  change = newstate ^ st->devstate[i];
>  if (st->utime && change && !st->err) {
>   if (i < array.raid_disks &&
>       (((newstate&change)&(1<<0)) ||
>        ((st->devstate[i]&change)&(1<<1)) ||
>        ((st->devstate[i]&change)&(1<<2)))
>    )
>    alert("Fail", dev, dv, ainfo);
>   else if (i >= array.raid_disks &&
>     (disc.major || disc.minor) &&
>     st->devid[i] == gnu_dev_makedev (disc.major, disc.minor) &&
>     ((newstate&change)&(1<<0))
>    )
>    alert("FailSpare", dev, dv, ainfo);
>   else if (i < array.raid_disks &&
>     ! (newstate & (1<<3)) &&
>     (((st->devstate[i]&change)&(1<<0)) ||
>      ((newstate&change)&(1<<1)) ||
>      ((newstate&change)&(1<<2)))
>    )
>    alert("SpareActive", dev, dv, ainfo);
>  }
>  st->devstate[i] = newstate;
>  st->devid[i] = gnu_dev_makedev (disc.major, disc.minor);
> }
> st->active = array.active_disks;
> st->working = array.working_disks;
> st->spare = array.spare_disks;
> st->failed = array.failed_disks;
> st->utime = array.utime;
> st->raid = array.raid_disks;
> st->err = 0;
> if ((st->active < st->raid) && st->spare == 0)
>  return 1;
> return 0;
>}
>
>static int add_new_arrays(struct mdstat_ent *mdstat, struct state **statelist,
>     int test, struct alert_info *info)
>{
> struct mdstat_ent *mse;
> int new_found = 0;
>
> for (mse=mdstat; mse; mse=mse->next)
>  if (mse->devnum != 2147483647 &&
>      (!mse->level ||
>       (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (mse->level) && __builtin_constant_p ("raid0") && (__s1_len = strlen (mse->level), __s2_len = strlen ("raid0"), (!((size_t)(const void *)((mse->level) + 1) - (size_t)(const void *)(mse->level) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("raid0") + 1) - (size_t)(const void *)("raid0") == 1) || __s2_len >= 4)) ? __builtin_strcmp (mse->level, "raid0") : (__builtin_constant_p (mse->level) && ((size_t)(const void *)((mse->level) + 1) - (size_t)(const void *)(mse->level) == 1) && (__s1_len = strlen (mse->level), __s1_len < 4) ? (__builtin_constant_p ("raid0") && ((size_t)(const void *)(("raid0") + 1) - (size_t)(const void *)("raid0") == 1) ? __builtin_strcmp (mse->level, "raid0") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("raid0"); register int __result = (((const unsigned char *) (const char *) (mse->level))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (mse->level))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (mse->level))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (mse->level))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("raid0") && ((size_t)(const void *)(("raid0") + 1) - (size_t)(const void *)("raid0") == 1) && (__s2_len = strlen ("raid0"), __s2_len < 4) ? (__builtin_constant_p (mse->level) && ((size_t)(const void *)((mse->level) + 1) - (size_t)(const void *)(mse->level) == 1) ? __builtin_strcmp (mse->level, "raid0") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (mse->level); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("raid0"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("raid0"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("raid0"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("raid0"))[3]); } } __result; }))) : __builtin_strcmp (mse->level, "raid0")))); }) != 0 &&
>        __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (mse->level) && __builtin_constant_p ("linear") && (__s1_len = strlen (mse->level), __s2_len = strlen ("linear"), (!((size_t)(const void *)((mse->level) + 1) - (size_t)(const void *)(mse->level) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("linear") + 1) - (size_t)(const void *)("linear") == 1) || __s2_len >= 4)) ? __builtin_strcmp (mse->level, "linear") : (__builtin_constant_p (mse->level) && ((size_t)(const void *)((mse->level) + 1) - (size_t)(const void *)(mse->level) == 1) && (__s1_len = strlen (mse->level), __s1_len < 4) ? (__builtin_constant_p ("linear") && ((size_t)(const void *)(("linear") + 1) - (size_t)(const void *)("linear") == 1) ? __builtin_strcmp (mse->level, "linear") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("linear"); register int __result = (((const unsigned char *) (const char *) (mse->level))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (mse->level))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (mse->level))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (mse->level))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("linear") && ((size_t)(const void *)(("linear") + 1) - (size_t)(const void *)("linear") == 1) && (__s2_len = strlen ("linear"), __s2_len < 4) ? (__builtin_constant_p (mse->level) && ((size_t)(const void *)((mse->level) + 1) - (size_t)(const void *)(mse->level) == 1) ? __builtin_strcmp (mse->level, "linear") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (mse->level); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("linear"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("linear"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("linear"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("linear"))[3]); } } __result; }))) : __builtin_strcmp (mse->level, "linear")))); }) != 0))
>   ) {
>   struct state *st = calloc(1, sizeof *st);
>   mdu_array_info_t array;
>   int fd;
>   if (st == ((void *)0))
>    continue;
>   st->devname = (__extension__ (__builtin_constant_p (get_md_name(mse->devnum)) && ((size_t)(const void *)((get_md_name(mse->devnum)) + 1) - (size_t)(const void *)(get_md_name(mse->devnum)) == 1) ? (((const char *) (get_md_name(mse->devnum)))[0] == '\0' ? (char *) calloc ((size_t) 1, (size_t) 1) : ({ size_t __len = strlen (get_md_name(mse->devnum)) + 1; char *__retval = (char *) malloc (__len); if (__retval != ((void *)0)) __retval = (char *) memcpy (__retval, get_md_name(mse->devnum), __len); __retval; })) : __strdup (get_md_name(mse->devnum))));
>   if ((fd = open(st->devname, 00)) < 0 ||
>       ioctl(fd, (((2U) << (((0 +8)+8)+13)) | (((9)) << (0 +8)) | (((0x11)) << 0) | ((((sizeof(mdu_array_info_t)))) << ((0 +8)+8))), &array)< 0) {
>
>    if (fd >=0) close(fd);
>    put_md_name(st->devname);
>    free(st->devname);
>    if (st->metadata) {
>     st->metadata->ss->free_super(st->metadata);
>     free(st->metadata);
>    }
>    free(st);
>    continue;
>   }
>   close(fd);
>   st->next = *statelist;
>   st->err = 1;
>   st->devnum = mse->devnum;
>   st->percent = -2;
>   st->expected_spares = -1;
>   if (mse->metadata_version &&
>       (__extension__ (__builtin_constant_p (9) && ((__builtin_constant_p (mse->metadata_version) && strlen (mse->metadata_version) < ((size_t) (9))) || (__builtin_constant_p ("external:") && strlen ("external:") < ((size_t) (9)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (mse->metadata_version) && __builtin_constant_p ("external:") && (__s1_len = strlen (mse->metadata_version), __s2_len = strlen ("external:"), (!((size_t)(const void *)((mse->metadata_version) + 1) - (size_t)(const void *)(mse->metadata_version) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("external:") + 1) - (size_t)(const void *)("external:") == 1) || __s2_len >= 4)) ? __builtin_strcmp (mse->metadata_version, "external:") : (__builtin_constant_p (mse->metadata_version) && ((size_t)(const void *)((mse->metadata_version) + 1) - (size_t)(const void *)(mse->metadata_version) == 1) && (__s1_len = strlen (mse->metadata_version), __s1_len < 4) ? (__builtin_constant_p ("external:") && ((size_t)(const void *)(("external:") + 1) - (size_t)(const void *)("external:") == 1) ? __builtin_strcmp (mse->metadata_version, "external:") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("external:"); register int __result = (((const unsigned char *) (const char *) (mse->metadata_version))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (mse->metadata_version))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (mse->metadata_version))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (mse->metadata_version))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("external:") && ((size_t)(const void *)(("external:") + 1) - (size_t)(const void *)("external:") == 1) && (__s2_len = strlen ("external:"), __s2_len < 4) ? (__builtin_constant_p (mse->metadata_version) && ((size_t)(const void *)((mse->metadata_version) + 1) - (size_t)(const void *)(mse->metadata_version) == 1) ? __builtin_strcmp (mse->metadata_version, "external:") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (mse->metadata_version); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("external:"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("external:"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("external:"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("external:"))[3]); } } __result; }))) : __builtin_strcmp (mse->metadata_version, "external:")))); }) : strncmp (mse->metadata_version, "external:", 9))) == 0 &&
>       is_subarray(mse->metadata_version+9))
>    st->parent_dev =
>     devname2devnum(mse->metadata_version+10);
>   else
>    st->parent_dev = (1<<23);
>   *statelist = st;
>   if (test)
>    alert("TestMessage", st->devname, ((void *)0), info);
>   alert("NewArray", st->devname, ((void *)0), info);
>   new_found = 1;
>  }
> return new_found;
>}
>
>static int get_min_spare_size_required(struct state *st, unsigned long long *sizep)
>{
> int fd;
>
> if (!st->metadata ||
>     !st->metadata->ss->min_acceptable_spare_size) {
>  *sizep = 0;
>  return 0;
> }
>
> fd = open(st->devname, 00);
> if (fd < 0)
>  return 1;
> if (st->metadata->ss->external)
>  st->metadata->ss->load_container(st->metadata, fd, st->devname);
> else
>  st->metadata->ss->load_super(st->metadata, fd, st->devname);
> close(fd);
> if (!st->metadata->sb)
>  return 1;
> *sizep = st->metadata->ss->min_acceptable_spare_size(st->metadata);
> st->metadata->ss->free_super(st->metadata);
>
> return 0;
>}
>
>static int check_donor(struct state *from, struct state *to)
>{
> struct state *sub;
>
> if (from == to)
>  return 0;
> if (from->parent)
>
>  return 0;
> if (from->err)
>  return 0;
> for (sub = from->subarray; sub; sub = sub->subarray)
>
>
>
>  if (sub->active < sub->raid)
>   return 0;
> if (from->metadata->ss->external == 0)
>  if (from->active < from->raid)
>   return 0;
> if (from->spare <= 0)
>  return 0;
> return 1;
>}
>
>static dev_t choose_spare(struct state *from, struct state *to,
>   struct domainlist *domlist, unsigned long long min_size)
>{
> int d;
> dev_t dev = 0;
>
> for (d = from->raid; !dev && d < 384; d++) {
>  if (from->devid[d] > 0 &&
>      from->devstate[d] == 0) {
>   struct dev_policy *pol;
>   unsigned long long dev_size;
>
>   if (to->metadata->ss->external &&
>       test_partition_from_id(from->devid[d]))
>    continue;
>
>   if (min_size &&
>       dev_size_from_id(from->devid[d], &dev_size) &&
>       dev_size < min_size)
>    continue;
>
>   pol = devnum_policy(from->devid[d]);
>   if (from->spare_group)
>    pol_add(&pol, pol_domain,
>     from->spare_group, ((void *)0));
>   if (domain_test(domlist, pol, to->metadata->ss->name) == 1)
>       dev = from->devid[d];
>   dev_policy_free(pol);
>  }
> }
> return dev;
>}
>
>static dev_t container_choose_spare(struct state *from, struct state *to,
>        struct domainlist *domlist,
>        unsigned long long min_size, int active)
>{
>
>
>
> struct mdinfo *list;
> struct supertype *st = from->metadata;
> int fd = open(from->devname, 00);
> int err;
> dev_t dev = 0;
>
> if (fd < 0)
>  return 0;
> if (!st->ss->getinfo_super_disks) {
>  close(fd);
>  return 0;
> }
>
> err = st->ss->load_container(st, fd, ((void *)0));
> close(fd);
> if (err)
>  return 0;
>
> if (from == to) {
>
>
>
>
>  int active_cnt = 0;
>  struct mdinfo *dp;
>  list = st->ss->getinfo_super_disks(st);
>  if (!list) {
>   st->ss->free_super(st);
>   return 1;
>  }
>  dp = list->devs;
>  while (dp) {
>   if (dp->disk.state & (1<<2) &&
>       !(dp->disk.state & (1<<0)))
>    active_cnt++;
>   dp = dp->next;
>  }
>  sysfs_free(list);
>  if (active < active_cnt) {
>
>   st->ss->free_super(st);
>   return 1;
>  }
> }
>
>
> list = container_choose_spares(st, min_size, domlist, from->spare_group,
>           to->metadata->ss->name, 1);
> if (list) {
>  struct mdinfo *disks = list->devs;
>  if (disks)
>   dev = gnu_dev_makedev (disks->disk.major, disks->disk.minor);
>  sysfs_free(list);
> }
> st->ss->free_super(st);
> return dev;
>}
>
>
>static void try_spare_migration(struct state *statelist, struct alert_info *info)
>{
> struct state *from;
> struct state *st;
>
> link_containers_with_subarrays(statelist);
> for (st = statelist; st; st = st->next)
>  if (st->active < st->raid &&
>      st->spare == 0 && !st->err) {
>   struct domainlist *domlist = ((void *)0);
>   int d;
>   struct state *to = st;
>   unsigned long long min_size;
>
>   if (to->parent_dev != (1<<23) && !to->parent)
>
>
>    continue;
>
>   if (to->parent)
>
>    to = to->parent;
>
>   if (get_min_spare_size_required(to, &min_size))
>    continue;
>   if (to->metadata->ss->external) {
>
>
>
>    dev_t devid = container_choose_spare(
>     to, to, ((void *)0), min_size, st->active);
>    if (devid > 0)
>     continue;
>   }
>   for (d = 0; d < 384; d++)
>    if (to->devid[d])
>     domainlist_add_dev(&domlist,
>          to->devid[d],
>          to->metadata->ss->name);
>   if (to->spare_group)
>    domain_add(&domlist, to->spare_group);
>
>
>
>
>   if (!domlist)
>    continue;
>   for (from=statelist ; from ; from=from->next) {
>    dev_t devid;
>    if (!check_donor(from, to))
>     continue;
>    if (from->metadata->ss->external)
>     devid = container_choose_spare(
>      from, to, domlist, min_size, 0);
>    else
>     devid = choose_spare(from, to, domlist,
>            min_size);
>    if (devid > 0
>        && move_spare(from->devname, to->devname, devid)) {
>     alert("MoveSpare", to->devname, from->devname, info);
>     break;
>    }
>   }
>   domain_free(domlist);
>  }
>}
>
>
>
>
>
>
>
>static void link_containers_with_subarrays(struct state *list)
>{
> struct state *st;
> struct state *cont;
> for (st = list; st; st = st->next) {
>  st->parent = ((void *)0);
>  st->subarray = ((void *)0);
> }
> for (st = list; st; st = st->next)
>  if (st->parent_dev != (1<<23))
>   for (cont = list; cont; cont = cont->next)
>    if (!cont->err &&
>        cont->parent_dev == (1<<23) &&
>        cont->devnum == st->parent_dev) {
>     st->parent = cont;
>     st->subarray = cont->subarray;
>     cont->subarray = st;
>     break;
>    }
>}
>
>
>int Wait(char *dev)
>{
> struct stat stb;
> int devnum;
> int rv = 1;
>
> if (stat(dev, &stb) != 0) {
>  fprintf(stderr, "mdadm" ": Cannot find %s: %s\n", dev,
>   strerror((*__errno_location ())));
>  return 2;
> }
> devnum = stat2devnum(&stb);
>
> while(1) {
>  struct mdstat_ent *ms = mdstat_read(1, 0);
>  struct mdstat_ent *e;
>
>  for (e=ms ; e; e=e->next)
>   if (e->devnum == devnum)
>    break;
>
>  if (!e || e->percent < 0) {
>   if (e && e->metadata_version &&
>       (__extension__ (__builtin_constant_p (9) && ((__builtin_constant_p (e->metadata_version) && strlen (e->metadata_version) < ((size_t) (9))) || (__builtin_constant_p ("external:") && strlen ("external:") < ((size_t) (9)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (e->metadata_version) && __builtin_constant_p ("external:") && (__s1_len = strlen (e->metadata_version), __s2_len = strlen ("external:"), (!((size_t)(const void *)((e->metadata_version) + 1) - (size_t)(const void *)(e->metadata_version) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("external:") + 1) - (size_t)(const void *)("external:") == 1) || __s2_len >= 4)) ? __builtin_strcmp (e->metadata_version, "external:") : (__builtin_constant_p (e->metadata_version) && ((size_t)(const void *)((e->metadata_version) + 1) - (size_t)(const void *)(e->metadata_version) == 1) && (__s1_len = strlen (e->metadata_version), __s1_len < 4) ? (__builtin_constant_p ("external:") && ((size_t)(const void *)(("external:") + 1) - (size_t)(const void *)("external:") == 1) ? __builtin_strcmp (e->metadata_version, "external:") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("external:"); register int __result = (((const unsigned char *) (const char *) (e->metadata_version))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (e->metadata_version))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (e->metadata_version))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (e->metadata_version))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("external:") && ((size_t)(const void *)(("external:") + 1) - (size_t)(const void *)("external:") == 1) && (__s2_len = strlen ("external:"), __s2_len < 4) ? (__builtin_constant_p (e->metadata_version) && ((size_t)(const void *)((e->metadata_version) + 1) - (size_t)(const void *)(e->metadata_version) == 1) ? __builtin_strcmp (e->metadata_version, "external:") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (e->metadata_version); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("external:"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("external:"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("external:"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("external:"))[3]); } } __result; }))) : __builtin_strcmp (e->metadata_version, "external:")))); }) : strncmp (e->metadata_version, "external:", 9))) == 0) {
>    if (is_subarray(&e->metadata_version[9]))
>     ping_monitor(&e->metadata_version[9]);
>    else
>     ping_monitor_by_id(devnum);
>   }
>   free_mdstat(ms);
>   return rv;
>  }
>  free_mdstat(ms);
>  rv = 0;
>  mdstat_wait(5);
> }
>}
>
>
>
>static char *clean_states[] = {
> "clear", "inactive", "readonly", "read-auto", "clean", ((void *)0) };
>
>int WaitClean(char *dev, int sock, int verbose)
>{
> int fd;
> struct mdinfo *mdi;
> int rv = 1;
> int devnum;
>
> fd = open(dev, 00);
> if (fd < 0) {
>  if (verbose)
>   fprintf(stderr, "mdadm" ": Couldn't open %s: %s\n", dev, strerror((*__errno_location ())));
>  return 1;
> }
>
> devnum = fd2devnum(fd);
> mdi = sysfs_read(fd, devnum, GET_VERSION|GET_LEVEL|GET_SAFEMODE);
> if (!mdi) {
>  if (verbose)
>   fprintf(stderr, "mdadm" ": Failed to read sysfs attributes for "
>    "%s\n", dev);
>  close(fd);
>  return 0;
> }
>
> switch(mdi->array.level) {
> case (-1):
> case (-4):
> case 0:
>
>  rv = 0;
> }
>
>
>
>
> if (!is_subarray(mdi->text_version))
>  rv = 0;
>
>
> if (mdi->safe_mode_delay == 0)
>  rv = 0;
>
> if (rv) {
>  int state_fd = sysfs_open(fd2devnum(fd), ((void *)0), "array_state");
>  char buf[20];
>  fd_set fds;
>  struct timeval tm;
>
>
>
>
>  sysfs_set_safemode(mdi, 1);
>  tm.tv_sec = 5;
>  tm.tv_usec = 0;
>
>  do { unsigned int __i; fd_set *__arr = (&fds); for (__i = 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) ((__arr)->fds_bits)[__i] = 0; } while (0);
>
>
>  while (1) {
>   rv = read(state_fd, buf, sizeof(buf));
>   if (rv < 0)
>    break;
>   if (sysfs_match_word(buf, clean_states) <= 4)
>    break;
>   ((void) (((&fds)->fds_bits)[__extension__ ({ long int __d = (state_fd); (__builtin_constant_p (__d) ? (0 <= __d && __d < 1024 ? (__d / (8 * sizeof(unsigned long))) : __fdelt_warn (__d)) : __fdelt_chk (__d)); })] |= ((__fd_mask) 1 << ((state_fd) % (8 * sizeof(unsigned long))))));
>   rv = select(state_fd + 1, ((void *)0), ((void *)0), &fds, &tm);
>   if (rv < 0 && (*__errno_location ()) != 4)
>    break;
>   lseek(state_fd, 0, 0);
>  }
>  if (rv < 0)
>   rv = 1;
>  else if (fping_monitor(sock) == 0 ||
>    ping_monitor(mdi->text_version) == 0) {
>
>
>
>
>   rv = 0;
>  } else
>   rv = 1;
>  if (rv && verbose)
>   fprintf(stderr, "mdadm" ": Error waiting for %s to be clean\n",
>    dev);
>
>
>  sysfs_set_safemode(mdi, mdi->safe_mode_delay);
>  close(state_fd);
> }
>
> sysfs_free(mdi);
> close(fd);
>
> return rv;
>}

Actions: View

Attachments on bug 841571: 599132