alarm(2) - Linux man page

Transcription

1 alarm(2): set alarm clock - Linux man page Page 1 of 1 10/20/2003 alarm(2) - Linux man page NAME alarm - set an alarm clock for delivery of a signal SYNOPSIS #include <unistd.h> unsigned int alarm(unsigned int seconds); DESCRIPTION alarm arranges for a SIGALRM signal to be delivered to the process in seconds seconds. If seconds is zero, no new alarm is scheduled. In any event any previously set alarm is cancelled. RETURN VALUE alarm returns the number of seconds remaining until any previously scheduled alarm was due to be delivered, or zero if there was no previously scheduled alarm. NOTES alarm and setitimer share the same timer; calls to one will interfere with use of the other. sleep() may be implemented using SIGALRM; mixing calls to alarm() and sleep() is a bad idea. Scheduling delays can, as ever, cause the execution of the process to be delayed by an arbitrary amount of time. CONFORMING TO SVr4, SVID, POSIX, X/OPEN, BSD 4.3 SEE ALSO setitimer(2), signal(2), sigaction(2), gettimeofday(2), select(2), pause(2), sleep(3)

2 waitpid(2): wait for process termination - Linux man page Page 1 of 3 waitpid(2) - Linux man page NAME wait, waitpid - wait for process termination SYNOPSIS #include <sys/types.h> #include <sys/wait.h> pid_t wait(int *status); pid_t waitpid(pid_t pid, int *status, int options); DESCRIPTION The wait function suspends execution of the current process until a child has exited, or until a signal is delivered whose action is to terminate the current process or to call a signal handling function. If a child has already exited by the time of the call (a so-called "zombie" process), the function returns immediately. Any system resources used by the child are freed. The waitpid function suspends execution of the current process until a child as specified by the pid argument has exited, or until a signal is delivered whose action is to terminate the current process or to call a signal handling function. If a child as requested by pid has already exited by the time of the call (a so-called "zombie" process), the function returns immediately. Any system resources used by the child are freed. The value of pid can be one of: < -1 which means to wait for any child process whose process group ID is equal to the absolute value of pid. -1 which means to wait for any child process; this is the same behaviour which wait exhibits. 0 which means to wait for any child process whose process group ID is equal to that of the calling process. > 0 which means to wait for the child whose process ID is equal to the value of pid. The value of options is an OR of zero or more of the following constants: WNOHANG which means to return immediately if no child has exited. WUNTRACED which means to also return for children which are stopped, and whose status has not been reported. (For Linux-only options, see below.) If status is not NULL, wait or waitpid store status information in the location pointed to by status. This status can be evaluated with the following macros (these macros take the stat buffer (an int) as an argument --- not a pointer to the buffer!): WIFEXITED(status) is non-zero if the child exited normally. WEXITSTATUS(status) evaluates to the least significant eight bits of the return code of the child which terminated, which may have been set as the argument to a call to exit() or as the argument for a return statement in the main program. This macro can only be evaluated if WIFEXITED returned non-zero. WIFSIGNALED(status)

3 waitpid(2): wait for process termination - Linux man page Page 2 of 3 returns true if the child process exited because of a signal which was not caught. WTERMSIG(status) returns the number of the signal that caused the child process to terminate. This macro can only be evaluated if WIFSIGNALED returned non-zero. WIFSTOPPED(status) returns true if the child process which caused the return is currently stopped; this is only possible if the call was done using WUNTRACED. WSTOPSIG(status) returns the number of the signal which caused the child to stop. This macro can only be evaluated if WIFSTOPPED returned non-zero. Some versions of Unix (e.g. Linux, Solaris, but not AIX, SunOS) also define a macro WCOREDUMP(status) to test whether the child process dumped core. Only use this enclosed in #ifdef WCOREDUMP... #endif. RETURN VALUE The process ID of the child which exited, or zero if WNOHANG was used and no child was available, or -1 on error (in which case errno is set to an appropriate value). ERRORS ECHILD if the process specified in pid does not exist or is not a child of the calling process. (This can happen for one's own child if the action for SIGCHLD is set to SIG_IGN. See also the LINUX NOTES section about threads.) EINVAL if the options argument was invalid. EINTR if WNOHANG was not set and an unblocked signal or a SIGCHLD was caught. NOTES The Single Unix Specification describes a flag SA_NOCLDWAIT (not supported under Linux) such that if either this flag is set, or the action for SIGCHLD is set to SIG_IGN then children that exit do not become zombies and a call to wait() or waitpid() will block until all children have exited, and then fail with errno set to ECHILD. The original POSIX standard left the behaviour of setting SIGCHLD to SIG_IGN unspecified. Later standards, including SUSv2 and POSIX specify the behaviour just described as an XSI-compliance option. Linux does not conform to the second of the two points just described: if a wait() or waitpid() call is made while SIGCHLD is being ignored, the call behaves just as though SIGCHLD were not being igored, that is, the call blocks until the next child terminates and then returns the PID and status of that child. LINUX NOTES In the Linux kernel, a kernel-scheduled thread is not a distinct construct from a process. Instead, a thread is simply a process that is created using the Linux-unique clone(2) system call; other routines such as the portable pthread_create(3) call are implemented using clone(2). Before Linux 2.4, a thread was just a special case of a process, and as a consequence one thread could not wait on the children of another thread, even when the latter belongs to the same thread group. However, POSIX prescribes such functionality, and since Linux 2.4 a thread can, and by default will, wait on children of other threads in the same thread group. The following Linux-specific options are for use with children created using clone(2). WCLONE Wait for "clone" children only. If omitted then wait for "non-clone" children only. (A "clone" child is one which delivers no signal, or a signal other than SIGCHLD to its parent upon termination.) This option is

