Google Git
Sign in
gfiber / toolchains / mindspeed / f6153d9b5022adf0575515eaebc05c2a3b08c688 / . / arm-buildroot-linux-gnueabi / sysroot / usr / share / info / libc.info-9
blob: 283ec264a864f434594da160ce6b45432cd7153c [file] [log] [blame]
This is
/usr/local/google/home/jnewlin/src/uclibc/buildroot/output/build/glibc-2.19/build/manual/libc.info,
produced by makeinfo version 4.13 from libc.texinfo.
INFO-DIR-SECTION Software libraries
START-INFO-DIR-ENTRY
* Libc: (libc). C library.
END-INFO-DIR-ENTRY
INFO-DIR-SECTION GNU C library functions and macros
START-INFO-DIR-ENTRY
* ALTWERASE: (libc)Local Modes.
* ARGP_ERR_UNKNOWN: (libc)Argp Parser Functions.
* ARG_MAX: (libc)General Limits.
* BC_BASE_MAX: (libc)Utility Limits.
* BC_DIM_MAX: (libc)Utility Limits.
* BC_SCALE_MAX: (libc)Utility Limits.
* BC_STRING_MAX: (libc)Utility Limits.
* BRKINT: (libc)Input Modes.
* BUFSIZ: (libc)Controlling Buffering.
* CCTS_OFLOW: (libc)Control Modes.
* CHILD_MAX: (libc)General Limits.
* CIGNORE: (libc)Control Modes.
* CLK_TCK: (libc)Processor Time.
* CLOCAL: (libc)Control Modes.
* CLOCKS_PER_SEC: (libc)CPU Time.
* COLL_WEIGHTS_MAX: (libc)Utility Limits.
* CPU_CLR: (libc)CPU Affinity.
* CPU_ISSET: (libc)CPU Affinity.
* CPU_SET: (libc)CPU Affinity.
* CPU_SETSIZE: (libc)CPU Affinity.
* CPU_ZERO: (libc)CPU Affinity.
* CREAD: (libc)Control Modes.
* CRTS_IFLOW: (libc)Control Modes.
* CS5: (libc)Control Modes.
* CS6: (libc)Control Modes.
* CS7: (libc)Control Modes.
* CS8: (libc)Control Modes.
* CSIZE: (libc)Control Modes.
* CSTOPB: (libc)Control Modes.
* DES_FAILED: (libc)DES Encryption.
* DTTOIF: (libc)Directory Entries.
* E2BIG: (libc)Error Codes.
* EACCES: (libc)Error Codes.
* EADDRINUSE: (libc)Error Codes.
* EADDRNOTAVAIL: (libc)Error Codes.
* EADV: (libc)Error Codes.
* EAFNOSUPPORT: (libc)Error Codes.
* EAGAIN: (libc)Error Codes.
* EALREADY: (libc)Error Codes.
* EAUTH: (libc)Error Codes.
* EBACKGROUND: (libc)Error Codes.
* EBADE: (libc)Error Codes.
* EBADF: (libc)Error Codes.
* EBADFD: (libc)Error Codes.
* EBADMSG: (libc)Error Codes.
* EBADR: (libc)Error Codes.
* EBADRPC: (libc)Error Codes.
* EBADRQC: (libc)Error Codes.
* EBADSLT: (libc)Error Codes.
* EBFONT: (libc)Error Codes.
* EBUSY: (libc)Error Codes.
* ECANCELED: (libc)Error Codes.
* ECHILD: (libc)Error Codes.
* ECHO: (libc)Local Modes.
* ECHOCTL: (libc)Local Modes.
* ECHOE: (libc)Local Modes.
* ECHOK: (libc)Local Modes.
* ECHOKE: (libc)Local Modes.
* ECHONL: (libc)Local Modes.
* ECHOPRT: (libc)Local Modes.
* ECHRNG: (libc)Error Codes.
* ECOMM: (libc)Error Codes.
* ECONNABORTED: (libc)Error Codes.
* ECONNREFUSED: (libc)Error Codes.
* ECONNRESET: (libc)Error Codes.
* ED: (libc)Error Codes.
* EDEADLK: (libc)Error Codes.
* EDEADLOCK: (libc)Error Codes.
* EDESTADDRREQ: (libc)Error Codes.
* EDIED: (libc)Error Codes.
* EDOM: (libc)Error Codes.
* EDOTDOT: (libc)Error Codes.
* EDQUOT: (libc)Error Codes.
* EEXIST: (libc)Error Codes.
* EFAULT: (libc)Error Codes.
* EFBIG: (libc)Error Codes.
* EFTYPE: (libc)Error Codes.
* EGRATUITOUS: (libc)Error Codes.
* EGREGIOUS: (libc)Error Codes.
* EHOSTDOWN: (libc)Error Codes.
* EHOSTUNREACH: (libc)Error Codes.
* EHWPOISON: (libc)Error Codes.
* EIDRM: (libc)Error Codes.
* EIEIO: (libc)Error Codes.
* EILSEQ: (libc)Error Codes.
* EINPROGRESS: (libc)Error Codes.
* EINTR: (libc)Error Codes.
* EINVAL: (libc)Error Codes.
* EIO: (libc)Error Codes.
* EISCONN: (libc)Error Codes.
* EISDIR: (libc)Error Codes.
* EISNAM: (libc)Error Codes.
* EKEYEXPIRED: (libc)Error Codes.
* EKEYREJECTED: (libc)Error Codes.
* EKEYREVOKED: (libc)Error Codes.
* EL2HLT: (libc)Error Codes.
* EL2NSYNC: (libc)Error Codes.
* EL3HLT: (libc)Error Codes.
* EL3RST: (libc)Error Codes.
* ELIBACC: (libc)Error Codes.
* ELIBBAD: (libc)Error Codes.
* ELIBEXEC: (libc)Error Codes.
* ELIBMAX: (libc)Error Codes.
* ELIBSCN: (libc)Error Codes.
* ELNRNG: (libc)Error Codes.
* ELOOP: (libc)Error Codes.
* EMEDIUMTYPE: (libc)Error Codes.
* EMFILE: (libc)Error Codes.
* EMLINK: (libc)Error Codes.
* EMSGSIZE: (libc)Error Codes.
* EMULTIHOP: (libc)Error Codes.
* ENAMETOOLONG: (libc)Error Codes.
* ENAVAIL: (libc)Error Codes.
* ENEEDAUTH: (libc)Error Codes.
* ENETDOWN: (libc)Error Codes.
* ENETRESET: (libc)Error Codes.
* ENETUNREACH: (libc)Error Codes.
* ENFILE: (libc)Error Codes.
* ENOANO: (libc)Error Codes.
* ENOBUFS: (libc)Error Codes.
* ENOCSI: (libc)Error Codes.
* ENODATA: (libc)Error Codes.
* ENODEV: (libc)Error Codes.
* ENOENT: (libc)Error Codes.
* ENOEXEC: (libc)Error Codes.
* ENOKEY: (libc)Error Codes.
* ENOLCK: (libc)Error Codes.
* ENOLINK: (libc)Error Codes.
* ENOMEDIUM: (libc)Error Codes.
* ENOMEM: (libc)Error Codes.
* ENOMSG: (libc)Error Codes.
* ENONET: (libc)Error Codes.
* ENOPKG: (libc)Error Codes.
* ENOPROTOOPT: (libc)Error Codes.
* ENOSPC: (libc)Error Codes.
* ENOSR: (libc)Error Codes.
* ENOSTR: (libc)Error Codes.
* ENOSYS: (libc)Error Codes.
* ENOTBLK: (libc)Error Codes.
* ENOTCONN: (libc)Error Codes.
* ENOTDIR: (libc)Error Codes.
* ENOTEMPTY: (libc)Error Codes.
* ENOTNAM: (libc)Error Codes.
* ENOTRECOVERABLE: (libc)Error Codes.
* ENOTSOCK: (libc)Error Codes.
* ENOTSUP: (libc)Error Codes.
* ENOTTY: (libc)Error Codes.
* ENOTUNIQ: (libc)Error Codes.
* ENXIO: (libc)Error Codes.
* EOF: (libc)EOF and Errors.
* EOPNOTSUPP: (libc)Error Codes.
* EOVERFLOW: (libc)Error Codes.
* EOWNERDEAD: (libc)Error Codes.
* EPERM: (libc)Error Codes.
* EPFNOSUPPORT: (libc)Error Codes.
* EPIPE: (libc)Error Codes.
* EPROCLIM: (libc)Error Codes.
* EPROCUNAVAIL: (libc)Error Codes.
* EPROGMISMATCH: (libc)Error Codes.
* EPROGUNAVAIL: (libc)Error Codes.
* EPROTO: (libc)Error Codes.
* EPROTONOSUPPORT: (libc)Error Codes.
* EPROTOTYPE: (libc)Error Codes.
* EQUIV_CLASS_MAX: (libc)Utility Limits.
* ERANGE: (libc)Error Codes.
* EREMCHG: (libc)Error Codes.
* EREMOTE: (libc)Error Codes.
* EREMOTEIO: (libc)Error Codes.
* ERESTART: (libc)Error Codes.
* ERFKILL: (libc)Error Codes.
* EROFS: (libc)Error Codes.
* ERPCMISMATCH: (libc)Error Codes.
* ESHUTDOWN: (libc)Error Codes.
* ESOCKTNOSUPPORT: (libc)Error Codes.
* ESPIPE: (libc)Error Codes.
* ESRCH: (libc)Error Codes.
* ESRMNT: (libc)Error Codes.
* ESTALE: (libc)Error Codes.
* ESTRPIPE: (libc)Error Codes.
* ETIME: (libc)Error Codes.
* ETIMEDOUT: (libc)Error Codes.
* ETOOMANYREFS: (libc)Error Codes.
* ETXTBSY: (libc)Error Codes.
* EUCLEAN: (libc)Error Codes.
* EUNATCH: (libc)Error Codes.
* EUSERS: (libc)Error Codes.
* EWOULDBLOCK: (libc)Error Codes.
* EXDEV: (libc)Error Codes.
* EXFULL: (libc)Error Codes.
* EXIT_FAILURE: (libc)Exit Status.
* EXIT_SUCCESS: (libc)Exit Status.
* EXPR_NEST_MAX: (libc)Utility Limits.
* FD_CLOEXEC: (libc)Descriptor Flags.
* FD_CLR: (libc)Waiting for I/O.
* FD_ISSET: (libc)Waiting for I/O.
* FD_SET: (libc)Waiting for I/O.
* FD_SETSIZE: (libc)Waiting for I/O.
* FD_ZERO: (libc)Waiting for I/O.
* FILENAME_MAX: (libc)Limits for Files.
* FLUSHO: (libc)Local Modes.
* FOPEN_MAX: (libc)Opening Streams.
* FP_ILOGB0: (libc)Exponents and Logarithms.
* FP_ILOGBNAN: (libc)Exponents and Logarithms.
* F_DUPFD: (libc)Duplicating Descriptors.
* F_GETFD: (libc)Descriptor Flags.
* F_GETFL: (libc)Getting File Status Flags.
* F_GETLK: (libc)File Locks.
* F_GETOWN: (libc)Interrupt Input.
* F_OK: (libc)Testing File Access.
* F_SETFD: (libc)Descriptor Flags.
* F_SETFL: (libc)Getting File Status Flags.
* F_SETLK: (libc)File Locks.
* F_SETLKW: (libc)File Locks.
* F_SETOWN: (libc)Interrupt Input.
* HUGE_VAL: (libc)Math Error Reporting.
* HUGE_VALF: (libc)Math Error Reporting.
* HUGE_VALL: (libc)Math Error Reporting.
* HUPCL: (libc)Control Modes.
* I: (libc)Complex Numbers.
* ICANON: (libc)Local Modes.
* ICRNL: (libc)Input Modes.
* IEXTEN: (libc)Local Modes.
* IFNAMSIZ: (libc)Interface Naming.
* IFTODT: (libc)Directory Entries.
* IGNBRK: (libc)Input Modes.
* IGNCR: (libc)Input Modes.
* IGNPAR: (libc)Input Modes.
* IMAXBEL: (libc)Input Modes.
* INADDR_ANY: (libc)Host Address Data Type.
* INADDR_BROADCAST: (libc)Host Address Data Type.
* INADDR_LOOPBACK: (libc)Host Address Data Type.
* INADDR_NONE: (libc)Host Address Data Type.
* INFINITY: (libc)Infinity and NaN.
* INLCR: (libc)Input Modes.
* INPCK: (libc)Input Modes.
* IPPORT_RESERVED: (libc)Ports.
* IPPORT_USERRESERVED: (libc)Ports.
* ISIG: (libc)Local Modes.
* ISTRIP: (libc)Input Modes.
* IXANY: (libc)Input Modes.
* IXOFF: (libc)Input Modes.
* IXON: (libc)Input Modes.
* LINE_MAX: (libc)Utility Limits.
* LINK_MAX: (libc)Limits for Files.
* L_ctermid: (libc)Identifying the Terminal.
* L_cuserid: (libc)Who Logged In.
* L_tmpnam: (libc)Temporary Files.
* MAXNAMLEN: (libc)Limits for Files.
* MAXSYMLINKS: (libc)Symbolic Links.
* MAX_CANON: (libc)Limits for Files.
* MAX_INPUT: (libc)Limits for Files.
* MB_CUR_MAX: (libc)Selecting the Conversion.
* MB_LEN_MAX: (libc)Selecting the Conversion.
* MDMBUF: (libc)Control Modes.
* MSG_DONTROUTE: (libc)Socket Data Options.
* MSG_OOB: (libc)Socket Data Options.
* MSG_PEEK: (libc)Socket Data Options.
* NAME_MAX: (libc)Limits for Files.
* NAN: (libc)Infinity and NaN.
* NCCS: (libc)Mode Data Types.
* NGROUPS_MAX: (libc)General Limits.
* NOFLSH: (libc)Local Modes.
* NOKERNINFO: (libc)Local Modes.
* NSIG: (libc)Standard Signals.
* NULL: (libc)Null Pointer Constant.
* ONLCR: (libc)Output Modes.
* ONOEOT: (libc)Output Modes.
* OPEN_MAX: (libc)General Limits.
* OPOST: (libc)Output Modes.
* OXTABS: (libc)Output Modes.
* O_ACCMODE: (libc)Access Modes.
* O_APPEND: (libc)Operating Modes.
* O_ASYNC: (libc)Operating Modes.
* O_CREAT: (libc)Open-time Flags.
* O_EXCL: (libc)Open-time Flags.
* O_EXEC: (libc)Access Modes.
* O_EXLOCK: (libc)Open-time Flags.
* O_FSYNC: (libc)Operating Modes.
* O_IGNORE_CTTY: (libc)Open-time Flags.
* O_NDELAY: (libc)Operating Modes.
* O_NOATIME: (libc)Operating Modes.
* O_NOCTTY: (libc)Open-time Flags.
* O_NOLINK: (libc)Open-time Flags.
* O_NONBLOCK: (libc)Open-time Flags.
* O_NONBLOCK: (libc)Operating Modes.
* O_NOTRANS: (libc)Open-time Flags.
* O_RDONLY: (libc)Access Modes.
* O_RDWR: (libc)Access Modes.
* O_READ: (libc)Access Modes.
* O_SHLOCK: (libc)Open-time Flags.
* O_SYNC: (libc)Operating Modes.
* O_TRUNC: (libc)Open-time Flags.
* O_WRITE: (libc)Access Modes.
* O_WRONLY: (libc)Access Modes.
* PARENB: (libc)Control Modes.
* PARMRK: (libc)Input Modes.
* PARODD: (libc)Control Modes.
* PATH_MAX: (libc)Limits for Files.
* PA_FLAG_MASK: (libc)Parsing a Template String.
* PENDIN: (libc)Local Modes.
* PF_FILE: (libc)Local Namespace Details.
* PF_INET6: (libc)Internet Namespace.
* PF_INET: (libc)Internet Namespace.
* PF_LOCAL: (libc)Local Namespace Details.
* PF_UNIX: (libc)Local Namespace Details.
* PIPE_BUF: (libc)Limits for Files.
* P_tmpdir: (libc)Temporary Files.
* RAND_MAX: (libc)ISO Random.
* RE_DUP_MAX: (libc)General Limits.
* RLIM_INFINITY: (libc)Limits on Resources.
* R_OK: (libc)Testing File Access.
* SA_NOCLDSTOP: (libc)Flags for Sigaction.
* SA_ONSTACK: (libc)Flags for Sigaction.
* SA_RESTART: (libc)Flags for Sigaction.
* SEEK_CUR: (libc)File Positioning.
* SEEK_END: (libc)File Positioning.
* SEEK_SET: (libc)File Positioning.
* SIGABRT: (libc)Program Error Signals.
* SIGALRM: (libc)Alarm Signals.
* SIGBUS: (libc)Program Error Signals.
* SIGCHLD: (libc)Job Control Signals.
* SIGCLD: (libc)Job Control Signals.
* SIGCONT: (libc)Job Control Signals.
* SIGEMT: (libc)Program Error Signals.
* SIGFPE: (libc)Program Error Signals.
* SIGHUP: (libc)Termination Signals.
* SIGILL: (libc)Program Error Signals.
* SIGINFO: (libc)Miscellaneous Signals.
* SIGINT: (libc)Termination Signals.
* SIGIO: (libc)Asynchronous I/O Signals.
* SIGIOT: (libc)Program Error Signals.
* SIGKILL: (libc)Termination Signals.
* SIGLOST: (libc)Operation Error Signals.
* SIGPIPE: (libc)Operation Error Signals.
* SIGPOLL: (libc)Asynchronous I/O Signals.
* SIGPROF: (libc)Alarm Signals.
* SIGQUIT: (libc)Termination Signals.
* SIGSEGV: (libc)Program Error Signals.
* SIGSTOP: (libc)Job Control Signals.
* SIGSYS: (libc)Program Error Signals.
* SIGTERM: (libc)Termination Signals.
* SIGTRAP: (libc)Program Error Signals.
* SIGTSTP: (libc)Job Control Signals.
* SIGTTIN: (libc)Job Control Signals.
* SIGTTOU: (libc)Job Control Signals.
* SIGURG: (libc)Asynchronous I/O Signals.
* SIGUSR1: (libc)Miscellaneous Signals.
* SIGUSR2: (libc)Miscellaneous Signals.
* SIGVTALRM: (libc)Alarm Signals.
* SIGWINCH: (libc)Miscellaneous Signals.
* SIGXCPU: (libc)Operation Error Signals.
* SIGXFSZ: (libc)Operation Error Signals.
* SIG_ERR: (libc)Basic Signal Handling.
* SOCK_DGRAM: (libc)Communication Styles.
* SOCK_RAW: (libc)Communication Styles.
* SOCK_RDM: (libc)Communication Styles.
* SOCK_SEQPACKET: (libc)Communication Styles.
* SOCK_STREAM: (libc)Communication Styles.
* SOL_SOCKET: (libc)Socket-Level Options.
* SSIZE_MAX: (libc)General Limits.
* STREAM_MAX: (libc)General Limits.
* SUN_LEN: (libc)Local Namespace Details.
* SV_INTERRUPT: (libc)BSD Handler.
* SV_ONSTACK: (libc)BSD Handler.
* SV_RESETHAND: (libc)BSD Handler.
* S_IFMT: (libc)Testing File Type.
* S_ISBLK: (libc)Testing File Type.
* S_ISCHR: (libc)Testing File Type.
* S_ISDIR: (libc)Testing File Type.
* S_ISFIFO: (libc)Testing File Type.
* S_ISLNK: (libc)Testing File Type.
* S_ISREG: (libc)Testing File Type.
* S_ISSOCK: (libc)Testing File Type.
* S_TYPEISMQ: (libc)Testing File Type.
* S_TYPEISSEM: (libc)Testing File Type.
* S_TYPEISSHM: (libc)Testing File Type.
* TMP_MAX: (libc)Temporary Files.
* TOSTOP: (libc)Local Modes.
* TZNAME_MAX: (libc)General Limits.
* VDISCARD: (libc)Other Special.
* VDSUSP: (libc)Signal Characters.
* VEOF: (libc)Editing Characters.
* VEOL2: (libc)Editing Characters.
* VEOL: (libc)Editing Characters.
* VERASE: (libc)Editing Characters.
* VINTR: (libc)Signal Characters.
* VKILL: (libc)Editing Characters.
* VLNEXT: (libc)Other Special.
* VMIN: (libc)Noncanonical Input.
* VQUIT: (libc)Signal Characters.
* VREPRINT: (libc)Editing Characters.
* VSTART: (libc)Start/Stop Characters.
* VSTATUS: (libc)Other Special.
* VSTOP: (libc)Start/Stop Characters.
* VSUSP: (libc)Signal Characters.
* VTIME: (libc)Noncanonical Input.
* VWERASE: (libc)Editing Characters.
* WCHAR_MAX: (libc)Extended Char Intro.
* WCHAR_MIN: (libc)Extended Char Intro.
* WCOREDUMP: (libc)Process Completion Status.
* WEOF: (libc)EOF and Errors.
* WEOF: (libc)Extended Char Intro.
* WEXITSTATUS: (libc)Process Completion Status.
* WIFEXITED: (libc)Process Completion Status.
* WIFSIGNALED: (libc)Process Completion Status.
* WIFSTOPPED: (libc)Process Completion Status.
* WSTOPSIG: (libc)Process Completion Status.
* WTERMSIG: (libc)Process Completion Status.
* W_OK: (libc)Testing File Access.
* X_OK: (libc)Testing File Access.
* _Complex_I: (libc)Complex Numbers.
* _Exit: (libc)Termination Internals.
* _IOFBF: (libc)Controlling Buffering.
* _IOLBF: (libc)Controlling Buffering.
* _IONBF: (libc)Controlling Buffering.
* _Imaginary_I: (libc)Complex Numbers.
* _PATH_UTMP: (libc)Manipulating the Database.
* _PATH_WTMP: (libc)Manipulating the Database.
* _POSIX2_C_DEV: (libc)System Options.
* _POSIX2_C_VERSION: (libc)Version Supported.
* _POSIX2_FORT_DEV: (libc)System Options.
* _POSIX2_FORT_RUN: (libc)System Options.
* _POSIX2_LOCALEDEF: (libc)System Options.
* _POSIX2_SW_DEV: (libc)System Options.
* _POSIX_CHOWN_RESTRICTED: (libc)Options for Files.
* _POSIX_JOB_CONTROL: (libc)System Options.
* _POSIX_NO_TRUNC: (libc)Options for Files.
* _POSIX_SAVED_IDS: (libc)System Options.
* _POSIX_VDISABLE: (libc)Options for Files.
* _POSIX_VERSION: (libc)Version Supported.
* __fbufsize: (libc)Controlling Buffering.
* __flbf: (libc)Controlling Buffering.
* __fpending: (libc)Controlling Buffering.
* __fpurge: (libc)Flushing Buffers.
* __freadable: (libc)Opening Streams.
* __freading: (libc)Opening Streams.
* __fsetlocking: (libc)Streams and Threads.
* __fwritable: (libc)Opening Streams.
* __fwriting: (libc)Opening Streams.
* __gconv_end_fct: (libc)glibc iconv Implementation.
* __gconv_fct: (libc)glibc iconv Implementation.
* __gconv_init_fct: (libc)glibc iconv Implementation.
* __ppc_get_timebase: (libc)PowerPC.
* __ppc_get_timebase_freq: (libc)PowerPC.
* __ppc_mdoio: (libc)PowerPC.
* __ppc_mdoom: (libc)PowerPC.
* __ppc_set_ppr_low: (libc)PowerPC.
* __ppc_set_ppr_med: (libc)PowerPC.
* __ppc_set_ppr_med_low: (libc)PowerPC.
* __ppc_yield: (libc)PowerPC.
* __va_copy: (libc)Argument Macros.
* _exit: (libc)Termination Internals.
* _flushlbf: (libc)Flushing Buffers.
* _tolower: (libc)Case Conversion.
* _toupper: (libc)Case Conversion.
* a64l: (libc)Encode Binary Data.
* abort: (libc)Aborting a Program.
* abs: (libc)Absolute Value.
* accept: (libc)Accepting Connections.
* access: (libc)Testing File Access.
* acos: (libc)Inverse Trig Functions.
* acosf: (libc)Inverse Trig Functions.
* acosh: (libc)Hyperbolic Functions.
* acoshf: (libc)Hyperbolic Functions.
* acoshl: (libc)Hyperbolic Functions.
* acosl: (libc)Inverse Trig Functions.
* addmntent: (libc)mtab.
* addseverity: (libc)Adding Severity Classes.
* adjtime: (libc)High-Resolution Calendar.
* adjtimex: (libc)High-Resolution Calendar.
* aio_cancel64: (libc)Cancel AIO Operations.
* aio_cancel: (libc)Cancel AIO Operations.
* aio_error64: (libc)Status of AIO Operations.
* aio_error: (libc)Status of AIO Operations.
* aio_fsync64: (libc)Synchronizing AIO Operations.
* aio_fsync: (libc)Synchronizing AIO Operations.
* aio_init: (libc)Configuration of AIO.
* aio_read64: (libc)Asynchronous Reads/Writes.
* aio_read: (libc)Asynchronous Reads/Writes.
* aio_return64: (libc)Status of AIO Operations.
* aio_return: (libc)Status of AIO Operations.
* aio_suspend64: (libc)Synchronizing AIO Operations.
* aio_suspend: (libc)Synchronizing AIO Operations.
* aio_write64: (libc)Asynchronous Reads/Writes.
* aio_write: (libc)Asynchronous Reads/Writes.
* alarm: (libc)Setting an Alarm.
* aligned_alloc: (libc)Aligned Memory Blocks.
* alloca: (libc)Variable Size Automatic.
* alphasort64: (libc)Scanning Directory Content.
* alphasort: (libc)Scanning Directory Content.
* argp_error: (libc)Argp Helper Functions.
* argp_failure: (libc)Argp Helper Functions.
* argp_help: (libc)Argp Help.
* argp_parse: (libc)Argp.
* argp_state_help: (libc)Argp Helper Functions.
* argp_usage: (libc)Argp Helper Functions.
* argz_add: (libc)Argz Functions.
* argz_add_sep: (libc)Argz Functions.
* argz_append: (libc)Argz Functions.
* argz_count: (libc)Argz Functions.
* argz_create: (libc)Argz Functions.
* argz_create_sep: (libc)Argz Functions.
* argz_delete: (libc)Argz Functions.
* argz_extract: (libc)Argz Functions.
* argz_insert: (libc)Argz Functions.
* argz_next: (libc)Argz Functions.
* argz_replace: (libc)Argz Functions.
* argz_stringify: (libc)Argz Functions.
* asctime: (libc)Formatting Calendar Time.
* asctime_r: (libc)Formatting Calendar Time.
* asin: (libc)Inverse Trig Functions.
* asinf: (libc)Inverse Trig Functions.
* asinh: (libc)Hyperbolic Functions.
* asinhf: (libc)Hyperbolic Functions.
* asinhl: (libc)Hyperbolic Functions.
* asinl: (libc)Inverse Trig Functions.
* asprintf: (libc)Dynamic Output.
* assert: (libc)Consistency Checking.
* assert_perror: (libc)Consistency Checking.
* atan2: (libc)Inverse Trig Functions.
* atan2f: (libc)Inverse Trig Functions.
* atan2l: (libc)Inverse Trig Functions.
* atan: (libc)Inverse Trig Functions.
* atanf: (libc)Inverse Trig Functions.
* atanh: (libc)Hyperbolic Functions.
* atanhf: (libc)Hyperbolic Functions.
* atanhl: (libc)Hyperbolic Functions.
* atanl: (libc)Inverse Trig Functions.
* atexit: (libc)Cleanups on Exit.
* atof: (libc)Parsing of Floats.
* atoi: (libc)Parsing of Integers.
* atol: (libc)Parsing of Integers.
* atoll: (libc)Parsing of Integers.
* backtrace: (libc)Backtraces.
* backtrace_symbols: (libc)Backtraces.
* backtrace_symbols_fd: (libc)Backtraces.
* basename: (libc)Finding Tokens in a String.
* basename: (libc)Finding Tokens in a String.
* bcmp: (libc)String/Array Comparison.
* bcopy: (libc)Copying and Concatenation.
* bind: (libc)Setting Address.
* bind_textdomain_codeset: (libc)Charset conversion in gettext.
* bindtextdomain: (libc)Locating gettext catalog.
* brk: (libc)Resizing the Data Segment.
* bsearch: (libc)Array Search Function.
* btowc: (libc)Converting a Character.
* bzero: (libc)Copying and Concatenation.
* cabs: (libc)Absolute Value.
* cabsf: (libc)Absolute Value.
* cabsl: (libc)Absolute Value.
* cacos: (libc)Inverse Trig Functions.
* cacosf: (libc)Inverse Trig Functions.
* cacosh: (libc)Hyperbolic Functions.
* cacoshf: (libc)Hyperbolic Functions.
* cacoshl: (libc)Hyperbolic Functions.
* cacosl: (libc)Inverse Trig Functions.
* calloc: (libc)Allocating Cleared Space.
* canonicalize_file_name: (libc)Symbolic Links.
* carg: (libc)Operations on Complex.
* cargf: (libc)Operations on Complex.
* cargl: (libc)Operations on Complex.
* casin: (libc)Inverse Trig Functions.
* casinf: (libc)Inverse Trig Functions.
* casinh: (libc)Hyperbolic Functions.
* casinhf: (libc)Hyperbolic Functions.
* casinhl: (libc)Hyperbolic Functions.
* casinl: (libc)Inverse Trig Functions.
* catan: (libc)Inverse Trig Functions.
* catanf: (libc)Inverse Trig Functions.
* catanh: (libc)Hyperbolic Functions.
* catanhf: (libc)Hyperbolic Functions.
* catanhl: (libc)Hyperbolic Functions.
* catanl: (libc)Inverse Trig Functions.
* catclose: (libc)The catgets Functions.
* catgets: (libc)The catgets Functions.
* catopen: (libc)The catgets Functions.
* cbc_crypt: (libc)DES Encryption.
* cbrt: (libc)Exponents and Logarithms.
* cbrtf: (libc)Exponents and Logarithms.
* cbrtl: (libc)Exponents and Logarithms.
* ccos: (libc)Trig Functions.
* ccosf: (libc)Trig Functions.
* ccosh: (libc)Hyperbolic Functions.
* ccoshf: (libc)Hyperbolic Functions.
* ccoshl: (libc)Hyperbolic Functions.
* ccosl: (libc)Trig Functions.
* ceil: (libc)Rounding Functions.
* ceilf: (libc)Rounding Functions.
* ceill: (libc)Rounding Functions.
* cexp: (libc)Exponents and Logarithms.
* cexpf: (libc)Exponents and Logarithms.
* cexpl: (libc)Exponents and Logarithms.
* cfgetispeed: (libc)Line Speed.
* cfgetospeed: (libc)Line Speed.
* cfmakeraw: (libc)Noncanonical Input.
* cfree: (libc)Freeing after Malloc.
* cfsetispeed: (libc)Line Speed.
* cfsetospeed: (libc)Line Speed.
* cfsetspeed: (libc)Line Speed.
* chdir: (libc)Working Directory.
* chmod: (libc)Setting Permissions.
* chown: (libc)File Owner.
* cimag: (libc)Operations on Complex.
* cimagf: (libc)Operations on Complex.
* cimagl: (libc)Operations on Complex.
* clearenv: (libc)Environment Access.
* clearerr: (libc)Error Recovery.
* clearerr_unlocked: (libc)Error Recovery.
* clock: (libc)CPU Time.
* clog10: (libc)Exponents and Logarithms.
* clog10f: (libc)Exponents and Logarithms.
* clog10l: (libc)Exponents and Logarithms.
* clog: (libc)Exponents and Logarithms.
* clogf: (libc)Exponents and Logarithms.
* clogl: (libc)Exponents and Logarithms.
* close: (libc)Opening and Closing Files.
* closedir: (libc)Reading/Closing Directory.
* closelog: (libc)closelog.
* confstr: (libc)String Parameters.
* conj: (libc)Operations on Complex.
* conjf: (libc)Operations on Complex.
* conjl: (libc)Operations on Complex.
* connect: (libc)Connecting.
* copysign: (libc)FP Bit Twiddling.
* copysignf: (libc)FP Bit Twiddling.
* copysignl: (libc)FP Bit Twiddling.
* cos: (libc)Trig Functions.
* cosf: (libc)Trig Functions.
* cosh: (libc)Hyperbolic Functions.
* coshf: (libc)Hyperbolic Functions.
* coshl: (libc)Hyperbolic Functions.
* cosl: (libc)Trig Functions.
* cpow: (libc)Exponents and Logarithms.
* cpowf: (libc)Exponents and Logarithms.
* cpowl: (libc)Exponents and Logarithms.
* cproj: (libc)Operations on Complex.
* cprojf: (libc)Operations on Complex.
* cprojl: (libc)Operations on Complex.
* creal: (libc)Operations on Complex.
* crealf: (libc)Operations on Complex.
* creall: (libc)Operations on Complex.
* creat64: (libc)Opening and Closing Files.
* creat: (libc)Opening and Closing Files.
* crypt: (libc)crypt.
* crypt_r: (libc)crypt.
* csin: (libc)Trig Functions.
* csinf: (libc)Trig Functions.
* csinh: (libc)Hyperbolic Functions.
* csinhf: (libc)Hyperbolic Functions.
* csinhl: (libc)Hyperbolic Functions.
* csinl: (libc)Trig Functions.
* csqrt: (libc)Exponents and Logarithms.
* csqrtf: (libc)Exponents and Logarithms.
* csqrtl: (libc)Exponents and Logarithms.
* ctan: (libc)Trig Functions.
* ctanf: (libc)Trig Functions.
* ctanh: (libc)Hyperbolic Functions.
* ctanhf: (libc)Hyperbolic Functions.
* ctanhl: (libc)Hyperbolic Functions.
* ctanl: (libc)Trig Functions.
* ctermid: (libc)Identifying the Terminal.
* ctime: (libc)Formatting Calendar Time.
* ctime_r: (libc)Formatting Calendar Time.
* cuserid: (libc)Who Logged In.
* dcgettext: (libc)Translation with gettext.
* dcngettext: (libc)Advanced gettext functions.
* des_setparity: (libc)DES Encryption.
* dgettext: (libc)Translation with gettext.
* difftime: (libc)Elapsed Time.
* dirfd: (libc)Opening a Directory.
* dirname: (libc)Finding Tokens in a String.
* div: (libc)Integer Division.
* dngettext: (libc)Advanced gettext functions.
* drand48: (libc)SVID Random.
* drand48_r: (libc)SVID Random.
* drem: (libc)Remainder Functions.
* dremf: (libc)Remainder Functions.
* dreml: (libc)Remainder Functions.
* dup2: (libc)Duplicating Descriptors.
* dup: (libc)Duplicating Descriptors.
* ecb_crypt: (libc)DES Encryption.
* ecvt: (libc)System V Number Conversion.
* ecvt_r: (libc)System V Number Conversion.
* encrypt: (libc)DES Encryption.
* encrypt_r: (libc)DES Encryption.
* endfsent: (libc)fstab.
* endgrent: (libc)Scanning All Groups.
* endhostent: (libc)Host Names.
* endmntent: (libc)mtab.
* endnetent: (libc)Networks Database.
* endnetgrent: (libc)Lookup Netgroup.
* endprotoent: (libc)Protocols Database.
* endpwent: (libc)Scanning All Users.
* endservent: (libc)Services Database.
* endutent: (libc)Manipulating the Database.
* endutxent: (libc)XPG Functions.
* envz_add: (libc)Envz Functions.
* envz_entry: (libc)Envz Functions.
* envz_get: (libc)Envz Functions.
* envz_merge: (libc)Envz Functions.
* envz_strip: (libc)Envz Functions.
* erand48: (libc)SVID Random.
* erand48_r: (libc)SVID Random.
* erf: (libc)Special Functions.
* erfc: (libc)Special Functions.
* erfcf: (libc)Special Functions.
* erfcl: (libc)Special Functions.
* erff: (libc)Special Functions.
* erfl: (libc)Special Functions.
* err: (libc)Error Messages.
* errno: (libc)Checking for Errors.
* error: (libc)Error Messages.
* error_at_line: (libc)Error Messages.
* errx: (libc)Error Messages.
* execl: (libc)Executing a File.
* execle: (libc)Executing a File.
* execlp: (libc)Executing a File.
* execv: (libc)Executing a File.
* execve: (libc)Executing a File.
* execvp: (libc)Executing a File.
* exit: (libc)Normal Termination.
* exp10: (libc)Exponents and Logarithms.
* exp10f: (libc)Exponents and Logarithms.
* exp10l: (libc)Exponents and Logarithms.
* exp2: (libc)Exponents and Logarithms.
* exp2f: (libc)Exponents and Logarithms.
* exp2l: (libc)Exponents and Logarithms.
* exp: (libc)Exponents and Logarithms.
* expf: (libc)Exponents and Logarithms.
* expl: (libc)Exponents and Logarithms.
* expm1: (libc)Exponents and Logarithms.
* expm1f: (libc)Exponents and Logarithms.
* expm1l: (libc)Exponents and Logarithms.
* fabs: (libc)Absolute Value.
* fabsf: (libc)Absolute Value.
* fabsl: (libc)Absolute Value.
* fchdir: (libc)Working Directory.
* fchmod: (libc)Setting Permissions.
* fchown: (libc)File Owner.
* fclose: (libc)Closing Streams.
* fcloseall: (libc)Closing Streams.
* fcntl: (libc)Control Operations.
* fcvt: (libc)System V Number Conversion.
* fcvt_r: (libc)System V Number Conversion.
* fdatasync: (libc)Synchronizing I/O.
* fdim: (libc)Misc FP Arithmetic.
* fdimf: (libc)Misc FP Arithmetic.
* fdiml: (libc)Misc FP Arithmetic.
* fdopen: (libc)Descriptors and Streams.
* fdopendir: (libc)Opening a Directory.
* feclearexcept: (libc)Status bit operations.
* fedisableexcept: (libc)Control Functions.
* feenableexcept: (libc)Control Functions.
* fegetenv: (libc)Control Functions.
* fegetexcept: (libc)Control Functions.
* fegetexceptflag: (libc)Status bit operations.
* fegetround: (libc)Rounding.
* feholdexcept: (libc)Control Functions.
* feof: (libc)EOF and Errors.
* feof_unlocked: (libc)EOF and Errors.
* feraiseexcept: (libc)Status bit operations.
* ferror: (libc)EOF and Errors.
* ferror_unlocked: (libc)EOF and Errors.
* fesetenv: (libc)Control Functions.
* fesetexceptflag: (libc)Status bit operations.
* fesetround: (libc)Rounding.
* fetestexcept: (libc)Status bit operations.
* feupdateenv: (libc)Control Functions.
* fflush: (libc)Flushing Buffers.
* fflush_unlocked: (libc)Flushing Buffers.
* fgetc: (libc)Character Input.
* fgetc_unlocked: (libc)Character Input.
* fgetgrent: (libc)Scanning All Groups.
* fgetgrent_r: (libc)Scanning All Groups.
* fgetpos64: (libc)Portable Positioning.
* fgetpos: (libc)Portable Positioning.
* fgetpwent: (libc)Scanning All Users.
* fgetpwent_r: (libc)Scanning All Users.
* fgets: (libc)Line Input.
* fgets_unlocked: (libc)Line Input.
* fgetwc: (libc)Character Input.
* fgetwc_unlocked: (libc)Character Input.
* fgetws: (libc)Line Input.
* fgetws_unlocked: (libc)Line Input.
* fileno: (libc)Descriptors and Streams.
* fileno_unlocked: (libc)Descriptors and Streams.
* finite: (libc)Floating Point Classes.
* finitef: (libc)Floating Point Classes.
* finitel: (libc)Floating Point Classes.
* flockfile: (libc)Streams and Threads.
* floor: (libc)Rounding Functions.
* floorf: (libc)Rounding Functions.
* floorl: (libc)Rounding Functions.
* fma: (libc)Misc FP Arithmetic.
* fmaf: (libc)Misc FP Arithmetic.
* fmal: (libc)Misc FP Arithmetic.
* fmax: (libc)Misc FP Arithmetic.
* fmaxf: (libc)Misc FP Arithmetic.
* fmaxl: (libc)Misc FP Arithmetic.
* fmemopen: (libc)String Streams.
* fmin: (libc)Misc FP Arithmetic.
* fminf: (libc)Misc FP Arithmetic.
* fminl: (libc)Misc FP Arithmetic.
* fmod: (libc)Remainder Functions.
* fmodf: (libc)Remainder Functions.
* fmodl: (libc)Remainder Functions.
* fmtmsg: (libc)Printing Formatted Messages.
* fnmatch: (libc)Wildcard Matching.
* fopen64: (libc)Opening Streams.
* fopen: (libc)Opening Streams.
* fopencookie: (libc)Streams and Cookies.
* fork: (libc)Creating a Process.
* forkpty: (libc)Pseudo-Terminal Pairs.
* fpathconf: (libc)Pathconf.
* fpclassify: (libc)Floating Point Classes.
* fprintf: (libc)Formatted Output Functions.
* fputc: (libc)Simple Output.
* fputc_unlocked: (libc)Simple Output.
* fputs: (libc)Simple Output.
* fputs_unlocked: (libc)Simple Output.
* fputwc: (libc)Simple Output.
* fputwc_unlocked: (libc)Simple Output.
* fputws: (libc)Simple Output.
* fputws_unlocked: (libc)Simple Output.
* fread: (libc)Block Input/Output.
* fread_unlocked: (libc)Block Input/Output.
* free: (libc)Freeing after Malloc.
* freopen64: (libc)Opening Streams.
* freopen: (libc)Opening Streams.
* frexp: (libc)Normalization Functions.
* frexpf: (libc)Normalization Functions.
* frexpl: (libc)Normalization Functions.
* fscanf: (libc)Formatted Input Functions.
* fseek: (libc)File Positioning.
* fseeko64: (libc)File Positioning.
* fseeko: (libc)File Positioning.
* fsetpos64: (libc)Portable Positioning.
* fsetpos: (libc)Portable Positioning.
* fstat64: (libc)Reading Attributes.
* fstat: (libc)Reading Attributes.
* fsync: (libc)Synchronizing I/O.
* ftell: (libc)File Positioning.
* ftello64: (libc)File Positioning.
* ftello: (libc)File Positioning.
* ftruncate64: (libc)File Size.
* ftruncate: (libc)File Size.
* ftrylockfile: (libc)Streams and Threads.
* ftw64: (libc)Working with Directory Trees.
* ftw: (libc)Working with Directory Trees.
* funlockfile: (libc)Streams and Threads.
* futimes: (libc)File Times.
* fwide: (libc)Streams and I18N.
* fwprintf: (libc)Formatted Output Functions.
* fwrite: (libc)Block Input/Output.
* fwrite_unlocked: (libc)Block Input/Output.
* fwscanf: (libc)Formatted Input Functions.
* gamma: (libc)Special Functions.
* gammaf: (libc)Special Functions.
* gammal: (libc)Special Functions.
* gcvt: (libc)System V Number Conversion.
* get_avphys_pages: (libc)Query Memory Parameters.
* get_current_dir_name: (libc)Working Directory.
* get_nprocs: (libc)Processor Resources.
* get_nprocs_conf: (libc)Processor Resources.
* get_phys_pages: (libc)Query Memory Parameters.
* getauxval: (libc)Auxiliary Vector.
* getc: (libc)Character Input.
* getc_unlocked: (libc)Character Input.
* getchar: (libc)Character Input.
* getchar_unlocked: (libc)Character Input.
* getcontext: (libc)System V contexts.
* getcwd: (libc)Working Directory.
* getdate: (libc)General Time String Parsing.
* getdate_r: (libc)General Time String Parsing.
* getdelim: (libc)Line Input.
* getdomainnname: (libc)Host Identification.
* getegid: (libc)Reading Persona.
* getenv: (libc)Environment Access.
* geteuid: (libc)Reading Persona.
* getfsent: (libc)fstab.
* getfsfile: (libc)fstab.
* getfsspec: (libc)fstab.
* getgid: (libc)Reading Persona.
* getgrent: (libc)Scanning All Groups.
* getgrent_r: (libc)Scanning All Groups.
* getgrgid: (libc)Lookup Group.
* getgrgid_r: (libc)Lookup Group.
* getgrnam: (libc)Lookup Group.
* getgrnam_r: (libc)Lookup Group.
* getgrouplist: (libc)Setting Groups.
* getgroups: (libc)Reading Persona.
* gethostbyaddr: (libc)Host Names.
* gethostbyaddr_r: (libc)Host Names.
* gethostbyname2: (libc)Host Names.
* gethostbyname2_r: (libc)Host Names.
* gethostbyname: (libc)Host Names.
* gethostbyname_r: (libc)Host Names.
* gethostent: (libc)Host Names.
* gethostid: (libc)Host Identification.
* gethostname: (libc)Host Identification.
* getitimer: (libc)Setting an Alarm.
* getline: (libc)Line Input.
* getloadavg: (libc)Processor Resources.
* getlogin: (libc)Who Logged In.
* getmntent: (libc)mtab.
* getmntent_r: (libc)mtab.
* getnetbyaddr: (libc)Networks Database.
* getnetbyname: (libc)Networks Database.
* getnetent: (libc)Networks Database.
* getnetgrent: (libc)Lookup Netgroup.
* getnetgrent_r: (libc)Lookup Netgroup.
* getopt: (libc)Using Getopt.
* getopt_long: (libc)Getopt Long Options.
* getopt_long_only: (libc)Getopt Long Options.
* getpagesize: (libc)Query Memory Parameters.
* getpass: (libc)getpass.
* getpeername: (libc)Who is Connected.
* getpgid: (libc)Process Group Functions.
* getpgrp: (libc)Process Group Functions.
* getpid: (libc)Process Identification.
* getppid: (libc)Process Identification.
* getpriority: (libc)Traditional Scheduling Functions.
* getprotobyname: (libc)Protocols Database.
* getprotobynumber: (libc)Protocols Database.
* getprotoent: (libc)Protocols Database.
* getpt: (libc)Allocation.
* getpwent: (libc)Scanning All Users.
* getpwent_r: (libc)Scanning All Users.
* getpwnam: (libc)Lookup User.
* getpwnam_r: (libc)Lookup User.
* getpwuid: (libc)Lookup User.
* getpwuid_r: (libc)Lookup User.
* getrlimit64: (libc)Limits on Resources.
* getrlimit: (libc)Limits on Resources.
* getrusage: (libc)Resource Usage.
* gets: (libc)Line Input.
* getservbyname: (libc)Services Database.
* getservbyport: (libc)Services Database.
* getservent: (libc)Services Database.
* getsid: (libc)Process Group Functions.
* getsockname: (libc)Reading Address.
* getsockopt: (libc)Socket Option Functions.
* getsubopt: (libc)Suboptions.
* gettext: (libc)Translation with gettext.
* gettimeofday: (libc)High-Resolution Calendar.
* getuid: (libc)Reading Persona.
* getumask: (libc)Setting Permissions.
* getutent: (libc)Manipulating the Database.
* getutent_r: (libc)Manipulating the Database.
* getutid: (libc)Manipulating the Database.
* getutid_r: (libc)Manipulating the Database.
* getutline: (libc)Manipulating the Database.
* getutline_r: (libc)Manipulating the Database.
* getutmp: (libc)XPG Functions.
* getutmpx: (libc)XPG Functions.
* getutxent: (libc)XPG Functions.
* getutxid: (libc)XPG Functions.
* getutxline: (libc)XPG Functions.
* getw: (libc)Character Input.
* getwc: (libc)Character Input.
* getwc_unlocked: (libc)Character Input.
* getwchar: (libc)Character Input.
* getwchar_unlocked: (libc)Character Input.
* getwd: (libc)Working Directory.
* glob64: (libc)Calling Glob.
* glob: (libc)Calling Glob.
* globfree64: (libc)More Flags for Globbing.
* globfree: (libc)More Flags for Globbing.
* gmtime: (libc)Broken-down Time.
* gmtime_r: (libc)Broken-down Time.
* grantpt: (libc)Allocation.
* gsignal: (libc)Signaling Yourself.
* gtty: (libc)BSD Terminal Modes.
* hasmntopt: (libc)mtab.
* hcreate: (libc)Hash Search Function.
* hcreate_r: (libc)Hash Search Function.
* hdestroy: (libc)Hash Search Function.
* hdestroy_r: (libc)Hash Search Function.
* hsearch: (libc)Hash Search Function.
* hsearch_r: (libc)Hash Search Function.
* htonl: (libc)Byte Order.
* htons: (libc)Byte Order.
* hypot: (libc)Exponents and Logarithms.
* hypotf: (libc)Exponents and Logarithms.
* hypotl: (libc)Exponents and Logarithms.
* iconv: (libc)Generic Conversion Interface.
* iconv_close: (libc)Generic Conversion Interface.
* iconv_open: (libc)Generic Conversion Interface.
* if_freenameindex: (libc)Interface Naming.
* if_indextoname: (libc)Interface Naming.
* if_nameindex: (libc)Interface Naming.
* if_nametoindex: (libc)Interface Naming.
* ilogb: (libc)Exponents and Logarithms.
* ilogbf: (libc)Exponents and Logarithms.
* ilogbl: (libc)Exponents and Logarithms.
* imaxabs: (libc)Absolute Value.
* imaxdiv: (libc)Integer Division.
* in6addr_any: (libc)Host Address Data Type.
* in6addr_loopback: (libc)Host Address Data Type.
* index: (libc)Search Functions.
* inet_addr: (libc)Host Address Functions.
* inet_aton: (libc)Host Address Functions.
* inet_lnaof: (libc)Host Address Functions.
* inet_makeaddr: (libc)Host Address Functions.
* inet_netof: (libc)Host Address Functions.
* inet_network: (libc)Host Address Functions.
* inet_ntoa: (libc)Host Address Functions.
* inet_ntop: (libc)Host Address Functions.
* inet_pton: (libc)Host Address Functions.
* initgroups: (libc)Setting Groups.
* initstate: (libc)BSD Random.
* initstate_r: (libc)BSD Random.
* innetgr: (libc)Netgroup Membership.
* ioctl: (libc)IOCTLs.
* isalnum: (libc)Classification of Characters.
* isalpha: (libc)Classification of Characters.
* isascii: (libc)Classification of Characters.
* isatty: (libc)Is It a Terminal.
* isblank: (libc)Classification of Characters.
* iscntrl: (libc)Classification of Characters.
* isdigit: (libc)Classification of Characters.
* isfinite: (libc)Floating Point Classes.
* isgraph: (libc)Classification of Characters.
* isgreater: (libc)FP Comparison Functions.
* isgreaterequal: (libc)FP Comparison Functions.
* isinf: (libc)Floating Point Classes.
* isinff: (libc)Floating Point Classes.
* isinfl: (libc)Floating Point Classes.
* isless: (libc)FP Comparison Functions.
* islessequal: (libc)FP Comparison Functions.
* islessgreater: (libc)FP Comparison Functions.
* islower: (libc)Classification of Characters.
* isnan: (libc)Floating Point Classes.
* isnan: (libc)Floating Point Classes.
* isnanf: (libc)Floating Point Classes.
* isnanl: (libc)Floating Point Classes.
* isnormal: (libc)Floating Point Classes.
* isprint: (libc)Classification of Characters.
* ispunct: (libc)Classification of Characters.
* issignaling: (libc)Floating Point Classes.
* isspace: (libc)Classification of Characters.
* isunordered: (libc)FP Comparison Functions.
* isupper: (libc)Classification of Characters.
* iswalnum: (libc)Classification of Wide Characters.
* iswalpha: (libc)Classification of Wide Characters.
* iswblank: (libc)Classification of Wide Characters.
* iswcntrl: (libc)Classification of Wide Characters.
* iswctype: (libc)Classification of Wide Characters.
* iswdigit: (libc)Classification of Wide Characters.
* iswgraph: (libc)Classification of Wide Characters.
* iswlower: (libc)Classification of Wide Characters.
* iswprint: (libc)Classification of Wide Characters.
* iswpunct: (libc)Classification of Wide Characters.
* iswspace: (libc)Classification of Wide Characters.
* iswupper: (libc)Classification of Wide Characters.
* iswxdigit: (libc)Classification of Wide Characters.
* isxdigit: (libc)Classification of Characters.
* j0: (libc)Special Functions.
* j0f: (libc)Special Functions.
* j0l: (libc)Special Functions.
* j1: (libc)Special Functions.
* j1f: (libc)Special Functions.
* j1l: (libc)Special Functions.
* jn: (libc)Special Functions.
* jnf: (libc)Special Functions.
* jnl: (libc)Special Functions.
* jrand48: (libc)SVID Random.
* jrand48_r: (libc)SVID Random.
* kill: (libc)Signaling Another Process.
* killpg: (libc)Signaling Another Process.
* l64a: (libc)Encode Binary Data.
* labs: (libc)Absolute Value.
* lcong48: (libc)SVID Random.
* lcong48_r: (libc)SVID Random.
* ldexp: (libc)Normalization Functions.
* ldexpf: (libc)Normalization Functions.
* ldexpl: (libc)Normalization Functions.
* ldiv: (libc)Integer Division.
* lfind: (libc)Array Search Function.
* lgamma: (libc)Special Functions.
* lgamma_r: (libc)Special Functions.
* lgammaf: (libc)Special Functions.
* lgammaf_r: (libc)Special Functions.
* lgammal: (libc)Special Functions.
* lgammal_r: (libc)Special Functions.
* link: (libc)Hard Links.
* lio_listio64: (libc)Asynchronous Reads/Writes.
* lio_listio: (libc)Asynchronous Reads/Writes.
* listen: (libc)Listening.
* llabs: (libc)Absolute Value.
* lldiv: (libc)Integer Division.
* llrint: (libc)Rounding Functions.
* llrintf: (libc)Rounding Functions.
* llrintl: (libc)Rounding Functions.
* llround: (libc)Rounding Functions.
* llroundf: (libc)Rounding Functions.
* llroundl: (libc)Rounding Functions.
* localeconv: (libc)The Lame Way to Locale Data.
* localtime: (libc)Broken-down Time.
* localtime_r: (libc)Broken-down Time.
* log10: (libc)Exponents and Logarithms.
* log10f: (libc)Exponents and Logarithms.
* log10l: (libc)Exponents and Logarithms.
* log1p: (libc)Exponents and Logarithms.
* log1pf: (libc)Exponents and Logarithms.
* log1pl: (libc)Exponents and Logarithms.
* log2: (libc)Exponents and Logarithms.
* log2f: (libc)Exponents and Logarithms.
* log2l: (libc)Exponents and Logarithms.
* log: (libc)Exponents and Logarithms.
* logb: (libc)Exponents and Logarithms.
* logbf: (libc)Exponents and Logarithms.
* logbl: (libc)Exponents and Logarithms.
* logf: (libc)Exponents and Logarithms.
* login: (libc)Logging In and Out.
* login_tty: (libc)Logging In and Out.
* logl: (libc)Exponents and Logarithms.
* logout: (libc)Logging In and Out.
* logwtmp: (libc)Logging In and Out.
* longjmp: (libc)Non-Local Details.
* lrand48: (libc)SVID Random.
* lrand48_r: (libc)SVID Random.
* lrint: (libc)Rounding Functions.
* lrintf: (libc)Rounding Functions.
* lrintl: (libc)Rounding Functions.
* lround: (libc)Rounding Functions.
* lroundf: (libc)Rounding Functions.
* lroundl: (libc)Rounding Functions.
* lsearch: (libc)Array Search Function.
* lseek64: (libc)File Position Primitive.
* lseek: (libc)File Position Primitive.
* lstat64: (libc)Reading Attributes.
* lstat: (libc)Reading Attributes.
* lutimes: (libc)File Times.
* madvise: (libc)Memory-mapped I/O.
* makecontext: (libc)System V contexts.
* mallinfo: (libc)Statistics of Malloc.
* malloc: (libc)Basic Allocation.
* mallopt: (libc)Malloc Tunable Parameters.
* mblen: (libc)Non-reentrant Character Conversion.
* mbrlen: (libc)Converting a Character.
* mbrtowc: (libc)Converting a Character.
* mbsinit: (libc)Keeping the state.
* mbsnrtowcs: (libc)Converting Strings.
* mbsrtowcs: (libc)Converting Strings.
* mbstowcs: (libc)Non-reentrant String Conversion.
* mbtowc: (libc)Non-reentrant Character Conversion.
* mcheck: (libc)Heap Consistency Checking.
* memalign: (libc)Aligned Memory Blocks.
* memccpy: (libc)Copying and Concatenation.
* memchr: (libc)Search Functions.
* memcmp: (libc)String/Array Comparison.
* memcpy: (libc)Copying and Concatenation.
* memfrob: (libc)Trivial Encryption.
* memmem: (libc)Search Functions.
* memmove: (libc)Copying and Concatenation.
* mempcpy: (libc)Copying and Concatenation.
* memrchr: (libc)Search Functions.
* memset: (libc)Copying and Concatenation.
* mkdir: (libc)Creating Directories.
* mkdtemp: (libc)Temporary Files.
* mkfifo: (libc)FIFO Special Files.
* mknod: (libc)Making Special Files.
* mkstemp: (libc)Temporary Files.
* mktemp: (libc)Temporary Files.
* mktime: (libc)Broken-down Time.
* mlock: (libc)Page Lock Functions.
* mlockall: (libc)Page Lock Functions.
* mmap64: (libc)Memory-mapped I/O.
* mmap: (libc)Memory-mapped I/O.
* modf: (libc)Rounding Functions.
* modff: (libc)Rounding Functions.
* modfl: (libc)Rounding Functions.
* mount: (libc)Mount-Unmount-Remount.
* mprobe: (libc)Heap Consistency Checking.
* mrand48: (libc)SVID Random.
* mrand48_r: (libc)SVID Random.
* mremap: (libc)Memory-mapped I/O.
* msync: (libc)Memory-mapped I/O.
* mtrace: (libc)Tracing malloc.
* munlock: (libc)Page Lock Functions.
* munlockall: (libc)Page Lock Functions.
* munmap: (libc)Memory-mapped I/O.
* muntrace: (libc)Tracing malloc.
* nan: (libc)FP Bit Twiddling.
* nanf: (libc)FP Bit Twiddling.
* nanl: (libc)FP Bit Twiddling.
* nanosleep: (libc)Sleeping.
* nearbyint: (libc)Rounding Functions.
* nearbyintf: (libc)Rounding Functions.
* nearbyintl: (libc)Rounding Functions.
* nextafter: (libc)FP Bit Twiddling.
* nextafterf: (libc)FP Bit Twiddling.
* nextafterl: (libc)FP Bit Twiddling.
* nexttoward: (libc)FP Bit Twiddling.
* nexttowardf: (libc)FP Bit Twiddling.
* nexttowardl: (libc)FP Bit Twiddling.
* nftw64: (libc)Working with Directory Trees.
* nftw: (libc)Working with Directory Trees.
* ngettext: (libc)Advanced gettext functions.
* nice: (libc)Traditional Scheduling Functions.
* nl_langinfo: (libc)The Elegant and Fast Way.
* nrand48: (libc)SVID Random.
* nrand48_r: (libc)SVID Random.
* ntohl: (libc)Byte Order.
* ntohs: (libc)Byte Order.
* ntp_adjtime: (libc)High Accuracy Clock.
* ntp_gettime: (libc)High Accuracy Clock.
* obstack_1grow: (libc)Growing Objects.
* obstack_1grow_fast: (libc)Extra Fast Growing.
* obstack_alignment_mask: (libc)Obstacks Data Alignment.
* obstack_alloc: (libc)Allocation in an Obstack.
* obstack_base: (libc)Status of an Obstack.
* obstack_blank: (libc)Growing Objects.
* obstack_blank_fast: (libc)Extra Fast Growing.
* obstack_chunk_size: (libc)Obstack Chunks.
* obstack_copy0: (libc)Allocation in an Obstack.
* obstack_copy: (libc)Allocation in an Obstack.
* obstack_finish: (libc)Growing Objects.
* obstack_free: (libc)Freeing Obstack Objects.
* obstack_grow0: (libc)Growing Objects.
* obstack_grow: (libc)Growing Objects.
* obstack_init: (libc)Preparing for Obstacks.
* obstack_int_grow: (libc)Growing Objects.
* obstack_int_grow_fast: (libc)Extra Fast Growing.
* obstack_next_free: (libc)Status of an Obstack.
* obstack_object_size: (libc)Growing Objects.
* obstack_object_size: (libc)Status of an Obstack.
* obstack_printf: (libc)Dynamic Output.
* obstack_ptr_grow: (libc)Growing Objects.
* obstack_ptr_grow_fast: (libc)Extra Fast Growing.
* obstack_room: (libc)Extra Fast Growing.
* obstack_vprintf: (libc)Variable Arguments Output.
* offsetof: (libc)Structure Measurement.
* on_exit: (libc)Cleanups on Exit.
* open64: (libc)Opening and Closing Files.
* open: (libc)Opening and Closing Files.
* open_memstream: (libc)String Streams.
* opendir: (libc)Opening a Directory.
* openlog: (libc)openlog.
* openpty: (libc)Pseudo-Terminal Pairs.
* parse_printf_format: (libc)Parsing a Template String.
* pathconf: (libc)Pathconf.
* pause: (libc)Using Pause.
* pclose: (libc)Pipe to a Subprocess.
* perror: (libc)Error Messages.
* pipe: (libc)Creating a Pipe.
* popen: (libc)Pipe to a Subprocess.
* posix_memalign: (libc)Aligned Memory Blocks.
* pow10: (libc)Exponents and Logarithms.
* pow10f: (libc)Exponents and Logarithms.
* pow10l: (libc)Exponents and Logarithms.
* pow: (libc)Exponents and Logarithms.
* powf: (libc)Exponents and Logarithms.
* powl: (libc)Exponents and Logarithms.
* pread64: (libc)I/O Primitives.
* pread: (libc)I/O Primitives.
* printf: (libc)Formatted Output Functions.
* printf_size: (libc)Predefined Printf Handlers.
* printf_size_info: (libc)Predefined Printf Handlers.
* psignal: (libc)Signal Messages.
* pthread_getattr_default_np: (libc)Default Thread Attributes.
* pthread_getspecific: (libc)Thread-specific Data.
* pthread_key_create: (libc)Thread-specific Data.
* pthread_key_delete: (libc)Thread-specific Data.
* pthread_setattr_default_np: (libc)Default Thread Attributes.
* pthread_setspecific: (libc)Thread-specific Data.
* ptsname: (libc)Allocation.
* ptsname_r: (libc)Allocation.
* putc: (libc)Simple Output.
* putc_unlocked: (libc)Simple Output.
* putchar: (libc)Simple Output.
* putchar_unlocked: (libc)Simple Output.
* putenv: (libc)Environment Access.
* putpwent: (libc)Writing a User Entry.
* puts: (libc)Simple Output.
* pututline: (libc)Manipulating the Database.
* pututxline: (libc)XPG Functions.
* putw: (libc)Simple Output.
* putwc: (libc)Simple Output.
* putwc_unlocked: (libc)Simple Output.
* putwchar: (libc)Simple Output.
* putwchar_unlocked: (libc)Simple Output.
* pwrite64: (libc)I/O Primitives.
* pwrite: (libc)I/O Primitives.
* qecvt: (libc)System V Number Conversion.
* qecvt_r: (libc)System V Number Conversion.
* qfcvt: (libc)System V Number Conversion.
* qfcvt_r: (libc)System V Number Conversion.
* qgcvt: (libc)System V Number Conversion.
* qsort: (libc)Array Sort Function.
* raise: (libc)Signaling Yourself.
* rand: (libc)ISO Random.
* rand_r: (libc)ISO Random.
* random: (libc)BSD Random.
* random_r: (libc)BSD Random.
* rawmemchr: (libc)Search Functions.
* read: (libc)I/O Primitives.
* readdir64: (libc)Reading/Closing Directory.
* readdir64_r: (libc)Reading/Closing Directory.
* readdir: (libc)Reading/Closing Directory.
* readdir_r: (libc)Reading/Closing Directory.
* readlink: (libc)Symbolic Links.
* readv: (libc)Scatter-Gather.
* realloc: (libc)Changing Block Size.
* realpath: (libc)Symbolic Links.
* recv: (libc)Receiving Data.
* recvfrom: (libc)Receiving Datagrams.
* recvmsg: (libc)Receiving Datagrams.
* regcomp: (libc)POSIX Regexp Compilation.
* regerror: (libc)Regexp Cleanup.
* regexec: (libc)Matching POSIX Regexps.
* regfree: (libc)Regexp Cleanup.
* register_printf_function: (libc)Registering New Conversions.
* remainder: (libc)Remainder Functions.
* remainderf: (libc)Remainder Functions.
* remainderl: (libc)Remainder Functions.
* remove: (libc)Deleting Files.
* rename: (libc)Renaming Files.
* rewind: (libc)File Positioning.
* rewinddir: (libc)Random Access Directory.
* rindex: (libc)Search Functions.
* rint: (libc)Rounding Functions.
* rintf: (libc)Rounding Functions.
* rintl: (libc)Rounding Functions.
* rmdir: (libc)Deleting Files.
* round: (libc)Rounding Functions.
* roundf: (libc)Rounding Functions.
* roundl: (libc)Rounding Functions.
* rpmatch: (libc)Yes-or-No Questions.
* sbrk: (libc)Resizing the Data Segment.
* scalb: (libc)Normalization Functions.
* scalbf: (libc)Normalization Functions.
* scalbl: (libc)Normalization Functions.
* scalbln: (libc)Normalization Functions.
* scalblnf: (libc)Normalization Functions.
* scalblnl: (libc)Normalization Functions.
* scalbn: (libc)Normalization Functions.
* scalbnf: (libc)Normalization Functions.
* scalbnl: (libc)Normalization Functions.
* scandir64: (libc)Scanning Directory Content.
* scandir: (libc)Scanning Directory Content.
* scanf: (libc)Formatted Input Functions.
* sched_get_priority_max: (libc)Basic Scheduling Functions.
* sched_get_priority_min: (libc)Basic Scheduling Functions.
* sched_getaffinity: (libc)CPU Affinity.
* sched_getparam: (libc)Basic Scheduling Functions.
* sched_getscheduler: (libc)Basic Scheduling Functions.
* sched_rr_get_interval: (libc)Basic Scheduling Functions.
* sched_setaffinity: (libc)CPU Affinity.
* sched_setparam: (libc)Basic Scheduling Functions.
* sched_setscheduler: (libc)Basic Scheduling Functions.
* sched_yield: (libc)Basic Scheduling Functions.
* secure_getenv: (libc)Environment Access.
* seed48: (libc)SVID Random.
* seed48_r: (libc)SVID Random.
* seekdir: (libc)Random Access Directory.
* select: (libc)Waiting for I/O.
* send: (libc)Sending Data.
* sendmsg: (libc)Receiving Datagrams.
* sendto: (libc)Sending Datagrams.
* setbuf: (libc)Controlling Buffering.
* setbuffer: (libc)Controlling Buffering.
* setcontext: (libc)System V contexts.
* setdomainname: (libc)Host Identification.
* setegid: (libc)Setting Groups.
* setenv: (libc)Environment Access.
* seteuid: (libc)Setting User ID.
* setfsent: (libc)fstab.
* setgid: (libc)Setting Groups.
* setgrent: (libc)Scanning All Groups.
* setgroups: (libc)Setting Groups.
* sethostent: (libc)Host Names.
* sethostid: (libc)Host Identification.
* sethostname: (libc)Host Identification.
* setitimer: (libc)Setting an Alarm.
* setjmp: (libc)Non-Local Details.
* setkey: (libc)DES Encryption.
* setkey_r: (libc)DES Encryption.
* setlinebuf: (libc)Controlling Buffering.
* setlocale: (libc)Setting the Locale.
* setlogmask: (libc)setlogmask.
* setmntent: (libc)mtab.
* setnetent: (libc)Networks Database.
* setnetgrent: (libc)Lookup Netgroup.
* setpgid: (libc)Process Group Functions.
* setpgrp: (libc)Process Group Functions.
* setpriority: (libc)Traditional Scheduling Functions.
* setprotoent: (libc)Protocols Database.
* setpwent: (libc)Scanning All Users.
* setregid: (libc)Setting Groups.
* setreuid: (libc)Setting User ID.
* setrlimit64: (libc)Limits on Resources.
* setrlimit: (libc)Limits on Resources.
* setservent: (libc)Services Database.
* setsid: (libc)Process Group Functions.
* setsockopt: (libc)Socket Option Functions.
* setstate: (libc)BSD Random.
* setstate_r: (libc)BSD Random.
* settimeofday: (libc)High-Resolution Calendar.
* setuid: (libc)Setting User ID.
* setutent: (libc)Manipulating the Database.
* setutxent: (libc)XPG Functions.
* setvbuf: (libc)Controlling Buffering.
* shm_open: (libc)Memory-mapped I/O.
* shm_unlink: (libc)Memory-mapped I/O.
* shutdown: (libc)Closing a Socket.
* sigaction: (libc)Advanced Signal Handling.
* sigaddset: (libc)Signal Sets.
* sigaltstack: (libc)Signal Stack.
* sigblock: (libc)Blocking in BSD.
* sigdelset: (libc)Signal Sets.
* sigemptyset: (libc)Signal Sets.
* sigfillset: (libc)Signal Sets.
* siginterrupt: (libc)BSD Handler.
* sigismember: (libc)Signal Sets.
* siglongjmp: (libc)Non-Local Exits and Signals.
* sigmask: (libc)Blocking in BSD.
* signal: (libc)Basic Signal Handling.
* signbit: (libc)FP Bit Twiddling.
* significand: (libc)Normalization Functions.
* significandf: (libc)Normalization Functions.
* significandl: (libc)Normalization Functions.
* sigpause: (libc)Blocking in BSD.
* sigpending: (libc)Checking for Pending Signals.
* sigprocmask: (libc)Process Signal Mask.
* sigsetjmp: (libc)Non-Local Exits and Signals.
* sigsetmask: (libc)Blocking in BSD.
* sigstack: (libc)Signal Stack.
* sigsuspend: (libc)Sigsuspend.
* sigvec: (libc)BSD Handler.
* sin: (libc)Trig Functions.
* sincos: (libc)Trig Functions.
* sincosf: (libc)Trig Functions.
* sincosl: (libc)Trig Functions.
* sinf: (libc)Trig Functions.
* sinh: (libc)Hyperbolic Functions.
* sinhf: (libc)Hyperbolic Functions.
* sinhl: (libc)Hyperbolic Functions.
* sinl: (libc)Trig Functions.
* sleep: (libc)Sleeping.
* snprintf: (libc)Formatted Output Functions.
* socket: (libc)Creating a Socket.
* socketpair: (libc)Socket Pairs.
* sprintf: (libc)Formatted Output Functions.
* sqrt: (libc)Exponents and Logarithms.
* sqrtf: (libc)Exponents and Logarithms.
* sqrtl: (libc)Exponents and Logarithms.
* srand48: (libc)SVID Random.
* srand48_r: (libc)SVID Random.
* srand: (libc)ISO Random.
* srandom: (libc)BSD Random.
* srandom_r: (libc)BSD Random.
* sscanf: (libc)Formatted Input Functions.
* ssignal: (libc)Basic Signal Handling.
* stat64: (libc)Reading Attributes.
* stat: (libc)Reading Attributes.
* stime: (libc)Simple Calendar Time.
* stpcpy: (libc)Copying and Concatenation.
* stpncpy: (libc)Copying and Concatenation.
* strcasecmp: (libc)String/Array Comparison.
* strcasestr: (libc)Search Functions.
* strcat: (libc)Copying and Concatenation.
* strchr: (libc)Search Functions.
* strchrnul: (libc)Search Functions.
* strcmp: (libc)String/Array Comparison.
* strcoll: (libc)Collation Functions.
* strcpy: (libc)Copying and Concatenation.
* strcspn: (libc)Search Functions.
* strdup: (libc)Copying and Concatenation.
* strdupa: (libc)Copying and Concatenation.
* strerror: (libc)Error Messages.
* strerror_r: (libc)Error Messages.
* strfmon: (libc)Formatting Numbers.
* strfry: (libc)strfry.
* strftime: (libc)Formatting Calendar Time.
* strlen: (libc)String Length.
* strncasecmp: (libc)String/Array Comparison.
* strncat: (libc)Copying and Concatenation.
* strncmp: (libc)String/Array Comparison.
* strncpy: (libc)Copying and Concatenation.
* strndup: (libc)Copying and Concatenation.
* strndupa: (libc)Copying and Concatenation.
* strnlen: (libc)String Length.
* strpbrk: (libc)Search Functions.
* strptime: (libc)Low-Level Time String Parsing.
* strrchr: (libc)Search Functions.
* strsep: (libc)Finding Tokens in a String.
* strsignal: (libc)Signal Messages.
* strspn: (libc)Search Functions.
* strstr: (libc)Search Functions.
* strtod: (libc)Parsing of Floats.
* strtof: (libc)Parsing of Floats.
* strtoimax: (libc)Parsing of Integers.
* strtok: (libc)Finding Tokens in a String.
* strtok_r: (libc)Finding Tokens in a String.
* strtol: (libc)Parsing of Integers.
* strtold: (libc)Parsing of Floats.
* strtoll: (libc)Parsing of Integers.
* strtoq: (libc)Parsing of Integers.
* strtoul: (libc)Parsing of Integers.
* strtoull: (libc)Parsing of Integers.
* strtoumax: (libc)Parsing of Integers.
* strtouq: (libc)Parsing of Integers.
* strverscmp: (libc)String/Array Comparison.
* strxfrm: (libc)Collation Functions.
* stty: (libc)BSD Terminal Modes.
* swapcontext: (libc)System V contexts.
* swprintf: (libc)Formatted Output Functions.
* swscanf: (libc)Formatted Input Functions.
* symlink: (libc)Symbolic Links.
* sync: (libc)Synchronizing I/O.
* syscall: (libc)System Calls.
* sysconf: (libc)Sysconf Definition.
* sysctl: (libc)System Parameters.
* syslog: (libc)syslog; vsyslog.
* system: (libc)Running a Command.
* sysv_signal: (libc)Basic Signal Handling.
* tan: (libc)Trig Functions.
* tanf: (libc)Trig Functions.
* tanh: (libc)Hyperbolic Functions.
* tanhf: (libc)Hyperbolic Functions.
* tanhl: (libc)Hyperbolic Functions.
* tanl: (libc)Trig Functions.
* tcdrain: (libc)Line Control.
* tcflow: (libc)Line Control.
* tcflush: (libc)Line Control.
* tcgetattr: (libc)Mode Functions.
* tcgetpgrp: (libc)Terminal Access Functions.
* tcgetsid: (libc)Terminal Access Functions.
* tcsendbreak: (libc)Line Control.
* tcsetattr: (libc)Mode Functions.
* tcsetpgrp: (libc)Terminal Access Functions.
* tdelete: (libc)Tree Search Function.
* tdestroy: (libc)Tree Search Function.
* telldir: (libc)Random Access Directory.
* tempnam: (libc)Temporary Files.
* textdomain: (libc)Locating gettext catalog.
* tfind: (libc)Tree Search Function.
* tgamma: (libc)Special Functions.
* tgammaf: (libc)Special Functions.
* tgammal: (libc)Special Functions.
* time: (libc)Simple Calendar Time.
* timegm: (libc)Broken-down Time.
* timelocal: (libc)Broken-down Time.
* times: (libc)Processor Time.
* tmpfile64: (libc)Temporary Files.
* tmpfile: (libc)Temporary Files.
* tmpnam: (libc)Temporary Files.
* tmpnam_r: (libc)Temporary Files.
* toascii: (libc)Case Conversion.
* tolower: (libc)Case Conversion.
* toupper: (libc)Case Conversion.
* towctrans: (libc)Wide Character Case Conversion.
* towlower: (libc)Wide Character Case Conversion.
* towupper: (libc)Wide Character Case Conversion.
* trunc: (libc)Rounding Functions.
* truncate64: (libc)File Size.
* truncate: (libc)File Size.
* truncf: (libc)Rounding Functions.
* truncl: (libc)Rounding Functions.
* tsearch: (libc)Tree Search Function.
* ttyname: (libc)Is It a Terminal.
* ttyname_r: (libc)Is It a Terminal.
* twalk: (libc)Tree Search Function.
* tzset: (libc)Time Zone Functions.
* ulimit: (libc)Limits on Resources.
* umask: (libc)Setting Permissions.
* umount2: (libc)Mount-Unmount-Remount.
* umount: (libc)Mount-Unmount-Remount.
* uname: (libc)Platform Type.
* ungetc: (libc)How Unread.
* ungetwc: (libc)How Unread.
* unlink: (libc)Deleting Files.
* unlockpt: (libc)Allocation.
* unsetenv: (libc)Environment Access.
* updwtmp: (libc)Manipulating the Database.
* utime: (libc)File Times.
* utimes: (libc)File Times.
* utmpname: (libc)Manipulating the Database.
* utmpxname: (libc)XPG Functions.
* va_arg: (libc)Argument Macros.
* va_copy: (libc)Argument Macros.
* va_end: (libc)Argument Macros.
* va_start: (libc)Argument Macros.
* valloc: (libc)Aligned Memory Blocks.
* vasprintf: (libc)Variable Arguments Output.
* verr: (libc)Error Messages.
* verrx: (libc)Error Messages.
* versionsort64: (libc)Scanning Directory Content.
* versionsort: (libc)Scanning Directory Content.
* vfork: (libc)Creating a Process.
* vfprintf: (libc)Variable Arguments Output.
* vfscanf: (libc)Variable Arguments Input.
* vfwprintf: (libc)Variable Arguments Output.
* vfwscanf: (libc)Variable Arguments Input.
* vlimit: (libc)Limits on Resources.
* vprintf: (libc)Variable Arguments Output.
* vscanf: (libc)Variable Arguments Input.
* vsnprintf: (libc)Variable Arguments Output.
* vsprintf: (libc)Variable Arguments Output.
* vsscanf: (libc)Variable Arguments Input.
* vswprintf: (libc)Variable Arguments Output.
* vswscanf: (libc)Variable Arguments Input.
* vsyslog: (libc)syslog; vsyslog.
* vtimes: (libc)Resource Usage.
* vwarn: (libc)Error Messages.
* vwarnx: (libc)Error Messages.
* vwprintf: (libc)Variable Arguments Output.
* vwscanf: (libc)Variable Arguments Input.
* wait3: (libc)BSD Wait Functions.
* wait4: (libc)Process Completion.
* wait: (libc)Process Completion.
* waitpid: (libc)Process Completion.
* warn: (libc)Error Messages.
* warnx: (libc)Error Messages.
* wcpcpy: (libc)Copying and Concatenation.
* wcpncpy: (libc)Copying and Concatenation.
* wcrtomb: (libc)Converting a Character.
* wcscasecmp: (libc)String/Array Comparison.
* wcscat: (libc)Copying and Concatenation.
* wcschr: (libc)Search Functions.
* wcschrnul: (libc)Search Functions.
* wcscmp: (libc)String/Array Comparison.
* wcscoll: (libc)Collation Functions.
* wcscpy: (libc)Copying and Concatenation.
* wcscspn: (libc)Search Functions.
* wcsdup: (libc)Copying and Concatenation.
* wcsftime: (libc)Formatting Calendar Time.
* wcslen: (libc)String Length.
* wcsncasecmp: (libc)String/Array Comparison.
* wcsncat: (libc)Copying and Concatenation.
* wcsncmp: (libc)String/Array Comparison.
* wcsncpy: (libc)Copying and Concatenation.
* wcsnlen: (libc)String Length.
* wcsnrtombs: (libc)Converting Strings.
* wcspbrk: (libc)Search Functions.
* wcsrchr: (libc)Search Functions.
* wcsrtombs: (libc)Converting Strings.
* wcsspn: (libc)Search Functions.
* wcsstr: (libc)Search Functions.
* wcstod: (libc)Parsing of Floats.
* wcstof: (libc)Parsing of Floats.
* wcstoimax: (libc)Parsing of Integers.
* wcstok: (libc)Finding Tokens in a String.
* wcstol: (libc)Parsing of Integers.
* wcstold: (libc)Parsing of Floats.
* wcstoll: (libc)Parsing of Integers.
* wcstombs: (libc)Non-reentrant String Conversion.
* wcstoq: (libc)Parsing of Integers.
* wcstoul: (libc)Parsing of Integers.
* wcstoull: (libc)Parsing of Integers.
* wcstoumax: (libc)Parsing of Integers.
* wcstouq: (libc)Parsing of Integers.
* wcswcs: (libc)Search Functions.
* wcsxfrm: (libc)Collation Functions.
* wctob: (libc)Converting a Character.
* wctomb: (libc)Non-reentrant Character Conversion.
* wctrans: (libc)Wide Character Case Conversion.
* wctype: (libc)Classification of Wide Characters.
* wmemchr: (libc)Search Functions.
* wmemcmp: (libc)String/Array Comparison.
* wmemcpy: (libc)Copying and Concatenation.
* wmemmove: (libc)Copying and Concatenation.
* wmempcpy: (libc)Copying and Concatenation.
* wmemset: (libc)Copying and Concatenation.
* wordexp: (libc)Calling Wordexp.
* wordfree: (libc)Calling Wordexp.
* wprintf: (libc)Formatted Output Functions.
* write: (libc)I/O Primitives.
* writev: (libc)Scatter-Gather.
* wscanf: (libc)Formatted Input Functions.
* y0: (libc)Special Functions.
* y0f: (libc)Special Functions.
* y0l: (libc)Special Functions.
* y1: (libc)Special Functions.
* y1f: (libc)Special Functions.
* y1l: (libc)Special Functions.
* yn: (libc)Special Functions.
* ynf: (libc)Special Functions.
* ynl: (libc)Special Functions.
END-INFO-DIR-ENTRY
This file documents the GNU C Library.
This is `The GNU C Library Reference Manual', for version 2.19
(Buildroot).
Copyright (C) 1993-2014 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version
1.3 or any later version published by the Free Software Foundation;
with the Invariant Sections being "Free Software Needs Free
Documentation" and "GNU Lesser General Public License", the Front-Cover
texts being "A GNU Manual", and with the Back-Cover Texts as in (a)
below. A copy of the license is included in the section entitled "GNU
Free Documentation License".
(a) The FSF's Back-Cover Text is: "You have the freedom to copy and
modify this GNU manual. Buying copies from the FSF supports it in
developing GNU and promoting software freedom."

File: libc.info, Node: fstab, Next: mtab, Up: Mount Information
30.3.1.1 The `fstab' file
.........................
The internal representation for entries of the file is `struct fstab',
defined in `fstab.h'.
-- Data Type: struct fstab
This structure is used with the `getfsent', `getfsspec', and
`getfsfile' functions.
`char *fs_spec'
This element describes the device from which the filesystem
is mounted. Normally this is the name of a special device,
such as a hard disk partition, but it could also be a more or
less generic string. For "NFS" it would be a hostname and
directory name combination.
Even though the element is not declared `const' it shouldn't
be modified. The missing `const' has historic reasons, since
this function predates ISO C. The same is true for the other
string elements of this structure.
`char *fs_file'
This describes the mount point on the local system. I.e.,
accessing any file in this filesystem has implicitly or
explicitly this string as a prefix.
`char *fs_vfstype'
This is the type of the filesystem. Depending on what the
underlying kernel understands it can be any string.
`char *fs_mntops'
This is a string containing options passed to the kernel with
the `mount' call. Again, this can be almost anything. There
can be more than one option, separated from the others by a
comma. Each option consists of a name and an optional value
part, introduced by an `=' character.
If the value of this element must be processed it should
ideally be done using the `getsubopt' function; see *note
Suboptions::.
`const char *fs_type'
This name is poorly chosen. This element points to a string
(possibly in the `fs_mntops' string) which describes the
modes with which the filesystem is mounted. `fstab' defines
five macros to describe the possible values:
`FSTAB_RW'
The filesystems gets mounted with read and write enabled.
`FSTAB_RQ'
The filesystems gets mounted with read and write
enabled. Write access is restricted by quotas.
`FSTAB_RO'
The filesystem gets mounted read-only.
`FSTAB_SW'
This is not a real filesystem, it is a swap device.
`FSTAB_XX'
This entry from the `fstab' file is totally ignored.
Testing for equality with these value must happen using
`strcmp' since these are all strings. Comparing the pointer
will probably always fail.
`int fs_freq'
This element describes the dump frequency in days.
`int fs_passno'
This element describes the pass number on parallel dumps. It
is closely related to the `dump' utility used on Unix systems.
To read the entire content of the of the `fstab' file the GNU C
Library contains a set of three functions which are designed in the
usual way.
-- Function: int setfsent (void)
Preliminary: | MT-Unsafe race:fsent | AS-Unsafe heap corrupt lock
| AC-Unsafe corrupt lock mem fd | *Note POSIX Safety Concepts::.
This function makes sure that the internal read pointer for the
`fstab' file is at the beginning of the file. This is done by
either opening the file or resetting the read pointer.
Since the file handle is internal to the libc this function is not
thread-safe.
This function returns a non-zero value if the operation was
successful and the `getfs*' functions can be used to read the
entries of the file.
-- Function: void endfsent (void)
Preliminary: | MT-Unsafe race:fsent | AS-Unsafe heap corrupt lock
| AC-Unsafe corrupt lock mem fd | *Note POSIX Safety Concepts::.
This function makes sure that all resources acquired by a prior
call to `setfsent' (explicitly or implicitly by calling
`getfsent') are freed.
-- Function: struct fstab * getfsent (void)
Preliminary: | MT-Unsafe race:fsent locale | AS-Unsafe corrupt
heap lock | AC-Unsafe corrupt lock mem | *Note POSIX Safety
Concepts::.
This function returns the next entry of the `fstab' file. If this
is the first call to any of the functions handling `fstab' since
program start or the last call of `endfsent', the file will be
opened.
The function returns a pointer to a variable of type `struct
fstab'. This variable is shared by all threads and therefore this
function is not thread-safe. If an error occurred `getfsent'
returns a `NULL' pointer.
-- Function: struct fstab * getfsspec (const char *NAME)
Preliminary: | MT-Unsafe race:fsent locale | AS-Unsafe corrupt
heap lock | AC-Unsafe corrupt lock mem | *Note POSIX Safety
Concepts::.
This function returns the next entry of the `fstab' file which has
a string equal to NAME pointed to by the `fs_spec' element. Since
there is normally exactly one entry for each special device it
makes no sense to call this function more than once for the same
argument. If this is the first call to any of the functions
handling `fstab' since program start or the last call of
`endfsent', the file will be opened.
The function returns a pointer to a variable of type `struct
fstab'. This variable is shared by all threads and therefore this
function is not thread-safe. If an error occurred `getfsent'
returns a `NULL' pointer.
-- Function: struct fstab * getfsfile (const char *NAME)
Preliminary: | MT-Unsafe race:fsent locale | AS-Unsafe corrupt
heap lock | AC-Unsafe corrupt lock mem | *Note POSIX Safety
Concepts::.
This function returns the next entry of the `fstab' file which has
a string equal to NAME pointed to by the `fs_file' element. Since
there is normally exactly one entry for each mount point it makes
no sense to call this function more than once for the same
argument. If this is the first call to any of the functions
handling `fstab' since program start or the last call of
`endfsent', the file will be opened.
The function returns a pointer to a variable of type `struct
fstab'. This variable is shared by all threads and therefore this
function is not thread-safe. If an error occurred `getfsent'
returns a `NULL' pointer.

