This is ‘The GNU C Library Reference Manual’, for version 2.36.

   Copyright © 1993–2022 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.”

* 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.
* CHAR_BIT: (libc)Width of Type.
* CHILD_MAX: (libc)General Limits.
* CIGNORE: (libc)Control Modes.
* CLK_TCK: (libc)Processor Time.
* CLOCAL: (libc)Control Modes.
* CLOCKS_PER_SEC: (libc)CPU Time.
* CLOCK_MONOTONIC: (libc)Getting the Time.
* CLOCK_REALTIME: (libc)Getting the Time.
* COLL_WEIGHTS_MAX: (libc)Utility Limits.
* CPU_CLR: (libc)CPU Affinity.
* CPU_FEATURE_ACTIVE: (libc)X86.
* CPU_FEATURE_PRESENT: (libc)X86.
* 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.
* DLFO_EH_SEGMENT_TYPE: (libc)Dynamic Linker Introspection.
* DLFO_STRUCT_HAS_EH_COUNT: (libc)Dynamic Linker Introspection.
* DLFO_STRUCT_HAS_EH_DBASE: (libc)Dynamic Linker Introspection.
* 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.
* FE_SNANS_ALWAYS_SIGNAL: (libc)Infinity and NaN.
* 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.
* FP_LLOGB0: (libc)Exponents and Logarithms.
* FP_LLOGBNAN: (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_OFD_GETLK: (libc)Open File Description Locks.
* F_OFD_SETLK: (libc)Open File Description Locks.
* F_OFD_SETLKW: (libc)Open File Description Locks.
* 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.
* HUGE_VAL_FN: (libc)Math Error Reporting.
* HUGE_VAL_FNx: (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_DIRECTORY: (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_NOFOLLOW: (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_PATH: (libc)Access Modes.
* 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_TMPFILE: (libc)Open-time Flags.
* 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.
* PTHREAD_ATTR_NO_SIGMASK_NP: (libc)Initial Thread Signal Mask.
* P_tmpdir: (libc)Temporary Files.
* RAND_MAX: (libc)ISO Random.
* RE_DUP_MAX: (libc)General Limits.
* RLIM_INFINITY: (libc)Limits on Resources.
* RSEQ_SIG: (libc)Restartable Sequences.
* 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.
* SNAN: (libc)Infinity and NaN.
* SNANF: (libc)Infinity and NaN.
* SNANFN: (libc)Infinity and NaN.
* SNANFNx: (libc)Infinity and NaN.
* SNANL: (libc)Infinity and NaN.
* 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.
* 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.
* _Fork: (libc)Creating a Process.
* _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_high: (libc)PowerPC.
* __ppc_set_ppr_med_low: (libc)PowerPC.
* __ppc_set_ppr_very_low: (libc)PowerPC.
* __ppc_yield: (libc)PowerPC.
* __riscv_flush_icache: (libc)RISC-V.
* __va_copy: (libc)Argument Macros.
* __x86_get_cpuid_feature_leaf: (libc)X86.
* _dl_find_object: (libc)Dynamic Linker Introspection.
* _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.
* acosfN: (libc)Inverse Trig Functions.
* acosfNx: (libc)Inverse Trig Functions.
* acosh: (libc)Hyperbolic Functions.
* acoshf: (libc)Hyperbolic Functions.
* acoshfN: (libc)Hyperbolic Functions.
* acoshfNx: (libc)Hyperbolic Functions.
* acoshl: (libc)Hyperbolic Functions.
* acosl: (libc)Inverse Trig Functions.
* addmntent: (libc)mtab.
* addseverity: (libc)Adding Severity Classes.
* adjtime: (libc)Setting and Adjusting the Time.
* adjtimex: (libc)Setting and Adjusting the Time.
* 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.
* arc4random: (libc)High Quality Random.
* arc4random_buf: (libc)High Quality Random.
* arc4random_uniform: (libc)High Quality Random.
* 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.
* asinfN: (libc)Inverse Trig Functions.
* asinfNx: (libc)Inverse Trig Functions.
* asinh: (libc)Hyperbolic Functions.
* asinhf: (libc)Hyperbolic Functions.
* asinhfN: (libc)Hyperbolic Functions.
* asinhfNx: (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.
* atan2fN: (libc)Inverse Trig Functions.
* atan2fNx: (libc)Inverse Trig Functions.
* atan2l: (libc)Inverse Trig Functions.
* atan: (libc)Inverse Trig Functions.
* atanf: (libc)Inverse Trig Functions.
* atanfN: (libc)Inverse Trig Functions.
* atanfNx: (libc)Inverse Trig Functions.
* atanh: (libc)Hyperbolic Functions.
* atanhf: (libc)Hyperbolic Functions.
* atanhfN: (libc)Hyperbolic Functions.
* atanhfNx: (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 Strings and Arrays.
* 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 Strings and Arrays.
* cabs: (libc)Absolute Value.
* cabsf: (libc)Absolute Value.
* cabsfN: (libc)Absolute Value.
* cabsfNx: (libc)Absolute Value.
* cabsl: (libc)Absolute Value.
* cacos: (libc)Inverse Trig Functions.
* cacosf: (libc)Inverse Trig Functions.
* cacosfN: (libc)Inverse Trig Functions.
* cacosfNx: (libc)Inverse Trig Functions.
* cacosh: (libc)Hyperbolic Functions.
* cacoshf: (libc)Hyperbolic Functions.
* cacoshfN: (libc)Hyperbolic Functions.
* cacoshfNx: (libc)Hyperbolic Functions.
* cacoshl: (libc)Hyperbolic Functions.
* cacosl: (libc)Inverse Trig Functions.
* call_once: (libc)Call Once.
* calloc: (libc)Allocating Cleared Space.
* canonicalize: (libc)FP Bit Twiddling.
* canonicalize_file_name: (libc)Symbolic Links.
* canonicalizef: (libc)FP Bit Twiddling.
* canonicalizefN: (libc)FP Bit Twiddling.
* canonicalizefNx: (libc)FP Bit Twiddling.
* canonicalizel: (libc)FP Bit Twiddling.
* carg: (libc)Operations on Complex.
* cargf: (libc)Operations on Complex.
* cargfN: (libc)Operations on Complex.
* cargfNx: (libc)Operations on Complex.
* cargl: (libc)Operations on Complex.
* casin: (libc)Inverse Trig Functions.
* casinf: (libc)Inverse Trig Functions.
* casinfN: (libc)Inverse Trig Functions.
* casinfNx: (libc)Inverse Trig Functions.
* casinh: (libc)Hyperbolic Functions.
* casinhf: (libc)Hyperbolic Functions.
* casinhfN: (libc)Hyperbolic Functions.
* casinhfNx: (libc)Hyperbolic Functions.
* casinhl: (libc)Hyperbolic Functions.
* casinl: (libc)Inverse Trig Functions.
* catan: (libc)Inverse Trig Functions.
* catanf: (libc)Inverse Trig Functions.
* catanfN: (libc)Inverse Trig Functions.
* catanfNx: (libc)Inverse Trig Functions.
* catanh: (libc)Hyperbolic Functions.
* catanhf: (libc)Hyperbolic Functions.
* catanhfN: (libc)Hyperbolic Functions.
* catanhfNx: (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.
* cbrt: (libc)Exponents and Logarithms.
* cbrtf: (libc)Exponents and Logarithms.
* cbrtfN: (libc)Exponents and Logarithms.
* cbrtfNx: (libc)Exponents and Logarithms.
* cbrtl: (libc)Exponents and Logarithms.
* ccos: (libc)Trig Functions.
* ccosf: (libc)Trig Functions.
* ccosfN: (libc)Trig Functions.
* ccosfNx: (libc)Trig Functions.
* ccosh: (libc)Hyperbolic Functions.
* ccoshf: (libc)Hyperbolic Functions.
* ccoshfN: (libc)Hyperbolic Functions.
* ccoshfNx: (libc)Hyperbolic Functions.
* ccoshl: (libc)Hyperbolic Functions.
* ccosl: (libc)Trig Functions.
* ceil: (libc)Rounding Functions.
* ceilf: (libc)Rounding Functions.
* ceilfN: (libc)Rounding Functions.
* ceilfNx: (libc)Rounding Functions.
* ceill: (libc)Rounding Functions.
* cexp: (libc)Exponents and Logarithms.
* cexpf: (libc)Exponents and Logarithms.
* cexpfN: (libc)Exponents and Logarithms.
* cexpfNx: (libc)Exponents and Logarithms.
* cexpl: (libc)Exponents and Logarithms.
* cfgetispeed: (libc)Line Speed.
* cfgetospeed: (libc)Line Speed.
* cfmakeraw: (libc)Noncanonical Input.
* 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.
* cimagfN: (libc)Operations on Complex.
* cimagfNx: (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.
* clock_getres: (libc)Getting the Time.
* clock_gettime: (libc)Getting the Time.
* clock_settime: (libc)Setting and Adjusting the Time.
* clog10: (libc)Exponents and Logarithms.
* clog10f: (libc)Exponents and Logarithms.
* clog10fN: (libc)Exponents and Logarithms.
* clog10fNx: (libc)Exponents and Logarithms.
* clog10l: (libc)Exponents and Logarithms.
* clog: (libc)Exponents and Logarithms.
* clogf: (libc)Exponents and Logarithms.
* clogfN: (libc)Exponents and Logarithms.
* clogfNx: (libc)Exponents and Logarithms.
* clogl: (libc)Exponents and Logarithms.
* close: (libc)Opening and Closing Files.
* close_range: (libc)Opening and Closing Files.
* closedir: (libc)Reading/Closing Directory.
* closefrom: (libc)Opening and Closing Files.
* closelog: (libc)closelog.
* cnd_broadcast: (libc)ISO C Condition Variables.
* cnd_destroy: (libc)ISO C Condition Variables.
* cnd_init: (libc)ISO C Condition Variables.
* cnd_signal: (libc)ISO C Condition Variables.
* cnd_timedwait: (libc)ISO C Condition Variables.
* cnd_wait: (libc)ISO C Condition Variables.
* confstr: (libc)String Parameters.
* conj: (libc)Operations on Complex.
* conjf: (libc)Operations on Complex.
* conjfN: (libc)Operations on Complex.
* conjfNx: (libc)Operations on Complex.
* conjl: (libc)Operations on Complex.
* connect: (libc)Connecting.
* copy_file_range: (libc)Copying File Data.
* copysign: (libc)FP Bit Twiddling.
* copysignf: (libc)FP Bit Twiddling.
* copysignfN: (libc)FP Bit Twiddling.
* copysignfNx: (libc)FP Bit Twiddling.
* copysignl: (libc)FP Bit Twiddling.
* cos: (libc)Trig Functions.
* cosf: (libc)Trig Functions.
* cosfN: (libc)Trig Functions.
* cosfNx: (libc)Trig Functions.
* cosh: (libc)Hyperbolic Functions.
* coshf: (libc)Hyperbolic Functions.
* coshfN: (libc)Hyperbolic Functions.
* coshfNx: (libc)Hyperbolic Functions.
* coshl: (libc)Hyperbolic Functions.
* cosl: (libc)Trig Functions.
* cpow: (libc)Exponents and Logarithms.
* cpowf: (libc)Exponents and Logarithms.
* cpowfN: (libc)Exponents and Logarithms.
* cpowfNx: (libc)Exponents and Logarithms.
* cpowl: (libc)Exponents and Logarithms.
* cproj: (libc)Operations on Complex.
* cprojf: (libc)Operations on Complex.
* cprojfN: (libc)Operations on Complex.
* cprojfNx: (libc)Operations on Complex.
* cprojl: (libc)Operations on Complex.
* creal: (libc)Operations on Complex.
* crealf: (libc)Operations on Complex.
* crealfN: (libc)Operations on Complex.
* crealfNx: (libc)Operations on Complex.
* creall: (libc)Operations on Complex.
* creat64: (libc)Opening and Closing Files.
* creat: (libc)Opening and Closing Files.
* crypt: (libc)Passphrase Storage.
* crypt_r: (libc)Passphrase Storage.
* csin: (libc)Trig Functions.
* csinf: (libc)Trig Functions.
* csinfN: (libc)Trig Functions.
* csinfNx: (libc)Trig Functions.
* csinh: (libc)Hyperbolic Functions.
* csinhf: (libc)Hyperbolic Functions.
* csinhfN: (libc)Hyperbolic Functions.
* csinhfNx: (libc)Hyperbolic Functions.
* csinhl: (libc)Hyperbolic Functions.
* csinl: (libc)Trig Functions.
* csqrt: (libc)Exponents and Logarithms.
* csqrtf: (libc)Exponents and Logarithms.
* csqrtfN: (libc)Exponents and Logarithms.
* csqrtfNx: (libc)Exponents and Logarithms.
* csqrtl: (libc)Exponents and Logarithms.
* ctan: (libc)Trig Functions.
* ctanf: (libc)Trig Functions.
* ctanfN: (libc)Trig Functions.
* ctanfNx: (libc)Trig Functions.
* ctanh: (libc)Hyperbolic Functions.
* ctanhf: (libc)Hyperbolic Functions.
* ctanhfN: (libc)Hyperbolic Functions.
* ctanhfNx: (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.
* daddl: (libc)Misc FP Arithmetic.
* dcgettext: (libc)Translation with gettext.
* dcngettext: (libc)Advanced gettext functions.
* ddivl: (libc)Misc FP Arithmetic.
* dfmal: (libc)Misc FP Arithmetic.
* dgettext: (libc)Translation with gettext.
* difftime: (libc)Calculating Elapsed Time.
* dirfd: (libc)Opening a Directory.
* dirname: (libc)Finding Tokens in a String.
* div: (libc)Integer Division.
* dlinfo: (libc)Dynamic Linker Introspection.
* dmull: (libc)Misc FP Arithmetic.
* 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.
* dsqrtl: (libc)Misc FP Arithmetic.
* dsubl: (libc)Misc FP Arithmetic.
* dup2: (libc)Duplicating Descriptors.
* dup: (libc)Duplicating Descriptors.
* ecvt: (libc)System V Number Conversion.
* ecvt_r: (libc)System V Number Conversion.
* 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_remove: (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.
* erfcfN: (libc)Special Functions.
* erfcfNx: (libc)Special Functions.
* erfcl: (libc)Special Functions.
* erff: (libc)Special Functions.
* erffN: (libc)Special Functions.
* erffNx: (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.
* exp10fN: (libc)Exponents and Logarithms.
* exp10fNx: (libc)Exponents and Logarithms.
* exp10l: (libc)Exponents and Logarithms.
* exp2: (libc)Exponents and Logarithms.
* exp2f: (libc)Exponents and Logarithms.
* exp2fN: (libc)Exponents and Logarithms.
* exp2fNx: (libc)Exponents and Logarithms.
* exp2l: (libc)Exponents and Logarithms.
* exp: (libc)Exponents and Logarithms.
* expf: (libc)Exponents and Logarithms.
* expfN: (libc)Exponents and Logarithms.
* expfNx: (libc)Exponents and Logarithms.
* expl: (libc)Exponents and Logarithms.
* explicit_bzero: (libc)Erasing Sensitive Data.
* expm1: (libc)Exponents and Logarithms.
* expm1f: (libc)Exponents and Logarithms.
* expm1fN: (libc)Exponents and Logarithms.
* expm1fNx: (libc)Exponents and Logarithms.
* expm1l: (libc)Exponents and Logarithms.
* fMaddfN: (libc)Misc FP Arithmetic.
* fMaddfNx: (libc)Misc FP Arithmetic.
* fMdivfN: (libc)Misc FP Arithmetic.
* fMdivfNx: (libc)Misc FP Arithmetic.
* fMfmafN: (libc)Misc FP Arithmetic.
* fMfmafNx: (libc)Misc FP Arithmetic.
* fMmulfN: (libc)Misc FP Arithmetic.
* fMmulfNx: (libc)Misc FP Arithmetic.
* fMsqrtfN: (libc)Misc FP Arithmetic.
* fMsqrtfNx: (libc)Misc FP Arithmetic.
* fMsubfN: (libc)Misc FP Arithmetic.
* fMsubfNx: (libc)Misc FP Arithmetic.
* fMxaddfN: (libc)Misc FP Arithmetic.
* fMxaddfNx: (libc)Misc FP Arithmetic.
* fMxdivfN: (libc)Misc FP Arithmetic.
* fMxdivfNx: (libc)Misc FP Arithmetic.
* fMxfmafN: (libc)Misc FP Arithmetic.
* fMxfmafNx: (libc)Misc FP Arithmetic.
* fMxmulfN: (libc)Misc FP Arithmetic.
* fMxmulfNx: (libc)Misc FP Arithmetic.
* fMxsqrtfN: (libc)Misc FP Arithmetic.
* fMxsqrtfNx: (libc)Misc FP Arithmetic.
* fMxsubfN: (libc)Misc FP Arithmetic.
* fMxsubfNx: (libc)Misc FP Arithmetic.
* fabs: (libc)Absolute Value.
* fabsf: (libc)Absolute Value.
* fabsfN: (libc)Absolute Value.
* fabsfNx: (libc)Absolute Value.
* fabsl: (libc)Absolute Value.
* fadd: (libc)Misc FP Arithmetic.
* faddl: (libc)Misc FP Arithmetic.
* 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.
* fdimfN: (libc)Misc FP Arithmetic.
* fdimfNx: (libc)Misc FP Arithmetic.
* fdiml: (libc)Misc FP Arithmetic.
* fdiv: (libc)Misc FP Arithmetic.
* fdivl: (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.
* fegetmode: (libc)Control Functions.
* 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.
* fesetexcept: (libc)Status bit operations.
* fesetexceptflag: (libc)Status bit operations.
* fesetmode: (libc)Control Functions.
* fesetround: (libc)Rounding.
* fetestexcept: (libc)Status bit operations.
* fetestexceptflag: (libc)Status bit operations.
* feupdateenv: (libc)Control Functions.
* fexecve: (libc)Executing a File.
* fflush: (libc)Flushing Buffers.
* fflush_unlocked: (libc)Flushing Buffers.
* ffma: (libc)Misc FP Arithmetic.
* ffmal: (libc)Misc FP Arithmetic.
* 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.
* floorfN: (libc)Rounding Functions.
* floorfNx: (libc)Rounding Functions.
* floorl: (libc)Rounding Functions.
* fma: (libc)Misc FP Arithmetic.
* fmaf: (libc)Misc FP Arithmetic.
* fmafN: (libc)Misc FP Arithmetic.
* fmafNx: (libc)Misc FP Arithmetic.
* fmal: (libc)Misc FP Arithmetic.
* fmax: (libc)Misc FP Arithmetic.
* fmaxf: (libc)Misc FP Arithmetic.
* fmaxfN: (libc)Misc FP Arithmetic.
* fmaxfNx: (libc)Misc FP Arithmetic.
* fmaximum: (libc)Misc FP Arithmetic.
* fmaximum_mag: (libc)Misc FP Arithmetic.
* fmaximum_mag_num: (libc)Misc FP Arithmetic.
* fmaximum_mag_numf: (libc)Misc FP Arithmetic.
* fmaximum_mag_numfN: (libc)Misc FP Arithmetic.
* fmaximum_mag_numfNx: (libc)Misc FP Arithmetic.
* fmaximum_mag_numl: (libc)Misc FP Arithmetic.
* fmaximum_magf: (libc)Misc FP Arithmetic.
* fmaximum_magfN: (libc)Misc FP Arithmetic.
* fmaximum_magfNx: (libc)Misc FP Arithmetic.
* fmaximum_magl: (libc)Misc FP Arithmetic.
* fmaximum_num: (libc)Misc FP Arithmetic.
* fmaximum_numf: (libc)Misc FP Arithmetic.
* fmaximum_numfN: (libc)Misc FP Arithmetic.
* fmaximum_numfNx: (libc)Misc FP Arithmetic.
* fmaximum_numl: (libc)Misc FP Arithmetic.
* fmaximumf: (libc)Misc FP Arithmetic.
* fmaximumfN: (libc)Misc FP Arithmetic.
* fmaximumfNx: (libc)Misc FP Arithmetic.
* fmaximuml: (libc)Misc FP Arithmetic.
* fmaxl: (libc)Misc FP Arithmetic.
* fmaxmag: (libc)Misc FP Arithmetic.
* fmaxmagf: (libc)Misc FP Arithmetic.
* fmaxmagfN: (libc)Misc FP Arithmetic.
* fmaxmagfNx: (libc)Misc FP Arithmetic.
* fmaxmagl: (libc)Misc FP Arithmetic.
* fmemopen: (libc)String Streams.
* fmin: (libc)Misc FP Arithmetic.
* fminf: (libc)Misc FP Arithmetic.
* fminfN: (libc)Misc FP Arithmetic.
* fminfNx: (libc)Misc FP Arithmetic.
* fminimum: (libc)Misc FP Arithmetic.
* fminimum_mag: (libc)Misc FP Arithmetic.
* fminimum_mag_num: (libc)Misc FP Arithmetic.
* fminimum_mag_numf: (libc)Misc FP Arithmetic.
* fminimum_mag_numfN: (libc)Misc FP Arithmetic.
* fminimum_mag_numfNx: (libc)Misc FP Arithmetic.
* fminimum_mag_numl: (libc)Misc FP Arithmetic.
* fminimum_magf: (libc)Misc FP Arithmetic.
* fminimum_magfN: (libc)Misc FP Arithmetic.
* fminimum_magfNx: (libc)Misc FP Arithmetic.
* fminimum_magl: (libc)Misc FP Arithmetic.
* fminimum_num: (libc)Misc FP Arithmetic.
* fminimum_numf: (libc)Misc FP Arithmetic.
* fminimum_numfN: (libc)Misc FP Arithmetic.
* fminimum_numfNx: (libc)Misc FP Arithmetic.
* fminimum_numl: (libc)Misc FP Arithmetic.
* fminimumf: (libc)Misc FP Arithmetic.
* fminimumfN: (libc)Misc FP Arithmetic.
* fminimumfNx: (libc)Misc FP Arithmetic.
* fminimuml: (libc)Misc FP Arithmetic.
* fminl: (libc)Misc FP Arithmetic.
* fminmag: (libc)Misc FP Arithmetic.
* fminmagf: (libc)Misc FP Arithmetic.
* fminmagfN: (libc)Misc FP Arithmetic.
* fminmagfNx: (libc)Misc FP Arithmetic.
* fminmagl: (libc)Misc FP Arithmetic.
* fmod: (libc)Remainder Functions.
* fmodf: (libc)Remainder Functions.
* fmodfN: (libc)Remainder Functions.
* fmodfNx: (libc)Remainder Functions.
* fmodl: (libc)Remainder Functions.
* fmtmsg: (libc)Printing Formatted Messages.
* fmul: (libc)Misc FP Arithmetic.
* fmull: (libc)Misc FP Arithmetic.
* 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.
* frexpfN: (libc)Normalization Functions.
* frexpfNx: (libc)Normalization Functions.
* frexpl: (libc)Normalization Functions.
* fromfp: (libc)Rounding Functions.
* fromfpf: (libc)Rounding Functions.
* fromfpfN: (libc)Rounding Functions.
* fromfpfNx: (libc)Rounding Functions.
* fromfpl: (libc)Rounding Functions.
* fromfpx: (libc)Rounding Functions.
* fromfpxf: (libc)Rounding Functions.
* fromfpxfN: (libc)Rounding Functions.
* fromfpxfNx: (libc)Rounding Functions.
* fromfpxl: (libc)Rounding 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.
* fsqrt: (libc)Misc FP Arithmetic.
* fsqrtl: (libc)Misc FP Arithmetic.
* fstat64: (libc)Reading Attributes.
* fstat: (libc)Reading Attributes.
* fsub: (libc)Misc FP Arithmetic.
* fsubl: (libc)Misc FP Arithmetic.
* 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.
* getcpu: (libc)CPU Affinity.
* getcwd: (libc)Working Directory.
* getdate: (libc)General Time String Parsing.
* getdate_r: (libc)General Time String Parsing.
* getdelim: (libc)Line Input.
* getdents64: (libc)Low-level Directory Access.
* getdomainnname: (libc)Host Identification.
* getegid: (libc)Reading Persona.
* getentropy: (libc)Unpredictable Bytes.
* 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.
* getpayload: (libc)FP Bit Twiddling.
* getpayloadf: (libc)FP Bit Twiddling.
* getpayloadfN: (libc)FP Bit Twiddling.
* getpayloadfNx: (libc)FP Bit Twiddling.
* getpayloadl: (libc)FP Bit Twiddling.
* 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.
* getrandom: (libc)Unpredictable Bytes.
* 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.
* gettid: (libc)Process Identification.
* gettimeofday: (libc)Getting the Time.
* 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.
* hypotfN: (libc)Exponents and Logarithms.
* hypotfNx: (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.
* ilogbfN: (libc)Exponents and Logarithms.
* ilogbfNx: (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.
* iscanonical: (libc)Floating Point Classes.
* iscntrl: (libc)Classification of Characters.
* isdigit: (libc)Classification of Characters.
* iseqsig: (libc)FP Comparison Functions.
* 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.
* issubnormal: (libc)Floating Point Classes.
* 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.
* iszero: (libc)Floating Point Classes.
* j0: (libc)Special Functions.
* j0f: (libc)Special Functions.
* j0fN: (libc)Special Functions.
* j0fNx: (libc)Special Functions.
* j0l: (libc)Special Functions.
* j1: (libc)Special Functions.
* j1f: (libc)Special Functions.
* j1fN: (libc)Special Functions.
* j1fNx: (libc)Special Functions.
* j1l: (libc)Special Functions.
* jn: (libc)Special Functions.
* jnf: (libc)Special Functions.
* jnfN: (libc)Special Functions.
* jnfNx: (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.
* ldexpfN: (libc)Normalization Functions.
* ldexpfNx: (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.
* lgammafN: (libc)Special Functions.
* lgammafN_r: (libc)Special Functions.
* lgammafNx: (libc)Special Functions.
* lgammafNx_r: (libc)Special Functions.
* lgammaf_r: (libc)Special Functions.
* lgammal: (libc)Special Functions.
* lgammal_r: (libc)Special Functions.
* link: (libc)Hard Links.
* linkat: (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.
* llogb: (libc)Exponents and Logarithms.
* llogbf: (libc)Exponents and Logarithms.
* llogbfN: (libc)Exponents and Logarithms.
* llogbfNx: (libc)Exponents and Logarithms.
* llogbl: (libc)Exponents and Logarithms.
* llrint: (libc)Rounding Functions.
* llrintf: (libc)Rounding Functions.
* llrintfN: (libc)Rounding Functions.
* llrintfNx: (libc)Rounding Functions.
* llrintl: (libc)Rounding Functions.
* llround: (libc)Rounding Functions.
* llroundf: (libc)Rounding Functions.
* llroundfN: (libc)Rounding Functions.
* llroundfNx: (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.
* log10fN: (libc)Exponents and Logarithms.
* log10fNx: (libc)Exponents and Logarithms.
* log10l: (libc)Exponents and Logarithms.
* log1p: (libc)Exponents and Logarithms.
* log1pf: (libc)Exponents and Logarithms.
* log1pfN: (libc)Exponents and Logarithms.
* log1pfNx: (libc)Exponents and Logarithms.
* log1pl: (libc)Exponents and Logarithms.
* log2: (libc)Exponents and Logarithms.
* log2f: (libc)Exponents and Logarithms.
* log2fN: (libc)Exponents and Logarithms.
* log2fNx: (libc)Exponents and Logarithms.
* log2l: (libc)Exponents and Logarithms.
* log: (libc)Exponents and Logarithms.
* logb: (libc)Exponents and Logarithms.
* logbf: (libc)Exponents and Logarithms.
* logbfN: (libc)Exponents and Logarithms.
* logbfNx: (libc)Exponents and Logarithms.
* logbl: (libc)Exponents and Logarithms.
* logf: (libc)Exponents and Logarithms.
* logfN: (libc)Exponents and Logarithms.
* logfNx: (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.
* lrintfN: (libc)Rounding Functions.
* lrintfNx: (libc)Rounding Functions.
* lrintl: (libc)Rounding Functions.
* lround: (libc)Rounding Functions.
* lroundf: (libc)Rounding Functions.
* lroundfN: (libc)Rounding Functions.
* lroundfNx: (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.
* mallinfo2: (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 Strings and Arrays.
* memchr: (libc)Search Functions.
* memcmp: (libc)String/Array Comparison.
* memcpy: (libc)Copying Strings and Arrays.
* memfd_create: (libc)Memory-mapped I/O.
* memfrob: (libc)Obfuscating Data.
* memmem: (libc)Search Functions.
* memmove: (libc)Copying Strings and Arrays.
* mempcpy: (libc)Copying Strings and Arrays.
* memrchr: (libc)Search Functions.
* memset: (libc)Copying Strings and Arrays.
* 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.
* mlock2: (libc)Page Lock Functions.
* 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.
* modffN: (libc)Rounding Functions.
* modffNx: (libc)Rounding Functions.
* modfl: (libc)Rounding Functions.
* mount: (libc)Mount-Unmount-Remount.
* mprobe: (libc)Heap Consistency Checking.
* mprotect: (libc)Memory Protection.
* 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.
* mtx_destroy: (libc)ISO C Mutexes.
* mtx_init: (libc)ISO C Mutexes.
* mtx_lock: (libc)ISO C Mutexes.
* mtx_timedlock: (libc)ISO C Mutexes.
* mtx_trylock: (libc)ISO C Mutexes.
* mtx_unlock: (libc)ISO C Mutexes.
* 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.
* nanfN: (libc)FP Bit Twiddling.
* nanfNx: (libc)FP Bit Twiddling.
* nanl: (libc)FP Bit Twiddling.
* nanosleep: (libc)Sleeping.
* nearbyint: (libc)Rounding Functions.
* nearbyintf: (libc)Rounding Functions.
* nearbyintfN: (libc)Rounding Functions.
* nearbyintfNx: (libc)Rounding Functions.
* nearbyintl: (libc)Rounding Functions.
* nextafter: (libc)FP Bit Twiddling.
* nextafterf: (libc)FP Bit Twiddling.
* nextafterfN: (libc)FP Bit Twiddling.
* nextafterfNx: (libc)FP Bit Twiddling.
* nextafterl: (libc)FP Bit Twiddling.
* nextdown: (libc)FP Bit Twiddling.
* nextdownf: (libc)FP Bit Twiddling.
* nextdownfN: (libc)FP Bit Twiddling.
* nextdownfNx: (libc)FP Bit Twiddling.
* nextdownl: (libc)FP Bit Twiddling.
* nexttoward: (libc)FP Bit Twiddling.
* nexttowardf: (libc)FP Bit Twiddling.
* nexttowardl: (libc)FP Bit Twiddling.
* nextup: (libc)FP Bit Twiddling.
* nextupf: (libc)FP Bit Twiddling.
* nextupfN: (libc)FP Bit Twiddling.
* nextupfNx: (libc)FP Bit Twiddling.
* nextupl: (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)Setting and Adjusting the Time.
* ntp_gettime: (libc)Setting and Adjusting the Time.
* 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.
* pkey_alloc: (libc)Memory Protection.
* pkey_free: (libc)Memory Protection.
* pkey_get: (libc)Memory Protection.
* pkey_mprotect: (libc)Memory Protection.
* pkey_set: (libc)Memory Protection.
* popen: (libc)Pipe to a Subprocess.
* posix_fallocate64: (libc)Storage Allocation.
* posix_fallocate: (libc)Storage Allocation.
* posix_memalign: (libc)Aligned Memory Blocks.
* pow: (libc)Exponents and Logarithms.
* powf: (libc)Exponents and Logarithms.
* powfN: (libc)Exponents and Logarithms.
* powfNx: (libc)Exponents and Logarithms.
* powl: (libc)Exponents and Logarithms.
* pread64: (libc)I/O Primitives.
* pread: (libc)I/O Primitives.
* preadv2: (libc)Scatter-Gather.
* preadv64: (libc)Scatter-Gather.
* preadv64v2: (libc)Scatter-Gather.
* preadv: (libc)Scatter-Gather.
* printf: (libc)Formatted Output Functions.
* printf_size: (libc)Predefined Printf Handlers.
* printf_size_info: (libc)Predefined Printf Handlers.
* psignal: (libc)Signal Messages.
* pthread_attr_getsigmask_np: (libc)Initial Thread Signal Mask.
* pthread_attr_setsigmask_np: (libc)Initial Thread Signal Mask.
* pthread_clockjoin_np: (libc)Waiting with Explicit Clocks.
* pthread_cond_clockwait: (libc)Waiting with Explicit Clocks.
* 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_rwlock_clockrdlock: (libc)Waiting with Explicit Clocks.
* pthread_rwlock_clockwrlock: (libc)Waiting with Explicit Clocks.
* pthread_setattr_default_np: (libc)Default Thread Attributes.
* pthread_setspecific: (libc)Thread-specific Data.
* pthread_timedjoin_np: (libc)Waiting with Explicit Clocks.
* pthread_tryjoin_np: (libc)Waiting with Explicit Clocks.
* 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.
* pwritev2: (libc)Scatter-Gather.
* pwritev64: (libc)Scatter-Gather.
* pwritev64v2: (libc)Scatter-Gather.
* pwritev: (libc)Scatter-Gather.
* 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.
* reallocarray: (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.
* remainderfN: (libc)Remainder Functions.
* remainderfNx: (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.
* rintfN: (libc)Rounding Functions.
* rintfNx: (libc)Rounding Functions.
* rintl: (libc)Rounding Functions.
* rmdir: (libc)Deleting Files.
* round: (libc)Rounding Functions.
* roundeven: (libc)Rounding Functions.
* roundevenf: (libc)Rounding Functions.
* roundevenfN: (libc)Rounding Functions.
* roundevenfNx: (libc)Rounding Functions.
* roundevenl: (libc)Rounding Functions.
* roundf: (libc)Rounding Functions.
* roundfN: (libc)Rounding Functions.
* roundfNx: (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.
* scalblnfN: (libc)Normalization Functions.
* scalblnfNx: (libc)Normalization Functions.
* scalblnl: (libc)Normalization Functions.
* scalbn: (libc)Normalization Functions.
* scalbnf: (libc)Normalization Functions.
* scalbnfN: (libc)Normalization Functions.
* scalbnfNx: (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.
* sem_clockwait: (libc)Waiting with Explicit Clocks.
* sem_close: (libc)Semaphores.
* sem_destroy: (libc)Semaphores.
* sem_getvalue: (libc)Semaphores.
* sem_init: (libc)Semaphores.
* sem_open: (libc)Semaphores.
* sem_post: (libc)Semaphores.
* sem_timedwait: (libc)Semaphores.
* sem_trywait: (libc)Semaphores.
* sem_unlink: (libc)Semaphores.
* sem_wait: (libc)Semaphores.
* semctl: (libc)Semaphores.
* semget: (libc)Semaphores.
* semop: (libc)Semaphores.
* semtimedop: (libc)Semaphores.
* 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.
* setlinebuf: (libc)Controlling Buffering.
* setlocale: (libc)Setting the Locale.
* setlogmask: (libc)setlogmask.
* setmntent: (libc)mtab.
* setnetent: (libc)Networks Database.
* setnetgrent: (libc)Lookup Netgroup.
* setpayload: (libc)FP Bit Twiddling.
* setpayloadf: (libc)FP Bit Twiddling.
* setpayloadfN: (libc)FP Bit Twiddling.
* setpayloadfNx: (libc)FP Bit Twiddling.
* setpayloadl: (libc)FP Bit Twiddling.
* setpayloadsig: (libc)FP Bit Twiddling.
* setpayloadsigf: (libc)FP Bit Twiddling.
* setpayloadsigfN: (libc)FP Bit Twiddling.
* setpayloadsigfNx: (libc)FP Bit Twiddling.
* setpayloadsigl: (libc)FP Bit Twiddling.
* 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)Setting and Adjusting the Time.
* 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.
* sigabbrev_np: (libc)Signal Messages.
* sigaction: (libc)Advanced Signal Handling.
* sigaddset: (libc)Signal Sets.
* sigaltstack: (libc)Signal Stack.
* sigblock: (libc)BSD Signal Handling.
* sigdelset: (libc)Signal Sets.
* sigdescr_np: (libc)Signal Messages.
* sigemptyset: (libc)Signal Sets.
* sigfillset: (libc)Signal Sets.
* siginterrupt: (libc)BSD Signal Handling.
* sigismember: (libc)Signal Sets.
* siglongjmp: (libc)Non-Local Exits and Signals.
* sigmask: (libc)BSD Signal Handling.
* signal: (libc)Basic Signal Handling.
* signbit: (libc)FP Bit Twiddling.
* significand: (libc)Normalization Functions.
* significandf: (libc)Normalization Functions.
* significandl: (libc)Normalization Functions.
* sigpause: (libc)BSD Signal Handling.
* sigpending: (libc)Checking for Pending Signals.
* sigprocmask: (libc)Process Signal Mask.
* sigsetjmp: (libc)Non-Local Exits and Signals.
* sigsetmask: (libc)BSD Signal Handling.
* sigstack: (libc)Signal Stack.
* sigsuspend: (libc)Sigsuspend.
* sin: (libc)Trig Functions.
* sincos: (libc)Trig Functions.
* sincosf: (libc)Trig Functions.
* sincosfN: (libc)Trig Functions.
* sincosfNx: (libc)Trig Functions.
* sincosl: (libc)Trig Functions.
* sinf: (libc)Trig Functions.
* sinfN: (libc)Trig Functions.
* sinfNx: (libc)Trig Functions.
* sinh: (libc)Hyperbolic Functions.
* sinhf: (libc)Hyperbolic Functions.
* sinhfN: (libc)Hyperbolic Functions.
* sinhfNx: (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.
* sqrtfN: (libc)Exponents and Logarithms.
* sqrtfNx: (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)Setting and Adjusting the Time.
* stpcpy: (libc)Copying Strings and Arrays.
* stpncpy: (libc)Truncating Strings.
* strcasecmp: (libc)String/Array Comparison.
* strcasestr: (libc)Search Functions.
* strcat: (libc)Concatenating Strings.
* strchr: (libc)Search Functions.
* strchrnul: (libc)Search Functions.
* strcmp: (libc)String/Array Comparison.
* strcoll: (libc)Collation Functions.
* strcpy: (libc)Copying Strings and Arrays.
* strcspn: (libc)Search Functions.
* strdup: (libc)Copying Strings and Arrays.
* strdupa: (libc)Copying Strings and Arrays.
* strerror: (libc)Error Messages.
* strerror_r: (libc)Error Messages.
* strerrordesc_np: (libc)Error Messages.
* strerrorname_np: (libc)Error Messages.
* strfmon: (libc)Formatting Numbers.
* strfromd: (libc)Printing of Floats.
* strfromf: (libc)Printing of Floats.
* strfromfN: (libc)Printing of Floats.
* strfromfNx: (libc)Printing of Floats.
* strfroml: (libc)Printing of Floats.
* strfry: (libc)Shuffling Bytes.
* strftime: (libc)Formatting Calendar Time.
* strlen: (libc)String Length.
* strncasecmp: (libc)String/Array Comparison.
* strncat: (libc)Truncating Strings.
* strncmp: (libc)String/Array Comparison.
* strncpy: (libc)Truncating Strings.
* strndup: (libc)Truncating Strings.
* strndupa: (libc)Truncating Strings.
* 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.
* strtofN: (libc)Parsing of Floats.
* strtofNx: (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.
* syslog: (libc)syslog; vsyslog.
* system: (libc)Running a Command.
* sysv_signal: (libc)Basic Signal Handling.
* tan: (libc)Trig Functions.
* tanf: (libc)Trig Functions.
* tanfN: (libc)Trig Functions.
* tanfNx: (libc)Trig Functions.
* tanh: (libc)Hyperbolic Functions.
* tanhf: (libc)Hyperbolic Functions.
* tanhfN: (libc)Hyperbolic Functions.
* tanhfNx: (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.
* tgammafN: (libc)Special Functions.
* tgammafNx: (libc)Special Functions.
* tgammal: (libc)Special Functions.
* tgkill: (libc)Signaling Another Process.
* thrd_create: (libc)ISO C Thread Management.
* thrd_current: (libc)ISO C Thread Management.
* thrd_detach: (libc)ISO C Thread Management.
* thrd_equal: (libc)ISO C Thread Management.
* thrd_exit: (libc)ISO C Thread Management.
* thrd_join: (libc)ISO C Thread Management.
* thrd_sleep: (libc)ISO C Thread Management.
* thrd_yield: (libc)ISO C Thread Management.
* time: (libc)Getting the 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.
* totalorder: (libc)FP Comparison Functions.
* totalorderf: (libc)FP Comparison Functions.
* totalorderfN: (libc)FP Comparison Functions.
* totalorderfNx: (libc)FP Comparison Functions.
* totalorderl: (libc)FP Comparison Functions.
* totalordermag: (libc)FP Comparison Functions.
* totalordermagf: (libc)FP Comparison Functions.
* totalordermagfN: (libc)FP Comparison Functions.
* totalordermagfNx: (libc)FP Comparison Functions.
* totalordermagl: (libc)FP Comparison Functions.
* 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.
* truncfN: (libc)Rounding Functions.
* truncfNx: (libc)Rounding Functions.
* truncl: (libc)Rounding Functions.
* tsearch: (libc)Tree Search Function.
* tss_create: (libc)ISO C Thread-local Storage.
* tss_delete: (libc)ISO C Thread-local Storage.
* tss_get: (libc)ISO C Thread-local Storage.
* tss_set: (libc)ISO C Thread-local Storage.
* ttyname: (libc)Is It a Terminal.
* ttyname_r: (libc)Is It a Terminal.
* twalk: (libc)Tree Search Function.
* twalk_r: (libc)Tree Search Function.
* tzset: (libc)Time Zone Functions.
* ufromfp: (libc)Rounding Functions.
* ufromfpf: (libc)Rounding Functions.
* ufromfpfN: (libc)Rounding Functions.
* ufromfpfNx: (libc)Rounding Functions.
* ufromfpl: (libc)Rounding Functions.
* ufromfpx: (libc)Rounding Functions.
* ufromfpxf: (libc)Rounding Functions.
* ufromfpxfN: (libc)Rounding Functions.
* ufromfpxfNx: (libc)Rounding Functions.
* ufromfpxl: (libc)Rounding 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.
* 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 Strings and Arrays.
* wcpncpy: (libc)Truncating Strings.
* wcrtomb: (libc)Converting a Character.
* wcscasecmp: (libc)String/Array Comparison.
* wcscat: (libc)Concatenating Strings.
* wcschr: (libc)Search Functions.
* wcschrnul: (libc)Search Functions.
* wcscmp: (libc)String/Array Comparison.
* wcscoll: (libc)Collation Functions.
* wcscpy: (libc)Copying Strings and Arrays.
* wcscspn: (libc)Search Functions.
* wcsdup: (libc)Copying Strings and Arrays.
* wcsftime: (libc)Formatting Calendar Time.
* wcslen: (libc)String Length.
* wcsncasecmp: (libc)String/Array Comparison.
* wcsncat: (libc)Truncating Strings.
* wcsncmp: (libc)String/Array Comparison.
* wcsncpy: (libc)Truncating Strings.
* 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.
* wcstofN: (libc)Parsing of Floats.
* wcstofNx: (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 Strings and Arrays.
* wmemmove: (libc)Copying Strings and Arrays.
* wmempcpy: (libc)Copying Strings and Arrays.
* wmemset: (libc)Copying Strings and Arrays.
* 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.
* y0fN: (libc)Special Functions.
* y0fNx: (libc)Special Functions.
* y0l: (libc)Special Functions.
* y1: (libc)Special Functions.
* y1f: (libc)Special Functions.
* y1fN: (libc)Special Functions.
* y1fNx: (libc)Special Functions.
* y1l: (libc)Special Functions.
* yn: (libc)Special Functions.
* ynf: (libc)Special Functions.
* ynfN: (libc)Special Functions.
* ynfNx: (libc)Special Functions.
* ynl: (libc)Special Functions.
END-INFO-DIR-ENTRY

30.14.1 The Data Structure for a Group
--------------------------------------

The functions and data structures for accessing the system group
database are declared in the header file ‘grp.h’.

 -- Data Type: struct group

     The ‘group’ structure is used to hold information about an entry in
     the system group database.  It has at least the following members:

     ‘char *gr_name’
          The name of the group.

     ‘gid_t gr_gid’
          The group ID of the group.

     ‘char **gr_mem’
          A vector of pointers to the names of users in the group.  Each
          user name is a null-terminated string, and the vector itself
          is terminated by a null pointer.

30.14.2 Looking Up One Group
----------------------------

You can search the group database for information about a specific group
using ‘getgrgid’ or ‘getgrnam’.  These functions are declared in
‘grp.h’.

 -- Function: struct group * getgrgid (gid_t GID)

     Preliminary: | MT-Unsafe race:grgid locale | AS-Unsafe dlopen
     plugin heap lock | AC-Unsafe corrupt lock fd mem | See POSIX Safety Concepts.

     This function returns a pointer to a statically-allocated structure
     containing information about the group whose group ID is GID.  This
     structure may be overwritten by subsequent calls to ‘getgrgid’.

     A null pointer indicates there is no group with ID GID.

 -- Function: int getgrgid_r (gid_t GID, struct group *RESULT_BUF, char
          *BUFFER, size_t BUFLEN, struct group **RESULT)

     Preliminary: | MT-Safe locale | AS-Unsafe dlopen plugin heap lock |
     AC-Unsafe corrupt lock fd mem | See POSIX Safety Concepts.

     This function is similar to ‘getgrgid’ in that it returns
     information about the group whose group ID is GID.  However, it
     fills the user supplied structure pointed to by RESULT_BUF with the
     information instead of using a static buffer.  The first BUFLEN
     bytes of the additional buffer pointed to by BUFFER are used to
     contain additional information, normally strings which are pointed
     to by the elements of the result structure.

     If a group with ID GID is found, the pointer returned in RESULT
     points to the record which contains the wanted data (i.e., RESULT
     contains the value RESULT_BUF).  If no group is found or if an
     error occurred, the pointer returned in RESULT is a null pointer.
     The function returns zero or an error code.  If the buffer BUFFER
     is too small to contain all the needed information, the error code
     ‘ERANGE’ is returned and ‘errno’ is set to ‘ERANGE’.

 -- Function: struct group * getgrnam (const char *NAME)

     Preliminary: | MT-Unsafe race:grnam locale | AS-Unsafe dlopen
     plugin heap lock | AC-Unsafe corrupt lock fd mem | See POSIX Safety Concepts.

     This function returns a pointer to a statically-allocated structure
     containing information about the group whose group name is NAME.
     This structure may be overwritten by subsequent calls to
     ‘getgrnam’.

     A null pointer indicates there is no group named NAME.

 -- Function: int getgrnam_r (const char *NAME, struct group
          *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct group
          **RESULT)

     Preliminary: | MT-Safe locale | AS-Unsafe dlopen plugin heap lock |
     AC-Unsafe corrupt lock fd mem | See POSIX Safety Concepts.

     This function is similar to ‘getgrnam’ in that it returns
     information about the group whose group name is NAME.  Like
     ‘getgrgid_r’, it uses the user supplied buffers in RESULT_BUF and
     BUFFER, not a static buffer.

     The return values are the same as for ‘getgrgid_r’.

30.14.3 Scanning the List of All Groups
---------------------------------------

This section explains how a program can read the list of all groups in
the system, one group at a time.  The functions described here are
declared in ‘grp.h’.

   You can use the ‘fgetgrent’ function to read group entries from a
particular file.

 -- Function: struct group * fgetgrent (FILE *STREAM)

     Preliminary: | MT-Unsafe race:fgrent | AS-Unsafe corrupt lock |
     AC-Unsafe corrupt lock | See POSIX Safety Concepts.

     The ‘fgetgrent’ function reads the next entry from STREAM.  It
     returns a pointer to the entry.  The structure is statically
     allocated and is overwritten on subsequent calls to ‘fgetgrent’.
     You must copy the contents of the structure if you wish to save the
     information.

     The stream must correspond to a file in the same format as the
     standard group database file.

 -- Function: int fgetgrent_r (FILE *STREAM, struct group *RESULT_BUF,
          char *BUFFER, size_t BUFLEN, struct group **RESULT)

     Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe corrupt lock
     | See POSIX Safety Concepts.

     This function is similar to ‘fgetgrent’ in that it reads the next
     user entry from STREAM.  But the result is returned in the
     structure pointed to by RESULT_BUF.  The first BUFLEN bytes of the
     additional buffer pointed to by BUFFER are used to contain
     additional information, normally strings which are pointed to by
     the elements of the result structure.

     This stream must correspond to a file in the same format as the
     standard group database file.

     If the function returns zero RESULT points to the structure with
     the wanted data (normally this is in RESULT_BUF).  If errors
     occurred the return value is non-zero and RESULT contains a null
     pointer.

   The way to scan all the entries in the group database is with
‘setgrent’, ‘getgrent’, and ‘endgrent’.

 -- Function: void setgrent (void)

     Preliminary: | MT-Unsafe race:grent locale | AS-Unsafe dlopen
     plugin heap lock | AC-Unsafe corrupt lock fd mem | See POSIX Safety Concepts.

     This function initializes a stream for reading from the group data
     base.  You use this stream by calling ‘getgrent’ or ‘getgrent_r’.

 -- Function: struct group * getgrent (void)

     Preliminary: | MT-Unsafe race:grent race:grentbuf locale |
     AS-Unsafe dlopen plugin heap lock | AC-Unsafe corrupt lock fd mem |
     See POSIX Safety Concepts.

     The ‘getgrent’ function reads the next entry from the stream
     initialized by ‘setgrent’.  It returns a pointer to the entry.  The
     structure is statically allocated and is overwritten on subsequent
     calls to ‘getgrent’.  You must copy the contents of the structure
     if you wish to save the information.

 -- Function: int getgrent_r (struct group *RESULT_BUF, char *BUFFER,
          size_t BUFLEN, struct group **RESULT)

     Preliminary: | MT-Unsafe race:grent locale | AS-Unsafe dlopen
     plugin heap lock | AC-Unsafe corrupt lock fd mem | See POSIX Safety Concepts.

     This function is similar to ‘getgrent’ in that it returns the next
     entry from the stream initialized by ‘setgrent’.  Like
     ‘fgetgrent_r’, it places the result in user-supplied buffers
     pointed to by RESULT_BUF and BUFFER.

     If the function returns zero RESULT contains a pointer to the data
     (normally equal to RESULT_BUF).  If errors occurred the return
     value is non-zero and RESULT contains a null pointer.

 -- Function: void endgrent (void)

     Preliminary: | MT-Unsafe race:grent locale | AS-Unsafe dlopen
     plugin heap lock | AC-Unsafe corrupt lock fd mem | See POSIX Safety Concepts.

     This function closes the internal stream used by ‘getgrent’ or
     ‘getgrent_r’.

30.15 User and Group Database Example
=====================================

Here is an example program showing the use of the system database
inquiry functions.  The program prints some information about the user
running the program.

     #include <grp.h>
     #include <pwd.h>
     #include <sys/types.h>
     #include <unistd.h>
     #include <stdlib.h>

     int
     main (void)
     {
       uid_t me;
       struct passwd *my_passwd;
       struct group *my_group;
       char **members;

       /* Get information about the user ID. */
       me = getuid ();
       my_passwd = getpwuid (me);
       if (!my_passwd)
         {
           printf ("Couldn't find out about user %d.\n", (int) me);
           exit (EXIT_FAILURE);
         }

       /* Print the information. */
       printf ("I am %s.\n", my_passwd->pw_gecos);
       printf ("My login name is %s.\n", my_passwd->pw_name);
       printf ("My uid is %d.\n", (int) (my_passwd->pw_uid));
       printf ("My home directory is %s.\n", my_passwd->pw_dir);
       printf ("My default shell is %s.\n", my_passwd->pw_shell);

       /* Get information about the default group ID. */
       my_group = getgrgid (my_passwd->pw_gid);
       if (!my_group)
         {
           printf ("Couldn't find out about group %d.\n",
                   (int) my_passwd->pw_gid);
           exit (EXIT_FAILURE);
         }

       /* Print the information. */
       printf ("My default group is %s (%d).\n",
               my_group->gr_name, (int) (my_passwd->pw_gid));
       printf ("The members of this group are:\n");
       members = my_group->gr_mem;
       while (*members)
         {
           printf ("  %s\n", *(members));
           members++;
         }

       return EXIT_SUCCESS;
     }

   Here is some output from this program:

     I am Throckmorton Snurd.
     My login name is snurd.
     My uid is 31093.
     My home directory is /home/fsg/snurd.
     My default shell is /bin/sh.
     My default group is guest (12).
     The members of this group are:
       friedman
       tami

30.16 Netgroup Database
=======================

30.16.1 Netgroup Data
---------------------

Sometimes it is useful to group users according to other criteria (see
Group Database).  E.g., it is useful to associate a certain group of
users with a certain machine.  On the other hand grouping of host names
is not supported so far.

   In Sun Microsystems’ SunOS appeared a new kind of database, the
netgroup database.  It allows grouping hosts, users, and domains freely,
giving them individual names.  To be more concrete, a netgroup is a list
of triples consisting of a host name, a user name, and a domain name
where any of the entries can be a wildcard entry matching all inputs.  A
last possibility is that names of other netgroups can also be given in
the list specifying a netgroup.  So one can construct arbitrary
hierarchies without loops.

   Sun’s implementation allows netgroups only for the ‘nis’ or ‘nisplus’
service, see Services in the NSS configuration.  The implementation
in the GNU C Library has no such restriction.  An entry in either of the
input services must have the following form:

     GROUPNAME ( GROUPNAME | (HOSTNAME,USERNAME,domainname) )+

   Any of the fields in the triple can be empty which means anything
matches.  While describing the functions we will see that the opposite
case is useful as well.  I.e., there may be entries which will not match
any input.  For entries like this, a name consisting of the single
character ‘-’ shall be used.

30.16.2 Looking up one Netgroup
-------------------------------

The lookup functions for netgroups are a bit different than all other
system database handling functions.  Since a single netgroup can contain
many entries a two-step process is needed.  First a single netgroup is
selected and then one can iterate over all entries in this netgroup.
These functions are declared in ‘netdb.h’.

 -- Function: int setnetgrent (const char *NETGROUP)

     Preliminary: | MT-Unsafe race:netgrent locale | AS-Unsafe dlopen
     plugin heap lock | AC-Unsafe corrupt lock fd mem | See POSIX Safety Concepts.

     A call to this function initializes the internal state of the
     library to allow following calls of ‘getnetgrent’ to iterate over
     all entries in the netgroup with name NETGROUP.

     When the call is successful (i.e., when a netgroup with this name
     exists) the return value is ‘1’.  When the return value is ‘0’ no
     netgroup of this name is known or some other error occurred.

   It is important to remember that there is only one single state for
iterating the netgroups.  Even if the programmer uses the
‘getnetgrent_r’ function the result is not really reentrant since always
only one single netgroup at a time can be processed.  If the program
needs to process more than one netgroup simultaneously she must protect
this by using external locking.  This problem was introduced in the
original netgroups implementation in SunOS and since we must stay
compatible it is not possible to change this.

   Some other functions also use the netgroups state.  Currently these
are the ‘innetgr’ function and parts of the implementation of the
‘compat’ service part of the NSS implementation.

 -- Function: int getnetgrent (char **HOSTP, char **USERP, char
          **DOMAINP)

     Preliminary: | MT-Unsafe race:netgrent race:netgrentbuf locale |
     AS-Unsafe dlopen plugin heap lock | AC-Unsafe corrupt lock fd mem |
     See POSIX Safety Concepts.

     This function returns the next unprocessed entry of the currently
     selected netgroup.  The string pointers, in which addresses are
     passed in the arguments HOSTP, USERP, and DOMAINP, will contain
     after a successful call pointers to appropriate strings.  If the
     string in the next entry is empty the pointer has the value ‘NULL’.
     The returned string pointers are only valid if none of the netgroup
     related functions are called.

     The return value is ‘1’ if the next entry was successfully read.  A
     value of ‘0’ means no further entries exist or internal errors
     occurred.

 -- Function: int getnetgrent_r (char **HOSTP, char **USERP, char
          **DOMAINP, char *BUFFER, size_t BUFLEN)

     Preliminary: | MT-Unsafe race:netgrent locale | AS-Unsafe dlopen
     plugin heap lock | AC-Unsafe corrupt lock fd mem | See POSIX Safety Concepts.

     This function is similar to ‘getnetgrent’ with only one exception:
     the strings the three string pointers HOSTP, USERP, and DOMAINP
     point to, are placed in the buffer of BUFLEN bytes starting at
     BUFFER.  This means the returned values are valid even after other
     netgroup related functions are called.

     The return value is ‘1’ if the next entry was successfully read and
     the buffer contains enough room to place the strings in it.  ‘0’ is
     returned in case no more entries are found, the buffer is too
     small, or internal errors occurred.

     This function is a GNU extension.  The original implementation in
     the SunOS libc does not provide this function.

 -- Function: void endnetgrent (void)

     Preliminary: | MT-Unsafe race:netgrent | AS-Unsafe dlopen plugin
     heap lock | AC-Unsafe corrupt lock fd mem | See POSIX Safety Concepts.

     This function frees all buffers which were allocated to process the
     last selected netgroup.  As a result all string pointers returned
     by calls to ‘getnetgrent’ are invalid afterwards.

30.16.3 Testing for Netgroup Membership
---------------------------------------

It is often not necessary to scan the whole netgroup since often the
only interesting question is whether a given entry is part of the
selected netgroup.

 -- Function: int innetgr (const char *NETGROUP, const char *HOST, const
          char *USER, const char *DOMAIN)

     Preliminary: | MT-Unsafe race:netgrent locale | AS-Unsafe dlopen
     plugin heap lock | AC-Unsafe corrupt lock fd mem | See POSIX Safety Concepts.

     This function tests whether the triple specified by the parameters
     HOST, USER, and DOMAIN is part of the netgroup NETGROUP.  Using
     this function has the advantage that

       1. no other netgroup function can use the global netgroup state
          since internal locking is used and
       2. the function is implemented more efficiently than successive
          calls to the other ‘set’/‘get’/‘endnetgrent’ functions.

     Any of the pointers HOST, USER, or DOMAIN can be ‘NULL’ which means
     any value is accepted in this position.  This is also true for the
     name ‘-’ which should not match any other string otherwise.

     The return value is ‘1’ if an entry matching the given triple is
     found in the netgroup.  The return value is ‘0’ if the netgroup
     itself is not found, the netgroup does not contain the triple or
     internal errors occurred.

31 System Management
********************

This chapter describes facilities for controlling the system that
underlies a process (including the operating system and hardware) and
for getting information about it.  Anyone can generally use the
informational facilities, but usually only a properly privileged process
can make changes.

   To get information on parameters of the system that are built into
the system, such as the maximum length of a filename, see System Configuration.

31.1 Host Identification
========================

This section explains how to identify the particular system on which
your program is running.  First, let’s review the various ways computer
systems are named, which is a little complicated because of the history
of the development of the Internet.

   Every Unix system (also known as a host) has a host name, whether
it’s connected to a network or not.  In its simplest form, as used
before computer networks were an issue, it’s just a word like ‘chicken’.

   But any system attached to the Internet or any network like it
conforms to a more rigorous naming convention as part of the Domain Name
System (DNS). In the DNS, every host name is composed of two parts:

  1. hostname
  2. domain name

   You will note that “hostname” looks a lot like “host name”, but is
not the same thing, and that people often incorrectly refer to entire
host names as “domain names.”

   In the DNS, the full host name is properly called the FQDN (Fully
Qualified Domain Name) and consists of the hostname, then a period, then
the domain name.  The domain name itself usually has multiple components
separated by periods.  So for example, a system’s hostname may be
‘chicken’ and its domain name might be ‘ai.mit.edu’, so its FQDN (which
is its host name) is ‘chicken.ai.mit.edu’.

   Adding to the confusion, though, is that the DNS is not the only name
space in which a computer needs to be known.  Another name space is the
NIS (aka YP) name space.  For NIS purposes, there is another domain
name, which is called the NIS domain name or the YP domain name.  It
need not have anything to do with the DNS domain name.

   Confusing things even more is the fact that in the DNS, it is
possible for multiple FQDNs to refer to the same system.  However, there
is always exactly one of them that is the true host name, and it is
called the canonical FQDN.

   In some contexts, the host name is called a “node name.”

   For more information on DNS host naming, see Host Names.

   Prototypes for these functions appear in ‘unistd.h’.

   The programs ‘hostname’, ‘hostid’, and ‘domainname’ work by calling
these functions.

 -- Function: int gethostname (char *NAME, size_t SIZE)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     This function returns the host name of the system on which it is
     called, in the array NAME.  The SIZE argument specifies the size of
     this array, in bytes.  Note that this is _not_ the DNS hostname.
     If the system participates in the DNS, this is the FQDN (see
     above).

     The return value is ‘0’ on success and ‘-1’ on failure.  In the GNU
     C Library, ‘gethostname’ fails if SIZE is not large enough; then
     you can try again with a larger array.  The following ‘errno’ error
     condition is defined for this function:

     ‘ENAMETOOLONG’
          The SIZE argument is less than the size of the host name plus
          one.

     On some systems, there is a symbol for the maximum possible host
     name length: ‘MAXHOSTNAMELEN’.  It is defined in ‘sys/param.h’.
     But you can’t count on this to exist, so it is cleaner to handle
     failure and try again.

     ‘gethostname’ stores the beginning of the host name in NAME even if
     the host name won’t entirely fit.  For some purposes, a truncated
     host name is good enough.  If it is, you can ignore the error code.

 -- Function: int sethostname (const char *NAME, size_t LENGTH)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     The ‘sethostname’ function sets the host name of the system that
     calls it to NAME, a string with length LENGTH.  Only privileged
     processes are permitted to do this.

     Usually ‘sethostname’ gets called just once, at system boot time.
     Often, the program that calls it sets it to the value it finds in
     the file ‘/etc/hostname’.

     Be sure to set the host name to the full host name, not just the
     DNS hostname (see above).

     The return value is ‘0’ on success and ‘-1’ on failure.  The
     following ‘errno’ error condition is defined for this function:

     ‘EPERM’
          This process cannot set the host name because it is not
          privileged.

 -- Function: int getdomainnname (char *NAME, size_t LENGTH)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘getdomainname’ returns the NIS (aka YP) domain name of the system
     on which it is called.  Note that this is not the more popular DNS
     domain name.  Get that with ‘gethostname’.

     The specifics of this function are analogous to ‘gethostname’,
     above.

 -- Function: int setdomainname (const char *NAME, size_t LENGTH)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘setdomainname’ sets the NIS (aka YP) domain name of the system on
     which it is called.  Note that this is not the more popular DNS
     domain name.  Set that with ‘sethostname’.

     The specifics of this function are analogous to ‘sethostname’,
     above.

 -- Function: long int gethostid (void)

     Preliminary: | MT-Safe hostid env locale | AS-Unsafe dlopen plugin
     corrupt heap lock | AC-Unsafe lock corrupt mem fd | See POSIX Safety Concepts.

     This function returns the “host ID” of the machine the program is
     running on.  By convention, this is usually the primary Internet IP
     address of that machine, converted to a ‘long int’.  However, on
     some systems it is a meaningless but unique number which is
     hard-coded for each machine.

     This is not widely used.  It arose in BSD 4.2, but was dropped in
     BSD 4.4.  It is not required by POSIX.

     The proper way to query the IP address is to use ‘gethostbyname’ on
     the results of ‘gethostname’.  For more information on IP
     addresses, see Host Addresses.

 -- Function: int sethostid (long int ID)

     Preliminary: | MT-Unsafe const:hostid | AS-Unsafe | AC-Unsafe
     corrupt fd | See POSIX Safety Concepts.

     The ‘sethostid’ function sets the “host ID” of the host machine to
     ID.  Only privileged processes are permitted to do this.  Usually
     it happens just once, at system boot time.

     The proper way to establish the primary IP address of a system is
     to configure the IP address resolver to associate that IP address
     with the system’s host name as returned by ‘gethostname’.  For
     example, put a record for the system in ‘/etc/hosts’.

     See ‘gethostid’ above for more information on host ids.

     The return value is ‘0’ on success and ‘-1’ on failure.  The
     following ‘errno’ error conditions are defined for this function:

     ‘EPERM’
          This process cannot set the host name because it is not
          privileged.

     ‘ENOSYS’
          The operating system does not support setting the host ID. On
          some systems, the host ID is a meaningless but unique number
          hard-coded for each machine.

31.2 Platform Type Identification
=================================

You can use the ‘uname’ function to find out some information about the
type of computer your program is running on.  This function and the
associated data type are declared in the header file ‘sys/utsname.h’.

   As a bonus, ‘uname’ also gives some information identifying the
particular system your program is running on.  This is the same
information which you can get with functions targeted to this purpose
described in Host Identification.

 -- Data Type: struct utsname

     The ‘utsname’ structure is used to hold information returned by the
     ‘uname’ function.  It has the following members:

     ‘char sysname[]’
          This is the name of the operating system in use.

     ‘char release[]’
          This is the current release level of the operating system
          implementation.

     ‘char version[]’
          This is the current version level within the release of the
          operating system.

     ‘char machine[]’
          This is a description of the type of hardware that is in use.

          Some systems provide a mechanism to interrogate the kernel
          directly for this information.  On systems without such a
          mechanism, the GNU C Library fills in this field based on the
          configuration name that was specified when building and
          installing the library.

          GNU uses a three-part name to describe a system configuration;
          the three parts are CPU, MANUFACTURER and SYSTEM-TYPE, and
          they are separated with dashes.  Any possible combination of
          three names is potentially meaningful, but most such
          combinations are meaningless in practice and even the
          meaningful ones are not necessarily supported by any
          particular GNU program.

          Since the value in ‘machine’ is supposed to describe just the
          hardware, it consists of the first two parts of the
          configuration name: ‘CPU-MANUFACTURER’.  For example, it might
          be one of these:

               ‘"sparc-sun"’, ‘"i386-ANYTHING"’, ‘"m68k-hp"’,
               ‘"m68k-sony"’, ‘"m68k-sun"’, ‘"mips-dec"’

     ‘char nodename[]’
          This is the host name of this particular computer.  In the GNU
          C Library, the value is the same as that returned by
          ‘gethostname’; see Host Identification.

          ‘gethostname’ is implemented with a call to ‘uname’.

     ‘char domainname[]’
          This is the NIS or YP domain name.  It is the same value
          returned by ‘getdomainname’; see Host Identification.
          This element is a relatively recent invention and use of it is
          not as portable as use of the rest of the structure.

 -- Function: int uname (struct utsname *INFO)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     The ‘uname’ function fills in the structure pointed to by INFO with
     information about the operating system and host machine.  A
     non-negative return value indicates that the data was successfully
     stored.

     ‘-1’ as the return value indicates an error.  The only error
     possible is ‘EFAULT’, which we normally don’t mention as it is
     always a possibility.

31.3 Controlling and Querying Mounts
====================================

All files are in filesystems, and before you can access any file, its
filesystem must be mounted.  Because of Unix’s concept of _Everything is
a file_, mounting of filesystems is central to doing almost anything.
This section explains how to find out what filesystems are currently
mounted and what filesystems are available for mounting, and how to
change what is mounted.

   The classic filesystem is the contents of a disk drive.  The concept
is considerably more abstract, though, and lots of things other than
disk drives can be mounted.

   Some block devices don’t correspond to traditional devices like disk
drives.  For example, a loop device is a block device whose driver uses
a regular file in another filesystem as its medium.  So if that regular
file contains appropriate data for a filesystem, you can by mounting the
loop device essentially mount a regular file.

   Some filesystems aren’t based on a device of any kind.  The “proc”
filesystem, for example, contains files whose data is made up by the
filesystem driver on the fly whenever you ask for it.  And when you
write to it, the data you write causes changes in the system.  No data
gets stored.

31.3.1 Mount Information
------------------------

For some programs it is desirable and necessary to access information
about whether a certain filesystem is mounted and, if it is, where, or
simply to get lists of all the available filesystems.  The GNU C Library
provides some functions to retrieve this information portably.

   Traditionally Unix systems have a file named ‘/etc/fstab’ which
describes all possibly mounted filesystems.  The ‘mount’ program uses
this file to mount at startup time of the system all the necessary
filesystems.  The information about all the filesystems actually mounted
is normally kept in a file named either ‘/var/run/mtab’ or ‘/etc/mtab’.
Both files share the same syntax and it is crucial that this syntax is
followed all the time.  Therefore it is best to never directly write to
the files.  The functions described in this section can do this and they
also provide the functionality to convert the external textual
representation to the internal representation.

   Note that the ‘fstab’ and ‘mtab’ files are maintained on a system by
_convention_.  It is possible for the files not to exist or not to be
consistent with what is really mounted or available to mount, if the
system’s administration policy allows it.  But programs that mount and
unmount filesystems typically maintain and use these files as described
herein.

   The filenames given above should never be used directly.  The
portable way to handle these files is to use the macros ‘_PATH_FSTAB’,
defined in ‘fstab.h’, or ‘_PATH_MNTTAB’, defined in ‘mntent.h’ and
‘paths.h’, for ‘fstab’; and the macro ‘_PATH_MOUNTED’, also defined in
‘mntent.h’ and ‘paths.h’, for ‘mtab’.  There are also two alternate
macro names ‘FSTAB’, ‘MNTTAB’, and ‘MOUNTED’ defined but these names are
deprecated and kept only for backward compatibility.  The names
‘_PATH_MNTTAB’ and ‘_PATH_MOUNTED’ should always be used.

31.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
          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 filesystem gets mounted with read and write enabled.
          ‘FSTAB_RQ’
               The filesystem 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 values 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 | See 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 | See 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 | See 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 | See 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 | See 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.

31.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_r’,
     ‘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
               sometimes 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’ (see 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’
               Expands 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 (see
               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.  Besides 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 | See 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’ (see 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
     handle 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 | See 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 | See POSIX Safety Concepts.

     The ‘getmntent’ function takes as the parameter a file handle
     previously returned by a 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 names
     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 | See 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-Safe race:stream locale | AS-Unsafe corrupt |
     AC-Unsafe corrupt | See 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 described 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 | See 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.

31.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.

31.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.  See 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 | See 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 with
     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.

     ‘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", "iso9660", 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.  See 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 writing.

     ‘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 | See 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 | See 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.

32 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 (see String Parameters).

32.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.  See 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.  See 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; see
     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; see Limits on Resources.

 -- Macro: int STREAM_MAX

     If defined, the unvarying maximum number of streams that a single
     process can have open simultaneously.  See Opening Streams.

 -- Macro: int TZNAME_MAX

     If defined, the unvarying maximum length of a time zone name.
     See 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 (see 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 (see 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.

32.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 are 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.  See 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.  See
     Job Control.  Systems conforming to the 2001 revision of POSIX,
     or newer, will always define this symbol.

 -- 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.  See 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.
See 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.

32.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)’.

32.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’.

32.4.1 Definition of ‘sysconf’
------------------------------

 -- Function: long int sysconf (int PARAMETER)

     Preliminary: | MT-Safe env | AS-Unsafe lock heap | AC-Unsafe lock
     mem fd | See 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.

32.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; see 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 about 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 about 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 (see 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’; see Cleanups on Exit.

‘_SC_LEVEL1_ICACHE_SIZE’

     Inquire about the size of the Level 1 instruction cache.

‘_SC_LEVEL1_ICACHE_ASSOC’

     Inquire about the associativity of the Level 1 instruction cache.

‘_SC_LEVEL1_ICACHE_LINESIZE’

     Inquire about the line length of the Level 1 instruction cache.

     On aarch64, the cache line size returned is the minimum instruction
     cache line size observable by userspace.  This is typically the
     same as the L1 icache size but on some cores it may not be so.
     However, it is specified in the architecture that operations such
     as cache line invalidation are consistent with the size reported
     with this variable.

‘_SC_LEVEL1_DCACHE_SIZE’

     Inquire about the size of the Level 1 data cache.

‘_SC_LEVEL1_DCACHE_ASSOC’

     Inquire about the associativity of the Level 1 data cache.

‘_SC_LEVEL1_DCACHE_LINESIZE’

     Inquire about the line length of the Level 1 data cache.

     On aarch64, the cache line size returned is the minimum data cache
     line size observable by userspace.  This is typically the same as
     the L1 dcache size but on some cores it may not be so.  However, it
     is specified in the architecture that operations such as cache line
     invalidation are consistent with the size reported with this
     variable.

‘_SC_LEVEL2_CACHE_SIZE’

     Inquire about the size of the Level 2 cache.

‘_SC_LEVEL2_CACHE_ASSOC’

     Inquire about the associativity of the Level 2 cache.

‘_SC_LEVEL2_CACHE_LINESIZE’

     Inquire about the line length of the Level 2 cache.

‘_SC_LEVEL3_CACHE_SIZE’

     Inquire about the size of the Level 3 cache.

‘_SC_LEVEL3_CACHE_ASSOC’

     Inquire about the associativity of the Level 3 cache.

‘_SC_LEVEL3_CACHE_LINESIZE’

     Inquire about the line length of the Level 3 cache.

‘_SC_LEVEL4_CACHE_SIZE’

     Inquire about the size of the Level 4 cache.

‘_SC_LEVEL4_CACHE_ASSOC’

     Inquire about the associativity of the Level 4 cache.

‘_SC_LEVEL4_CACHE_LINESIZE’

     Inquire about the line length of the Level 4 cache.

‘_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’.  The
     GNU C Library no longer implements the ‘_XOPEN_CRYPT’ extensions,
     so ‘sysconf (_SC_XOPEN_CRYPT)’ always returns ‘-1’.

‘_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 about 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’.

‘_SC_MINSIGSTKSZ’

     Inquire about the minimum number of bytes of free stack space
     required in order to guarantee successful, non-nested handling of a
     single signal whose handler is an empty function.

‘_SC_SIGSTKSZ’

     Inquire about the suggested minimum number of bytes of stack space
     required for a signal stack.

     This is not guaranteed to be enough for any specific purpose other
     than the invocation of a single, non-nested, empty handler, but
     nonetheless should be enough for basic scenarios involving simple
     signal handlers and very low levels of signal nesting (say, 2 or 3
     levels at the very most).

     This value is provided for developer convenience and to ease
     migration from the legacy ‘SIGSTKSZ’ constant.  Programs requiring
     stronger guarantees should avoid using it if at all possible.

32.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
     }

32.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’.

32.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.  See 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.  See File Minimums.

 -- Macro: int LINK_MAX

     The uniform system limit (if any) for the number of names for a
     given file.  See 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.  See Canonical or Not.

 -- Macro: int MAX_INPUT

     The uniform system limit (if any) for the total number of
     characters typed ahead as input.  See 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.  See 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 (see Memory Allocation) instead.

32.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.  See
     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.  See 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’.  See Pathconf.

32.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).  See 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.

32.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 | See 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 (see 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 | See 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.

32.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
     parentheses 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.

32.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.

32.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 | See 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; see 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; see 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; see 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; see 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; see 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; see 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; see 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; see 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;
     }

33 Cryptographic Functions
**************************

The GNU C Library includes only a few special-purpose cryptographic
functions: one-way hash functions for passphrase storage, and access to
a cryptographic randomness source, if one is provided by the operating
system.  Programs that need general-purpose cryptography should use a
dedicated cryptography library, such as libgcrypt.

   Many countries place legal restrictions on the import, export,
possession, or use of cryptographic software.  We deplore these
restrictions, but we must still warn you that the GNU C Library may be
subject to them, even if you do not use the functions in this chapter
yourself.  The restrictions vary from place to place and are changed
often, so we cannot give any more specific advice than this warning.

33.1 Passphrase Storage
=======================

Sometimes 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 (see Users and Groups).  One traditional way of doing this
is for each user to choose a secret “passphrase”; then, the system can
ask someone claiming to be a user what the user’s passphrase is, and if
the person gives the correct passphrase then the system can grant the
appropriate privileges.  (Traditionally, these were called “passwords,”
but nowadays a single word is too easy to guess.)

   Programs that handle passphrases must take special care not to reveal
them to anyone, no matter what.  It is not enough to keep them in a file
that is only accessible with special privileges.  The file might be
“leaked” via a bug or misconfiguration, and system administrators
shouldn’t learn everyone’s passphrase even if they have to edit that
file for some reason.  To avoid this, passphrases should also be
converted into “one-way hashes”, using a “one-way function”, before they
are stored.

   A one-way function is easy to compute, but there is no known way to
compute its inverse.  This means the system can easily check
passphrases, by hashing them and comparing the result with the stored
hash.  But an attacker who discovers someone’s passphrase hash can only
discover the passphrase it corresponds to by guessing and checking.  The
one-way functions are designed to make this process impractically slow,
for all but the most obvious guesses.  (Do not use a word from the
dictionary as your passphrase.)

   The GNU C Library provides an interface to four one-way functions,
based on the SHA-2-512, SHA-2-256, MD5, and DES cryptographic
primitives.  New passphrases should be hashed with either of the
SHA-based functions.  The others are too weak for newly set passphrases,
but we continue to support them for verifying old passphrases.  The
DES-based hash is especially weak, because it ignores all but the first
eight characters of its input.

 -- Function: char * crypt (const char *PHRASE, const char *SALT)

     Preliminary: | MT-Unsafe race:crypt | AS-Unsafe corrupt lock heap
     dlopen | AC-Unsafe lock mem | See POSIX Safety Concepts.

     The function ‘crypt’ converts a passphrase string, PHRASE, into a
     one-way hash suitable for storage in the user database.  The string
     that it returns will consist entirely of printable ASCII
     characters.  It will not contain whitespace, nor any of the
     characters ‘:’, ‘;’, ‘*’, ‘!’, or ‘\’.

     The SALT parameter controls which one-way function is used, and it
     also ensures that the output of the one-way function is different
     for every user, even if they have the same passphrase.  This makes
     it harder to guess passphrases from a large user database.  Without
     salt, the attacker could make a guess, run ‘crypt’ on it once, and
     compare the result with all the hashes.  Salt forces the attacker
     to make separate calls to ‘crypt’ for each user.

     To verify a passphrase, pass the previously hashed passphrase as
     the SALT.  To hash a new passphrase for storage, set SALT to a
     string consisting of a prefix plus a sequence of randomly chosen
     characters, according to this table:

     One-way        Prefix  Random sequence
     function
     ----------------------------------------------
     SHA-2-512      ‘$6$’   16 characters
     SHA-2-256      ‘$5$’   16 characters
     MD5            ‘$1$’   8 characters
     DES            ‘’      2 characters

     In all cases, the random characters should be chosen from the
     alphabet ‘./0-9A-Za-z’.

     With all of the hash functions _except_ DES, PHRASE can be
     arbitrarily long, and all eight bits of each byte are significant.
     With DES, only the first eight characters of PHRASE affect the
     output, and the eighth bit of each byte is also ignored.

     ‘crypt’ can fail.  Some implementations return ‘NULL’ on failure,
     and others return an _invalid_ hashed passphrase, which will begin
     with a ‘*’ and will not be the same as SALT.  In either case,
     ‘errno’ will be set to indicate the problem.  Some of the possible
     error codes are:

     ‘EINVAL’
          SALT is invalid; neither a previously hashed passphrase, nor a
          well-formed new salt for any of the supported hash functions.

     ‘EPERM’
          The system configuration forbids use of the hash function
          selected by SALT.

     ‘ENOMEM’
          Failed to allocate internal scratch storage.

     ‘ENOSYS’
     ‘EOPNOTSUPP’
          Hashing passphrases is not supported at all, or the hash
          function selected by SALT is not supported.  The GNU C Library
          does not use these error codes, but they may be encountered on
          other operating systems.

     ‘crypt’ uses static storage for both internal scratchwork and the
     string it returns.  It is not safe to call ‘crypt’ from multiple
     threads simultaneously, and the string it returns will be
     overwritten by any subsequent call to ‘crypt’.

     ‘crypt’ is specified in the X/Open Portability Guide and is present
     on nearly all historical Unix systems.  However, the XPG does not
     specify any one-way functions.

     ‘crypt’ is declared in ‘unistd.h’.  The GNU C Library also declares
     this function in ‘crypt.h’.

 -- Function: char * crypt_r (const char *PHRASE, const char *SALT,
          struct crypt_data *DATA)

     Preliminary: | MT-Safe | AS-Unsafe corrupt lock heap dlopen |
     AC-Unsafe lock mem | See POSIX Safety Concepts.

     The function ‘crypt_r’ is a thread-safe version of ‘crypt’.
     Instead of static storage, it uses the memory pointed to by its
     DATA argument for both scratchwork and the string it returns.  It
     can safely be used from multiple threads, as long as different DATA
     objects are used in each thread.  The string it returns will still
     be overwritten by another call with the same DATA.

     DATA must point to a ‘struct crypt_data’ object allocated by the
     caller.  All of the fields of ‘struct crypt_data’ are private, but
     before one of these objects is used for the first time, it must be
     initialized to all zeroes, using ‘memset’ or similar.  After that,
     it can be reused for many calls to ‘crypt_r’ without erasing it
     again.  ‘struct crypt_data’ is very large, so it is best to
     allocate it with ‘malloc’ rather than as a local variable.  See
     Memory Allocation.

     ‘crypt_r’ is a GNU extension.  It is declared in ‘crypt.h’, as is
     ‘struct crypt_data’.

   The following program shows how to use ‘crypt’ the first time a
passphrase is entered.  It uses ‘getentropy’ to make the salt as
unpredictable as possible; see Unpredictable Bytes.

     #include <stdio.h>
     #include <unistd.h>
     #include <crypt.h>

     int
     main(void)
     {
       unsigned char ubytes[16];
       char salt[20];
       const char *const saltchars =
         "./0123456789ABCDEFGHIJKLMNOPQRST"
         "UVWXYZabcdefghijklmnopqrstuvwxyz";
       char *hash;
       int i;

       /* Retrieve 16 unpredictable bytes from the operating system. */
       if (getentropy (ubytes, sizeof ubytes))
         {
           perror ("getentropy");
           return 1;
         }

       /* Use them to fill in the salt string. */
       salt[0] = '$';
       salt[1] = '5'; /* SHA-256 */
       salt[2] = '$';
       for (i = 0; i < 16; i++)
         salt[3+i] = saltchars[ubytes[i] & 0x3f];
       salt[3+i] = '\0';

       /* Read in the user’s passphrase and hash it. */
       hash = crypt (getpass ("Enter new passphrase: "), salt);
       if (!hash || hash[0] == '*')
         {
           perror ("crypt");
           return 1;
         }

       /* Print the results. */
       puts (hash);
       return 0;
     }

   The next program demonstrates how to verify a passphrase.  It checks
a hash hardcoded into the program, because looking up real users’ hashed
passphrases may require special privileges (see User Database).  It
also shows that different one-way functions produce different hashes for
the same passphrase.

     #include <stdio.h>
     #include <string.h>
     #include <unistd.h>
     #include <crypt.h>

     /* ‘GNU's Not Unix’ hashed using SHA-256, MD5, and DES. */
     static const char hash_sha[] =
       "$5$DQ2z5NHf1jNJnChB$kV3ZTR0aUaosujPhLzR84Llo3BsspNSe4/tsp7VoEn6";
     static const char hash_md5[] = "$1$A3TxDv41$rtXVTUXl2LkeSV0UU5xxs1";
     static const char hash_des[] = "FgkTuF98w5DaI";

     int
     main(void)
     {
       char *phrase;
       int status = 0;

       /* Prompt for a passphrase. */
       phrase = getpass ("Enter passphrase: ");

       /* Compare against the stored hashes.  Any input that begins with
          ‘GNU's No’ will match the DES hash, but the other two will
          only match ‘GNU's Not Unix’. */

       if (strcmp (crypt (phrase, hash_sha), hash_sha))
         {
           puts ("SHA: not ok");
           status = 1;
         }
       else
         puts ("SHA: ok");

       if (strcmp (crypt (phrase, hash_md5), hash_md5))
         {
           puts ("MD5: not ok");
           status = 1;
         }
       else
         puts ("MD5: ok");

       if (strcmp (crypt (phrase, hash_des), hash_des))
         {
           puts ("DES: not ok");
           status = 1;
         }
       else
         puts ("DES: ok");

       return status;
     }

33.2 Generating Unpredictable Bytes
===================================

Cryptographic applications often need some random data that will be as
difficult as possible for a hostile eavesdropper to guess.  For
instance, encryption keys should be chosen at random, and the “salt”
strings used by ‘crypt’ (see Passphrase Storage) should also be
chosen at random.

   Some pseudo-random number generators do not provide
unpredictable-enough output for cryptographic applications; see
Pseudo-Random Numbers.  Such applications need to use a “cryptographic
random number generator” (CRNG), also sometimes called a
“cryptographically strong pseudo-random number generator” (CSPRNG) or
“deterministic random bit generator” (DRBG).

   Currently, the GNU C Library does not provide a cryptographic random
number generator, but it does provide functions that read random data
from a “randomness source” supplied by the operating system.  The
randomness source is a CRNG at heart, but it also continually “re-seeds”
itself from physical sources of randomness, such as electronic noise and
clock jitter.  This means applications do not need to do anything to
ensure that the random numbers it produces are different on each run.

   The catch, however, is that these functions will only produce
relatively short random strings in any one call.  Often this is not a
problem, but applications that need more than a few kilobytes of
cryptographically strong random data should call these functions once
and use their output to seed a CRNG.

   Most applications should use ‘getentropy’.  The ‘getrandom’ function
is intended for low-level applications which need additional control
over blocking behavior.

 -- Function: int getentropy (void *BUFFER, size_t LENGTH)

     | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     This function writes exactly LENGTH bytes of random data to the
     array starting at BUFFER.  LENGTH can be no more than 256.  On
     success, it returns zero.  On failure, it returns -1, and ‘errno’
     is set to indicate the problem.  Some of the possible errors are
     listed below.

     ‘ENOSYS’
          The operating system does not implement a randomness source,
          or does not support this way of accessing it.  (For instance,
          the system call used by this function was added to the Linux
          kernel in version 3.17.)

     ‘EFAULT’
          The combination of BUFFER and LENGTH arguments specifies an
          invalid memory range.

     ‘EIO’
          LENGTH is larger than 256, or the kernel entropy pool has
          suffered a catastrophic failure.

     A call to ‘getentropy’ can only block when the system has just
     booted and the randomness source has not yet been initialized.
     However, if it does block, it cannot be interrupted by signals or
     thread cancellation.  Programs intended to run in very early stages
     of the boot process may need to use ‘getrandom’ in non-blocking
     mode instead, and be prepared to cope with random data not being
     available at all.

     The ‘getentropy’ function is declared in the header file
     ‘sys/random.h’.  It is derived from OpenBSD.

 -- Function: ssize_t getrandom (void *BUFFER, size_t LENGTH, unsigned
          int FLAGS)

     | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     This function writes up to LENGTH bytes of random data to the array
     starting at BUFFER.  The FLAGS argument should be either zero, or
     the bitwise OR of some of the following flags:

     ‘GRND_RANDOM’
          Use the ‘/dev/random’ (blocking) source instead of the
          ‘/dev/urandom’ (non-blocking) source to obtain randomness.

          If this flag is specified, the call may block, potentially for
          quite some time, even after the randomness source has been
          initialized.  If it is not specified, the call can only block
          when the system has just booted and the randomness source has
          not yet been initialized.

     ‘GRND_NONBLOCK’
          Instead of blocking, return to the caller immediately if no
          data is available.

     ‘GRND_INSECURE’
          Write random data that may not be cryptographically secure.

     Unlike ‘getentropy’, the ‘getrandom’ function is a cancellation
     point, and if it blocks, it can be interrupted by signals.

     On success, ‘getrandom’ returns the number of bytes which have been
     written to the buffer, which may be less than LENGTH.  On error, it
     returns -1, and ‘errno’ is set to indicate the problem.  Some of
     the possible errors are:

     ‘ENOSYS’
          The operating system does not implement a randomness source,
          or does not support this way of accessing it.  (For instance,
          the system call used by this function was added to the Linux
          kernel in version 3.17.)

     ‘EAGAIN’
          No random data was available and ‘GRND_NONBLOCK’ was specified
          in FLAGS.

     ‘EFAULT’
          The combination of BUFFER and LENGTH arguments specifies an
          invalid memory range.

     ‘EINTR’
          The system call was interrupted.  During the system boot
          process, before the kernel randomness pool is initialized,
          this can happen even if FLAGS is zero.

     ‘EINVAL’
          The FLAGS argument contains an invalid combination of flags.

     The ‘getrandom’ function is declared in the header file
     ‘sys/random.h’.  It is a GNU extension.

34 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.

34.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 | See 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 |
     See 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 can 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 | See 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];
       char **strings;
       int size, i;

       size = backtrace (array, 10);
       strings = backtrace_symbols (array, size);
       if (strings != NULL)
       {

         printf ("Obtained %d 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;
     }

35 Threads
**********

This chapter describes functions used for managing threads.  The GNU C
Library provides two threading implementations: ISO C threads and POSIX
threads.

35.1 ISO C Threads
==================

This section describes the GNU C Library ISO C threads implementation.
To have a deeper understanding of this API, it is strongly recommended
to read ISO/IEC 9899:2011, section 7.26, in which ISO C threads were
originally specified.  All types and function prototypes are declared in
the header file ‘threads.h’.

35.1.1 Return Values
--------------------

The ISO C thread specification provides the following enumeration
constants for return values from functions in the API:

‘thrd_timedout’

     A specified time was reached without acquiring the requested
     resource, usually a mutex or condition variable.

‘thrd_success’

     The requested operation succeeded.

‘thrd_busy’

     The requested operation failed because a requested resource is
     already in use.

‘thrd_error’

     The requested operation failed.

‘thrd_nomem’

     The requested operation failed because it was unable to allocate
     enough memory.

35.1.2 Creation and Control
---------------------------

The GNU C Library implements a set of functions that allow the user to
easily create and use threads.  Additional functionality is provided to
control the behavior of threads.

   The following data types are defined for managing threads:

 -- Data Type: thrd_t

     A unique object that identifies a thread.

 -- Data Type: thrd_start_t

     This data type is an ‘int (*) (void *)’ typedef that is passed to
     ‘thrd_create’ when creating a new thread.  It should point to the
     first function that thread will run.

   The following functions are used for working with threads:

 -- Function: int thrd_create (thrd_t *THR, thrd_start_t FUNC, void
          *ARG)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘thrd_create’ creates a new thread that will execute the function
     FUNC.  The object pointed to by ARG will be used as the argument to
     FUNC.  If successful, THR is set to the new thread identifier.

     This function may return ‘thrd_success’, ‘thrd_nomem’, or
     ‘thrd_error’.

 -- Function: thrd_t thrd_current (void)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     This function returns the identifier of the calling thread.

 -- Function: int thrd_equal (thrd_t LHS, thrd_t RHS)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘thrd_equal’ checks whether LHS and RHS refer to the same thread.
     If LHS and RHS are different threads, this function returns 0;
     otherwise, the return value is non-zero.

 -- Function: int thrd_sleep (const struct timespec *TIME_POINT, struct
          timespec *REMAINING)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘thrd_sleep’ blocks the execution of the current thread for at
     least until the elapsed time pointed to by TIME_POINT has been
     reached.  This function does not take an absolute time, but a
     duration that the thread is required to be blocked.  See Time Basics,
     and Time Types.

     The thread may wake early if a signal that is not ignored is
     received.  In such a case, if ‘remaining’ is not NULL, the
     remaining time duration is stored in the object pointed to by
     REMAINING.

     ‘thrd_sleep’ returns 0 if it blocked for at least the amount of
     time in ‘time_point’, -1 if it was interrupted by a signal, or a
     negative number on failure.

 -- Function: void thrd_yield (void)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘thrd_yield’ provides a hint to the implementation to reschedule
     the execution of the current thread, allowing other threads to run.

 -- Function: _Noreturn void thrd_exit (int RES)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘thrd_exit’ terminates execution of the calling thread and sets its
     result code to RES.

     If this function is called from a single-threaded process, the call
     is equivalent to calling ‘exit’ with ‘EXIT_SUCCESS’ (see Normal Termination).
     Also note that returning from a function that
     started a thread is equivalent to calling ‘thrd_exit’.

 -- Function: int thrd_detach (thrd_t THR)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘thrd_detach’ detaches the thread identified by ‘thr’ from the
     current control thread.  The resources held by the detached thread
     will be freed automatically once the thread exits.  The parent
     thread will never be notified by any THR signal.

     Calling ‘thrd_detach’ on a thread that was previously detached or
     joined by another thread results in undefined behavior.

     This function returns either ‘thrd_success’ or ‘thrd_error’.

 -- Function: int thrd_join (thrd_t THR, int *RES)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘thrd_join’ blocks the current thread until the thread identified
     by ‘thr’ finishes execution.  If ‘res’ is not NULL, the result code
     of the thread is put into the location pointed to by RES.  The
     termination of the thread “synchronizes-with” the completion of
     this function, meaning both threads have arrived at a common point
     in their execution.

     Calling ‘thrd_join’ on a thread that was previously detached or
     joined by another thread results in undefined behavior.

     This function returns either ‘thrd_success’ or ‘thrd_error’.

35.1.3 Call Once
----------------

In order to guarantee single access to a function, the GNU C Library
implements a “call once function” to ensure a function is only called
once in the presence of multiple, potentially calling threads.

 -- Data Type: once_flag

     A complete object type capable of holding a flag used by
     ‘call_once’.

 -- Macro: ONCE_FLAG_INIT

     This value is used to initialize an object of type ‘once_flag’.

 -- Function: void call_once (once_flag *FLAG, void (*FUNC) (void))

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘call_once’ calls function FUNC exactly once, even if invoked from
     several threads.  The completion of the function FUNC
     synchronizes-with all previous or subsequent calls to ‘call_once’
     with the same ‘flag’ variable.

35.1.4 Mutexes
--------------

To have better control of resources and how threads access them, the GNU
C Library implements a “mutex” object, which can help avoid race
conditions and other concurrency issues.  The term “mutex” refers to
mutual exclusion.

   The fundamental data type for a mutex is the ‘mtx_t’:

 -- Data Type: mtx_t

     The ‘mtx_t’ data type uniquely identifies a mutex object.

   The ISO C standard defines several types of mutexes.  They are
represented by the following symbolic constants:

‘mtx_plain’

     A mutex that does not support timeout, or test and return.

‘mtx_recursive’

     A mutex that supports recursive locking, which means that the
     owning thread can lock it more than once without causing deadlock.

‘mtx_timed’

     A mutex that supports timeout.

   The following functions are used for working with mutexes:

 -- Function: int mtx_init (mtx_t *MUTEX, int TYPE)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘mtx_init’ creates a new mutex object with type TYPE.  The object
     pointed to by MUTEX is set to the identifier of the newly created
     mutex.

     Not all combinations of mutex types are valid for the ‘type’
     argument.  Valid uses of mutex types for the ‘type’ argument are:

     ‘mtx_plain’
          A non-recursive mutex that does not support timeout.

     ‘mtx_timed’
          A non-recursive mutex that does support timeout.

     ‘mtx_plain | mtx_recursive’
          A recursive mutex that does not support timeout.

     ‘mtx_timed | mtx_recursive’
          A recursive mutex that does support timeout.

     This function returns either ‘thrd_success’ or ‘thrd_error’.

 -- Function: int mtx_lock (mtx_t *MUTEX)

     Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | See
     POSIX Safety Concepts.

     ‘mtx_lock’ blocks the current thread until the mutex pointed to by
     MUTEX is locked.  The behavior is undefined if the current thread
     has already locked the mutex and the mutex is not recursive.

     Prior calls to ‘mtx_unlock’ on the same mutex synchronize-with this
     operation (if this operation succeeds), and all lock/unlock
     operations on any given mutex form a single total order (similar to
     the modification order of an atomic).

     This function returns either ‘thrd_success’ or ‘thrd_error’.

 -- Function: int mtx_timedlock (mtx_t *restrict MUTEX, const struct
          timespec *restrict TIME_POINT)

     Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | See
     POSIX Safety Concepts.

     ‘mtx_timedlock’ blocks the current thread until the mutex pointed
     to by MUTEX is locked or until the calendar time pointed to by
     TIME_POINT has been reached.  Since this function takes an absolute
     time, if a duration is required, the calendar time must be
     calculated manually.  See Time Basics, and Calendar Time.

     If the current thread has already locked the mutex and the mutex is
     not recursive, or if the mutex does not support timeout, the
     behavior of this function is undefined.

     Prior calls to ‘mtx_unlock’ on the same mutex synchronize-with this
     operation (if this operation succeeds), and all lock/unlock
     operations on any given mutex form a single total order (similar to
     the modification order of an atomic).

     This function returns either ‘thrd_success’ or ‘thrd_error’.

 -- Function: int mtx_trylock (mtx_t *MUTEX)

     Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | See
     POSIX Safety Concepts.

     ‘mtx_trylock’ tries to lock the mutex pointed to by MUTEX without
     blocking.  It returns immediately if the mutex is already locked.

     Prior calls to ‘mtx_unlock’ on the same mutex synchronize-with this
     operation (if this operation succeeds), and all lock/unlock
     operations on any given mutex form a single total order (similar to
     the modification order of an atomic).

     This function returns ‘thrd_success’ if the lock was obtained,
     ‘thrd_busy’ if the mutex is already locked, and ‘thrd_error’ on
     failure.

 -- Function: int mtx_unlock (mtx_t *MUTEX)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘mtx_unlock’ unlocks the mutex pointed to by MUTEX.  The behavior
     is undefined if the mutex is not locked by the calling thread.

     This function synchronizes-with subsequent ‘mtx_lock’,
     ‘mtx_trylock’, and ‘mtx_timedlock’ calls on the same mutex.  All
     lock/unlock operations on any given mutex form a single total order
     (similar to the modification order of an atomic).

     This function returns either ‘thrd_success’ or ‘thrd_error’.

 -- Function: void mtx_destroy (mtx_t *MUTEX)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘mtx_destroy’ destroys the mutex pointed to by MUTEX.  If there are
     any threads waiting on the mutex, the behavior is undefined.

35.1.5 Condition Variables
--------------------------

Mutexes are not the only synchronization mechanisms available.  For some
more complex tasks, the GNU C Library also implements “condition
variables”, which allow the programmer to think at a higher level when
solving complex synchronization problems.  They are used to synchronize
threads waiting on a certain condition to happen.

   The fundamental data type for condition variables is the ‘cnd_t’:

 -- Data Type: cnd_t

     The ‘cnd_t’ uniquely identifies a condition variable object.

   The following functions are used for working with condition
variables:

 -- Function: int cnd_init (cnd_t *COND)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘cnd_init’ initializes a new condition variable, identified by
     COND.

     This function may return ‘thrd_success’, ‘thrd_nomem’, or
     ‘thrd_error’.

 -- Function: int cnd_signal (cnd_t *COND)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘cnd_signal’ unblocks one thread that is currently waiting on the
     condition variable pointed to by COND.  If a thread is successfully
     unblocked, this function returns ‘thrd_success’.  If no threads are
     blocked, this function does nothing and returns ‘thrd_success’.
     Otherwise, this function returns ‘thrd_error’.

 -- Function: int cnd_broadcast (cnd_t *COND)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘cnd_broadcast’ unblocks all the threads that are currently waiting
     on the condition variable pointed to by COND.  This function
     returns ‘thrd_success’ on success.  If no threads are blocked, this
     function does nothing and returns ‘thrd_success’.  Otherwise, this
     function returns ‘thrd_error’.

 -- Function: int cnd_wait (cnd_t *COND, mtx_t *MUTEX)

     Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | See
     POSIX Safety Concepts.

     ‘cnd_wait’ atomically unlocks the mutex pointed to by MUTEX and
     blocks on the condition variable pointed to by COND until the
     thread is signaled by ‘cnd_signal’ or ‘cnd_broadcast’.  The mutex
     is locked again before the function returns.

     This function returns either ‘thrd_success’ or ‘thrd_error’.

 -- Function: int cnd_timedwait (cnd_t *restrict COND, mtx_t *restrict
          MUTEX, const struct timespec *restrict TIME_POINT)

     Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | See
     POSIX Safety Concepts.

     ‘cnd_timedwait’ atomically unlocks the mutex pointed to by MUTEX
     and blocks on the condition variable pointed to by COND until the
     thread is signaled by ‘cnd_signal’ or ‘cnd_broadcast’, or until the
     calendar time pointed to by TIME_POINT has been reached.  The mutex
     is locked again before the function returns.

     As for ‘mtx_timedlock’, since this function takes an absolute time,
     if a duration is required, the calendar time must be calculated
     manually.  See Time Basics, and Calendar Time.

     This function may return ‘thrd_success’, ‘thrd_nomem’, or
     ‘thrd_error’.

 -- Function: void cnd_destroy (cnd_t *COND)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘cnd_destroy’ destroys the condition variable pointed to by COND.
     If there are threads waiting on COND, the behavior is undefined.

35.1.6 Thread-local Storage
---------------------------

The GNU C Library implements functions to provide “thread-local
storage”, a mechanism by which variables can be defined to have unique
per-thread storage, lifetimes that match the thread lifetime, and
destructors that cleanup the unique per-thread storage.

   Several data types and macros exist for working with thread-local
storage:

 -- Data Type: tss_t

     The ‘tss_t’ data type identifies a thread-specific storage object.
     Even if shared, every thread will have its own instance of the
     variable, with different values.

 -- Data Type: tss_dtor_t

     The ‘tss_dtor_t’ is a function pointer of type ‘void (*) (void *)’,
     to be used as a thread-specific storage destructor.  The function
     will be called when the current thread calls ‘thrd_exit’ (but never
     when calling ‘tss_delete’ or ‘exit’).

 -- Macro: thread_local

     ‘thread_local’ is used to mark a variable with thread storage
     duration, which means it is created when the thread starts and
     cleaned up when the thread ends.

     _Note:_ For C++, C++11 or later is required to use the
     ‘thread_local’ keyword.

 -- Macro: TSS_DTOR_ITERATIONS

     ‘TSS_DTOR_ITERATIONS’ is an integer constant expression
     representing the maximum number of iterations over all thread-local
     destructors at the time of thread termination.  This value provides
     a bounded limit to the destruction of thread-local storage; e.g.,
     consider a destructor that creates more thread-local storage.

   The following functions are used to manage thread-local storage:

 -- Function: int tss_create (tss_t *TSS_KEY, tss_dtor_t DESTRUCTOR)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘tss_create’ creates a new thread-specific storage key and stores
     it in the object pointed to by TSS_KEY.  Although the same key
     value may be used by different threads, the values bound to the key
     by ‘tss_set’ are maintained on a per-thread basis and persist for
     the life of the calling thread.

     If ‘destructor’ is not NULL, a destructor function will be set, and
     called when the thread finishes its execution by calling
     ‘thrd_exit’.

     This function returns ‘thrd_success’ if ‘tss_key’ is successfully
     set to a unique value for the thread; otherwise, ‘thrd_error’ is
     returned and the value of ‘tss_key’ is undefined.

 -- Function: int tss_set (tss_t TSS_KEY, void *VAL)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘tss_set’ sets the value of the thread-specific storage identified
     by TSS_KEY for the current thread to VAL.  Different threads may
     set different values to the same key.

     This function returns either ‘thrd_success’ or ‘thrd_error’.

 -- Function: void * tss_get (tss_t TSS_KEY)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘tss_get’ returns the value identified by TSS_KEY held in
     thread-specific storage for the current thread.  Different threads
     may get different values identified by the same key.  On failure,
     ‘tss_get’ returns zero.

 -- Function: void tss_delete (tss_t TSS_KEY)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     ‘tss_delete’ destroys the thread-specific storage identified by
     TSS_KEY.

35.2 POSIX Threads
==================

This section describes the GNU C Library POSIX Threads implementation.

35.2.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 | See 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 | See 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 | See 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 | See POSIX Safety Concepts.

     Associate the thread-specific VALUE with KEY in the calling thread.

35.2.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.

35.2.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 | See
     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 |
     See 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.

35.2.2.2 Controlling the Initial Signal Mask of a New Thread
............................................................

The GNU C Library provides a way to specify the initial signal mask of a
thread created using ‘pthread_create’, passing a thread attribute object
configured for this purpose.

 -- Function: int pthread_attr_setsigmask_np (pthread_attr_t *ATTR,
          const sigset_t *SIGMASK)

     Preliminary: | MT-Safe | AS-Unsafe heap | AC-Unsafe mem | See
     POSIX Safety Concepts.

     Change the initial signal mask specified by ATTR.  If SIGMASK is
     not ‘NULL’, the initial signal mask for new threads created with
     ATTR is set to ‘*SIGMASK’.  If SIGMASK is ‘NULL’, ATTR will no
     longer specify an explicit signal mask, so that the initial signal
     mask of the new thread is inherited from the thread that calls
     ‘pthread_create’.

     This function returns zero on success, and ‘ENOMEM’ on memory
     allocation failure.

 -- Function: int pthread_attr_getsigmask_np (const pthread_attr_t
          *ATTR, sigset_t *SIGMASK)

     Preliminary: | MT-Safe | AS-Unsafe heap | AC-Unsafe mem | See
     POSIX Safety Concepts.

     Retrieve the signal mask stored in ATTR and copy it to ‘*SIGMASK’.
     If the signal mask has not been set, return the special constant
     ‘PTHREAD_ATTR_NO_SIGMASK_NP’, otherwise return zero.

     Obtaining the signal mask only works if it has been previously
     stored by ‘pthread_attr_setsigmask_np’.  For example, the
     ‘pthread_getattr_np’ function does not obtain the current signal
     mask of the specified thread, and ‘pthread_attr_getsigmask_np’ will
     subsequently report the signal mask as unset.

 -- Macro: int PTHREAD_ATTR_NO_SIGMASK_NP
     The special value returned by ‘pthread_attr_setsigmask_np’ to
     indicate that no signal mask has been set for the attribute.

   It is possible to create a new thread with a specific signal mask
without using these functions.  On the thread that calls
‘pthread_create’, the required steps for the general case are:

  1. Mask all signals, and save the old signal mask, using
     ‘pthread_sigmask’.  This ensures that the new thread will be
     created with all signals masked, so that no signals can be
     delivered to the thread until the desired signal mask is set.

  2. Call ‘pthread_create’ to create the new thread, passing the desired
     signal mask to the thread start routine (which could be a wrapper
     function for the actual thread start routine).  It may be necessary
     to make a copy of the desired signal mask on the heap, so that the
     life-time of the copy extends to the point when the start routine
     needs to access the signal mask.

  3. Restore the thread’s signal mask, to the set that was saved in the
     first step.

   The start routine for the created thread needs to locate the desired
signal mask and use ‘pthread_sigmask’ to apply it to the thread.  If the
signal mask was copied to a heap allocation, the copy should be freed.

35.2.2.3 Functions for Waiting According to a Specific Clock
............................................................

The GNU C Library provides several waiting functions that expect an
explicit ‘clockid_t’ argument.

 -- Function: int sem_clockwait (sem_t *SEM, clockid_t CLOCKID,
     const struct timespec *ABSTIME) Behaves like ‘sem_timedwait’ except
     the time ABSTIME is measured against the clock specified by CLOCKID
     rather than ‘CLOCK_REALTIME’.  Currently, CLOCKID must be either
     ‘CLOCK_MONOTONIC’ or ‘CLOCK_REALTIME’.

 -- Function: int pthread_cond_clockwait (pthread_cond_t *COND,
          pthread_mutex_t *MUTEX,
     clockid_t CLOCKID, const struct timespec *ABSTIME) Preliminary: |
     MT-Safe | AS-Unsafe lock | AC-Unsafe lock | See POSIX Safety Concepts.

     Behaves like ‘pthread_cond_timedwait’ except the time ABSTIME is
     measured against the clock specified by CLOCKID rather than the
     clock specified or defaulted when ‘pthread_cond_init’ was called.
     Currently, CLOCKID must be either ‘CLOCK_MONOTONIC’ or
     ‘CLOCK_REALTIME’.

 -- Function: int pthread_rwlock_clockrdlock (pthread_rwlock_t *RWLOCK,
     clockid_t CLOCKID, const struct timespec *ABSTIME)

     Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | See
     POSIX Safety Concepts.

     Behaves like ‘pthread_rwlock_timedrdlock’ except the time ABSTIME
     is measured against the clock specified by CLOCKID rather than
     ‘CLOCK_REALTIME’.  Currently, CLOCKID must be either
     ‘CLOCK_MONOTONIC’ or ‘CLOCK_REALTIME’, otherwise ‘EINVAL’ is
     returned.

 -- Function: int pthread_rwlock_clockwrlock (pthread_rwlock_t *RWLOCK,
     clockid_t CLOCKID, const struct timespec *ABSTIME)

     Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | See
     POSIX Safety Concepts.

     Behaves like ‘pthread_rwlock_timedwrlock’ except the time ABSTIME
     is measured against the clock specified by CLOCKID rather than
     ‘CLOCK_REALTIME’.  Currently, CLOCKID must be either
     ‘CLOCK_MONOTONIC’ or ‘CLOCK_REALTIME’, otherwise ‘EINVAL’ is
     returned.

 -- Function: int pthread_tryjoin_np (pthread_t *THREAD,
     void **THREAD_RETURN)

     Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | See
     POSIX Safety Concepts.

     Behaves like ‘pthread_join’ except that it will return ‘EBUSY’
     immediately if the thread specified by THREAD has not yet
     terminated.

 -- Function: int pthread_timedjoin_np (pthread_t *THREAD,
     void **THREAD_RETURN, const struct timespec *ABSTIME)

     Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | See
     POSIX Safety Concepts.

     Behaves like ‘pthread_tryjoin_np’ except that it will block until
     the absolute time ABSTIME measured against ‘CLOCK_REALTIME’ is
     reached if the thread has not terminated by that time and return
     ‘EBUSY’.  If ABSTIME is equal to ‘NULL’ then the function will wait
     forever in the same way as ‘pthread_join’.

 -- Function: int pthread_clockjoin_np (pthread_t *THREAD,
     void **THREAD_RETURN, clockid_t CLOCKID, const struct timespec
     *ABSTIME)

     Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | See
     POSIX Safety Concepts.

     Behaves like ‘pthread_timedjoin_np’ except that the absolute time
     in ABSTIME is measured against the clock specified by CLOCKID.
     Currently, CLOCKID must be either ‘CLOCK_MONOTONIC’ or
     ‘CLOCK_REALTIME’.

35.2.2.4 Detecting Single-Threaded Execution
............................................

Multi-threaded programs require synchronization among threads.  This
synchronization can be costly even if there is just a single thread and
no data is shared between multiple processors.  The GNU C Library offers
an interface to detect whether the process is in single-threaded mode.
Applications can use this information to avoid synchronization, for
example by using regular instructions to load and store memory instead
of atomic instructions, or using relaxed memory ordering instead of
stronger memory ordering.

 -- Variable: char __libc_single_threaded

     This variable is non-zero if the current process is definitely
     single-threaded.  If it is zero, the process may be multi-threaded,
     or the GNU C Library cannot determine at this point of the program
     execution whether the process is single-threaded or not.

     Applications must never write to this variable.

   Most applications should perform the same actions whether or not
‘__libc_single_threaded’ is true, except with less synchronization.  If
this rule is followed, a process that subsequently becomes
multi-threaded is already in a consistent state.  For example, in order
to increment a reference count, the following code can be used:

     if (__libc_single_threaded)
       atomic_fetch_add (&reference_count, 1, memory_order_relaxed);
     else
       atomic_fetch_add (&reference_count, 1, memory_order_acq_rel);

   This still requires some form of synchronization on the
single-threaded branch, so it can be beneficial not to declare the
reference count as ‘_Atomic’, and use the GCC ‘__atomic’ built-ins.
See Built-in Functions for Memory Model Aware Atomic Operations (gcc).
Then the code to increment a reference count
looks like this:

     if (__libc_single_threaded)
       ++reference_count;
     else
       __atomic_fetch_add (&reference_count, 1, __ATOMIC_ACQ_REL);

   (Depending on the data associated with the reference count, it may be
possible to use the weaker ‘__ATOMIC_RELAXED’ memory ordering on the
multi-threaded branch.)

   Several functions in the GNU C Library can change the value of the
‘__libc_single_threaded’ variable.  For example, creating new threads
using the ‘pthread_create’ or ‘thrd_create’ function sets the variable
to false.  This can also happen indirectly, say via a call to ‘dlopen’.
Therefore, applications need to make a copy of the value of
‘__libc_single_threaded’ if after such a function call, behavior must
match the value as it was before the call, like this:

     bool single_threaded = __libc_single_threaded;
     if (single_threaded)
       prepare_single_threaded ();
     else
       prepare_multi_thread ();

     void *handle = dlopen (shared_library_name, RTLD_NOW);
     lookup_symbols (handle);

     if (single_threaded)
       cleanup_single_threaded ();
     else
       cleanup_multi_thread ();

   Since the value of ‘__libc_single_threaded’ can change from true to
false during the execution of the program, it is not useful for
selecting optimized function implementations in IFUNC resolvers.

   Atomic operations can also be used on mappings shared among
single-threaded processes.  This means that a compiler must not use
‘__libc_single_threaded’ to optimize atomic operations, unless it is
able to prove that the memory is not shared.

   *Implementation Note:* The ‘__libc_single_threaded’ variable is not
declared as ‘volatile’ because it is expected that compilers optimize a
sequence of single-threaded checks into one check, for example if
several reference counts are updated.  The current implementation in the
GNU C Library does not set the ‘__libc_single_threaded’ variable to a
true value if a process turns single-threaded again.  Future versions of
the GNU C Library may do this, but only as the result of function calls
which imply an acquire (compiler) barrier.  (Some compilers assume that
well-known functions such as ‘malloc’ do not write to global variables,
and setting ‘__libc_single_threaded’ would introduce a data race and
undefined behavior.)  In any case, an application must not write to
‘__libc_single_threaded’ even if it has joined the last
application-created thread because future versions of the GNU C Library
may create background threads after the first thread has been created,
and the application has no way of knowning that these threads are
present.

35.2.2.5 Restartable Sequences
..............................

This section describes restartable sequences integration for the GNU C
Library.  This functionality is only available on Linux.

 -- Data Type: struct rseq

     The type of the restartable sequences area.  Future versions of
     Linux may add additional fields to the end of this structure.

     Users need to obtain the address of the restartable sequences area
     using the thread pointer and the ‘__rseq_offset’ variable,
     described below.

     One use of the restartable sequences area is to read the current
     CPU number from its ‘cpu_id’ field, as an inline version of
     ‘sched_getcpu’.  The GNU C Library sets the ‘cpu_id’ field to
     ‘RSEQ_CPU_ID_REGISTRATION_FAILED’ if registration failed or was
     explicitly disabled.

     Furthermore, users can store the address of a ‘struct rseq_cs’
     object into the ‘rseq_cs’ field of ‘struct rseq’, thus informing
     the kernel that the thread enters a restartable sequence critical
     section.  This pointer and the code areas it itself points to must
     not be left pointing to memory areas which are freed or re-used.
     Several approaches can guarantee this.  If the application or
     library can guarantee that the memory used to hold the ‘struct
     rseq_cs’ and the code areas it refers to are never freed or
     re-used, no special action must be taken.  Else, before that memory
     is re-used of freed, the application is responsible for setting the
     ‘rseq_cs’ field to ‘NULL’ in each thread’s restartable sequence
     area to guarantee that it does not leak dangling references.
     Because the application does not typically have knowledge of
     libraries’ use of restartable sequences, it is recommended that
     libraries using restartable sequences which may end up freeing or
     re-using their memory set the ‘rseq_cs’ field to ‘NULL’ before
     returning from library functions which use restartable sequences.

     The manual for the ‘rseq’ system call can be found at
     <https://git.kernel.org/pub/scm/libs/librseq/librseq.git/tree/doc/man/rseq.2>.

 -- Variable: ptrdiff_t __rseq_offset

     This variable contains the offset between the thread pointer (as
     defined by ‘__builtin_thread_pointer’ or the thread pointer
     register for the architecture) and the restartable sequences area.
     This value is the same for all threads in the process.  If the
     restartable sequences area is located at a lower address than the
     location to which the thread pointer points, the value is negative.

 -- Variable: unsigned int __rseq_size

     This variable is either zero (if restartable sequence registration
     failed or has been disabled) or the size of the restartable
     sequence registration.  This can be different from the size of
     ‘struct rseq’ if the kernel has extended the size of the
     registration.  If registration is successful, ‘__rseq_size’ is at
     least 32 (the initial size of ‘struct rseq’).

 -- Variable: unsigned int __rseq_flags

     The flags used during restartable sequence registration with the
     kernel.  Currently zero.

 -- Macro: int RSEQ_SIG

     Each supported architecture provides a ‘RSEQ_SIG’ macro in
     ‘sys/rseq.h’ which contains a signature.  That signature is
     expected to be present in the code before each restartable
     sequences abort handler.  Failure to provide the expected signature
     may terminate the process with a segmentation fault.

36 Dynamic Linker
*****************

The “dynamic linker” is responsible for loading dynamically linked
programs and their dependencies (in the form of shared objects).  The
dynamic linker in the GNU C Library also supports loading shared objects
(such as plugins) later at run time.

   Dynamic linkers are sometimes called “dynamic loaders”.

36.1 Dynamic Linker Introspection
=================================

The GNU C Library provides various functions for querying information
from the dynamic linker.

 -- Function: int dlinfo (void *HANDLE, int REQUEST, void *ARG)
     | MT-Safe | AS-Unsafe corrupt | AC-Unsafe corrupt | See POSIX Safety Concepts.

     This function returns information about HANDLE in the memory
     location ARG, based on REQUEST.  The HANDLE argument must be a
     pointer returned by ‘dlopen’ or ‘dlmopen’; it must not have been
     closed by ‘dlclose’.

     On success, ‘dlinfo’ returns 0 for most request types; exceptions
     are noted below.  If there is an error, the function returns -1,
     and ‘dlerror’ can be used to obtain a corresponding error message.

     The following operations are defined for use with REQUEST:

     ‘RTLD_DI_LINKMAP’
          The corresponding ‘struct link_map’ pointer for HANDLE is
          written to ‘*ARG’.  The ARG argument must be the address of an
          object of type ‘struct link_map *’.

     ‘RTLD_DI_LMID’
          The namespace identifier of HANDLE is written to ‘*ARG’.  The
          ARG argument must be the address of an object of type
          ‘Lmid_t’.

     ‘RTLD_DI_ORIGIN’
          The value of the ‘$ORIGIN’ dynamic string token for HANDLE is
          written to the character array starting at ARG as a
          null-terminated string.

          This request type should not be used because it is prone to
          buffer overflows.

     ‘RTLD_DI_SERINFO’
     ‘RTLD_DI_SERINFOSIZE’
          These requests can be used to obtain search path information
          for HANDLE.  For both requests, ARG must point to a
          ‘Dl_serinfo’ object.  The ‘RTLD_DI_SERINFOSIZE’ request must
          be made first; it updates the ‘dls_size’ and ‘dls_cnt’ members
          of the ‘Dl_serinfo’ object.  The caller should then allocate
          memory to store at least ‘dls_size’ bytes and pass that buffer
          to a ‘RTLD_DI_SERINFO’ request.  This second request fills the
          ‘dls_serpath’ array.  The number of array elements was
          returned in the ‘dls_cnt’ member in the initial
          ‘RTLD_DI_SERINFOSIZE’ request.  The caller is responsible for
          freeing the allocated buffer.

          This interface is prone to buffer overflows in multi-threaded
          processes because the required size can change between the
          ‘RTLD_DI_SERINFOSIZE’ and ‘RTLD_DI_SERINFO’ requests.

     ‘RTLD_DI_TLS_DATA’
          This request writes the address of the TLS block (in the
          current thread) for the shared object identified by HANDLE to
          ‘*ARG’.  The argument ARG must be the address of an object of
          type ‘void *’.  A null pointer is written if the object does
          not have any associated TLS block.

     ‘RTLD_DI_TLS_MODID’
          This request writes the TLS module ID for the shared object
          HANDLE to ‘*ARG’.  The argument ARG must be the address of an
          object of type ‘size_t’.  The module ID is zero if the object
          does not have an associated TLS block.

     ‘RTLD_DI_PHDR’
          This request writes the address of the program header array to
          ‘*ARG’.  The argument ARG must be the address of an object of
          type ‘const ElfW(Phdr) *’ (that is, ‘const Elf32_Phdr *’ or
          ‘const Elf64_Phdr *’, as appropriate for the current
          architecture).  For this request, the value returned by
          ‘dlinfo’ is the number of program headers in the program
          header array.

     The ‘dlinfo’ function is a GNU extension.

   The remainder of this section documents the ‘_dl_find_object’
function and supporting types and constants.

 -- Data Type: struct dl_find_object

     This structure contains information about a main program or loaded
     object.  The ‘_dl_find_object’ function uses it to return result
     data to the caller.

     ‘unsigned long long int dlfo_flags’
          Currently unused and always 0.

     ‘void *dlfo_map_start’
          The start address of the inspected mapping.  This information
          comes from the program header, so it follows its convention,
          and the address is not necessarily page-aligned.

     ‘void *dlfo_map_end’
          The end address of the mapping.

     ‘struct link_map *dlf_link_map’
          This member contains a pointer to the link map of the object.

     ‘struct link_map *dlf_link_map’
          This member contains a pointer to the exception handling data
          of the object.  See ‘DLFO_EH_SEGMENT_TYPE’ below.

     This structure is a GNU extension.

 -- Macro: int DLFO_STRUCT_HAS_EH_DBASE

     On most targets, this macro is defined as ‘0’.  If it is defined to
     ‘1’, ‘struct dl_find_object’ contains an additional member
     ‘dlfo_eh_dbase’ of type ‘void *’.  It is the base address for
     ‘DW_EH_PE_datarel’ DWARF encodings to this location.

     This macro is a GNU extension.

 -- Macro: int DLFO_STRUCT_HAS_EH_COUNT

     On most targets, this macro is defined as ‘0’.  If it is defined to
     ‘1’, ‘struct dl_find_object’ contains an additional member
     ‘dlfo_eh_count’ of type ‘int’.  It is the number of exception
     handling entries in the EH frame segment identified by the
     ‘dlfo_eh_frame’ member.

     This macro is a GNU extension.

 -- Macro: int DLFO_EH_SEGMENT_TYPE

     On targets using DWARF-based exception unwinding, this macro
     expands to ‘PT_GNU_EH_FRAME’.  This indicates that ‘dlfo_eh_frame’
     in ‘struct dl_find_object’ points to the ‘PT_GNU_EH_FRAME’ segment
     of the object.  On targets that use other unwinding formats, the
     macro expands to the program header type for the unwinding data.

     This macro is a GNU extension.

 -- Function: int _dl_find_object (void *ADDRESS, struct dl_find_object
          *RESULT)

     | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

     On success, this function returns 0 and writes about the object
     surrounding the address to ‘*RESULT’.  On failure, -1 is returned.

     The ADDRESS can be a code address or data address.  On
     architectures using function descriptors, no attempt is made to
     decode the function descriptor.  Depending on how these descriptors
     are implemented, ‘_dl_find_object’ may return the object that
     defines the function descriptor (and not the object that contains
     the code implementing the function), or fail to find any object at
     all.

     On success ADDRESS is greater than or equal to
     ‘RESULT->dlfo_map_start’ and less than ‘RESULT->dlfo_map_end’, that
     is, the supplied code address is located within the reported
     mapping.

     This function returns a pointer to the unwinding information for
     the object that contains the program code ADDRESS in
     ‘RESULT->dlfo_eh_frame’.  If the platform uses DWARF unwinding
     information, this is the in-memory address of the ‘PT_GNU_EH_FRAME’
     segment.  See ‘DLFO_EH_SEGMENT_TYPE’ above.  In case ADDRESS
     resides in an object that lacks unwinding information, the function
     still returns 0, but sets ‘RESULT->dlfo_eh_frame’ to a null
     pointer.

     ‘_dl_find_object’ itself is thread-safe.  However, if the
     application invokes ‘dlclose’ for the object that contains ADDRESS
     concurrently with ‘_dl_find_object’ or after the call returns,
     accessing the unwinding data for that object or the link map
     (through ‘RESULT->dlfo_link_map’) is not safe.  Therefore, the
     application needs to ensure by other means (e.g., by convention)
     that ADDRESS remains a valid code address while the unwinding
     information is processed.

     This function is a GNU extension.

37 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.

37.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
     allocation, 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 triggered 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_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.

 -- Probe: memory_tunable_tcache_max_bytes (int $ARG1, int $ARG2)
     This probe is triggered when the ‘glibc.malloc.tcache_max’ tunable
     is set.  Argument $ARG1 is the requested value, and $ARG2 is the
     previous value of this tunable.

 -- Probe: memory_tunable_tcache_count (int $ARG1, int $ARG2)
     This probe is triggered when the ‘glibc.malloc.tcache_count’
     tunable is set.  Argument $ARG1 is the requested value, and $ARG2
     is the previous value of this tunable.

 -- Probe: memory_tunable_tcache_unsorted_limit (int $ARG1, int $ARG2)
     This probe is triggered when the
     ‘glibc.malloc.tcache_unsorted_limit’ tunable is set.  Argument
     $ARG1 is the requested value, and $ARG2 is the previous value of
     this tunable.

 -- Probe: memory_tcache_double_free (void *$ARG1, int $ARG2)
     This probe is triggered when ‘free’ determines that the memory
     being freed has probably already been freed, and resides in the
     per-thread cache.  Note that there is an extremely unlikely chance
     that this probe will trigger due to random payload data remaining
     in the allocated memory matching the key used to detect double
     frees.  This probe actually indicates that an expensive linear
     search of the tcache, looking for a double free, has happened.
     Argument $ARG1 is the memory location as passed to ‘free’, Argument
     $ARG2 is the tcache bin it resides in.

37.2 Non-local Goto Probes
==========================

These probes are used to signal calls to ‘setjmp’, ‘sigsetjmp’,
‘longjmp’ or ‘siglongjmp’.

 -- Probe: setjmp (void *$ARG1, int $ARG2, void *$ARG3)
     This probe is triggered whenever ‘setjmp’ or ‘sigsetjmp’ is called.
     Argument $ARG1 is a pointer to the ‘jmp_buf’ passed as the first
     argument of ‘setjmp’ or ‘sigsetjmp’, $ARG2 is the second argument
     of ‘sigsetjmp’ or zero if this is a call to ‘setjmp’ and $ARG3 is a
     pointer to the return address that will be stored in the ‘jmp_buf’.

 -- Probe: longjmp (void *$ARG1, int $ARG2, void *$ARG3)
     This probe is triggered whenever ‘longjmp’ or ‘siglongjmp’ is
     called.  Argument $ARG1 is a pointer to the ‘jmp_buf’ passed as the
     first argument of ‘longjmp’ or ‘siglongjmp’, $ARG2 is the return
     value passed as the second argument of ‘longjmp’ or ‘siglongjmp’
     and $ARG3 is a pointer to the return address ‘longjmp’ or
     ‘siglongjmp’ will return to.

     The ‘longjmp’ probe is triggered at a point where the registers
     have not yet been restored to the values in the ‘jmp_buf’ and
     unwinding will show a call stack including the caller of ‘longjmp’
     or ‘siglongjmp’.

 -- Probe: longjmp_target (void *$ARG1, int $ARG2, void *$ARG3)
     This probe is triggered under the same conditions and with the same
     arguments as the ‘longjmp’ probe.

     The ‘longjmp_target’ probe is triggered at a point where the
     registers have been restored to the values in the ‘jmp_buf’ and
     unwinding will show a call stack including the caller of ‘setjmp’
     or ‘sigsetjmp’.

38 Tunables
***********

“Tunables” are a feature in the GNU C Library that allows application
authors and distribution maintainers to alter the runtime library
behavior to match their workload.  These are implemented as a set of
switches that may be modified in different ways.  The current default
method to do this is via the ‘GLIBC_TUNABLES’ environment variable by
setting it to a string of colon-separated NAME=VALUE pairs.  For
example, the following example enables ‘malloc’ checking and sets the
‘malloc’ trim threshold to 128 bytes:

     GLIBC_TUNABLES=glibc.malloc.trim_threshold=128:glibc.malloc.check=3
     export GLIBC_TUNABLES

   Tunables are not part of the GNU C Library stable ABI, and they are
subject to change or removal across releases.  Additionally, the method
to modify tunable values may change between releases and across
distributions.  It is possible to implement multiple ‘frontends’ for the
tunables allowing distributions to choose their preferred method at
build time.

   Finally, the set of tunables available may vary between distributions
as the tunables feature allows distributions to add their own tunables
under their own namespace.

   Passing ‘--list-tunables’ to the dynamic loader to print all tunables
with minimum and maximum values:

     $ /lib64/ld-linux-x86-64.so.2 --list-tunables
     glibc.rtld.nns: 0x4 (min: 0x1, max: 0x10)
     glibc.elision.skip_lock_after_retries: 3 (min: -2147483648, max: 2147483647)
     glibc.malloc.trim_threshold: 0x0 (min: 0x0, max: 0xffffffffffffffff)
     glibc.malloc.perturb: 0 (min: 0, max: 255)
     glibc.cpu.x86_shared_cache_size: 0x100000 (min: 0x0, max: 0xffffffffffffffff)
     glibc.mem.tagging: 0 (min: 0, max: 255)
     glibc.elision.tries: 3 (min: -2147483648, max: 2147483647)
     glibc.elision.enable: 0 (min: 0, max: 1)
     glibc.cpu.x86_rep_movsb_threshold: 0x1000 (min: 0x100, max: 0xffffffffffffffff)
     glibc.malloc.mxfast: 0x0 (min: 0x0, max: 0xffffffffffffffff)
     glibc.elision.skip_lock_busy: 3 (min: -2147483648, max: 2147483647)
     glibc.malloc.top_pad: 0x0 (min: 0x0, max: 0xffffffffffffffff)
     glibc.cpu.x86_rep_stosb_threshold: 0x800 (min: 0x1, max: 0xffffffffffffffff)
     glibc.cpu.x86_non_temporal_threshold: 0xc0000 (min: 0x4040, max: 0x0fffffffffffffff)
     glibc.cpu.x86_shstk:
     glibc.cpu.hwcap_mask: 0x6 (min: 0x0, max: 0xffffffffffffffff)
     glibc.malloc.mmap_max: 0 (min: -2147483648, max: 2147483647)
     glibc.elision.skip_trylock_internal_abort: 3 (min: -2147483648, max: 2147483647)
     glibc.malloc.tcache_unsorted_limit: 0x0 (min: 0x0, max: 0xffffffffffffffff)
     glibc.cpu.x86_ibt:
     glibc.cpu.hwcaps:
     glibc.elision.skip_lock_internal_abort: 3 (min: -2147483648, max: 2147483647)
     glibc.malloc.arena_max: 0x0 (min: 0x1, max: 0xffffffffffffffff)
     glibc.malloc.mmap_threshold: 0x0 (min: 0x0, max: 0xffffffffffffffff)
     glibc.cpu.x86_data_cache_size: 0x8000 (min: 0x0, max: 0xffffffffffffffff)
     glibc.malloc.tcache_count: 0x0 (min: 0x0, max: 0xffffffffffffffff)
     glibc.malloc.arena_test: 0x0 (min: 0x1, max: 0xffffffffffffffff)
     glibc.pthread.mutex_spin_count: 100 (min: 0, max: 32767)
     glibc.rtld.optional_static_tls: 0x200 (min: 0x0, max: 0xffffffffffffffff)
     glibc.malloc.tcache_max: 0x0 (min: 0x0, max: 0xffffffffffffffff)
     glibc.malloc.check: 0 (min: 0, max: 3)

38.1 Tunable names
==================

A tunable name is split into three components, a top namespace, a
tunable namespace and the tunable name.  The top namespace for tunables
implemented in the GNU C Library is ‘glibc’.  Distributions that choose
to add custom tunables in their maintained versions of the GNU C Library
may choose to do so under their own top namespace.

   The tunable namespace is a logical grouping of tunables in a single
module.  This currently holds no special significance, although that may
change in the future.

   The tunable name is the actual name of the tunable.  It is possible
that different tunable namespaces may have tunables within them that
have the same name, likewise for top namespaces.  Hence, we only support
identification of tunables by their full name, i.e.  with the top
namespace, tunable namespace and tunable name, separated by periods.

38.2 Memory Allocation Tunables
===============================

 -- Tunable namespace: glibc.malloc
     Memory allocation behavior can be modified by setting any of the
     following tunables in the ‘malloc’ namespace:

 -- Tunable: glibc.malloc.check
     This tunable supersedes the ‘MALLOC_CHECK_’ environment variable
     and is identical in features.  This tunable has no effect by
     default and needs the debug library ‘libc_malloc_debug’ to be
     preloaded using the ‘LD_PRELOAD’ environment variable.

     Setting this tunable to a non-zero value less than 4 enables a
     special (less efficient) memory allocator for the ‘malloc’ family
     of functions that is designed to be tolerant against simple errors
     such as double calls of free with the same argument, or overruns of
     a single byte (off-by-one bugs).  Not all such errors can be
     protected against, however, and memory leaks can result.  Any
     detected heap corruption results in immediate termination of the
     process.

     Like ‘MALLOC_CHECK_’, ‘glibc.malloc.check’ has a problem in that it
     diverges from normal program behavior by writing to ‘stderr’, which
     could by exploited in SUID and SGID binaries.  Therefore,
     ‘glibc.malloc.check’ is disabled by default for SUID and SGID
     binaries.  This can be enabled again by the system administrator by
     adding a file ‘/etc/suid-debug’; the content of the file could be
     anything or even empty.

 -- Tunable: glibc.malloc.top_pad
     This tunable supersedes the ‘MALLOC_TOP_PAD_’ environment variable
     and is identical in features.

     This tunable determines the amount of extra memory in bytes to
     obtain from the system when any of the arenas need to be extended.
     It also specifies the number of bytes to retain when shrinking any
     of the arenas.  This provides the necessary hysteresis in heap size
     such that excessive amounts of system calls can be avoided.

     The default value of this tunable is ‘0’.

 -- Tunable: glibc.malloc.perturb
     This tunable supersedes the ‘MALLOC_PERTURB_’ environment variable
     and is identical in features.

     If set to a non-zero value, memory blocks are initialized with
     values depending on some low order bits of this tunable when they
     are allocated (except when allocated by ‘calloc’) and freed.  This
     can be used to debug the use of uninitialized or freed heap memory.
     Note that this option does not guarantee that the freed block will
     have any specific values.  It only guarantees that the content the
     block had before it was freed will be overwritten.

     The default value of this tunable is ‘0’.

 -- Tunable: glibc.malloc.mmap_threshold
     This tunable supersedes the ‘MALLOC_MMAP_THRESHOLD_’ environment
     variable and is identical in features.

     When this tunable is set, all chunks larger than this value in
     bytes are allocated outside the normal heap, using the ‘mmap’
     system call.  This way it is guaranteed that the memory for these
     chunks can be returned to the system on ‘free’.  Note that requests
     smaller than this threshold might still be allocated via ‘mmap’.

     If this tunable is not set, the default value is set to ‘131072’
     bytes and the threshold is adjusted dynamically to suit the
     allocation patterns of the program.  If the tunable is set, the
     dynamic adjustment is disabled and the value is set as static.

 -- Tunable: glibc.malloc.trim_threshold
     This tunable supersedes the ‘MALLOC_TRIM_THRESHOLD_’ environment
     variable and is identical in features.

     The value of this tunable is the minimum size (in bytes) of the
     top-most, releasable chunk in an arena that will trigger a system
     call in order to return memory to the system from that arena.

     If this tunable is not set, the default value is set as 128 KB and
     the threshold is adjusted dynamically to suit the allocation
     patterns of the program.  If the tunable is set, the dynamic
     adjustment is disabled and the value is set as static.

 -- Tunable: glibc.malloc.mmap_max
     This tunable supersedes the ‘MALLOC_MMAP_MAX_’ environment variable
     and is identical in features.

     The value of this tunable is maximum number of chunks to allocate
     with ‘mmap’.  Setting this to zero disables all use of ‘mmap’.

     The default value of this tunable is ‘65536’.

 -- Tunable: glibc.malloc.arena_test
     This tunable supersedes the ‘MALLOC_ARENA_TEST’ environment
     variable and is identical in features.

     The ‘glibc.malloc.arena_test’ tunable specifies the number of
     arenas that can be created before the test on the limit to the
     number of arenas is conducted.  The value is ignored if
     ‘glibc.malloc.arena_max’ is set.

     The default value of this tunable is 2 for 32-bit systems and 8 for
     64-bit systems.

 -- Tunable: glibc.malloc.arena_max
     This tunable supersedes the ‘MALLOC_ARENA_MAX’ environment variable
     and is identical in features.

     This tunable sets the number of arenas to use in a process
     regardless of the number of cores in the system.

     The default value of this tunable is ‘0’, meaning that the limit on
     the number of arenas is determined by the number of CPU cores
     online.  For 32-bit systems the limit is twice the number of cores
     online and on 64-bit systems, it is 8 times the number of cores
     online.

 -- Tunable: glibc.malloc.tcache_max
     The maximum size of a request (in bytes) which may be met via the
     per-thread cache.  The default (and maximum) value is 1032 bytes on
     64-bit systems and 516 bytes on 32-bit systems.

 -- Tunable: glibc.malloc.tcache_count
     The maximum number of chunks of each size to cache.  The default is
     7.  The upper limit is 65535.  If set to zero, the per-thread cache
     is effectively disabled.

     The approximate maximum overhead of the per-thread cache is thus
     equal to the number of bins times the chunk count in each bin times
     the size of each chunk.  With defaults, the approximate maximum
     overhead of the per-thread cache is approximately 236 KB on 64-bit
     systems and 118 KB on 32-bit systems.

 -- Tunable: glibc.malloc.tcache_unsorted_limit
     When the user requests memory and the request cannot be met via the
     per-thread cache, the arenas are used to meet the request.  At this
     time, additional chunks will be moved from existing arena lists to
     pre-fill the corresponding cache.  While copies from the fastbins,
     smallbins, and regular bins are bounded and predictable due to the
     bin sizes, copies from the unsorted bin are not bounded, and incur
     additional time penalties as they need to be sorted as they’re
     scanned.  To make scanning the unsorted list more predictable and
     bounded, the user may set this tunable to limit the number of
     chunks that are scanned from the unsorted list while searching for
     chunks to pre-fill the per-thread cache with.  The default, or when
     set to zero, is no limit.

 -- Tunable: glibc.malloc.mxfast
     One of the optimizations ‘malloc’ uses is to maintain a series of
     “fast bins” that hold chunks up to a specific size.  The default
     and maximum size which may be held this way is 80 bytes on 32-bit
     systems or 160 bytes on 64-bit systems.  Applications which value
     size over speed may choose to reduce the size of requests which are
     serviced from fast bins with this tunable.  Note that the value
     specified includes ‘malloc’’s internal overhead, which is normally
     the size of one pointer, so add 4 on 32-bit systems or 8 on 64-bit
     systems to the size passed to ‘malloc’ for the largest bin size to
     enable.

 -- Tunable: glibc.malloc.hugetlb
     This tunable controls the usage of Huge Pages on ‘malloc’ calls.
     The default value is ‘0’, which disables any additional support on
     ‘malloc’.

     Setting its value to ‘1’ enables the use of ‘madvise’ with
     ‘MADV_HUGEPAGE’ after memory allocation with ‘mmap’.  It is enabled
     only if the system supports Transparent Huge Page (currently only
     on Linux).

     Setting its value to ‘2’ enables the use of Huge Page directly with
     ‘mmap’ with the use of ‘MAP_HUGETLB’ flag.  The huge page size to
     use will be the default one provided by the system.  A value larger
     than ‘2’ specifies huge page size, which will be matched against
     the system supported ones.  If provided value is invalid,
     ‘MAP_HUGETLB’ will not be used.

38.3 Dynamic Linking Tunables
=============================

 -- Tunable namespace: glibc.rtld
     Dynamic linker behavior can be modified by setting the following
     tunables in the ‘rtld’ namespace:

 -- Tunable: glibc.rtld.nns
     Sets the number of supported dynamic link namespaces (see
     ‘dlmopen’).  Currently this limit can be set between 1 and 16
     inclusive, the default is 4.  Each link namespace consumes some
     memory in all thread, and thus raising the limit will increase the
     amount of memory each thread uses.  Raising the limit is useful
     when your application uses more than 4 dynamic link namespaces as
     created by ‘dlmopen’ with an lmid argument of ‘LM_ID_NEWLM’.
     Dynamic linker audit modules are loaded in their own dynamic link
     namespaces, but they are not accounted for in ‘glibc.rtld.nns’.
     They implicitly increase the per-thread memory usage as necessary,
     so this tunable does not need to be changed to allow many audit
     modules e.g.  via ‘LD_AUDIT’.

 -- Tunable: glibc.rtld.optional_static_tls
     Sets the amount of surplus static TLS in bytes to allocate at
     program startup.  Every thread created allocates this amount of
     specified surplus static TLS. This is a minimum value and
     additional space may be allocated for internal purposes including
     alignment.  Optional static TLS is used for optimizing dynamic TLS
     access for platforms that support such optimizations e.g.  TLS
     descriptors or optimized TLS access for POWER (‘DT_PPC64_OPT’ and
     ‘DT_PPC_OPT’).  In order to make the best use of such optimizations
     the value should be as many bytes as would be required to hold all
     TLS variables in all dynamic loaded shared libraries.  The value
     cannot be known by the dynamic loader because it doesn’t know the
     expected set of shared libraries which will be loaded.  The
     existing static TLS space cannot be changed once allocated at
     process startup.  The default allocation of optional static TLS is
     512 bytes and is allocated in every thread.

 -- Tunable: glibc.rtld.dynamic_sort
     Sets the algorithm to use for DSO sorting, valid values are ‘1’ and
     ‘2’.  For value of ‘1’, an older O(n^3) algorithm is used, which is
     long time tested, but may have performance issues when dependencies
     between shared objects contain cycles due to circular dependencies.
     When set to the value of ‘2’, a different algorithm is used, which
     implements a topological sort through depth-first search, and does
     not exhibit the performance issues of ‘1’.

     The default value of this tunable is ‘2’.

38.4 Elision Tunables
=====================

 -- Tunable namespace: glibc.elision
     Contended locks are usually slow and can lead to performance and
     scalability issues in multithread code.  Lock elision will use
     memory transactions to under certain conditions, to elide locks and
     improve performance.  Elision behavior can be modified by setting
     the following tunables in the ‘elision’ namespace:

 -- Tunable: glibc.elision.enable
     The ‘glibc.elision.enable’ tunable enables lock elision if the
     feature is supported by the hardware.  If elision is not supported
     by the hardware this tunable has no effect.

     Elision tunables are supported for 64-bit Intel, IBM POWER, and z
     System architectures.

 -- Tunable: glibc.elision.skip_lock_busy
     The ‘glibc.elision.skip_lock_busy’ tunable sets how many times to
     use a non-transactional lock after a transactional failure has
     occurred because the lock is already acquired.  Expressed in number
     of lock acquisition attempts.

     The default value of this tunable is ‘3’.

 -- Tunable: glibc.elision.skip_lock_internal_abort
     The ‘glibc.elision.skip_lock_internal_abort’ tunable sets how many
     times the thread should avoid using elision if a transaction
     aborted for any reason other than a different thread’s memory
     accesses.  Expressed in number of lock acquisition attempts.

     The default value of this tunable is ‘3’.

 -- Tunable: glibc.elision.skip_lock_after_retries
     The ‘glibc.elision.skip_lock_after_retries’ tunable sets how many
     times to try to elide a lock with transactions, that only failed
     due to a different thread’s memory accesses, before falling back to
     regular lock.  Expressed in number of lock elision attempts.

     This tunable is supported only on IBM POWER, and z System
     architectures.

     The default value of this tunable is ‘3’.

 -- Tunable: glibc.elision.tries
     The ‘glibc.elision.tries’ sets how many times to retry elision if
     there is chance for the transaction to finish execution e.g., it
     wasn’t aborted due to the lock being already acquired.  If elision
     is not supported by the hardware this tunable is set to ‘0’ to
     avoid retries.

     The default value of this tunable is ‘3’.

 -- Tunable: glibc.elision.skip_trylock_internal_abort
     The ‘glibc.elision.skip_trylock_internal_abort’ tunable sets how
     many times the thread should avoid trying the lock if a transaction
     aborted due to reasons other than a different thread’s memory
     accesses.  Expressed in number of try lock attempts.

     The default value of this tunable is ‘3’.