4 waitpid(2): wait for process termination - Linux man page Page 3 of 3 ignored if WALL is also specified. WALL (Since Linux 2.4) Wait for all children, regardless of type ("clone" or "non-clone"). WNOTHREAD (Since Linux 2.4) Do not wait for children of other threads in the same thread group. This was the default before Linux 2.4. CONFORMING TO SVr4, POSIX.1 SEE ALSO clone(2), signal(2), wait4(2), pthread_create(3), signal(7)

5 sigaddset(3): POSIX signal set operations - Linux man page Page 1 of 1 10/20/2003 sigaddset(3) - Linux man page NAME sigemptyset, sigfillset, sigaddset, sigdelset, sigismember - POSIX signal set operations. SYNOPSIS #include <signal.h> int sigemptyset(sigset_t *set); int sigfillset(sigset_t *set); int sigaddset(sigset_t *set, int signum); int sigdelset(sigset_t *set, int signum); int sigismember(const sigset_t *set, int signum); DESCRIPTION The sigsetops(3) functions allow the manipulation of POSIX signal sets. sigemptyset initializes the signal set given by set to empty, with all signals excluded from the set. sigfillset initializes set to full, including all signals. sigaddset and sigdelset add and delete respectively signal signum from set. sigismember tests whether signum is a member of set. RETURN VALUE sigemptyset, sigfillset, sigaddset and sigdelset return 0 on success and -1 on error. sigismember returns 1 if signum is a member of set, 0 if signum is not a member, and -1 on error. ERRORS EINVAL sig is not a valid signal. CONFORMING TO POSIX SEE ALSO sigaction(2), sigpending(2), sigprocmask(2), sigsuspend(2)

6 sigaction(2): POSIX signal handling functions - Linux man page Page 1 of 5 10/20/2003 sigaction(2) - Linux man page NAME sigaction, sigprocmask, sigpending, sigsuspend - POSIX signal handling functions. SYNOPSIS #include <signal.h> int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); int sigprocmask(int how, const sigset_t *set, sigset_t *oldset); int sigpending(sigset_t *set); int sigsuspend(const sigset_t *mask); DESCRIPTION The sigaction system call is used to change the action taken by a process on receipt of a specific signal. signum specifies the signal and can be any valid signal except SIGKILL and SIGSTOP. If act is non-null, the new action for signal signum is installed from act. If oldact is non-null, the previous action is saved in oldact. The sigaction structure is defined as something like struct sigaction { void (*sa_handler)(int); void (*sa_sigaction)(int, siginfo_t *, void *); sigset_t sa_mask; int sa_flags; void (*sa_restorer)(void); } On some architectures a union is involved - do not assign to both sa_handler and sa_sigaction. The sa_restorer element is obsolete and should not be used. POSIX does not specify a sa_restorer element. sa_handler specifies the action to be associated with signum and may be SIG_DFL for the default action, SIG_IGN to ignore this signal, or a pointer to a signal handling function. sa_mask gives a mask of signals which should be blocked during execution of the signal handler. In addition, the signal which triggered the handler will be blocked, unless the SA_NODEFER or SA_NOMASK flags are used. sa_flags specifies a set of flags which modify the behaviour of the signal handling process. It is formed by the bitwise OR of zero or more of the following: SA_NOCLDSTOP If signum is SIGCHLD, do not receive notification when child processes stop (i.e., when child processes receive one of SIGSTOP, SIGTSTP, SIGTTIN or SIGTTOU). SA_ONESHOT or SA_RESETHAND

7 sigaction(2): POSIX signal handling functions - Linux man page Page 2 of 5 10/20/2003 Restore the signal action to the default state once the signal handler has been called. SA_ONSTACK Call the signal handler on an alternate signal stack provided by sigaltstack(2). If an alternate stack is not available, the default stack will be used. SA_RESTART Provide behaviour compatible with BSD signal semantics by making certain system calls restartable across signals. SA_NOMASK or SA_NODEFER Do not prevent the signal from being received from within its own signal handler. SA_SIGINFO The signal handler takes 3 arguments, not one. In this case, sa_sigaction should be set instead of sa_handler. (The sa_sigaction field was added in Linux ) The siginfo_t parameter to sa_sigaction is a struct with the following elements siginfo_t { int si_signo; /* Signal number */ int si_errno; /* An errno value */ int si_code; /* Signal code */ pid_t si_pid; /* Sending process ID */ uid_t si_uid; /* Real user ID of sending process */ int si_status; /* Exit value or signal */ clock_t si_utime; /* User time consumed */ clock_t si_stime; /* System time consumed */ sigval_t si_value; /* Signal value */ int si_int; /* POSIX.1b signal */ void * si_ptr; /* POSIX.1b signal */ void * si_addr; /* Memory location which caused fault */ int si_band; /* Band event */ int si_fd; /* File descriptor */ } si_signo, si_errno and si_code are defined for all signals. The rest of the struct may be a union, so that one should only read the fields that are meaningful for the given signal. kill(2), POSIX.1b signals and SIGCHLD fill in si_pid and si_uid. SIGCHLDalsofillsin si_status, si_utime and si_stime. si_int and si_ptr are specified by the sender of the POSIX.1b signal. SIGILL, SIGFPE, SIGSEGV and SIGBUS fill in si_addr with the address of the fault. SIGPOLL fills in si_band and si_fd. si_code indicates why this signal was sent. It is a value, not a bitmask. The values which are possible for any signal are listed in this table: Value SI_USER si_code Signal origin kill, sigsend or raise SI_KERNEL The kernel SI_QUEUE SI_TIMER SI_MESGQ sigqueue timer expired mesq state changed SI_ASYNCIO AIO completed SI_SIGIO queued SIGIO SIGILL ILL_ILLOPC illegal opcode ILL_ILLOPN illegal operand