File: libc.info, Node: mtab, Next: Other Mount Information, Prev: fstab, Up: Mount Information
30.3.1.2 The `mtab' file
........................
The following functions and data structure access the `mtab' file.
-- Data Type: struct mntent
This structure is used with the `getmntent', `getmntent_t',
`addmntent', and `hasmntopt' functions.
`char *mnt_fsname'
This element contains a pointer to a string describing the
name of the special device from which the filesystem is
mounted. It corresponds to the `fs_spec' element in `struct
fstab'.
`char *mnt_dir'
This element points to a string describing the mount point of
the filesystem. It corresponds to the `fs_file' element in
`struct fstab'.
`char *mnt_type'
`mnt_type' describes the filesystem type and is therefore
equivalent to `fs_vfstype' in `struct fstab'. `mntent.h'
defines a few symbolic names for some of the values this
string can have. But since the kernel can support arbitrary
filesystems it does not make much sense to give them symbolic
names. If one knows the symbol name one also knows the
filesystem name. Nevertheless here follows the list of the
symbols provided in `mntent.h'.
`MNTTYPE_IGNORE'
This symbol expands to `"ignore"'. The value is
sometime used in `fstab' files to make sure entries are
not used without removing them.
`MNTTYPE_NFS'
Expands to `"nfs"'. Using this macro sometimes could
make sense since it names the default NFS
implementation, in case both version 2 and 3 are
supported.
`MNTTYPE_SWAP'
This symbol expands to `"swap"'. It names the special
`fstab' entry which names one of the possibly multiple
swap partitions.
`char *mnt_opts'
The element contains a string describing the options used
while mounting the filesystem. As for the equivalent element
`fs_mntops' of `struct fstab' it is best to use the function
`getsubopt' (*note Suboptions::) to access the parts of this
string.
The `mntent.h' file defines a number of macros with string
values which correspond to some of the options understood by
the kernel. There might be many more options which are
possible so it doesn't make much sense to rely on these
macros but to be consistent here is the list:
`MNTOPT_DEFAULTS'
Expands to `"defaults"'. This option should be used
alone since it indicates all values for the customizable
values are chosen to be the default.
`MNTOPT_RO'
Expands to `"ro"'. See the `FSTAB_RO' value, it means
the filesystem is mounted read-only.
`MNTOPT_RW'
Expand to `"rw"'. See the `FSTAB_RW' value, it means the
filesystem is mounted with read and write permissions.
`MNTOPT_SUID'
Expands to `"suid"'. This means that the SUID bit
(*note How Change Persona::) is respected when a program
from the filesystem is started.
`MNTOPT_NOSUID'
Expands to `"nosuid"'. This is the opposite of
`MNTOPT_SUID', the SUID bit for all files from the
filesystem is ignored.
`MNTOPT_NOAUTO'
Expands to `"noauto"'. At startup time the `mount'
program will ignore this entry if it is started with the
`-a' option to mount all filesystems mentioned in the
`fstab' file.
As for the `FSTAB_*' entries introduced above it is important
to use `strcmp' to check for equality.
`mnt_freq'
This elements corresponds to `fs_freq' and also specifies the
frequency in days in which dumps are made.
`mnt_passno'
This element is equivalent to `fs_passno' with the same
meaning which is uninteresting for all programs beside `dump'.
For accessing the `mtab' file there is again a set of three
functions to access all entries in a row. Unlike the functions to
handle `fstab' these functions do not access a fixed file and there is
even a thread safe variant of the get function. Beside this the GNU C
Library contains functions to alter the file and test for specific
options.
-- Function: FILE * setmntent (const char *FILE, const char *MODE)
Preliminary: | MT-Safe | AS-Unsafe heap lock | AC-Unsafe mem fd
lock | *Note POSIX Safety Concepts::.
The `setmntent' function prepares the file named FILE which must
be in the format of a `fstab' and `mtab' file for the upcoming
processing through the other functions of the family. The MODE
parameter can be chosen in the way the OPENTYPE parameter for
`fopen' (*note Opening Streams::) can be chosen. If the file is
opened for writing the file is also allowed to be empty.
If the file was successfully opened `setmntent' returns a file
descriptor for future use. Otherwise the return value is `NULL'
and `errno' is set accordingly.
-- Function: int endmntent (FILE *STREAM)
Preliminary: | MT-Safe | AS-Unsafe heap lock | AC-Unsafe lock mem
fd | *Note POSIX Safety Concepts::.
This function takes for the STREAM parameter a file handle which
previously was returned from the `setmntent' call. `endmntent'
closes the stream and frees all resources.
The return value is 1 unless an error occurred in which case it is
0.
-- Function: struct mntent * getmntent (FILE *STREAM)
Preliminary: | MT-Unsafe race:mntentbuf locale | AS-Unsafe corrupt
heap init | AC-Unsafe init corrupt lock mem | *Note POSIX Safety
Concepts::.
The `getmntent' function takes as the parameter a file handle
previously returned by successful call to `setmntent'. It returns
a pointer to a static variable of type `struct mntent' which is
filled with the information from the next entry from the file
currently read.
The file format used prescribes the use of spaces or tab
characters to separate the fields. This makes it harder to use
name containing one of these characters (e.g., mount points using
spaces). Therefore these characters are encoded in the files and
the `getmntent' function takes care of the decoding while reading
the entries back in. `'\040'' is used to encode a space
character, `'\011'' to encode a tab character, `'\012'' to encode
a newline character, and `'\\'' to encode a backslash.
If there was an error or the end of the file is reached the return
value is `NULL'.
This function is not thread-safe since all calls to this function
return a pointer to the same static variable. `getmntent_r'
should be used in situations where multiple threads access the
file.
-- Function: struct mntent * getmntent_r (FILE *STREAM, struct mntent
*RESULT, char *BUFFER, int BUFSIZE)
Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe
corrupt lock mem | *Note POSIX Safety Concepts::.
The `getmntent_r' function is the reentrant variant of
`getmntent'. It also returns the next entry from the file and
returns a pointer. The actual variable the values are stored in
is not static, though. Instead the function stores the values in
the variable pointed to by the RESULT parameter. Additional
information (e.g., the strings pointed to by the elements of the
result) are kept in the buffer of size BUFSIZE pointed to by
BUFFER.
Escaped characters (space, tab, backslash) are converted back in
the same way as it happens for `getmentent'.
The function returns a `NULL' pointer in error cases. Errors
could be:
* error while reading the file,
* end of file reached,
* BUFSIZE is too small for reading a complete new entry.
-- Function: int addmntent (FILE *STREAM, const struct mntent *MNT)
Preliminary: | MT-Unsafe race:stream locale | AS-Unsafe corrupt |
AC-Unsafe corrupt | *Note POSIX Safety Concepts::.
The `addmntent' function allows adding a new entry to the file
previously opened with `setmntent'. The new entries are always
appended. I.e., even if the position of the file descriptor is
not at the end of the file this function does not overwrite an
existing entry following the current position.
The implication of this is that to remove an entry from a file one
has to create a new file while leaving out the entry to be removed
and after closing the file remove the old one and rename the new
file to the chosen name.
This function takes care of spaces and tab characters in the names
to be written to the file. It converts them and the backslash
character into the format describe in the `getmntent' description
above.
This function returns 0 in case the operation was successful.
Otherwise the return value is 1 and `errno' is set appropriately.
-- Function: char * hasmntopt (const struct mntent *MNT, const char
*OPT)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
This function can be used to check whether the string pointed to
by the `mnt_opts' element of the variable pointed to by MNT
contains the option OPT. If this is true a pointer to the
beginning of the option in the `mnt_opts' element is returned. If
no such option exists the function returns `NULL'.
This function is useful to test whether a specific option is
present but when all options have to be processed one is better
off with using the `getsubopt' function to iterate over all
options in the string.

File: libc.info, Node: Other Mount Information, Prev: mtab, Up: Mount Information
30.3.1.3 Other (Non-libc) Sources of Mount Information
......................................................
On a system with a Linux kernel and the `proc' filesystem, you can get
information on currently mounted filesystems from the file `mounts' in
the `proc' filesystem. Its format is similar to that of the `mtab'
file, but represents what is truly mounted without relying on
facilities outside the kernel to keep `mtab' up to date.

File: libc.info, Node: Mount-Unmount-Remount, Prev: Mount Information, Up: Filesystem Handling
30.3.2 Mount, Unmount, Remount
------------------------------
This section describes the functions for mounting, unmounting, and
remounting filesystems.
Only the superuser can mount, unmount, or remount a filesystem.
These functions do not access the `fstab' and `mtab' files. You
should maintain and use these separately. *Note Mount Information::.
The symbols in this section are declared in `sys/mount.h'.
-- Function: int mount (const char *SPECIAL_FILE, const char *DIR,
const char *FSTYPE, unsigned long int OPTIONS, const void
*DATA)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
`mount' mounts or remounts a filesystem. The two operations are
quite different and are merged rather unnaturally into this one
function. The `MS_REMOUNT' option, explained below, determines
whether `mount' mounts or remounts.
For a mount, the filesystem on the block device represented by the
device special file named SPECIAL_FILE gets mounted over the mount
point DIR. This means that the directory DIR (along with any
files in it) is no longer visible; in its place (and still with
the name DIR) is the root directory of the filesystem on the
device.
As an exception, if the filesystem type (see below) is one which
is not based on a device (e.g. "proc"), `mount' instantiates a
filesystem and mounts it over DIR and ignores SPECIAL_FILE.
For a remount, DIR specifies the mount point where the filesystem
to be remounted is (and remains) mounted and SPECIAL_FILE is
ignored. Remounting a filesystem means changing the options that
control operations on the filesystem while it is mounted. It does
not mean unmounting and mounting again.
For a mount, you must identify the type of the filesystem as
FSTYPE. This type tells the kernel how to access the filesystem
and can be thought of as the name of a filesystem driver. The
acceptable values are system dependent. On a system with a Linux
kernel and the `proc' filesystem, the list of possible values is
in the file `filesystems' in the `proc' filesystem (e.g. type `cat
/proc/filesystems' to see the list). With a Linux kernel, the
types of filesystems that `mount' can mount, and their type names,
depends on what filesystem drivers are configured into the kernel
or loaded as loadable kernel modules. An example of a common
value for FSTYPE is `ext2'.
For a remount, `mount' ignores FSTYPE.
OPTIONS specifies a variety of options that apply until the
filesystem is unmounted or remounted. The precise meaning of an
option depends on the filesystem and with some filesystems, an
option may have no effect at all. Furthermore, for some
filesystems, some of these options (but never `MS_RDONLY') can be
overridden for individual file accesses via `ioctl'.
OPTIONS is a bit string with bit fields defined using the
following mask and masked value macros:
`MS_MGC_MASK'
This multibit field contains a magic number. If it does not
have the value `MS_MGC_VAL', `mount' assumes all the
following bits are zero and the DATA argument is a null
string, regardless of their actual values.
`MS_REMOUNT'
This bit on means to remount the filesystem. Off means to
mount it.
`MS_RDONLY'
This bit on specifies that no writing to the filesystem shall
be allowed while it is mounted. This cannot be overridden by
`ioctl'. This option is available on nearly all filesystems.
`S_IMMUTABLE'
This bit on specifies that no writing to the files in the
filesystem shall be allowed while it is mounted. This can be
overridden for a particular file access by a properly
privileged call to `ioctl'. This option is a relatively new
invention and is not available on many filesystems.
`S_APPEND'
This bit on specifies that the only file writing that shall
be allowed while the filesystem is mounted is appending.
Some filesystems allow this to be overridden for a particular
process by a properly privileged call to `ioctl'. This is a
relatively new invention and is not available on many
filesystems.
`MS_NOSUID'
This bit on specifies that Setuid and Setgid permissions on
files in the filesystem shall be ignored while it is mounted.
`MS_NOEXEC'
This bit on specifies that no files in the filesystem shall
be executed while the filesystem is mounted.
`MS_NODEV'
This bit on specifies that no device special files in the
filesystem shall be accessible while the filesystem is
mounted.
`MS_SYNCHRONOUS'
This bit on specifies that all writes to the filesystem while
it is mounted shall be synchronous; i.e., data shall be
synced before each write completes rather than held in the
buffer cache.
`MS_MANDLOCK'
This bit on specifies that mandatory locks on files shall be
permitted while the filesystem is mounted.
`MS_NOATIME'
This bit on specifies that access times of files shall not be
updated when the files are accessed while the filesystem is
mounted.
`MS_NODIRATIME'
This bit on specifies that access times of directories shall
not be updated when the directories are accessed while the
filesystem in mounted.
Any bits not covered by the above masks should be set off;
otherwise, results are undefined.
The meaning of DATA depends on the filesystem type and is
controlled entirely by the filesystem driver in the kernel.
Example:
#include <sys/mount.h>
mount("/dev/hdb", "/cdrom", MS_MGC_VAL | MS_RDONLY | MS_NOSUID, "");
mount("/dev/hda2", "/mnt", MS_MGC_VAL | MS_REMOUNT, "");
Appropriate arguments for `mount' are conventionally recorded in
the `fstab' table. *Note Mount Information::.
The return value is zero if the mount or remount is successful.
Otherwise, it is `-1' and `errno' is set appropriately. The
values of `errno' are filesystem dependent, but here is a general
list:
`EPERM'
The process is not superuser.
`ENODEV'
The file system type FSTYPE is not known to the kernel.
`ENOTBLK'
The file DEV is not a block device special file.
`EBUSY'
* The device is already mounted.
* The mount point is busy. (E.g. it is some process'
working directory or has a filesystem mounted on it
already).
* The request is to remount read-only, but there are files
open for write.
`EINVAL'
* A remount was attempted, but there is no filesystem
mounted over the specified mount point.
* The supposed filesystem has an invalid superblock.
`EACCES'
* The filesystem is inherently read-only (possibly due to
a switch on the device) and the process attempted to
mount it read/write (by setting the `MS_RDONLY' bit off).
* SPECIAL_FILE or DIR is not accessible due to file
permissions.
* SPECIAL_FILE is not accessible because it is in a
filesystem that is mounted with the `MS_NODEV' option.
`EM_FILE'
The table of dummy devices is full. `mount' needs to create a
dummy device (aka "unnamed" device) if the filesystem being
mounted is not one that uses a device.
-- Function: int umount2 (const char *FILE, int FLAGS)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
`umount2' unmounts a filesystem.
You can identify the filesystem to unmount either by the device
special file that contains the filesystem or by the mount point.
The effect is the same. Specify either as the string FILE.
FLAGS contains the one-bit field identified by the following mask
macro:
`MNT_FORCE'
This bit on means to force the unmounting even if the
filesystem is busy, by making it unbusy first. If the bit is
off and the filesystem is busy, `umount2' fails with `errno'
= `EBUSY'. Depending on the filesystem, this may override
all, some, or no busy conditions.
All other bits in FLAGS should be set to zero; otherwise, the
result is undefined.
Example:
#include <sys/mount.h>
umount2("/mnt", MNT_FORCE);
umount2("/dev/hdd1", 0);
After the filesystem is unmounted, the directory that was the
mount point is visible, as are any files in it.
As part of unmounting, `umount2' syncs the filesystem.
If the unmounting is successful, the return value is zero.
Otherwise, it is `-1' and `errno' is set accordingly:
`EPERM'
The process is not superuser.
`EBUSY'
The filesystem cannot be unmounted because it is busy. E.g.
it contains a directory that is some process's working
directory or a file that some process has open. With some
filesystems in some cases, you can avoid this failure with
the `MNT_FORCE' option.
`EINVAL'
FILE validly refers to a file, but that file is neither a
mount point nor a device special file of a currently mounted
filesystem.
This function is not available on all systems.
-- Function: int umount (const char *FILE)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
`umount' does the same thing as `umount2' with FLAGS set to
zeroes. It is more widely available than `umount2' but since it
lacks the possibility to forcefully unmount a filesystem is
deprecated when `umount2' is also available.

