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

File:, Node: CPU Affinity, Prev: Traditional Scheduling, Up: Priority
22.3.5 Limiting execution to certain CPUs
On a multi-processor system the operating system usually distributes the
different processes which are runnable on all available CPUs in a way
which allows the system to work most efficiently. Which processes and
threads run can be to some extend be control with the scheduling
functionality described in the last sections. But which CPU finally
executes which process or thread is not covered.
There are a number of reasons why a program might want to have
control over this aspect of the system as well:
* One thread or process is responsible for absolutely critical work
which under no circumstances must be interrupted or hindered from
making process by other process or threads using CPU resources. In
this case the special process would be confined to a CPU which no
other process or thread is allowed to use.
* The access to certain resources (RAM, I/O ports) has different
costs from different CPUs. This is the case in NUMA (Non-Uniform
Memory Architecture) machines. Preferably memory should be
accessed locally but this requirement is usually not visible to the
scheduler. Therefore forcing a process or thread to the CPUs which
have local access to the mostly used memory helps to significantly
boost the performance.
* In controlled runtimes resource allocation and book-keeping work
(for instance garbage collection) is performance local to
processors. This can help to reduce locking costs if the resources
do not have to be protected from concurrent accesses from different
The POSIX standard up to this date is of not much help to solve this
problem. The Linux kernel provides a set of interfaces to allow
specifying _affinity sets_ for a process. The scheduler will schedule
the thread or process on CPUs specified by the affinity masks. The
interfaces which the GNU C Library define follow to some extend the
Linux kernel interface.
-- Data Type: cpu_set_t
This data set is a bitset where each bit represents a CPU. How the
system's CPUs are mapped to bits in the bitset is system dependent.
The data type has a fixed size; in the unlikely case that the
number of bits are not sufficient to describe the CPUs of the
system a different interface has to be used.
This type is a GNU extension and is defined in 'sched.h'.
To manipulate the bitset, to set and reset bits, a number of macros
is defined. Some of the macros take a CPU number as a parameter. Here
it is important to never exceed the size of the bitset. The following
macro specifies the number of bits in the 'cpu_set_t' bitset.
-- Macro: int CPU_SETSIZE
The value of this macro is the maximum number of CPUs which can be
handled with a 'cpu_set_t' object.
The type 'cpu_set_t' should be considered opaque; all manipulation
should happen via the next four macros.
-- Macro: void CPU_ZERO (cpu_set_t *SET)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
This macro initializes the CPU set SET to be the empty set.
This macro is a GNU extension and is defined in 'sched.h'.
-- Macro: void CPU_SET (int CPU, cpu_set_t *SET)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
This macro adds CPU to the CPU set SET.
The CPU parameter must not have side effects since it is evaluated
more than once.
This macro is a GNU extension and is defined in 'sched.h'.
-- Macro: void CPU_CLR (int CPU, cpu_set_t *SET)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
This macro removes CPU from the CPU set SET.
The CPU parameter must not have side effects since it is evaluated
more than once.
This macro is a GNU extension and is defined in 'sched.h'.
-- Macro: int CPU_ISSET (int CPU, const cpu_set_t *SET)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
This macro returns a nonzero value (true) if CPU is a member of the
CPU set SET, and zero (false) otherwise.
The CPU parameter must not have side effects since it is evaluated
more than once.
This macro is a GNU extension and is defined in 'sched.h'.
CPU bitsets can be constructed from scratch or the currently
installed affinity mask can be retrieved from the system.
-- Function: int sched_getaffinity (pid_t PID, size_t CPUSETSIZE,
cpu_set_t *CPUSET)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
This functions stores the CPU affinity mask for the process or
thread with the ID PID in the CPUSETSIZE bytes long bitmap pointed
to by CPUSET. If successful, the function always initializes all
bits in the 'cpu_set_t' object and returns zero.
If PID does not correspond to a process or thread on the system the
or the function fails for some other reason, it returns '-1' and
'errno' is set to represent the error condition.
No process or thread with the given ID found.
The pointer CPUSET is does not point to a valid object.
This function is a GNU extension and is declared in 'sched.h'.
Note that it is not portably possible to use this information to
retrieve the information for different POSIX threads. A separate
interface must be provided for that.
-- Function: int sched_setaffinity (pid_t PID, size_t CPUSETSIZE, const
cpu_set_t *CPUSET)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
This function installs the CPUSETSIZE bytes long affinity mask
pointed to by CPUSET for the process or thread with the ID PID. If
successful the function returns zero and the scheduler will in
future take the affinity information into account.
If the function fails it will return '-1' and 'errno' is set to the
error code:
No process or thread with the given ID found.
The pointer CPUSET is does not point to a valid object.
The bitset is not valid. This might mean that the affinity
set might not leave a processor for the process or thread to
run on.
This function is a GNU extension and is declared in 'sched.h'.

File:, Node: Memory Resources, Next: Processor Resources, Prev: Priority, Up: Resource Usage And Limitation
22.4 Querying memory available resources
The amount of memory available in the system and the way it is organized
determines oftentimes the way programs can and have to work. For
functions like 'mmap' it is necessary to know about the size of
individual memory pages and knowing how much memory is available enables
a program to select appropriate sizes for, say, caches. Before we get
into these details a few words about memory subsystems in traditional
Unix systems will be given.
* Menu:
* Memory Subsystem:: Overview about traditional Unix memory handling.
* Query Memory Parameters:: How to get information about the memory

File:, Node: Memory Subsystem, Next: Query Memory Parameters, Up: Memory Resources
22.4.1 Overview about traditional Unix memory handling
Unix systems normally provide processes virtual address spaces. This
means that the addresses of the memory regions do not have to correspond
directly to the addresses of the actual physical memory which stores the
data. An extra level of indirection is introduced which translates
virtual addresses into physical addresses. This is normally done by the
hardware of the processor.
Using a virtual address space has several advantage. The most
important is process isolation. The different processes running on the
system cannot interfere directly with each other. No process can write
into the address space of another process (except when shared memory is
used but then it is wanted and controlled).
Another advantage of virtual memory is that the address space the
processes see can actually be larger than the physical memory available.
The physical memory can be extended by storage on an external media
where the content of currently unused memory regions is stored. The
address translation can then intercept accesses to these memory regions
and make memory content available again by loading the data back into
memory. This concept makes it necessary that programs which have to use
lots of memory know the difference between available virtual address
space and available physical memory. If the working set of virtual
memory of all the processes is larger than the available physical memory
the system will slow down dramatically due to constant swapping of
memory content from the memory to the storage media and back. This is
called "thrashing".
A final aspect of virtual memory which is important and follows from
what is said in the last paragraph is the granularity of the virtual
address space handling. When we said that the virtual address handling
stores memory content externally it cannot do this on a byte-by-byte
basis. The administrative overhead does not allow this (leaving alone
the processor hardware). Instead several thousand bytes are handled
together and form a "page". The size of each page is always a power of
two byte. The smallest page size in use today is 4096, with 8192,
16384, and 65536 being other popular sizes.