8 sigaction(2): POSIX signal handling functions - Linux man page Page 3 of 5 10/20/2003 ILL_ILLADR illegal addressing mode ILL_ILLTRP illegal trap ILL_PRVOPC privileged opcode ILL_PRVREG privileged register ILL_COPROC coprocessor error ILL_BADSTK internal stack error SIGFPE FPE_INTDIV integer divide by zero FPE_INTOVF integer overflow FPE_FLTDIV floating point divide by zero FPE_FLTOVF floating point overflow FPE_FLTUND floating point underflow FPE_FLTRES floating point inexact result FPE_FLTINV floating point invalid operation FPE_FLTSUB subscript out of range SIGSEGV SEGV_MAPERR address not mapped to object SEGV_ACCERR invalid permissions for mapped object SIGBUS BUS_ADRALN invalid address alignment BUS_ADRERR non-existent physical address BUS_OBJERR object specific hardware error SIGTRAP TRAP_BRKPT process breakpoint TRAP_TRACE process trace trap SIGCHLD CLD_EXITED child has exited CLD_KILLED child was killed CLD_DUMPED child terminated abnormally CLD_TRAPPED traced child has trapped CLD_STOPPED child has stopped CLD_CONTINUED stopped child has continued SIGPOLL POLL_IN data input available

9 sigaction(2): POSIX signal handling functions - Linux man page Page 4 of 5 10/20/2003 POLL_OUT output buffers available POLL_MSG input message available POLL_ERR i/o error POLL_PRI high priority input available POLL_HUP device disconnected The sigprocmask call is used to change the list of currently blocked signals. The behaviour of the call is dependent on the value of how, as follows. SIG_BLOCK The set of blocked signals is the union of the current set and the set argument. SIG_UNBLOCK The signals in set are removed from the current set of blocked signals. It is legal to attempt to unblock a signal which is not blocked. SIG_SETMASK The set of blocked signals is set to the argument set. If oldset is non-null, the previous value of the signal mask is stored in oldset. The sigpending call allows the examination of pending signals (ones which have been raised while blocked). The signal mask of pending signals is stored in set. The sigsuspend call temporarily replaces the signal mask for the process with that given by mask and then suspends the process until a signal is received. RETURN VALUE The functions sigaction, sigprocmask, and sigpending return 0 on success and -1 on error. The function sigsuspend always returns -1, normally with the error EINTR. ERRORS EINVAL An invalid signal was specified. This will also be generated if an attempt is made to change the action for SIGKILL or SIGSTOP, which cannot be caught. EFAULT act, oldact, set, oldset or mask point to memory which is not a valid part of the process address space. EINTR System call was interrupted. NOTES It is not possible to block SIGKILL or SIGSTOP with the sigprocmask call. Attempts to do so will be silently ignored. According to POSIX, the behaviour of a process is undefined after it ignores a SIGFPE, SIGILL, or SIGSEGV signal that was not generated by the kill() or the raise() functions. Integer division by zero has undefined result. On some architectures it will generate a SIGFPE signal. (Also dividing the most negative integer by -1 may generate SIGFPE.) Ignoring this signal might lead to an endless loop. POSIX (B ) disallows setting the action for SIGCHLD to SIG_IGN. The BSD and SYSV behaviours differ, causing BSD software that sets the action for SIGCHLD to SIG_IGN to fail on Linux.

10 sigaction(2): POSIX signal handling functions - Linux man page Page 5 of 5 10/20/2003 The POSIX spec only defines SA_NOCLDSTOP. Use of other sa_flags is non-portable. The SA_RESETHAND flag is compatible with the SVr4 flag of the same name. The SA_NODEFER flag is compatible with the SVr4 flag of the same name under kernels and newer. On older kernels the Linux implementation allowed the receipt of any signal, not just the one we are installing (effectively overriding any sa_mask settings). The SA_RESETHAND and SA_NODEFER names for SVr4 compatibility are present only in library versions and greater. The SA_SIGINFO flag is specified by POSIX.1b. Support for it was added in Linux 2.2. sigaction can be called with a null second argument to query the current signal handler. It can also be used to check whether a given signal is valid for the current machine by calling it with null second and third arguments. See sigsetops(3) for details on manipulating signal sets. CONFORMING TO POSIX, SVr4. SVr4 does not document the EINTR condition. UNDOCUMENTED Before the introduction of SA_SIGINFO it was also possible to get some additional information, namely by using a sa_handler with second argument of type struct sigcontext. See the relevant kernel sources for details. This use is obsolete now. SEE ALSO kill(1), kill(2), killpg(2), pause(2), sigaltstack(2), raise(3), siginterrupt(3), signal(2), signal(7), sigsetops(3), sigvec(2)