File: libc.info, Node: System Parameters, Prev: Filesystem Handling, Up: System Management
30.4 System Parameters
======================
This section describes the `sysctl' function, which gets and sets a
variety of system parameters.
The symbols used in this section are declared in the file
`sys/sysctl.h'.
-- Function: int sysctl (int *NAMES, int NLEN, void *OLDVAL, size_t
*OLDLENP, void *NEWVAL, size_t NEWLEN)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
`sysctl' gets or sets a specified system parameter. There are so
many of these parameters that it is not practical to list them all
here, but here are some examples:
* network domain name
* paging parameters
* network Address Resolution Protocol timeout time
* maximum number of files that may be open
* root filesystem device
* when kernel was built
The set of available parameters depends on the kernel
configuration and can change while the system is running,
particularly when you load and unload loadable kernel modules.
The system parameters with which `syslog' is concerned are arranged
in a hierarchical structure like a hierarchical filesystem. To
identify a particular parameter, you specify a path through the
structure in a way analogous to specifying the pathname of a file.
Each component of the path is specified by an integer and each of
these integers has a macro defined for it by `sys/sysctl.h'.
NAMES is the path, in the form of an array of integers. Each
component of the path is one element of the array, in order. NLEN
is the number of components in the path.
For example, the first component of the path for all the paging
parameters is the value `CTL_VM'. For the free page thresholds,
the second component of the path is `VM_FREEPG'. So to get the
free page threshold values, make NAMES an array containing the two
elements `CTL_VM' and `VM_FREEPG' and make NLEN = 2.
The format of the value of a parameter depends on the parameter.
Sometimes it is an integer; sometimes it is an ASCII string;
sometimes it is an elaborate structure. In the case of the free
page thresholds used in the example above, the parameter value is
a structure containing several integers.
In any case, you identify a place to return the parameter's value
with OLDVAL and specify the amount of storage available at that
location as *OLDLENP. *OLDLENP does double duty because it is
also the output location that contains the actual length of the
returned value.
If you don't want the parameter value returned, specify a null
pointer for OLDVAL.
To set the parameter, specify the address and length of the new
value as NEWVAL and NEWLEN. If you don't want to set the
parameter, specify a null pointer as NEWVAL.
If you get and set a parameter in the same `sysctl' call, the value
returned is the value of the parameter before it was set.
Each system parameter has a set of permissions similar to the
permissions for a file (including the permissions on directories
in its path) that determine whether you may get or set it. For
the purposes of these permissions, every parameter is considered
to be owned by the superuser and Group 0 so processes with that
effective uid or gid may have more access to system parameters.
Unlike with files, the superuser does not invariably have full
permission to all system parameters, because some of them are
designed not to be changed ever.
`sysctl' returns a zero return value if it succeeds. Otherwise, it
returns `-1' and sets `errno' appropriately. Besides the failures
that apply to all system calls, the following are the `errno'
codes for all possible failures:
`EPERM'
The process is not permitted to access one of the components
of the path of the system parameter or is not permitted to
access the system parameter itself in the way (read or write)
that it requested.
`ENOTDIR'
There is no system parameter corresponding to NAME.
`EFAULT'
OLDVAL is not null, which means the process wanted to read
the parameter, but *OLDLENP is zero, so there is no place to
return it.
`EINVAL'
* The process attempted to set a system parameter to a
value that is not valid for that parameter.
* The space provided for the return of the system
parameter is not the right size for that parameter.
`ENOMEM'
This value may be returned instead of the more correct
`EINVAL' in some cases where the space provided for the
return of the system parameter is too small.
If you have a Linux kernel with the `proc' filesystem, you can get
and set most of the same parameters by reading and writing to files in
the `sys' directory of the `proc' filesystem. In the `sys' directory,
the directory structure represents the hierarchical structure of the
parameters. E.g. you can display the free page thresholds with
cat /proc/sys/vm/freepages
Some more traditional and more widely available, though less general,
GNU C Library functions for getting and setting some of the same system
parameters are:
* `getdomainname', `setdomainname'
* `gethostname', `sethostname' (*Note Host Identification::.)
* `uname' (*Note Platform Type::.)
* `bdflush'

