blob: 3030a8a18b62a9e4cb2a463cc5e7d3876227c51a [file] [log] [blame]
This is /home/vagrant/rpmbuild/BUILD/build-eglibc/manual/,
produced by makeinfo version 4.13 from libc.texinfo.
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.
* 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.
* 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_getattr_default_np: (libc)Default Thread Attributes.
* 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.
* 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.
This file documents the GNU C Library.
This is `The GNU C Library Reference Manual', for version
2.18-2013.10 (EGLIBC).
Copyright (C) 1993-2013 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version
1.3 or any later version published by the Free Software Foundation;
with the Invariant Sections being "Free Software Needs Free
Documentation" and "GNU Lesser General Public License", the Front-Cover
texts being "A GNU Manual", and with the Back-Cover Texts as in (a)
below. A copy of the license is included in the section entitled "GNU
Free Documentation License".
(a) The FSF's Back-Cover Text is: "You have the freedom to copy and
modify this GNU manual. Buying copies from the FSF supports it in
developing GNU and promoting software freedom."

File:, Node: Limits on Resources, Next: Priority, Prev: Resource Usage, Up: Resource Usage And Limitation
22.2 Limiting Resource Usage
You can specify limits for the resource usage of a process. When the
process tries to exceed a limit, it may get a signal, or the system call
by which it tried to do so may fail, depending on the resource. Each
process initially inherits its limit values from its parent, but it can
subsequently change them.
There are two per-process limits associated with a resource:
"current limit"
The current limit is the value the system will not allow usage to
exceed. It is also called the "soft limit" because the process
being limited can generally raise the current limit at will.
"maximum limit"
The maximum limit is the maximum value to which a process is
allowed to set its current limit. It is also called the "hard
limit" because there is no way for a process to get around it. A
process may lower its own maximum limit, but only the superuser
may increase a maximum limit.
The symbols for use with `getrlimit', `setrlimit', `getrlimit64',
and `setrlimit64' are defined in `sys/resource.h'.
-- Function: int getrlimit (int RESOURCE, struct rlimit *RLP)
Read the current and maximum limits for the resource RESOURCE and
store them in `*RLP'.
The return value is `0' on success and `-1' on failure. The only
possible `errno' error condition is `EFAULT'.
When the sources are compiled with `_FILE_OFFSET_BITS == 64' on a
32-bit system this function is in fact `getrlimit64'. Thus, the
LFS interface transparently replaces the old interface.
-- Function: int getrlimit64 (int RESOURCE, struct rlimit64 *RLP)
This function is similar to `getrlimit' but its second parameter is
a pointer to a variable of type `struct rlimit64', which allows it
to read values which wouldn't fit in the member of a `struct
If the sources are compiled with `_FILE_OFFSET_BITS == 64' on a
32-bit machine, this function is available under the name
`getrlimit' and so transparently replaces the old interface.
-- Function: int setrlimit (int RESOURCE, const struct rlimit *RLP)
Store the current and maximum limits for the resource RESOURCE in
The return value is `0' on success and `-1' on failure. The
following `errno' error condition is possible:
* The process tried to raise a current limit beyond the
maximum limit.
* The process tried to raise a maximum limit, but is not
When the sources are compiled with `_FILE_OFFSET_BITS == 64' on a
32-bit system this function is in fact `setrlimit64'. Thus, the
LFS interface transparently replaces the old interface.
-- Function: int setrlimit64 (int RESOURCE, const struct rlimit64 *RLP)
This function is similar to `setrlimit' but its second parameter is
a pointer to a variable of type `struct rlimit64' which allows it
to set values which wouldn't fit in the member of a `struct
If the sources are compiled with `_FILE_OFFSET_BITS == 64' on a
32-bit machine this function is available under the name
`setrlimit' and so transparently replaces the old interface.
-- Data Type: struct rlimit
This structure is used with `getrlimit' to receive limit values,
and with `setrlimit' to specify limit values for a particular
process and resource. It has two fields:
`rlim_t rlim_cur'
The current limit
`rlim_t rlim_max'
The maximum limit.
For `getrlimit', the structure is an output; it receives the
current values. For `setrlimit', it specifies the new values.
For the LFS functions a similar type is defined in `sys/resource.h'.
-- Data Type: struct rlimit64
This structure is analogous to the `rlimit' structure above, but
its components have wider ranges. It has two fields:
`rlim64_t rlim_cur'
This is analogous to `rlimit.rlim_cur', but with a different
`rlim64_t rlim_max'
This is analogous to `rlimit.rlim_max', but with a different
Here is a list of resources for which you can specify a limit.
Memory and file sizes are measured in bytes.
The maximum amount of CPU time the process can use. If it runs for
longer than this, it gets a signal: `SIGXCPU'. The value is
measured in seconds. *Note Operation Error Signals::.
The maximum size of file the process can create. Trying to write a
larger file causes a signal: `SIGXFSZ'. *Note Operation Error
The maximum size of data memory for the process. If the process
tries to allocate data memory beyond this amount, the allocation
function fails.
The maximum stack size for the process. If the process tries to
extend its stack past this size, it gets a `SIGSEGV' signal.
*Note Program Error Signals::.
The maximum size core file that this process can create. If the
process terminates and would dump a core file larger than this,
then no core file is created. So setting this limit to zero
prevents core files from ever being created.
The maximum amount of physical memory that this process should get.
This parameter is a guide for the system's scheduler and memory
allocator; the system may give the process more memory when there
is a surplus.
The maximum amount of memory that can be locked into physical
memory (so it will never be paged out).
The maximum number of processes that can be created with the same
user ID. If you have reached the limit for your user ID, `fork'
will fail with `EAGAIN'. *Note Creating a Process::.
The maximum number of files that the process can open. If it
tries to open more files than this, its open attempt fails with
`errno' `EMFILE'. *Note Error Codes::. Not all systems support
this limit; GNU does, and 4.4 BSD does.
The maximum size of total memory that this process should get. If
the process tries to allocate more memory beyond this amount with,
for example, `brk', `malloc', `mmap' or `sbrk', the allocation
function fails.
The number of different resource limits. Any valid RESOURCE
operand must be less than `RLIM_NLIMITS'.
-- Constant: rlim_t RLIM_INFINITY
This constant stands for a value of "infinity" when supplied as
the limit value in `setrlimit'.
The following are historical functions to do some of what the
functions above do. The functions above are better choices.
`ulimit' and the command symbols are declared in `ulimit.h'.
-- Function: long int ulimit (int CMD, ...)
`ulimit' gets the current limit or sets the current and maximum
limit for a particular resource for the calling process according
to the command CMD.a
If you are getting a limit, the command argument is the only
argument. If you are setting a limit, there is a second argument:
`long int' LIMIT which is the value to which you are setting the
The CMD values and the operations they specify are:
Get the current limit on the size of a file, in units of 512
Set the current and maximum limit on the size of a file to
LIMIT * 512 bytes.
There are also some other CMD values that may do things on some
systems, but they are not supported.
Only the superuser may increase a maximum limit.
When you successfully get a limit, the return value of `ulimit' is
that limit, which is never negative. When you successfully set a
limit, the return value is zero. When the function fails, the
return value is `-1' and `errno' is set according to the reason:
A process tried to increase a maximum limit, but is not
`vlimit' and its resource symbols are declared in `sys/vlimit.h'.
-- Function: int vlimit (int RESOURCE, int LIMIT)
`vlimit' sets the current limit for a resource for a process.
RESOURCE identifies the resource:
Maximum CPU time. Same as `RLIMIT_CPU' for `setrlimit'.
Maximum file size. Same as `RLIMIT_FSIZE' for `setrlimit'.
Maximum data memory. Same as `RLIMIT_DATA' for `setrlimit'.
Maximum stack size. Same as `RLIMIT_STACK' for `setrlimit'.
Maximum core file size. Same as `RLIMIT_COR' for `setrlimit'.
Maximum physical memory. Same as `RLIMIT_RSS' for
The return value is zero for success, and `-1' with `errno' set
accordingly for failure:
The process tried to set its current limit beyond its maximum