11 shmget(2): allocates a shared memory segment - Linux man page Page 1 of 3 shmget(2) - Linux man page NAME shmget - allocates a shared memory segment SYNOPSIS #include <sys/ipc.h> #include <sys/shm.h> int shmget(key_t key, int size, int shmflg); DESCRIPTION shmget() returns the identifier of the shared memory segment associated to the value of the argument key. A new shared memory segment, with size equal to the round up of size to a multiple of PAGE_SIZE, is created if key has value IPC_PRIVATE or key isn't IPC_PRIVATE, no shared memory segment is associated to key, and IPC_CREAT is asserted in shmflg (i.e. shmflg&ipc_creat isn't zero). The value shmflg is composed of: IPC_CREAT to create a new segment. If this flag is not used, then shmget() will find the segment associated with key, check to see if the user has permission to receive the shmid associated with the segment, and ensure the segment is not marked for destruction. IPC_EXCL used with IPC_CREAT to ensure failure if the segment exists. mode_flags (lowest 9 bits) specifying the permissions granted to the owner, group, and world. Presently, the execute permissions are not used by the system. If a new segment is created, the access permissions from shmflg are copied into the shm_perm member of the shmid_ds structure that defines the segment. The shmid_ds structure: struct shmid_ds { struct ipc_perm shm_perm; /* operation perms */ int shm_segsz; /* size of segment (bytes) */ time_t shm_atime; /* last attach time */ time_t shm_dtime; /* last detach time */ time_t shm_ctime; /* last change time */ unsigned short shm_cpid; /* pid of creator */ unsigned short shm_lpid; /* pid of last operator */ short shm_nattch; /* no. of current attaches */ }; struct ipc_perm { key_t key; ushort uid; /* owner euid and egid */ ushort gid; ushort cuid; /* creator euid and egid */ ushort cgid; ushort mode; /* lower 9 bits of shmflg */ ushort seq; /* sequence number */ };

12 shmget(2): allocates a shared memory segment - Linux man page Page 2 of 3 Furthermore, while creating, the system call initializes the system shared memory segment data structure shmid_ds as follows: shm_perm.cuid and shm_perm.uid are set to the effective user-id of the calling process. shm_perm.cgid and shm_perm.gid are set to the effective group-id of the calling process. The lowest order 9 bits of shm_perm.mode are set to the lowest order 9 bit of shmflg. shm_segsz is set to the value of size. shm_lpid, shm_nattch, shm_atime and shm_dtime are set to 0. shm_ctime is set to the current time. If the shared memory segment already exists, the access permissions are verified, and a check is made to see if it is marked for destruction. SYSTEM CALLS fork() After a fork() the child inherits the attached shared memory segments. exec() After an exec() all attached shared memory segments are detached (not destroyed). exit() Upon exit() all attached shared memory segments are detached (not destroyed). RETURN VALUE A valid segment identifier, shmid, is returned on success, -1 on error. ERRORS On failure, errno is set to one of the following: EINVAL is returned if a new segment was to be created and size < SHMMIN or size > SHMMAX, or no new segment was to be created, a segment with given key existed, but size is greater than the size of that segment. EEXIST is returned if IPC_CREAT IPC_EXCL was specified and the segment exists. EIDRM is returned if the segment is marked as destroyed, or was removed. ENOSPC is returned if all possible shared memory id's have been taken (SHMMNI) or if allocating a segment of the requested size would cause the system to exceed the system-wide limit on shared memory (SHMALL). ENOENT is returned if no segment exists for the given key, and IPC_CREAT was not specified. EACCES is returned if the user does not have permission to access the shared memory segment. ENOMEM is returned if no memory could be allocated for segment overhead. NOTES IPC_PRIVATE isn't a flag field but a key_t type. If this special value is used for key, the system call ignores everything but the lowest order 9 bits of shmflg and creates a new shared memory segment (on success). The followings are limits on shared memory segment resources affecting a shmget call: SHMALL System wide maximum of shared memory pages: policy dependent.

13 shmget(2): allocates a shared memory segment - Linux man page Page 3 of 3 SHMMAX Maximum size in bytes for a shared memory segment: implementation dependent (currently 4M). SHMMIN Minimum size in bytes for a shared memory segment: implementation dependent (currently 1 byte, though PAGE_SIZE is the effective minimum size). SHMMNI System wide maximum number of shared memory segments: implementation dependent (currently 4096, was 128 before Linux ). The implementation has no specific limits for the per process maximum number of shared memory segments (SHMSEG). BUGS Use of IPC_PRIVATE doesn't inhibit to other processes the access to the allocated shared memory segment. There is currently no intrinsic way for a process to ensure exclusive access to a shared memory segment. Asserting both IPC_CREAT and IPC_EXCL in shmflg only ensures (on success) that a new shared memory segment will be created, it doesn't imply exclusive access to the segment. CONFORMING TO SVr4, SVID. SVr4 documents an additional error condition EEXIST. Neither SVr4 nor SVID documents an EIDRM condition. SEE ALSO ftok(3), ipc(5), shmctl(2), shmat(2), shmdt(2)

14 shmdt(2): shared memory operations - Linux man page Page 1 of 3 shmdt(2) - Linux man page NAME shmop - shared memory operations SYNOPSIS #include <sys/types.h> #include <sys/shm.h> void *shmat(int shmid, const void *shmaddr, int shmflg); int shmdt(const void *shmaddr); DESCRIPTION The function shmat attaches the shared memory segment identified by shmid to the address space of the calling process. The attaching address is specified by shmaddr with one of the following criteria: If shmaddr is NULL, the system chooses a suitable (unused) address at which to attach the segment. If shmaddr isn't NULL and SHM_RND is asserted in shmflg, the attach occurs at the address equal to shmaddr rounded down to the nearest multiple of SHMLBA. Otherwise shmaddr must be a page aligned address at which the attach occurs. If SHM_RDONLY is asserted in shmflg, the segment is attached for reading and the process must have read permission for the segment. Otherwise the segment is attached for read and write and the process must have read and write permission for the segment. There is no notion of a write-only shared memory segment. The brk value of the calling process is not altered by the attach. The segment will automatically be detached at process exit. The same segment may be attached as a read and as a read-write one, and more than once, in the process's address space. On a successful shmat call the system updates the members of the shmid_ds structure associated to the shared memory segment as follows: shm_atime is set to the current time. shm_lpid is set to the process-id of the calling process. shm_nattch is incremented by one. Note that the attach succeeds also if the shared memory segment is marked to be deleted. The function shmdt detaches the shared memory segment located at the address specified by shmaddr from the address space of the calling process. The to-be-detached segment must be currently attached with shmaddr equal to the value returned by the its attaching shmat call. On a successful shmdt call the system updates the members of the shmid_ds structure associated with the shared memory segment as follows: shm_dtime is set to the current time. shm_lpid is set to the process-id of the calling process. shm_nattch is decremented by one. If it becomes 0 and the segment is marked for deletion, the segment is deleted.

