This is libc.info, produced by makeinfo version 5.1 from libc.texinfo. This is ‘The GNU C Library Reference Manual’, for version 2.36 (Arm). 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.” INFO-DIR-SECTION Software libraries START-INFO-DIR-ENTRY * Libc: (libc). C library. END-INFO-DIR-ENTRY INFO-DIR-SECTION GNU C library functions and macros START-INFO-DIR-ENTRY * ALTWERASE: (libc)Local Modes. * ARGP_ERR_UNKNOWN: (libc)Argp Parser Functions. * ARG_MAX: (libc)General Limits. * BC_BASE_MAX: (libc)Utility Limits. * BC_DIM_MAX: (libc)Utility Limits. * BC_SCALE_MAX: (libc)Utility Limits. * BC_STRING_MAX: (libc)Utility Limits. * BRKINT: (libc)Input Modes. * BUFSIZ: (libc)Controlling Buffering. * CCTS_OFLOW: (libc)Control Modes. * 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  File: libc.info, Node: Scanning All Groups, Prev: Lookup Group, Up: Group Database 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 | *Note 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 | *Note 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 | *Note 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 | *Note 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 | *Note 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 | *Note POSIX Safety Concepts::. This function closes the internal stream used by ‘getgrent’ or ‘getgrent_r’.  File: libc.info, Node: Database Example, Next: Netgroup Database, Prev: Group Database, Up: Users and Groups 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 #include #include #include #include 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  File: libc.info, Node: Netgroup Database, Prev: Database Example, Up: Users and Groups 30.16 Netgroup Database ======================= * Menu: * Netgroup Data:: Data in the Netgroup database and where it comes from. * Lookup Netgroup:: How to look for a particular netgroup. * Netgroup Membership:: How to test for netgroup membership.  File: libc.info, Node: Netgroup Data, Next: Lookup Netgroup, Up: Netgroup Database 30.16.1 Netgroup Data --------------------- Sometimes it is useful to group users according to other criteria (*note 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, *note 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.  File: libc.info, Node: Lookup Netgroup, Next: Netgroup Membership, Prev: Netgroup Data, Up: Netgroup Database 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 | *Note 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 | *Note 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 | *Note 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 | *Note 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.  File: libc.info, Node: Netgroup Membership, Prev: Lookup Netgroup, Up: Netgroup Database 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 | *Note 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.  File: libc.info, Node: System Management, Next: System Configuration, Prev: Users and Groups, Up: Top 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. * Menu: * Host Identification:: Determining the name of the machine. * Platform Type:: Determining operating system and basic machine type * Filesystem Handling:: Controlling/querying mounts To get information on parameters of the system that are built into the system, such as the maximum length of a filename, *note System Configuration::.  File: libc.info, Node: Host Identification, Next: Platform Type, Up: System Management 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 *note 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 | *Note 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 | *Note 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 | *Note 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 | *Note 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 | *Note 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, *Note Host Addresses::. -- Function: int sethostid (long int ID) Preliminary: | MT-Unsafe const:hostid | AS-Unsafe | AC-Unsafe corrupt fd | *Note 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.  File: libc.info, Node: Platform Type, Next: Filesystem Handling, Prev: Host Identification, Up: System Management 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 *note 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 *note 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 *note 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 | *Note 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.  File: libc.info, Node: Filesystem Handling, Prev: Platform Type, Up: System Management 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. * Menu: * Mount Information:: What is or could be mounted? * Mount-Unmount-Remount:: Controlling what is mounted and how  File: libc.info, Node: Mount Information, Next: Mount-Unmount-Remount, Up: Filesystem Handling 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. * Menu: * fstab:: The ‘fstab’ file * mtab:: The ‘mtab’ file * Other Mount Information:: Other (non-libc) sources of mount information  File: libc.info, Node: fstab, Next: mtab, Up: Mount Information 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 *note Suboptions::. ‘const char *fs_type’ This name is poorly chosen. This element points to a string (possibly in the ‘fs_mntops’ string) which describes the modes with which the filesystem is mounted. ‘fstab’ defines five macros to describe the possible values: ‘FSTAB_RW’ The 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 | *Note POSIX Safety Concepts::. This function makes sure that the internal read pointer for the ‘fstab’ file is at the beginning of the file. This is done by either opening the file or resetting the read pointer. Since the file handle is internal to the libc this function is not thread-safe. This function returns a non-zero value if the operation was successful and the ‘getfs*’ functions can be used to read the entries of the file. -- Function: void endfsent (void) Preliminary: | MT-Unsafe race:fsent | AS-Unsafe heap corrupt lock | AC-Unsafe corrupt lock mem fd | *Note POSIX Safety Concepts::. This function makes sure that all resources acquired by a prior call to ‘setfsent’ (explicitly or implicitly by calling ‘getfsent’) are freed. -- Function: struct fstab * getfsent (void) Preliminary: | MT-Unsafe race:fsent locale | AS-Unsafe corrupt heap lock | AC-Unsafe corrupt lock mem | *Note POSIX Safety Concepts::. This function returns the next entry of the ‘fstab’ file. If this is the first call to any of the functions handling ‘fstab’ since program start or the last call of ‘endfsent’, the file will be opened. The function returns a pointer to a variable of type ‘struct fstab’. This variable is shared by all threads and therefore this function is not thread-safe. If an error occurred ‘getfsent’ returns a ‘NULL’ pointer. -- Function: struct fstab * getfsspec (const char *NAME) Preliminary: | MT-Unsafe race:fsent locale | AS-Unsafe corrupt heap lock | AC-Unsafe corrupt lock mem | *Note POSIX Safety Concepts::. This function returns the next entry of the ‘fstab’ file which has a string equal to NAME pointed to by the ‘fs_spec’ element. Since there is normally exactly one entry for each special device it makes no sense to call this function more than once for the same argument. If this is the first call to any of the functions handling ‘fstab’ since program start or the last call of ‘endfsent’, the file will be opened. The function returns a pointer to a variable of type ‘struct fstab’. This variable is shared by all threads and therefore this function is not thread-safe. If an error occurred ‘getfsent’ returns a ‘NULL’ pointer. -- Function: struct fstab * getfsfile (const char *NAME) Preliminary: | MT-Unsafe race:fsent locale | AS-Unsafe corrupt heap lock | AC-Unsafe corrupt lock mem | *Note POSIX Safety Concepts::. This function returns the next entry of the ‘fstab’ file which has a string equal to NAME pointed to by the ‘fs_file’ element. Since there is normally exactly one entry for each mount point it makes no sense to call this function more than once for the same argument. If this is the first call to any of the functions handling ‘fstab’ since program start or the last call of ‘endfsent’, the file will be opened. The function returns a pointer to a variable of type ‘struct fstab’. This variable is shared by all threads and therefore this function is not thread-safe. If an error occurred ‘getfsent’ returns a ‘NULL’ pointer.  File: libc.info, Node: mtab, Next: Other Mount Information, Prev: fstab, Up: Mount Information 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’ (*note Suboptions::) to access the parts of this string. The ‘mntent.h’ file defines a number of macros with string values which correspond to some of the options understood by the kernel. There might be many more options which are possible so it doesn’t make much sense to rely on these macros but to be consistent here is the list: ‘MNTOPT_DEFAULTS’ Expands to ‘"defaults"’. This option should be used alone since it indicates all values for the customizable values are chosen to be the default. ‘MNTOPT_RO’ Expands to ‘"ro"’. See the ‘FSTAB_RO’ value, it means the filesystem is mounted read-only. ‘MNTOPT_RW’ 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 (*note How Change Persona::) is respected when a program from the filesystem is started. ‘MNTOPT_NOSUID’ Expands to ‘"nosuid"’. This is the opposite of ‘MNTOPT_SUID’, the SUID bit for all files from the filesystem is ignored. ‘MNTOPT_NOAUTO’ Expands to ‘"noauto"’. At startup time the ‘mount’ program will ignore this entry if it is started with the ‘-a’ option to mount all filesystems mentioned in the ‘fstab’ file. As for the ‘FSTAB_*’ entries introduced above it is important to use ‘strcmp’ to check for equality. ‘mnt_freq’ This elements corresponds to ‘fs_freq’ and also specifies the frequency in days in which dumps are made. ‘mnt_passno’ This element is equivalent to ‘fs_passno’ with the same meaning which is uninteresting for all programs beside ‘dump’. For accessing the ‘mtab’ file there is again a set of three functions to access all entries in a row. Unlike the functions to handle ‘fstab’ these functions do not access a fixed file and there is even a thread safe variant of the get function. 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 | *Note POSIX Safety Concepts::. The ‘setmntent’ function prepares the file named FILE which must be in the format of a ‘fstab’ and ‘mtab’ file for the upcoming processing through the other functions of the family. The MODE parameter can be chosen in the way the OPENTYPE parameter for ‘fopen’ (*note Opening Streams::) can be chosen. If the file is opened for writing the file is also allowed to be empty. If the file was successfully opened ‘setmntent’ returns a file 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 | *Note POSIX Safety Concepts::. This function takes for the STREAM parameter a file handle which previously was returned from the ‘setmntent’ call. ‘endmntent’ closes the stream and frees all resources. The return value is 1 unless an error occurred in which case it is 0. -- Function: struct mntent * getmntent (FILE *STREAM) Preliminary: | MT-Unsafe race:mntentbuf locale | AS-Unsafe corrupt heap init | AC-Unsafe init corrupt lock mem | *Note POSIX Safety Concepts::. The ‘getmntent’ function takes as the parameter a file handle previously returned by 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 | *Note POSIX Safety Concepts::. The ‘getmntent_r’ function is the reentrant variant of ‘getmntent’. It also returns the next entry from the file and returns a pointer. The actual variable the values are stored in is not static, though. Instead the function stores the values in the variable pointed to by the RESULT parameter. Additional information (e.g., the strings pointed to by the elements of the result) are kept in the buffer of size BUFSIZE pointed to by BUFFER. Escaped characters (space, tab, backslash) are converted back in the same way as it happens for ‘getmentent’. The function returns a ‘NULL’ pointer in error cases. Errors could be: • error while reading the file, • end of file reached, • BUFSIZE is too small for reading a complete new entry. -- Function: int addmntent (FILE *STREAM, const struct mntent *MNT) Preliminary: | MT-Safe race:stream locale | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘addmntent’ function allows adding a new entry to the file previously opened with ‘setmntent’. The new entries are always appended. I.e., even if the position of the file descriptor is not at the end of the file this function does not overwrite an existing entry following the current position. The implication of this is that to remove an entry from a file one has to create a new file while leaving out the entry to be removed and after closing the file remove the old one and rename the new file to the chosen name. This function takes care of spaces and tab characters in the names to be written to the file. It converts them and the backslash character into the format 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 | *Note POSIX Safety Concepts::. This function can be used to check whether the string pointed to by the ‘mnt_opts’ element of the variable pointed to by MNT contains the option OPT. If this is true a pointer to the beginning of the option in the ‘mnt_opts’ element is returned. If no such option exists the function returns ‘NULL’. This function is useful to test whether a specific option is present but when all options have to be processed one is better off with using the ‘getsubopt’ function to iterate over all options in the string.  File: libc.info, Node: Other Mount Information, Prev: mtab, Up: Mount Information 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.  File: libc.info, Node: Mount-Unmount-Remount, Prev: Mount Information, Up: Filesystem Handling 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. *Note Mount Information::. The symbols in this section are declared in ‘sys/mount.h’. -- Function: int mount (const char *SPECIAL_FILE, const char *DIR, const char *FSTYPE, unsigned long int OPTIONS, const void *DATA) Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. ‘mount’ mounts or remounts a filesystem. The two operations are quite different and are merged rather unnaturally into this one function. The ‘MS_REMOUNT’ option, explained below, determines whether ‘mount’ mounts or remounts. For a mount, the filesystem on the block device represented by the device special file named SPECIAL_FILE gets mounted over the mount point DIR. This means that the directory DIR (along with any files in it) is no longer visible; in its place (and still with the name DIR) is the root directory of the filesystem on the device. As an exception, if the filesystem type (see below) is one which is not based on a device (e.g. “proc”), ‘mount’ instantiates a filesystem and mounts it over DIR and ignores SPECIAL_FILE. For a remount, DIR specifies the mount point where the filesystem to be remounted is (and remains) mounted and SPECIAL_FILE is ignored. Remounting a filesystem means changing the options that control operations on the filesystem while it is mounted. It does not mean unmounting and mounting again. For a mount, you must identify the type of the filesystem 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 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. *Note Mount Information::. The return value is zero if the mount or remount is successful. Otherwise, it is ‘-1’ and ‘errno’ is set appropriately. The values of ‘errno’ are filesystem dependent, but here is a general list: ‘EPERM’ The process is not superuser. ‘ENODEV’ The file system type FSTYPE is not known to the kernel. ‘ENOTBLK’ The file DEV is not a block device special file. ‘EBUSY’ • The device is already mounted. • The mount point is busy. (E.g. it is some process’ working directory or has a filesystem mounted on it already). • The request is to remount read-only, but there are files open for 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 | *Note POSIX Safety Concepts::. ‘umount2’ unmounts a filesystem. You can identify the filesystem to unmount either by the device special file that contains the filesystem or by the mount point. The effect is the same. Specify either as the string FILE. FLAGS contains the one-bit field identified by the following mask macro: ‘MNT_FORCE’ This bit on means to force the unmounting even if the filesystem is busy, by making it unbusy first. If the bit is off and the filesystem is busy, ‘umount2’ fails with ‘errno’ = ‘EBUSY’. Depending on the filesystem, this may override all, some, or no busy conditions. All other bits in FLAGS should be set to zero; otherwise, the result is undefined. Example: #include umount2("/mnt", MNT_FORCE); umount2("/dev/hdd1", 0); After the filesystem is unmounted, the directory that was the mount point is visible, as are any files in it. As part of unmounting, ‘umount2’ syncs the filesystem. If the unmounting is successful, the return value is zero. Otherwise, it is ‘-1’ and ‘errno’ is set accordingly: ‘EPERM’ The process is not superuser. ‘EBUSY’ The filesystem cannot be unmounted because it is busy. E.g. it contains a directory that is some process’s working directory or a file that some process has open. With some filesystems in some cases, you can avoid this failure with the ‘MNT_FORCE’ option. ‘EINVAL’ FILE validly refers to a file, but that file is neither a mount point nor a device special file of a currently mounted filesystem. This function is not available on all systems. -- Function: int umount (const char *FILE) Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. ‘umount’ does the same thing as ‘umount2’ with FLAGS set to zeroes. It is more widely available than ‘umount2’ but since it lacks the possibility to forcefully unmount a filesystem is deprecated when ‘umount2’ is also available.  File: libc.info, Node: System Configuration, Next: Cryptographic Functions, Prev: System Management, Up: Top 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 (*note String Parameters::). * Menu: * General Limits:: Constants and functions that describe various process-related limits that have one uniform value for any given machine. * System Options:: Optional POSIX features. * Version Supported:: Version numbers of POSIX.1 and POSIX.2. * Sysconf:: Getting specific configuration values of general limits and system options. * Minimums:: Minimum values for general limits. * Limits for Files:: Size limitations that pertain to individual files. These can vary between file systems or even from file to file. * Options for Files:: Optional features that some files may support. * File Minimums:: Minimum values for file limits. * Pathconf:: Getting the limit values for a particular file. * Utility Limits:: Capacity limits of some POSIX.2 utility programs. * Utility Minimums:: Minimum allowable values of those limits. * String Parameters:: Getting the default search path.  File: libc.info, Node: General Limits, Next: System Options, Up: System Configuration 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. *Note Sysconf::. Each of these parameters also has another macro, with a name starting with ‘_POSIX’, which gives the lowest value that the limit is allowed to have on _any_ POSIX system. *Note Minimums::. -- Macro: int ARG_MAX If defined, the unvarying maximum combined length of the ARGV and ENVIRON arguments that can be passed to the ‘exec’ functions. -- Macro: int CHILD_MAX If defined, the unvarying maximum number of processes that can exist with the same real user ID at any one time. In BSD and GNU, this is controlled by the ‘RLIMIT_NPROC’ resource limit; *note Limits on Resources::. -- Macro: int OPEN_MAX If defined, the unvarying maximum number of files that a single process can have open simultaneously. In BSD and GNU, this is controlled by the ‘RLIMIT_NOFILE’ resource limit; *note Limits on Resources::. -- Macro: int STREAM_MAX If defined, the unvarying maximum number of streams that a single process can have open simultaneously. *Note Opening Streams::. -- Macro: int TZNAME_MAX If defined, the unvarying maximum length of a time zone name. *Note Time Zone Functions::. These limit macros are always defined in ‘limits.h’. -- Macro: int NGROUPS_MAX The maximum number of supplementary group IDs that one process can have. The value of this macro is actually a lower bound for the maximum. That is, you can count on being able to have that many supplementary group IDs, but a particular machine might let you have even more. You can use ‘sysconf’ to see whether a particular machine will let you have more (*note Sysconf::). -- Macro: ssize_t SSIZE_MAX The largest value that can fit in an object of type ‘ssize_t’. Effectively, this is the limit on the number of bytes that can be read or written in a single operation. This macro is defined in all POSIX systems because this limit is never configurable. -- Macro: int RE_DUP_MAX The largest number of repetitions you are guaranteed is allowed in the construct ‘\{MIN,MAX\}’ in a regular expression. The value of this macro is actually a lower bound for the maximum. That is, you can count on being able to have that many repetitions, but a particular machine might let you have even more. You can use ‘sysconf’ to see whether a particular machine will let you have more (*note Sysconf::). And even the value that ‘sysconf’ tells you is just a lower bound—larger values might work. This macro is defined in all POSIX.2 systems, because POSIX.2 says it should always be defined even if there is no specific imposed limit.  File: libc.info, Node: System Options, Next: Version Supported, Prev: General Limits, Up: System Configuration 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. *Note Sysconf::. -- Macro: int _POSIX_JOB_CONTROL If this symbol is defined, it indicates that the system supports job control. Otherwise, the implementation behaves as if all processes within a session belong to a single process group. *Note Job Control::. 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. *Note Enable/Disable Setuid::. For the following macros, if the macro is defined in ‘unistd.h’, then its value indicates whether the option is supported. A value of ‘-1’ means no, and any other value means yes. If the macro is not defined, then the option may or may not be supported; use ‘sysconf’ to find out. *Note Sysconf::. -- Macro: int _POSIX2_C_DEV If this symbol is defined, it indicates that the system has the POSIX.2 C compiler command, ‘c89’. The GNU C Library always defines this as ‘1’, on the assumption that you would not have installed it if you didn’t have a C compiler. -- Macro: int _POSIX2_FORT_DEV If this symbol is defined, it indicates that the system has the POSIX.2 Fortran compiler command, ‘fort77’. The GNU C Library never defines this, because we don’t know what the system has. -- Macro: int _POSIX2_FORT_RUN If this symbol is defined, it indicates that the system has the POSIX.2 ‘asa’ command to interpret Fortran carriage control. The GNU C Library never defines this, because we don’t know what the system has. -- Macro: int _POSIX2_LOCALEDEF If this symbol is defined, it indicates that the system has the POSIX.2 ‘localedef’ command. The GNU C Library never defines this, because we don’t know what the system has. -- Macro: int _POSIX2_SW_DEV If this symbol is defined, it indicates that the system has the POSIX.2 commands ‘ar’, ‘make’, and ‘strip’. The GNU C Library always defines this as ‘1’, on the assumption that you had to have ‘ar’ and ‘make’ to install the library, and it’s unlikely that ‘strip’ would be absent when those are present.  File: libc.info, Node: Version Supported, Next: Sysconf, Prev: System Options, Up: System Configuration 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)’.  File: libc.info, Node: Sysconf, Next: Minimums, Prev: Version Supported, Up: System Configuration 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’. * Menu: * Sysconf Definition:: Detailed specifications of ‘sysconf’. * Constants for Sysconf:: The list of parameters ‘sysconf’ can read. * Examples of Sysconf:: How to use ‘sysconf’ and the parameter macros properly together.  File: libc.info, Node: Sysconf Definition, Next: Constants for Sysconf, Up: Sysconf 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 | *Note POSIX Safety Concepts::. This function is used to inquire about runtime system parameters. The PARAMETER argument should be one of the ‘_SC_’ symbols listed below. The normal return value from ‘sysconf’ is the value you requested. A value of ‘-1’ is returned both if the implementation does not impose a limit, and in case of an error. The following ‘errno’ error conditions are defined for this function: ‘EINVAL’ The value of the PARAMETER is invalid.  File: libc.info, Node: Constants for Sysconf, Next: Examples of Sysconf, Prev: Sysconf Definition, Up: Sysconf 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; *note CPU Time::. The corresponding parameter ‘CLK_TCK’ is obsolete. ‘_SC_CHARCLASS_NAME_MAX’ Inquire about the parameter corresponding to maximal length allowed for a character class name in an extended locale specification. These extensions are not yet standardized and so this option is not standardized as well. ‘_SC_REALTIME_SIGNALS’ Inquire about the parameter corresponding to ‘_POSIX_REALTIME_SIGNALS’. ‘_SC_PRIORITY_SCHEDULING’ Inquire about the parameter corresponding to ‘_POSIX_PRIORITY_SCHEDULING’. ‘_SC_TIMERS’ Inquire about the parameter corresponding to ‘_POSIX_TIMERS’. ‘_SC_ASYNCHRONOUS_IO’ Inquire about the parameter corresponding to ‘_POSIX_ASYNCHRONOUS_IO’. ‘_SC_PRIORITIZED_IO’ Inquire about the parameter corresponding to ‘_POSIX_PRIORITIZED_IO’. ‘_SC_SYNCHRONIZED_IO’ Inquire about the parameter corresponding to ‘_POSIX_SYNCHRONIZED_IO’. ‘_SC_FSYNC’ Inquire about the parameter corresponding to ‘_POSIX_FSYNC’. ‘_SC_MAPPED_FILES’ Inquire about the parameter corresponding to ‘_POSIX_MAPPED_FILES’. ‘_SC_MEMLOCK’ Inquire about the parameter corresponding to ‘_POSIX_MEMLOCK’. ‘_SC_MEMLOCK_RANGE’ Inquire about the parameter corresponding to ‘_POSIX_MEMLOCK_RANGE’. ‘_SC_MEMORY_PROTECTION’ Inquire about the parameter corresponding to ‘_POSIX_MEMORY_PROTECTION’. ‘_SC_MESSAGE_PASSING’ Inquire about the parameter corresponding to ‘_POSIX_MESSAGE_PASSING’. ‘_SC_SEMAPHORES’ Inquire about the parameter corresponding to ‘_POSIX_SEMAPHORES’. ‘_SC_SHARED_MEMORY_OBJECTS’ Inquire about the parameter corresponding to ‘_POSIX_SHARED_MEMORY_OBJECTS’. ‘_SC_AIO_LISTIO_MAX’ Inquire about the parameter corresponding to ‘_POSIX_AIO_LISTIO_MAX’. ‘_SC_AIO_MAX’ Inquire about the parameter corresponding to ‘_POSIX_AIO_MAX’. ‘_SC_AIO_PRIO_DELTA_MAX’ Inquire 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 (*note Query Memory Parameters::). ‘_SC_NPROCESSORS_CONF’ Inquire about the number of configured processors. ‘_SC_NPROCESSORS_ONLN’ Inquire about the number of processors online. ‘_SC_PHYS_PAGES’ Inquire about the number of physical pages in the system. ‘_SC_AVPHYS_PAGES’ Inquire about the number of available physical pages in the system. ‘_SC_ATEXIT_MAX’ Inquire about the number of functions which can be registered as termination functions for ‘atexit’; *note Cleanups on Exit::. ‘_SC_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.  File: libc.info, Node: Examples of Sysconf, Prev: Constants for Sysconf, Up: Sysconf 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 }  File: libc.info, Node: Minimums, Next: Limits for Files, Prev: Sysconf, Up: System Configuration 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’.  File: libc.info, Node: Limits for Files, Next: Options for Files, Prev: Minimums, Up: System Configuration 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. *Note Pathconf::. Each parameter also has another macro, with a name starting with ‘_POSIX’, which gives the lowest value that the limit is allowed to have on _any_ POSIX system. *Note File Minimums::. -- Macro: int LINK_MAX The uniform system limit (if any) for the number of names for a given file. *Note Hard Links::. -- Macro: int MAX_CANON The uniform system limit (if any) for the amount of text in a line of input when input editing is enabled. *Note Canonical or Not::. -- Macro: int MAX_INPUT The uniform system limit (if any) for the total number of characters typed ahead as input. *Note I/O Queues::. -- Macro: int NAME_MAX The uniform system limit (if any) for the length of a file name component, not including the terminating null character. *Portability Note:* On some systems, the GNU C Library defines ‘NAME_MAX’, but does not actually enforce this limit. -- Macro: int PATH_MAX The uniform system limit (if any) for the length of an entire file name (that is, the argument given to system calls such as ‘open’), including the terminating null character. *Portability Note:* The GNU C Library does not enforce this limit even if ‘PATH_MAX’ is defined. -- Macro: int PIPE_BUF The uniform system limit (if any) for the number of bytes that can be written atomically to a pipe. If multiple processes are writing to the same pipe simultaneously, output from different processes might be interleaved in chunks of this size. *Note Pipes and FIFOs::. These are alternative macro names for some of the same information. -- Macro: int MAXNAMLEN This is the BSD name for ‘NAME_MAX’. It is defined in ‘dirent.h’. -- Macro: int FILENAME_MAX The value of this macro is an integer constant expression that represents the maximum length of a file name string. It is defined in ‘stdio.h’. Unlike ‘PATH_MAX’, this macro is defined even if there is no actual limit imposed. In such a case, its value is typically a very large number. *This is always the case on GNU/Hurd systems.* *Usage Note:* Don’t use ‘FILENAME_MAX’ as the size of an array in which to store a file name! You can’t possibly make an array that big! Use dynamic allocation (*note Memory Allocation::) instead.  File: libc.info, Node: Options for Files, Next: File Minimums, Prev: Limits for Files, Up: System Configuration 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. *Note File Owner::. -- Macro: int _POSIX_NO_TRUNC If this option is in effect, file name components longer than ‘NAME_MAX’ generate an ‘ENAMETOOLONG’ error. Otherwise, file name components that are too long are silently truncated. -- Macro: unsigned char _POSIX_VDISABLE This option is only meaningful for files that are terminal devices. If it is enabled, then handling for special control characters can be disabled individually. *Note Special Characters::. If one of these macros is undefined, that means that the option might be in effect for some files and not for others. To inquire about a particular file, call ‘pathconf’ or ‘fpathconf’. *Note Pathconf::.  File: libc.info, Node: File Minimums, Next: Pathconf, Prev: Options for Files, Up: System Configuration 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). *Note Input Modes::. The value of this constant is ‘255’. ‘_POSIX_NAME_MAX’ The most restrictive limit permitted by POSIX for the maximum number of bytes in a file name component. The value of this constant is ‘14’. ‘_POSIX_PATH_MAX’ The most restrictive limit permitted by POSIX for the maximum number of bytes in a file name. The value of this constant is ‘256’. ‘_POSIX_PIPE_BUF’ The most restrictive limit permitted by POSIX for the maximum number of bytes that can be written atomically to a pipe. The value of this constant is ‘512’. ‘SYMLINK_MAX’ Maximum number of bytes in a symbolic link. ‘POSIX_REC_INCR_XFER_SIZE’ Recommended increment for file transfer sizes between the ‘POSIX_REC_MIN_XFER_SIZE’ and ‘POSIX_REC_MAX_XFER_SIZE’ values. ‘POSIX_REC_MAX_XFER_SIZE’ Maximum recommended file transfer size. ‘POSIX_REC_MIN_XFER_SIZE’ Minimum recommended file transfer size. ‘POSIX_REC_XFER_ALIGN’ Recommended file transfer buffer alignment.  File: libc.info, Node: Pathconf, Next: Utility Limits, Prev: File Minimums, Up: System Configuration 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 | *Note POSIX Safety Concepts::. This function is used to inquire about the limits that apply to the file named FILENAME. The PARAMETER argument should be one of the ‘_PC_’ constants listed below. The normal return value from ‘pathconf’ is the value you requested. A value of ‘-1’ is returned both if the implementation does not impose a limit, and in case of an error. In the former case, ‘errno’ is not set, while in the latter case, ‘errno’ is set to indicate the cause of the problem. So the only way to use this function robustly is to store ‘0’ into ‘errno’ just before calling it. Besides the usual file name errors (*note File Name Errors::), the following error condition is defined for this function: ‘EINVAL’ The value of PARAMETER is invalid, or the implementation doesn’t support the PARAMETER for the specific file. -- Function: long int fpathconf (int FILEDES, int PARAMETER) Preliminary: | MT-Safe | AS-Unsafe lock heap | AC-Unsafe lock fd mem | *Note POSIX Safety Concepts::. This is just like ‘pathconf’ except that an open file descriptor is used to specify the file for which information is requested, instead of a file name. The following ‘errno’ error conditions are defined for this function: ‘EBADF’ The FILEDES argument is not a valid file descriptor. ‘EINVAL’ The value of PARAMETER is invalid, or the implementation doesn’t support the PARAMETER for the specific file. Here are the symbolic constants that you can use as the PARAMETER argument to ‘pathconf’ and ‘fpathconf’. The values are all integer constants. ‘_PC_LINK_MAX’ Inquire about the value of ‘LINK_MAX’. ‘_PC_MAX_CANON’ Inquire about the value of ‘MAX_CANON’. ‘_PC_MAX_INPUT’ Inquire about the value of ‘MAX_INPUT’. ‘_PC_NAME_MAX’ Inquire about the value of ‘NAME_MAX’. ‘_PC_PATH_MAX’ Inquire about the value of ‘PATH_MAX’. ‘_PC_PIPE_BUF’ Inquire about the value of ‘PIPE_BUF’. ‘_PC_CHOWN_RESTRICTED’ Inquire about the value of ‘_POSIX_CHOWN_RESTRICTED’. ‘_PC_NO_TRUNC’ Inquire about the value of ‘_POSIX_NO_TRUNC’. ‘_PC_VDISABLE’ Inquire about the value of ‘_POSIX_VDISABLE’. ‘_PC_SYNC_IO’ Inquire about the value of ‘_POSIX_SYNC_IO’. ‘_PC_ASYNC_IO’ Inquire about the value of ‘_POSIX_ASYNC_IO’. ‘_PC_PRIO_IO’ Inquire about the value of ‘_POSIX_PRIO_IO’. ‘_PC_FILESIZEBITS’ Inquire about the availability of large files on the filesystem. ‘_PC_REC_INCR_XFER_SIZE’ Inquire about the value of ‘POSIX_REC_INCR_XFER_SIZE’. ‘_PC_REC_MAX_XFER_SIZE’ Inquire about the value of ‘POSIX_REC_MAX_XFER_SIZE’. ‘_PC_REC_MIN_XFER_SIZE’ Inquire about the value of ‘POSIX_REC_MIN_XFER_SIZE’. ‘_PC_REC_XFER_ALIGN’ Inquire about the value of ‘POSIX_REC_XFER_ALIGN’. *Portability Note:* On some systems, the GNU C Library does not enforce ‘_PC_NAME_MAX’ or ‘_PC_PATH_MAX’ limits.  File: libc.info, Node: Utility Limits, Next: Utility Minimums, Prev: Pathconf, Up: System Configuration 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.  File: libc.info, Node: Utility Minimums, Next: String Parameters, Prev: Utility Limits, Up: System Configuration 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.  File: libc.info, Node: String Parameters, Prev: Utility Minimums, Up: System Configuration 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 | *Note POSIX Safety Concepts::. This function reads the value of a string-valued system parameter, storing the string into LEN bytes of memory space starting at BUF. The PARAMETER argument should be one of the ‘_CS_’ symbols listed below. The normal return value from ‘confstr’ is the length of the string value that you asked for. If you supply a null pointer for BUF, then ‘confstr’ does not try to store the string; it just returns its length. A value of ‘0’ indicates an error. If the string you asked for is too long for the buffer (that is, longer than ‘LEN - 1’), then ‘confstr’ stores just that much (leaving room for the terminating null character). You can tell that this has happened because ‘confstr’ returns a value greater than or equal to LEN. The following ‘errno’ error conditions are defined for this function: ‘EINVAL’ The value of the PARAMETER is invalid. Currently there is just one parameter you can read with ‘confstr’: ‘_CS_PATH’ This parameter’s value is the recommended default path for searching for executable files. This is the path that a user has by default just after logging in. ‘_CS_LFS_CFLAGS’ The returned string specifies which additional flags must be given to the C compiler if a source is compiled using the ‘_LARGEFILE_SOURCE’ feature select macro; *note Feature Test Macros::. ‘_CS_LFS_LDFLAGS’ The returned string specifies which additional flags must be given to the linker if a source is compiled using the ‘_LARGEFILE_SOURCE’ feature select macro; *note Feature Test Macros::. ‘_CS_LFS_LIBS’ The returned string specifies which additional libraries must be linked to the application if a source is compiled using the ‘_LARGEFILE_SOURCE’ feature select macro; *note Feature Test Macros::. ‘_CS_LFS_LINTFLAGS’ The returned string specifies which additional flags must be given to the lint tool if a source is compiled using the ‘_LARGEFILE_SOURCE’ feature select macro; *note Feature Test Macros::. ‘_CS_LFS64_CFLAGS’ The returned string specifies which additional flags must be given to the C compiler if a source is compiled using the ‘_LARGEFILE64_SOURCE’ feature select macro; *note Feature Test Macros::. ‘_CS_LFS64_LDFLAGS’ The returned string specifies which additional flags must be given to the linker if a source is compiled using the ‘_LARGEFILE64_SOURCE’ feature select macro; *note Feature Test Macros::. ‘_CS_LFS64_LIBS’ The returned string specifies which additional libraries must be linked to the application if a source is compiled using the ‘_LARGEFILE64_SOURCE’ feature select macro; *note Feature Test Macros::. ‘_CS_LFS64_LINTFLAGS’ The returned string specifies which additional flags must be given to the lint tool if a source is compiled using the ‘_LARGEFILE64_SOURCE’ feature select macro; *note Feature Test Macros::. The way to use ‘confstr’ without any arbitrary limit on string size is to call it twice: first call it to get the length, allocate the buffer accordingly, and then call ‘confstr’ again to fill the buffer, like this: char * get_default_path (void) { size_t len = confstr (_CS_PATH, NULL, 0); char *buffer = (char *) xmalloc (len); if (confstr (_CS_PATH, buf, len + 1) == 0) { free (buffer); return NULL; } return buffer; }  File: libc.info, Node: Cryptographic Functions, Next: Debugging Support, Prev: System Configuration, Up: Top 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. * Menu: * Passphrase Storage:: One-way hashing for passphrases. * Unpredictable Bytes:: Randomness for cryptographic purposes.  File: libc.info, Node: Passphrase Storage, Next: Unpredictable Bytes, Up: Cryptographic Functions 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 (*note 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 | *Note 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 | *Note 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. *Note 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; *note Unpredictable Bytes::. #include #include #include 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 (*note User Database::). It also shows that different one-way functions produce different hashes for the same passphrase. #include #include #include #include /* ‘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; }  File: libc.info, Node: Unpredictable Bytes, Prev: Passphrase Storage, Up: Cryptographic Functions 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’ (*note Passphrase Storage::) should also be chosen at random. Some pseudo-random number generators do not provide unpredictable-enough output for cryptographic applications; *note 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 | *Note 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 | *Note 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.  File: libc.info, Node: Debugging Support, Next: Threads, Prev: Cryptographic Functions, Up: Top 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. * Menu: * Backtraces:: Obtaining and printing a back trace of the current stack.  File: libc.info, Node: Backtraces, Up: Debugging Support 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 | *Note POSIX Safety Concepts::. The ‘backtrace’ function obtains a backtrace for the current thread, as a list of pointers, and places the information into BUFFER. The argument SIZE should be the number of ‘void *’ elements that will fit into BUFFER. The return value is the actual number of entries of BUFFER that are obtained, and is at most SIZE. The pointers placed in BUFFER are actually return addresses obtained by inspecting the stack, one return address per stack frame. Note that certain compiler optimizations may interfere with obtaining a valid backtrace. Function inlining causes the inlined function to not have a stack frame; tail call optimization replaces one stack frame with another; frame pointer elimination will stop ‘backtrace’ from interpreting the stack contents correctly. -- Function: char ** backtrace_symbols (void *const *BUFFER, int SIZE) Preliminary: | MT-Safe | AS-Unsafe heap | AC-Unsafe mem lock | *Note POSIX Safety Concepts::. The ‘backtrace_symbols’ function translates the information obtained from the ‘backtrace’ function into an array of strings. The argument BUFFER should be a pointer to an array of addresses obtained via the ‘backtrace’ function, and SIZE is the number of entries in that array (the return value of ‘backtrace’). The return value is a pointer to an array of strings, which has SIZE entries just like the array BUFFER. Each string contains a printable representation of the corresponding element of BUFFER. It includes the function name (if this can be determined), an offset into the function, and the actual return address (in hexadecimal). Currently, the function name and offset 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 | *Note POSIX Safety Concepts::. The ‘backtrace_symbols_fd’ function performs the same translation as the function ‘backtrace_symbols’ function. Instead of returning the strings to the caller, it writes the strings to the file descriptor FD, one per line. It does not use the ‘malloc’ function, and can therefore be used in situations where that function might fail. The following program illustrates the use of these functions. Note that the array to contain the return addresses returned by ‘backtrace’ is allocated on the stack. Therefore code like this can be used in situations where the memory handling via ‘malloc’ does not work anymore (in which case the ‘backtrace_symbols’ has to be replaced by a ‘backtrace_symbols_fd’ call as well). The number of return addresses is normally not very large. Even complicated programs rather seldom have a nesting level of more than, say, 50 and with 200 possible entries probably all programs should be covered. #include #include #include /* 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; }  File: libc.info, Node: Threads, Next: Dynamic Linker, Prev: Debugging Support, Up: Top 35 Threads ********** This chapter describes functions used for managing threads. The GNU C Library provides two threading implementations: ISO C threads and POSIX threads. * Menu: * ISO C Threads:: Threads based on the ISO C specification. * POSIX Threads:: Threads based on the POSIX specification.  File: libc.info, Node: ISO C Threads, Next: POSIX Threads, Up: 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’. * Menu: * ISO C Threads Return Values:: Symbolic constants that represent a function’s return value. * ISO C Thread Management:: Support for basic threading. * Call Once:: Single-call functions and macros. * ISO C Mutexes:: A low-level mechanism for mutual exclusion. * ISO C Condition Variables:: High-level objects for thread synchronization. * ISO C Thread-local Storage:: Functions to support thread-local storage.  File: libc.info, Node: ISO C Threads Return Values, Next: ISO C Thread Management, Up: ISO C Threads 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.  File: libc.info, Node: ISO C Thread Management, Next: Call Once, Prev: ISO C Threads Return Values, Up: ISO C Threads 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 | *Note 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 | *Note 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 | *Note 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 | *Note 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. *Note Time Basics::, and *note 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 | *Note 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 | *Note 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’ (*note 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 | *Note 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 | *Note 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’.  File: libc.info, Node: Call Once, Next: ISO C Mutexes, Prev: ISO C Thread Management, Up: ISO C Threads 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 | *Note 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.  File: libc.info, Node: ISO C Mutexes, Next: ISO C Condition Variables, Prev: Call Once, Up: ISO C Threads 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 | *Note 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 | *Note 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 | *Note 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. *Note Time Basics::, and *note 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 | *Note 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 | *Note 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 | *Note 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.  File: libc.info, Node: ISO C Condition Variables, Next: ISO C Thread-local Storage, Prev: ISO C Mutexes, Up: ISO C Threads 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 | *Note 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 | *Note 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 | *Note 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 | *Note 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 | *Note 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. *Note Time Basics::, and *note 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 | *Note POSIX Safety Concepts::. ‘cnd_destroy’ destroys the condition variable pointed to by COND. If there are threads waiting on COND, the behavior is undefined.  File: libc.info, Node: ISO C Thread-local Storage, Prev: ISO C Condition Variables, Up: ISO C Threads 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 | *Note 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 | *Note 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 | *Note 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 | *Note POSIX Safety Concepts::. ‘tss_delete’ destroys the thread-specific storage identified by TSS_KEY.  File: libc.info, Node: POSIX Threads, Prev: ISO C Threads, Up: Threads 35.2 POSIX Threads ================== This section describes the GNU C Library POSIX Threads implementation. * Menu: * Thread-specific Data:: Support for creating and managing thread-specific data * Non-POSIX Extensions:: Additional functions to extend POSIX Thread functionality  File: libc.info, Node: Thread-specific Data, Next: Non-POSIX Extensions, Up: POSIX Threads 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 | *Note POSIX Safety Concepts::. Create a thread-specific data key for the calling thread, referenced by KEY. Objects declared with the C++11 ‘thread_local’ keyword are destroyed before thread-specific data, so they should not be used in thread-specific data destructors or even as members of the thread-specific data, since the latter is passed as an argument to the destructor function. -- Function: int pthread_key_delete (pthread_key_t KEY) Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. Destroy the thread-specific data KEY in the calling thread. The destructor for the thread-specific data is not called during destruction, nor is it called during thread exit. -- Function: void *pthread_getspecific (pthread_key_t KEY) Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. Return the thread-specific data associated with KEY in the calling thread. -- Function: int pthread_setspecific (pthread_key_t KEY, const void *VALUE) Preliminary: | MT-Safe | AS-Unsafe corrupt heap | AC-Unsafe corrupt mem | *Note POSIX Safety Concepts::. Associate the thread-specific VALUE with KEY in the calling thread.  File: libc.info, Node: Non-POSIX Extensions, Prev: Thread-specific Data, Up: POSIX Threads 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. * Menu: * Default Thread Attributes:: Setting default attributes for threads in a process. * Initial Thread Signal Mask:: Setting the initial mask of threads. * Waiting with Explicit Clocks:: Functions for waiting with an explicit clock specification. * Single-Threaded:: Detecting single-threaded execution. * Restartable Sequences:: Linux-specific restartable sequences integration.  File: libc.info, Node: Default Thread Attributes, Next: Initial Thread Signal Mask, Up: Non-POSIX Extensions 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 | *Note POSIX Safety Concepts::. Get the default attribute values and set ATTR to match. This function returns 0 on success and a non-zero error code on failure. -- Function: int pthread_setattr_default_np (pthread_attr_t *ATTR) Preliminary: | MT-Safe | AS-Unsafe heap lock | AC-Unsafe lock mem | *Note POSIX Safety Concepts::. Set the default attribute values to match the values in ATTR. The function returns 0 on success and a non-zero error code on failure. The following error codes are defined for this function: ‘EINVAL’ At least one of the values in ATTR does not qualify as valid for the attributes or the stack address is set in the attribute. ‘ENOMEM’ The system does not have sufficient memory.  File: libc.info, Node: Initial Thread Signal Mask, Next: Waiting with Explicit Clocks, Prev: Default Thread Attributes, Up: Non-POSIX Extensions 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 | *Note 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 | *Note 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.  File: libc.info, Node: Waiting with Explicit Clocks, Next: Single-Threaded, Prev: Initial Thread Signal Mask, Up: Non-POSIX Extensions 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 | *Note 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 | *Note 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 | *Note 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 | *Note 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 | *Note 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 | *Note 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’.  File: libc.info, Node: Single-Threaded, Next: Restartable Sequences, Prev: Waiting with Explicit Clocks, Up: Non-POSIX Extensions 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. *Note Built-in Functions for Memory Model Aware Atomic Operations: (gcc)__atomic Builtins. 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.  File: libc.info, Node: Restartable Sequences, Prev: Single-Threaded, Up: Non-POSIX Extensions 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 . -- 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.  File: libc.info, Node: Dynamic Linker, Next: Internal Probes, Prev: Threads, Up: Top 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". * Menu: * Dynamic Linker Introspection:: Interfaces for querying mapping information.  File: libc.info, Node: Dynamic Linker Introspection, Up: Dynamic Linker 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 | *Note 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 | *Note 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.  File: libc.info, Node: Internal Probes, Next: Tunables, Prev: Dynamic Linker, Up: Top 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. * Menu: * Memory Allocation Probes:: Probes in the memory allocation subsystem * Non-local Goto Probes:: Probes in setjmp and longjmp  File: libc.info, Node: Memory Allocation Probes, Next: Non-local Goto Probes, Up: Internal Probes 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.  File: libc.info, Node: Non-local Goto Probes, Prev: Memory Allocation Probes, Up: Internal Probes 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’.  File: libc.info, Node: Tunables, Next: Language Features, Prev: Internal Probes, Up: Top 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) * Menu: * Tunable names:: The structure of a tunable name * Memory Allocation Tunables:: Tunables in the memory allocation subsystem * Dynamic Linking Tunables:: Tunables in the dynamic linking subsystem * Elision Tunables:: Tunables in elision subsystem * POSIX Thread Tunables:: Tunables in the POSIX thread subsystem * Hardware Capability Tunables:: Tunables that modify the hardware capabilities seen by the GNU C Library * Memory Related Tunables:: Tunables that control the use of memory by the GNU C Library.  File: libc.info, Node: Tunable names, Next: Memory Allocation Tunables, Up: Tunables 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.  File: libc.info, Node: Memory Allocation Tunables, Next: Dynamic Linking Tunables, Prev: Tunable names, Up: Tunables 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.  File: libc.info, Node: Dynamic Linking Tunables, Next: Elision Tunables, Prev: Memory Allocation Tunables, Up: Tunables 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’.  File: libc.info, Node: Elision Tunables, Next: POSIX Thread Tunables, Prev: Dynamic Linking Tunables, Up: Tunables 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’.