File:, Node: Priority, Next: Memory Resources, Prev: Limits on Resources, Up: Resource Usage And Limitation
22.3 Process CPU Priority And Scheduling
When multiple processes simultaneously require CPU time, the system's
scheduling policy and process CPU priorities determine which processes
get it. This section describes how that determination is made and GNU
C Library functions to control it.
It is common to refer to CPU scheduling simply as scheduling and a
process' CPU priority simply as the process' priority, with the CPU
resource being implied. Bear in mind, though, that CPU time is not the
only resource a process uses or that processes contend for. In some
cases, it is not even particularly important. Giving a process a high
"priority" may have very little effect on how fast a process runs with
respect to other processes. The priorities discussed in this section
apply only to CPU time.
CPU scheduling is a complex issue and different systems do it in
wildly different ways. New ideas continually develop and find their
way into the intricacies of the various systems' scheduling algorithms.
This section discusses the general concepts, some specifics of systems
that commonly use the GNU C Library, and some standards.
For simplicity, we talk about CPU contention as if there is only one
CPU in the system. But all the same principles apply when a processor
has multiple CPUs, and knowing that the number of processes that can
run at any one time is equal to the number of CPUs, you can easily
extrapolate the information.
The functions described in this section are all defined by the
POSIX.1 and POSIX.1b standards (the `sched...' functions are POSIX.1b).
However, POSIX does not define any semantics for the values that these
functions get and set. In this chapter, the semantics are based on the
Linux kernel's implementation of the POSIX standard. As you will see,
the Linux implementation is quite the inverse of what the authors of the
POSIX syntax had in mind.
* Menu:
* Absolute Priority:: The first tier of priority. Posix
* Realtime Scheduling:: Scheduling among the process nobility
* Basic Scheduling Functions:: Get/set scheduling policy, priority
* Traditional Scheduling:: Scheduling among the vulgar masses
* CPU Affinity:: Limiting execution to certain CPUs

File:, Node: Absolute Priority, Next: Realtime Scheduling, Up: Priority
22.3.1 Absolute Priority
Every process has an absolute priority, and it is represented by a
number. The higher the number, the higher the absolute priority.
On systems of the past, and most systems today, all processes have
absolute priority 0 and this section is irrelevant. In that case,
*Note Traditional Scheduling::. Absolute priorities were invented to
accommodate realtime systems, in which it is vital that certain
processes be able to respond to external events happening in real time,
which means they cannot wait around while some other process that _wants
to_, but doesn't _need to_ run occupies the CPU.
When two processes are in contention to use the CPU at any instant,
the one with the higher absolute priority always gets it. This is true
even if the process with the lower priority is already using the CPU
(i.e., the scheduling is preemptive). Of course, we're only talking
about processes that are running or "ready to run," which means they are
ready to execute instructions right now. When a process blocks to wait
for something like I/O, its absolute priority is irrelevant.
*NB:* The term "runnable" is a synonym for "ready to run."
When two processes are running or ready to run and both have the same
absolute priority, it's more interesting. In that case, who gets the
CPU is determined by the scheduling policy. If the processes have
absolute priority 0, the traditional scheduling policy described in
*note Traditional Scheduling:: applies. Otherwise, the policies
described in *note Realtime Scheduling:: apply.
You normally give an absolute priority above 0 only to a process that
can be trusted not to hog the CPU. Such processes are designed to block
(or terminate) after relatively short CPU runs.
A process begins life with the same absolute priority as its parent
process. Functions described in *note Basic Scheduling Functions:: can
change it.
Only a privileged process can change a process' absolute priority to
something other than `0'. Only a privileged process or the target
process' owner can change its absolute priority at all.
POSIX requires absolute priority values used with the realtime
scheduling policies to be consecutive with a range of at least 32. On
Linux, they are 1 through 99. The functions `sched_get_priority_max'
and `sched_set_priority_min' portably tell you what the range is on a
particular system. Using Absolute Priority
One thing you must keep in mind when designing real time applications is
that having higher absolute priority than any other process doesn't
guarantee the process can run continuously. Two things that can wreck a
good CPU run are interrupts and page faults.
Interrupt handlers live in that limbo between processes. The CPU is
executing instructions, but they aren't part of any process. An
interrupt will stop even the highest priority process. So you must
allow for slight delays and make sure that no device in the system has
an interrupt handler that could cause too long a delay between
instructions for your process.
Similarly, a page fault causes what looks like a straightforward
sequence of instructions to take a long time. The fact that other
processes get to run while the page faults in is of no consequence,
because as soon as the I/O is complete, the high priority process will
kick them out and run again, but the wait for the I/O itself could be a
problem. To neutralize this threat, use `mlock' or `mlockall'.
There are a few ramifications of the absoluteness of this priority
on a single-CPU system that you need to keep in mind when you choose to
set a priority and also when you're working on a program that runs with
high absolute priority. Consider a process that has higher absolute
priority than any other process in the system and due to a bug in its
program, it gets into an infinite loop. It will never cede the CPU.
You can't run a command to kill it because your command would need to
get the CPU in order to run. The errant program is in complete
control. It controls the vertical, it controls the horizontal.
There are two ways to avoid this: 1) keep a shell running somewhere
with a higher absolute priority. 2) keep a controlling terminal
attached to the high priority process group. All the priority in the
world won't stop an interrupt handler from running and delivering a
signal to the process if you hit Control-C.
Some systems use absolute priority as a means of allocating a fixed
percentage of CPU time to a process. To do this, a super high priority
privileged process constantly monitors the process' CPU usage and raises
its absolute priority when the process isn't getting its entitled share
and lowers it when the process is exceeding it.
*NB:* The absolute priority is sometimes called the "static
priority." We don't use that term in this manual because it misses the
most important feature of the absolute priority: its absoluteness.