15 shmdt(2): shared memory operations - Linux man page Page 2 of 3 The occupied region in the user space of the calling process is unmapped. SYSTEM CALLS fork() After a fork() the child inherits the attached shared memory segments. exec() After an exec() all attached shared memory segments are detached from the process. exit() Upon exit() all attached shared memory segments are detached from the process. RETURN VALUE On failure both functions return -1 with errno indicating the error. On success shmat returns the address of the attached shared memory segment, and shmdt returns 0. ERRORS When shmat fails, errno is set to one of the following: EACCES The calling process has no access permissions for the requested attach type. EINVAL Invalid shmid value, unaligned (i.e., not page-aligned and SHM_RND was not specified) or invalid shmaddr value, or failing attach at brk. ENOMEM Could not allocate memory for the descriptor or for the page tables. The function shmdt can fail only if there is no shared memory segment attached at shmaddr, in such a case at return errno will be set to EINVAL. NOTES Using shmat with shmaddr equal to NULL is the preferred, portable way of attaching a shared memory segment. Be aware that the shared memory segment attached in this way may be attached at different addresses in different processes. Therefore, any pointers maintained within the shared memory must be made relative (typically to the starting address of the segment), rather than absolute. The following system parameter affects a shmat system call: SHMLBA Segment low boundary address multiple. Must be page aligned. For the current implementation the SHMBLA value is PAGE_SIZE. The implementation has no intrinsic limit to the per-process maximum number of shared memory segments (SHMSEG). CONFORMING TO SVr4, SVID. SVr4 documents an additional error condition EMFILE. In SVID-v4 the type of the shmaddr argument was changed from char * into const void *, and the returned type of shmat() from char * into void *. (Linux libc4 and libc5 have the char * prototypes; glibc2 has void *.) SEE ALSO ipc(5), shmctl(2), shmget(2)

16 shmdt(2): shared memory operations - Linux man page Page 3 of 3

17 shmctl(2): shared memory control - Linux man page Page 1 of 2 shmctl(2) - Linux man page NAME shmctl - shared memory control SYNOPSIS #include <sys/ipc.h> #include <sys/shm.h> int shmctl(int shmid, int cmd, struct shmid_ds *buf); DESCRIPTION shmctl() allows the user to receive information on a shared memory segment, set the owner, group, and permissions of a shared memory segment, or destroy a segment. The information about the segment identified by shmid is returned in a shmid_ds structure: struct shmid_ds { struct ipc_perm shm_perm; /* operation perms */ int shm_segsz; /* size of segment (bytes) */ time_t shm_atime; /* last attach time */ time_t shm_dtime; /* last detach time */ time_t shm_ctime; /* last change time */ unsigned short shm_cpid; /* pid of creator */ unsigned short shm_lpid; /* pid of last operator */ short shm_nattch; /* no. of current attaches */... }; The highlighted fields in the member shm_perm can be set: struct ipc_perm { key_t key; ushort uid; /* owner euid and egid */ ushort gid; ushort cuid; /* creator euid and egid */ ushort cgid; ushort mode; /* lower 9 bits of access modes */ ushort seq; /* sequence number */ }; The following cmds are available: IPC_STAT is used to copy the information about the shared memory segment into the buffer buf. The user must have read access to the shared memory segment. IPC_SET is used to apply the changes the user has made to the uid, gid, or mode members of the shm_perms field. Only the lowest 9 bits of mode are used. The shm_ctime member is also updated. The user must be the owner, creator, or the super-user. IPC_RMID is used to mark the segment as destroyed. It will actually be destroyed after the last detach. (I.e., when the shm_nattch member of the associated structure shmid_ds is zero.) The user must be the owner, creator, or the super-user.

18 shmctl(2): shared memory control - Linux man page Page 2 of 2 The user must ensure that a segment is eventually destroyed; otherwise its pages that were faulted in will remain in memory or swap. In addition, the super-user can prevent or allow swapping of a shared memory segment with the following cmds: (Linux only) SHM_LOCK prevents swapping of a shared memory segment. The user must fault in any pages that are required to be present after locking is enabled. SHM_UNLOCK allows the shared memory segment to be swapped out. The IPC_INFO, SHM_STAT and SHM_INFO control calls are used by the ipcs(8) program to provide information on allocated resources. In the future, these may be modified as needed or moved to a proc file system interface. RETURN VALUE 0 is returned on success, -1 on error. ERRORS On error, errno will be set to one of the following: EACCES is returned if IPC_STAT is requested and shm_perm.modes does not allow read access for shmid. EFAULT The argument cmd has value IPC_SET or IPC_STAT but the address pointed to by buf isn't accessible. EINVAL is returned if shmid is not a valid identifier, or cmd is not a valid command. EIDRM is returned if shmid points to a removed identifier. EPERM is returned if IPC_SET or IPC_RMID is attempted, and the effective user ID of the calling process is not the creator (as found in shm_perm.cuid), the owner (as found in shm_perm.uid), or the super-user. EOVERFLOW is returned if IPC_STAT is attempted, and the gid or uid value is too large to be stored in the structure pointed to by buf. NOTE Various fields in a struct shmid_ds were shorts under Linux 2.2 and have become longs under Linux 2.4. To take advantage of this, a recompilation under glibc or later should suffice. (The kernel distinguishes old and new calls by a IPC_64 flag in cmd.) CONFORMING TO SVr4, SVID. SVr4 documents additional error conditions EINVAL, ENOENT, ENOSPC, ENOMEM, EEXIST. Neither SVr4 nor SVID documents an EIDRM error condition. SEE ALSO shmget(2), shmop(2)