File:, Node: Query Memory Parameters, Prev: Memory Subsystem, Up: Memory Resources
22.4.2 How to get information about the memory subsystem?
The page size of the virtual memory the process sees is essential to
know in several situations. Some programming interface (e.g., 'mmap',
*note Memory-mapped I/O::) require the user to provide information
adjusted to the page size. In the case of 'mmap' is it necessary to
provide a length argument which is a multiple of the page size. Another
place where the knowledge about the page size is useful is in memory
allocation. If one allocates pieces of memory in larger chunks which
are then subdivided by the application code it is useful to adjust the
size of the larger blocks to the page size. If the total memory
requirement for the block is close (but not larger) to a multiple of the
page size the kernel's memory handling can work more effectively since
it only has to allocate memory pages which are fully used. (To do this
optimization it is necessary to know a bit about the memory allocator
which will require a bit of memory itself for each block and this
overhead must not push the total size over the page size multiple.
The page size traditionally was a compile time constant. But recent
development of processors changed this. Processors now support
different page sizes and they can possibly even vary among different
processes on the same system. Therefore the system should be queried at
runtime about the current page size and no assumptions (except about it
being a power of two) should be made.
The correct interface to query about the page size is 'sysconf'
(*note Sysconf Definition::) with the parameter '_SC_PAGESIZE'. There
is a much older interface available, too.
-- Function: int getpagesize (void)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
The 'getpagesize' function returns the page size of the process.
This value is fixed for the runtime of the process but can vary in
different runs of the application.
The function is declared in 'unistd.h'.
Widely available on System V derived systems is a method to get
information about the physical memory the system has. The call
sysconf (_SC_PHYS_PAGES)
returns the total number of pages of physical the system has. This does
not mean all this memory is available. This information can be found
sysconf (_SC_AVPHYS_PAGES)
These two values help to optimize applications. The value returned
for '_SC_AVPHYS_PAGES' is the amount of memory the application can use
without hindering any other process (given that no other process
increases its memory usage). The value returned for '_SC_PHYS_PAGES' is
more or less a hard limit for the working set. If all applications
together constantly use more than that amount of memory the system is in
The GNU C Library provides in addition to these already described way
to get this information two functions. They are declared in the file
'sys/sysinfo.h'. Programmers should prefer to use the 'sysconf' method
described above.
-- Function: long int get_phys_pages (void)
Preliminary: | MT-Safe | AS-Unsafe heap lock | AC-Unsafe lock fd
mem | *Note POSIX Safety Concepts::.
The 'get_phys_pages' function returns the total number of pages of
physical the system has. To get the amount of memory this number
has to be multiplied by the page size.
This function is a GNU extension.
-- Function: long int get_avphys_pages (void)
Preliminary: | MT-Safe | AS-Unsafe heap lock | AC-Unsafe lock fd
mem | *Note POSIX Safety Concepts::.
The 'get_phys_pages' function returns the number of available pages
of physical the system has. To get the amount of memory this
number has to be multiplied by the page size.
This function is a GNU extension.

File:, Node: Processor Resources, Prev: Memory Resources, Up: Resource Usage And Limitation
22.5 Learn about the processors available
The use of threads or processes with shared memory allows an application
to take advantage of all the processing power a system can provide. If
the task can be parallelized the optimal way to write an application is
to have at any time as many processes running as there are processors.
To determine the number of processors available to the system one can
which returns the number of processors the operating system configured.
But it might be possible for the operating system to disable individual
processors and so the call
returns the number of processors which are currently online (i.e.,
For these two pieces of information the GNU C Library also provides
functions to get the information directly. The functions are declared
in 'sys/sysinfo.h'.
-- Function: int get_nprocs_conf (void)
Preliminary: | MT-Safe | AS-Unsafe heap lock | AC-Unsafe lock fd
mem | *Note POSIX Safety Concepts::.
The 'get_nprocs_conf' function returns the number of processors the
operating system configured.
This function is a GNU extension.
-- Function: int get_nprocs (void)
Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | *Note POSIX Safety
The 'get_nprocs' function returns the number of available
This function is a GNU extension.
Before starting more threads it should be checked whether the
processors are not already overused. Unix systems calculate something
called the "load average". This is a number indicating how many
processes were running. This number is average over different periods
of times (normally 1, 5, and 15 minutes).
-- Function: int getloadavg (double LOADAVG[], int NELEM)
Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | *Note POSIX Safety
This function gets the 1, 5 and 15 minute load averages of the
system. The values are placed in LOADAVG. 'getloadavg' will place
at most NELEM elements into the array but never more than three
elements. The return value is the number of elements written to
LOADAVG, or -1 on error.
This function is declared in 'stdlib.h'.

File:, Node: Non-Local Exits, Next: Signal Handling, Prev: Resource Usage And Limitation, Up: Top
23 Non-Local Exits
Sometimes when your program detects an unusual situation inside a deeply
nested set of function calls, you would like to be able to immediately
return to an outer level of control. This section describes how you can
do such "non-local exits" using the 'setjmp' and 'longjmp' functions.
* Menu:
* Intro: Non-Local Intro. When and how to use these facilities.
* Details: Non-Local Details. Functions for non-local exits.
* Non-Local Exits and Signals:: Portability issues.
* System V contexts:: Complete context control a la System V.

File:, Node: Non-Local Intro, Next: Non-Local Details, Up: Non-Local Exits
23.1 Introduction to Non-Local Exits
As an example of a situation where a non-local exit can be useful,
suppose you have an interactive program that has a "main loop" that
prompts for and executes commands. Suppose the "read" command reads
input from a file, doing some lexical analysis and parsing of the input
while processing it. If a low-level input error is detected, it would
be useful to be able to return immediately to the "main loop" instead of
having to make each of the lexical analysis, parsing, and processing
phases all have to explicitly deal with error situations initially
detected by nested calls.
(On the other hand, if each of these phases has to do a substantial
amount of cleanup when it exits--such as closing files, deallocating
buffers or other data structures, and the like--then it can be more
appropriate to do a normal return and have each phase do its own
cleanup, because a non-local exit would bypass the intervening phases
and their associated cleanup code entirely. Alternatively, you could
use a non-local exit but do the cleanup explicitly either before or
after returning to the "main loop".)
In some ways, a non-local exit is similar to using the 'return'
statement to return from a function. But while 'return' abandons only a
single function call, transferring control back to the point at which it
was called, a non-local exit can potentially abandon many levels of
nested function calls.
You identify return points for non-local exits by calling the
function 'setjmp'. This function saves information about the execution
environment in which the call to 'setjmp' appears in an object of type
'jmp_buf'. Execution of the program continues normally after the call
to 'setjmp', but if an exit is later made to this return point by
calling 'longjmp' with the corresponding 'jmp_buf' object, control is
transferred back to the point where 'setjmp' was called. The return
value from 'setjmp' is used to distinguish between an ordinary return
and a return made by a call to 'longjmp', so calls to 'setjmp' usually
appear in an 'if' statement.
Here is how the example program described above might be set up:
#include <setjmp.h>
#include <stdlib.h>
#include <stdio.h>
jmp_buf main_loop;
abort_to_main_loop (int status)
longjmp (main_loop, status);
main (void)
while (1)
if (setjmp (main_loop))
puts ("Back at main loop....");
do_command ();
do_command (void)
char buffer[128];
if (fgets (buffer, 128, stdin) == NULL)
abort_to_main_loop (-1);
The function 'abort_to_main_loop' causes an immediate transfer of
control back to the main loop of the program, no matter where it is
called from.
The flow of control inside the 'main' function may appear a little
mysterious at first, but it is actually a common idiom with 'setjmp'. A
normal call to 'setjmp' returns zero, so the "else" clause of the
conditional is executed. If 'abort_to_main_loop' is called somewhere
within the execution of 'do_command', then it actually appears as if the
_same_ call to 'setjmp' in 'main' were returning a second time with a
value of '-1'.
So, the general pattern for using 'setjmp' looks something like:
if (setjmp (BUFFER))
/* Code to clean up after premature return. */
/* Code to be executed normally after setting up the return point. */

File:, Node: Non-Local Details, Next: Non-Local Exits and Signals, Prev: Non-Local Intro, Up: Non-Local Exits
23.2 Details of Non-Local Exits
Here are the details on the functions and data structures used for
performing non-local exits. These facilities are declared in
-- Data Type: jmp_buf
Objects of type 'jmp_buf' hold the state information to be restored
by a non-local exit. The contents of a 'jmp_buf' identify a
specific place to return to.
-- Macro: int setjmp (jmp_buf STATE)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
When called normally, 'setjmp' stores information about the
execution state of the program in STATE and returns zero. If
'longjmp' is later used to perform a non-local exit to this STATE,
'setjmp' returns a nonzero value.
-- Function: void longjmp (jmp_buf STATE, int VALUE)
Preliminary: | MT-Safe | AS-Unsafe plugin corrupt lock/hurd |
AC-Unsafe corrupt lock/hurd | *Note POSIX Safety Concepts::.
This function restores current execution to the state saved in
STATE, and continues execution from the call to 'setjmp' that
established that return point. Returning from 'setjmp' by means of
'longjmp' returns the VALUE argument that was passed to 'longjmp',
rather than '0'. (But if VALUE is given as '0', 'setjmp' returns
There are a lot of obscure but important restrictions on the use of
'setjmp' and 'longjmp'. Most of these restrictions are present because
non-local exits require a fair amount of magic on the part of the C
compiler and can interact with other parts of the language in strange
The 'setjmp' function is actually a macro without an actual function
definition, so you shouldn't try to '#undef' it or take its address. In
addition, calls to 'setjmp' are safe in only the following contexts:
* As the test expression of a selection or iteration statement (such
as 'if', 'switch', or 'while').
* As one operand of an equality or comparison operator that appears
as the test expression of a selection or iteration statement. The
other operand must be an integer constant expression.
* As the operand of a unary '!' operator, that appears as the test
expression of a selection or iteration statement.
* By itself as an expression statement.
Return points are valid only during the dynamic extent of the
function that called 'setjmp' to establish them. If you 'longjmp' to a
return point that was established in a function that has already
returned, unpredictable and disastrous things are likely to happen.
You should use a nonzero VALUE argument to 'longjmp'. While
'longjmp' refuses to pass back a zero argument as the return value from
'setjmp', this is intended as a safety net against accidental misuse and
is not really good programming style.
When you perform a non-local exit, accessible objects generally
retain whatever values they had at the time 'longjmp' was called. The
exception is that the values of automatic variables local to the
function containing the 'setjmp' call that have been changed since the
call to 'setjmp' are indeterminate, unless you have declared them

File:, Node: Non-Local Exits and Signals, Next: System V contexts, Prev: Non-Local Details, Up: Non-Local Exits
23.3 Non-Local Exits and Signals
In BSD Unix systems, 'setjmp' and 'longjmp' also save and restore the
set of blocked signals; see *note Blocking Signals::. However, the
POSIX.1 standard requires 'setjmp' and 'longjmp' not to change the set
of blocked signals, and provides an additional pair of functions
('sigsetjmp' and 'siglongjmp') to get the BSD behavior.
The behavior of 'setjmp' and 'longjmp' in the GNU C Library is
controlled by feature test macros; see *note Feature Test Macros::. The
default in the GNU C Library is the POSIX.1 behavior rather than the BSD
The facilities in this section are declared in the header file
-- Data Type: sigjmp_buf
This is similar to 'jmp_buf', except that it can also store state
information about the set of blocked signals.
-- Function: int sigsetjmp (sigjmp_buf STATE, int SAVESIGS)
Preliminary: | MT-Safe | AS-Unsafe lock/hurd | AC-Unsafe lock/hurd
| *Note POSIX Safety Concepts::.
This is similar to 'setjmp'. If SAVESIGS is nonzero, the set of
blocked signals is saved in STATE and will be restored if a
'siglongjmp' is later performed with this STATE.
-- Function: void siglongjmp (sigjmp_buf STATE, int VALUE)
Preliminary: | MT-Safe | AS-Unsafe plugin corrupt lock/hurd |
AC-Unsafe corrupt lock/hurd | *Note POSIX Safety Concepts::.
This is similar to 'longjmp' except for the type of its STATE
argument. If the 'sigsetjmp' call that set this STATE used a
nonzero SAVESIGS flag, 'siglongjmp' also restores the set of
blocked signals.

File:, Node: System V contexts, Prev: Non-Local Exits and Signals, Up: Non-Local Exits
23.4 Complete Context Control
The Unix standard provides one more set of functions to control the
execution path and these functions are more powerful than those
discussed in this chapter so far. These function were part of the
original System V API and by this route were added to the Unix API.
Beside on branded Unix implementations these interfaces are not widely
available. Not all platforms and/or architectures the GNU C Library is
available on provide this interface. Use 'configure' to detect the
Similar to the 'jmp_buf' and 'sigjmp_buf' types used for the
variables to contain the state of the 'longjmp' functions the interfaces
of interest here have an appropriate type as well. Objects of this type
are normally much larger since more information is contained. The type
is also used in a few more places as we will see. The types and
functions described in this section are all defined and declared
respectively in the 'ucontext.h' header file.
-- Data Type: ucontext_t
The 'ucontext_t' type is defined as a structure with as least the
following elements:
'ucontext_t *uc_link'
This is a pointer to the next context structure which is used
if the context described in the current structure returns.
'sigset_t uc_sigmask'
Set of signals which are blocked when this context is used.
'stack_t uc_stack'
Stack used for this context. The value need not be (and
normally is not) the stack pointer. *Note Signal Stack::.
'mcontext_t uc_mcontext'
This element contains the actual state of the process. The
'mcontext_t' type is also defined in this header but the
definition should be treated as opaque. Any use of knowledge
of the type makes applications less portable.
Objects of this type have to be created by the user. The
initialization and modification happens through one of the following
-- Function: int getcontext (ucontext_t *UCP)
Preliminary: | MT-Safe race:ucp | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
The 'getcontext' function initializes the variable pointed to by
UCP with the context of the calling thread. The context contains
the content of the registers, the signal mask, and the current
stack. Executing the contents would start at the point where the
'getcontext' call just returned.
The function returns '0' if successful. Otherwise it returns '-1'
and sets ERRNO accordingly.
The 'getcontext' function is similar to 'setjmp' but it does not
provide an indication of whether the function returns for the first time
or whether the initialized context was used and the execution is resumed
at just that point. If this is necessary the user has to take determine
this herself. This must be done carefully since the context contains
registers which might contain register variables. This is a good
situation to define variables with 'volatile'.
Once the context variable is initialized it can be used as is or it
can be modified. The latter is normally done to implement co-routines
or similar constructs. The 'makecontext' function is what has to be
used to do that.
-- Function: void makecontext (ucontext_t *UCP, void (*FUNC) (void),
int ARGC, ...)
Preliminary: | MT-Safe race:ucp | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
The UCP parameter passed to the 'makecontext' shall be initialized
by a call to 'getcontext'. The context will be modified to in a
way so that if the context is resumed it will start by calling the
function 'func' which gets ARGC integer arguments passed. The
integer arguments which are to be passed should follow the ARGC
parameter in the call to 'makecontext'.
Before the call to this function the 'uc_stack' and 'uc_link'
element of the UCP structure should be initialized. The 'uc_stack'
element describes the stack which is used for this context. No two
contexts which are used at the same time should use the same memory
region for a stack.
The 'uc_link' element of the object pointed to by UCP should be a
pointer to the context to be executed when the function FUNC
returns or it should be a null pointer. See 'setcontext' for more
information about the exact use.
While allocating the memory for the stack one has to be careful.
Most modern processors keep track of whether a certain memory region is
allowed to contain code which is executed or not. Data segments and
heap memory is normally not tagged to allow this. The result is that
programs would fail. Examples for such code include the calling
sequences the GNU C compiler generates for calls to nested functions.
Safe ways to allocate stacks correctly include using memory on the
original threads stack or explicitly allocate memory tagged for
execution using (*note Memory-mapped I/O::).
*Compatibility note*: The current Unix standard is very imprecise
about the way the stack is allocated. All implementations seem to agree
that the 'uc_stack' element must be used but the values stored in the
elements of the 'stack_t' value are unclear. The GNU C Library and most
other Unix implementations require the 'ss_sp' value of the 'uc_stack'
element to point to the base of the memory region allocated for the
stack and the size of the memory region is stored in 'ss_size'. There
are implements out there which require 'ss_sp' to be set to the value
the stack pointer will have (which can depending on the direction the
stack grows be different). This difference makes the 'makecontext'
function hard to use and it requires detection of the platform at
compile time.
-- Function: int setcontext (const ucontext_t *UCP)
Preliminary: | MT-Safe race:ucp | AS-Unsafe corrupt | AC-Unsafe
corrupt | *Note POSIX Safety Concepts::.
The 'setcontext' function restores the context described by UCP.
The context is not modified and can be reused as often as wanted.
If the context was created by 'getcontext' execution resumes with
the registers filled with the same values and the same stack as if
the 'getcontext' call just returned.
If the context was modified with a call to 'makecontext' execution
continues with the function passed to 'makecontext' which gets the
specified parameters passed. If this function returns execution is
resumed in the context which was referenced by the 'uc_link'
element of the context structure passed to 'makecontext' at the
time of the call. If 'uc_link' was a null pointer the application
terminates normally with an exit status value of 'EXIT_SUCCESS'
(*note Program Termination::).
Since the context contains information about the stack no two
threads should use the same context at the same time. The result
in most cases would be disastrous.
The 'setcontext' function does not return unless an error occurred
in which case it returns '-1'.
The 'setcontext' function simply replaces the current context with
the one described by the UCP parameter. This is often useful but there
are situations where the current context has to be preserved.
-- Function: int swapcontext (ucontext_t *restrict OUCP, const
ucontext_t *restrict UCP)
Preliminary: | MT-Safe race:oucp race:ucp | AS-Unsafe corrupt |
AC-Unsafe corrupt | *Note POSIX Safety Concepts::.
The 'swapcontext' function is similar to 'setcontext' but instead
of just replacing the current context the latter is first saved in
the object pointed to by OUCP as if this was a call to
'getcontext'. The saved context would resume after the call to
Once the current context is saved the context described in UCP is
installed and execution continues as described in this context.
If 'swapcontext' succeeds the function does not return unless the
context OUCP is used without prior modification by 'makecontext'.
The return value in this case is '0'. If the function fails it
returns '-1' and set ERRNO accordingly.
Example for SVID Context Handling
The easiest way to use the context handling functions is as a
replacement for 'setjmp' and 'longjmp'. The context contains on most
platforms more information which might lead to less surprises but this
also means using these functions is more expensive (beside being less
random_search (int n, int (*fp) (int, ucontext_t *))
volatile int cnt = 0;
ucontext_t uc;
/* Safe current context. */
if (getcontext (&uc) < 0)
return -1;
/* If we have not tried N times try again. */
if (cnt++ < n)
/* Call the function with a new random number
and the context. */
if (fp (rand (), &uc) != 0)
/* We found what we were looking for. */
return 1;
/* Not found. */
return 0;
Using contexts in such a way enables emulating exception handling.
The search functions passed in the FP parameter could be very large,
nested, and complex which would make it complicated (or at least would
require a lot of code) to leave the function with an error value which
has to be passed down to the caller. By using the context it is
possible to leave the search function in one step and allow restarting
the search which also has the nice side effect that it can be
significantly faster.
Something which is harder to implement with 'setjmp' and 'longjmp' is
to switch temporarily to a different execution path and then resume
where execution was stopped.
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <ucontext.h>
#include <sys/time.h>
/* Set by the signal handler. */
static volatile int expired;
/* The contexts. */
static ucontext_t uc[3];
/* We do only a certain number of switches. */
static int switches;
/* This is the function doing the work. It is just a
skeleton, real code has to be filled in. */
static void
f (int n)
int m = 0;
while (1)
/* This is where the work would be done. */
if (++m % 100 == 0)
putchar ('.');
fflush (stdout);
/* Regularly the EXPIRE variable must be checked. */
if (expired)
/* We do not want the program to run forever. */
if (++switches == 20)
printf ("\nswitching from %d to %d\n", n, 3 - n);
expired = 0;
/* Switch to the other context, saving the current one. */
swapcontext (&uc[n], &uc[3 - n]);
/* This is the signal handler which simply set the variable. */
handler (int signal)
expired = 1;
main (void)
struct sigaction sa;
struct itimerval it;
char st1[8192];
char st2[8192];
/* Initialize the data structures for the interval timer. */
sa.sa_flags = SA_RESTART;
sigfillset (&sa.sa_mask);
sa.sa_handler = handler;
it.it_interval.tv_sec = 0;
it.it_interval.tv_usec = 1;
it.it_value = it.it_interval;
/* Install the timer and get the context we can manipulate. */
if (sigaction (SIGPROF, &sa, NULL) < 0
|| setitimer (ITIMER_PROF, &it, NULL) < 0
|| getcontext (&uc[1]) == -1
|| getcontext (&uc[2]) == -1)
abort ();
/* Create a context with a separate stack which causes the
function 'f' to be call with the parameter '1'.
Note that the 'uc_link' points to the main context
which will cause the program to terminate once the function
return. */
uc[1].uc_link = &uc[0];
uc[1].uc_stack.ss_sp = st1;
uc[1].uc_stack.ss_size = sizeof st1;
makecontext (&uc[1], (void (*) (void)) f, 1, 1);
/* Similarly, but '2' is passed as the parameter to 'f'. */
uc[2].uc_link = &uc[0];
uc[2].uc_stack.ss_sp = st2;
uc[2].uc_stack.ss_size = sizeof st2;
makecontext (&uc[2], (void (*) (void)) f, 1, 2);
/* Start running. */
swapcontext (&uc[0], &uc[1]);
putchar ('\n');
return 0;
This an example how the context functions can be used to implement
co-routines or cooperative multi-threading. All that has to be done is
to call every once in a while 'swapcontext' to continue running a
different context. It is not allowed to do the context switching from
the signal handler directly since neither 'setcontext' nor 'swapcontext'
are functions which can be called from a signal handler. But setting a
variable in the signal handler and checking it in the body of the
functions which are executed. Since 'swapcontext' is saving the current
context it is possible to have multiple different scheduling points in
the code. Execution will always resume where it was left.

File:, Node: Signal Handling, Next: Program Basics, Prev: Non-Local Exits, Up: Top
24 Signal Handling
A "signal" is a software interrupt delivered to a process. The
operating system uses signals to report exceptional situations to an
executing program. Some signals report errors such as references to
invalid memory addresses; others report asynchronous events, such as
disconnection of a phone line.
The GNU C Library defines a variety of signal types, each for a
particular kind of event. Some kinds of events make it inadvisable or
impossible for the program to proceed as usual, and the corresponding
signals normally abort the program. Other kinds of signals that report
harmless events are ignored by default.
If you anticipate an event that causes signals, you can define a
handler function and tell the operating system to run it when that
particular type of signal arrives.
Finally, one process can send a signal to another process; this
allows a parent process to abort a child, or two related processes to
communicate and synchronize.
* Menu:
* Concepts of Signals:: Introduction to the signal facilities.
* Standard Signals:: Particular kinds of signals with
standard names and meanings.
* Signal Actions:: Specifying what happens when a
particular signal is delivered.
* Defining Handlers:: How to write a signal handler function.
* Interrupted Primitives:: Signal handlers affect use of 'open',
'read', 'write' and other functions.
* Generating Signals:: How to send a signal to a process.
* Blocking Signals:: Making the system hold signals temporarily.
* Waiting for a Signal:: Suspending your program until a signal
* Signal Stack:: Using a Separate Signal Stack.
* BSD Signal Handling:: Additional functions for backward
compatibility with BSD.

File:, Node: Concepts of Signals, Next: Standard Signals, Up: Signal Handling
24.1 Basic Concepts of Signals
This section explains basic concepts of how signals are generated, what
happens after a signal is delivered, and how programs can handle
* Menu:
* Kinds of Signals:: Some examples of what can cause a signal.
* Signal Generation:: Concepts of why and how signals occur.
* Delivery of Signal:: Concepts of what a signal does to the

File:, Node: Kinds of Signals, Next: Signal Generation, Up: Concepts of Signals
24.1.1 Some Kinds of Signals
A signal reports the occurrence of an exceptional event. These are some
of the events that can cause (or "generate", or "raise") a signal:
* A program error such as dividing by zero or issuing an address
outside the valid range.
* A user request to interrupt or terminate the program. Most
environments are set up to let a user suspend the program by typing
'C-z', or terminate it with 'C-c'. Whatever key sequence is used,
the operating system sends the proper signal to interrupt the
* The termination of a child process.
* Expiration of a timer or alarm.
* A call to 'kill' or 'raise' by the same process.
* A call to 'kill' from another process. Signals are a limited but
useful form of interprocess communication.
* An attempt to perform an I/O operation that cannot be done.
Examples are reading from a pipe that has no writer (*note Pipes
and FIFOs::), and reading or writing to a terminal in certain
situations (*note Job Control::).
Each of these kinds of events (excepting explicit calls to 'kill' and
'raise') generates its own particular kind of signal. The various kinds
of signals are listed and described in detail in *note Standard

File:, Node: Signal Generation, Next: Delivery of Signal, Prev: Kinds of Signals, Up: Concepts of Signals
24.1.2 Concepts of Signal Generation
In general, the events that generate signals fall into three major
categories: errors, external events, and explicit requests.
An error means that a program has done something invalid and cannot
continue execution. But not all kinds of errors generate signals--in
fact, most do not. For example, opening a nonexistent file is an error,
but it does not raise a signal; instead, 'open' returns '-1'. In
general, errors that are necessarily associated with certain library
functions are reported by returning a value that indicates an error.
The errors which raise signals are those which can happen anywhere in
the program, not just in library calls. These include division by zero
and invalid memory addresses.
An external event generally has to do with I/O or other processes.
These include the arrival of input, the expiration of a timer, and the
termination of a child process.
An explicit request means the use of a library function such as
'kill' whose purpose is specifically to generate a signal.
Signals may be generated "synchronously" or "asynchronously". A
synchronous signal pertains to a specific action in the program, and is
delivered (unless blocked) during that action. Most errors generate
signals synchronously, and so do explicit requests by a process to
generate a signal for that same process. On some machines, certain
kinds of hardware errors (usually floating-point exceptions) are not
reported completely synchronously, but may arrive a few instructions
Asynchronous signals are generated by events outside the control of
the process that receives them. These signals arrive at unpredictable
times during execution. External events generate signals
asynchronously, and so do explicit requests that apply to some other
A given type of signal is either typically synchronous or typically
asynchronous. For example, signals for errors are typically synchronous
because errors generate signals synchronously. But any type of signal
can be generated synchronously or asynchronously with an explicit

File:, Node: Delivery of Signal, Prev: Signal Generation, Up: Concepts of Signals
24.1.3 How Signals Are Delivered
When a signal is generated, it becomes "pending". Normally it remains
pending for just a short period of time and then is "delivered" to the
process that was signaled. However, if that kind of signal is currently
"blocked", it may remain pending indefinitely--until signals of that
kind are "unblocked". Once unblocked, it will be delivered immediately.
*Note Blocking Signals::.
When the signal is delivered, whether right away or after a long
delay, the "specified action" for that signal is taken. For certain
signals, such as 'SIGKILL' and 'SIGSTOP', the action is fixed, but for
most signals, the program has a choice: ignore the signal, specify a
"handler function", or accept the "default action" for that kind of
signal. The program specifies its choice using functions such as
'signal' or 'sigaction' (*note Signal Actions::). We sometimes say that
a handler "catches" the signal. While the handler is running, that
particular signal is normally blocked.
If the specified action for a kind of signal is to ignore it, then
any such signal which is generated is discarded immediately. This
happens even if the signal is also blocked at the time. A signal
discarded in this way will never be delivered, not even if the program
subsequently specifies a different action for that kind of signal and
then unblocks it.
If a signal arrives which the program has neither handled nor
ignored, its "default action" takes place. Each kind of signal has its
own default action, documented below (*note Standard Signals::). For
most kinds of signals, the default action is to terminate the process.
For certain kinds of signals that represent "harmless" events, the
default action is to do nothing.
When a signal terminates a process, its parent process can determine
the cause of termination by examining the termination status code
reported by the 'wait' or 'waitpid' functions. (This is discussed in
more detail in *note Process Completion::.) The information it can get
includes the fact that termination was due to a signal and the kind of
signal involved. If a program you run from a shell is terminated by a
signal, the shell typically prints some kind of error message.
The signals that normally represent program errors have a special
property: when one of these signals terminates the process, it also
writes a "core dump file" which records the state of the process at the
time of termination. You can examine the core dump with a debugger to
investigate what caused the error.
If you raise a "program error" signal by explicit request, and this
terminates the process, it makes a core dump file just as if the signal
had been due directly to an error.

File:, Node: Standard Signals, Next: Signal Actions, Prev: Concepts of Signals, Up: Signal Handling
24.2 Standard Signals
This section lists the names for various standard kinds of signals and
describes what kind of event they mean. Each signal name is a macro
which stands for a positive integer--the "signal number" for that kind
of signal. Your programs should never make assumptions about the
numeric code for a particular kind of signal, but rather refer to them
always by the names defined here. This is because the number for a
given kind of signal can vary from system to system, but the meanings of
the names are standardized and fairly uniform.
The signal names are defined in the header file 'signal.h'.
-- Macro: int NSIG
The value of this symbolic constant is the total number of signals
defined. Since the signal numbers are allocated consecutively,
'NSIG' is also one greater than the largest defined signal number.
* Menu:
* Program Error Signals:: Used to report serious program errors.
* Termination Signals:: Used to interrupt and/or terminate the
* Alarm Signals:: Used to indicate expiration of timers.
* Asynchronous I/O Signals:: Used to indicate input is available.
* Job Control Signals:: Signals used to support job control.
* Operation Error Signals:: Used to report operational system errors.
* Miscellaneous Signals:: Miscellaneous Signals.
* Signal Messages:: Printing a message describing a signal.

File:, Node: Program Error Signals, Next: Termination Signals, Up: Standard Signals
24.2.1 Program Error Signals
The following signals are generated when a serious program error is
detected by the operating system or the computer itself. In general,
all of these signals are indications that your program is seriously
broken in some way, and there's usually no way to continue the
computation which encountered the error.
Some programs handle program error signals in order to tidy up before
terminating; for example, programs that turn off echoing of terminal
input should handle program error signals in order to turn echoing back
on. The handler should end by specifying the default action for the
signal that happened and then reraising it; this will cause the program
to terminate with that signal, as if it had not had a handler. (*Note
Termination in Handler::.)
Termination is the sensible ultimate outcome from a program error in
most programs. However, programming systems such as Lisp that can load
compiled user programs might need to keep executing even if a user
program incurs an error. These programs have handlers which use
'longjmp' to return control to the command level.
The default action for all of these signals is to cause the process
to terminate. If you block or ignore these signals or establish
handlers for them that return normally, your program will probably break
horribly when such signals happen, unless they are generated by 'raise'
or 'kill' instead of a real error.
When one of these program error signals terminates a process, it also
writes a "core dump file" which records the state of the process at the
time of termination. The core dump file is named 'core' and is written
in whichever directory is current in the process at the time. (On
GNU/Hurd systems, you can specify the file name for core dumps with the
environment variable 'COREFILE'.) The purpose of core dump files is so
that you can examine them with a debugger to investigate what caused the
-- Macro: int SIGFPE
The 'SIGFPE' signal reports a fatal arithmetic error. Although the
name is derived from "floating-point exception", this signal
actually covers all arithmetic errors, including division by zero
and overflow. If a program stores integer data in a location which
is then used in a floating-point operation, this often causes an
"invalid operation" exception, because the processor cannot
recognize the data as a floating-point number.
Actual floating-point exceptions are a complicated subject because
there are many types of exceptions with subtly different meanings,
and the 'SIGFPE' signal doesn't distinguish between them. The
'IEEE Standard for Binary Floating-Point Arithmetic (ANSI/IEEE Std
754-1985 and ANSI/IEEE Std 854-1987)' defines various
floating-point exceptions and requires conforming computer systems
to report their occurrences. However, this standard does not
specify how the exceptions are reported, or what kinds of handling
and control the operating system can offer to the programmer.
BSD systems provide the 'SIGFPE' handler with an extra argument that
distinguishes various causes of the exception. In order to access this
argument, you must define the handler to accept two arguments, which
means you must cast it to a one-argument function type in order to
establish the handler. The GNU C Library does provide this extra
argument, but the value is meaningful only on operating systems that
provide the information (BSD systems and GNU systems).
Integer overflow (impossible in a C program unless you enable
overflow trapping in a hardware-specific fashion).
Integer division by zero.
Subscript-range (something that C programs never check for).
Floating overflow trap.
Floating/decimal division by zero.
Floating underflow trap. (Trapping on floating underflow is not
normally enabled.)
Decimal overflow trap. (Only a few machines have decimal
arithmetic and C never uses it.)
-- Macro: int SIGILL
The name of this signal is derived from "illegal instruction"; it
usually means your program is trying to execute garbage or a
privileged instruction. Since the C compiler generates only valid
instructions, 'SIGILL' typically indicates that the executable file
is corrupted, or that you are trying to execute data. Some common
ways of getting into the latter situation are by passing an invalid
object where a pointer to a function was expected, or by writing
past the end of an automatic array (or similar problems with
pointers to automatic variables) and corrupting other data on the
stack such as the return address of a stack frame.
'SIGILL' can also be generated when the stack overflows, or when
the system has trouble running the handler for a signal.
-- Macro: int SIGSEGV
This signal is generated when a program tries to read or write
outside the memory that is allocated for it, or to write memory
that can only be read. (Actually, the signals only occur when the
program goes far enough outside to be detected by the system's
memory protection mechanism.) The name is an abbreviation for
"segmentation violation".
Common ways of getting a 'SIGSEGV' condition include dereferencing
a null or uninitialized pointer, or when you use a pointer to step
through an array, but fail to check for the end of the array. It
varies among systems whether dereferencing a null pointer generates
-- Macro: int SIGBUS
This signal is generated when an invalid pointer is dereferenced.
Like 'SIGSEGV', this signal is typically the result of
dereferencing an uninitialized pointer. The difference between the
two is that 'SIGSEGV' indicates an invalid access to valid memory,
while 'SIGBUS' indicates an access to an invalid address. In
particular, 'SIGBUS' signals often result from dereferencing a
misaligned pointer, such as referring to a four-word integer at an
address not divisible by four. (Each kind of computer has its own
requirements for address alignment.)
The name of this signal is an abbreviation for "bus error".
-- Macro: int SIGABRT
This signal indicates an error detected by the program itself and
reported by calling 'abort'. *Note Aborting a Program::.
-- Macro: int SIGIOT
Generated by the PDP-11 "iot" instruction. On most machines, this
is just another name for 'SIGABRT'.
-- Macro: int SIGTRAP
Generated by the machine's breakpoint instruction, and possibly
other trap instructions. This signal is used by debuggers. Your
program will probably only see 'SIGTRAP' if it is somehow executing
bad instructions.
-- Macro: int SIGEMT
Emulator trap; this results from certain unimplemented instructions
which might be emulated in software, or the operating system's
failure to properly emulate them.
-- Macro: int SIGSYS
Bad system call; that is to say, the instruction to trap to the
operating system was executed, but the code number for the system
call to perform was invalid.

File:, Node: Termination Signals, Next: Alarm Signals, Prev: Program Error Signals, Up: Standard Signals
24.2.2 Termination Signals
These signals are all used to tell a process to terminate, in one way or
another. They have different names because they're used for slightly
different purposes, and programs might want to handle them differently.
The reason for handling these signals is usually so your program can
tidy up as appropriate before actually terminating. For example, you
might want to save state information, delete temporary files, or restore
the previous terminal modes. Such a handler should end by specifying
the default action for the signal that happened and then reraising it;
this will cause the program to terminate with that signal, as if it had
not had a handler. (*Note Termination in Handler::.)
The (obvious) default action for all of these signals is to cause the
process to terminate.
-- Macro: int SIGTERM
The 'SIGTERM' signal is a generic signal used to cause program
termination. Unlike 'SIGKILL', this signal can be blocked,
handled, and ignored. It is the normal way to politely ask a
program to terminate.
The shell command 'kill' generates 'SIGTERM' by default.
-- Macro: int SIGINT
The 'SIGINT' ("program interrupt") signal is sent when the user
types the INTR character (normally 'C-c'). *Note Special
Characters::, for information about terminal driver support for
-- Macro: int SIGQUIT
The 'SIGQUIT' signal is similar to 'SIGINT', except that it's
controlled by a different key--the QUIT character, usually
'C-\'--and produces a core dump when it terminates the process,
just like a program error signal. You can think of this as a
program error condition "detected" by the user.
*Note Program Error Signals::, for information about core dumps.
*Note Special Characters::, for information about terminal driver
Certain kinds of cleanups are best omitted in handling 'SIGQUIT'.
For example, if the program creates temporary files, it should
handle the other termination requests by deleting the temporary
files. But it is better for 'SIGQUIT' not to delete them, so that
the user can examine them in conjunction with the core dump.
-- Macro: int SIGKILL
The 'SIGKILL' signal is used to cause immediate program
termination. It cannot be handled or ignored, and is therefore
always fatal. It is also not possible to block this signal.
This signal is usually generated only by explicit request. Since
it cannot be handled, you should generate it only as a last resort,
after first trying a less drastic method such as 'C-c' or
'SIGTERM'. If a process does not respond to any other termination
signals, sending it a 'SIGKILL' signal will almost always cause it
to go away.
In fact, if 'SIGKILL' fails to terminate a process, that by itself
constitutes an operating system bug which you should report.
The system will generate 'SIGKILL' for a process itself under some
unusual conditions where the program cannot possibly continue to
run (even to run a signal handler).
-- Macro: int SIGHUP
The 'SIGHUP' ("hang-up") signal is used to report that the user's
terminal is disconnected, perhaps because a network or telephone
connection was broken. For more information about this, see *note
Control Modes::.
This signal is also used to report the termination of the
controlling process on a terminal to jobs associated with that
session; this termination effectively disconnects all processes in
the session from the controlling terminal. For more information,
see *note Termination Internals::.

File:, Node: Alarm Signals, Next: Asynchronous I/O Signals, Prev: Termination Signals, Up: Standard Signals
24.2.3 Alarm Signals
These signals are used to indicate the expiration of timers. *Note
Setting an Alarm::, for information about functions that cause these
signals to be sent.
The default behavior for these signals is to cause program
termination. This default is rarely useful, but no other default would
be useful; most of the ways of using these signals would require handler
functions in any case.
-- Macro: int SIGALRM
This signal typically indicates expiration of a timer that measures
real or clock time. It is used by the 'alarm' function, for
-- Macro: int SIGVTALRM
This signal typically indicates expiration of a timer that measures
CPU time used by the current process. The name is an abbreviation
for "virtual time alarm".
-- Macro: int SIGPROF
This signal typically indicates expiration of a timer that measures
both CPU time used by the current process, and CPU time expended on
behalf of the process by the system. Such a timer is used to
implement code profiling facilities, hence the name of this signal.

File:, Node: Asynchronous I/O Signals, Next: Job Control Signals, Prev: Alarm Signals, Up: Standard Signals
24.2.4 Asynchronous I/O Signals
The signals listed in this section are used in conjunction with
asynchronous I/O facilities. You have to take explicit action by
calling 'fcntl' to enable a particular file descriptor to generate these
signals (*note Interrupt Input::). The default action for these signals
is to ignore them.
-- Macro: int SIGIO
This signal is sent when a file descriptor is ready to perform
input or output.
On most operating systems, terminals and sockets are the only kinds
of files that can generate 'SIGIO'; other kinds, including ordinary
files, never generate 'SIGIO' even if you ask them to.
On GNU systems 'SIGIO' will always be generated properly if you
successfully set asynchronous mode with 'fcntl'.
-- Macro: int SIGURG
This signal is sent when "urgent" or out-of-band data arrives on a
socket. *Note Out-of-Band Data::.
-- Macro: int SIGPOLL
This is a System V signal name, more or less similar to 'SIGIO'.
It is defined only for compatibility.

File:, Node: Job Control Signals, Next: Operation Error Signals, Prev: Asynchronous I/O Signals, Up: Standard Signals
24.2.5 Job Control Signals
These signals are used to support job control. If your system doesn't
support job control, then these macros are defined but the signals
themselves can't be raised or handled.
You should generally leave these signals alone unless you really
understand how job control works. *Note Job Control::.
-- Macro: int SIGCHLD
This signal is sent to a parent process whenever one of its child
processes terminates or stops.
The default action for this signal is to ignore it. If you
establish a handler for this signal while there are child processes
that have terminated but not reported their status via 'wait' or
'waitpid' (*note Process Completion::), whether your new handler
applies to those processes or not depends on the particular
operating system.
-- Macro: int SIGCLD
This is an obsolete name for 'SIGCHLD'.
-- Macro: int SIGCONT
You can send a 'SIGCONT' signal to a process to make it continue.
This signal is special--it always makes the process continue if it
is stopped, before the signal is delivered. The default behavior
is to do nothing else. You cannot block this signal. You can set
a handler, but 'SIGCONT' always makes the process continue
Most programs have no reason to handle 'SIGCONT'; they simply
resume execution without realizing they were ever stopped. You can
use a handler for 'SIGCONT' to make a program do something special
when it is stopped and continued--for example, to reprint a prompt
when it is suspended while waiting for input.
-- Macro: int SIGSTOP
The 'SIGSTOP' signal stops the process. It cannot be handled,
ignored, or blocked.
-- Macro: int SIGTSTP
The 'SIGTSTP' signal is an interactive stop signal. Unlike
'SIGSTOP', this signal can be handled and ignored.
Your program should handle this signal if you have a special need
to leave files or system tables in a secure state when a process is
stopped. For example, programs that turn off echoing should handle
'SIGTSTP' so they can turn echoing back on before stopping.
This signal is generated when the user types the SUSP character
(normally 'C-z'). For more information about terminal driver
support, see *note Special Characters::.
-- Macro: int SIGTTIN
A process cannot read from the user's terminal while it is running
as a background job. When any process in a background job tries to
read from the terminal, all of the processes in the job are sent a
'SIGTTIN' signal. The default action for this signal is to stop
the process. For more information about how this interacts with
the terminal driver, see *note Access to the Terminal::.
-- Macro: int SIGTTOU
This is similar to 'SIGTTIN', but is generated when a process in a
background job attempts to write to the terminal or set its modes.
Again, the default action is to stop the process. 'SIGTTOU' is
only generated for an attempt to write to the terminal if the
'TOSTOP' output mode is set; *note Output Modes::.
While a process is stopped, no more signals can be delivered to it
until it is continued, except 'SIGKILL' signals and (obviously)
'SIGCONT' signals. The signals are marked as pending, but not delivered
until the process is continued. The 'SIGKILL' signal always causes
termination of the process and can't be blocked, handled or ignored.
You can ignore 'SIGCONT', but it always causes the process to be
continued anyway if it is stopped. Sending a 'SIGCONT' signal to a
process causes any pending stop signals for that process to be
discarded. Likewise, any pending 'SIGCONT' signals for a process are
discarded when it receives a stop signal.
When a process in an orphaned process group (*note Orphaned Process
Groups::) receives a 'SIGTSTP', 'SIGTTIN', or 'SIGTTOU' signal and does
not handle it, the process does not stop. Stopping the process would
probably not be very useful, since there is no shell program that will
notice it stop and allow the user to continue it. What happens instead
depends on the operating system you are using. Some systems may do
nothing; others may deliver another signal instead, such as 'SIGKILL' or
'SIGHUP'. On GNU/Hurd systems, the process dies with 'SIGKILL'; this
avoids the problem of many stopped, orphaned processes lying around the

File:, Node: Operation Error Signals, Next: Miscellaneous Signals, Prev: Job Control Signals, Up: Standard Signals
24.2.6 Operation Error Signals
These signals are used to report various errors generated by an
operation done by the program. They do not necessarily indicate a
programming error in the program, but an error that prevents an
operating system call from completing. The default action for all of
them is to cause the process to terminate.
-- Macro: int SIGPIPE
Broken pipe. If you use pipes or FIFOs, you have to design your
application so that one process opens the pipe for reading before
another starts writing. If the reading process never starts, or
terminates unexpectedly, writing to the pipe or FIFO raises a
'SIGPIPE' signal. If 'SIGPIPE' is blocked, handled or ignored, the
offending call fails with 'EPIPE' instead.
Pipes and FIFO special files are discussed in more detail in *note
Pipes and FIFOs::.
Another cause of 'SIGPIPE' is when you try to output to a socket
that isn't connected. *Note Sending Data::.
-- Macro: int SIGLOST
Resource lost. This signal is generated when you have an advisory
lock on an NFS file, and the NFS server reboots and forgets about
your lock.
On GNU/Hurd systems, 'SIGLOST' is generated when any server program
dies unexpectedly. It is usually fine to ignore the signal;
whatever call was made to the server that died just returns an
-- Macro: int SIGXCPU
CPU time limit exceeded. This signal is generated when the process
exceeds its soft resource limit on CPU time. *Note Limits on
-- Macro: int SIGXFSZ
File size limit exceeded. This signal is generated when the
process attempts to extend a file so it exceeds the process's soft
resource limit on file size. *Note Limits on Resources::.

File:, Node: Miscellaneous Signals, Next: Signal Messages, Prev: Operation Error Signals, Up: Standard Signals
24.2.7 Miscellaneous Signals
These signals are used for various other purposes. In general, they
will not affect your program unless it explicitly uses them for
-- Macro: int SIGUSR1
-- Macro: int SIGUSR2
The 'SIGUSR1' and 'SIGUSR2' signals are set aside for you to use
any way you want. They're useful for simple interprocess
communication, if you write a signal handler for them in the
program that receives the signal.
There is an example showing the use of 'SIGUSR1' and 'SIGUSR2' in
*note Signaling Another Process::.
The default action is to terminate the process.
-- Macro: int SIGWINCH
Window size change. This is generated on some systems (including
GNU) when the terminal driver's record of the number of rows and
columns on the screen is changed. The default action is to ignore
If a program does full-screen display, it should handle 'SIGWINCH'.
When the signal arrives, it should fetch the new screen size and
reformat its display accordingly.
-- Macro: int SIGINFO
Information request. On 4.4 BSD and GNU/Hurd systems, this signal
is sent to all the processes in the foreground process group of the
controlling terminal when the user types the STATUS character in
canonical mode; *note Signal Characters::.
If the process is the leader of the process group, the default
action is to print some status information about the system and
what the process is doing. Otherwise the default is to do nothing.

File:, Node: Signal Messages, Prev: Miscellaneous Signals, Up: Standard Signals
24.2.8 Signal Messages
We mentioned above that the shell prints a message describing the signal
that terminated a child process. The clean way to print a message
describing a signal is to use the functions 'strsignal' and 'psignal'.
These functions use a signal number to specify which kind of signal to
describe. The signal number may come from the termination status of a
child process (*note Process Completion::) or it may come from a signal
handler in the same process.
-- Function: char * strsignal (int SIGNUM)
Preliminary: | MT-Unsafe race:strsignal locale | AS-Unsafe init
i18n corrupt heap | AC-Unsafe init corrupt mem | *Note POSIX Safety
This function returns a pointer to a statically-allocated string
containing a message describing the signal SIGNUM. You should not
modify the contents of this string; and, since it can be rewritten
on subsequent calls, you should save a copy of it if you need to
reference it later.
This function is a GNU extension, declared in the header file
-- Function: void psignal (int SIGNUM, const char *MESSAGE)
Preliminary: | MT-Safe locale | AS-Unsafe corrupt i18n heap |
AC-Unsafe lock corrupt mem | *Note POSIX Safety Concepts::.
This function prints a message describing the signal SIGNUM to the
standard error output stream 'stderr'; see *note Standard
If you call 'psignal' with a MESSAGE that is either a null pointer
or an empty string, 'psignal' just prints the message corresponding
to SIGNUM, adding a trailing newline.
If you supply a non-null MESSAGE argument, then 'psignal' prefixes
its output with this string. It adds a colon and a space character
to separate the MESSAGE from the string corresponding to SIGNUM.
This function is a BSD feature, declared in the header file
There is also an array 'sys_siglist' which contains the messages for
the various signal codes. This array exists on BSD systems, unlike

File:, Node: Signal Actions, Next: Defining Handlers, Prev: Standard Signals, Up: Signal Handling
24.3 Specifying Signal Actions
The simplest way to change the action for a signal is to use the
'signal' function. You can specify a built-in action (such as to ignore
the signal), or you can "establish a handler".
The GNU C Library also implements the more versatile 'sigaction'
facility. This section describes both facilities and gives suggestions
on which to use when.
* Menu:
* Basic Signal Handling:: The simple 'signal' function.
* Advanced Signal Handling:: The more powerful 'sigaction' function.
* Signal and Sigaction:: How those two functions interact.
* Sigaction Function Example:: An example of using the sigaction function.
* Flags for Sigaction:: Specifying options for signal handling.
* Initial Signal Actions:: How programs inherit signal actions.

File:, Node: Basic Signal Handling, Next: Advanced Signal Handling, Up: Signal Actions
24.3.1 Basic Signal Handling
The 'signal' function provides a simple interface for establishing an
action for a particular signal. The function and associated macros are
declared in the header file 'signal.h'.
-- Data Type: sighandler_t
This is the type of signal handler functions. Signal handlers take
one integer argument specifying the signal number, and have return
type 'void'. So, you should define handler functions like this:
void HANDLER (int signum) { ... }
The name 'sighandler_t' for this data type is a GNU extension.
-- Function: sighandler_t signal (int SIGNUM, sighandler_t ACTION)
Preliminary: | MT-Safe sigintr | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
The 'signal' function establishes ACTION as the action for the
signal SIGNUM.
The first argument, SIGNUM, identifies the signal whose behavior
you want to control, and should be a signal number. The proper way
to specify a signal number is with one of the symbolic signal names
(*note Standard Signals::)--don't use an explicit number, because
the numerical code for a given kind of signal may vary from
operating system to operating system.
The second argument, ACTION, specifies the action to use for the
signal SIGNUM. This can be one of the following:
'SIG_DFL' specifies the default action for the particular
signal. The default actions for various kinds of signals are
stated in *note Standard Signals::.
'SIG_IGN' specifies that the signal should be ignored.
Your program generally should not ignore signals that
represent serious events or that are normally used to request
termination. You cannot ignore the 'SIGKILL' or 'SIGSTOP'
signals at all. You can ignore program error signals like
'SIGSEGV', but ignoring the error won't enable the program to
continue executing meaningfully. Ignoring user requests such
as 'SIGINT', 'SIGQUIT', and 'SIGTSTP' is unfriendly.
When you do not wish signals to be delivered during a certain
part of the program, the thing to do is to block them, not
ignore them. *Note Blocking Signals::.
Supply the address of a handler function in your program, to
specify running this handler as the way to deliver the signal.
For more information about defining signal handler functions,
see *note Defining Handlers::.
If you set the action for a signal to 'SIG_IGN', or if you set it
to 'SIG_DFL' and the default action is to ignore that signal, then
any pending signals of that type are discarded (even if they are
blocked). Discarding the pending signals means that they will
never be delivered, not even if you subsequently specify another
action and unblock this kind of signal.
The 'signal' function returns the action that was previously in
effect for the specified SIGNUM. You can save this value and
restore it later by calling 'signal' again.
If 'signal' can't honor the request, it returns 'SIG_ERR' instead.
The following 'errno' error conditions are defined for this
You specified an invalid SIGNUM; or you tried to ignore or
provide a handler for 'SIGKILL' or 'SIGSTOP'.
*Compatibility Note:* A problem encountered when working with the
'signal' function is that it has different semantics on BSD and SVID
systems. The difference is that on SVID systems the signal handler is
deinstalled after signal delivery. On BSD systems the handler must be
explicitly deinstalled. In the GNU C Library we use the BSD version by
default. To use the SVID version you can either use the function
'sysv_signal' (see below) or use the '_XOPEN_SOURCE' feature select
macro (*note Feature Test Macros::). In general, use of these functions
should be avoided because of compatibility problems. It is better to
use 'sigaction' if it is available since the results are much more
Here is a simple example of setting up a handler to delete temporary
files when certain fatal signals happen:
#include <signal.h>
termination_handler (int signum)
struct temp_file *p;
for (p = temp_file_list; p; p = p->next)
unlink (p->name);
main (void)
if (signal (SIGINT, termination_handler) == SIG_IGN)
signal (SIGINT, SIG_IGN);
if (signal (SIGHUP, termination_handler) == SIG_IGN)
signal (SIGHUP, SIG_IGN);
if (signal (SIGTERM, termination_handler) == SIG_IGN)
signal (SIGTERM, SIG_IGN);
Note that if a given signal was previously set to be ignored, this code
avoids altering that setting. This is because non-job-control shells
often ignore certain signals when starting children, and it is important
for the children to respect this.
We do not handle 'SIGQUIT' or the program error signals in this
example because these are designed to provide information for debugging
(a core dump), and the temporary files may give useful information.
-- Function: sighandler_t sysv_signal (int SIGNUM, sighandler_t ACTION)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
The 'sysv_signal' implements the behavior of the standard 'signal'
function as found on SVID systems. The difference to BSD systems
is that the handler is deinstalled after a delivery of a signal.
*Compatibility Note:* As said above for 'signal', this function
should be avoided when possible. 'sigaction' is the preferred
-- Function: sighandler_t ssignal (int SIGNUM, sighandler_t ACTION)
Preliminary: | MT-Safe sigintr | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
The 'ssignal' function does the same thing as 'signal'; it is
provided only for compatibility with SVID.
-- Macro: sighandler_t SIG_ERR
The value of this macro is used as the return value from 'signal'
to indicate an error.

File:, Node: Advanced Signal Handling, Next: Signal and Sigaction, Prev: Basic Signal Handling, Up: Signal Actions
24.3.2 Advanced Signal Handling
The 'sigaction' function has the same basic effect as 'signal': to
specify how a signal should be handled by the process. However,
'sigaction' offers more control, at the expense of more complexity. In
particular, 'sigaction' allows you to specify additional flags to
control when the signal is generated and how the handler is invoked.
The 'sigaction' function is declared in 'signal.h'.
-- Data Type: struct sigaction
Structures of type 'struct sigaction' are used in the 'sigaction'
function to specify all the information about how to handle a
particular signal. This structure contains at least the following
'sighandler_t sa_handler'