File: libc.info, Node: System Configuration, Next: Cryptographic Functions, Prev: System Management, Up: Top
31 System Configuration Parameters
**********************************
The functions and macros listed in this chapter give information about
configuration parameters of the operating system--for example, capacity
limits, presence of optional POSIX features, and the default path for
executable files (*note String Parameters::).
* Menu:
* General Limits:: Constants and functions that describe
various process-related limits that have
one uniform value for any given machine.
* System Options:: Optional POSIX features.
* Version Supported:: Version numbers of POSIX.1 and POSIX.2.
* Sysconf:: Getting specific configuration values
of general limits and system options.
* Minimums:: Minimum values for general limits.
* Limits for Files:: Size limitations that pertain to individual files.
These can vary between file systems
or even from file to file.
* Options for Files:: Optional features that some files may support.
* File Minimums:: Minimum values for file limits.
* Pathconf:: Getting the limit values for a particular file.
* Utility Limits:: Capacity limits of some POSIX.2 utility programs.
* Utility Minimums:: Minimum allowable values of those limits.
* String Parameters:: Getting the default search path.

File: libc.info, Node: General Limits, Next: System Options, Up: System Configuration
31.1 General Capacity Limits
============================
The POSIX.1 and POSIX.2 standards specify a number of parameters that
describe capacity limitations of the system. These limits can be fixed
constants for a given operating system, or they can vary from machine to
machine. For example, some limit values may be configurable by the
system administrator, either at run time or by rebuilding the kernel,
and this should not require recompiling application programs.
Each of the following limit parameters has a macro that is defined in
`limits.h' only if the system has a fixed, uniform limit for the
parameter in question. If the system allows different file systems or
files to have different limits, then the macro is undefined; use
`sysconf' to find out the limit that applies at a particular time on a
particular machine. *Note Sysconf::.
Each of these parameters also has another macro, with a name starting
with `_POSIX', which gives the lowest value that the limit is allowed
to have on _any_ POSIX system. *Note Minimums::.
-- Macro: int ARG_MAX
If defined, the unvarying maximum combined length of the ARGV and
ENVIRON arguments that can be passed to the `exec' functions.
-- Macro: int CHILD_MAX
If defined, the unvarying maximum number of processes that can
exist with the same real user ID at any one time. In BSD and GNU,
this is controlled by the `RLIMIT_NPROC' resource limit; *note
Limits on Resources::.
-- Macro: int OPEN_MAX
If defined, the unvarying maximum number of files that a single
process can have open simultaneously. In BSD and GNU, this is
controlled by the `RLIMIT_NOFILE' resource limit; *note Limits on
Resources::.
-- Macro: int STREAM_MAX
If defined, the unvarying maximum number of streams that a single
process can have open simultaneously. *Note Opening Streams::.
-- Macro: int TZNAME_MAX
If defined, the unvarying maximum length of a time zone name.
*Note Time Zone Functions::.
These limit macros are always defined in `limits.h'.
-- Macro: int NGROUPS_MAX
The maximum number of supplementary group IDs that one process can
have.
The value of this macro is actually a lower bound for the maximum.
That is, you can count on being able to have that many
supplementary group IDs, but a particular machine might let you
have even more. You can use `sysconf' to see whether a particular
machine will let you have more (*note Sysconf::).
-- Macro: ssize_t SSIZE_MAX
The largest value that can fit in an object of type `ssize_t'.
Effectively, this is the limit on the number of bytes that can be
read or written in a single operation.
This macro is defined in all POSIX systems because this limit is
never configurable.
-- Macro: int RE_DUP_MAX
The largest number of repetitions you are guaranteed is allowed in
the construct `\{MIN,MAX\}' in a regular expression.
The value of this macro is actually a lower bound for the maximum.
That is, you can count on being able to have that many
repetitions, but a particular machine might let you have even
more. You can use `sysconf' to see whether a particular machine
will let you have more (*note Sysconf::). And even the value that
`sysconf' tells you is just a lower bound--larger values might
work.
This macro is defined in all POSIX.2 systems, because POSIX.2 says
it should always be defined even if there is no specific imposed
limit.