19 shmat(2): shared memory operations - Linux man page Page 1 of 3 shmat(2) - Linux man page NAME shmop - shared memory operations SYNOPSIS #include <sys/types.h> #include <sys/shm.h> void *shmat(int shmid, const void *shmaddr, int shmflg); int shmdt(const void *shmaddr); DESCRIPTION The function shmat attaches the shared memory segment identified by shmid to the address space of the calling process. The attaching address is specified by shmaddr with one of the following criteria: If shmaddr is NULL, the system chooses a suitable (unused) address at which to attach the segment. If shmaddr isn't NULL and SHM_RND is asserted in shmflg, the attach occurs at the address equal to shmaddr rounded down to the nearest multiple of SHMLBA. Otherwise shmaddr must be a page aligned address at which the attach occurs. If SHM_RDONLY is asserted in shmflg, the segment is attached for reading and the process must have read permission for the segment. Otherwise the segment is attached for read and write and the process must have read and write permission for the segment. There is no notion of a write-only shared memory segment. The brk value of the calling process is not altered by the attach. The segment will automatically be detached at process exit. The same segment may be attached as a read and as a read-write one, and more than once, in the process's address space. On a successful shmat call the system updates the members of the shmid_ds structure associated to the shared memory segment as follows: shm_atime is set to the current time. shm_lpid is set to the process-id of the calling process. shm_nattch is incremented by one. Note that the attach succeeds also if the shared memory segment is marked to be deleted. The function shmdt detaches the shared memory segment located at the address specified by shmaddr from the address space of the calling process. The to-be-detached segment must be currently attached with shmaddr equal to the value returned by the its attaching shmat call. On a successful shmdt call the system updates the members of the shmid_ds structure associated with the shared memory segment as follows: shm_dtime is set to the current time. shm_lpid is set to the process-id of the calling process. shm_nattch is decremented by one. If it becomes 0 and the segment is marked for deletion, the segment is deleted.

20 shmat(2): shared memory operations - Linux man page Page 2 of 3 The occupied region in the user space of the calling process is unmapped. SYSTEM CALLS fork() After a fork() the child inherits the attached shared memory segments. exec() After an exec() all attached shared memory segments are detached from the process. exit() Upon exit() all attached shared memory segments are detached from the process. RETURN VALUE On failure both functions return -1 with errno indicating the error. On success shmat returns the address of the attached shared memory segment, and shmdt returns 0. ERRORS When shmat fails, errno is set to one of the following: EACCES The calling process has no access permissions for the requested attach type. EINVAL Invalid shmid value, unaligned (i.e., not page-aligned and SHM_RND was not specified) or invalid shmaddr value, or failing attach at brk. ENOMEM Could not allocate memory for the descriptor or for the page tables. The function shmdt can fail only if there is no shared memory segment attached at shmaddr, in such a case at return errno will be set to EINVAL. NOTES Using shmat with shmaddr equal to NULL is the preferred, portable way of attaching a shared memory segment. Be aware that the shared memory segment attached in this way may be attached at different addresses in different processes. Therefore, any pointers maintained within the shared memory must be made relative (typically to the starting address of the segment), rather than absolute. The following system parameter affects a shmat system call: SHMLBA Segment low boundary address multiple. Must be page aligned. For the current implementation the SHMBLA value is PAGE_SIZE. The implementation has no intrinsic limit to the per-process maximum number of shared memory segments (SHMSEG). CONFORMING TO SVr4, SVID. SVr4 documents an additional error condition EMFILE. In SVID-v4 the type of the shmaddr argument was changed from char * into const void *, and the returned type of shmat() from char * into void *. (Linux libc4 and libc5 have the char * prototypes; glibc2 has void *.) SEE ALSO ipc(5), shmctl(2), shmget(2)

21 shmat(2): shared memory operations - Linux man page Page 3 of 3

22 semop(2): semaphore operations - Linux man page Page 1 of 3 semop(2) - Linux man page NAME semop - semaphore operations SYNOPSIS #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> int semop(int semid, struct sembuf *sops, unsigned nsops); DESCRIPTION A semaphore is represented by an anonymous structure including the following members: unsigned short semval; /* semaphore value */ unsigned short semzcnt; /* # waiting for zero */ unsigned short semncnt; /* # waiting for increase */ pid_t sempid; /* process that did last op */ The function semop performs operations on selected members of the semaphore set indicated by semid. Each of the nsops elements in the array pointed to by sops specifies an operation to be performed on a semaphore by a struct sembuf including the following members: unsigned short sem_num; /* semaphore number */ short sem_op; /* semaphore operation */ short sem_flg; /* operation flags */ Flags recognized in sem_flg are IPC_NOWAIT and SEM_UNDO. If an operation asserts SEM_UNDO, it will be undone when the process exits. The set of operations contained in sops is performed atomically, that is, the operations are performed at the same time, and only if they can all be simultaneously performed. The behaviour of the system call if not all operations can be performed immediately depends on the presence of the IPC_NOWAIT flag in the individual sem_flg fields, as noted below. Each operation is performed on the sem_num-th semaphore of the semaphore set, where the first semaphore of the set is semaphore 0. There are three types of operation, distinguished by the value of sem_op. If sem_op is a positive integer, the operation adds this value to the semaphore value (semval). Furthermore, if SEM_UNDO is asserted for this operation, the system updates the process undo count (semadj) for this semaphore. This operation can always proceed - it never forces a process to wait. The calling process must have alter permission on the semaphore set. If sem_op is zero, the process must have read access permission on the semaphore set. This is a "wait-forzero" operation: if semval is zero, the operation can immediately proceed. Otherwise, if IPC_NOWAIT is asserted in sem_flg, the system call fails with errno set to EAGAIN (and none of the operations in sops is performed). Otherwise semzcnt (the count of processes waiting until this semaphore's value becomes zero) is incremented by one and the process sleeps until one of the following occurs: *