File:, Node: Realtime Scheduling, Next: Basic Scheduling Functions, Prev: Absolute Priority, Up: Priority
22.3.2 Realtime Scheduling
Whenever two processes with the same absolute priority are ready to run,
the kernel has a decision to make, because only one can run at a time.
If the processes have absolute priority 0, the kernel makes this
decision as described in *note Traditional Scheduling::. Otherwise,
the decision is as described in this section.
If two processes are ready to run but have different absolute
priorities, the decision is much simpler, and is described in *note
Absolute Priority::.
Each process has a scheduling policy. For processes with absolute
priority other than zero, there are two available:
1. First Come First Served
2. Round Robin
The most sensible case is where all the processes with a certain
absolute priority have the same scheduling policy. We'll discuss that
In Round Robin, processes share the CPU, each one running for a small
quantum of time ("time slice") and then yielding to another in a
circular fashion. Of course, only processes that are ready to run and
have the same absolute priority are in this circle.
In First Come First Served, the process that has been waiting the
longest to run gets the CPU, and it keeps it until it voluntarily
relinquishes the CPU, runs out of things to do (blocks), or gets
preempted by a higher priority process.
First Come First Served, along with maximal absolute priority and
careful control of interrupts and page faults, is the one to use when a
process absolutely, positively has to run at full CPU speed or not at
Judicious use of `sched_yield' function invocations by processes
with First Come First Served scheduling policy forms a good compromise
between Round Robin and First Come First Served.
To understand how scheduling works when processes of different
scheduling policies occupy the same absolute priority, you have to know
the nitty gritty details of how processes enter and exit the ready to
run list:
In both cases, the ready to run list is organized as a true queue,
where a process gets pushed onto the tail when it becomes ready to run
and is popped off the head when the scheduler decides to run it. Note
that ready to run and running are two mutually exclusive states. When
the scheduler runs a process, that process is no longer ready to run
and no longer in the ready to run list. When the process stops
running, it may go back to being ready to run again.
The only difference between a process that is assigned the Round
Robin scheduling policy and a process that is assigned First Come First
Serve is that in the former case, the process is automatically booted
off the CPU after a certain amount of time. When that happens, the
process goes back to being ready to run, which means it enters the
queue at the tail. The time quantum we're talking about is small.
Really small. This is not your father's timesharing. For example,
with the Linux kernel, the round robin time slice is a thousand times
shorter than its typical time slice for traditional scheduling.
A process begins life with the same scheduling policy as its parent
process. Functions described in *note Basic Scheduling Functions:: can
change it.
Only a privileged process can set the scheduling policy of a process
that has absolute priority higher than 0.

File:, Node: Basic Scheduling Functions, Next: Traditional Scheduling, Prev: Realtime Scheduling, Up: Priority
22.3.3 Basic Scheduling Functions
This section describes functions in the GNU C Library for setting the
absolute priority and scheduling policy of a process.
*Portability Note:* On systems that have the functions in this
section, the macro _POSIX_PRIORITY_SCHEDULING is defined in
For the case that the scheduling policy is traditional scheduling,
more functions to fine tune the scheduling are in *note Traditional
Don't try to make too much out of the naming and structure of these
functions. They don't match the concepts described in this manual
because the functions are as defined by POSIX.1b, but the implementation
on systems that use the GNU C Library is the inverse of what the POSIX
structure contemplates. The POSIX scheme assumes that the primary
scheduling parameter is the scheduling policy and that the priority
value, if any, is a parameter of the scheduling policy. In the
implementation, though, the priority value is king and the scheduling
policy, if anything, only fine tunes the effect of that priority.
The symbols in this section are declared by including file `sched.h'.
-- Data Type: struct sched_param
This structure describes an absolute priority.
`int sched_priority'
absolute priority value
-- Function: int sched_setscheduler (pid_t PID, int POLICY, const
struct sched_param *PARAM)
This function sets both the absolute priority and the scheduling
policy for a process.
It assigns the absolute priority value given by PARAM and the
scheduling policy POLICY to the process with Process ID PID, or
the calling process if PID is zero. If POLICY is negative,
`sched_setscheduler' keeps the existing scheduling policy.
The following macros represent the valid values for POLICY:
Traditional Scheduling
First In First Out
Round Robin
On success, the return value is `0'. Otherwise, it is `-1' and
`ERRNO' is set accordingly. The `errno' values specific to this
function are:
* The calling process does not have `CAP_SYS_NICE'
permission and POLICY is not `SCHED_OTHER' (or it's
negative and the existing policy is not `SCHED_OTHER'.
* The calling process does not have `CAP_SYS_NICE'
permission and its owner is not the target process'
owner. I.e., the effective uid of the calling process
is neither the effective nor the real uid of process PID.
There is no process with pid PID and PID is not zero.
* POLICY does not identify an existing scheduling policy.
* The absolute priority value identified by *PARAM is
outside the valid range for the scheduling policy POLICY
(or the existing scheduling policy if POLICY is
negative) or PARAM is null. `sched_get_priority_max'
and `sched_get_priority_min' tell you what the valid
range is.
* PID is negative.
-- Function: int sched_getscheduler (pid_t PID)
This function returns the scheduling policy assigned to the
process with Process ID (pid) PID, or the calling process if PID
is zero.
The return value is the scheduling policy. See
`sched_setscheduler' for the possible values.
If the function fails, the return value is instead `-1' and
`errno' is set accordingly.
The `errno' values specific to this function are:
There is no process with pid PID and it is not zero.
PID is negative.
Note that this function is not an exact mate to
`sched_setscheduler' because while that function sets the
scheduling policy and the absolute priority, this function gets
only the scheduling policy. To get the absolute priority, use
-- Function: int sched_setparam (pid_t PID, const struct sched_param
This function sets a process' absolute priority.
It is functionally identical to `sched_setscheduler' with POLICY =
-- Function: int sched_getparam (pid_t PID, struct sched_param *PARAM)
This function returns a process' absolute priority.
PID is the Process ID (pid) of the process whose absolute priority
you want to know.
PARAM is a pointer to a structure in which the function stores the
absolute priority of the process.
On success, the return value is `0'. Otherwise, it is `-1' and
`ERRNO' is set accordingly. The `errno' values specific to this
function are:
There is no process with pid PID and it is not zero.
PID is negative.
-- Function: int sched_get_priority_min (int POLICY)
This function returns the lowest absolute priority value that is
allowable for a process with scheduling policy POLICY.
On Linux, it is 0 for SCHED_OTHER and 1 for everything else.
On success, the return value is `0'. Otherwise, it is `-1' and
`ERRNO' is set accordingly. The `errno' values specific to this
function are:
POLICY does not identify an existing scheduling policy.
-- Function: int sched_get_priority_max (int POLICY)
This function returns the highest absolute priority value that is
allowable for a process that with scheduling policy POLICY.
On Linux, it is 0 for SCHED_OTHER and 99 for everything else.
On success, the return value is `0'. Otherwise, it is `-1' and
`ERRNO' is set accordingly. The `errno' values specific to this
function are:
POLICY does not identify an existing scheduling policy.
-- Function: int sched_rr_get_interval (pid_t PID, struct timespec
This function returns the length of the quantum (time slice) used
with the Round Robin scheduling policy, if it is used, for the
process with Process ID PID.
It returns the length of time as INTERVAL.
With a Linux kernel, the round robin time slice is always 150
microseconds, and PID need not even be a real pid.
The return value is `0' on success and in the pathological case
that it fails, the return value is `-1' and `errno' is set
accordingly. There is nothing specific that can go wrong with this
function, so there are no specific `errno' values.
-- Function: int sched_yield (void)
This function voluntarily gives up the process' claim on the CPU.
Technically, `sched_yield' causes the calling process to be made
immediately ready to run (as opposed to running, which is what it
was before). This means that if it has absolute priority higher
than 0, it gets pushed onto the tail of the queue of processes
that share its absolute priority and are ready to run, and it will
run again when its turn next arrives. If its absolute priority is
0, it is more complicated, but still has the effect of yielding
the CPU to other processes.
If there are no other processes that share the calling process'
absolute priority, this function doesn't have any effect.
To the extent that the containing program is oblivious to what
other processes in the system are doing and how fast it executes,
this function appears as a no-op.
The return value is `0' on success and in the pathological case
that it fails, the return value is `-1' and `errno' is set
accordingly. There is nothing specific that can go wrong with this
function, so there are no specific `errno' values.

File:, Node: Traditional Scheduling, Next: CPU Affinity, Prev: Basic Scheduling Functions, Up: Priority
22.3.4 Traditional Scheduling
This section is about the scheduling among processes whose absolute
priority is 0. When the system hands out the scraps of CPU time that
are left over after the processes with higher absolute priority have
taken all they want, the scheduling described herein determines who
among the great unwashed processes gets them.
* Menu:
* Traditional Scheduling Intro::
* Traditional Scheduling Functions::

File:, Node: Traditional Scheduling Intro, Next: Traditional Scheduling Functions, Up: Traditional Scheduling Introduction To Traditional Scheduling
Long before there was absolute priority (See *note Absolute Priority::),
Unix systems were scheduling the CPU using this system. When Posix came
in like the Romans and imposed absolute priorities to accommodate the
needs of realtime processing, it left the indigenous Absolute Priority
Zero processes to govern themselves by their own familiar scheduling
Indeed, absolute priorities higher than zero are not available on
many systems today and are not typically used when they are, being
intended mainly for computers that do realtime processing. So this
section describes the only scheduling many programmers need to be
concerned about.
But just to be clear about the scope of this scheduling: Any time a
process with a absolute priority of 0 and a process with an absolute
priority higher than 0 are ready to run at the same time, the one with
absolute priority 0 does not run. If it's already running when the
higher priority ready-to-run process comes into existence, it stops
In addition to its absolute priority of zero, every process has
another priority, which we will refer to as "dynamic priority" because
it changes over time. The dynamic priority is meaningless for
processes with an absolute priority higher than zero.
The dynamic priority sometimes determines who gets the next turn on
the CPU. Sometimes it determines how long turns last. Sometimes it
determines whether a process can kick another off the CPU.
In Linux, the value is a combination of these things, but mostly it
is just determines the length of the time slice. The higher a process'
dynamic priority, the longer a shot it gets on the CPU when it gets one.
If it doesn't use up its time slice before giving up the CPU to do
something like wait for I/O, it is favored for getting the CPU back when
it's ready for it, to finish out its time slice. Other than that,
selection of processes for new time slices is basically round robin.
But the scheduler does throw a bone to the low priority processes: A
process' dynamic priority rises every time it is snubbed in the
scheduling process. In Linux, even the fat kid gets to play.
The fluctuation of a process' dynamic priority is regulated by
another value: The "nice" value. The nice value is an integer, usually
in the range -20 to 20, and represents an upper limit on a process'
dynamic priority. The higher the nice number, the lower that limit.
On a typical Linux system, for example, a process with a nice value
of 20 can get only 10 milliseconds on the CPU at a time, whereas a
process with a nice value of -20 can achieve a high enough priority to
get 400 milliseconds.
The idea of the nice value is deferential courtesy. In the
beginning, in the Unix garden of Eden, all processes shared equally in
the bounty of the computer system. But not all processes really need
the same share of CPU time, so the nice value gave a courteous process
the ability to refuse its equal share of CPU time that others might
prosper. Hence, the higher a process' nice value, the nicer the
process is. (Then a snake came along and offered some process a
negative nice value and the system became the crass resource allocation
system we know today).
Dynamic priorities tend upward and downward with an objective of
smoothing out allocation of CPU time and giving quick response time to
infrequent requests. But they never exceed their nice limits, so on a
heavily loaded CPU, the nice value effectively determines how fast a
process runs.
In keeping with the socialistic heritage of Unix process priority, a
process begins life with the same nice value as its parent process and
can raise it at will. A process can also raise the nice value of any
other process owned by the same user (or effective user). But only a
privileged process can lower its nice value. A privileged process can
also raise or lower another process' nice value.
GNU C Library functions for getting and setting nice values are
described in *Note Traditional Scheduling Functions::.

File:, Node: Traditional Scheduling Functions, Prev: Traditional Scheduling Intro, Up: Traditional Scheduling Functions For Traditional Scheduling
This section describes how you can read and set the nice value of a
process. All these symbols are declared in `sys/resource.h'.
The function and macro names are defined by POSIX, and refer to
"priority," but the functions actually have to do with nice values, as
the terms are used both in the manual and POSIX.
The range of valid nice values depends on the kernel, but typically
it runs from `-20' to `20'. A lower nice value corresponds to higher
priority for the process. These constants describe the range of
priority values:
The lowest valid nice value.
The highest valid nice value.
-- Function: int getpriority (int CLASS, int ID)
Return the nice value of a set of processes; CLASS and ID specify
which ones (see below). If the processes specified do not all
have the same nice value, this returns the lowest value that any
of them has.
On success, the return value is `0'. Otherwise, it is `-1' and
`ERRNO' is set accordingly. The `errno' values specific to this
function are:
The combination of CLASS and ID does not match any existing
The value of CLASS is not valid.
If the return value is `-1', it could indicate failure, or it could
be the nice value. The only way to make certain is to set `errno =
0' before calling `getpriority', then use `errno != 0' afterward
as the criterion for failure.
-- Function: int setpriority (int CLASS, int ID, int NICEVAL)
Set the nice value of a set of processes to NICEVAL; CLASS and ID
specify which ones (see below).
The return value is `0' on success, and `-1' on failure. The
following `errno' error condition are possible for this function:
The combination of CLASS and ID does not match any existing
The value of CLASS is not valid.
The call would set the nice value of a process which is owned
by a different user than the calling process (i.e., the
target process' real or effective uid does not match the
calling process' effective uid) and the calling process does
not have `CAP_SYS_NICE' permission.
The call would lower the process' nice value and the process
does not have `CAP_SYS_NICE' permission.
The arguments CLASS and ID together specify a set of processes in
which you are interested. These are the possible values of CLASS:
One particular process. The argument ID is a process ID (pid).
All the processes in a particular process group. The argument ID
is a process group ID (pgid).
All the processes owned by a particular user (i.e., whose real uid
indicates the user). The argument ID is a user ID (uid).
If the argument ID is 0, it stands for the calling process, its
process group, or its owner (real uid), according to CLASS.
-- Function: int nice (int INCREMENT)
Increment the nice value of the calling process by INCREMENT. The
return value is the new nice value on success, and `-1' on
failure. In the case of failure, `errno' will be set to the same
values as for `setpriority'.
Here is an equivalent definition of `nice':
nice (int increment)
int result, old = getpriority (PRIO_PROCESS, 0);
result = setpriority (PRIO_PROCESS, 0, old + increment);
if (result != -1)
return old + increment;
return -1;

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 processors.
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)
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)
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)
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)
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)
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)
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)
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 using
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 trouble.
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)
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)
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)
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)
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)
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)
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)
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 a 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)
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)
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)
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, ...)
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)
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)
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 process.
* 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 error.
-- 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 example.
-- 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 system.

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.