File: libc.info, Node: System Options, Next: Version Supported, Prev: General Limits, Up: System Configuration
31.2 Overall System Options
===========================
POSIX defines certain system-specific options that not all POSIX systems
support. Since these options are provided in the kernel, not in the
library, simply using the GNU C Library does not guarantee any of these
features is supported; it depends on the system you are using.
You can test for the availability of a given option using the macros
in this section, together with the function `sysconf'. The macros are
defined only if you include `unistd.h'.
For the following macros, if the macro is defined in `unistd.h',
then the option is supported. Otherwise, the option may or may not be
supported; use `sysconf' to find out. *Note Sysconf::.
-- Macro: int _POSIX_JOB_CONTROL
If this symbol is defined, it indicates that the system supports
job control. Otherwise, the implementation behaves as if all
processes within a session belong to a single process group.
*Note Job Control::.
-- Macro: int _POSIX_SAVED_IDS
If this symbol is defined, it indicates that the system remembers
the effective user and group IDs of a process before it executes an
executable file with the set-user-ID or set-group-ID bits set, and
that explicitly changing the effective user or group IDs back to
these values is permitted. If this option is not defined, then if
a nonprivileged process changes its effective user or group ID to
the real user or group ID of the process, it can't change it back
again. *Note Enable/Disable Setuid::.
For the following macros, if the macro is defined in `unistd.h',
then its value indicates whether the option is supported. A value of
`-1' means no, and any other value means yes. If the macro is not
defined, then the option may or may not be supported; use `sysconf' to
find out. *Note Sysconf::.
-- Macro: int _POSIX2_C_DEV
If this symbol is defined, it indicates that the system has the
POSIX.2 C compiler command, `c89'. The GNU C Library always
defines this as `1', on the assumption that you would not have
installed it if you didn't have a C compiler.
-- Macro: int _POSIX2_FORT_DEV
If this symbol is defined, it indicates that the system has the
POSIX.2 Fortran compiler command, `fort77'. The GNU C Library
never defines this, because we don't know what the system has.
-- Macro: int _POSIX2_FORT_RUN
If this symbol is defined, it indicates that the system has the
POSIX.2 `asa' command to interpret Fortran carriage control. The
GNU C Library never defines this, because we don't know what the
system has.
-- Macro: int _POSIX2_LOCALEDEF
If this symbol is defined, it indicates that the system has the
POSIX.2 `localedef' command. The GNU C Library never defines
this, because we don't know what the system has.
-- Macro: int _POSIX2_SW_DEV
If this symbol is defined, it indicates that the system has the
POSIX.2 commands `ar', `make', and `strip'. The GNU C Library
always defines this as `1', on the assumption that you had to have
`ar' and `make' to install the library, and it's unlikely that
`strip' would be absent when those are present.

File: libc.info, Node: Version Supported, Next: Sysconf, Prev: System Options, Up: System Configuration
31.3 Which Version of POSIX is Supported
========================================
-- Macro: long int _POSIX_VERSION
This constant represents the version of the POSIX.1 standard to
which the implementation conforms. For an implementation
conforming to the 1995 POSIX.1 standard, the value is the integer
`199506L'.
`_POSIX_VERSION' is always defined (in `unistd.h') in any POSIX
system.
*Usage Note:* Don't try to test whether the system supports POSIX
by including `unistd.h' and then checking whether `_POSIX_VERSION'
is defined. On a non-POSIX system, this will probably fail
because there is no `unistd.h'. We do not know of _any_ way you
can reliably test at compilation time whether your target system
supports POSIX or whether `unistd.h' exists.
-- Macro: long int _POSIX2_C_VERSION
This constant represents the version of the POSIX.2 standard which
the library and system kernel support. We don't know what value
this will be for the first version of the POSIX.2 standard,
because the value is based on the year and month in which the
standard is officially adopted.
The value of this symbol says nothing about the utilities
installed on the system.
*Usage Note:* You can use this macro to tell whether a POSIX.1
system library supports POSIX.2 as well. Any POSIX.1 system
contains `unistd.h', so include that file and then test `defined
(_POSIX2_C_VERSION)'.

File: libc.info, Node: Sysconf, Next: Minimums, Prev: Version Supported, Up: System Configuration
31.4 Using `sysconf'
====================
When your system has configurable system limits, you can use the
`sysconf' function to find out the value that applies to any particular
machine. The function and the associated PARAMETER constants are
declared in the header file `unistd.h'.
* Menu:
* Sysconf Definition:: Detailed specifications of `sysconf'.
* Constants for Sysconf:: The list of parameters `sysconf' can read.
* Examples of Sysconf:: How to use `sysconf' and the parameter
macros properly together.

File: libc.info, Node: Sysconf Definition, Next: Constants for Sysconf, Up: Sysconf
31.4.1 Definition of `sysconf'
------------------------------
-- Function: long int sysconf (int PARAMETER)
Preliminary: | MT-Safe env | AS-Unsafe lock heap | AC-Unsafe lock
mem fd | *Note POSIX Safety Concepts::.
This function is used to inquire about runtime system parameters.
The PARAMETER argument should be one of the `_SC_' symbols listed
below.
The normal return value from `sysconf' is the value you requested.
A value of `-1' is returned both if the implementation does not
impose a limit, and in case of an error.
The following `errno' error conditions are defined for this
function:
`EINVAL'
The value of the PARAMETER is invalid.

File: libc.info, Node: Constants for Sysconf, Next: Examples of Sysconf, Prev: Sysconf Definition, Up: Sysconf
31.4.2 Constants for `sysconf' Parameters
-----------------------------------------
Here are the symbolic constants for use as the PARAMETER argument to
`sysconf'. The values are all integer constants (more specifically,
enumeration type values).
`_SC_ARG_MAX'
Inquire about the parameter corresponding to `ARG_MAX'.
`_SC_CHILD_MAX'
Inquire about the parameter corresponding to `CHILD_MAX'.
`_SC_OPEN_MAX'
Inquire about the parameter corresponding to `OPEN_MAX'.
`_SC_STREAM_MAX'
Inquire about the parameter corresponding to `STREAM_MAX'.
`_SC_TZNAME_MAX'
Inquire about the parameter corresponding to `TZNAME_MAX'.
`_SC_NGROUPS_MAX'
Inquire about the parameter corresponding to `NGROUPS_MAX'.
`_SC_JOB_CONTROL'
Inquire about the parameter corresponding to `_POSIX_JOB_CONTROL'.
`_SC_SAVED_IDS'
Inquire about the parameter corresponding to `_POSIX_SAVED_IDS'.
`_SC_VERSION'
Inquire about the parameter corresponding to `_POSIX_VERSION'.
`_SC_CLK_TCK'
Inquire about the number of clock ticks per second; *note CPU
Time::. The corresponding parameter `CLK_TCK' is obsolete.
`_SC_CHARCLASS_NAME_MAX'
Inquire about the parameter corresponding to maximal length
allowed for a character class name in an extended locale
specification. These extensions are not yet standardized and so
this option is not standardized as well.
`_SC_REALTIME_SIGNALS'
Inquire about the parameter corresponding to
`_POSIX_REALTIME_SIGNALS'.
`_SC_PRIORITY_SCHEDULING'
Inquire about the parameter corresponding to
`_POSIX_PRIORITY_SCHEDULING'.
`_SC_TIMERS'
Inquire about the parameter corresponding to `_POSIX_TIMERS'.
`_SC_ASYNCHRONOUS_IO'
Inquire about the parameter corresponding to
`_POSIX_ASYNCHRONOUS_IO'.
`_SC_PRIORITIZED_IO'
Inquire about the parameter corresponding to
`_POSIX_PRIORITIZED_IO'.
`_SC_SYNCHRONIZED_IO'
Inquire about the parameter corresponding to
`_POSIX_SYNCHRONIZED_IO'.
`_SC_FSYNC'
Inquire about the parameter corresponding to `_POSIX_FSYNC'.
`_SC_MAPPED_FILES'
Inquire about the parameter corresponding to `_POSIX_MAPPED_FILES'.
`_SC_MEMLOCK'
Inquire about the parameter corresponding to `_POSIX_MEMLOCK'.
`_SC_MEMLOCK_RANGE'
Inquire about the parameter corresponding to
`_POSIX_MEMLOCK_RANGE'.
`_SC_MEMORY_PROTECTION'
Inquire about the parameter corresponding to
`_POSIX_MEMORY_PROTECTION'.
`_SC_MESSAGE_PASSING'
Inquire about the parameter corresponding to
`_POSIX_MESSAGE_PASSING'.
`_SC_SEMAPHORES'
Inquire about the parameter corresponding to `_POSIX_SEMAPHORES'.
`_SC_SHARED_MEMORY_OBJECTS'
Inquire about the parameter corresponding to
`_POSIX_SHARED_MEMORY_OBJECTS'.
`_SC_AIO_LISTIO_MAX'
Inquire about the parameter corresponding to
`_POSIX_AIO_LISTIO_MAX'.
`_SC_AIO_MAX'
Inquire about the parameter corresponding to `_POSIX_AIO_MAX'.
`_SC_AIO_PRIO_DELTA_MAX'
Inquire the value by which a process can decrease its asynchronous
I/O priority level from its own scheduling priority. This
corresponds to the run-time invariant value `AIO_PRIO_DELTA_MAX'.
`_SC_DELAYTIMER_MAX'
Inquire about the parameter corresponding to
`_POSIX_DELAYTIMER_MAX'.
`_SC_MQ_OPEN_MAX'
Inquire about the parameter corresponding to `_POSIX_MQ_OPEN_MAX'.
`_SC_MQ_PRIO_MAX'
Inquire about the parameter corresponding to `_POSIX_MQ_PRIO_MAX'.
`_SC_RTSIG_MAX'
Inquire about the parameter corresponding to `_POSIX_RTSIG_MAX'.
`_SC_SEM_NSEMS_MAX'
Inquire about the parameter corresponding to
`_POSIX_SEM_NSEMS_MAX'.
`_SC_SEM_VALUE_MAX'
Inquire about the parameter corresponding to
`_POSIX_SEM_VALUE_MAX'.
`_SC_SIGQUEUE_MAX'
Inquire about the parameter corresponding to `_POSIX_SIGQUEUE_MAX'.
`_SC_TIMER_MAX'
Inquire about the parameter corresponding to `_POSIX_TIMER_MAX'.
`_SC_PII'
Inquire about the parameter corresponding to `_POSIX_PII'.
`_SC_PII_XTI'
Inquire about the parameter corresponding to `_POSIX_PII_XTI'.
`_SC_PII_SOCKET'
Inquire about the parameter corresponding to `_POSIX_PII_SOCKET'.
`_SC_PII_INTERNET'
Inquire about the parameter corresponding to `_POSIX_PII_INTERNET'.
`_SC_PII_OSI'
Inquire about the parameter corresponding to `_POSIX_PII_OSI'.
`_SC_SELECT'
Inquire about the parameter corresponding to `_POSIX_SELECT'.
`_SC_UIO_MAXIOV'
Inquire about the parameter corresponding to `_POSIX_UIO_MAXIOV'.
`_SC_PII_INTERNET_STREAM'
Inquire about the parameter corresponding to
`_POSIX_PII_INTERNET_STREAM'.
`_SC_PII_INTERNET_DGRAM'
Inquire about the parameter corresponding to
`_POSIX_PII_INTERNET_DGRAM'.
`_SC_PII_OSI_COTS'
Inquire about the parameter corresponding to `_POSIX_PII_OSI_COTS'.
`_SC_PII_OSI_CLTS'
Inquire about the parameter corresponding to `_POSIX_PII_OSI_CLTS'.
`_SC_PII_OSI_M'
Inquire about the parameter corresponding to `_POSIX_PII_OSI_M'.
`_SC_T_IOV_MAX'
Inquire the value of the value associated with the `T_IOV_MAX'
variable.
`_SC_THREADS'
Inquire about the parameter corresponding to `_POSIX_THREADS'.
`_SC_THREAD_SAFE_FUNCTIONS'
Inquire about the parameter corresponding to
`_POSIX_THREAD_SAFE_FUNCTIONS'.
`_SC_GETGR_R_SIZE_MAX'
Inquire about the parameter corresponding to
`_POSIX_GETGR_R_SIZE_MAX'.
`_SC_GETPW_R_SIZE_MAX'
Inquire about the parameter corresponding to
`_POSIX_GETPW_R_SIZE_MAX'.
`_SC_LOGIN_NAME_MAX'
Inquire about the parameter corresponding to
`_POSIX_LOGIN_NAME_MAX'.
`_SC_TTY_NAME_MAX'
Inquire about the parameter corresponding to `_POSIX_TTY_NAME_MAX'.
`_SC_THREAD_DESTRUCTOR_ITERATIONS'
Inquire about the parameter corresponding to
`_POSIX_THREAD_DESTRUCTOR_ITERATIONS'.
`_SC_THREAD_KEYS_MAX'
Inquire about the parameter corresponding to
`_POSIX_THREAD_KEYS_MAX'.
`_SC_THREAD_STACK_MIN'
Inquire about the parameter corresponding to
`_POSIX_THREAD_STACK_MIN'.
`_SC_THREAD_THREADS_MAX'
Inquire about the parameter corresponding to
`_POSIX_THREAD_THREADS_MAX'.
`_SC_THREAD_ATTR_STACKADDR'
Inquire about the parameter corresponding to
a `_POSIX_THREAD_ATTR_STACKADDR'.
`_SC_THREAD_ATTR_STACKSIZE'
Inquire about the parameter corresponding to
`_POSIX_THREAD_ATTR_STACKSIZE'.
`_SC_THREAD_PRIORITY_SCHEDULING'
Inquire about the parameter corresponding to
`_POSIX_THREAD_PRIORITY_SCHEDULING'.
`_SC_THREAD_PRIO_INHERIT'
Inquire about the parameter corresponding to
`_POSIX_THREAD_PRIO_INHERIT'.
`_SC_THREAD_PRIO_PROTECT'
Inquire about the parameter corresponding to
`_POSIX_THREAD_PRIO_PROTECT'.
`_SC_THREAD_PROCESS_SHARED'
Inquire about the parameter corresponding to
`_POSIX_THREAD_PROCESS_SHARED'.
`_SC_2_C_DEV'
Inquire about whether the system has the POSIX.2 C compiler
command, `c89'.
`_SC_2_FORT_DEV'
Inquire about whether the system has the POSIX.2 Fortran compiler
command, `fort77'.
`_SC_2_FORT_RUN'
Inquire about whether the system has the POSIX.2 `asa' command to
interpret Fortran carriage control.
`_SC_2_LOCALEDEF'
Inquire about whether the system has the POSIX.2 `localedef'
command.
`_SC_2_SW_DEV'
Inquire about whether the system has the POSIX.2 commands `ar',
`make', and `strip'.
`_SC_BC_BASE_MAX'
Inquire about the maximum value of `obase' in the `bc' utility.
`_SC_BC_DIM_MAX'
Inquire about the maximum size of an array in the `bc' utility.
`_SC_BC_SCALE_MAX'
Inquire about the maximum value of `scale' in the `bc' utility.
`_SC_BC_STRING_MAX'
Inquire about the maximum size of a string constant in the `bc'
utility.
`_SC_COLL_WEIGHTS_MAX'
Inquire about the maximum number of weights that can necessarily
be used in defining the collating sequence for a locale.
`_SC_EXPR_NEST_MAX'
Inquire about the maximum number of expressions nested within
parentheses when using the `expr' utility.
`_SC_LINE_MAX'
Inquire about the maximum size of a text line that the POSIX.2 text
utilities can handle.
`_SC_EQUIV_CLASS_MAX'
Inquire about the maximum number of weights that can be assigned
to an entry of the `LC_COLLATE' category `order' keyword in a
locale definition. The GNU C Library does not presently support
locale definitions.
`_SC_VERSION'
Inquire about the version number of POSIX.1 that the library and
kernel support.
`_SC_2_VERSION'
Inquire about the version number of POSIX.2 that the system
utilities support.
`_SC_PAGESIZE'
Inquire about the virtual memory page size of the machine.
`getpagesize' returns the same value (*note Query Memory
Parameters::).
`_SC_NPROCESSORS_CONF'
Inquire about the number of configured processors.
`_SC_NPROCESSORS_ONLN'
Inquire about the number of processors online.
`_SC_PHYS_PAGES'
Inquire about the number of physical pages in the system.
`_SC_AVPHYS_PAGES'
Inquire about the number of available physical pages in the system.
`_SC_ATEXIT_MAX'
Inquire about the number of functions which can be registered as
termination functions for `atexit'; *note Cleanups on Exit::.
`_SC_XOPEN_VERSION'
Inquire about the parameter corresponding to `_XOPEN_VERSION'.
`_SC_XOPEN_XCU_VERSION'
Inquire about the parameter corresponding to `_XOPEN_XCU_VERSION'.
`_SC_XOPEN_UNIX'
Inquire about the parameter corresponding to `_XOPEN_UNIX'.
`_SC_XOPEN_REALTIME'
Inquire about the parameter corresponding to `_XOPEN_REALTIME'.
`_SC_XOPEN_REALTIME_THREADS'
Inquire about the parameter corresponding to
`_XOPEN_REALTIME_THREADS'.
`_SC_XOPEN_LEGACY'
Inquire about the parameter corresponding to `_XOPEN_LEGACY'.
`_SC_XOPEN_CRYPT'
Inquire about the parameter corresponding to `_XOPEN_CRYPT'.
`_SC_XOPEN_ENH_I18N'
Inquire about the parameter corresponding to `_XOPEN_ENH_I18N'.
`_SC_XOPEN_SHM'
Inquire about the parameter corresponding to `_XOPEN_SHM'.
`_SC_XOPEN_XPG2'
Inquire about the parameter corresponding to `_XOPEN_XPG2'.
`_SC_XOPEN_XPG3'
Inquire about the parameter corresponding to `_XOPEN_XPG3'.
`_SC_XOPEN_XPG4'
Inquire about the parameter corresponding to `_XOPEN_XPG4'.
`_SC_CHAR_BIT'
Inquire about the number of bits in a variable of type `char'.
`_SC_CHAR_MAX'
Inquire about the maximum value which can be stored in a variable
of type `char'.
`_SC_CHAR_MIN'
Inquire about the minimum value which can be stored in a variable
of type `char'.
`_SC_INT_MAX'
Inquire about the maximum value which can be stored in a variable
of type `int'.
`_SC_INT_MIN'
Inquire about the minimum value which can be stored in a variable
of type `int'.
`_SC_LONG_BIT'
Inquire about the number of bits in a variable of type `long int'.
`_SC_WORD_BIT'
Inquire about the number of bits in a variable of a register word.
`_SC_MB_LEN_MAX'
Inquire the maximum length of a multi-byte representation of a wide
character value.
`_SC_NZERO'
Inquire about the value used to internally represent the zero
priority level for the process execution.
`SC_SSIZE_MAX'
Inquire about the maximum value which can be stored in a variable
of type `ssize_t'.
`_SC_SCHAR_MAX'
Inquire about the maximum value which can be stored in a variable
of type `signed char'.
`_SC_SCHAR_MIN'
Inquire about the minimum value which can be stored in a variable
of type `signed char'.
`_SC_SHRT_MAX'
Inquire about the maximum value which can be stored in a variable
of type `short int'.
`_SC_SHRT_MIN'
Inquire about the minimum value which can be stored in a variable
of type `short int'.
`_SC_UCHAR_MAX'
Inquire about the maximum value which can be stored in a variable
of type `unsigned char'.
`_SC_UINT_MAX'
Inquire about the maximum value which can be stored in a variable
of type `unsigned int'.
`_SC_ULONG_MAX'
Inquire about the maximum value which can be stored in a variable
of type `unsigned long int'.
`_SC_USHRT_MAX'
Inquire about the maximum value which can be stored in a variable
of type `unsigned short int'.
`_SC_NL_ARGMAX'
Inquire about the parameter corresponding to `NL_ARGMAX'.
`_SC_NL_LANGMAX'
Inquire about the parameter corresponding to `NL_LANGMAX'.
`_SC_NL_MSGMAX'
Inquire about the parameter corresponding to `NL_MSGMAX'.
`_SC_NL_NMAX'
Inquire about the parameter corresponding to `NL_NMAX'.
`_SC_NL_SETMAX'
Inquire about the parameter corresponding to `NL_SETMAX'.
`_SC_NL_TEXTMAX'
Inquire about the parameter corresponding to `NL_TEXTMAX'.

File: libc.info, Node: Examples of Sysconf, Prev: Constants for Sysconf, Up: Sysconf
31.4.3 Examples of `sysconf'
----------------------------
We recommend that you first test for a macro definition for the
parameter you are interested in, and call `sysconf' only if the macro
is not defined. For example, here is how to test whether job control
is supported:
int
have_job_control (void)
{
#ifdef _POSIX_JOB_CONTROL
return 1;
#else
int value = sysconf (_SC_JOB_CONTROL);
if (value < 0)
/* If the system is that badly wedged,
there's no use trying to go on. */
fatal (strerror (errno));
return value;
#endif
}
Here is how to get the value of a numeric limit:
int
get_child_max ()
{
#ifdef CHILD_MAX
return CHILD_MAX;
#else
int value = sysconf (_SC_CHILD_MAX);
if (value < 0)
fatal (strerror (errno));
return value;
#endif
}

File: libc.info, Node: Minimums, Next: Limits for Files, Prev: Sysconf, Up: System Configuration
31.5 Minimum Values for General Capacity Limits
===============================================
Here are the names for the POSIX minimum upper bounds for the system
limit parameters. The significance of these values is that you can
safely push to these limits without checking whether the particular
system you are using can go that far.
`_POSIX_AIO_LISTIO_MAX'
The most restrictive limit permitted by POSIX for the maximum
number of I/O operations that can be specified in a list I/O call.
The value of this constant is `2'; thus you can add up to two new
entries of the list of outstanding operations.
`_POSIX_AIO_MAX'
The most restrictive limit permitted by POSIX for the maximum
number of outstanding asynchronous I/O operations. The value of
this constant is `1'. So you cannot expect that you can issue
more than one operation and immediately continue with the normal
work, receiving the notifications asynchronously.
`_POSIX_ARG_MAX'
The value of this macro is the most restrictive limit permitted by
POSIX for the maximum combined length of the ARGV and ENVIRON
arguments that can be passed to the `exec' functions. Its value
is `4096'.
`_POSIX_CHILD_MAX'
The value of this macro is the most restrictive limit permitted by
POSIX for the maximum number of simultaneous processes per real
user ID. Its value is `6'.
`_POSIX_NGROUPS_MAX'
The value of this macro is the most restrictive limit permitted by
POSIX for the maximum number of supplementary group IDs per
process. Its value is `0'.
`_POSIX_OPEN_MAX'
The value of this macro is the most restrictive limit permitted by
POSIX for the maximum number of files that a single process can
have open simultaneously. Its value is `16'.
`_POSIX_SSIZE_MAX'
The value of this macro is the most restrictive limit permitted by
POSIX for the maximum value that can be stored in an object of type
`ssize_t'. Its value is `32767'.
`_POSIX_STREAM_MAX'
The value of this macro is the most restrictive limit permitted by
POSIX for the maximum number of streams that a single process can
have open simultaneously. Its value is `8'.
`_POSIX_TZNAME_MAX'
The value of this macro is the most restrictive limit permitted by
POSIX for the maximum length of a time zone name. Its value is
`3'.
`_POSIX2_RE_DUP_MAX'
The value of this macro is the most restrictive limit permitted by
POSIX for the numbers used in the `\{MIN,MAX\}' construct in a
regular expression. Its value is `255'.

File: libc.info, Node: Limits for Files, Next: Options for Files, Prev: Minimums, Up: System Configuration
31.6 Limits on File System Capacity
===================================
The POSIX.1 standard specifies a number of parameters that describe the
limitations of the file system. It's possible for the system to have a
fixed, uniform limit for a parameter, but this isn't the usual case. On
most systems, it's possible for different file systems (and, for some
parameters, even different files) to have different maximum limits. For
example, this is very likely if you use NFS to mount some of the file
systems from other machines.
Each of the following macros is defined in `limits.h' only if the
system has a fixed, uniform limit for the parameter in question. If the
system allows different file systems or files to have different limits,
then the macro is undefined; use `pathconf' or `fpathconf' to find out
the limit that applies to a particular file. *Note Pathconf::.
Each parameter also has another macro, with a name starting with
`_POSIX', which gives the lowest value that the limit is allowed to
have on _any_ POSIX system. *Note File Minimums::.
-- Macro: int LINK_MAX
The uniform system limit (if any) for the number of names for a
given file. *Note Hard Links::.
-- Macro: int MAX_CANON
The uniform system limit (if any) for the amount of text in a line
of input when input editing is enabled. *Note Canonical or Not::.
-- Macro: int MAX_INPUT
The uniform system limit (if any) for the total number of
characters typed ahead as input. *Note I/O Queues::.
-- Macro: int NAME_MAX
The uniform system limit (if any) for the length of a file name
component, not including the terminating null character.
*Portability Note:* On some systems, the GNU C Library defines
`NAME_MAX', but does not actually enforce this limit.
-- Macro: int PATH_MAX
The uniform system limit (if any) for the length of an entire file
name (that is, the argument given to system calls such as `open'),
including the terminating null character.
*Portability Note:* The GNU C Library does not enforce this limit
even if `PATH_MAX' is defined.
-- Macro: int PIPE_BUF
The uniform system limit (if any) for the number of bytes that can
be written atomically to a pipe. If multiple processes are
writing to the same pipe simultaneously, output from different
processes might be interleaved in chunks of this size. *Note
Pipes and FIFOs::.
These are alternative macro names for some of the same information.
-- Macro: int MAXNAMLEN
This is the BSD name for `NAME_MAX'. It is defined in `dirent.h'.
-- Macro: int FILENAME_MAX
The value of this macro is an integer constant expression that
represents the maximum length of a file name string. It is
defined in `stdio.h'.
Unlike `PATH_MAX', this macro is defined even if there is no actual
limit imposed. In such a case, its value is typically a very large
number. *This is always the case on GNU/Hurd systems.*
*Usage Note:* Don't use `FILENAME_MAX' as the size of an array in
which to store a file name! You can't possibly make an array that
big! Use dynamic allocation (*note Memory Allocation::) instead.

File: libc.info, Node: Options for Files, Next: File Minimums, Prev: Limits for Files, Up: System Configuration
31.7 Optional Features in File Support
======================================
POSIX defines certain system-specific options in the system calls for
operating on files. Some systems support these options and others do
not. Since these options are provided in the kernel, not in the
library, simply using the GNU C Library does not guarantee that any of
these features is supported; it depends on the system you are using.
They can also vary between file systems on a single machine.
This section describes the macros you can test to determine whether a
particular option is supported on your machine. If a given macro is
defined in `unistd.h', then its value says whether the corresponding
feature is supported. (A value of `-1' indicates no; any other value
indicates yes.) If the macro is undefined, it means particular files
may or may not support the feature.
Since all the machines that support the GNU C Library also support
NFS, one can never make a general statement about whether all file
systems support the `_POSIX_CHOWN_RESTRICTED' and `_POSIX_NO_TRUNC'
features. So these names are never defined as macros in the GNU C
Library.
-- Macro: int _POSIX_CHOWN_RESTRICTED
If this option is in effect, the `chown' function is restricted so
that the only changes permitted to nonprivileged processes is to
change the group owner of a file to either be the effective group
ID of the process, or one of its supplementary group IDs. *Note
File Owner::.
-- Macro: int _POSIX_NO_TRUNC
If this option is in effect, file name components longer than
`NAME_MAX' generate an `ENAMETOOLONG' error. Otherwise, file name
components that are too long are silently truncated.
-- Macro: unsigned char _POSIX_VDISABLE
This option is only meaningful for files that are terminal devices.
If it is enabled, then handling for special control characters can
be disabled individually. *Note Special Characters::.
If one of these macros is undefined, that means that the option
might be in effect for some files and not for others. To inquire about
a particular file, call `pathconf' or `fpathconf'. *Note Pathconf::.