23 semop(2): semaphore operations - Linux man page Page 2 of 3 semval becomes 0, at which time the value of semzcnt is decremented. * The semaphore set is removed: the system call fails, with errno set to EIDRM. * The calling process catches a signal: the value of semzcnt is decremented and the system call fails, with errno set to EINTR. If sem_op is less than zero, the process must have alter permission on the semaphore set. If semval is greater than or equal to the absolute value of sem_op, the operation can proceed immediately: the absolute value of sem_op is subtracted from semval, and, if SEM_UNDO is asserted for this operation, the system updates the process undo count (semadj) for this semaphore. If the absolute value of sem_op is greater than semval, and IPC_NOWAIT is asserted in sem_flg, the system call fails, with errno set to EAGAIN (and none of the operations in sops is performed). Otherwise semncnt (the counter of processes waiting for this semaphore's value to increase) is incremented by one and the process sleeps until one of the following occurs: * semval becomes greater than or equal to the absolute value of sem_op, at which time the value of semncnt is decremented, the absolute value of sem_op is subtracted from semval and, if SEM_UNDO is asserted for this operation, the system updates the process undo count (semadj) for this semaphore. * The semaphore set is removed from the system: the system call fails with errno set to EIDRM. * The calling process catches a signal: the value of semncnt is decremented and the system call fails with errno set to EINTR. On successful completion, the sempid value for each semaphore specified in the array pointed to by sops is set to the process ID of the calling process. In addition, the sem_otime is set to the current time. RETURN VALUE If successful the system call returns 0, otherwise it returns -1 with errno indicating the error. ERRORS On failure, errno is set to one of the following: E2BIG The argument nsops is greater than SEMOPM, the maximum number of operations allowed per system call. EACCES The calling process has no access permissions on the semaphore set as required by one of the specified operations. EAGAIN An operation could not proceed immediately and IPC_NOWAIT was asserted in its sem_flg. EFAULT The address pointed to by sops isn't accessible. EFBIG For some operation the value of sem_num is less than 0 or greater than or equal to the number of semaphores in the set. EIDRM The semaphore set was removed. EINTR While blocked in this system call, the process caught a signal. EINVAL The semaphore set doesn't exist, or semid is less than zero, or nsops has a non-positive value. ENOMEM The sem_flg of some operation asserted SEM_UNDO and the system does not have enough memory to allocate the undo structure. ERANGE For some operation sem_op+semval is greater than SEMVMX, the implementation dependent maximum value for semval. NOTES

24 semop(2): semaphore operations - Linux man page Page 3 of 3 The sem_undo structures of a process aren't inherited across a fork(2) system call, but they are inherited across a execve(2) system call. semop is never automatically restarted after being interrupted by a signal handler, regardless of the setting of the SA_RESTART flags when establishing a signal handler. semadj is a per-process integer which is simply the (negative) count of all semaphore operations performed specifying the SEM_UNDO flag. When a semaphore's value is directly set using the SETVAL or SETALL request to semctl(2), the corresponding semadj values in all processes are cleared. The semval, sempid, semzcnt, and semnct values for a semaphore can all be retrieved using appropriate semctl(2) calls. The followings are limits on semaphore set resources affecting a semop call: SEMOPM Maximum number of operations allowed for one semop call (32). SEMVMX Maximum allowable value for semval: implementation dependent (32767). The implementation has no intrinsic limits for the adjust on exit maximum value (SEMAEM), the system wide maximum number of undo structures (SEMMNU) and the per-process maximum number of undo entries system parameters. BUGS When a process terminates, its set of associated semadj structures is used to undo the effect of all of the semaphore operations it performed with the SEM_UNDO flag. This raises a difficulty: if one (or more) of these semaphore adjustments would result in an attempt to decrease a semaphore's value below zero, what should an implementation do? One possible approach would be to block until all the semaphore adjustments could be performed. This is however undesirable since it could force process termination to block for arbitrarily long periods. Another possibility is that such semaphore adjustments could be ignored altogether (somewhat analogously to failing when IPC_NOWAIT is specified for a semaphore operation). Linux adopts a third approach: decreasing the semaphore value as far as possible (i.e., to zero) and allowing process termination to proceed immediately. CONFORMING TO SVr4, SVID. SVr4 documents additional error conditions EINVAL, EFBIG, ENOSPC. SEE ALSO ipc(5), semctl(2), semget(2), sigaction(2)

25 semget(2): get a semaphore set identifier - Linux man page Page 1 of 2 semget(2) - Linux man page NAME semget - get a semaphore set identifier SYNOPSIS #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> int semget(key_t key, int nsems, int semflg); DESCRIPTION This function returns the semaphore set identifier associated with the argument key. A new set of nsems semaphores is created if key has the value IPC_PRIVATE or if no existing semaphore set is associated to key and IPC_CREAT is asserted in semflg (i.e. semflg & IPC_CREAT isn't zero). The presence in semflg of the fields IPC_CREAT and IPC_EXCL plays the same role, with respect to the existence of the semaphore set, as the presence of O_CREAT and O_EXCL in the mode argument of the open(2) system call: i.e. the semget function fails if semflg asserts both IPC_CREAT and IPC_EXCL and a semaphore set already exists for key. Upon creation, the low-order 9 bits of the argument semflg define the access permissions (for owner, group and others) for the semaphore set. These bits have the same format, and the same meaning, as the mode argument in the open(2) or creat(2) system calls (though the execute permissions are not meaningful for semaphores, and write permissions mean permission to alter semaphore values). When creating a new semaphore set, semget initializes the semaphore set's associated data structure semid_ds as follows: sem_perm.cuid and sem_perm.uid are set to the effective user-id of the calling process. sem_perm.cgid and sem_perm.gid are set to the effective group-id of the calling process. The low-order 9 bits of sem_perm.mode are set to the low-order 9 bits of semflg. sem_nsems is set to the value of nsems. sem_otime is set to 0. sem_ctime is set to the current time. The argument nsems can be 0 (a don't care) when a semaphore set is not being created. Otherwise nsems must be greater than 0 and less than or equal to the maximum number of semaphores per semaphore set (SEMMSL). If the semaphore set already exists, the access permissions are verified. RETURN VALUE If successful, the return value will be the semaphore set identifier (a nonnegative integer), otherwise -1 is returned, with errno indicating the error. ERRORS On failure errno will be set to one of the following:

26 semget(2): get a semaphore set identifier - Linux man page Page 2 of 2 EACCES A semaphore set exists for key, but the calling process does not have permission to access the set. EEXIST A semaphore set exists for key and semflg was asserting both IPC_CREAT and IPC_EXCL. ENOENT No semaphore set exists for key and semflg wasn't asserting IPC_CREAT. EINVAL nsems is less than 0 or greater than the limit on the number of semaphores per semaphore set (SEMMSL), or a semaphore set corresponding to key already exists, and nsems is larger than the number of semaphores in that set. ENOMEM A semaphore set has to be created but the system has not enough memory for the new data structure. ENOSPC A semaphore set has to be created but the system limit for the maximum number of semaphore sets (SEMMNI), or the system wide maximum number of semaphores (SEMMNS), would be exceeded. NOTES IPC_PRIVATE isn't a flag field but a key_t type. If this special value is used for key, the system call ignores everything but the low-order 9 bits of semflg and creates a new semaphore set (on success). The followings are limits on semaphore set resources affecting a semget call: SEMMNI System wide maximum number of semaphore sets: policy dependent. SEMMSL Maximum number of semaphores per semid: implementation dependent (500 currently). SEMMNS System wide maximum number of semaphores: policy dependent. Values greater than SEMMSL * SEMMNI makes it irrelevant. BUGS Use of IPC_PRIVATE doesn't inhibit to other processes the access to the allocated semaphore set. There is currently no intrinsic way for a process to ensure exclusive access to a semaphore set. Asserting both IPC_CREAT and IPC_EXCL in semflg only ensures (on success) that a new semaphore set will be created, it doesn't imply exclusive access to the semaphore set. The data structure associated with each semaphore in the set isn't initialized by the system call. In order to initialize those data structures, one has to execute a subsequent call to semctl(2) to perform a SETVAL or a SETALL command on the semaphore set. CONFORMING TO SVr4, SVID. SVr4 documents additional error conditions EFBIG, E2BIG, EAGAIN, ERANGE, EFAULT. SEE ALSO ftok(3), ipc(5), semctl(2), semop(2)

27 semctl(2): semaphore control operations - Linux man page Page 1 of 3 semctl(2) - Linux man page NAME semctl - semaphore control operations SYNOPSIS #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> int semctl(int semid, int semnum, int cmd,...); DESCRIPTION The function semctl performs the control operation specified by cmd on the semaphore set identified by semid, or on the semnum-th semaphore of that set. (Semaphores are numbered starting at 0.) This function has three or four arguments. When there are four, the call is semctl(semid,semnum,cmd,arg); where the fourth argument arg has a type union semun defined as follows: #if defined( GNU_LIBRARY ) &&!defined(_sem_semun_undefined) /* union semun is defined by including <sys/sem.h> */ #else /* according to X/OPEN we have to define it ourselves */ union semun { int val; /* value for SETVAL */ struct semid_ds *buf; /* buffer for IPC_STAT, IPC_SET */ unsigned short *array; /* array for GETALL, SETALL */ /* Linux specific part: */ struct seminfo * buf; /* buffer for IPC_INFO */ }; #endif Legal values for cmd are: IPC_STAT Copy info from the semaphore set data structure into the structure pointed to by arg.buf. The argument semnum is ignored. The calling process must have read access privileges on the semaphore set. IPC_SET Write the values of some members of the semid_ds structure pointed to by arg.buf to the semaphore set data structure, updating also its sem_ctime member. Considered members from the user supplied struct semid_ds pointed to by arg.buf are sem_perm.uid sem_perm.gid sem_perm.mode /* only lowest 9-bits */ The effective user-id of the calling process must be that of the super-user, or match the creator or owner of the semaphore set. The argument semnum is ignored. IPC_RMID Immediately remove the semaphore set and its data structures awakening all waiting processes (with an error return and errno set to EIDRM). The effective user-id of the calling process must be that of the super-user, or match the creator or owner of the semaphore set. The argument semnum is ignored. GETALL