File: libc.info, Node: File Minimums, Next: Pathconf, Prev: Options for Files, Up: System Configuration
31.8 Minimum Values for File System Limits
==========================================
Here are the names for the POSIX minimum upper bounds for some of the
above parameters. The significance of these values is that you can
safely push to these limits without checking whether the particular
system you are using can go that far. In most cases GNU systems do not
have these strict limitations. The actual limit should be requested if
necessary.
`_POSIX_LINK_MAX'
The most restrictive limit permitted by POSIX for the maximum
value of a file's link count. The value of this constant is `8';
thus, you can always make up to eight names for a file without
running into a system limit.
`_POSIX_MAX_CANON'
The most restrictive limit permitted by POSIX for the maximum
number of bytes in a canonical input line from a terminal device.
The value of this constant is `255'.
`_POSIX_MAX_INPUT'
The most restrictive limit permitted by POSIX for the maximum
number of bytes in a terminal device input queue (or typeahead
buffer). *Note Input Modes::. The value of this constant is
`255'.
`_POSIX_NAME_MAX'
The most restrictive limit permitted by POSIX for the maximum
number of bytes in a file name component. The value of this
constant is `14'.
`_POSIX_PATH_MAX'
The most restrictive limit permitted by POSIX for the maximum
number of bytes in a file name. The value of this constant is
`256'.
`_POSIX_PIPE_BUF'
The most restrictive limit permitted by POSIX for the maximum
number of bytes that can be written atomically to a pipe. The
value of this constant is `512'.
`SYMLINK_MAX'
Maximum number of bytes in a symbolic link.
`POSIX_REC_INCR_XFER_SIZE'
Recommended increment for file transfer sizes between the
`POSIX_REC_MIN_XFER_SIZE' and `POSIX_REC_MAX_XFER_SIZE' values.
`POSIX_REC_MAX_XFER_SIZE'
Maximum recommended file transfer size.
`POSIX_REC_MIN_XFER_SIZE'
Minimum recommended file transfer size.
`POSIX_REC_XFER_ALIGN'
Recommended file transfer buffer alignment.

File: libc.info, Node: Pathconf, Next: Utility Limits, Prev: File Minimums, Up: System Configuration
31.9 Using `pathconf'
=====================
When your machine allows different files to have different values for a
file system parameter, you can use the functions in this section to find
out the value that applies to any particular file.
These functions and the associated constants for the PARAMETER
argument are declared in the header file `unistd.h'.
-- Function: long int pathconf (const char *FILENAME, int PARAMETER)
Preliminary: | MT-Safe | AS-Unsafe lock heap | AC-Unsafe lock fd
mem | *Note POSIX Safety Concepts::.
This function is used to inquire about the limits that apply to
the file named FILENAME.
The PARAMETER argument should be one of the `_PC_' constants
listed below.
The normal return value from `pathconf' is the value you requested.
A value of `-1' is returned both if the implementation does not
impose a limit, and in case of an error. In the former case,
`errno' is not set, while in the latter case, `errno' is set to
indicate the cause of the problem. So the only way to use this
function robustly is to store `0' into `errno' just before calling
it.
Besides the usual file name errors (*note File Name Errors::), the
following error condition is defined for this function:
`EINVAL'
The value of PARAMETER is invalid, or the implementation
doesn't support the PARAMETER for the specific file.
-- Function: long int fpathconf (int FILEDES, int PARAMETER)
Preliminary: | MT-Safe | AS-Unsafe lock heap | AC-Unsafe lock fd
mem | *Note POSIX Safety Concepts::.
This is just like `pathconf' except that an open file descriptor
is used to specify the file for which information is requested,
instead of a file name.
The following `errno' error conditions are defined for this
function:
`EBADF'
The FILEDES argument is not a valid file descriptor.
`EINVAL'
The value of PARAMETER is invalid, or the implementation
doesn't support the PARAMETER for the specific file.
Here are the symbolic constants that you can use as the PARAMETER
argument to `pathconf' and `fpathconf'. The values are all integer
constants.
`_PC_LINK_MAX'
Inquire about the value of `LINK_MAX'.
`_PC_MAX_CANON'
Inquire about the value of `MAX_CANON'.
`_PC_MAX_INPUT'
Inquire about the value of `MAX_INPUT'.
`_PC_NAME_MAX'
Inquire about the value of `NAME_MAX'.
`_PC_PATH_MAX'
Inquire about the value of `PATH_MAX'.
`_PC_PIPE_BUF'
Inquire about the value of `PIPE_BUF'.
`_PC_CHOWN_RESTRICTED'
Inquire about the value of `_POSIX_CHOWN_RESTRICTED'.
`_PC_NO_TRUNC'
Inquire about the value of `_POSIX_NO_TRUNC'.
`_PC_VDISABLE'
Inquire about the value of `_POSIX_VDISABLE'.
`_PC_SYNC_IO'
Inquire about the value of `_POSIX_SYNC_IO'.
`_PC_ASYNC_IO'
Inquire about the value of `_POSIX_ASYNC_IO'.
`_PC_PRIO_IO'
Inquire about the value of `_POSIX_PRIO_IO'.
`_PC_FILESIZEBITS'
Inquire about the availability of large files on the filesystem.
`_PC_REC_INCR_XFER_SIZE'
Inquire about the value of `POSIX_REC_INCR_XFER_SIZE'.
`_PC_REC_MAX_XFER_SIZE'
Inquire about the value of `POSIX_REC_MAX_XFER_SIZE'.
`_PC_REC_MIN_XFER_SIZE'
Inquire about the value of `POSIX_REC_MIN_XFER_SIZE'.
`_PC_REC_XFER_ALIGN'
Inquire about the value of `POSIX_REC_XFER_ALIGN'.
*Portability Note:* On some systems, the GNU C Library does not
enforce `_PC_NAME_MAX' or `_PC_PATH_MAX' limits.

File: libc.info, Node: Utility Limits, Next: Utility Minimums, Prev: Pathconf, Up: System Configuration
31.10 Utility Program Capacity Limits
=====================================
The POSIX.2 standard specifies certain system limits that you can access
through `sysconf' that apply to utility behavior rather than the
behavior of the library or the operating system.
The GNU C Library defines macros for these limits, and `sysconf'
returns values for them if you ask; but these values convey no
meaningful information. They are simply the smallest values that
POSIX.2 permits.
-- Macro: int BC_BASE_MAX
The largest value of `obase' that the `bc' utility is guaranteed
to support.
-- Macro: int BC_DIM_MAX
The largest number of elements in one array that the `bc' utility
is guaranteed to support.
-- Macro: int BC_SCALE_MAX
The largest value of `scale' that the `bc' utility is guaranteed
to support.
-- Macro: int BC_STRING_MAX
The largest number of characters in one string constant that the
`bc' utility is guaranteed to support.
-- Macro: int COLL_WEIGHTS_MAX
The largest number of weights that can necessarily be used in
defining the collating sequence for a locale.
-- Macro: int EXPR_NEST_MAX
The maximum number of expressions that can be nested within
parenthesis by the `expr' utility.
-- Macro: int LINE_MAX
The largest text line that the text-oriented POSIX.2 utilities can
support. (If you are using the GNU versions of these utilities,
then there is no actual limit except that imposed by the available
virtual memory, but there is no way that the library can tell you
this.)
-- Macro: int EQUIV_CLASS_MAX
The maximum number of weights that can be assigned to an entry of
the `LC_COLLATE' category `order' keyword in a locale definition.
The GNU C Library does not presently support locale definitions.

File: libc.info, Node: Utility Minimums, Next: String Parameters, Prev: Utility Limits, Up: System Configuration
31.11 Minimum Values for Utility Limits
=======================================
`_POSIX2_BC_BASE_MAX'
The most restrictive limit permitted by POSIX.2 for the maximum
value of `obase' in the `bc' utility. Its value is `99'.
`_POSIX2_BC_DIM_MAX'
The most restrictive limit permitted by POSIX.2 for the maximum
size of an array in the `bc' utility. Its value is `2048'.
`_POSIX2_BC_SCALE_MAX'
The most restrictive limit permitted by POSIX.2 for the maximum
value of `scale' in the `bc' utility. Its value is `99'.
`_POSIX2_BC_STRING_MAX'
The most restrictive limit permitted by POSIX.2 for the maximum
size of a string constant in the `bc' utility. Its value is
`1000'.
`_POSIX2_COLL_WEIGHTS_MAX'
The most restrictive limit permitted by POSIX.2 for the maximum
number of weights that can necessarily be used in defining the
collating sequence for a locale. Its value is `2'.
`_POSIX2_EXPR_NEST_MAX'
The most restrictive limit permitted by POSIX.2 for the maximum
number of expressions nested within parenthesis when using the
`expr' utility. Its value is `32'.
`_POSIX2_LINE_MAX'
The most restrictive limit permitted by POSIX.2 for the maximum
size of a text line that the text utilities can handle. Its value
is `2048'.
`_POSIX2_EQUIV_CLASS_MAX'
The most restrictive limit permitted by POSIX.2 for the maximum
number of weights that can be assigned to an entry of the
`LC_COLLATE' category `order' keyword in a locale definition. Its
value is `2'. The GNU C Library does not presently support locale
definitions.

File: libc.info, Node: String Parameters, Prev: Utility Minimums, Up: System Configuration
31.12 String-Valued Parameters
==============================
POSIX.2 defines a way to get string-valued parameters from the operating
system with the function `confstr':
-- Function: size_t confstr (int PARAMETER, char *BUF, size_t LEN)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
This function reads the value of a string-valued system parameter,
storing the string into LEN bytes of memory space starting at BUF.
The PARAMETER argument should be one of the `_CS_' symbols listed
below.
The normal return value from `confstr' is the length of the string
value that you asked for. If you supply a null pointer for BUF,
then `confstr' does not try to store the string; it just returns
its length. A value of `0' indicates an error.
If the string you asked for is too long for the buffer (that is,
longer than `LEN - 1'), then `confstr' stores just that much
(leaving room for the terminating null character). You can tell
that this has happened because `confstr' returns a value greater
than or equal to LEN.
The following `errno' error conditions are defined for this
function:
`EINVAL'
The value of the PARAMETER is invalid.
Currently there is just one parameter you can read with `confstr':
`_CS_PATH'
This parameter's value is the recommended default path for
searching for executable files. This is the path that a user has
by default just after logging in.
`_CS_LFS_CFLAGS'
The returned string specifies which additional flags must be given
to the C compiler if a source is compiled using the
`_LARGEFILE_SOURCE' feature select macro; *note Feature Test
Macros::.
`_CS_LFS_LDFLAGS'
The returned string specifies which additional flags must be given
to the linker if a source is compiled using the
`_LARGEFILE_SOURCE' feature select macro; *note Feature Test
Macros::.
`_CS_LFS_LIBS'
The returned string specifies which additional libraries must be
linked to the application if a source is compiled using the
`_LARGEFILE_SOURCE' feature select macro; *note Feature Test
Macros::.
`_CS_LFS_LINTFLAGS'
The returned string specifies which additional flags must be given
to the lint tool if a source is compiled using the
`_LARGEFILE_SOURCE' feature select macro; *note Feature Test
Macros::.
`_CS_LFS64_CFLAGS'
The returned string specifies which additional flags must be given
to the C compiler if a source is compiled using the
`_LARGEFILE64_SOURCE' feature select macro; *note Feature Test
Macros::.
`_CS_LFS64_LDFLAGS'
The returned string specifies which additional flags must be given
to the linker if a source is compiled using the
`_LARGEFILE64_SOURCE' feature select macro; *note Feature Test
Macros::.
`_CS_LFS64_LIBS'
The returned string specifies which additional libraries must be
linked to the application if a source is compiled using the
`_LARGEFILE64_SOURCE' feature select macro; *note Feature Test
Macros::.
`_CS_LFS64_LINTFLAGS'
The returned string specifies which additional flags must be given
to the lint tool if a source is compiled using the
`_LARGEFILE64_SOURCE' feature select macro; *note Feature Test
Macros::.
The way to use `confstr' without any arbitrary limit on string size
is to call it twice: first call it to get the length, allocate the
buffer accordingly, and then call `confstr' again to fill the buffer,
like this:
char *
get_default_path (void)
{
size_t len = confstr (_CS_PATH, NULL, 0);
char *buffer = (char *) xmalloc (len);
if (confstr (_CS_PATH, buf, len + 1) == 0)
{
free (buffer);
return NULL;
}
return buffer;
}

File: libc.info, Node: Cryptographic Functions, Next: Debugging Support, Prev: System Configuration, Up: Top
32 DES Encryption and Password Handling
***************************************
On many systems, it is unnecessary to have any kind of user
authentication; for instance, a workstation which is not connected to a
network probably does not need any user authentication, because to use
the machine an intruder must have physical access.
Sometimes, however, it is necessary to be sure that a user is
authorized to use some service a machine provides--for instance, to log
in as a particular user id (*note Users and Groups::). One traditional
way of doing this is for each user to choose a secret "password"; then,
the system can ask someone claiming to be a user what the user's
password is, and if the person gives the correct password then the
system can grant the appropriate privileges.
If all the passwords are just stored in a file somewhere, then this
file has to be very carefully protected. To avoid this, passwords are
run through a "one-way function", a function which makes it difficult to
work out what its input was by looking at its output, before storing in
the file.
The GNU C Library provides a one-way function that is compatible with
the behavior of the `crypt' function introduced in FreeBSD 2.0. It
supports two one-way algorithms: one based on the MD5 message-digest
algorithm that is compatible with modern BSD systems, and the other
based on the Data Encryption Standard (DES) that is compatible with
Unix systems.
It also provides support for Secure RPC, and some library functions
that can be used to perform normal DES encryption. The `AUTH_DES'
authentication flavor in Secure RPC, as provided by the GNU C Library,
uses DES and does not comply with FIPS 140-2 nor does any other use of
DES within the GNU C Library. It is recommended that Secure RPC should
not be used for systems that need to comply with FIPS 140-2 since all
flavors of encrypted authentication use normal DES.
* Menu:
* Legal Problems:: This software can get you locked up, or worse.
* getpass:: Prompting the user for a password.
* crypt:: A one-way function for passwords.
* DES Encryption:: Routines for DES encryption.

File: libc.info, Node: Legal Problems, Next: getpass, Up: Cryptographic Functions
32.1 Legal Problems
===================
Because of the continuously changing state of the law, it's not possible
to provide a definitive survey of the laws affecting cryptography.
Instead, this section warns you of some of the known trouble spots; this
may help you when you try to find out what the laws of your country are.
Some countries require that you have a licence to use, possess, or
import cryptography. These countries are believed to include
Byelorussia, Burma, India, Indonesia, Israel, Kazakhstan, Pakistan,
Russia, and Saudi Arabia.
Some countries restrict the transmission of encrypted messages by
radio; some telecommunications carriers restrict the transmission of
encrypted messages over their network.
Many countries have some form of export control for encryption
software. The Wassenaar Arrangement is a multilateral agreement
between 33 countries (Argentina, Australia, Austria, Belgium, Bulgaria,
Canada, the Czech Republic, Denmark, Finland, France, Germany, Greece,
Hungary, Ireland, Italy, Japan, Luxembourg, the Netherlands, New
Zealand, Norway, Poland, Portugal, the Republic of Korea, Romania, the
Russian Federation, the Slovak Republic, Spain, Sweden, Switzerland,
Turkey, Ukraine, the United Kingdom and the United States) which
restricts some kinds of encryption exports. Different countries apply
the arrangement in different ways; some do not allow the exception for
certain kinds of "public domain" software (which would include this
library), some only restrict the export of software in tangible form,
and others impose significant additional restrictions.
The United States has additional rules. This software would
generally be exportable under 15 CFR 740.13(e), which permits exports of
"encryption source code" which is "publicly available" and which is
"not subject to an express agreement for the payment of a licensing fee
or royalty for commercial production or sale of any product developed
with the source code" to most countries.
The rules in this area are continuously changing. If you know of any
information in this manual that is out-of-date, please report it to the
bug database. *Note Reporting Bugs::.

File: libc.info, Node: getpass, Next: crypt, Prev: Legal Problems, Up: Cryptographic Functions
32.2 Reading Passwords
======================
When reading in a password, it is desirable to avoid displaying it on
the screen, to help keep it secret. The following function handles this
in a convenient way.
-- Function: char * getpass (const char *PROMPT)
Preliminary: | MT-Unsafe term | AS-Unsafe heap lock corrupt |
AC-Unsafe term lock corrupt | *Note POSIX Safety Concepts::.
`getpass' outputs PROMPT, then reads a string in from the terminal
without echoing it. It tries to connect to the real terminal,
`/dev/tty', if possible, to encourage users not to put plaintext
passwords in files; otherwise, it uses `stdin' and `stderr'.
`getpass' also disables the INTR, QUIT, and SUSP characters on the
terminal using the `ISIG' terminal attribute (*note Local Modes::).
The terminal is flushed before and after `getpass', so that
characters of a mistyped password are not accidentally visible.
In other C libraries, `getpass' may only return the first
`PASS_MAX' bytes of a password. The GNU C Library has no limit, so
`PASS_MAX' is undefined.
The prototype for this function is in `unistd.h'. `PASS_MAX'
would be defined in `limits.h'.
This precise set of operations may not suit all possible situations.
In this case, it is recommended that users write their own `getpass'
substitute. For instance, a very simple substitute is as follows:
#include <termios.h>
#include <stdio.h>
ssize_t
my_getpass (char **lineptr, size_t *n, FILE *stream)
{
struct termios old, new;
int nread;
/* Turn echoing off and fail if we can't. */
if (tcgetattr (fileno (stream), &old) != 0)
return -1;
new = old;
new.c_lflag &= ~ECHO;
if (tcsetattr (fileno (stream), TCSAFLUSH, &new) != 0)
return -1;
/* Read the password. */
nread = getline (lineptr, n, stream);
/* Restore terminal. */
(void) tcsetattr (fileno (stream), TCSAFLUSH, &old);
return nread;
}
The substitute takes the same parameters as `getline' (*note Line
Input::); the user must print any prompt desired.

File: libc.info, Node: crypt, Next: DES Encryption, Prev: getpass, Up: Cryptographic Functions
32.3 Encrypting Passwords
=========================
-- Function: char * crypt (const char *KEY, const char *SALT)
Preliminary: | MT-Unsafe race:crypt | AS-Unsafe corrupt lock heap
dlopen | AC-Unsafe lock mem | *Note POSIX Safety Concepts::.
The `crypt' function takes a password, KEY, as a string, and a
SALT character array which is described below, and returns a
printable ASCII string which starts with another salt. It is
believed that, given the output of the function, the best way to
find a KEY that will produce that output is to guess values of KEY
until the original value of KEY is found.
The SALT parameter does two things. Firstly, it selects which
algorithm is used, the MD5-based one or the DES-based one.
Secondly, it makes life harder for someone trying to guess
passwords against a file containing many passwords; without a
SALT, an intruder can make a guess, run `crypt' on it once, and
compare the result with all the passwords. With a SALT, the
intruder must run `crypt' once for each different salt.
For the MD5-based algorithm, the SALT should consist of the string
`$1$', followed by up to 8 characters, terminated by either
another `$' or the end of the string. The result of `crypt' will
be the SALT, followed by a `$' if the salt didn't end with one,
followed by 22 characters from the alphabet `./0-9A-Za-z', up to
34 characters total. Every character in the KEY is significant.
For the DES-based algorithm, the SALT should consist of two
characters from the alphabet `./0-9A-Za-z', and the result of
`crypt' will be those two characters followed by 11 more from the
same alphabet, 13 in total. Only the first 8 characters in the
KEY are significant.
The MD5-based algorithm has no limit on the useful length of the
password used, and is slightly more secure. It is therefore
preferred over the DES-based algorithm.
When the user enters their password for the first time, the SALT
should be set to a new string which is reasonably random. To
verify a password against the result of a previous call to
`crypt', pass the result of the previous call as the SALT.
The following short program is an example of how to use `crypt' the
first time a password is entered. Note that the SALT generation is
just barely acceptable; in particular, it is not unique between
machines, and in many applications it would not be acceptable to let an
attacker know what time the user's password was last set.
#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include <crypt.h>
int
main(void)
{
unsigned long seed[2];
char salt[] = "$1$........";
const char *const seedchars =
"./0123456789ABCDEFGHIJKLMNOPQRST"
"UVWXYZabcdefghijklmnopqrstuvwxyz";
char *password;
int i;
/* Generate a (not very) random seed.
You should do it better than this... */
seed[0] = time(NULL);
seed[1] = getpid() ^ (seed[0] >> 14 & 0x30000);
/* Turn it into printable characters from `seedchars'. */
for (i = 0; i < 8; i++)
salt[3+i] = seedchars[(seed[i/5] >> (i%5)*6) & 0x3f];
/* Read in the user's password and encrypt it. */
password = crypt(getpass("Password:"), salt);
/* Print the results. */
puts(password);
return 0;
}
The next program shows how to verify a password. It prompts the user
for a password and prints "Access granted." if the user types `GNU libc
manual'.
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <crypt.h>
int
main(void)
{
/* Hashed form of "GNU libc manual". */
const char *const pass = "$1$/iSaq7rB$EoUw5jJPPvAPECNaaWzMK/";
char *result;
int ok;
/* Read in the user's password and encrypt it,
passing the expected password in as the salt. */
result = crypt(getpass("Password:"), pass);
/* Test the result. */
ok = strcmp (result, pass) == 0;
puts(ok ? "Access granted." : "Access denied.");
return ok ? 0 : 1;
}
-- Function: char * crypt_r (const char *KEY, const char *SALT, struct
crypt_data * DATA)
Preliminary: | MT-Safe | AS-Unsafe corrupt lock heap dlopen |
AC-Unsafe lock mem | *Note POSIX Safety Concepts::.
The `crypt_r' function does the same thing as `crypt', but takes
an extra parameter which includes space for its result (among
other things), so it can be reentrant. `data->initialized' must be
cleared to zero before the first time `crypt_r' is called.
The `crypt_r' function is a GNU extension.
The `crypt' and `crypt_r' functions are prototyped in the header
`crypt.h'.

File: libc.info, Node: DES Encryption, Prev: crypt, Up: Cryptographic Functions
32.4 DES Encryption
===================
The Data Encryption Standard is described in the US Government Federal
Information Processing Standards (FIPS) 46-3 published by the National
Institute of Standards and Technology. The DES has been very thoroughly
analyzed since it was developed in the late 1970s, and no new
significant flaws have been found.
However, the DES uses only a 56-bit key (plus 8 parity bits), and a
machine has been built in 1998 which can search through all possible
keys in about 6 days, which cost about US$200000; faster searches would
be possible with more money. This makes simple DES insecure for most
purposes, and NIST no longer permits new US government systems to use
simple DES.
For serious encryption functionality, it is recommended that one of
the many free encryption libraries be used instead of these routines.
The DES is a reversible operation which takes a 64-bit block and a
64-bit key, and produces another 64-bit block. Usually the bits are
numbered so that the most-significant bit, the first bit, of each block
is numbered 1.
Under that numbering, every 8th bit of the key (the 8th, 16th, and so
on) is not used by the encryption algorithm itself. But the key must
have odd parity; that is, out of bits 1 through 8, and 9 through 16, and
so on, there must be an odd number of `1' bits, and this completely
specifies the unused bits.
-- Function: void setkey (const char *KEY)
Preliminary: | MT-Unsafe race:crypt | AS-Unsafe corrupt lock |
AC-Unsafe lock | *Note POSIX Safety Concepts::.
The `setkey' function sets an internal data structure to be an
expanded form of KEY. KEY is specified as an array of 64 bits
each stored in a `char', the first bit is `key[0]' and the 64th
bit is `key[63]'. The KEY should have the correct parity.
-- Function: void encrypt (char *BLOCK, int EDFLAG)
Preliminary: | MT-Unsafe race:crypt | AS-Unsafe corrupt lock |
AC-Unsafe lock | *Note POSIX Safety Concepts::.
The `encrypt' function encrypts BLOCK if EDFLAG is 0, otherwise it
decrypts BLOCK, using a key previously set by `setkey'. The
result is placed in BLOCK.
Like `setkey', BLOCK is specified as an array of 64 bits each
stored in a `char', but there are no parity bits in BLOCK.
-- Function: void setkey_r (const char *KEY, struct crypt_data * DATA)
-- Function: void encrypt_r (char *BLOCK, int EDFLAG, struct
crypt_data * DATA)
Preliminary: | MT-Safe | AS-Unsafe corrupt lock | AC-Unsafe lock |
*Note POSIX Safety Concepts::.
These are reentrant versions of `setkey' and `encrypt'. The only
difference is the extra parameter, which stores the expanded
version of KEY. Before calling `setkey_r' the first time,
`data->initialized' must be cleared to zero.
The `setkey_r' and `encrypt_r' functions are GNU extensions.
`setkey', `encrypt', `setkey_r', and `encrypt_r' are defined in
`crypt.h'.
-- Function: int ecb_crypt (char *KEY, char *BLOCKS, unsigned LEN,
unsigned MODE)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
The function `ecb_crypt' encrypts or decrypts one or more blocks
using DES. Each block is encrypted independently.
The BLOCKS and the KEY are stored packed in 8-bit bytes, so that
the first bit of the key is the most-significant bit of `key[0]'
and the 63rd bit of the key is stored as the least-significant bit
of `key[7]'. The KEY should have the correct parity.
LEN is the number of bytes in BLOCKS. It should be a multiple of
8 (so that there is a whole number of blocks to encrypt). LEN is
limited to a maximum of `DES_MAXDATA' bytes.
The result of the encryption replaces the input in BLOCKS.
The MODE parameter is the bitwise OR of two of the following:
`DES_ENCRYPT'
This constant, used in the MODE parameter, specifies that
BLOCKS is to be encrypted.
`DES_DECRYPT'
This constant, used in the MODE parameter, specifies that
BLOCKS is to be decrypted.
`DES_HW'
This constant, used in the MODE parameter, asks to use a
hardware device. If no hardware device is available,
encryption happens anyway, but in software.
`DES_SW'
This constant, used in the MODE parameter, specifies that no
hardware device is to be used.
The result of the function will be one of these values:
`DESERR_NONE'
The encryption succeeded.
`DESERR_NOHWDEVICE'
The encryption succeeded, but there was no hardware device
available.
`DESERR_HWERROR'
The encryption failed because of a hardware problem.
`DESERR_BADPARAM'
The encryption failed because of a bad parameter, for
instance LEN is not a multiple of 8 or LEN is larger than
`DES_MAXDATA'.
-- Function: int DES_FAILED (int ERR)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
This macro returns 1 if ERR is a `success' result code from
`ecb_crypt' or `cbc_crypt', and 0 otherwise.
-- Function: int cbc_crypt (char *KEY, char *BLOCKS, unsigned LEN,
unsigned MODE, char *IVEC)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
The function `cbc_crypt' encrypts or decrypts one or more blocks
using DES in Cipher Block Chaining mode.
For encryption in CBC mode, each block is exclusive-ored with IVEC
before being encrypted, then IVEC is replaced with the result of
the encryption, then the next block is processed. Decryption is
the reverse of this process.
This has the advantage that blocks which are the same before being
encrypted are very unlikely to be the same after being encrypted,
making it much harder to detect patterns in the data.
Usually, IVEC is set to 8 random bytes before encryption starts.
Then the 8 random bytes are transmitted along with the encrypted
data (without themselves being encrypted), and passed back in as
IVEC for decryption. Another possibility is to set IVEC to 8
zeroes initially, and have the first the block encrypted consist
of 8 random bytes.
Otherwise, all the parameters are similar to those for `ecb_crypt'.
-- Function: void des_setparity (char *KEY)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
The function `des_setparity' changes the 64-bit KEY, stored packed
in 8-bit bytes, to have odd parity by altering the low bits of
each byte.
The `ecb_crypt', `cbc_crypt', and `des_setparity' functions and
their accompanying macros are all defined in the header
`rpc/des_crypt.h'.

File: libc.info, Node: Debugging Support, Next: POSIX Threads, Prev: Cryptographic Functions, Up: Top
33 Debugging support
********************
Applications are usually debugged using dedicated debugger programs.
But sometimes this is not possible and, in any case, it is useful to
provide the developer with as much information as possible at the time
the problems are experienced. For this reason a few functions are
provided which a program can use to help the developer more easily
locate the problem.
* Menu:
* Backtraces:: Obtaining and printing a back trace of the
current stack.

File: libc.info, Node: Backtraces, Up: Debugging Support
33.1 Backtraces
===============
A "backtrace" is a list of the function calls that are currently active
in a thread. The usual way to inspect a backtrace of a program is to
use an external debugger such as gdb. However, sometimes it is useful
to obtain a backtrace programmatically from within a program, e.g., for
the purposes of logging or diagnostics.
The header file `execinfo.h' declares three functions that obtain
and manipulate backtraces of the current thread.
-- Function: int backtrace (void **BUFFER, int SIZE)
Preliminary: | MT-Safe | AS-Unsafe init heap dlopen plugin lock |
AC-Unsafe init mem lock fd | *Note POSIX Safety Concepts::.
The `backtrace' function obtains a backtrace for the current
thread, as a list of pointers, and places the information into
BUFFER. The argument SIZE should be the number of `void *'
elements that will fit into BUFFER. The return value is the
actual number of entries of BUFFER that are obtained, and is at
most SIZE.
The pointers placed in BUFFER are actually return addresses
obtained by inspecting the stack, one return address per stack
frame.
Note that certain compiler optimizations may interfere with
obtaining a valid backtrace. Function inlining causes the inlined
function to not have a stack frame; tail call optimization
replaces one stack frame with another; frame pointer elimination
will stop `backtrace' from interpreting the stack contents
correctly.
-- Function: char ** backtrace_symbols (void *const *BUFFER, int SIZE)
Preliminary: | MT-Safe | AS-Unsafe heap | AC-Unsafe mem lock |
*Note POSIX Safety Concepts::.
The `backtrace_symbols' function translates the information
obtained from the `backtrace' function into an array of strings.
The argument BUFFER should be a pointer to an array of addresses
obtained via the `backtrace' function, and SIZE is the number of
entries in that array (the return value of `backtrace').
The return value is a pointer to an array of strings, which has
SIZE entries just like the array BUFFER. Each string contains a
printable representation of the corresponding element of BUFFER.
It includes the function name (if this can be determined), an
offset into the function, and the actual return address (in
hexadecimal).
Currently, the function name and offset only be obtained on
systems that use the ELF binary format for programs and libraries.
On other systems, only the hexadecimal return address will be
present. Also, you may need to pass additional flags to the
linker to make the function names available to the program. (For
example, on systems using GNU ld, you must pass (`-rdynamic'.)
The return value of `backtrace_symbols' is a pointer obtained via
the `malloc' function, and it is the responsibility of the caller
to `free' that pointer. Note that only the return value need be
freed, not the individual strings.
The return value is `NULL' if sufficient memory for the strings
cannot be obtained.
-- Function: void backtrace_symbols_fd (void *const *BUFFER, int SIZE,
int FD)
Preliminary: | MT-Safe | AS-Safe | AC-Unsafe lock | *Note POSIX
Safety Concepts::.
The `backtrace_symbols_fd' function performs the same translation
as the function `backtrace_symbols' function. Instead of returning
the strings to the caller, it writes the strings to the file
descriptor FD, one per line. It does not use the `malloc'
function, and can therefore be used in situations where that
function might fail.
The following program illustrates the use of these functions. Note
that the array to contain the return addresses returned by `backtrace'
is allocated on the stack. Therefore code like this can be used in
situations where the memory handling via `malloc' does not work anymore
(in which case the `backtrace_symbols' has to be replaced by a
`backtrace_symbols_fd' call as well). The number of return addresses
is normally not very large. Even complicated programs rather seldom
have a nesting level of more than, say, 50 and with 200 possible
entries probably all programs should be covered.
#include <execinfo.h>
#include <stdio.h>
#include <stdlib.h>
/* Obtain a backtrace and print it to `stdout'. */
void
print_trace (void)
{
void *array[10];
size_t size;
char **strings;
size_t i;
size = backtrace (array, 10);
strings = backtrace_symbols (array, size);
printf ("Obtained %zd stack frames.\n", size);
for (i = 0; i < size; i++)
printf ("%s\n", strings[i]);
free (strings);
}
/* A dummy function to make the backtrace more interesting. */
void
dummy_function (void)
{
print_trace ();
}
int
main (void)
{
dummy_function ();
return 0;
}

File: libc.info, Node: POSIX Threads, Next: Internal Probes, Prev: Debugging Support, Up: Top
34 POSIX Threads
****************
This chapter describes the GNU C Library POSIX Thread implementation.
* Menu:
* Thread-specific Data:: Support for creating and
managing thread-specific data
* Non-POSIX Extensions:: Additional functions to extend
POSIX Thread functionality

File: libc.info, Node: Thread-specific Data, Next: Non-POSIX Extensions, Up: POSIX Threads
34.1 Thread-specific Data
=========================
The GNU C Library implements functions to allow users to create and
manage data specific to a thread. Such data may be destroyed at thread
exit, if a destructor is provided. The following functions are defined:
-- Function: int pthread_key_create (pthread_key_t *KEY, void
(*DESTRUCTOR)(void*))
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Create a thread-specific data key for the calling thread,
referenced by KEY.
Objects declared with the C++11 `thread_local' keyword are
destroyed before thread-specific data, so they should not be used
in thread-specific data destructors or even as members of the
thread-specific data, since the latter is passed as an argument to
the destructor function.
-- Function: int pthread_key_delete (pthread_key_t KEY)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Destroy the thread-specific data KEY in the calling thread. The
destructor for the thread-specific data is not called during
destruction, nor is it called during thread exit.
-- Function: void *pthread_getspecific (pthread_key_t KEY)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Return the thread-specific data associated with KEY in the calling
thread.
-- Function: int pthread_setspecific (pthread_key_t KEY, const void
*VALUE)
Preliminary: | MT-Safe | AS-Unsafe corrupt heap | AC-Unsafe
corrupt mem | *Note POSIX Safety Concepts::.
Associate the thread-specific VALUE with KEY in the calling thread.

File: libc.info, Node: Non-POSIX Extensions, Prev: Thread-specific Data, Up: POSIX Threads
34.2 Non-POSIX Extensions
=========================
In addition to implementing the POSIX API for threads, the GNU C
Library provides additional functions and interfaces to provide
functionality not specified in the standard.
* Menu:
* Default Thread Attributes:: Setting default attributes for
threads in a process.

File: libc.info, Node: Default Thread Attributes, Up: Non-POSIX Extensions
34.2.1 Setting Process-wide defaults for thread attributes
----------------------------------------------------------
The GNU C Library provides non-standard API functions to set and get
the default attributes used in the creation of threads in a process.
-- Function: int pthread_getattr_default_np (pthread_attr_t *ATTR)
Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | *Note
POSIX Safety Concepts::.
Get the default attribute values and set ATTR to match. This
function returns 0 on success and a non-zero error code on failure.
-- Function: int pthread_setattr_default_np (pthread_attr_t *ATTR)
Preliminary: | MT-Safe | AS-Unsafe heap lock | AC-Unsafe lock mem
| *Note POSIX Safety Concepts::.
Set the default attribute values to match the values in ATTR. The
function returns 0 on success and a non-zero error code on failure.
The following error codes are defined for this function:
`EINVAL'
At least one of the values in ATTR does not qualify as valid
for the attributes or the stack address is set in the
attribute.
`ENOMEM'
The system does not have sufficient memory.

File: libc.info, Node: Internal Probes, Next: Language Features, Prev: POSIX Threads, Up: Top
35 Internal probes
******************
In order to aid in debugging and monitoring internal behavior, the GNU
C Library exposes nearly-zero-overhead SystemTap probes marked with the
`libc' provider.
These probes are not part of the GNU C Library stable ABI, and they
are subject to change or removal across releases. Our only promise with
regard to them is that, if we find a need to remove or modify the
arguments of a probe, the modified probe will have a different name, so
that program monitors relying on the old probe will not get unexpected
arguments.
* Menu:
* Memory Allocation Probes:: Probes in the memory allocation subsystem
* Mathematical Function Probes:: Probes in mathematical functions

File: libc.info, Node: Memory Allocation Probes, Next: Mathematical Function Probes, Up: Internal Probes
35.1 Memory Allocation Probes
=============================
These probes are designed to signal relatively unusual situations within
the virtual memory subsystem of the GNU C Library.
-- Probe: memory_sbrk_more (void *$ARG1, size_t $ARG2)
This probe is triggered after the main arena is extended by calling
`sbrk'. Argument $ARG1 is the additional size requested to
`sbrk', and $ARG2 is the pointer that marks the end of the `sbrk'
area, returned in response to the request.
-- Probe: memory_sbrk_less (void *$ARG1, size_t $ARG2)
This probe is triggered after the size of the main arena is
decreased by calling `sbrk'. Argument $ARG1 is the size released
by `sbrk' (the positive value, rather than the negative value
passed to `sbrk'), and $ARG2 is the pointer that marks the end of
the `sbrk' area, returned in response to the request.
-- Probe: memory_heap_new (void *$ARG1, size_t $ARG2)
This probe is triggered after a new heap is `mmap'ed. Argument
$ARG1 is a pointer to the base of the memory area, where the
`heap_info' data structure is held, and $ARG2 is the size of the
heap.
-- Probe: memory_heap_free (void *$ARG1, size_t $ARG2)
This probe is triggered _before_ (unlike the other sbrk and heap
probes) a heap is completely removed via `munmap'. Argument $ARG1
is a pointer to the heap, and $ARG2 is the size of the heap.
-- Probe: memory_heap_more (void *$ARG1, size_t $ARG2)
This probe is triggered after a trailing portion of an `mmap'ed
heap is extended. Argument $ARG1 is a pointer to the heap, and
$ARG2 is the new size of the heap.
-- Probe: memory_heap_less (void *$ARG1, size_t $ARG2)
This probe is triggered after a trailing portion of an `mmap'ed
heap is released. Argument $ARG1 is a pointer to the heap, and
$ARG2 is the new size of the heap.
-- Probe: memory_malloc_retry (size_t $ARG1)
-- Probe: memory_realloc_retry (size_t $ARG1, void *$ARG2)
-- Probe: memory_memalign_retry (size_t $ARG1, size_t $ARG2)
-- Probe: memory_calloc_retry (size_t $ARG1)
These probes are triggered when the corresponding functions fail to
obtain the requested amount of memory from the arena in use,
before they call `arena_get_retry' to select an alternate arena in
which to retry the allocation. Argument $ARG1 is the amount of
memory requested by the user; in the `calloc' case, that is the
total size computed from both function arguments. In the
`realloc' case, $ARG2 is the pointer to the memory area being
resized. In the `memalign' case, $ARG2 is the alignment to be
used for the request, which may be stricter than the value passed
to the `memalign' function. A `memalign' probe is also used by
functions `posix_memalign, valloc' and `pvalloc'.
Note that the argument order does _not_ match that of the
corresponding two-argument functions, so that in all of these
probes the user-requested allocation size is in $ARG1.
-- Probe: memory_arena_retry (size_t $ARG1, void *$ARG2)
This probe is triggered within `arena_get_retry' (the function
called to select the alternate arena in which to retry an
allocation that failed on the first attempt), before the selection
of an alternate arena. This probe is redundant, but much easier
to use when it's not important to determine which of the various
memory allocation functions is failing to allocate on the first
try. Argument $ARG1 is the same as in the function-specific
probes, except for extra room for padding introduced by functions
that have to ensure stricter alignment. Argument $ARG2 is the
arena in which allocation failed.
-- Probe: memory_arena_new (void *$ARG1, size_t $ARG2)
This probe is triggered when `malloc' allocates and initializes an
additional arena (not the main arena), but before the arena is
assigned to the running thread or inserted into the internal
linked list of arenas. The arena's `malloc_state' internal data
structure is located at $ARG1, within a newly-allocated heap big
enough to hold at least $ARG2 bytes.
-- Probe: memory_arena_reuse (void *$ARG1, void *$ARG2)
This probe is triggered when `malloc' has just selected an existing
arena to reuse, and (temporarily) reserved it for exclusive use.
Argument $ARG1 is a pointer to the newly-selected arena, and $ARG2
is a pointer to the arena previously used by that thread.
This occurs within `reused_arena', right after the mutex mentioned
in probe `memory_arena_reuse_wait' is acquired; argument $ARG1 will
point to the same arena. In this configuration, this will usually
only occur once per thread. The exception is when a thread first
selected the main arena, but a subsequent allocation from it
fails: then, and only then, may we switch to another arena to
retry that allocations, and for further allocations within that
thread.
-- Probe: memory_arena_reuse_wait (void *$ARG1, void *$ARG2, void
*$ARG3)
This probe is triggered when `malloc' is about to wait for an arena
to become available for reuse. Argument $ARG1 holds a pointer to
the mutex the thread is going to wait on, $ARG2 is a pointer to a
newly-chosen arena to be reused, and $ARG3 is a pointer to the
arena previously used by that thread.
This occurs within `reused_arena', when a thread first tries to
allocate memory or needs a retry after a failure to allocate from
the main arena, there isn't any free arena, the maximum number of
arenas has been reached, and an existing arena was chosen for
reuse, but its mutex could not be immediately acquired. The mutex
in $ARG1 is the mutex of the selected arena.
-- Probe: memory_arena_reuse_free_list (void *$ARG1)
This probe is triggered when `malloc' has chosen an arena that is
in the free list for use by a thread, within the `get_free_list'
function. The argument $ARG1 holds a pointer to the selected
arena.
-- Probe: memory_mallopt (int $ARG1, int $ARG2)
This probe is triggered when function `mallopt' is called to change
`malloc' internal configuration parameters, before any change to
the parameters is made. The arguments $ARG1 and $ARG2 are the
ones passed to the `mallopt' function.
-- Probe: memory_mallopt_mxfast (int $ARG1, int $ARG2)
This probe is triggered shortly after the `memory_mallopt' probe,
when the parameter to be changed is `M_MXFAST', and the requested
value is in an acceptable range. Argument $ARG1 is the requested
value, and $ARG2 is the previous value of this `malloc' parameter.
-- Probe: memory_mallopt_trim_threshold (int $ARG1, int $ARG2, int
$ARG3)
This probe is triggere shortly after the `memory_mallopt' probe,
when the parameter to be changed is `M_TRIM_THRESHOLD'. Argument
$ARG1 is the requested value, $ARG2 is the previous value of this
`malloc' parameter, and $ARG3 is nonzero if dynamic threshold
adjustment was already disabled.
-- Probe: memory_mallopt_top_pad (int $ARG1, int $ARG2, int $ARG3)
This probe is triggered shortly after the `memory_mallopt' probe,
when the parameter to be changed is `M_TOP_PAD'. Argument $ARG1
is the requested value, $ARG2 is the previous value of this
`malloc' parameter, and $ARG3 is nonzero if dynamic threshold
adjustment was already disabled.
-- Probe: memory_mallopt_mmap_threshold (int $ARG1, int $ARG2, int
$ARG3)
This probe is triggered shortly after the `memory_mallopt' probe,
when the parameter to be changed is `M_MMAP_THRESHOLD', and the
requested value is in an acceptable range. Argument $ARG1 is the
requested value, $ARG2 is the previous value of this `malloc'
parameter, and $ARG3 is nonzero if dynamic threshold adjustment
was already disabled.
-- Probe: memory_mallopt_mmap_max (int $ARG1, int $ARG2, int $ARG3)
This probe is triggered shortly after the `memory_mallopt' probe,
when the parameter to be changed is `M_MMAP_MAX'. Argument $ARG1
is the requested value, $ARG2 is the previous value of this
`malloc' parameter, and $ARG3 is nonzero if dynamic threshold
adjustment was already disabled.
-- Probe: memory_mallopt_check_action (int $ARG1, int $ARG2)
This probe is triggered shortly after the `memory_mallopt' probe,
when the parameter to be changed is `M_CHECK_ACTION'. Argument
$ARG1 is the requested value, and $ARG2 is the previous value of
this `malloc' parameter.
-- Probe: memory_mallopt_perturb (int $ARG1, int $ARG2)
This probe is triggered shortly after the `memory_mallopt' probe,
when the parameter to be changed is `M_PERTURB'. Argument $ARG1
is the requested value, and $ARG2 is the previous value of this
`malloc' parameter.
-- Probe: memory_mallopt_arena_test (int $ARG1, int $ARG2)
This probe is triggered shortly after the `memory_mallopt' probe,
when the parameter to be changed is `M_ARENA_TEST', and the
requested value is in an acceptable range. Argument $ARG1 is the
requested value, and $ARG2 is the previous value of this `malloc'
parameter.
-- Probe: memory_mallopt_arena_max (int $ARG1, int $ARG2)
This probe is triggered shortly after the `memory_mallopt' probe,
when the parameter to be changed is `M_ARENA_MAX', and the
requested value is in an acceptable range. Argument $ARG1 is the
requested value, and $ARG2 is the previous value of this `malloc'
parameter.
-- Probe: memory_mallopt_free_dyn_thresholds (int $ARG1, int $ARG2)
This probe is triggered when function `free' decides to adjust the
dynamic brk/mmap thresholds. Argument $ARG1 and $ARG2 are the
adjusted mmap and trim thresholds, respectively.

File: libc.info, Node: Mathematical Function Probes, Prev: Memory Allocation Probes, Up: Internal Probes
35.2 Mathematical Function Probes
=================================
Some mathematical functions fall back to multiple precision arithmetic
for some inputs to get last bit precision for their return values.
This multiple precision fallback is much slower than the default
algorithms and may have a significant impact on application
performance. The systemtap probe markers described in this section may
help you determine if your application calls mathematical functions
with inputs that may result in multiple-precision arithmetic.
Unless explicitly mentioned otherwise, a precision of 1 implies 24
bits of precision in the mantissa of the multiple precision number.
Hence, a precision level of 32 implies 768 bits of precision in the
mantissa.
-- Probe: slowexp_p6 (double $ARG1, double $ARG2)
This probe is hit when the `exp' function is called with an input
that results in multiple precision computation with precision 6.
Argument $ARG1 is the input value and $ARG2 is the computed output.
-- Probe: slowexp_p32 (double $ARG1, double $ARG2)
This probe is hit when the `exp' function is called with an input
that results in multiple precision computation with precision 32.
Argument $ARG1 is the input value and $ARG2 is the computed output.
-- Probe: slowpow_p10 (double $ARG1, double $ARG2, double $ARG3,
double $ARG4)
This probe is hit when the `pow' function is called with inputs
that result in multiple precision computation with precision 10.
Arguments $ARG1 and $ARG2 are the input values, `$arg3' is the
value computed in the fast phase of the algorithm and `$arg4' is
the final accurate value.
-- Probe: slowpow_p32 (double $ARG1, double $ARG2, double $ARG3,
double $ARG4)
This probe is hit when the `pow' function is called with an input
that results in multiple precision computation with precision 32.
Arguments $ARG1 and $ARG2 are the input values, `$arg3' is the
value computed in the fast phase of the algorithm and `$arg4' is
the final accurate value.
-- Probe: slowlog (int $ARG1, double $ARG2, double $ARG3)
This probe is hit when the `log' function is called with an input
that results in multiple precision computation. Argument $ARG1 is
the precision with which the computation succeeded. Argument
$ARG2 is the input and $ARG3 is the computed output.
-- Probe: slowlog_inexact (int $ARG1, double $ARG2, double $ARG3)
This probe is hit when the `log' function is called with an input
that results in multiple precision computation and none of the
multiple precision computations result in an accurate result.
Argument $ARG1 is the maximum precision with which computations
were performed. Argument $ARG2 is the input and $ARG3 is the
computed output.
-- Probe: slowatan2 (int $ARG1, double $ARG2, double $ARG3, double
$ARG4)
This probe is hit when the `atan2' function is called with an
input that results in multiple precision computation. Argument
$ARG1 is the precision with which computation succeeded.
Arguments $ARG2 and $ARG3 are inputs to the `atan2' function and
$ARG4 is the computed result.
-- Probe: slowatan2_inexact (int $ARG1, double $ARG2, double $ARG3,
double $ARG4)
This probe is hit when the `atan' function is called with an input
that results in multiple precision computation and none of the
multiple precision computations result in an accurate result.
Argument $ARG1 is the maximum precision with which computations
were performed. Arguments $ARG2 and $ARG3 are inputs to the
`atan2' function and $ARG4 is the computed result.
-- Probe: slowatan (int $ARG1, double $ARG2, double $ARG3)
This probe is hit when the `atan' function is called with an input
that results in multiple precision computation. Argument $ARG1 is
the precision with which computation succeeded. Argument $ARG2 is
the input to the `atan' function and $ARG3 is the computed result.
-- Probe: slowatan_inexact (int $ARG1, double $ARG2, double $ARG3)
This probe is hit when the `atan' function is called with an input
that results in multiple precision computation and none of the
multiple precision computations result in an accurate result.
Argument $ARG1 is the maximum precision with which computations
were performed. Argument $ARG2 is the input to the `atan'
function and $ARG3 is the computed result.
-- Probe: slowtan (double $ARG1, double $ARG2)
This probe is hit when the `tan' function is called with an input
that results in multiple precision computation with precision 32.
Argument $ARG1 is the input to the function and $ARG2 is the
computed result.
-- Probe: slowasin (double $ARG1, double $ARG2)
This probe is hit when the `asin' function is called with an input
that results in multiple precision computation with precision 32.
Argument $ARG1 is the input to the function and $ARG2 is the
computed result.
-- Probe: slowacos (double $ARG1, double $ARG2)
This probe is hit when the `acos' function is called with an input
that results in multiple precision computation with precision 32.
Argument $ARG1 is the input to the function and $ARG2 is the
computed result.
-- Probe: slowsin (double $ARG1, double $ARG2)
This probe is hit when the `sin' function is called with an input
that results in multiple precision computation with precision 32.
Argument $ARG1 is the input to the function and $ARG2 is the
computed result.
-- Probe: slowcos (double $ARG1, double $ARG2)
This probe is hit when the `cos' function is called with an input
that results in multiple precision computation with precision 32.
Argument $ARG1 is the input to the function and $ARG2 is the
computed result.
-- Probe: slowsin_dx (double $ARG1, double $ARG2, double $ARG3)
This probe is hit when the `sin' function is called with an input
that results in multiple precision computation with precision 32.
Argument $ARG1 is the input to the function, $ARG2 is the error
bound of $ARG1 and $ARG3 is the computed result.
-- Probe: slowcos_dx (double $ARG1, double $ARG2, double $ARG3)
This probe is hit when the `cos' function is called with an input
that results in multiple precision computation with precision 32.
Argument $ARG1 is the input to the function, $ARG2 is the error
bound of $ARG1 and $ARG3 is the computed result.

File: libc.info, Node: Language Features, Next: Library Summary, Prev: Internal Probes, Up: Top
Appendix A C Language Facilities in the Library
***********************************************
Some of the facilities implemented by the C library really should be
thought of as parts of the C language itself. These facilities ought to
be documented in the C Language Manual, not in the library manual; but
since we don't have the language manual yet, and documentation for these
features has been written, we are publishing it here.
* Menu:
* Consistency Checking:: Using `assert' to abort if
something ``impossible'' happens.
* Variadic Functions:: Defining functions with varying numbers
of args.
* Null Pointer Constant:: The macro `NULL'.
* Important Data Types:: Data types for object sizes.
* Data Type Measurements:: Parameters of data type representations.

File: libc.info, Node: Consistency Checking, Next: Variadic Functions, Up: Language Features
A.1 Explicitly Checking Internal Consistency
============================================
When you're writing a program, it's often a good idea to put in checks
at strategic places for "impossible" errors or violations of basic
assumptions. These kinds of checks are helpful in debugging problems
with the interfaces between different parts of the program, for example.
The `assert' macro, defined in the header file `assert.h', provides
a convenient way to abort the program while printing a message about
where in the program the error was detected.
Once you think your program is debugged, you can disable the error
checks performed by the `assert' macro by recompiling with the macro
`NDEBUG' defined. This means you don't actually have to change the
program source code to disable these checks.
But disabling these consistency checks is undesirable unless they
make the program significantly slower. All else being equal, more error
checking is good no matter who is running the program. A wise user
would rather have a program crash, visibly, than have it return nonsense
without indicating anything might be wrong.
-- Macro: void assert (int EXPRESSION)
Preliminary: | MT-Safe | AS-Unsafe heap corrupt | AC-Unsafe mem
lock corrupt | *Note POSIX Safety Concepts::.
Verify the programmer's belief that EXPRESSION is nonzero at this
point in the program.
If `NDEBUG' is not defined, `assert' tests the value of
EXPRESSION. If it is false (zero), `assert' aborts the program
(*note Aborting a Program::) after printing a message of the form:
`FILE':LINENUM: FUNCTION: Assertion `EXPRESSION' failed.
on the standard error stream `stderr' (*note Standard Streams::).
The filename and line number are taken from the C preprocessor
macros `__FILE__' and `__LINE__' and specify where the call to
`assert' was made. When using the GNU C compiler, the name of the
function which calls `assert' is taken from the built-in variable
`__PRETTY_FUNCTION__'; with older compilers, the function name and
following colon are omitted.
If the preprocessor macro `NDEBUG' is defined before `assert.h' is
included, the `assert' macro is defined to do absolutely nothing.
*Warning:* Even the argument expression EXPRESSION is not
evaluated if `NDEBUG' is in effect. So never use `assert' with
arguments that involve side effects. For example, `assert (++i >
0);' is a bad idea, because `i' will not be incremented if
`NDEBUG' is defined.
Sometimes the "impossible" condition you want to check for is an
error return from an operating system function. Then it is useful to
display not only where the program crashes, but also what error was
returned. The `assert_perror' macro makes this easy.
-- Macro: void assert_perror (int ERRNUM)
Preliminary: | MT-Safe | AS-Unsafe heap corrupt | AC-Unsafe mem
lock corrupt | *Note POSIX Safety Concepts::.
Similar to `assert', but verifies that ERRNUM is zero.
If `NDEBUG' is not defined, `assert_perror' tests the value of
ERRNUM. If it is nonzero, `assert_perror' aborts the program
after printing a message of the form:
`FILE':LINENUM: FUNCTION: ERROR TEXT
on the standard error stream. The file name, line number, and
function name are as for `assert'. The error text is the result of
`strerror (ERRNUM)'. *Note Error Messages::.
Like `assert', if `NDEBUG' is defined before `assert.h' is
included, the `assert_perror' macro does absolutely nothing. It
does not evaluate the argument, so ERRNUM should not have any side
effects. It is best for ERRNUM to be just a simple variable
reference; often it will be `errno'.
This macro is a GNU extension.
*Usage note:* The `assert' facility is designed for detecting
_internal inconsistency_; it is not suitable for reporting invalid
input or improper usage by the _user_ of the program.
The information in the diagnostic messages printed by the `assert'
and `assert_perror' macro is intended to help you, the programmer,
track down the cause of a bug, but is not really useful for telling a
user of your program why his or her input was invalid or why a command
could not be carried out. What's more, your program should not abort
when given invalid input, as `assert' would do--it should exit with
nonzero status (*note Exit Status::) after printing its error messages,
or perhaps read another command or move on to the next input file.
*Note Error Messages::, for information on printing error messages
for problems that _do not_ represent bugs in the program.

File: libc.info, Node: Variadic Functions, Next: Null Pointer Constant, Prev: Consistency Checking, Up: Language Features
A.2 Variadic Functions
======================
ISO C defines a syntax for declaring a function to take a variable
number or type of arguments. (Such functions are referred to as
"varargs functions" or "variadic functions".) However, the language
itself provides no mechanism for such functions to access their
non-required arguments; instead, you use the variable arguments macros
defined in `stdarg.h'.
This section describes how to declare variadic functions, how to
write them, and how to call them properly.
*Compatibility Note:* Many older C dialects provide a similar, but
incompatible, mechanism for defining functions with variable numbers of
arguments, using `varargs.h'.
* Menu:
* Why Variadic:: Reasons for making functions take
variable arguments.
* How Variadic:: How to define and call variadic functions.
* Variadic Example:: A complete example.

File: libc.info, Node: Why Variadic, Next: How Variadic, Up: Variadic Functions
A.2.1 Why Variadic Functions are Used
-------------------------------------
Ordinary C functions take a fixed number of arguments. When you define
a function, you specify the data type for each argument. Every call to
the function should supply the expected number of arguments, with types
that can be converted to the specified ones. Thus, if the function
`foo' is declared with `int foo (int, char *);' then you must call it
with two arguments, a number (any kind will do) and a string pointer.
But some functions perform operations that can meaningfully accept an
unlimited number of arguments.
In some cases a function can handle any number of values by
operating on all of them as a block. For example, consider a function
that allocates a one-dimensional array with `malloc' to hold a
specified set of values. This operation makes sense for any number of
values, as long as the length of the array corresponds to that number.
Without facilities for variable arguments, you would have to define a
separate function for each possible array size.
The library function `printf' (*note Formatted Output::) is an
example of another class of function where variable arguments are
useful. This function prints its arguments (which can vary in type as
well as number) under the control of a format template string.
These are good reasons to define a "variadic" function which can
handle as many arguments as the caller chooses to pass.
Some functions such as `open' take a fixed set of arguments, but
occasionally ignore the last few. Strict adherence to ISO C requires
these functions to be defined as variadic; in practice, however, the GNU
C compiler and most other C compilers let you define such a function to
take a fixed set of arguments--the most it can ever use--and then only
_declare_ the function as variadic (or not declare its arguments at
all!).

File: libc.info, Node: How Variadic, Next: Variadic Example, Prev: Why Variadic, Up: Variadic Functions
A.2.2 How Variadic Functions are Defined and Used
-------------------------------------------------
Defining and using a variadic function involves three steps:
* _Define_ the function as variadic, using an ellipsis (`...') in
the argument list, and using special macros to access the variable
arguments. *Note Receiving Arguments::.
* _Declare_ the function as variadic, using a prototype with an
ellipsis (`...'), in all the files which call it. *Note Variadic
Prototypes::.
* _Call_ the function by writing the fixed arguments followed by the
additional variable arguments. *Note Calling Variadics::.
* Menu:
* Variadic Prototypes:: How to make a prototype for a function
with variable arguments.
* Receiving Arguments:: Steps you must follow to access the
optional argument values.
* How Many Arguments:: How to decide whether there are more arguments.
* Calling Variadics:: Things you need to know about calling
variable arguments functions.
* Argument Macros:: Detailed specification of the macros
for accessing variable arguments.

File: libc.info, Node: Variadic Prototypes, Next: Receiving Arguments, Up: How Variadic
A.2.2.1 Syntax for Variable Arguments
.....................................
A function that accepts a variable number of arguments must be declared
with a prototype that says so. You write the fixed arguments as usual,
and then tack on `...' to indicate the possibility of additional
arguments. The syntax of ISO C requires at least one fixed argument
before the `...'. For example,
int
func (const char *a, int b, ...)
{
...
}
defines a function `func' which returns an `int' and takes two required
arguments, a `const char *' and an `int'. These are followed by any
number of anonymous arguments.
*Portability note:* For some C compilers, the last required argument
must not be declared `register' in the function definition.
Furthermore, this argument's type must be "self-promoting": that is,
the default promotions must not change its type. This rules out array
and function types, as well as `float', `char' (whether signed or not)
and `short int' (whether signed or not). This is actually an ISO C
requirement.

File: libc.info, Node: Receiving Arguments, Next: How Many Arguments, Prev: Variadic Prototypes, Up: How Variadic
A.2.2.2 Receiving the Argument Values
.....................................
Ordinary fixed arguments have individual names, and you can use these
names to access their values. But optional arguments have no
names--nothing but `...'. How can you access them?
The only way to access them is sequentially, in the order they were
written, and you must use special macros from `stdarg.h' in the
following three step process:
1. You initialize an argument pointer variable of type `va_list' using
`va_start'. The argument pointer when initialized points to the
first optional argument.
2. You access the optional arguments by successive calls to `va_arg'.
The first call to `va_arg' gives you the first optional argument,
the next call gives you the second, and so on.
You can stop at any time if you wish to ignore any remaining
optional arguments. It is perfectly all right for a function to
access fewer arguments than were supplied in the call, but you
will get garbage values if you try to access too many arguments.
3. You indicate that you are finished with the argument pointer
variable by calling `va_end'.
(In practice, with most C compilers, calling `va_end' does nothing.
This is always true in the GNU C compiler. But you might as well
call `va_end' just in case your program is someday compiled with a
peculiar compiler.)
*Note Argument Macros::, for the full definitions of `va_start',
`va_arg' and `va_end'.
Steps 1 and 3 must be performed in the function that accepts the
optional arguments. However, you can pass the `va_list' variable as an
argument to another function and perform all or part of step 2 there.
You can perform the entire sequence of three steps multiple times
within a single function invocation. If you want to ignore the optional
arguments, you can do these steps zero times.
You can have more than one argument pointer variable if you like.
You can initialize each variable with `va_start' when you wish, and
then you can fetch arguments with each argument pointer as you wish.
Each argument pointer variable will sequence through the same set of
argument values, but at its own pace.
*Portability note:* With some compilers, once you pass an argument
pointer value to a subroutine, you must not keep using the same
argument pointer value after that subroutine returns. For full
portability, you should just pass it to `va_end'. This is actually an
ISO C requirement, but most ANSI C compilers work happily regardless.

File: libc.info, Node: How Many Arguments, Next: Calling Variadics, Prev: Receiving Arguments, Up: How Variadic
A.2.2.3 How Many Arguments Were Supplied
........................................
There is no general way for a function to determine the number and type
of the optional arguments it was called with. So whoever designs the
function typically designs a convention for the caller to specify the
number and type of arguments. It is up to you to define an appropriate
calling convention for each variadic function, and write all calls
accordingly.
One kind of calling convention is to pass the number of optional
arguments as one of the fixed arguments. This convention works provided
all of the optional arguments are of the same type.
A similar alternative is to have one of the required arguments be a
bit mask, with a bit for each possible purpose for which an optional
argument might be supplied. You would test the bits in a predefined
sequence; if the bit is set, fetch the value of the next argument,
otherwise use a default value.
A required argument can be used as a pattern to specify both the
number and types of the optional arguments. The format string argument
to `printf' is one example of this (*note Formatted Output Functions::).
Another possibility is to pass an "end marker" value as the last
optional argument. For example, for a function that manipulates an
arbitrary number of pointer arguments, a null pointer might indicate the
end of the argument list. (This assumes that a null pointer isn't
otherwise meaningful to the function.) The `execl' function works in
just this way; see *note Executing a File::.

File: libc.info, Node: Calling Variadics, Next: Argument Macros, Prev: How Many Arguments, Up: How Variadic
A.2.2.4 Calling Variadic Functions
..................................
You don't have to do anything special to call a variadic function.
Just put the arguments (required arguments, followed by optional ones)
inside parentheses, separated by commas, as usual. But you must declare
the function with a prototype and know how the argument values are
converted.
In principle, functions that are _defined_ to be variadic must also
be _declared_ to be variadic using a function prototype whenever you
call them. (*Note Variadic Prototypes::, for how.) This is because
some C compilers use a different calling convention to pass the same set
of argument values to a function depending on whether that function
takes variable arguments or fixed arguments.
In practice, the GNU C compiler always passes a given set of argument
types in the same way regardless of whether they are optional or
required. So, as long as the argument types are self-promoting, you can
safely omit declaring them. Usually it is a good idea to declare the
argument types for variadic functions, and indeed for all functions.
But there are a few functions which it is extremely convenient not to
have to declare as variadic--for example, `open' and `printf'.
Since the prototype doesn't specify types for optional arguments, in
a call to a variadic function the "default argument promotions" are
performed on the optional argument values. This means the objects of
type `char' or `short int' (whether signed or not) are promoted to
either `int' or `unsigned int', as appropriate; and that objects of
type `float' are promoted to type `double'. So, if the caller passes a
`char' as an optional argument, it is promoted to an `int', and the
function can access it with `va_arg (AP, int)'.
Conversion of the required arguments is controlled by the function
prototype in the usual way: the argument expression is converted to the
declared argument type as if it were being assigned to a variable of
that type.

File: libc.info, Node: Argument Macros, Prev: Calling Variadics, Up: How Variadic
A.2.2.5 Argument Access Macros
..............................
Here are descriptions of the macros used to retrieve variable arguments.
These macros are defined in the header file `stdarg.h'.
-- Data Type: va_list
The type `va_list' is used for argument pointer variables.
-- Macro: void va_start (va_list AP, LAST-REQUIRED)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
This macro initializes the argument pointer variable AP to point
to the first of the optional arguments of the current function;
LAST-REQUIRED must be the last required argument to the function.
-- Macro: TYPE va_arg (va_list AP, TYPE)
Preliminary: | MT-Safe race:ap | AS-Safe | AC-Unsafe corrupt |
*Note POSIX Safety Concepts::.
The `va_arg' macro returns the value of the next optional argument,
and modifies the value of AP to point to the subsequent argument.
Thus, successive uses of `va_arg' return successive optional
arguments.
The type of the value returned by `va_arg' is TYPE as specified in
the call. TYPE must be a self-promoting type (not `char' or
`short int' or `float') that matches the type of the actual
argument.
-- Macro: void va_end (va_list AP)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
This ends the use of AP. After a `va_end' call, further `va_arg'
calls with the same AP may not work. You should invoke `va_end'
before returning from the function in which `va_start' was invoked
with the same AP argument.
In the GNU C Library, `va_end' does nothing, and you need not ever
use it except for reasons of portability.
Sometimes it is necessary to parse the list of parameters more than
once or one wants to remember a certain position in the parameter list.
To do this, one will have to make a copy of the current value of the
argument. But `va_list' is an opaque type and one cannot necessarily
assign the value of one variable of type `va_list' to another variable
of the same type.
-- Macro: void va_copy (va_list DEST, va_list SRC)
-- Macro: void __va_copy (va_list DEST, va_list SRC)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
The `va_copy' macro allows copying of objects of type `va_list'
even if this is not an integral type. The argument pointer in
DEST is initialized to point to the same argument as the pointer
in SRC.
This macro was added in ISO C99. When building for strict
conformance to ISO C90 (`gcc -ansi'), it is not available. The
macro `__va_copy' is available as a GNU extension in any standards
mode; before GCC 3.0, it was the only macro for this functionality.
If you want to use `va_copy' and be portable to pre-C99 systems, you
should always be prepared for the possibility that this macro will not
be available. On architectures where a simple assignment is invalid,
hopefully `va_copy' _will_ be available, so one should always write
something like this if concerned about pre-C99 portability:
{
va_list ap, save;
...
#ifdef va_copy
va_copy (save, ap);
#else
save = ap;
#endif
...
}

File: libc.info, Node: Variadic Example, Prev: How Variadic, Up: Variadic Functions
A.2.3 Example of a Variadic Function
------------------------------------
Here is a complete sample function that accepts a variable number of
arguments. The first argument to the function is the count of remaining
arguments, which are added up and the result returned. While trivial,
this function is sufficient to illustrate how to use the variable
arguments facility.
#include <stdarg.h>
#include <stdio.h>
int
add_em_up (int count,...)
{
va_list ap;
int i, sum;
va_start (ap, count); /* Initialize the argument list. */
sum = 0;
for (i = 0; i < count; i++)
sum += va_arg (ap, int); /* Get the next argument value. */
va_end (ap); /* Clean up. */
return sum;
}
int
main (void)
{
/* This call prints 16. */
printf ("%d\n", add_em_up (3, 5, 5, 6));
/* This call prints 55. */
printf ("%d\n", add_em_up (10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
return 0;
}

File: libc.info, Node: Null Pointer Constant, Next: Important Data Types, Prev: Variadic Functions, Up: Language Features
A.3 Null Pointer Constant
=========================
The null pointer constant is guaranteed not to point to any real object.
You can assign it to any pointer variable since it has type `void *'.
The preferred way to write a null pointer constant is with `NULL'.
-- Macro: void * NULL
This is a null pointer constant.
You can also use `0' or `(void *)0' as a null pointer constant, but
using `NULL' is cleaner because it makes the purpose of the constant
more evident.
If you use the null pointer constant as a function argument, then for
complete portability you should make sure that the function has a
prototype declaration. Otherwise, if the target machine has two
different pointer representations, the compiler won't know which
representation to use for that argument. You can avoid the problem by
explicitly casting the constant to the proper pointer type, but we
recommend instead adding a prototype for the function you are calling.

File: libc.info, Node: Important Data Types, Next: Data Type Measurements, Prev: Null Pointer Constant, Up: Language Features
A.4 Important Data Types
========================
The result of subtracting two pointers in C is always an integer, but
the precise data type varies from C compiler to C compiler. Likewise,
the data type of the result of `sizeof' also varies between compilers.
ISO defines standard aliases for these two types, so you can refer to
them in a portable fashion. They are defined in the header file
`stddef.h'.
-- Data Type: ptrdiff_t
This is the signed integer type of the result of subtracting two
pointers. For example, with the declaration `char *p1, *p2;', the
expression `p2 - p1' is of type `ptrdiff_t'. This will probably
be one of the standard signed integer types (`short int', `int' or
`long int'), but might be a nonstandard type that exists only for
this purpose.
-- Data Type: size_t
This is an unsigned integer type used to represent the sizes of
objects. The result of the `sizeof' operator is of this type, and
functions such as `malloc' (*note Unconstrained Allocation::) and
`memcpy' (*note Copying and Concatenation::) accept arguments of
this type to specify object sizes. On systems using the GNU C
Library, this will be `unsigned int' or `unsigned long int'.
*Usage Note:* `size_t' is the preferred way to declare any
arguments or variables that hold the size of an object.
*Compatibility Note:* Implementations of C before the advent of
ISO C generally used `unsigned int' for representing object sizes and
`int' for pointer subtraction results. They did not necessarily define
either `size_t' or `ptrdiff_t'. Unix systems did define `size_t', in
`sys/types.h', but the definition was usually a signed type.

File: libc.info, Node: Data Type Measurements, Prev: Important Data Types, Up: Language Features
A.5 Data Type Measurements
==========================
Most of the time, if you choose the proper C data type for each object
in your program, you need not be concerned with just how it is
represented or how many bits it uses. When you do need such
information, the C language itself does not provide a way to get it.
The header files `limits.h' and `float.h' contain macros which give you
this information in full detail.
* Menu:
* Width of Type:: How many bits does an integer type hold?
* Range of Type:: What are the largest and smallest values
that an integer type can hold?
* Floating Type Macros:: Parameters that measure the floating point types.
* Structure Measurement:: Getting measurements on structure types.

File: libc.info, Node: Width of Type, Next: Range of Type, Up: Data Type Measurements
A.5.1 Computing the Width of an Integer Data Type
-------------------------------------------------
The most common reason that a program needs to know how many bits are in
an integer type is for using an array of `long int' as a bit vector.
You can access the bit at index N with
vector[N / LONGBITS] & (1 << (N % LONGBITS))
provided you define `LONGBITS' as the number of bits in a `long int'.
There is no operator in the C language that can give you the number
of bits in an integer data type. But you can compute it from the macro
`CHAR_BIT', defined in the header file `limits.h'.
`CHAR_BIT'
This is the number of bits in a `char'--eight, on most systems.
The value has type `int'.
You can compute the number of bits in any data type TYPE like this:
sizeof (TYPE) * CHAR_BIT

File: libc.info, Node: Range of Type, Next: Floating Type Macros, Prev: Width of Type, Up: Data Type Measurements
A.5.2 Range of an Integer Type
------------------------------
Suppose you need to store an integer value which can range from zero to
one million. Which is the smallest type you can use? There is no
general rule; it depends on the C compiler and target machine. You can
use the `MIN' and `MAX' macros in `limits.h' to determine which type
will work.
Each signed integer type has a pair of macros which give the smallest
and largest values that it can hold. Each unsigned integer type has one
such macro, for the maximum value; the minimum value is, of course,
zero.
The values of these macros are all integer constant expressions. The
`MAX' and `MIN' macros for `char' and `short int' types have values of
type `int'. The `MAX' and `MIN' macros for the other types have values
of the same type described by the macro--thus, `ULONG_MAX' has type
`unsigned long int'.
`SCHAR_MIN'
This is the minimum value that can be represented by a
`signed char'.
`SCHAR_MAX'
`UCHAR_MAX'
These are the maximum values that can be represented by a
`signed char' and `unsigned char', respectively.
`CHAR_MIN'
This is the minimum value that can be represented by a `char'.
It's equal to `SCHAR_MIN' if `char' is signed, or zero otherwise.
`CHAR_MAX'
This is the maximum value that can be represented by a `char'.
It's equal to `SCHAR_MAX' if `char' is signed, or `UCHAR_MAX'
otherwise.
`SHRT_MIN'
This is the minimum value that can be represented by a
`signed short int'. On most machines that the GNU C Library runs
on, `short' integers are 16-bit quantities.
`SHRT_MAX'
`USHRT_MAX'
These are the maximum values that can be represented by a
`signed short int' and `unsigned short int', respectively.
`INT_MIN'
This is the minimum value that can be represented by a
`signed int'. On most machines that the GNU C Library runs on, an
`int' is a 32-bit quantity.
`INT_MAX'
`UINT_MAX'
These are the maximum values that can be represented by,
respectively, the type `signed int' and the type `unsigned int'.
`LONG_MIN'
This is the minimum value that can be represented by a
`signed long int'. On most machines that the GNU C Library runs
on, `long' integers are 32-bit quantities, the same size as `int'.
`LONG_MAX'
`ULONG_MAX'
These are the maximum values that can be represented by a
`signed long int' and `unsigned long int', respectively.
`LLONG_MIN'
This is the minimum value that can be represented by a
`signed long long int'. On most machines that the GNU C Library
runs on, `long long' integers are 64-bit quantities.
`LLONG_MAX'
`ULLONG_MAX'
These are the maximum values that can be represented by a `signed
long long int' and `unsigned long long int', respectively.
`LONG_LONG_MIN'
`LONG_LONG_MAX'
`ULONG_LONG_MAX'
These are obsolete names for `LLONG_MIN', `LLONG_MAX', and
`ULLONG_MAX'. They are only available if `_GNU_SOURCE' is defined
(*note Feature Test Macros::). In GCC versions prior to 3.0,
these were the only names available.
`WCHAR_MAX'
This is the maximum value that can be represented by a `wchar_t'.
*Note Extended Char Intro::.
The header file `limits.h' also defines some additional constants
that parameterize various operating system and file system limits.
These constants are described in *note System Configuration::.

File: libc.info, Node: Floating Type Macros, Next: Structure Measurement, Prev: Range of Type, Up: Data Type Measurements
A.5.3 Floating Type Macros
--------------------------
The specific representation of floating point numbers varies from
machine to machine. Because floating point numbers are represented
internally as approximate quantities, algorithms for manipulating
floating point data often need to take account of the precise details of
the machine's floating point representation.
Some of the functions in the C library itself need this information;
for example, the algorithms for printing and reading floating point
numbers (*note I/O on Streams::) and for calculating trigonometric and
irrational functions (*note Mathematics::) use it to avoid round-off
error and loss of accuracy. User programs that implement numerical
analysis techniques also often need this information in order to
minimize or compute error bounds.
The header file `float.h' describes the format used by your machine.
* Menu:
* Floating Point Concepts:: Definitions of terminology.
* Floating Point Parameters:: Details of specific macros.
* IEEE Floating Point:: The measurements for one common
representation.

File: libc.info, Node: Floating Point Concepts, Next: Floating Point Parameters, Up: Floating Type Macros
A.5.3.1 Floating Point Representation Concepts
..............................................
This section introduces the terminology for describing floating point
representations.
You are probably already familiar with most of these concepts in
terms of scientific or exponential notation for floating point numbers.
For example, the number `123456.0' could be expressed in exponential
notation as `1.23456e+05', a shorthand notation indicating that the
mantissa `1.23456' is multiplied by the base `10' raised to power `5'.
More formally, the internal representation of a floating point number
can be characterized in terms of the following parameters:
* The "sign" is either `-1' or `1'.
* The "base" or "radix" for exponentiation, an integer greater than
`1'. This is a constant for a particular representation.
* The "exponent" to which the base is raised. The upper and lower
bounds of the exponent value are constants for a particular
representation.
Sometimes, in the actual bits representing the floating point
number, the exponent is "biased" by adding a constant to it, to
make it always be represented as an unsigned quantity. This is
only important if you have some reason to pick apart the bit
fields making up the floating point number by hand, which is
something for which the GNU C Library provides no support. So
this is ignored in the discussion that follows.
* The "mantissa" or "significand" is an unsigned integer which is a
part of each floating point number.
* The "precision" of the mantissa. If the base of the representation
is B, then the precision is the number of base-B digits in the
mantissa. This is a constant for a particular representation.
Many floating point representations have an implicit "hidden bit"
in the mantissa. This is a bit which is present virtually in the
mantissa, but not stored in memory because its value is always 1
in a normalized number. The precision figure (see above) includes
any hidden bits.
Again, the GNU C Library provides no facilities for dealing with
such low-level aspects of the representation.
The mantissa of a floating point number represents an implicit
fraction whose denominator is the base raised to the power of the
precision. Since the largest representable mantissa is one less than
this denominator, the value of the fraction is always strictly less
than `1'. The mathematical value of a floating point number is then
the product of this fraction, the sign, and the base raised to the
exponent.
We say that the floating point number is "normalized" if the
fraction is at least `1/B', where B is the base. In other words, the
mantissa would be too large to fit if it were multiplied by the base.
Non-normalized numbers are sometimes called "denormal"; they contain
less precision than the representation normally can hold.
If the number is not normalized, then you can subtract `1' from the
exponent while multiplying the mantissa by the base, and get another
floating point number with the same value. "Normalization" consists of
doing this repeatedly until the number is normalized. Two distinct
normalized floating point numbers cannot be equal in value.
(There is an exception to this rule: if the mantissa is zero, it is
considered normalized. Another exception happens on certain machines
where the exponent is as small as the representation can hold. Then it
is impossible to subtract `1' from the exponent, so a number may be
normalized even if its fraction is less than `1/B'.)

File: libc.info, Node: Floating Point Parameters, Next: IEEE Floating Point, Prev: Floating Point Concepts, Up: Floating Type Macros
A.5.3.2 Floating Point Parameters
.................................
These macro definitions can be accessed by including the header file
`float.h' in your program.
Macro names starting with `FLT_' refer to the `float' type, while
names beginning with `DBL_' refer to the `double' type and names
beginning with `LDBL_' refer to the `long double' type. (If GCC does
not support `long double' as a distinct data type on a target machine
then the values for the `LDBL_' constants are equal to the
corresponding constants for the `double' type.)
Of these macros, only `FLT_RADIX' is guaranteed to be a constant
expression. The other macros listed here cannot be reliably used in
places that require constant expressions, such as `#if' preprocessing
directives or in the dimensions of static arrays.
Although the ISO C standard specifies minimum and maximum values for
most of these parameters, the GNU C implementation uses whatever values
describe the floating point representation of the target machine. So in
principle GNU C actually satisfies the ISO C requirements only if the
target machine is suitable. In practice, all the machines currently
supported are suitable.
`FLT_ROUNDS'
This value characterizes the rounding mode for floating point
addition. The following values indicate standard rounding modes:
`-1'
The mode is indeterminable.
`0'
Rounding is towards zero.
`1'
Rounding is to the nearest number.
`2'
Rounding is towards positive infinity.
`3'
Rounding is towards negative infinity.
Any other value represents a machine-dependent nonstandard rounding
mode.
On most machines, the value is `1', in accordance with the IEEE
standard for floating point.
Here is a table showing how certain values round for each possible
value of `FLT_ROUNDS', if the other aspects of the representation
match the IEEE single-precision standard.
0 1 2 3
1.00000003 1.0 1.0 1.00000012 1.0
1.00000007 1.0 1.00000012 1.00000012 1.0
-1.00000003 -1.0 -1.0 -1.0 -1.00000012
-1.00000007 -1.0 -1.00000012 -1.0 -1.00000012
`FLT_RADIX'
This is the value of the base, or radix, of the exponent
representation. This is guaranteed to be a constant expression,
unlike the other macros described in this section. The value is 2
on all machines we know of except the IBM 360 and derivatives.
`FLT_MANT_DIG'
This is the number of base-`FLT_RADIX' digits in the floating point
mantissa for the `float' data type. The following expression
yields `1.0' (even though mathematically it should not) due to the
limited number of mantissa digits:
float radix = FLT_RADIX;
1.0f + 1.0f / radix / radix / ... / radix
where `radix' appears `FLT_MANT_DIG' times.
`DBL_MANT_DIG'
`LDBL_MANT_DIG'
This is the number of base-`FLT_RADIX' digits in the floating point
mantissa for the data types `double' and `long double',
respectively.
`FLT_DIG'
This is the number of decimal digits of precision for the `float'
data type. Technically, if P and B are the precision and base
(respectively) for the representation, then the decimal precision
Q is the maximum number of decimal digits such that any floating
point number with Q base 10 digits can be rounded to a floating
point number with P base B digits and back again, without change
to the Q decimal digits.
The value of this macro is supposed to be at least `6', to satisfy
ISO C.
`DBL_DIG'
`LDBL_DIG'
These are similar to `FLT_DIG', but for the data types `double'
and `long double', respectively. The values of these macros are
supposed to be at least `10'.
`FLT_MIN_EXP'
This is the smallest possible exponent value for type `float'.
More precisely, is the minimum negative integer such that the value
`FLT_RADIX' raised to this power minus 1 can be represented as a
normalized floating point number of type `float'.
`DBL_MIN_EXP'
`LDBL_MIN_EXP'
These are similar to `FLT_MIN_EXP', but for the data types
`double' and `long double', respectively.
`FLT_MIN_10_EXP'
This is the minimum negative integer such that `10' raised to this
power minus 1 can be represented as a normalized floating point
number of type `float'. This is supposed to be `-37' or even less.
`DBL_MIN_10_EXP'
`LDBL_MIN_10_EXP'
These are similar to `FLT_MIN_10_EXP', but for the data types
`double' and `long double', respectively.
`FLT_MAX_EXP'
This is the largest possible exponent value for type `float'. More
precisely, this is the maximum positive integer such that value
`FLT_RADIX' raised to this power minus 1 can be represented as a
floating point number of type `float'.
`DBL_MAX_EXP'
`LDBL_MAX_EXP'
These are similar to `FLT_MAX_EXP', but for the data types
`double' and `long double', respectively.
`FLT_MAX_10_EXP'
This is the maximum positive integer such that `10' raised to this
power minus 1 can be represented as a normalized floating point
number of type `float'. This is supposed to be at least `37'.
`DBL_MAX_10_EXP'
`LDBL_MAX_10_EXP'
These are similar to `FLT_MAX_10_EXP', but for the data types
`double' and `long double', respectively.
`FLT_MAX'
The value of this macro is the maximum number representable in type
`float'. It is supposed to be at least `1E+37'. The value has
type `float'.
The smallest representable number is `- FLT_MAX'.
`DBL_MAX'
`LDBL_MAX'
These are similar to `FLT_MAX', but for the data types `double'
and `long double', respectively. The type of the macro's value is
the same as the type it describes.
`FLT_MIN'
The value of this macro is the minimum normalized positive floating
point number that is representable in type `float'. It is supposed
to be no more than `1E-37'.
`DBL_MIN'
`LDBL_MIN'
These are similar to `FLT_MIN', but for the data types `double'
and `long double', respectively. The type of the macro's value is
the same as the type it describes.
`FLT_EPSILON'
This is the difference between 1 and the smallest floating point
number of type `float' that is greater than 1. It's supposed to
be no greater than `1E-5'.
`DBL_EPSILON'
`LDBL_EPSILON'
These are similar to `FLT_EPSILON', but for the data types
`double' and `long double', respectively. The type of the macro's
value is the same as the type it describes. The values are not
supposed to be greater than `1E-9'.

File: libc.info, Node: IEEE Floating Point, Prev: Floating Point Parameters, Up: Floating Type Macros
A.5.3.3 IEEE Floating Point
...........................
Here is an example showing how the floating type measurements come out
for the most common floating point representation, specified by the
`IEEE Standard for Binary Floating Point Arithmetic (ANSI/IEEE Std
754-1985)'. Nearly all computers designed since the 1980s use this
format.
The IEEE single-precision float representation uses a base of 2.
There is a sign bit, a mantissa with 23 bits plus one hidden bit (so
the total precision is 24 base-2 digits), and an 8-bit exponent that
can represent values in the range -125 to 128, inclusive.
So, for an implementation that uses this representation for the
`float' data type, appropriate values for the corresponding parameters
are:
FLT_RADIX 2
FLT_MANT_DIG 24
FLT_DIG 6
FLT_MIN_EXP -125
FLT_MIN_10_EXP -37
FLT_MAX_EXP 128
FLT_MAX_10_EXP +38
FLT_MIN 1.17549435E-38F
FLT_MAX 3.40282347E+38F
FLT_EPSILON 1.19209290E-07F
Here are the values for the `double' data type:
DBL_MANT_DIG 53
DBL_DIG 15
DBL_MIN_EXP -1021
DBL_MIN_10_EXP -307
DBL_MAX_EXP 1024
DBL_MAX_10_EXP 308
DBL_MAX 1.7976931348623157E+308
DBL_MIN 2.2250738585072014E-308
DBL_EPSILON 2.2204460492503131E-016

File: libc.info, Node: Structure Measurement, Prev: Floating Type Macros, Up: Data Type Measurements
A.5.4 Structure Field Offset Measurement
----------------------------------------
You can use `offsetof' to measure the location within a structure type
of a particular structure member.
-- Macro: size_t offsetof (TYPE, MEMBER)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
This expands to an integer constant expression that is the offset
of the structure member named MEMBER in the structure type TYPE.
For example, `offsetof (struct s, elem)' is the offset, in bytes,
of the member `elem' in a `struct s'.
This macro won't work if MEMBER is a bit field; you get an error
from the C compiler in that case.