HP-UX Reference Section 2: System Calls HP-UX 11i Version 2 December 2007 Update Volume 5 of 10 Manufacturing Part Number : B2355-92070 E1207 Printed in USA © Copyright 1983-2007 Hewlett-Packard Development Company LP.
Legal Notices The information in this document is subject to change without notice. Warranty The only warranties for HP products and services are set forth in the express warranty statements accompanying such products and services. Nothing herein should be construed as constituting an additional warranty. HP shall not be liable for technical or editorial errors or omissions contained herein. U.S. Government License Confidential computer software.
Copyright 1996 Morning Star Technologies, Inc. Copyright 1996 Progressive Systems, Inc. Trademark Notices Intel and Itanium are registered trademarks of Intel Corporation in the US and other countries and are used under license. Java is a US trademark of Sun Microsystems, Inc. Microsoft and MS-DOS are U.S. registered trademarks of Microsoft Corporation. OSF/Motif is a trademark of The Open Group in the US and other countries. UNIX is a registered trademark of The Open Group.
Preface HP-UX is the Hewlett-Packard Company’s implementation of a UNIX operating system that is compatible with various industry standards. It is based on the System V Release 4 operating system and includes important features from the Fourth Berkeley Software Distribution. The ten volumes of this manual contain the system reference documentation, made up of individual entries called manpages, named for the man command (see man (1)) that displays them on the system.
Typographical Conventions audit (5) An HP-UX manpage reference. For example, audit is the name and 5 is the section in the HP-UX Reference. On the web and on the Instant Information CD or DVD, it may be a hyperlink to the manpage itself. From the HP-UX command line, you can enter “man audit” or “man 5 audit” to view the manpage. See man (1). Book Title The title of a book. On the web and on the Instant Information CD or DVD, it may be a hyperlink to the book itself.
Command Syntax Literal A word or character that you enter literally. Replaceable A word or phrase that you replace with an appropriate value. -chars One or more grouped command options, such as -ikx. The chars are usually a string of literal characters that each represent a specific option. For example, the entry -ikx is equivalent to the individual options -i, -k, and -x. The plus character (+) is sometimes used as an option prefix. -word A single command option, such as -help.
Function Synopsis and Syntax HP-UX functions are described in a definition format rather than a usage format. The definition format includes type information that is omitted when the function call is actually included in a program. The function syntax elements are the same as for commands, except for the options; see “Command Syntax” on page 7. Function General Definition The general definition form is: type func ( type param [ , type param ]...
Publishing History Revisions of the HP-UX Reference are published with each initial version release and at significant update milestones for each release. The contents are current as of the publication dates. Since manpages are often updated in software patches, you can find the latest version of a manpage on an appropriately patched system, using the man command. The list below is in reverse order of the date of publication.
B9106-90007-13 HP-UX 11i Version 1.5; June 2001 Release; seven volumes HTML; http://docs.hp.com and Instant Information. B2355-90689-97 HP-UX 11i Version 1; December 2000 Release; nine volumes PDF and HTML; http://docs.hp.com, Instant Information and print. B2355-90680-84 HP-UX 11.0; October 1997 Release; five volumes HTML; http://docs.hp.com. B2355-90166 HP-UX 11.0; October 1997 Release; five volumes PDF; http://docs.hp.com. B2355-90128-31 HP-UX 10.
Volume Five Table of Contents Section 2
Volume Five Table of Contents Section 2
Table of Contents Volume Five Section 2: System Calls Entry Name(Section): name Description intro(2): intro() .................................................................................................. introduction to system calls __pset_rtctl(2): __pset_rtctl() ..................................................................... real-time processor set control _exit(): terminate process .............................................................................................................
Table of Contents Volume Five Entry Name(Section): name Description FD_CLR(): synchronous I/O multiplexing ...................................................................................... see select(2) FD_ISSET(): synchronous I/O multiplexing .................................................................................. see select(2) FD_SET(): synchronous I/O multiplexing ......................................................................................
Table of Contents Volume Five Entry Name(Section): name Description ............................................................... get real user, effective user, real group, and effective group IDs gtty(): control terminal device (Bell Version 6 compatibility) .......................................................... see stty(2) ioctl(2): ioctl() ........................................................................................................................ control device iscomsec(2): iscomsec() .
Table of Contents Volume Five Entry Name(Section): name Description nice(2): nice() ...................................................................................................... change priority of a process O_LARGEFILE(): non-POSIX standard API interfaces to support large files ............................... see creat64(2) open(2): open() ................................................................................................
Table of Contents Volume Five Entry Name(Section): name Description pstat_getsem(): get semaphore set information .......................................................................... see pstat(2) pstat_getshm(): get shared memory segment information .......................................................... see pstat(2) pstat_getsocket(): get detailed open socket information ...........................................................
Table of Contents Volume Five Entry Name(Section): name Description sem_unlink(2): sem_unlink() .................................................................. unlink a named POSIX semaphore sem_wait(2): sem_wait(), sem_trywait() ............................................................. lock a POSIX semaphore semctl(2): semctl() ........................................................................................... semaphore control operations semget(2): semget() .................................
Table of Contents Volume Five Entry Name(Section): name Description signal(2): signal(), sigset(), sighold(), sigrelse(), sigignore(), sigpause() .............................................................................................................. signal management signal(): 4.2 BSD-compatible process control facilities ............................................................... see killpg(2) sigpause(): signal management .........................................................................
Table of Contents Volume Five Entry Name(Section): name Description umask(2): umask() ............................................................................................ set and get file creation mask umount(2): umount() .................................................................................................... unmount a file system uname(2): uname(), setuname() ....... get information about computer system; set node name (system name) unlink(2): unlink() ..................................
Section 2 System Calls
Section 2 System Calls
intro(2) intro(2) NAME intro - introduction to system calls DESCRIPTION This section describes all of the system calls. All of these calls return a function result. This result indicates the status of the call. Typically, a zero or positive result indicates that the call completed successfully, and -1 indicates an error. The individual descriptions specify the details. An error number is also made available in the external variable errno (see errno(2)). Note that errno is not cleared on successful calls.
__pset_rtctl(2) __pset_rtctl(2) NAME __pset_rtctl() - real-time processor set control SYNOPSIS #include int __pset_rtctl( pset_rt_req_t request , psetid_t pset , int arg , ); _ DESCRIPTION HP-UX Processor Sets allow a subset of processors in the system to be isolated for exclusive use by specified threads and processes. Only the threads bound to a processor set can execute on processors in that processor set (see pset_create (2)).
__pset_rtctl(2) RTE_PSET_GETNEXTPSET __pset_rtctl(2) Return the ID of the next RTE processor set in the system after pset. The arg argument is ignored. Typically, RTE_PSET_GETFIRSTPSET is called to determine the first RTE processor set. RTE_PSET_GETNEXTPSET is then called in a loop (until the call returns -1) to determine the IDs of the remaining RTE processor sets in the system. See pset_ctl(2) for additional processor set query operations.
__pset_rtctl(2) __pset_rtctl(2) with WRITE access to the pset can change the value of this attribute to allow removal of the last processor from an RTE processor set even if the processor set is busy. Refer to pset_setattr (2) for supported values. PSET_ATTR_NONEMPTY _ Indicates the behavior on a request to destroy a non-empty processor set. A non-empty processor set has at least one processor assigned to it. For RTE processor sets, such a request will be rejected by default.
__pset_rtctl(2) __pset_rtctl(2) [ENOSYS] The RTE processor set functionality is not supported by the underlying HP-UX version. [EPERM] The user does not have necessary permissions to perform the requested operation. [EPERM] The specified processor set, pset, is a special, reserved processor set, and cannot be configured as an RTE processor set. SEE ALSO psrset(1M), pset_assign(2), pset_bind(2), pset_ctl(2), pset_destroy(2), pset_getattr(2), pset_setattr(2), sysconf(2), privileges(5).
accept(2) accept(2) NAME accept() - accept a connection on a socket SYNOPSIS #include a AF_CCITT only #include int accept(int s, void *addr, int *addrlen); _XOPEN_SOURCE_EXTENDED only (UNIX 98) int accept(int s, struct sockaddr *addr, socklen_t *addrlen); Obsolescent _XOPEN_SOURCE_EXTENDED only (UNIX 95) int accept(int s, struct sockaddr *addr, size_t *addrlen); DESCRIPTION The accept() system call is used with connection-based socket types, such as SOCK_STREAM .
accept(2) accept(2) If an error occurs, accept() returns -1 and sets errno to indicate the cause. ERRORS If accept() fails, errno is set to one of the following values: [EAGAIN] Nonblocking I/O is enabled using O_NONBLOCK and no connections are present to be accepted. [EBADF] The argument, s, is not a valid file descriptor. [ECONNABORTED] The socket is being shutdown due to a request by software. This is usually caused by a shutdown() system call. [EFAULT] The addr parameter is not a valid pointer.
access(2) access(2) NAME access() - determine accessibility of a file SYNOPSIS #include int access(char *path, int amode); a DESCRIPTION The access() system call checks the file pointed to by path for accessibility according to the bit pattern contained in amode. access() uses the real user ID, not the effective user ID, and the real group ID, not the effective group ID. The value of amode is either the bit-wise inclusive OR of the access permissions to be checked, or the existence test.
access(2) access(2) ERRORS If access() fails, errno is set to one of the following values: [EACCES] Search permission is denied on a component of the path prefix. [EACCES] The access control list does not permit the requested access and the real user ID is not a user with DACREAD or DACWRITE privileges. [EFAULT] path points outside the allocated address space for the process. The reliable detection of this error is implementation dependent.
acct(2) acct(2) NAME acct() - enable or disable process accounting SYNOPSIS #include int acct(const char *path); a DESCRIPTION The acct() system call enables or disables the system’s process accounting routine. If the routine is enabled, an accounting record is written on an accounting file for each process that terminates. Termination can be caused by one of two things: an exit() call or a signal (see exit(2) and signal(5)).
acct(2) acct(2) STANDARDS CONFORMANCE acct() : SVID2, SVID3, XPG2 a HP-UX 11i Version 2: December 2007 Update −2− Hewlett-Packard Company 33
acl(2) acl(2) NAME acl() - set a file’s Access Control List (ACL) information (JFS File Systems only) SYNOPSIS #include #include int acl(char *pathp, int cmd, int nentries, struct acl *aclbufp); a DESCRIPTION The acl() system call is used to manipulate ACLs on JFS file system objects. pathp points to a path name naming a file. nentries specifies how many ACL entries are pointed to by aclbufp. aclbufp is a pointer to the first element of an array of struct
acl(2) acl(2) If pathp points to a directory, there is at most one entry each of type DEF_USER_OBJ , DEF_GROUP_OBJ , DEF_CLASS_OBJ, and DEF_OTHER_OBJ. Entries of type USER , GROUP , DEF_USER , or DEF_GROUP do not contain duplicate entries. A duplicate entry is one of the same type containing the same numeric ID. If the ACL contains no entries of type USER and no entries of type GROUP , then the entries of type GROUP_OBJ and CLASS_OBJ have the same permissions.
adjtime(2) adjtime(2) NAME adjtime() - correct the time to synchronize the system clock SYNOPSIS #include int adjtime( const struct timeval *delta, struct timeval *olddelta ); a DESCRIPTION The function adjtime() adjusts the current time of the system. The time is either advanced or retarded by the amount of time specified in the struct timeval pointed to by delta. The adjustment is made by applying small correctional adjustments to the value of current time that the system keeps.
adjtime(2) adjtime(2) ERRORS adjtime() fails if one or more of the following is true: [EPERM] if the process does not have the appropriate privilege. [EFAULT] The address specified for delta (or olddelta) is invalid. [EINVAL] If delta.tv_sec is greater than 31536000 (approx. 365 days) or less than -31536000. The delta.tv_usec field is not used in calculation of these limits. If the user wants to adjust time greater than these limits, an appropriate alternative interface should be used.
aio_cancel(2) aio_cancel(2) NAME aio_cancel() - cancel an asynchronous I/O operation SYNOPSIS #include int aio_cancel(int fildes, struct aiocb *aiocbp); a DESCRIPTION The aio_cancel() function attempts to cancel the asynchronous I/O request currently outstanding for the aiocb referenced by aiocbp or, if aiocbp is NULL , any asynchronous I/O operations currently outstanding for the file descriptor fildes.
aio_error(2) aio_error(2) NAME aio_error() - return error status of an asynchronous I/O operation SYNOPSIS #include int aio_error(const struct aiocb *aiocbp); a DESCRIPTION The aio_error() function returns the error status of the asynchronous I/O operation that was initiated with the aiocb and referenced by aiocbp . The error status for an asynchronous I/O operation is the errno value set by the corresponding read() , write() , or fsync() function.
aio_fsync(2) aio_fsync(2) NAME aio_fsync() - force outstanding asynchronous operations on a file to the synchronized state SYNOPSIS #include int aio_fsync(int op, struct aiocb *aiocbp); a DESCRIPTION The aio_fsync() function asynchronously forces all I/O operations that are enqueued at the time of the call for the file or device referenced by aiocbp->aio_fildes to the synchronized I/O state.
aio_fsync(2) aio_fsync(2) STANDARDS CONFORMANCE aio_fsync() : POSIX Realtime Extensions, IEEE Std 1003.
aio_read(2) aio_read(2) NAME aio_read() - start an asynchronous read operation SYNOPSIS #include int aio_read(struct aiocb *aiocbp); a DESCRIPTION The aio_read() function allows the calling process to perform an asynchronous read from a previously opened file. The function call returns when the read operation has been enqueued for processing. At this point, processing of the read operation may proceed concurrently with execution of the calling process or thread.
aio_read(2) aio_read(2) Once the read request has been enqueued by aio_read() , the following errors, in addition to all of the errors normally reported by the read() function, may be reported asynchronously by a subsequent call to aio_error() or aio_return() referencing its aiocb . [EBADF] The aiocbp->aio_fildes was not a valid file descriptor open for reading. a [EINVAL] The value of aiocbp->aio_reqprio is not valid. [EINVAL] The value of aiocbp->aio_nbytes is invalid.
aio_reap(2) aio_reap(2) NAME aio_reap() - wait for multiple asynchronous I/O requests SYNOPSIS #include typedef struct aio_completion_data { struct aiocb *aio_aiocb; int aio_return; int aio_error; } aio_completion_t; int aio_reap(aio_completion_t list[], int nent, const struct timespec *timeout, int waitfor, int *completed_count) ; a DESCRIPTION The aio_reap() function is an extension of the aio_suspend() library function.
aio_reap(2) aio_reap(2) The use of aio_reap() in an application should not be mixed with the older aio_return() or aio_error() functions. Mixing of the two methods of IO collection will result in undefined behavior and possible data loss. The timeout parameter must be either NULL or point to a timespec structure that has a timeout time specified. If a NULL pointer is specified, then no timeout handling is performed and aio_reap() blocks until waitfor AIO requests are available.
aio_reap(2) aio_reap(2) Usage Notes To use aio_reap() , link in the realtime library by specifying -lrt on the compiler or linker command line. Then, before making any AIO function calls, initialize the reap mechanism by calling aio_reap() in lightweight mode, as shown in this example: int ignore; (void)aio_reap(NULL, 0, NULL, 0, &ignore); For this single call to initialize aio_reap() , all output (including return value) should be ignored.
aio_return(2) aio_return(2) NAME aio_return() - return status of an asynchronous I/O operation SYNOPSIS #include ssize_t aio_return(struct aiocb *aiocbp); a DESCRIPTION The aio_return() function returns the return status associated with the aiocb structure referenced by the aiocbp argument. The return value for an asynchronous I/O operation is the value that would be set by the corresponding read() , write() , or fsync() operation.
aio_suspend(2) aio_suspend(2) NAME aio_suspend() - wait for an asynchronous I/O operation to complete SYNOPSIS #include
aio_write(2) aio_write(2) NAME aio_write() - start asynchronous write operation SYNOPSIS #include int aio_write(struct aiocb *aiocbp); a DESCRIPTION The aio_write() function allows the calling process to perform an asynchronous write to a previously opened file. The function call returns when the write operation has been enqueued for processing. At this point, processing of the write operation may proceed concurrently with execution of the calling process or thread.
aio_write(2) a aio_write(2) [EBADF] The aiocbp->aio_fildes was not a valid file descriptor open for writing. [EINVAL] The aiocb->aio_sigevent is not a valid address in the process virtual address space. [EINVAL] The parameters of the indicated sigevent in aiocb->aio_sigevent are invalid. [EINVAL] The value of aiocbp->aio_reqprio is not valid. [EINVAL] The value of aiocbp->aio_nbytes is invalid.
alarm(2) alarm(2) NAME alarm() - set a process’s alarm clock SYNOPSIS #include unsigned int alarm(unsigned int sec); a DESCRIPTION alarm() instructs the alarm clock of the calling process to send the signal SIGALRM to the calling process after the number of real-time seconds specified by sec have elapsed; see signal(5). Specific implementations might place limitations on the maximum supported alarm time. The constant MAX_ALARM defined in
audctl(2) audctl(2) NAME audctl() - start or halt the auditing system and set or get audit files SYNOPSIS #include int audctl(int cmd, char *cpath, char *npath, mode_t mode); a DESCRIPTION audctl() sets or gets the auditing system "current" and "next" audit files, and starts or halts the auditing system. This call is restricted to processes with the AUDCONTROL privilege. cpath and npath hold the absolute path names of the "current" and "next" files.
audctl(2) audctl(2) The caller issues the AUD_OFF command to halt the auditing system. If the auditing system is on, it is turned off and the "current" and "next" audit files are closed. cpath, npath, and mode are ignored. If the audit system is already off, -1 is returned and errno is set to [EALREADY]. AUD_OFF Security Restrictions Some or all of the actions associated with this system call require the AUDCONTROL privilege. Processes owned by the superuser have this privilege.
audswitch(2) audswitch(2) NAME audswitch() - suspend or resume auditing on the current process SYNOPSIS #include int audswitch(int aflag); a DESCRIPTION audswitch() suspends or resumes auditing within the current process. This call is restricted to users with the SELFAUDIT privilege. One of the following aflags must be used: AUD_SUSPEND Suspend auditing on the current process. AUD_RESUME Resume auditing on the current process.
audwrite(2) audwrite(2) NAME audwrite() - write an audit record for a self-auditing process SYNOPSIS #include int audwrite(const struct self_audit_rec *audrec_p); a DESCRIPTION audwrite() is called by trusted self-auditing processes, which are capable of turning off the regular auditing (using the audswitch() system call, see audswitch(2),) and doing higher-level auditing on their own. audwrite() is restricted to users with the SELFAUDIT privilege.
bind(2) bind(2) NAME bind() - bind an address to a socket SYNOPSIS #include AF_CCITT only b #include AF_INET, AF_INET6 and AF_VME_LINK only #include AF_UNIX only #include
bind(2) bind(2) [EBADF] s is not a valid file descriptor. [EDESTADDRREQ] No addr parameter was specified. [EFAULT] addr is not a valid pointer. [EINVAL] The socket is already bound to an address, the socket has been shut down, addrlen is a bad value, or an attempt was made to bind() an AF_UNIX socket to an NFS-mounted (remote) name. AF_CCITT: The protocol-ID length is negative or greater than 8, the X.121 address string contains an illegal character, or the X.
brk(2) brk(2) NAME brk(), sbrk() - change data segment space allocation SYNOPSIS #include int brk(const void *endds); void *sbrk(int incr); b DESCRIPTION brk() and sbrk() are used to change dynamically the amount of space allocated for the calling process’s data segment; see exec(2). The change is made by resetting the process’s break value and allocating the appropriate amount of space. The break value is the address of the first location beyond the end of the data segment.
chdir(2) chdir(2) NAME chdir(), fchdir() - change working directory SYNOPSIS #include int chdir(const char *path); int fchdir(int fildes); DESCRIPTION chdir() and fchdir() cause a directory pointed to by path or fildes to become the current working directory, the starting point for path searches of path names not beginning with /. path points to the path name of a directory. fildes is an open file descriptor of a directory.
chmod(2) chmod(2) NAME chmod(), fchmod() - change file mode access permissions SYNOPSIS #include int chmod(const char *path, mode_t mode); int fchmod(int fildes, mode_t mode); c DESCRIPTION The chmod() and fchmod() system calls set the access permission portion of the file’s mode according to the bit pattern contained in mode. path points to a path name naming a file. fildes is a file descriptor.
chmod(2) chmod(2) If the effective user ID of the process is not that of a user with the OBJSUID privilege, mode bit S_ISVTX is cleared. If the effective user ID of the process is not that of a user with the OBJSUID privilege, and the effective group ID of the process does not match the group ID of the file, and none of the group IDs in the supplementary groups list match the group ID of the file, mode bit S_ISGID is cleared.
chown(2) chown(2) NAME chown(), fchown(), lchown() - change owner and group of a file SYNOPSIS #include int chown(const char *path, uid_t owner, gid_t group); int lchown(const char *path, uid_t owner, gid_t group); int fchown(int fildes, uid_t owner, gid_t group); c DESCRIPTION The chown() system call changes the user and group ownership of a file. path points to the path name of a file.
chown(2) chown(2) ERRORS If chown() or lchown() fails, errno is set to one of the following values: [EACCES] Search permission is denied on a component of the path prefix. [EFAULT] path points outside the allocated address space of the process. The reliable detection of this error is implementation dependent. [ELOOP] Too many symbolic links were encountered in translating path.
chroot(2) chroot(2) (TO BE OBSOLETED) NAME chroot() - change root directory SYNOPSIS #include int chroot(const char *path); DESCRIPTION chroot() causes the named directory to become the root directory, the starting point for path searches for path names beginning with /. path points to a path name naming a directory. The user’s working directory is unaffected by the chroot() system call. The .. entry in the root directory is interpreted to mean the root directory itself. Thus, ..
clocks(2) clocks(2) NAME clocks: clock_settime(), clock_gettime(), clock_getres() - clock operations SYNOPSIS #include int clock_settime( clockid_t clock_id, const struct timespec *tp ); int clock_gettime( clockid_t clock_id, struct timespec *tp ); int clock_getres( clockid_t clock_id, struct timespec *res ); c DESCRIPTION clock_settime() The clock_settime() function sets the specified clock, clock_id , to the value specified by tp .
clocks(2) clocks(2) RETURN VALUE A return of 0 indicates that the call succeeded. A return value of -1 indicates that an error occurred, and errno is set to indicate the error. ERRORS If any of the following conditions occur, the clock_settime(), clock_gettime(), and clock_getres() functions return -1 and set errno (see errno(2)) to the corresponding value: c [ENOSYS] The functions clock_settime(), clock_gettime(), and clock_getres() are not supported by this implementation.
close(2) close(2) NAME close() - close a file descriptor SYNOPSIS #include int close(int fildes); DESCRIPTION close() closes the file descriptor indicated by fildes. fildes is a file descriptor obtained from a creat() , open() , dup() , fcntl() , or pipe() system call. All associated file segments which have been locked by this process with the lockf() function are released (i.e., unlocked).
connect(2) connect(2) NAME connect() - initiate connection on a socket SYNOPSIS #include AF_CCITT only #include c AF_INET, AF_INET6 and AF_VME_LINK only #include AF_UNIX only #include
connect(2) connect(2) AF_CCITT Only Use the x25addrstr struct for the address structure. The caller must know the X.121 address of the DTE to which the connection is to be established, including any subaddresses or protocol IDs that may be needed. If address-matching by protocol ID, specify the protocol ID with the X25_WR_USER_DATA ioctl() call before issuing the connect() call. DEPENDENCIES AF_CCITT The SO_REUSEADDR option to setsockopt() is not supported for sockets in the AF_CCITT address family.
connect(2) [ENETUNREACH] connect(2) The network is not reachable from this host. For AF_CCITT only: X.25 Level 2 is down. The X.25 link is not working: wires might be broken, connections are loose on the interface hoods at the modem, the modem failed, or noise interfered with the line for an extremely long period of time. [ENOBUFS] c No buffer space is available. The connect() has failed. [ENOMEM] No memory is available. The connect() has failed.
crashconf(2) crashconf(2) NAME crashconf() - configure system crash dumps SYNOPSIS #include int crashconf( int operation, int includeClasses, int excludeClasses, int deviceCount, char **devices, int *deviceReturn ); c DESCRIPTION crashconf() changes the current system crash dump configuration. The crash dump configuration consists of: • The crash dump device list. This list identifies all devices that can be used to store a crash dump.
crashconf(2) crashconf(2) includeClasses is a bitmask of classes that must be dumped. If it is set to DT_ALL , all dumps will be full dumps. Other allowed values are described under Classes, below. excludeClasses is a bitmask of classes that may not be dumped unless a full dump is required (due to the cause of the dump, or by explicit operator request). If it is set to DT_ALL , dumps will be disabled. Other allowed values are described under Classes, below.
crashconf(2) crashconf(2) Example 3: Disable Dumps crashconf(DC_EXCLUDE | DC_REPLACE, 0, DT_ALL, 0, NULL, NULL); Example 4: Using CCERR_STRINGS and CCWARN_STRINGS Assume only one device, devices[0], is being added to the dump configuration. The following code will check the device_return[0] value and print corresponding error or warning messages.
creat(2) creat(2) NAME creat() - create a new file or rewrite an existing one SYNOPSIS #include int creat(const char *path, mode_t mode); c DESCRIPTION The creat() system call creates a new regular file or prepares to rewrite an existing file named by the path name pointed to by path. If the file exists, its length is truncated to 0, and its mode and owner are unchanged. Otherwise, the file’s owner ID is set to the effective user ID of the process.
creat(2) [EMFILE] creat(2) More than the maximum number of file descriptors are currently open. [ENAMETOOLONG] The length of the specified path name exceeds PATH_MAX bytes, or the length of a component of the path name exceeds NAME_MAX bytes while _POSIX_NO_TRUNC is in effect. [ENFILE] The system file table is full. [ENOENT] The named file does not exist (for example, path is null, or a component of path does not exist). [ENOSPC] Not enough space on the file system.
creat64(2) creat64(2) NAME creat64(), fstat64(), fstatvfs64(), getrlimit64(), lockf64(), lseek64(), lstat64(), mmap64(), open64(), pread64(), prealloc64(), pwrite64(), setrlimit64(), stat64(), statvfs64(), truncate64(), ftruncate64(), O_LARGEFILE non-POSIX standard API interfaces to support large files SYNOPSIS #include int creat64(const char *path, mode_t mode); #include int fstat64(int fildes, struct stat64 *buf); #include
creat64(2) creat64(2) creat64() The creat64() function returns a file descriptor which can be used to grow the file past 2 GB if desired. All other functional behaviors, returns, and errors are identical to creat() . fstat64() The fstat64() function is identical to fstat() except that fstat64() returns file status in a struct stat64 instead of a struct stat . All other functional behaviors, returns, and errors are identical.
creat64(2) creat64(2) _FILE_OFFSET_BITS is set to 64. The bit may be queried by fcntl() (or fcntl64() ), which can also turn the bit on or off if desired. APPLICATION USAGE The standard POSIX interfaces may be used by 32-bit applications to create and access large files if compiled with _FILE_OFFSET_BITS set to 64. The interfaces described here are alternatives to the standard ones, and are enabled by defining _LARGEFILE64_SOURCE.
dup(2) dup(2) NAME dup() - duplicate an open file descriptor SYNOPSIS #include int dup(int fildes); DESCRIPTION fildes is a file descriptor obtained from a creat() , open() , dup() , fcntl() , or pipe() system call. dup() returns a new file descriptor having the following in common with the original: • Same open file (or pipe). • Same file pointer (i.e., both file descriptors share one file pointer). • Same access mode (read, write or read/write).
dup2(2) dup2(2) NAME dup2() - duplicate an open file descriptor to a specific slot SYNOPSIS #include int dup2(int fildes, int fildes2); DESCRIPTION fildes is a file descriptor obtained from a creat() , open() , dup() , fcntl() , or pipe() system call. fildes2 is a non-negative integer less than the maximum value allowed for file descriptors. d dup2() causes fildes2 to refer to the same file as fildes. If fildes2 refers to an already open file, the open file is closed first.
errno(2) errno(2) NAME errno() - error indicator for function calls SYNOPSIS #include DESCRIPTION Many functions in the HP-UX operating system indicate an error condition by returning an otherwise outof-range value (usually -1). Most of these functions set the symbol errno , that is defined in errno.h , to a nonzero code value that more specifically identifies the particular error condition that was encountered.
errno(2) errno(2) [ECONNREFUSED] Connection refused. No connection could be made because the target machine actively refused it. This usually results from trying to connect to a service that is inactive on the foreign host. [ECONNRESET] Connection reset by peer. A connection was forcibly closed by a peer. This normally results from the peer executing a shutdown() call (see shutdown(2)). [EDEADLK] Resource deadlock would occur.
errno(2) errno(2) [EMLINK] Too many links. An attempt to make more than the maximum number of links to a file. [EMSGSIZE] Message too long. The socket requires that the message be sent atomically, and the size of the message to be sent made this impossible. [ENAMETOOLONG] File name too long. A path specified exceeds the maximum path length for the system. The maximum path length is specified by PATH_MAX and is defined in . PATH_MAX is guaranteed to be at least 1023 bytes.
errno(2) errno(2) while SEM_UNDO flag is set. [ENOSYM] Symbol does not exist in executable. The dynamic loader was unable to resolve a symbolic reference in a shared library during a call to one of the dynamic loader interface routines (see shl_load(3X). The program may be in an inconsistent state and should be terminated immediately. [ENOSYS] Function is not available. The requested function or operation is not implemented or not configured in the system. [ENOTBLK] Block device required.
errno(2) errno(2) [ESPIPE] Illegal seek. An lseek() was issued to a pipe. [ESRCH] No such process. No process can be found corresponding to that specified by pid in kill() , rtprio() , or ptrace() , or the process is not accessible. [ETIMEDOUT] Connection timed out. A connect() request failed because the connected party did not properly respond after a period of time (timeout period varies, depending on the communication protocol). [ETXTBSY] Text file busy.
exec(2) exec(2) NAME execl(), execle(), execlp(), execv(), execve(), execvp() - execute a file SYNOPSIS #include extern char **environ; int execl(const char *path, const char *arg0, ... /* * [const char *arg1, ... , const char *argn, ] */ (char *)0 ); int execle(const char *path, const char *arg0, ... /* * [const char *arg1, ... , const char *argn, ] */ (char *)0, char * const envp[] ); int execlp(const char *file, const char *arg0, ... /* * [const char *arg1, ...
exec(2) exec(2) file (in execlp() or execvp() ) points to a file name identifying the executable file containing the new program. The path prefix for this file is obtained by searching the directories passed in the environment variable PATH (see environ(5)). The environment is supplied by the shell (see sh(1)). If file does not have an executable magic number (see magic(4)), it is passed to the POSIX shell as a shell script. arg0, ..., argn are one or more pointers to null-terminated character strings.
exec(2) exec(2) • • • • • • • • • • process start time real-time priority (see rtprio(2)) root directory (see chroot(2)) semadj values (see semop(2)) session membership signal mask (see sigvector (2)) supplementary group IDs time left until an alarm clock signal (see alarm(2)) trace flag (see the PT_SETTRC request of ptrace(2)) tms_utime , tms_stime , tms_cutime , and tms_cstime (see times(2)) For a script file, the initial line of a script file must begin with #! as the first two bytes, followed by zer
exec(2) exec(2) [EINTR] A signal was caught during the exec*() system call. [EINVAL] The executable file is incompatible with the architecture on which the exec*() has been performed, and is presumed to be for a different architecture. It is not guaranteed that every architecture’s executable files will be recognized. [EINVAL] argv points to NULL and null pointer dereferencing is allowed. In this case, NULL is a valid address, but is considered an invalid argument.
exit(2) exit(2) NAME exit(), _exit() - terminate process SYNOPSIS #include void exit(int status); #include void _exit(int status); e DESCRIPTION exit() terminates the calling process and passes status to the system for inspection, see wait(2). Returning from main in a C program has the same effect as exit() ; the status value is the function value returned by main (this value is undefined if main does not take care to return a value or to call exit() explicitly).
exit(2) • exit(2) If the current process has any child processes that are being traced, they are sent a SIGKILL signal. AUTHOR exit() was developed by HP, AT&T, and the University of California, Berkeley. SEE ALSO acct(2), plock(2), pthread_cancel(3T), pthread_exit(3T), pthread_key_create(3T), semop(2), shmop(2), times(2), vfork(2), wait(2), signal(5), sh(1), see exit conditions ($? ). STANDARDS CONFORMANCE exit() : AES, SVID2, SVID3, XPG2, XPG3, XPG4, FIPS 151-2, POSIX.
fcntl(2) fcntl(2) NAME fcntl() - file control SYNOPSIS #include int fcntl(int fildes, int cmd, ... /* arg */); Remarks The ANSI C ", ... " construct denotes a variable length argument list whose optional [or required] members are given in the associated comment (/* */ ). DESCRIPTION fcntl() provides for control over open files. fildes is an open file descriptor.
fcntl(2) fcntl(2) values, other than -1, indicate a process group ID. F_GETLK64 Same as F_GETLK , except arg is a pointer to struct struct flock . flock64 instead of F_SETLK64 Same as F_SETLK , except arg is a pointer to struct struct flock . flock64 instead of F_SETLKW64 Same as F_SETLKW , except arg is a pointer to struct flock64 instead of struct flock . A read lock prevents any other process from write-locking the protected area.
fcntl(2) f fcntl(2) F_SETFD F_GETFL F_SETFL F_GETLK F_SETLK F_SETLKW F_GETOWN Value other than −1. F_SETOWN F_GETLK64 F_SETLK64 F_SETLKW64 Value other than −1. Value of file status flags and access modes. Value other than −1. Value other than −1. Value other than −1. Value other than −1. Value of process or process group ID specified to receive SIGURG signals when outof-band data is available. Value other than −1. Value other than −1. Value other than −1.
fcntl(2) [EFAULT] fcntl(2) cmd is either F_GETLK , F_SETLK , or F_SETLKW , and arg points to an illegal address. [ENOTSOCK] cmd is F_GETOWN or F_SETOWN , and fildes does not refer to a socket. AUTHOR fcntl() was developed by HP, AT&T and the University of California, Berkeley. SEE ALSO lockd(1M), statd(1M), chmod(2), close(2), creat64(2), exec(2), lockf(2), open(2), read(2), write(2), fcntl(5). STANDARDS CONFORMANCE fcntl() : AES, SVID2, SVID3, XPG2, XPG3, XPG4, FIPS 151-2, POSIX.
flock(2) flock(2) NAME flock() - apply or remove an advisory or enforced lock on an open file SYNOPSIS #include int flock(int filedes , int operation ); Parameters filedes Specifies a file descriptor returned by a successful open() , creat() , dup() , dup2 , or fcntl() function, identifying the file on which the locking operation is to be performed. operation Specifies one of the following constants for flock() , defined in the
flock(2) flock(2) locks associated with the crashed server. If a lock cannot be reclaimed, the process that held the lock is issued a SIGLOST signal. See lockd(1M). File locking as implemented for NFS files is only advisory. RETURN VALUES flock() returns: 0 for successful completion -1 for unsuccessful completion; errno is set to indicate the error ERRORS If the flock() function fails, errno may be set to one of the following values: [EWOULDBLOCK] The file is locked and the LOCK_NB option was specified.
fork(2) fork(2) NAME fork() - create a new process SYNOPSIS #include pid_t fork(void); DESCRIPTION The fork() system call causes the creation of a new process. The new child process is created wth exactly one thread or lightweight process. The new child process contains a replica of the calling thread (if the calling process is multi-threaded) and its entire address space, possibly including the state of mutexes and other resources.
fork(2) fork(2) Fine-grained privileges are inherited through a calculation to determine which, if any, of the parent process’ privileges are inherited by the child. The vfork() system call can be used to fork processes more quickly than fork() , but has some restrictions. See vfork(2) for details. If a parent and child process both have a file opened and the parent or child closes the file, the file is still open for the other process.
fsctl(2) fsctl(2) NAME fsctl() - file system control SYNOPSIS #include int fsctl( int fildes, int command, void *outbuf, size_t outlen ); f DESCRIPTION fsctl() provides access to file-system-specific information. fildes is an open file descriptor for a file in the file system of interest. The possible values for command depend on the type of file system. Currently, defined commands exist only for the CDFS file system (see sys/cdfsdir.h).
fsctl(2) fsctl(2) with a NULL character. The maximum size of the volume set ID is 128 bytes, so a length of 129 can be used for outlen and the size of outbuf. EXAMPLES The following code fragment gets the extended attribute record for a file on a CDFS volume. The filename is passed in as the first argument to the routine. Note that error checking is omitted for brevity. #include #include #include #include
fstat(2) fstat(2) NAME fstat() - get file status SYNOPSIS #include #include int fstat(int fildes, struct stat *buf); DESCRIPTION The fstat() function obtains information about an open file associated with the file descriptor fildes, and writes it to the area pointed to by buf. fildes is a file descriptor for an open file, which is created with the successful completion of an open() , creat() , dup() , fcntl() , or pipe() system call.
fstat(2) fstat(2) st_mode The value returned in this field is the bit-wise inclusive OR of a value indicating the file’s type, attribute bits, and a value summarizing its access permission. See mknod(2). For ordinary users, the least significant nine bits consist of the file’s permission bits modified to reflect the access granted or denied to the caller by optional entries in the file’s access control list.
fstat(2) fstat(2) DEPENDENCIES CD-ROM The st_uid and st_gid fields are set to -1 if they are not specified on the disk for a given file. AUTHOR stat() and fstat() were developed by AT&T. lstat() was developed by the University of California, Berkeley. SEE ALSO touch(1), acl(2), chmod(2), chown(2), creat(2), fstat64(2), link(2), lstat(2), mknod(2), pipe(2), read(2), rename(2), setacl(2), sysfs(2), time(2), truncate(2), unlink(2), utime(2), write(2), acl(5), aclv(5), stat(5), , .
fsync(2) fsync(2) NAME fsync(), fdatasync() - synchronize a file’s in-core and on-disk states SYNOPSIS #include int fsync(int fildes); int fdatasync(int fildes); DESCRIPTION fsync() and fdatasync() cause all modified data and attributes of fildes to be moved to a permanent storage device. This normally results in all in-core modified copies of buffers for the associated file to be written to a disk.
ftime(2) ftime(2) NAME ftime() - get date and time more precisely SYNOPSIS #include int ftime(struct timeb *tp); Remarks This facility is provided for backwards compatibility with Version 7 systems. Either time() or gettimeofday() should be used in new programs. DESCRIPTION ftime() fills in a structure pointed to by its argument, as defined by
getaccess(2) getaccess(2) NAME getaccess() - get a user’s effective access rights to a file SYNOPSIS #include int getaccess( const char *path, uid_t uid, int ngroups, const gid_t *gidset, void *label, void *privs ); DESCRIPTION getaccess() identifies the access rights (read, write, execute/search) a specific user ID has to an existing file. path points to a path name of a file.
getaccess(2) getaccess(2) access() Checks all ACL entries (HFS and JFS File Systems only) Uses real uid, real gid, and supplementary groups list Checks specific mode value, returns succeed or fail Checks path to file using caller’s effective IDs W_OK false if shared-text file currently being executed W_OK false if file on read-only file system X_OK not modified for file currently open for writing R_OK and W_OK always true for superuser (except as described in Security Restrictions) or users with DAC_READ
getaccess(2) getaccess(2) [ENOENT] The named file does not exist (for example, path is null or a component of path does not exist). [ENOTDIR] A component of the path prefix is not a directory. [EOPNOTSUPP] getaccess () is not supported on some types of remote files. EXAMPLES The following call determines the caller’s effective access rights to file test and succeeds if the user has read access: #include #include
getacl(2) getacl(2) NAME getacl(), fgetacl() - get access control list (ACL) information (HFS File Systems only) SYNOPSIS #include int getacl( const char *path, int nentries, struct acl_entry *acl ); int fgetacl(int fildes, int nentries, struct acl_entry *acl); DESCRIPTION getacl() returns a complete listing of all ACL entries (uid.gid, mode) in an existing file’s access control list. path points to a path name of a file.
getacl(2) getacl(2) [ENOSYS] The function is not supported by this file system type. [ENFILE] The system file table is full. EXAMPLES The following call returns the number of entries in the ACL on file /users/bill/mcfile. #include entries = getacl ("/users/bill/mcfile", 0, (struct acl_entry ∗) 0); The following call returns in acl all entries in the ACL on the file opened with file descriptor 5. #include
getaudid(2) getaudid(2) NAME getaudid() - get the audit ID (aid) for the current process SYNOPSIS #include int getaudid(void); DESCRIPTION getaudid() returns the audit ID (aid) for the current process. This call is restricted to users with the SELFAUDIT privilege. Security Restrictions Some or all of the actions associated with this system call require the SELFAUDIT privilege. Processes owned by the superuser have this privilege.
getaudproc(2) getaudproc(2) NAME getaudproc() - get the audit process flag for the calling process SYNOPSIS #include int getaudproc(void); DESCRIPTION getaudproc() returns the audit process flag for the calling process. The audit process flag (u_audproc) determines whether the process run by a given user should be audited. The process is audited if the returned flag is 1. If the returned flag is 0, the process is not audited. This call is restricted to users with the SELFAUDIT privilege.
getcontext(2) getcontext(2) NAME getcontext(), setcontext() - get and set current user context SYNOPSIS #include int getcontext(ucontext_t *ucp); int setcontext(const ucontext_t *ucp); DESCRIPTION The getcontext() function initializes the structure pointed to by ucp to the current user context of the calling process.
getdirentries(2) getdirentries(2) (TO BE OBSOLETED) NAME getdirentries() - get entries from a directory in a file-system-independent format SYNOPSIS #include For versions prior to 10.30 #include For 10.30 and later versions int getdirentries( int fildes, struct direct *buf, size_t nbytes, off_t *basep ); DESCRIPTION The getdirentries() system call and the header file have been obsoleted starting from HP-UX 10.30 by the functions described in directory(3C).
getdirentries(2) getdirentries(2) (TO BE OBSOLETED) [EIO] An I/O error occurred while reading from or writing to the file system. WARNINGS Obsolescent Interfaces getdirentries() is to be obsoleted at a future date. Note: The getdirentries() call can encounter truncated d_ino values when it is used with a 64-bit filesystem. AUTHOR getdirentries() was developed by Sun Microsystems, Inc. SEE ALSO lseek(2), open(2), directory(3C).
getdomainname(2) getdomainname(2) NAME getdomainname(), setdomainname() - get/set name of current Network Information Service domain SYNOPSIS int getdomainname(char *name, int namelen); int setdomainname(char *name, int namelen); DESCRIPTION getdomainname() returns the name of the Network Information Service (NIS) domain for the current processor, as previously set by setdomainname(). The parameter namelen specifies the size of the name array.
getdtablesize(2) getdtablesize(2) NAME getdtablesize() - get the size of the per-process file descriptor table SYNOPSIS #include int getdtablesize(void); DESCRIPTION The getdtablesize() function returns the maximum number of file descriptors that can currently be stored in a process’ file descriptor table. This maximum number is also known as the soft limit for open files, and can be adjusted up to the hard limit by calling setrlimit() .
getevent(2) getevent(2) NAME getevent() - get events and system calls that are currently being audited SYNOPSIS #include int getevent( struct aud_type *a_syscall, struct aud_event_tbl *a_event ); DESCRIPTION getevent() gets the events and system calls being audited. The events are returned in a table pointed to by a_event. The system calls are returned in a table pointed to by a_syscall. This call is restricted to users with the AUDCONTROL privilege.
getfh(2) getfh(2) NAME getfh() - return file handle for file on remote node SYNOPSIS #include #include #include #include int getfh(char *path, fhandle_t *fhp); DESCRIPTION The getfh() system call returns a file handle in the struct pointed to by fhp for the file pointed to by path. This information is used to perform an NFS mount for a remote node. getfh() is executed on the remote node; results are passed back to the program doing the NFS mount.
getgroups(2) getgroups(2) NAME getgroups() - get group access list SYNOPSIS #include int getgroups(int ngroups, gid_t gidset[ ]); DESCRIPTION getgroups() gets the current group access list of the user process and stores it in the array gidset. The parameter ngroups indicates the number of entries which may be placed in gidset. No more than NGROUPS_MAX , as defined in , is ever returned.
gethostid(2) gethostid(2) (TO BE OBSOLETED) NAME gethostid() - get an identifier for the current host SYNOPSIS #include long gethostid(void); DESCRIPTION The gethostid() function retrieves a 32-bit identifier for the current host. RETURN VALUE Upon successful completion, gethostid() returns an identifier for the current host. ERRORS No errors are defined. g APPLICATION USAGE X/Open does not define the domain in which the return value is unique.
gethostname(2) gethostname(2) NAME gethostname() - get name of current host system SYNOPSIS #include int gethostname(char *hostname, size_t size); DESCRIPTION gethostname() returns in the array to which hostname points, the standard host name for the current system as set by sethostname() (see sethostname(2)). size specifies the length of the hostname array. hostname is null-terminated unless insufficient space is provided. RETURN VALUE gethostname() returns 0 if successful.
getitimer(2) getitimer(2) NAME getitimer(), setitimer() - get and set value of interval timer SYNOPSIS #include int getitimer(int which, struct itimerval *value); int setitimer( int which, const struct itimerval *value, struct itimerval *ovalue ); g DESCRIPTION The getitimer() function stores the current value of the timer specified by which into the structure pointed to by value.
getitimer(2) timerisset timercmp getitimer(2) Test if a time value is non-zero. Compare two time values. (Beware that >= and <= do not work with the timercmp macro.) The timer used with ITIMER_REAL is also used by alarm() (see alarm(2)). Thus successive calls to alarm() , getitimer() , and setitimer() set and return the state of a single timer. In addition, a call to alarm() sets the timer interval to zero. The interaction between setitimer() and any of alarm() , sleep() or usleep() is unspecified.
getksym(2) getksym(2) NAME getksym() - get information for a global kernel symbol SYNOPSIS #include #include #include #include /* For STT_PARISC_MILLI on PA-RISC */ int getksym( char *symname , char *modname , uint64_t *value , uint64_t *info ); Remarks getksym() is currently implemented as a macro. g DESCRIPTION There are two ways that getksym() can be used to retrieve kernel symbol information.
getksym(2) getksym(2) EXAMPLES The following code sequence and call to getksym() obtains a symbol name (and an offset) given an address. #include #include #include uint64_t value=0x12345678, info=0; char symname[MAXSYMNMLEN]; /* name will be placed in symname, and offset in info */ if (getksym(symname, NULL, &value, &info) != 0) { perror("getksym"); return(-1); } The following code sequence and call to getksym() obtains an address given a symbol name.
getmsg(2) getmsg(2) NAME getmsg(), getpmsg() - receive next message from a STREAMS file SYNOPSIS #include int getmsg( int fildes, struct strbuf *ctlptr, struct strbuf *dataptr, int *flagsp ); int getpmsg( int fildes, struct strbuf *ctlptr, struct strbuf *dataptr, int *band, int *flagsp ); g DESCRIPTION The getmsg() function retrieves the contents of a message located at the head of the stream head read queue associated with a STREAMS file and places the contents into one or more buffers.
getmsg(2) getmsg(2) the priority band of interest. In this case, getpmsg() will only process the next message if it is in a priority band equal to, or greater than, the integer pointed to by bandp, or if it is a high-priority message. If a process just wants to get the first message off the queue, the integer pointed to by bandp should be set to 0.
getpagesize(2) getpagesize(2) NAME getpagesize() - get the current page size SYNOPSIS #include int getpagesize(void); DESCRIPTION The getpagesize() function returns the current page size. getpagesize() The function sysconf(_SC_PAGESIZE). is equivalent to sysconf(_SC_PAGE_SIZE) and RETURN VALUE The getpagesize() function returns the current page size. g ERRORS No errors are defined.
getpeername(2) getpeername(2) NAME getpeername() - get address of connected peer SYNOPSIS #include AF_CCITT only: #include
getpeername(2) getpeername(2) AUTHOR getpeername() was developed by HP and the University of California, Berkeley. SEE ALSO bind(2), socket(2), getsockname(2), thread_safety(5), inet(7F), xopen_networking(7).
getpid(2) getpid(2) NAME getpid(), getpgid(), getpgrp(), getpgrp2(), getppid() - get process, process group and parent process ID SYNOPSIS #include pid_t getpgid (pid_t pid); pid_t getpgrp(void); pid_t getpgrp2(pid_t pid); pid_t getpid(void); pid_t getppid(void); DESCRIPTION These functions return process, process group and parent process IDs, as follows: getpgid() Process group ID of the specified process. If pid is zero, the call applies to the calling process. Same result as getpgrp2() .
getpriority(2) getpriority(2) NAME getpriority(), setpriority() - get or set process priority SYNOPSIS #include int getpriority(int which, int who); int setpriority(int which, int who, int priority); DESCRIPTION getpriority() returns the priority of the indicated processes. setpriority() sets the priority of the indicated processes to priority.
getpriority(2) getpriority(2) ERRORS If getpriority() or setpriority() fails, errno is set to one of the following values: [EACCES] The calling process does not have access rights to change one or more of the indicated processes. All processes for which access is allowed are still affected. [EINVAL] which is not one of the choices listed above, or who is out of range.
getprivgrp(2) getprivgrp(2) NAME getprivgrp(), setprivgrp() - get and set special attributes for group SYNOPSIS #include int getprivgrp(struct privgrp_map *grplist); int setprivgrp(gid_t grpid, const int *mask); g DESCRIPTION getprivgrp() The getprivgrp() system call returns a table of the privileged group assignments into a user-supplied structure. grplist points to an array of structures of type privgrp_map , associating a group ID with a privilege mask.
getprivgrp(2) getprivgrp(2) [E2BIG] The request would require assigning privileges to more than PRIV_MAXGRPS groups. [EFAULT] mask points to an illegal address. The reliable detection of this error is implementation dependent. [EINVAL] mask has bits set for one or more unknown privileges. [EINVAL] grpid is out of range. [EPERM] The caller is not a privileged user.
getrlimit(2) getrlimit(2) NAME getrlimit(), setrlimit() - control maximum resource consumption SYNOPSIS #include int getrlimit(int resource, struct rlimit *rlp); int setrlimit(int resource, const struct rlimit *rlp); DESCRIPTION Limits on the consumption of a variety of resources by the calling process may be obtained with getrlimit() and set with setrlimit() . Each call to either getrlimit() or setrlimit() identifies a specific resource to be operated upon as well as a resource limit.
getrlimit(2) getrlimit(2) RLIMIT_NOFILE This is a number one greater than the maximum value that the system may assign to a newly-created descriptor. If this limit is exceeded, functions that allocate new file descriptors may fail with errno set to [EMFILE]. This limit constrains the number of file descriptors that a process may allocate. RLIMIT_STACK This is the maximum size of a process stack in bytes. The implementation will not automatically grow the stack beyond this limit.
getrlimit(2) getrlimit(2) returned by ulimit with UL_GETFSIZE may thus have to be rounded down to a multiple of 512. The total address space used by a process depends on the platform it is run on. When porting applications, limits set by setrlimit() with RLIMIT_AS may need to be adjusted. For example, programs tend to use more memory on Itanium-based systems than on PA-RISC systems. AUTHOR getrlimit() and setrlimit() were developed by HP, AT&T, and the University of California, Berkeley.
getrusage(2) getrusage(2) NAME getrusage() - get information about resource utilization SYNOPSIS #include int getrusage(int who, struct rusage *r_usage); DESCRIPTION The getrusage() function provides measures of the resources used by the current process or its terminated and waited-for child processes. If the value of the who argument is RUSAGE_SELF , information is returned about resources used by the current process.
getsid(2) getsid(2) NAME getsid() - get session ID SYNOPSIS #include pid_t getsid (pid_t pid); DESCRIPTION The getsid() function returns the session ID of the specified process. If pid is 0, the call applies to the current process. For this to be allowed, the current process and the referenced process must be in the same session. Security Restrictions The actions associated with this system call are subject to compartmental restrictions.
getsockname(2) getsockname(2) NAME getsockname() - get socket address SYNOPSIS #include AF_CCITT only #include
getsockname(2) getsockname(2) AUTHOR getsockname() was developed by HP and the University of California, Berkeley. SEE ALSO bind(2), socket(2), getpeername(2), thread_safety(5), inet(7F), xopen_networking(7).
getsockopt(2) getsockopt(2) NAME getsockopt(), setsockopt() - get and set options on sockets SYNOPSIS #include
getsockopt(2) getsockopt(2) The parameters optval and optlen specify the value of the option. optval is the address of the data structure that contains the option value, and optlen is the length of the data structure. The type and value of the data structure that optval points to depends on the option. For "boolean" options, the value may be zero (not set) or non-zero (set). The value of other options depends on the purpose of the option.
getsockopt(2) getsockopt(2) (default buffer size: 2147483647 bytes; maximum buffer size: 2147483647 bytes; udp maximum receive buffer size can be lowered using the ndd parameter udp_recv_hiwater_max). SO_REUSEADDR (int ; boolean; AF_INET sockets only) If enabled, allows a local address to be reused in subsequent calls to bind() . Default : disallowed. SO_REUSEPORT (int ; boolean; AF_INET sockets only) If enabled, allows a local address and port to be reused in subsequent calls to bind() .
getsockopt(2) getsockopt(2) Setting the SO_REUSEADDR option allows the local socket address to be reused in subsequent calls to bind() . This permits multiple SOCK_STREAM sockets to be bound to the same local address, as long as all existing sockets with the desired local address are in a connected state before bind() is called for a new socket. For SOCK_DGRAM sockets, SO_REUSEADDR allows multiple sockets to receive UDP multicast datagrams addressed to the bound port number.
getsockopt(2) getsockopt(2) should follow the X/Open specification (see xopen_networking(7)). FUTURE DIRECTION Currently, the default behavior is the HP-UX BSD Sockets; however, it might be changed to X/Open Sockets in a future release. At that time, any HP-UX BSD Sockets behavior that is incompatible with X/Open Sockets might be obsoleted. Applications that conform to the X/Open specification now will avoid migration problems (see xopen_networking(7)).
gettimeofday(2) gettimeofday(2) NAME gettimeofday() - get the date and time SYNOPSIS #include int gettimeofday(struct timeval *tp, void *tzp); DESCRIPTION The gettimeofday() function obtains the current time, expressed as seconds and microseconds since Epoch, and stores it in the timeval structure pointed to by tp. The resolution of the system clock is one microsecond. PARAMETERS Programs should use this time zone information only in the absence of the TZ environment variable.
gettimeofday(2) gettimeofday(2) WARNINGS Relying on a granularity of one microsecond may result in code that is not portable to other platforms. AUTHOR gettimeofday() was developed by the University of California, Berkeley, and HP. SEE ALSO date(1), ftime(2), settimeofda(2), stime(2), time(2), ctime(3C).
gettune(2) gettune(2) NAME gettune() - get the value of a kernel tunable parameter SYNOPSIS #include int gettune( const char *tunable, uint64_t *value ); DESCRIPTION This function retrieves the current value of the kernel tunable parameter named tunable. The value is passed back through the supplied value pointer. The value returned is the value for the tunable that is being used by the currently running kernel.
getuid(2) getuid(2) NAME getuid(), geteuid(), getgid(), getegid() - get real user, effective user, real group, and effective group IDs SYNOPSIS #include uid_t getuid(void); uid_t geteuid(void); gid_t getgid(void); gid_t getegid(void); DESCRIPTION The following functions return the information indicated: getuid() geteuid() getgid() getegid() Real-user-ID of the calling process. Effective-user-ID of the calling process. g Real-group-ID of the calling process.
ioctl(2) ioctl(2) NAME ioctl() - control device SYNOPSIS #include int ioctl(int fildes, int request, ... /* arg */); Remarks The ANSI C ", ... " construct denotes a variable length argument list whose optional [or required] members are given in the associated comment (/* */ ). DESCRIPTION ioctl() performs a variety of functions on character special files (devices), or regular files and directories on VxFS file systems.
ioctl(2) ioctl(2) WARNINGS Check all references to signal(5) for appropriateness on systems that support sigvector (2). sigvector (2) can affect the behavior described on this page. AUTHOR ioctl() was developed by AT&T and HP. SEE ALSO ioctl(5), arp(7P), socket(7), termio(7).
iscomsec(2) iscomsec(2) NAME iscomsec() - check if system has been converted to a trusted system SYNOPSIS #include int iscomsec(); DESCRIPTION iscomsec returns a zero (0) if the system is not a trusted system. If the system has been converted to a trusted system, iscomsec returns a one (1). Notes iscomsec determines if the system is a trusted system or not by checking the file, /tcb/files/auth/system/default. If the file exists, then the system is a trusted system.
kill(2) kill(2) NAME kill(), raise() - send a signal to a process or a group of processes SYNOPSIS #include int kill(pid_t pid, int sig); int raise(int sig); DESCRIPTION The kill() system call sends a signal to a process or a group of processes, as specified by pid. The signal to be sent is specified by sig and is either one from the list given in signal(2), or 0. The raise() system call sends a signal to the executing program.
kill(2) kill(2) [EINVAL] sig is SIGKILL or SIGSTOP and pid is 1 (process 1). [EPERM] The user ID of the sending process is not a user who has appropriate privileges and its real or effective user ID does not match the real or saved user ID of the receiving process. [EPERM] The sending and receiving processes are not in the same session and the real or effective user ID does not match the real or saved user ID of the receiving process.
killpg(2) killpg(2) NAME bsdproc: killpg(), getpgrp(), setpgrp(), signal(), sigvec() - 4.2 BSD-compatible process control facilities SYNOPSIS #include int killpg(int pgrp, int sig); int getpgrp(int pid); int setpgrp(int pid, int pgrp); void (*signal(int sig, void (*func)(int)))(int); Obsolescent Interfaces int sigvec( int sig, struct sigvec *vec, struct sigvec *ovec ); DESCRIPTION These calls simulate (and are provided for backward compatibility with) functions of the same name in the 4.
link(2) link(2) NAME link() - link to a file SYNOPSIS #include int link(const char *path1, const char *path2); DESCRIPTION The link() system call creates a new link (directory entry) for the existing file. path1 points to a path name naming an existing file. path2 points to a path name naming the new directory entry to be created. RETURN VALUE Upon successful completion, link() returns zero. Otherwise, it returns -1 and sets errno (see errno(2)) to indicate the error.
lio_listio(2) lio_listio(2) NAME lio_listio() - start a list of asynchronous I/O operations SYNOPSIS #include int lio_listio( int mode , struct aiocb *const list [], int nent , struct sigevent *sig ); DESCRIPTION The lio_listio() function allows the calling process to request a list of asynchronous I/O operations with a single function call. The function call returns when all operation requests have been enqueued for processing.
lio_listio(2) lio_listio(2) [EAGAIN] At least one request could not be queued either because of a resource shortage or because the per-process or system-wide limit on asynchronous I/O operations or asynchronous threads would have been exceeded. [EINTR] The mode argument was LIO_WAIT and a signal was delivered while waiting for the requested operations to complete. This signal may result from completion of one or more of the requested operations and other requests may still be pending or completed.
lio_listio(2) lio_listio(2) STANDARDS CONFORMANCE lio_listio() : POSIX Realtime Extensions, IEEE Std 1003.
listen(2) listen(2) NAME listen() - listen for connections on a socket SYNOPSIS #include int listen(int s, int backlog); DESCRIPTION To accept connections, a socket is first created using socket() , a queue for incoming connections is activated using listen() , and then connections are accepted using accept() . listen() applies only to unconnected sockets of type SOCK_STREAM .
lockf(2) lockf(2) NAME lockf() - provide semaphores and record locking on files SYNOPSIS #include int lockf(int fildes, int function, off_t size); DESCRIPTION The lockf() function allows regions of a file to be used as semaphores (advisory locks) or restricts access to only the locking process (enforcement-mode record locks). Other processes that attempt to access the locked resource either return an error or sleep until the resource becomes unlocked.
lockf(2) lockf(2) A potential for deadlock occurs if a process controlling a locked resource is put to sleep by accessing the locked resource of another process. Thus, calls to fcntl() , lockf() , read() , or write() (see fcntl(2), lockf(2), read(2), and write(2)) scan for a deadlock prior to sleeping on a locked resource. Deadlock is not checked for the wait() and pause() system calls (see wait(2) and pause(2)), so potential for deadlock is not eliminated.
lockf(2) lockf(2) Application Usage Because in the future the variable errno will be set to [EAGAIN] rather than [EACCES] when a section of a file is already locked by another process, portable application programs should expect and test for either value. For example: if (lockf(fd, F_TLOCK, siz) == -1) if ((errno == EAGAIN) || (errno == EACCES)) /* * section locked by another process * check for either EAGAIN or EACCES * due to different implementations */ else if ...
lseek(2) lseek(2) NAME lseek() - move read/write file pointer; seek SYNOPSIS #include off_t lseek(int fildes , off_t offset , int whence ); DESCRIPTION lseek() sets the file pointer associated with the file descriptor as follows: • If whence is SEEK_SET , the pointer is set to offset bytes. • If whence is SEEK_CUR , the pointer is set to its current location plus offset. • If whence is SEEK_END , the pointer is set to the size of the file plus offset.
lstat(2) lstat(2) NAME lstat() - get symbolic link status SYNOPSIS #include int lstat( const char *path , struct stat *buf ); PARAMETERS The parameters for the lstat() function are as follows: path is a pointer to a path name of any file within the mounted file system. All directories listed in the path name must be searchable. buf is a pointer to a stat structure where the file status information is stored.
lstat(2) lstat(2) RETURN VALUE Upon successful completion, lstat() returns 0. Otherwise, it returns -1 and sets errno to indicate the error. ERRORS The lstat() function will fail if: [EACCES] A component of the path prefix denies search permission. [ELOOP] Too many symbolic links were encountered in resolving path. [ENAMETOOLONG] The length of a pathname exceeds {PATH_MAX} , or the pathname component is longer than {NAME_MAX} . [ENOTDIR] A component of the path prefix is not a directory.
madvise(2) madvise(2) NAME madvise() - advise the system of a process’s expected paging behavior SYNOPSIS #include int madvise( caddr_t addr, size_t len, int behav ); DESCRIPTION The madvise system call permits a process to advise the system about its expected future behavior in referencing a mapped file, an anonymous memory region, or a shared memory region. Certain implementations can use this information to optimize the use of resources.
madvise(2) [EINVAL] madvise(2) The address range specified by addr and len was not created by a successful call to mmap() or shmat() . AUTHOR madvise() was developed by HP and OSF. SEE ALSO mmap(2), sysconf(2).
makecontext(2) makecontext(2) NAME makecontext(), swapcontext() - manipulate user contexts SYNOPSIS #include void makecontext(ucontext_t *ucp, (void *func)(), int argc, ...); int swapcontext(ucontext_t *oucp, const ucontext_t *ucp); DESCRIPTION The makecontext() function modifies the context specified by ucp, which has been initialized using getcontext() .
memcntl(2) memcntl(2) NAME memcntl() - memory management control SYNOPSIS #include #include int memcntl( caddr_t addr , size_t len , int cmd , caddr_t arg , int attr , int mask ); Parameters addr A multiple of page size as returned by the sysconf() routine where implemented; otherwise, addr must contain the value NULL . Where used, control operations can be further defined with the bit pattern contained in attr. m len Must be 0 for the MC_LOCKALL and MC_UNLOCKALL operations.
memcntl(2) memcntl(2) locks do not nest within a specified mapping. A single unlock operation removes multiple lock operations that occur on a page with the same address in the same process. If a page is locked in one process, but mapped in another, or visible through a different mapping in the locking process, the lock remains in memory until the locking process completes an either implicit or explicit unlock operation.
memcntl(2) [EPERM] memcntl(2) The effective user ID of the process is not superuser and MC_LOCK or MC_UNLOCK was specified. WARNINGS Users of memcntl() should note that the libcext library will not be available in future releases of HP-UX. However this function will be available as part of the C library libc . AUTHOR memcntl() was developed by HP. SEE ALSO mlock(2), mlockall(2), mmap(2), mprotect(2), msync(2), plock(2), sysconf(2).
mkdir(2) mkdir(2) NAME mkdir() - make a directory file SYNOPSIS #include int mkdir(const char *path, mode_t mode); DESCRIPTION The mkdir() system call creates a new directory file named by path. The file permission bits of the new directory are initialized from mode, and are modified by the process’s file mode creation mask. For each bit set in the process’s file mode creation mask, the corresponding bit in the new directory’s mode is cleared (see umask(2)).
mkdir(2) mkdir(2) [ENAMETOOLONG] The resolution of a symbolic link in path produced an intermediate result whose length exceeds PATH_MAX [ENOENT] A component of the path prefix does not exist. [ENOSPC] Not enough space on the file system. [ENOTDIR] A component of the path prefix is not a directory. [EROFS] The named file resides on a read-only file system. [EDQUOT] User’s disk quota block or inode limit has been reached for this file system.
mknod(2) mknod(2) NAME mknod() - make directory, special, or ordinary file SYNOPSIS #include int mknod(const char *path, mode_t mode, dev_t dev); DESCRIPTION The mknod() system call creates a new file named by the path name pointed to by path. The mode of the new file is specified by the mode argument. Symbolic constants that define the file type and file access permission bits are found in the header file and are used to construct the mode argument.
mknod(2) mknod(2) [ENOENT] The path argument is null. [ENOENT] A component of the path prefix does not exist. [ENOSPC] Not enough space on the file system. [ENOTDIR] A component of the path prefix is not a directory. [EPERM] The effective-user-ID of the process does not match that of a user who has appropriate privileges, and the file type is not FIFO special. [EROFS] The directory in which the file is to be created is located on a read-only file system.
mlock(2) mlock(2) NAME mlock() - lock a segment of the process virtual address space in memory SYNOPSIS #include int mlock( const void * addr, size_t len) ; DESCRIPTION The mlock() system call allows the calling process to lock a segment of the process virtual address space into memory. Any addressable segment of the process’ address space may be locked. Locked segments are immune to all routine swapping. addr must be a valid address in the process virtual address space.
mlockall(2) mlockall(2) NAME mlockall() - lock a process virtual address space in memory SYNOPSIS #include int mlockall( const int flags ); DESCRIPTION The mlockall() system call allows the calling process to lock its entire virtual address space into memory, making it immune to all routine swapping. flags may be one or both of the following: MCL_CURRENT Lock the current process virtual address space. All addressable pages of the address space are locked.
mlockall(2) mlockall(2) STANDARDS CONFORMANCE mlockall() : POSIX Realtime Extensions, IEEE Std 1003.
mmap(2) mmap(2) NAME mmap() - map pages of memory SYNOPSIS #include void *mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t off); DESCRIPTION The mmap() function establishes a mapping between a process’ address space and a file.
mmap(2) MAP_GLOBAL MAP_IO MAP_MEM_INTERLEAVED MAP_MEM_LOCAL MAP_MEM_FIRST_TOUCH mmap(2) Allocate physical memory from the global quadrant / octant. Create a virtual mapping for a physical I/O address range. Physical memory will be interleaved. Allocate physical memory from the current locality domain. Allocate physical memory from the locality domain of the first processor to touch each address. The MAP_PRIVATE and MAP_SHARED flags control the visibility of write references to the memory region.
mmap(2) mmap(2) implementation selects a value for pa, it never places a mapping at address 0, replaces any extant mapping, or maps into dynamic memory allocation areas. The off argument is constrained to be aligned and sized according to the value returned by sysconf() when passed _SC_PAGESIZE or _SC_PAGE_SIZE. When MAP_FIXED is specified, the argument addr must also meet these constraints. The implementation performs mapping operations over whole pages.
mmap(2) mmap(2) suitable memory is returned instead. mmap() cannot create a mapped file region unless the file descriptor used to map the file is open for reading. For a mapped file region that is mapped with MAP_SHARED , mmap() grants write access permission only if the file descriptor is open for writing. If a region was mapped with either MAP_PRIVATE or MAP_ANONYMOUS, mmap() grants all requested access permissions.
mmap(2) mmap(2) RETURN VALUE Upon successful completion, mmap() returns the address, (pa), at which the mapping was placed. Otherwise, it returns MAP_FAILED (defined in ) and sets errno to indicate the error.
mmap(2) mmap(2) • After the initial MAP_SHARED mmap() of a file range, all subsequent MAP_SHARED calls to mmap() to map the same range of a file must either specify MAP_VARIABLE in flags and inherit the virtual address range the system has chosen for this range, or specify MAP_FIXED with an addr that corresponds exactly to the address chosen by the system for the initial mapping. Only after all mappings for a file range have been destroyed can that range be mapped to a different virtual address.
mmap(2) mmap(2) becomes: fildes = open(...) address = mmap(0, len, PROT_READ, MAP_PRIVATE, fildes, some_offset) /* use data at address */ AUTHOR mmap() was developed by HP, AT&T, and OSF. SEE ALSO creat64(2), exec(2), fcntl(2), fork(2), lockf(2), madvise(2), mpctl(2), mprotect(2), msem_init(2), msem_lock(2), msem_unlock(2), msync(2), munmap(2), pset_ctl(2), shmop(2), sysconf(2), truncate(2), mman(5), privileges(5), stat(5), zero(7). Adaptive Address Space Whitepaper at http://www.hp.
modload(2) modload(2) NAME modload() - load kernel modules on demand SYNOPSIS #include int modload(char *pathname ); DESCRIPTION modload allows processes with appropriate privilege to demand-load a kernel module into the running kernel. The module must be of a supported type and must have been registered via kcmodule(1M) before it can be loaded. The module to be loaded is specified by pathname. pathname may be either a module name or an absolute path name.
modpath(2) modpath(2) NAME modpath() - change global search path for dynamically loadable kernel modules SYNOPSIS #include int modpath(const char *pathname ); DESCRIPTION modpath allows processes with appropriate privilege to modify the global search path used to locate object files for dynamically loadable kernel modules. The search path modifications take effect immediately and affect all subsequent loads for all users on the system.
modstat(2) modstat(2) NAME modstat() - get information for a dynamically loaded kernel module SYNOPSIS #include int modstat(int module_id , struct modstatus *stbuf , int get_next_module ); DESCRIPTION modstat allows processes to get information for dynamically loaded kernel modules. For processes with appropriate privilege, it fills in all the elements of the modstatus structure, specified by stbuf, with the information available for the given module identifier module_id.
modstat(2) [ENOSYS] modstat(2) The Dynamically Loadable Kernel Module feature is not initialized. SEE ALSO kcmodule(1M), modload(2), privileges(5).
moduload(2) moduload(2) NAME moduload() - unload a kernel module on demand SYNOPSIS #include int moduload(long module_id ); DESCRIPTION moduload allows processes with appropriate privilege to demand unload one or all unloadable modules from the running kernel. A module is considered unloadable if it is not currently in use, if no module depending on it is currently loaded, and if the module is not being loaded or unloaded from the kernel.
mount(2) mount(2) NAME mount() - mount a file system SYNOPSIS #include int mount(const char *fs, const char *path, int mflag); int mount(const char *fs, const char *path, int mflag, const char *fstype, const char *dataptr, int datalen); DESCRIPTION The mount() system call requests that a file system identified by fs be mounted on the file identified by path. mflag contains a bit-mask of flags (described below). Note that the MS_DATA flag must be set for the sixargument version of the call.
mount(2) mount(2) MS_BEHIND Writes to disks are to be done asynchronously, where possible, without waiting for completion. This is the default on Series 700 systems, as it was prior to release 10.0. MS_BEHIND and MS_DELAY are mutually exclusive. MS_NO_FSASYNC Rigorous posting of file system metadata is to be used. This is the default. MS_FSASYNC Relaxed posting of file system metadata is to be used.
mpctl(2) mpctl(2) NAME mpctl() - multiprocessor control SYNOPSIS #include int mpctl( mpc_request_t request, spu_t spu, pid_t pid ); int mpctl( mpc_request_t request, spu_t spu, lwpid_t lwpid ); int mpctl( mpc_request_t request, ldom_t ldom, pid_t pid ); int mpctl( mpc_request_t request, ldom_t ldom, lwpid_t lwpid ); m REMARKS Much of the functionality of this capability is highly dependent on the underlying hardware.
mpctl(2) mpctl(2) The mpctl call is expected to be used to increase performance in certain applications, but should not be used to ensure correctness of an application. Specifically, cooperating processes/lightweight processes should not rely on processor or locality domain assignment in lieu of a synchronization mechanism (such as semaphores). Machine Topology Information Warning: Processor and locality domain IDs are not guaranteed to exist in numerical order.
mpctl(2) mpctl(2) MPC_SPUTOLDOM This request returns the ID of the locality domain containing processor spu. The pid argument is ignored. Processor Core Information For processor core topology use: int mpctl(mpc_request_t request, spu_t spu, pid_t pid); The request argument determines the precise action to be taken by mpctl() and is one of the following: MPC_GETNUMCORES_SYS Returns the number of enabled processor cores in the system; this value will always be greater than or equal to 1.
mpctl(2) mpctl(2) Processor Set Information Warning: Dynamic creation and deletion of processor sets, and dynamic reassignment of a processor from one processor set to another may occur. All processors in the system comprise one processor set by default at boot time until new processor sets are created and configured by users. The following command requests the return of topology information on processors and locality domains in the processor set of the calling thread.
mpctl(2) mpctl(2) LWP create attributes). Processor binding and locality domain binding are mutually exclusive -- only one can be in effect at any time. If locality domain binding is in effect, the target is allowed to execute on any processor within that locality domain in its processor set. Setting the processor or locality domain binding will fail if the target processor or locality domain is not in the processor set of the specified process or LWP.
mpctl(2) mpctl(2) NOTE: This call is advisory. If the scheduling policy for a LWP conflicts with this processor assignment, the scheduling policy takes precedence. For example, when a processor is ready to choose another LWP to execute, and the highest priority SCHED_FIFO LWP is bound to a different processor, that the LWP will execute on the selecting processor rather than waiting for the specified processor to which it was bound.
mpctl(2) mpctl(2) processor will then choose a lower priority LWP to execute on the processor. NOTE: This option will not guarantee compliance with POSIX real-time scheduling algorithms. Obtaining Processor and Locality Domain Binding Type These options return the current binding type for the specified process or LWP.
mpctl(2) mpctl(2) When setting a process launch policy, the launch policy specified shall only be applied to the process. The launch policies of LWPs within the process shall not be affected.
mpctl(2) mpctl(2) MPC_SETPROCESS_RR This call establishes a round robin launch policy (MPC_LAUNCH_POLICY_RR) for the specified process. The successive child processes are launched on different locality domains in a round robin manner until all available locality domains have been used by processes in the launch tree. At that point, the selection of locality domains begins again from the original locality domain. The ldom argument is ignored.
mpctl(2) mpctl(2) domains in a round robin manner until all available locality domains have been used by LWPs in the launch tree. At that point, the selection of locality domains begins again from the original locality domain. The ldom argument is ignored. MPC_SETLWP_FILL This call establishes a fill first launch policy (MPC_LAUNCH_POLICY_FILL) for the specified LWP.
mpctl(2) mpctl(2) [EPERM] request is MPC_SETPROCESS, MPC_SETPROCESS_FORCE, or MPC_SETLDOM , spu is not MPC_SPUNOCHANGE or MPC_LDOMNOCHANGE, pid identifies another process, and the caller does not have the same effective user id as the target process, or does not have the MPCTL privilege.
mprotect(2) mprotect(2) NAME mprotect() - set or check protection of memory mapping SYNOPSIS #include int mprotect(void *addr, size_t len, int prot); DESCRIPTION The mprotect() function changes the access protections on the mappings specified by the range [addr, addr+len], rounding len up to the next multiple of the page size as returned by sysconf() , to be that specified by prot. Legitimate values for prot are the same as those permitted for mmap() and are defined in
mprotect(2) mprotect(2) SEE ALSO mmap(2), sysconf(2), . STANDARDS CONFORMANCE mprotect(): AES, SVID3 CHANGE HISTORY First released in Issue 4, Version 2.
mq_close(2) mq_close(2) NAME mq_close() - close a message queue descriptor SYNOPSIS #include int mq_close(mqd_t mqdes); DESCRIPTION The mq_close() system call removes the association between the message queue descriptor, mqdes, and a message queue.
mq_getattr(2) mq_getattr(2) NAME mq_getattr() - get status information and attributes associated with a message queue SYNOPSIS #include int mq_getattr(mqd_t mqdes, struct mq_attr *mqstat); DESCRIPTION The mq_getattr() system call collects status information and attributes associated with the message queue specified by mqdes which is copied into the mq_attr structure referenced by mqstat.
mq_notify(2) mq_notify(2) NAME mq_notify() - register/cancel a notification request with a message queue SYNOPSIS #include int mq_notify(mqd_t mqdes, const struct sigevent *notification); DESCRIPTION If the argument notification is not NULL , the mq_notify() system call registers the calling process to be notified of message arrival at an empty message queue associated with the message queue descriptor mqdes.
mq_open(2) mq_open(2) NAME mq_open() - create/open a message queue SYNOPSIS #include mqd_t mq_open(const char *name, int oflag, ... /* * [mode_t mode, struct mq_attr ] */ ); Remarks The ANSI C ", ... " construct specifies a variable length argument list whose optional members are given in the associated comment (/* */ ). DESCRIPTION The mq_open() system call establishes a connection between a process and a message queue.
mq_open(2) mq_open(2) b. Contain no pathname component consisting of a dot or dot-dot; e.g., /./tmp and /../tmp . c. Contain no illegal characters. d. Contain no pathname components longer that _POSIX_NAME_MAX. e. Entire name should not be longer that _POSIX_PATH_MAX. To use this function, link in the realtime library by specifying -lrt on the compiler or linker command line.
mq_receive(2) mq_receive(2) NAME mq_receive() - receive a message from a message queue SYNOPSIS #include ssize_t mq_receive(mqd_t char size_t unsigned int ); mqdes, *msg_ptr, msg_len, *msg_prio DESCRIPTION The mq_receive() system call receives the oldest of the highest priority message from the message queue specified by mqdes. The selected message is removed from the queue and copied to the buffer pointed to by the msg_ptr argument.
mq_send(2) mq_send(2) NAME mq_send() - send a message to a message queue SYNOPSIS #include int mq_send(mqd_t const char size_t unsigned int ); mqdes, *msg_ptr, msg_len, msg_prio DESCRIPTION The mq_send() system call adds a message pointed to by the argument msg_ptr to the message queue specified by mqdes. The msg_len argument specifies the length of the message in bytes.
mq_setattr(2) mq_setattr(2) NAME mq_setattr() - set the blocking status of a message queue associated with a descriptor SYNOPSIS #include int mq_setattr(mqd_t mqdes, const struct mq_attr *mqstat, struct mq_attr *omqstat, ); DESCRIPTION The mq_setattr() system call changes the blocking status of a message queue associated with the descriptor, mqdes.
mq_unlink(2) mq_unlink(2) NAME mq_unlink() - unlink a message queue SYNOPSIS #include int mq_unlink(const char *name); DESCRIPTION The mq_unlink() system call disassociates the queue name, from a message queue specified by the argument, name. After a successful call to mq_unlink() , attempts to open a message queue with the same name will fail, if the flag O_CREAT is not set in oflags. If there are no processes with existing open descriptors for the message queue, the queue is destroyed.
msem_init(2) msem_init(2) NAME msem_init() - initialize a semaphore in a mapped file or anonymous memory region SYNOPSIS #include msemaphore *msem_init(msemaphore *sem, int initial_value); DESCRIPTION msem_init() allocates a new binary semaphore and initializes the state of the new semaphore. sem points to an msemaphore structure in which the state of the semaphore is to be stored. If initial_value is MSEM_LOCKED , the new semaphore is initialized in the locked state.
msem_lock(2) msem_lock(2) NAME msem_lock() - lock a semaphore SYNOPSIS #include int msem_lock(msemaphore *sem, int condition); DESCRIPTION msem_lock() attempts to lock a binary semaphore. sem points to an msemaphore structure which specifies the semaphore to be locked. If the semaphore is not currently locked, it becomes locked and the function returns successfully. If the semaphore is currently locked, and condition is MSEM_IF_NOWAIT, then the function returns with an error.
msem_remove(2) msem_remove(2) NAME msem_remove() - remove a semaphore in mapped file or anonymous region SYNOPSIS #include int *msem_remove(msemaphore *sem ); DESCRIPTION msem_remove() removes a binary semaphore. sem points to an msemaphore structure that specifies the semaphore to be removed. Any subsequent use of the msemaphore structure before it is again initialized by calling msem_init() produces undefined results.
msem_unlock(2) msem_unlock(2) NAME msem_unlock() - unlock a semaphore SYNOPSIS #include int msem_unlock(msemaphore *sem, int condition); DESCRIPTION msem_unlock() unlocks a binary semaphore. sem points to an msemaphore structure that specifies the semaphore to be unlocked. If the condition argument is zero, the semaphore will be unlocked, whether or not any other processes are currently attempting to lock it.
msgctl(2) msgctl(2) NAME msgctl() - message control operations SYNOPSIS #include int msgctl(int msqid, int cmd, struct msqid_ds *buf); DESCRIPTION msgctl() provides a variety of message control operations as specified by cmd. The following cmds are available: IPC_STAT Place the current value of each member of the data structure associated with msqid into the structure pointed to by buf. The contents of this structure are defined in glossary(9).
msgctl(2) msgctl(2) [EINVAL] msqid is not a valid message queue identifier. [EINVAL] cmd is not a valid command, or the command contains invalid parameters. [EACCES] cmd is equal to IPC_STAT and Read operation permission is denied to the calling process (see message operation permissions in glossary(9)). [EPERM] cmd is equal to IPC_RMID or IPC_SET and the calling process does not have the OWNER privilege or the effective user ID of the calling process is not equal to the value of either msg_perm.
msgget(2) msgget(2) NAME msgget() - get message queue SYNOPSIS #include int msgget(key_t key, int msgflg); DESCRIPTION msgget() returns the message queue identifier associated with key. A message queue identifier and associated message queue and data structure are created for key if one of the following is true: key is equal to IPC_PRIVATE . This call creates a new identifier, subject to available resources.
msgget(2) [EEXIST] msgget(2) A message queue identifier exists for key but ( (msgflg & IPC_CREAT ) && (msgflg & IPC_EXCL ) ) is "true". SEE ALSO ipcrm(1), ipcs(1), msgctl(2), msgop(2), stdipc(3C).
msgop(2) msgop(2) NAME msgsnd(), msgrcv() - message operations SYNOPSIS #include int msgsnd( int msqid, const void *msgp, size_t msgsz, int msgflg ); int msgrcv( int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg ); DESCRIPTION The msgsnd() system call sends a message to the queue associated with the message queue identifier specified by msqid.
msgop(2) msgop(2) long char mtype; mtext[]; /* message type */ /* message text */ mtype is the received message’s type as specified by the sending process. mtext is the text of the message. msgsz specifies the size in bytes of mtext . The received message is truncated to msgsz bytes if it is larger than msgsz and (msgflg & MSG_NOERROR ) is true. The truncated part of the message is lost and no indication of the truncation is given to the calling process.
msgop(2) [EACCES] [EAGAIN] msgop(2) Operation permission is denied to the calling process. The message cannot be sent for one of the reasons cited above and (msgflg & IPC_NOWAIT ) is true. [EFAULT] msgp points to an illegal address. The reliable detection of this error is implementation dependent. [EIDRM] The message queue identifier msqid has been removed from the system. [EINTR] msgsnd() was interrupted by a signal. [EINVAL] msqid is not a valid message queue identifier.
msync(2) msync(2) NAME msync() - synchronize the memory of a mapped file with physical storage SYNOPSIS #include int msync(void *addr, size_t len, int flags); DESCRIPTION The msync() function writes all modified copies of pages over the range [addr, addr+len] to the underlying hardware, or invalidates any copies so that further references to the pages will be obtained by the system from their permanent storage locations.
msync(2) msync(2) RETURN VALUE Upon successful completion, msync() returns 0. Otherwise, it returns -1 and sets errno to indicate the error. ERRORS The msync() function will fail if: [EAGAIN] [EINVAL] A transient error occurred while writing to the file system. The addr argument is not a multiple of the page size as returned by sysconf(_SC_PAGE_SIZE). [EINVAL] The address range specified by addr and len was not created by a successful call to mmap() .
munlock(2) munlock(2) NAME munlock() - unlock a segment of the process virtual address space SYNOPSIS #include int munlock( const void * addr, size_t len) ; DESCRIPTION The munlock() system call allows the calling process to unlock a segment of the process virtual address space that may have been previously locked with mlock() or mlockall() . Upon successful completion of the munlock() , pages within the specified segment are subject to routine paging and/or swapping.
munlockall(2) munlockall(2) NAME munlockall() - unlock the entire virtual address space of a process SYNOPSIS #include int munlockall() ; DESCRIPTION The munlockall() system call allows the calling process to unlock any portions of its virtual address space that have previously been locked into memory with mlock() or mlockall() , including any portions locked due to the MCL_FUTURE option of mlockall() .
munmap(2) munmap(2) NAME munmap() - unmap pages of memory SYNOPSIS #include int munmap(void *addr, size_t len); DESCRIPTION The munmap() function removes the mappings for pages in the range [addr, addr+len], rounding the len argument up to the next multiple of the page size as returned by sysconf() . If addr is not the address of a mapping established by a prior call to mmap() , the behavior is undefined.
mvalid(2) mvalid(2) NAME mvalid() - check memory region for validity SYNOPSIS #include #include int mvalid( caddr_t addr , size_t len , int prot ); Parameters addr The address of the region whose validity is to be checked. len The length in bytes of the region specified by the addr parameter. prot The desired access protection for the region.
mvalid(2) mvalid(2) SEE ALSO mmap(2), mprotect(2), sysconf(2).
nanosleep(2) nanosleep(2) NAME nanosleep() - high resolution sleep SYNOPSIS #include int nanosleep( const struct timespec *rqtp, struct timespec *rmtp ); DESCRIPTION The nanosleep() function causes the current process to be suspended from execution until either the time interval specified by the rqtp argument has elapsed, or a signal is delivered to the calling process and its action is to invoke a signal-catching function or to terminate the process.
nanosleep(2) nanosleep(2) SEE ALSO clocks(2), timers(2), sleep(3C). STANDARDS CONFORMANCE nanosleep() : POSIX.
nice(2) nice(2) NAME nice() - change priority of a process SYNOPSIS #include int nice(int priority_change); DESCRIPTION nice() adds the value of priority_change to the nice value of the calling process. A process’s nice value is a positive number for which a more positive value results in lower CPU priority. A maximum nice value of 39 and a minimum nice value of 0 are imposed by the system.
open(2) open(2) NAME open() - open file for reading or writing SYNOPSIS #include int open(const char *path, int oflag, ... /* [mode_t mode ] */ ); Remarks The ANSI C ", ... " construct specifies a variable length argument list whose optional member is given in the associated comment (/* */). DESCRIPTION The open() system call opens a file descriptor for the named file and sets the file status flags according to the value of oflag.
open(2) open(2) When opening a FIFO with O_RDONLY or O_WRONLY set: If O_NDELAY is set: A read-only open() returns without delay. A write-only open() returns an error if no process currently has the file open for reading. If O_NDELAY is clear: A read-only open() does not return until a process opens the file for writing. A write-only open() does not return until a process opens the file for reading.
open(2) open(2) n Successful completion. n is a file descriptor for the opened file. -1 Failure. errno is set to indicate the error. ERRORS If open() fails, errno is set to one of the following values. [EACCES] oflag permission is denied for the named file. [EACCES] A component of the path prefix denies search permission. [EACCES] The file does not exist and the directory in which the file is to be created does not permit writing. [EACCES] O_TRUNC is specified and write permission is denied.
open(2) open(2) int infd; infd = open ("inputfile", O_RDONLY); The following call to open() opens file outputfile for writing and returns a file descriptor for outputfile . For an example of preallocating disk space for outputfile , see the prealloc(2) manual entry. For an example of writing to outputfile , see the write(2) manual entry. int outfd; outfd = open ("outputfile", O_WRONLY); The following call opens file iofile for synchronized I/O file integrity for reads and writes.
pathconf(2) pathconf(2) NAME pathconf(), fpathconf() - get configurable path name variables SYNOPSIS #include long pathconf(const char *path, int name); long fpathconf(int fildes, int name); DESCRIPTION The pathconf() and fpathconf() functions provide a method for applications to determine the value of a configurable limit or option associated with a file or directory (see limits(5) and ). For pathconf() , the path argument points to the path name of a file or directory.
pathconf(2) 9. pathconf(2) _POSIX_CHOWN_RESTRICTED is undefined and pathconf() or fpathconf() returns -1 without changing errno . To determine if chown() can be performed on a file, it is simplest to attempt the chown() operation and check the return value for failure or success. _POSIX_SYNC_IO, when defined, determines whether synchronized IO operations may be performed for the associated file (see open(2)).
pathconf(2) pathconf(2) } } /* otherwise, _POSIX_NO_TRUNC is in effect for this directory */ if ((fd = open(filebuf, O_CREAT, mode)) < 0) perror(filebuf); DEPENDENCIES NFS The following error can occur: [EOPNOTSUPP] path or fildes refers to a file for which a value for name cannot be determined. In particular, _PC_LINK_MAX , _PC_NAME_MAX , _PC_PIPE_BUF , _PC_PATH_MAX , _PC_NO_TRUNC , and _PC_CHOWN_RESTRICTED, cannot be determined for an NFS file. AUTHOR pathconf() and fpathconf() were developed by HP.
pause(2) pause(2) NAME pause() - suspend process until signal SYNOPSIS #include int pause(void); DESCRIPTION pause() suspends the calling process until it receives a signal. The signal must be one that is not currently set to be ignored or blocked (masked) by the calling process. If the signal causes termination of the calling process, pause() does not return.
pipe(2) pipe(2) NAME pipe() - create an interprocess channel SYNOPSIS int pipe(int fildes[2]); DESCRIPTION pipe() creates an I/O mechanism called a pipe and returns two file descriptors, fildes[0] and fildes[1]. fildes[0] is opened for reading and fildes[1] is opened for writing. A read-only file descriptor fildes[0] accesses the data written to fildes[1] on a first-in-first-out (FIFO) basis. For details of the I/O behavior of pipes see read(2) and write(2). By default, HP-UX pipes are not STREAMS-based.
pipe(2) pipe(2) [ENOSPC] The file system lacks sufficient space to create the pipe. [ENOSR] Could not allocate resources for both Stream heads (STREAMS-based pipes only). SEE ALSO sh(1), read(2), write(2), popen(3S), streamio(7). STANDARDS CONFORMANCE pipe() : AES, SVID2, SVID3, XPG2, XPG3, XPG4, FIPS 151-2, POSIX.
plock(2) plock(2) NAME plock() - lock process, text, data, stack, or shared library in memory SYNOPSIS #include int plock(int op ); DESCRIPTION The plock() system call allows the calling process to lock the text segment of the process (text lock), its data segment (data lock), or both its text and data segment (process lock) into memory. Stack segments are also locked when data segments are locked. Shared library text and shared library data segments (shlib lock) can also be locked.
plock(2) plock(2) [EINVAL] op is equal to TXTSHLIBLOCK and a text lock or process lock already exists on the calling process. [EINVAL] op is equal to DATSHLIBLOCK and a data lock, or process lock already exists on the calling process. [EINVAL] op is not equal to one of the values specified in DESCRIPTION. [EINVAL] plock() is not allowed in a [vfork ,exec ] window. See vfork(2). [ENOMEM] There is not enough lockable memory in the system to satisfy the locking request.
poll(2) poll(2) NAME poll() - monitor I/O conditions on multiple file descriptors SYNOPSIS #include int poll( struct pollfd fds[], nfds_t nfds, int timeout ); DESCRIPTION poll() provides a general mechanism for reporting I/O conditions associated with a set of file descriptors and for waiting until one or more specified conditions becomes true. Specified conditions include the ability to read or write data without blocking, and error conditions.
poll(2) poll(2) POLLMSG A M_SIG or M_PCSIG message specifying SIGPOLL has reached the front of the stream head read queue. The conditions indicated by POLLNORM and POLLOUT are true if and only if at least one byte of data can be read or written without blocking. The exception is regular files, which always poll true for POLLNORM and POLLOUT . Also, streams return POLLNORM in revents even if the available message is of zero length.
poll(2) poll(2) fds[2].events = POLLOUT; count = poll(fds, 3, 10000); if (count == -1) { perror("poll failed"); exit(1); } if (count==0) printf("No data for reading or writing\n"); if (fds[0].revents & POLLNORM) printf("There is data for reading fd %d\n", fds[0].fd); if (fds[1].revents & POLLNORM) printf("There is data for reading fd %d\n", fds[1].fd); if (fds[2].revents & POLLOUT) printf("There is room to write on fd %d\n", fds[2].
postwait(2) postwait(2) NAME postwait: pw_getukid(), pw_getvmax(), pw_post(), pw_postv(), pw_wait() - lightweight synchronization mechanism SYNOPSIS #include #include
postwait(2) postwait(2) [EINTR] pw_wait() was interrupted by a signal. [EINVAL] The timespec pointed to by ts is invalid. pw_post() sets errno to one of the following values if it fails: [EINVAL] The ukid refers to a non-existent kernel thread. pw_postv() sets errno to one of the following values if it fails: [EFAULT] targets points to an illegal address. The reliable detection of this error is implementation dependent. [EFAULT] errors points to an illegal address.
prealloc(2) prealloc(2) NAME prealloc() - preallocate fast disk storage SYNOPSIS #include int prealloc(int fildes, off_t size); DESCRIPTION prealloc() is used to preallocate space on a disk for faster storage operations. fildes is a file descriptor obtained from a creat() , open() , dup() , or fcntl() system call for an ordinary file of zero length. It must be opened writable, because it will be written to by prealloc() .
profil(2) profil(2) NAME profil() - execution time profile SYNOPSIS #include void profil( unsigned short int *buff, size_t bufsiz, size_t offset, unsigned int scale ); DESCRIPTION profil() controls profiling, by which the system maintains estimates of the amount of time the calling program spends executing at various places in its address space. The buff argument must point to an area of memory whose length (in bytes) is given by bufsiz.
pset_assign(2) pset_assign(2) NAME pset_assign() - change processor set assignment SYNOPSIS #include int pset_assign( psetid_t pset , spu_t spu , psetid_t *opset ); DESCRIPTION The pset_assign() function assigns the processor spu to the processor set pset, removing the processor spu from its current processor set. A processor can not belong to more than one processor set at any given time.
pset_assign(2) pset_assign(2) /* * Initialize spu and new_pset first. * spu identifies the processor to be reassigned, whereas * new_pset identifies the target processor set. */ if ((ret = pset_assign(new_pset, spu, &old_pset)) < 0) { perror("pset_assign"); exit(1); } RETURN VALUE pset_assign returns zero on successful completion. Otherwise, -1 is returned and errno is set to indicate the error.
pset_bind(2) pset_bind(2) NAME pset_bind() - bind process or thread to a processor set SYNOPSIS #include int pset_bind( psetid_t pset, idtype_t idtype, id_t id, psetid_t *opset); DESCRIPTION The pset_bind() function binds thread(s) or process(es) specified by idtype and id to the processor set pset. If idtype is P_PID , then id specifies the pid of the process to be assigned, and the binding affects all threads of the process.
pset_bind(2) pset_bind(2) The child process and its first thread created by a fork() or vfork() function inherits the processor set binding from the parent process. The new threads in the multi-threaded process inherits their processor set binding from the creator thread. Security Restrictions Some or all of the actions associated with this system call require the PSET privilege. Processes owned by the superuser have this privilege.
pset_create(2) pset_create(2) NAME pset_create() - create a processor set SYNOPSIS #include int pset_create( psetid_t *newpset); DESCRIPTION The pset_create() function creates an empty processor set with no processors. Processor sets allow a subset of processors in the system to be isolated for exclusive use by specified threads and processes. Only the threads bound to a processor set can execute on processors in that processor set.
pset_create(2) pset_create(2) PSET_ATTR_OWNID UID of the processor set owner. The processor set creator is the default owner. PSET_ATTR_PERM Access permissions for the processor set. By default, the processor set owner has all permissions, whereas group and others have only READ and EXEC permissions. Processor sets define a scheduling allocation domain for threads and processes. All threads may execute only on processors within the assigned processor set.
pset_ctl(2) pset_ctl(2) NAME pset_ctl() - processor set control SYNOPSIS #include int pset_ctl( pset_request_t request, psetid_t pset, id_t id); DESCRIPTION The pset_ctl() function provides a means to query the system processor set configuration and assignment information. The request argument specifies what information is needed for the pset processor set. The following request values are supported: PSET_GETCURRENTPSET Return the ID of the processor set binding for the calling thread.
pset_ctl(2) pset_ctl(2) PSET_SPUTOPSET Return the ID of the processor set assigned for the processor specified in id. If the processor is not enabled or is in transition from one processor set to another, -1 is returned with an error. The pset argument is ignored. Any user may query the system processor set topology using the pset_ctl() function. Use sysconf() with _SC_PSET_SUPPORT name to see if the processor set functionality is supported by the underlying HP-UX operating system version.
pset_ctl(2) [ENOSYS] pset_ctl(2) The processor set functionality is not supported by the underlying HP-UX version. AUTHOR pset_ctl() was developed by HP. SEE ALSO psrset(1M), pset_assign(2), pset_bind(2), pset_create(2), pset_destroy(2), pset_getattr(2), pset_setattr(2), sysconf(2).
pset_destroy(2) pset_destroy(2) NAME pset_destroy() - destroy a processor set SYNOPSIS #include int pset_destroy( psetid_t pset); DESCRIPTION The pset_destroy() function destroys the processor set pset, releasing all constituent processors and processes by default. The processors and processes are reassigned to the system default processor set. Once destroyed, the pset identifier becomes available for new processor sets that may be created in the future.
pset_destroy(2) pset_destroy(2) [EINTR] The operation was interrupted. [EINVAL] pset is not a valid processor set. [ENOSYS] The processor set functionality is not supported by the underlying HP-UX version. [EPERM] The user does not have necessary permissions to destroy a processor set or the system default processor set was specified. SEE ALSO psrset(1M), pset_assign(2), pset_bind(2), pset_create(2), pset_ctl(2), pset_getattr(2), privgrp(4), privileges(5).
pset_getattr(2) pset_getattr(2) NAME pset_getattr(), pset_setattr() - manage processor set attributes SYNOPSIS #include int pset_getattr( psetid_t pset, pset_attrtype_t type, pset_attrval_t* val); int pset_setattr( psetid_t pset, pset_attrtype_t type, pset_attrval_t val); DESCRIPTION The pset_getattr() function returns the current value of the attribute type for the processor set pset in the memory location pointed to by val.
pset_getattr(2) pset_getattr(2) A user with the PSET privilege or the pset owner may change the value of the PSET_ATTR_PERM attribute. PSET_ATTR_IOINTR A value of PSET_ATTRVAL_ALLOW indicates that processors in this processor set are configured to receive external interrupts. It may be assigned a value of PSET_ATTRVAL_DISALLOW to disable all processors in the processor set from receiving and processing external I/O interrupts. Not all platforms may support this feature.
pset_getattr(2) pset_getattr(2) Security Restrictions Some or all of the actions associated with this system call require the PSET privilege. Processes owned by the superuser have this privilege. Processes owned by other users may have this privilege, depending on system configuration. See privileges(5) for more information about privileged access on systems that support fine-grained privileges. RETURN VALUE The functions return zero on successful completion.
pstat(2) pstat(2) NAME pstat(), pstat_getcommandline(), pstat_getcrashdev(), pstat_getcrashinfo(), pstat_getdisk(), pstat_getdynamic(), pstat_getfile(), pstat_getfile2(), pstat_getfiledetails(), pstat_getipc(), pstat_getlocality(), pstat_getlv(), pstat_getlwp(), pstat_getmpathname(), pstat_getmsg(), pstat_getnode(), pstat_getpathname(), pstat_getpmq(), pstat_getproc(), pstat_getprocessor(), pstat_getproclocality(), pstat_getprocvm(), pstat_getpsem(), pstat_getpset(), pstat_getsem(), pstat_getshm(), pstat_
pstat(2) pstat(2) ); int pstat_getmpathname( struct pst_mpathnode *buf, size_t elemsize, size_t elemcount, int index, struct psfsid *fid ); int pstat_getmsg( struct pst_msginfo *buf, size_t elemsize, size_t elemcount, int index ); int pstat_getnode( struct pst_node *buf, size_t elemsize, size_t elemcount, int index ); int pstat_getpathname( char *buf, size_t elemcount, struct pst_fid *fid ); int pstat_getpmq( struct pst_pmqinfo *buf, size_t elemsize, size_t elemcount, int index ); int pstat_getproc( struc
pstat(2) pstat(2) int pstat_getstatic( struct pst_static *buf, size_t elemsize, size_t elemcount, int index ); int pstat_getstream( struct pst_stream *buf, size_t elemsize, size_t elemcount, int moduleskip, struct pst_fid *fid ); int pstat_getswap( struct pst_swapinfo *buf, size_t elemsize, size_t elemcount, int index ); int pstat_getvminfo( struct pst_vminfo *buf, size_t elemsize, size_t elemcount, int index ); Remarks The underlying function pstat() is provided for backward compatibility.
pstat(2) pstat(2) Context Struct Commandline char * Instances 1 per process Short Cut yes Process LW Process Process VM Process Locality LVM Vol Sema Set Msg Queue Shared Mem Proc Set P-Sema Set P-Msg Queue Open File Open File Open File 1 per 1 per 1 per 1 per process lwp/thread process region process loc.
pstat(2) pstat(2) open file for a specified process. For the specified process, there is one instance of this context for each open file descriptor. For each instance requested, data, up to a maximum of elemsize bytes, is returned in the struct s pst_fileinfo pointed to by buf . The elemcount parameter specifies the number of struct s pst_fileinfo that are available at buf to be filled in.
pstat(2) pstat(2) context. This data may change while the system is running due to administrative changes in the associated kernel tunables. Data, up to a maximum of elemsize bytes, is returned in the struct pst_ipcinfo pointed to by buf . The elemcount parameter must be 1. The index parameter must be 0. pstat_getlocality() Returns information specific to a particular locality. See the pstat_getlocality(2) manpage. pstat_getlv() Returns information specific to a particular logical volume.
pstat(2) pstat(2) Use of this function is limited to UID==0. On success, the function returns the number of DNLC entries copied. In case of failure, the value of -1 is returned and errno is set indicating the cause of the failure. pstat_getmsg() Returns information specific to a particular System V message queue. There is one instance of this context for each System V message queue on the system.
pstat(2) pstat(2) pstat_getprocvm() Returns information specific to a particular process’s address space. There is one instance of this context for each process region contained in the process’ address space. For each instance requested, data, up to a maximum of elemsize bytes, is returned in the struct pst_vm_status pointed to by buf . Only at most one instance (process region) is returned for each call to pstat_getprocvm().
pstat(2) pstat(2) On success, the function returns 1. On failure, the value of -1 is returned and errno is set indicating the cause of the failure. For AF_UNIX sockets that are opened to files, more information about the files can be obtained with the pstat_getfiledetails() call. In case of AF_UNIX sockets, the fields pst_peer_hi_nodeid and pst_peer_lo_nodeid can be used to find the peer socket by matching them with pst_hi_nodeid and pst_lo_nodeid.
pstat(2) pstat(2) Notes A wide (64 bit) version of the pstat interfaces are available for narrow (32 bit) applications to use. A narrow application could use the flag -D_PSTAT64 at compile time to switch to the wide interfaces. Using this compiler flag in a narrow application is equivalent to using the default interfaces on a wide system. Refer to the pstat header file to see how the various structures would look like when the -D_PSTAT64 flag is used.
pstat(2) pstat(2) [EINVAL] [EINVAL] [EINVAL] [EINVAL] [EINVAL] pstat_getpsem(), or pstat_getnode() calls. index is not a valid logical node id for pstat_getnode() call. elemcount is less than or equal to zero for pstat_getpathname() call. If pstat_getfiledetails() is called for a socket other than AF_UNIX family or pstat_getpathname is called for a socket. If pstat_getsocket() is called for a file which is not of type socket.
pstat(2) pstat(2) if (pstat_getstatic(&pst, sizeof(pst), (size_t)1, 0) != -1) (void)printf("page size is %d bytes\n", pst.page_size); else perror("pstat_getstatic"); } /* * Example 2: get information about all processors, first obtaining * number of processor context instances */ { struct pst_dynamic psd; struct pst_processor *psp; if (pstat_getdynamic(&psd, sizeof(psd), (size_t)1, 0) != -1) { size_t nspu = psd.
pstat(2) pstat(2) if (count == -1) perror("pstat_getproc()"); #undef BURST } /* * Example 4: Get a particular process’s information */ { struct pst_status pst; int target = (int)getppid(); if (pstat_getproc(&pst, sizeof(pst), (size_t)0, target) != -1) (void)printf("Parent started at %s", ctime(&pst.
pstat(2) pstat(2) for (i = 0; i < count; i++) { (void)printf("fd #%d\tFSid %x:%x\tfileid %d\n", psf[i].psf_fd, psf[i].psf_id.psf_fsid.psfs_id, psf[i].psf_id.psf_fsid.psfs_type, psf[i].psf_id.psf_fileid); } /* * Now go back and do it again, using the * next index after the current ’burst’ */ idx = psf[count-1].
pstat(2) pstat(2) perror("pstat_getfiledetails()"); } } else { perror("pstat_getfile2"); } close(fd); } /* * Example 9: Acquire detailed information about a stream */ main() { struct pst_fileinfo2 psf; struct pst_stream psfstream[3]; int rv, count, fd; fd = open("/dev/echo", O_RDONLY); rv = pstat_getfile2(&psf, sizeof(psf), 0, fd, getpid()); if (rv == 1) { /* * Ask for 3 structures (head + module(s) + driver).
pstat(2) */ #include #include #include #include #include #include #include #include main() { pstat(2)
pstat(2) pstat(2) psf.psf_lo_nodeid)) { printf("Success\n"); printf("The major number of the stream is %d\n", psfstream[i].val.head.pst_dev_major); if (psfstream[i].pst_extn_flags & PS_STR_XPORT_DATA) { if (psfstream[i].pst_str_xport_protocol == PS_STR_XPORT_TCP_PROTO) { printf("TCP max hiwat %d\n", psfstream[i].pst_str_xport_obufsz); printf("Local port number is %d\n", ((struct sockaddr_in *) (psfstream[i].pst_str_xport_boundaddr)) ->sin_port); printf("TCP protocol state %d\n", psfstream[i].
pstat(2) pstat(2) } else { perror("pstat_getsocket()"); } } else { perror("pstat_getfile2"); } close(fd); } /* * Example 11: Acquire pathname information about opened file */ main() { struct pst_fileinfo2 psf; char filename[20]; int rv, count, fd; fd = open("/etc/passwd", O_RDONLY); rv = pstat_getfile2(&psf, sizeof(psf), 0, fd, getpid()); if (rv == 1) { /* * Ask for pathname information. */ count = pstat_getpathname(filename, 20, &(psf.
pstat(2) pstat(2) rv = pstat_getfile2(&psf, sizeof(psf), 0, fd, target); if (rv == 1) { /* * Ask for multiple pathname information. */ count = pstat_getmpathname(mpath_buf, sizeof(struct pst_mpathnode), 20, 0, &(psf.psf_id.psf_fsid)); if (count > 0) { for (i = 0; i < count; i++) { printf("component %d: %s\n", i, mpath_buf[i].
pstat_getlocality(2) pstat_getlocality(2) NAME pstat_getlocality(), pstat_getproclocality() - returns system-wide or per-process information of a ccNUMA system SYNOPSIS #include
pstat_getlocality(2) pstat_getlocality(2) There is one instance of this context for each locality on the system. For each locality requested, data, up to a maximum of elemsize bytes, are returned in the struct pst_locality pointed to by buf. The elemcount parameter specifies the number of struct pst_locality that are available at buf to be filled in. The index parameter specifies the starting index within the context of localities.
pstat_getlocality(2) pstat_getlocality(2) uint64_t ppl_rss_weighted The number of resident pages for this process in this locality, weighted by the number of processes sharing each page. Private pages count as one page, and shared pages count as the page divided by the number of processes sharing that page. Notes These functions only return the wide (64-bit) versions of their associated structures.
pstat_getlocality(2) pstat_getlocality(2) /* * Verify arguments, call sys_locinfo(), and call pid_locinfo() * if desired.
pstat_getlocality(2) pstat_getlocality(2) /* Convert integers into strings */ pages_to_str ( pstl[i].psl_total_pages, total_str ); pages_to_str ( pstl[i].psl_free_pages, free_str ); pages_to_str ( (pstl[i].psl_total_pages pstl[i].psl_free_pages), used_str ); printf ( "%6d%6lld%7lld%6s%10s%10s%10s\n", (idx+i), pstl[i].psl_ldom_id, pstl[i].psl_physical_id, ((pstl[i].
pstat_getlocality(2) pstat_getlocality(2) */ count = pstat_getproclocality ( &ppl, sizeof(struct pst_proc_locality), pid, i ); printf ( " --- Per-process locality info for pid %d: ---\n", pid ); printf ( "%6s%10s%10s%10s%10s\n", "idx", "total", "shared", "private", "weighted" ); while ( count == 1 ) { total shared private weighted += += += += pages_to_str pages_to_str pages_to_str pages_to_str ppl.ppl_rss_total; ppl.ppl_rss_shared; ppl.ppl_rss_private; ppl.ppl_rss_weighted; ( ( ( ( ppl.
pstat_getlocality(2) pstat_getlocality(2) pages_to_str ( uint64_t pages, char *str ) { uint64_t kpg = pages*(pgsize/1024L); uint64_t mpg = kpg/1024L; uint64_t gpg = mpg/1024L; if ( gpg > 10 ) sprintf } else if ( mpg sprintf } else if ( kpg sprintf } else { sprintf } { ( > ( > ( str, "%lluG", gpg ); 10 ) { str, "%lluM", mpg ); 1 ) { str, "%lluK", kpg ); ( str, "%llu", pages ); } AUTHOR The pstat() routines were developed by HP. SEE ALSO mpctl(2), pstat(2).
ptrace(2) ptrace(2) (PA-RISC Only; TO BE OBSOLETED) NAME ptrace() - process trace SYNOPSIS #include long ptrace( int request, pid_t pid, long addr, long data, long addr2 ); Remarks ptrace() is not available on Itanium(R)-based systems. Its use is discouraged because it is targeted for removal from HP-UX. Please use ttrace(2) instead. Much of the functionality of ptrace() is highly dependent on the underlying hardware.
ptrace(2) ptrace(2) (PA-RISC Only; TO BE OBSOLETED) PT_RUAREA The word specified by the address in the addr argument in the user area of the traced process in the system’s address space (see ) is returned to the tracing process. The addresses in this area are system dependent but start at zero and the limit can be obtained from . The data and addr2 arguments are ignored.
ptrace(2) ptrace(2) (PA-RISC Only; TO BE OBSOLETED) PT_SINGLE This request causes a flag to be set so that an interrupt occurs upon the completion of one machine instruction. It then executes the same way as listed for request PT_CONTIN , effectively allowing the single-stepping of the traced process. If the processor does not provide a trace bit, this request returns an error. Whether or not the trace bit remains set after this interrupt is a function of the hardware.
ptrace(2) ptrace(2) (PA-RISC Only; TO BE OBSOLETED) context. The child does not inherit its parent’s event flags. See the ptrace_state structure description under PT_GET_PROCESS_STATE for further details. PTRACE_VFORK This event flag indicates that the traced process needs to take special action when it invokes vfork() . When set, the child process stops after marking itself as a traced process and adopting its parent’s debugger.
ptrace(2) ptrace(2) (PA-RISC Only; TO BE OBSOLETED) structure pointed to by addr argument. The addr2 argument is ignored. The request fails if the number of bytes requested is less than zero or greater than the size of the ptrace_event structure which results in errno being set to [EIO]. PT_GET_PROCESS_STATE This request is used by the calling process to access state information logged by the traced process after it has responded to an event.
ptrace(2) ptrace(2) (PA-RISC Only; TO BE OBSOLETED) Some or all of the actions associated with this system call reqnire the OWNER privilege. Processes owned by the superuser have this privilege. Processes owned by other users may have this privilege, depending on system configuration. See privileges(5) for more information about privileged access on systems that support fine-grained privileges. EXAMPLES The following example illustrates the use of some of the ptrace() calls by a tracing process.
ptrace(2) ptrace(2) (PA-RISC Only; TO BE OBSOLETED) /* * Wait for the traced child to stop after the exec system call in * response to an exec event set in its ptrace_event structure. */ if (pid != (npid = wait(&status))) /* wait failed */ printf("Parent: wait() failed with wrong status\n"); if (!WIFSTOPPED(status)) printf("Parent: invalid wait() completion\n"); /* * Child has stopped; fetch its process state and examine state * information.
ptrace(2) ptrace(2) (PA-RISC Only; TO BE OBSOLETED) [EIO] The PT_CONTIN request is being used with an invalid data signal number argument. [EIO] Attempting to write to the user area via the PT_WUAREA request. [EPERM] The specified process cannot be attached for tracing. [EPERM] The process specified in the pid argument is already being traced or refers to the calling process itself.
putmsg(2) putmsg(2) NAME putmsg(), putpmsg() - send a message on a stream SYNOPSIS #include int putmsg( int fildes, const struct strbuf const struct strbuf int flags ); int putpmsg( int fildes, const struct strbuf const struct strbuf int band, int flags ); *ctlptr, *dataptr, *ctlptr, *dataptr, DESCRIPTION The putmsg() function creates a message from a process buffer(s) and sends the message to a STREAMS file. The message may contain either a data part, a control part, or both.
putmsg(2) putmsg(2) RETURN VALUE Upon successful completion, putmsg() and putpmsg() return 0. Otherwise, they return -1 and set errno to indicate the error. ERRORS [EAGAIN] A non-priority message was specified, the O_NONBLOCK flag is set, and the stream write queue is full due to internal flow control conditions, or buffers could not be allocated for the message that was to be created. [EBADF] fildes is not a valid file descriptor open for writing.
quotactl(2) quotactl(2) NAME quotactl() - manipulate disk quotas SYNOPSIS #include int quotactl(int cmd, const char *special, uid_t uid, void *addr); DESCRIPTION quotactl() manipulates disk quotas. cmd indicates a command to be applied to the user ID uid. Parameter special is a pointer to a null-terminated string containing the path name of the block special device for the file system being manipulated. The block special device must be mounted.
quotactl(2) quotactl(2) [EINVAL] The parameters cmd and/or uid are invalid. [ESRCH] No disc quota is found for the indicated user or quotas have not been turned on for this file system. [EPERM] The call is privileged and the calling process does not have appropriate privileges. [ENODEV] The parameter special contains a type of file system that does not support quotas. Currently, quotas are supported on HFS and VxFS file systems. [ENOTBLK] The parameter special is not a block device.
read(2) read(2) NAME read(), readv(), pread() - read from file SYNOPSIS #include ssize_t read(int fildes, void *buf, size_t nbyte); ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset); #include ssize_t readv(int fildes, const struct iovec *iov, int iovcnt); DESCRIPTION The read() function attempts to read nbyte bytes from the file associated with the open file descriptor, fildes, into the buffer pointed to by buf.
read(2) read(2) For ordinary files, if the O_RSYNC |O_DSYNC file status flag is set, the calling process blocks until the data being read and all file attributes required to retrieve the data are the same as their image on disk. Writes pending on the data to be read are executed before returning to the calling process.
read(2) read(2) Upon successful completion, readv() marks for update the st_atime field of the file. The pread() function performs the same action as read() , except that it reads from a given position in the file without changing the file pointer. The first three arguments of pread() are the same as read() with the addition of a fourth argument offset for the desired position inside the file. An attempt to perform a pread() on a file that is incapable of seeking results in an error.
read(2) read(2) The readv() function may fail if: [EINVAL] The iovcnt argument was less than or equal to 0, or greater than {IOV_MAX} . The pread() function will fail and the file pointer remains unchanged if: [EINVAL] The offset argument is invalid. The value is negative. [EOVERFLOW] The file is a regular file and an attempt was made to read at or beyond the offset maximum associated with the file. [ESPIPE] fildes is associated with a pipe or FIFO.
readlink(2) readlink(2) NAME readlink() - read the contents of a symbolic link SYNOPSIS #include int readlink( const char *path, char *buf, size_t bufsiz ); DESCRIPTION The readlink() function places the contents of the symbolic link referred to by path in the buffer buf which has size bufsiz. If the number of bytes in the symbolic link is less than bufsiz, the contents of the remainder of buf are unspecified.
reboot(2) reboot(2) NAME reboot() - boot the system SYNOPSIS #include int reboot (int howto); DESCRIPTION reboot() causes the system to reboot. howto is a mask of reboot options (see ), specified as follows: RB_AUTOBOOT A file system sync is performed (unless RB_NOSYNC is set) and the processor is rebooted from the default device and file. RB_HALT The processor is simply halted. A sync of the file system is performed unless the RB_NOSYNC flag is set.
recv(2) recv(2) NAME recv(), recvfrom(), recvmsg() - receive message from a socket SYNOPSIS #include
recv(2) recv(2) the user as soon as it becomes available, and no data is discarded. See the AF_CCITT Only subsection below for a list of the exceptions to this behavior for connections in the address family AF_CCITT. recvmsg() performs the same action as recv() , but scatters the read data into the buffers specified in the msghdr structure (see _XOPEN_SOURCE_EXTENDED Only below). This structure is defined in
recv(2) recv(2) • If the remote side of a connection-based socket has reset the connection, recv() returns -1 and sets errno to [ECONNRESET]. • If an error occurs, recv() returns -1 and errno is set to indicate the error. If the O_NDELAY flag is set using fcntl() (defined in and explained in fcntl(2) and fcntl(5)), nonblocking I/O is enabled.
recv(2) recv(2) • The MSG_PEEK flag is supported; the two flags can be combined. • If a message is received that is larger than the user-controlled maximum message size, the X.25 subsystem RESETs the circuit, discards the data, and sends the out-of-band event OOB_VC_MESSAGE_TOO_BIG to the socket.
recv(2) recv(2) The flags parameter accepts a new value, MSG_WAITALL , which requests that the function block until the full amount of data requested can be returned. The function may return a smaller amount of data if a signal is caught, the connection is terminated, or an error is pending for the socket. On successful completion of recvmsg() , the msg_flags member of the message header is the bitwiseinclusive OR of all of the following flags that indicate conditions detected for the received message.
recv(2) recv(2) [ENOTCONN] Receive on a SOCK_STREAM socket that is not yet connected. [ENOTSOCK] The argument s is a valid file descriptor, but it is not a socket. [EOPNOTSUPP] The MSG_OOB flag was set for a UDP SOCK_DGRAM message-based socket, or MSG_OOB or MSG_PEEK was set for any AF_UNIX socket. The MSG_OOB flag is supported only for stream-based TCP SOCK_STREAM sockets. Neither MSG_PEEK nor MSG_OOB is supported for AF_UNIX sockets. AF_CCITT only: recv() was issued on a listen() socket.
rename(2) rename(2) NAME rename() - change the name of a file SYNOPSIS #include int rename(const char *source, const char *target); DESCRIPTION The rename() system call causes the source file to be renamed to target. If target exists, it is first removed. Both source and target must be of the same type (that is, either directories or nondirectories), and must reside on the same file system.
rename(2) rename(2) AUTHOR rename() was developed by the University of California, Berkeley. SEE ALSO open(2). STANDARDS CONFORMANCE rename() : AES, SVID3, XPG3, XPG4, FIPS 151-2, POSIX.
rmdir(2) rmdir(2) NAME rmdir() - remove a directory file SYNOPSIS #include int rmdir(const char *path); DESCRIPTION The rmdir() system call removes a directory file whose name is given by path. The directory must be empty (except for the files . and .. ) before it can be removed. RETURN VALUE rmdir() returns the following values: 0 Successful completion. -1 Failure. errno is set to indicate the error. ERRORS If rmdir() fails, errno is set to one of the following values.
rtprio(2) rtprio(2) NAME rtprio() - change or read real-time priority SYNOPSIS #include int rtprio(pid_t pid, int prio); DESCRIPTION The rtprio() system call sets or reads the real-time priority of a process. If pid is zero, it specifies the calling process; otherwise, it specifies the process ID of a process.
rtprio(2) rtprio(2) 0 to 127 The process was a real-time process. The value is the process’s former (before the call) real-time priority. RTPRIO_RTOFF -1 The process was not a real-time process. An error occurred. errno is set to indicate the error. ERRORS If rtprio() fails, errno is set to one of the following values: [EINVAL] prio is not RTPRIO_NOCHG , RTPRIO_RTOFF , or in the range 0 to 127.
rtsched(2) rtsched(2) NAME rtsched: sched_get_priority_max(), sched_get_priority_min(), sched_getparam(), sched_getscheduler(), sched_rr_get_interval(), sched_setparam(), sched_setscheduler(), sched_yield(), PRI_HPUX_TO_POSIX(), PRI_POSIX_TO_HPUX() - real-time scheduling operations SYNOPSIS #include
rtsched(2) rtsched(2) member in the param structure is any integer within the inclusive priority range for the current scheduling policy of the process specified by pid. Higher numerical values for the priority represent higher (stronger) priorities. Note that this is different from the SCHED_HPUX , SCHED_TIMESHARE, SCHED_NOAGE , and SCHED_RTPRIO scheduling policies, where higher numerical values represent lower (weaker) priorities.
rtsched(2) rtsched(2) If a process described by pid exists, the scheduling policy and scheduling parameters are set for the process whose process ID is equal to pid. If pid is zero, the scheduling policy and scheduling parameters are set for the calling process.
rtsched(2) rtsched(2) The PRI_HPUX_TO_POSIX() function returns the POSIX.4 scheduling priority corresponding to the HP-UX priority passed in the argument pri. The value of pri can be any integer. The PRI_POSIX_TO_HPUX() function returns an HP-UX process priority corresponding to the priority passed in the argument pri. The value of pri can be any integer. The HP-UX priority returned is comparable to the values returned by getpriority() (see getpriority (2)).
rtsched(2) rtsched(2) sched_rr_get_interval(), or longer, the thread becomes the tail of its thread list, and the head of that thread list is removed and made a running thread. The effect of this policy is to ensure that if there are multiple SCHED_RR threads at the same priority, one of them will not monopolize the processor.
rtsched(2) rtsched(2) SCHED_NOAGE A timeshare scheduling policy with nondecaying priorities. For processes executing under this policy, the implementation can use only priorities within the range returned by the functions sched_get_priority_max() and sched_get_priority_min() when SCHED_NOAGE is provided as the parameter. The priority range for the SCHED_NOAGE policy is a subset of the priority range supported by the SCHED_TIMESHARE policy.
rtsched(2) rtsched(2) sched_setparam() [EFAULT] The param argument points to an invalid address. [EINVAL] One or more of the requested scheduling parameters is outside the range defined for the scheduling policy of the specified pid. [ENOSYS] The function is not supported by this implementation. [EPERM] The requesting process does not have permission to set the scheduling parameters for the specified process, or does not have the RTSCHED privilege to invoke sched_setparam().
rtsched(2) rtsched(2) AUTHOR The sched_ * () functions were derived from the proposed IEEE POSIX P1003.4 standard, draft 14. PRI_HPUX_TO_POSIX() and PRI_POSIX_TO_HPUX() were developed by HP. SEE ALSO rtsched(1), rtprio(2), privileges(5). STANDARDS CONFORMANCE sched_get_priority_max(): POSIX.4 sched_get_priority_min(): POSIX.4 sched_getparam(): POSIX.4 sched_getscheduler(): POSIX.4 sched_rr_getinterval(): POSIX.4 sched_setparam(): POSIX.4 sched_setscheduler(): POSIX.4 sched_yield(): POSIX.
select(2) select(2) NAME select(), FD_CLR(), FD_ISSET(), FD_SET(), FD_ZERO() - synchronous I/O multiplexing SYNOPSIS #include int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *timeout); void FD_CLR(int fd, fd_set *fdset); int FD_ISSET(int fd, fd_set *fdset); void FD_SET(int fd, fd_set *fdset); void FD_ZERO(fd_set *fdset); For Backward Compatibility Only: (_XOPEN_SOURCE_EXTENDED not defined) #include
select(2) select(2) If the readfds, writefds, and errorfds arguments are all null pointers and the timeout argument is not a null pointer, select() blocks for the time specified, or until interrupted by a signal. If the readfds, writefds, and errorfds arguments are all null pointers and the timeout argument is a null pointer, select() blocks until interrupted by a signal. File descriptors associated with regular files always select true for ready to read, ready to write, and error conditions.
select(2) select(2) * Note that, if you are not using these many files, you are * wasting too much space. */ num_of_fds = sysconf(_SC_OPEN_MAX); s = sizeof(long); /* * howmany is a macro defined in sys/types.h */ f = (struct fd_set *)malloc(s*howmany(num_of_fds, s*8); /* * Use f wherever struct fd_set * is used. * It can be used to test num_of_fds file descriptors. */ RETURN VALUE FD_CLR() , FD_SET() , and FD_ZERO() return no value.
select(2) select(2) * for opening the terminals is not shown here. */ for (i=0; i < NTTYS; i++) { ttymask[i] = MASK(tty[i]); readmask |= ttymask[i]; } timeout.tv_sec = 5; timeout.
select(2) select(2) printf ("select timed out \n"); else for (i=0, k=0; i < NTTYS && k < NWORDS; k++) for (j=0; j < NFDBITS && i < NTTYS; j++, i++) if (ttymask[i] & readfds.fds_bits[k]) /* Read from tty[i]. The code for reading * is not shown here. */ else printf ("tty[%d] is not ready for reading \n",i); WARNINGS Check all references to signal(5) for appropriateness on systems that support sigvector() . sigvector() can affect the behavior described on this manpage.
sem_close(2) sem_close(2) NAME sem_close() - close a named POSIX semaphore SYNOPSIS #include int sem_close(sem_t *sem); DESCRIPTION sem_close() is used to close a named semaphore. A successful call to sem_close() will remove the process’s descriptor for the semaphore referenced by the specified sem_t structure sem if the semaphore is marked for removal by a call to sem_unlink() and there are no other descriptors referencing this semaphore.
sem_destroy(2) sem_destroy(2) NAME sem_destroy() - destroy an unnamed POSIX semaphore SYNOPSIS #include int sem_destroy(sem_t *sem); DESCRIPTION sem_destroy() is used to destroy an unnamed semaphore. A successful call to sem_destroy() will invalidate the unnamed semaphore referred to by sem and removes all descriptors referencing it. The semaphore should have been created by a previous call to sem_init() and there should not be any processes blocked on it.
sem_getvalue(2) sem_getvalue(2) NAME sem_getvalue() - get the value of a POSIX semaphore SYNOPSIS #include int sem_getvalue(sem_t *sem, int *sval); DESCRIPTION sem_getvalue() is used to read the value of the semaphore. The value of the semaphore specified by sem is read, at some unspecified time during the call, and then stored into sval. If the semaphore value is <= 0, at that time, the semaphore is considered unavailable.
sem_init(2) sem_init(2) NAME sem_init() - initialize an unnamed POSIX semaphore SYNOPSIS #include int sem_init(sem_t *sem, int pshared, unsigned int value); DESCRIPTION sem_init() is used to initialize an unnamed semaphore. A successful call to sem_init() will create a new unnamed semaphore referred to by sem, if one does not exist, initialize the unnamed semaphore descriptor, referred to by sem, to the non-negative value specified by value. If the unnamed semaphore already exists, i.
sem_open(2) sem_open(2) NAME sem_open() - create/open a named POSIX semaphore SYNOPSIS #include sem_t * sem_open(const char *name, int oflag, mode_t mode, unsigned int value); DESCRIPTION sem_open() is used to open or create a named semaphore. A successful call to sem_open() will create a descriptor for the semaphore specified by name. The pointer to the semaphore returned by sem_open() can be used to access the semaphore associated with name in subsequent operations.
sem_open(2) sem_open(2) [ENFILE] There are too many semaphores in the system. [ENOENT] The flag O_CREAT is not set in oflag and the named semaphore does not exist. [ENOSPC] There are insufficient resources for the creation of a new named semaphore. SEE ALSO sem_close(2), sem_post(2), sem_wait(2), sem_unlink(2), .
sem_post(2) sem_post(2) NAME sem_post() - unlock a POSIX semaphore SYNOPSIS #include int sem_post(sem_t *sem); DESCRIPTION sem_post() is used to post the semaphore referenced by sem. The calling thread will not return from its call to sem_post() unless it can either: increment the semaphore value, if there are no blocked threads on this semaphore; give the semaphore to a blocked thread, if there are any blocked threads on this semaphore; or have an error condition.
sem_unlink(2) sem_unlink(2) NAME sem_unlink() - unlink a named POSIX semaphore SYNOPSIS #include int sem_unlink(const char *name); DESCRIPTION sem_unlink() is used to unlink named semaphores. A successful call to sem_unlink() marks the semaphore, specified by name, for removal. Calling sem_unlink() does not affect processes, including the calling process, which currently have a descriptor, obtained from a call to sem_open() .
sem_wait(2) sem_wait(2) NAME sem_wait(), sem_trywait() - lock a POSIX semaphore SYNOPSIS #include int sem_wait(sem_t *sem); int sem_trywait(sem_t *sem); DESCRIPTION sem_wait() is used to lock a semaphore. The calling thread will not return from its call to sem_wait() until one of the following events occur: it successfully obtains a lock on the semaphore; it is interrupted by a signal or an error condition occurs. sem_trywait() is used to lock a semaphore, if it is available.
semctl(2) semctl(2) NAME semctl() - semaphore control operations SYNOPSIS #include int semctl(int semid, int semnum, int cmd, ... ); union semun { int val; struct semid_ds *buf; ushort *array; } arg; DESCRIPTION The semctl() system call provides a variety of semaphore control operations as specified by cmd. The fourth argument is optional and depends on the operation requested. If present, it must be of type union semun , which the application program must explicitly declare.
semctl(2) semctl(2) OWNER privilege or to the value of either sem_perm.uid or sem_perm.cuid in the data structure associated with semid. Security Restrictions Some or all of the actions associated with this system call are subject to compartmental restrictions. See compartments (5) for more information about compartmentalization on systems that support that feature. Compartmental restrictions can be overridden if the process possesses the COMMALLOWED privilege (PRIV_COMMALLOWED).
semctl(2) semctl(2) arg.array = &semarray[0]; semctl (mysemid, 0, SETALL, arg); SEE ALSO ipcrm(1), ipcs(1), semget(2), semop(2), privileges(5), glossary(9).
semget(2) semget(2) NAME semget() - get set of semaphores SYNOPSIS #include int semget(key_t key, int nsems, int semflg); DESCRIPTION semget() returns the semaphore identifier associated with key. A semaphore identifier and associated data structure and set containing nsems semaphores are created for key if one of the following is true: key is equal to IPC_PRIVATE . This call creates a new identifier, subject to available resources.
semget(2) [EINVAL] semget(2) A semaphore identifier exists for key, but the number of semaphores in the set associated with it is less than nsems, and nsems is not equal to zero. [ENOENT] A semaphore identifier does not exist for key and (semflg & IPC_CREAT ) is "false". [ENOSPC] A semaphore identifier is to be created, but the system-imposed limit on the maximum number of allowed semaphore identifiers system wide would be exceeded.
semop(2) semop(2) NAME semop(), semtimedop() - semaphore operations SYNOPSIS #include #include int semop( int semid, struct sembuf *sops, size_t nsops ); int semtimedop( int semid, struct sembuf *sops, size_t nsops, const struct timespec *timeout ); DESCRIPTION semop() is used to atomically perform an array of semaphore operations on the set of semaphores associated with the semaphore identifier specified by semid. sops is a pointer to the array of semaphoreoperation structures.
semop(2) semop(2) If semval is not equal to zero and (sem_flg & IPC_NOWAIT ) is ‘‘true’’, semop() returns immediately. If semval is not equal to zero and (sem_flg & IPC_NOWAIT ) is ‘‘false’’, semop() increments the semzcnt associated with the specified semaphore and suspends execution of the calling process until one of the following occurs: semval becomes zero, at which time the value of semzcnt associated with the specified semaphore is decremented.
semop(2) [EINVAL] semop(2) The number of individual semaphores for which the calling process requests a SEM_UNDO would exceed the limit. [ERANGE] An operation would cause a semval to overflow the system-imposed limit. [ERANGE] An operation would cause a semadj value to overflow the system-imposed limit. [EFAULT] sops points to an illegal address. The reliable detection of this error will be implementation dependent.
send(2) send(2) NAME send(), sendmsg(), sendto() - send message from a socket SYNOPSIS #include
send(2) send(2) returned, and errno is set to [EMSGSIZE]. For SOCK_DGRAM sockets, this size is fixed by the implementation (see the DEPENDENCIES section). Otherwise there is no size limit. When send() or sendto() returns a positive value, it only indicates this number of bytes have been sent to the local transport provider. It does not mean this number of bytes have been delivered to the peer socket application. A SOCK_DGRAM socket does not guarantee end-to-end delivery.
send(2) send(2) If the O_NDELAY flag is set using fcntl() (defined in and explained in fcntl(2) and fcntl(5)), nonblocking I/O is enabled. In this case, the send() request completes in one of three ways: • If there is enough space available in the system to buffer all of the data, send() completes successfully, having written out all of the data, and returns the number of bytes written.
send(2) send(2) void socklen_t int *msg_control; msg_controllen; msg_flags; /* ancillary data, see below */ /* ancillary data buffer len */ /* flags on received message */ } Obsolescent (UNIX 95) struct msghdr { void *msg_name; size_t msg_namelen; struct iovec *msg_iov; int msg_iovlen; void *msg_control; size_t msg_controllen; int msg_flags; } /* /* /* /* /* /* /* optional address */ size of address */ scatter array for data */ # of elements in msg_iov */ ancillary data, see below */ ancillary data b
send(2) send(2) asynchronously. An asynchronous error can be caused by a gateway failing to forward a datagram from this socket because the datagram exceeds the MTU of the next-hop network and the "Don’t Fragment" (DF) bit in the datagram is set. (See SO_PMTU in getsockopt(2)). [EBADF] s is not a valid file descriptor. [ECONNRESET] A connection was forcibly closed by a peer. [EDESTADDRREQ] The to parameter needs to specify a destination address for the message.
send(2) send(2) has been shut down either by the remote peer or by this side of the connection. Note that the default action for SIGPIPE , unless the process has established a signal handler for this signal, is to terminate the process. [EWOULDBLOCK] Nonblocking I/O is enabled using ioctl() FIOSNBIO request and the requested operation would block. WARNINGS IPv6 is supported on HP-UX 11i Version 1.0, with the optional IPv6 software installed.
sendfile(2) sendfile(2) NAME sendfile() - send the contents of a file through a socket SYNOPSIS #include sbsize_t sendfile(int s, int fd, off_t offset, bsize_t nbytes, const struct iovec *hdtrl, int flags); DESCRIPTION The sendfile() system call transmits the contents of a file associated with the file descriptor fd, plus an optional header and trailer buffers across a socket connection specified by s. sendfile() can be used only when the socket is in a connected state.
sendfile(2) sendfile(2) established a signal handler for this signal, is to terminate the process. [EAGAIN] Nonblocking I/O is enabled using the O_NONBLOCK flag with fcntl() , and the requested operation would block. [EWOULDBLOCK] The socket is marked non-blocking and the requested operation would block. [ENOMEM] No memory is available in the system to perform the operation. [EOPNOTSUPP] The socket is not a TCP socket.
sendfile64(2) sendfile64(2) NAME sendfile64() - send the contents of a Large File through a socket SYNOPSIS #include sbsize64_t sendfile64(int s, int fd, off64_t offset, bsize64_t nbytes, const struct iovec *hdtrl, int flags); DESCRIPTION The sendfile64() system call transmits the contents of a file (including a Large File (greater than 2GB)) associated with the file descriptor fd, plus an optional header and trailer buffers across a socket connection specified by s.
sendfile64(2) sendfile64(2) connected to its peer. [EPIPE] With SIGPIPE signal. An attempt was made to send on a socket that was connected, but the connection has been shut down either by the remote peer or by this side of the connection. Note that the default action for SIGPIPE , unless the process has established a signal handler for this signal, is to terminate the process. [EAGAIN] Nonblocking I/O is enabled using the O_NONBLOCK flag with fcntl() , and the requested operation would block.
serialize(2) serialize(2) NAME serialize() - force target process to run serially with other processes SYNOPSIS #include int serialize(int timeshare, pid_t pid); DESCRIPTION The serialize() system call is used to force the target process referenced by the pid value passed in to run serially with other processes also marked for serialization. If the value of pid is zero, then the currently running process is marked for serialization.
setacl(2) setacl(2) NAME setacl(), fsetacl() - set access control list (ACL) information SYNOPSIS #include int setacl( const char *path, int nentries, const struct acl_entry *acl ); int fsetacl( int fildes, int nentries, const struct acl_entry *acl ); DESCRIPTION setacl() sets an existing file’s access control list (ACL) or deletes optional entries from it. path points to a path name of a file.
setacl(2) setacl(2) The number of entries allowed per file (see NACLENTRIES in ) is small for space and performance reasons. User groups should be created as needed for access control purposes. Since ordinary users cannot create groups, their ability to control file access with ACLs might be somewhat limited. Security Restrictions The effective user ID of the process must match the owner of the file, or it must be the superuser or a user with the OWNER privilege to set a file’s ACL.
setacl(2) setacl(2) [ENOSYS] The function is not supported by this file system type. [ENOSPC] Not enough space on the file system. [ENFILE] System file table is full. [EDQUOT] User’s disk quota block or inode limit has been reached for this file system. EXAMPLES The following code fragment defines and sets an ACL on file ../shared which allows the file’s owner to read, write, and execute or search the file, and allows user 103, group 204 to read the file. #include #include
setaudid(2) setaudid(2) NAME setaudid() - set the audit ID (aid) for the current process SYNOPSIS #include int setaudid(aid_t audid); DESCRIPTION setaudid() sets the audit ID (aid) for the current process. This call is restricted to a user with the SELFAUDIT privilege. Security Restrictions Some or all of the actions associated with this system call require the SELFAUDIT privilege. Processes owned by the superuser will have this privilege.
setaudproc(2) setaudproc(2) NAME setaudproc() - controls process level auditing for the current process and its decendents SYNOPSIS #include int setaudproc(int aflag ); DESCRIPTION setaudproc() controls process level auditing for the current process and its decendents. It accomplishes this by setting or clearing the u_audproc flag in the u area of the calling process. When this flag is set, the system audits the process; when it is cleared, the process is not audited.
seteuid(2) seteuid(2) NAME seteuid(), setegid() - set effective user and group IDs SYNOPSIS #include int seteuid(uid_t euid); int setegid(gid_t egid); DESCRIPTION To use these functions, compile with the option -I/usr/include/ep and link in the libcext library by specifying -lcext , for example: cc -I/usr/include/ep [flag]... cfile[...] -lcext [...
setevent(2) setevent(2) NAME setevent() - set current events and system calls which are to be audited SYNOPSIS #include int setevent( const struct aud_type a_syscall[], const struct aud_event_tbl a_event[] ); DESCRIPTION setevent() sets the events and system calls to be audited. The event and system call settings in the tables pointed to by a_syscall and a_event become the current settings. This call is restricted to the users with the AUDCONTROL privilege.
setgroups(2) setgroups(2) NAME setgroups() - set group access list SYNOPSIS #include int setgroups(int ngroups, const gid_t *gidset); DESCRIPTION setgroups() sets the group access list of the current user process according to the array gidset. The parameter ngroups indicates the number of entries in the array and must be no more than NGROUPS_MAX , as defined in .
sethostname(2) sethostname(2) NAME sethostname() - set name of host cpu SYNOPSIS #include int sethostname(const char *name, size_t namelen); DESCRIPTION The sethostname() system call sets the name of the host processor to name, which has a length of namelen characters. At system boot time sethostname() is normally executed by the hostname command (see hostname(1)) in the /sbin/init.d/hostname script. Host names are limited to MAXHOSTNAMELEN characters, as defined in .
setpgid(2) setpgid(2) NAME setpgid(), setpgrp2() - set process group ID for job control SYNOPSIS #include int setpgid(pid_t pid, pid_t pgid); int setpgrp2(pid_t pid, pid_t pgid); DESCRIPTION The setpgid() and setpgrp2() system calls cause the process specified by pid to join an existing process group or create a new process group within the session of the calling process. The process group ID of the process whose process ID is pid is set to pgid.
setpgrp(2) setpgrp(2) NAME setpgrp() - set process group ID SYNOPSIS #include pid_t setpgrp(void); DESCRIPTION If the calling process is not already a session leader, setpgrp() sets the process group ID of the calling process to the process ID of the calling process. If setpgrp() creates a new session, then the new session has no controlling terminal. The setpgrp() function has no effect when the calling process is a session leader.
setpgrp3(2) setpgrp3(2) (TO BE OBSOLETED) NAME setpgrp3() - create session and set process group ID; for HP-UX 9.x compatibility. SYNOPSIS #include pid_t setpgrp3(void); DESCRIPTION If the calling process is not a process group leader, setpgrp3() creates a new session. The calling process becomes the session leader of this new session, it becomes the process group leader of a new process group, and it has no controlling terminal.
setregid(2) setregid(2) NAME setregid() - sets the real and effective group IDs SYNOPSIS #include int setregid(gid_t rgid , gid_t egid ); DESCRIPTION setregid() sets the real and effective group IDs of the calling process. Only a privileged process can set the real group ID and/or the effective group ID to any valid value.
setresuid(2) setresuid(2) NAME setresuid(), setresgid() - set real, effective, and saved user and group IDs SYNOPSIS #include int setresuid(uid_t ruid, uid_t euid, uid_t suid); int setresgid(gid_t rgid, gid_t egid, gid_t sgid); DESCRIPTION setresuid() sets the real, effective and/or saved user ID of the calling process.
setreuid(2) setreuid(2) NAME setreuid() - set real and effective user IDs SYNOPSIS #include int setreuid(uid_t ruid, uid_t euid); DESCRIPTION The setreuid() function sets the real and effective user IDs of the current process to the values specified by the ruid and euid arguments. If ruid or euid is -1, the corresponding effective or real user ID of the current process is left unchanged. A process with appropriate privileges can set either ID to any value.
setsid(2) setsid(2) NAME setsid() - create session and set process group ID SYNOPSIS #include pid_t setsid(void); DESCRIPTION If the calling process is not a process group leader, setsid() creates a new session. The calling process becomes the session leader of this new session, it becomes the process group leader of a new process group, and it has no controlling terminal. The process group ID of the calling process is set equal to the process ID of the calling process.
settimeofday(2) settimeofday(2) NAME settimeofday() - set the date and time SYNOPSIS #include int settimeofday struct timeval *tp, const struct timezone *tzp); DESCRIPTION The settimeofday() function sets the current time, expressed as seconds and microseconds since Epoch, and passed as the timeval structure pointed to by tp. The resolution of the system clock is one microsecond. Security Restrictions Setting the time of day requires the PRIV_SYSATTR privilege (SYSATTR).
settune(2) settune(2) NAME settune() - set the value of a kernel tunable parameter SYNOPSIS #include int settune(const char *tunable, uint64_t value, unsigned int flags); DESCRIPTION This function sets the value of the kernel tunable parameter named tunable to the supplied value. This new value takes effect immediately, except in the cases noted below. Some parameters cannot be changed without rebooting the OS kernel.
settune(2) settune(2) [EPERM] The caller does not have the SYSATTR privilege. [EINVAL] The specified value is not within the acceptable range for the specified parameter. [EBUSY] The value of the parameter could not be changed immediately. [ENOTSUP] The specified parameter cannot be changed without rebooting the kernel and STF_NOPENDING flag was specified. [EIO] The Kernel Registry Service was unavailable or encountered an error.
settune_txn(2) settune_txn(2) NAME settune_txn() - sets the values of kernel tunable parameters in a transaction SYNOPSIS #include int settune_txn (uint64_t version, struct ktune_context *transaction, size_t struct_size, uint64_t num_elements, char *err_buf, uint64_t *err_bufsize, uint64_t stf_flags); PARAMETERS version transaction The version parameter should always be set to SETTUNE_VERSION. The details of the changes are specified in an array of ktune_context structures.
settune_txn(2) settune_txn(2) DESCRIPTION This function is used to modify the values of a set of kernel tunable parameters at the same time. The caller needs to have the SYSATTR privilege to make this call. Changes are made to the tunables using a transactional change model using a three-phase commit where the following rules apply: • None of the changes within a transaction succeed or all of the changes within a transaction succeed. There are no in-betweens.
settune_txn(2) settune_txn(2) [EINVAL] At least one transaction rule was violated and hence none of the changes were made. [EINVAL] The changes within the transaction could not be applied immediately. One or more of the tunables within the transaction either do not support pending values or the STF_NEXTBOOT flag was not set. [EINVAL] The combination of flags specified is invalid. [EINVAL] The number of elements specified is zero.
setuid(2) setuid(2) NAME setuid(), setgid() - set user and group IDs SYNOPSIS #include int setuid(uid_t uid); int setgid(gid_t gid); DESCRIPTION setuid() sets the real-user-ID (ruid), effective-user-ID (euid), and/or saved-user-ID (suid) of the calling process. If the Security Containment product is installed, these interfaces treat a process observing CHSUBJIDENT as a privileged process. Otherwise, only processes with an euid of zero are treated as privileged processes.
setuid(2) setuid(2) setgid() was developed by AT&T. SEE ALSO exec(2), getuid(2), setresuid(2), privileges(5). STANDARDS CONFORMANCE setuid() : AES, SVID2, SVID3, XPG2, XPG3, XPG4, FIPS 151-2, POSIX.1 setgid() : AES, SVID2, SVID3, XPG2, XPG3, XPG4, FIPS 151-2, POSIX.
shm_open(2) shm_open(2) NAME shm_open() - create/open a shared memory object SYNOPSIS #include int shm_open(const char *name, int oflag, mode_t mode); DESCRIPTION The shm_open() system call establishes a connection between a shared memory object and a file descriptor. It creates an open file description that corresponds to the shared memory object and returns a file descriptor that refers to that open file description.
shm_open(2) [EMFILE] shm_open(2) Too many file descriptors are currently in use by this process. [ENAMETOOLONG] The length of the name string exceeds PATH_MAX , or the length of a (pathname) component of the name string exceeds NAME_MAX while _POSIX_NO_TRUNC is in effect. [ENFILE] Too many shared memory objects are currently open in the system. [ENOENT] The O_CREAT flag is not set in oflag and the named shared memory object does not exist.
shm_unlink(2) shm_unlink(2) NAME shm_unlink() - unlink a shared memory object SYNOPSIS #include int shm_unlink(const char *name); DESCRIPTION The shm_unlink() system call removes the name of the shared memory object named by the string pointed to by name.
shmctl(2) shmctl(2) NAME shmctl() - shared memory control operations SYNOPSIS #include int shmctl(int shmid, int cmd, struct shmid_ds *buf); DESCRIPTION The shmctl() system call provides a variety of shared memory control operations as specified by the cmd argument. cmd can have the following values: IPC_STAT Place the current value of each member of the data structure associated with shmid into the structure pointed to by buf. The contents of this structure are defined in glossary(9).
shmctl(2) shmctl(2) [EINVAL] cmd is not a valid command, or the command contains invalid parameters. [ENOMEM] cmd is equal to SHM_LOCK and there is not sufficient lockable memory to fill the request. [EPERM] cmd is equal to IPC_RMID , IPC_SET , SHM_LOCK , or SHM_UNLOCK and the effective user ID of the calling process is not equal to that of a user having appropriate privileges and it is not equal to the value of either shm_perm.uid or shm_perm.cuid in the data structure associated with shmid.
shmget(2) shmget(2) NAME shmget() - get shared memory segment SYNOPSIS #include int shmget(key_t key, size_t size, int shmflg); DESCRIPTION shmget() returns the shared memory identifier associated with key. A shared memory identifier and associated data structure and shared memory segment of size size bytes (see glossary(9)) are created for key if one of the following is true: • • key is equal to IPC_PRIVATE . This call creates a new identifier, subject to available resources.
shmget(2) shmget(2) System V Shared Memory Under Adaptive Address Space Itanium-based platforms have the capability to create two types of processes: MGAS (Mostly Global Address Space), which is the default, and MPAS (Mostly Private Address Space). See ld(1) and chatr(1). If 64-bit MPAS and 64-bit MGAS processes want to share a mapping among themselves without incurring the cost of aliasing, then (shmflg & IPC_GLOBAL ) should be "true", but (shmflg & IPC_SHARE32 ) should be "false".
shmop(2) shmop(2) NAME shmop: shmat(), shmdt() - shared memory operations SYNOPSIS #include void *shmat (int shmid, void *shmaddr , int shmflg ); int shmdt(void *shmaddr ); DESCRIPTION shmat() attaches the shared memory segment associated with the shared memory identifier specified by shmid to the data segment of the calling process. The segment is attached for reading if (shmflg & SHM_RDONLY ) is "true"; otherwise, it is attached for reading and writing.
shmop(2) shmop(2) [EACCES] Operation permission is denied to the calling process. [EINVAL] shmid is not a valid shared memory identifier, (possibly because the shared memory segment was already removed using shmctl(2) with IPC_RMID ), or the calling process is already attached to shmid. [EINVAL] shmaddr is not zero and the machine does not permit nonzero values, or shmaddr is not equal to the current attach location for the shared memory segment.
shutdown(2) shutdown(2) NAME shutdown() - shut down a socket SYNOPSIS #include int shutdown(int s, int how); DESCRIPTION The shutdown() system call is used to shut down a socket. In the case of a full-duplex connection, shutdown() can be used to either partially or fully shut down the socket, depending upon the value of how.
shutdown(2) shutdown(2) still leaving the socket descriptor open, so that the caller can receive back any data SCTP was unable to deliver. Note: SCTP is only available when the SCTP optional bundle is installed. RETURN VALUE Upon successful completion, shutdown() returns 0. Otherwise it returns -1 and errno is set to indicate the error. ERRORS shutdown() fails if any of the following conditions are encountered: [EBADF] s is not a valid file descriptor. [EINVAL] HP-UX BSD Sockets only.
sigaction(2) sigaction(2) NAME sigaction() - examine and change signal action SYNOPSIS #include int sigaction ( int sig, const struct sigaction *act, struct sigaction *oact ); DESCRIPTION The sigaction() function allows the calling process to examine and/or specify the action to be associated with a specific signal. The argument sig specifies the signal; acceptable values are defined in .
sigaction(2) sigaction(2) interruptible functions interrupted by this signal will fail with errno set to [EINTR]. SA_SIGINFO If cleared and the signal is caught, the signal-catching function will be entered as: void func(int signo); where signo is the only argument to the signal catching function. In this case the sa_handler member must be used to describe the signal catching function and the application must not modify the sa_sigaction member.
sigaction(2) sigaction(2) SA_RESETHAND is set, and then including the signal being delivered. If and when the user’s signal handler returns normally, the original signal mask is restored. Once an action is installed for a specific signal, it remains installed until another action is explicitly requested (by another call to sigaction() ), until the SA_RESETHAND flag causes resetting of the handler, or until one of the exec functions is called.
sigaction(2) sigaction(2) If, when a pending signal is delivered, there are additional signals to be queued to that signal number, the signal will remain pending. Otherwise, the pending indication will be reset. An implementation will document any condition not specified by this document under which the implementation generates signals. Signal Actions There are three types of action that can be associated with a signal: SIG_DFL , SIG_IGN or a pointer to a function.
sigaction(2) sigaction(2) • The behaviour of a process is undefined after it returns normally from a signal- catching function for a SIGBUS , SIGFPE , SIGILL , or SIGSEGV signal that was not generated by kill() or raise() . • The system will not allow a process to catch the signals SIGKILL and SIGSTOP .
sigaction(2) sigaction(2) In order to prevent errors arising from interrupting non-reentrant function calls, applications should protect calls to these functions either by blocking the appropriate signals or through the use of some programmatic semaphore. This document does not address the more general problem of synchronizing access to shared data structures.
sigaction(2) sigaction(2) STANDARDS CONFORMANCE sigaction() : AES, SVID3, XPG3, XPG4, FIPS 151-2, POSIX.
sigaltstack(2) sigaltstack(2) NAME sigaltstack() - set and/or get signal alternate stack context SYNOPSIS #include int sigaltstack(const stack_t *ss, stack_t *oss); DESCRIPTION The sigaltstack() function allows a process to define and examine the state of an alternate stack for signal handlers. Signals that have been explicitly declared to execute on the alternate stack will be delivered on the alternate stack.
sigaltstack(2) sigaltstack(2) if (sigaltstack(&sigstk,(stack_t *)0) < 0) perror("sigaltstack"); In some implementations, a signal (whether or not indicated to execute on the alternate stack) will always execute on the alternate stack if it is delivered while another signal is being caught using the alternate stack. On some implementations, stack space is automatically extended as needed. On those implementations, automatic extension is typically not available for an alternate stack.
sigblock(2) sigblock(2) (TO BE OBSOLETED) NAME sigblock() - block signals SYNOPSIS #include long sigblock(long mask); DESCRIPTION sigblock() causes the signals specified in mask to be added to the set of signals currently being blocked from delivery. Signal i is blocked if the i-th bit in mask is 1, as specified with the macro sigmask( i). It is not possible to block signals that cannot be ignored, as documented in signal(5); this restriction is silently imposed by the system.
sighold(2V) sighold(2V) NAME sigset(), sighold(), sigrelse(), sigignore(), sigpause() - signal management SYNOPSIS #include void (*sigset(int sig, void (*func)(int)))(int); int sighold(int sig); int sigrelse(int sig); int sigignore(int sig); int sigpause(int sig); DESCRIPTION The system defines a set of signals that can be delivered to a process. The set of signals is defined in signal(5), along with the meaning and side effects of each signal.
sighold(2V) sighold(2V) For the other functions, a 0 value indicates that the call succeeded. A -1 return value indicates an error occurred and errno is set to indicate the reason. ERRORS sigset() fails and the system signal action for sig is not changed if any of the following occur: [EFAULT] The func argument points to memory that is not a valid part of the process address space. Reliable detection of this error is implementation dependent.
siginterrupt(2) siginterrupt(2) NAME siginterrupt() - allow signals to interrupt functions SYNOPSIS #include int siginterrupt(int sig, int flag); DESCRIPTION The siginterrupt() function is used to change the restart behaviour when a function is interrupted by the specified signal. The function siginterrupt (sig, flag) has an effect as if implemented as: siginterrupt(int sig, int flag) { int ret; struct sigaction act; (void) sigaction(sig, NULL, &act); if (flag) act.
signal(2) signal(2) NAME signal(), sigset(), sighold(), sigrelse(), sigignore(), sigpause() - signal management SYNOPSIS #include
signal(2) signal(2) Acceptable values for sig are described in signal (5). Acceptable values for func are: SIG_DFL Execute the default action, which varies depending on the signal. The default action for most signals is to terminate the process (see signal(5)). A pending signal is discarded (whether or not it is blocked) if action is set to SIG_DFL but the default action of the pending signal is to ignore the signal (as in the case of SIGCLD ). SIG_IGN Ignore the signal.
signal(2) signal(2) If disp is not SIG_DFL , SIG_IGN , or SIG_HOLD , it must be a pointer to a function, the signal-catching handler, that is called when signal sig occurs. Before calling the signal-catching handler, the system signal action of sig is set to SIG_HOLD . Any pending signal of this type is released. This handler address is retained across calls to the other signal management functions listed here.
signal(2) signal(2) the variables. If they have not changed, call sigpause() to wait for the signal. Threads Considerations The signal disposition (such as catch/ignore/default) established by signal() is shared by all threads in the process. Blocked signal masks are maintained by each thread.
sigpending(2) sigpending(2) NAME sigpending() - examine pending signals SYNOPSIS #include int sigpending(sigset_t *set); DESCRIPTION sigpending() stores the set of signals that are blocked from delivery and are pending to the calling thread, at the location pointed to by set. RETURN VALUE Upon successful completion, sigpending() returns 0. Otherwise -1 is returned and errno is set to indicate the error.
sigprocmask(2) sigprocmask(2) NAME sigprocmask() - examine and change blocked signals SYNOPSIS #include int sigprocmask( int how, const sigset_t *set, sigset_t *oset ); DESCRIPTION The sigprocmask() function allows the calling thread to examine and/or change its signal mask. If the argument set is not a null pointer, it points to a set of signals to be used to change the currently blocked set.
sigprocmask(2) sigprocmask(2) SEE ALSO pthread_sigmask(3T), sigaction(2), sigpending(2), sigsetops(3C), sigsuspend(2), signal(5). CHANGE HISTORY First released in Issue 3. Entry included for alignment with the POSIX.1-1988 standard. STANDARDS CONFORMANCE sigprocmask(): AES, SVID3, XPG3, XPG4, FIPS 151-2, POSIX.
sigqueue(2) sigqueue(2) NAME sigqueue() - queue a signal to a process SYNOPSIS #include int sigqueue(pid_t pid, int signo, const union sigval value); DESCRIPTION The sigqueue() system call causes the signal specified by signo to be sent with the value specified by value to the process specified by pid. If signo is zero (the null signal), error checking is performed but no signal is actually sent. The null signal can be used to check the validity of pid.
sigqueue(2) sigqueue(2) [EINVAL] The value of the signo argument is an invalid or unsupported signal number. [EPERM] The process does not have the appropriate privilege to send the signal to the receiving process. [ESRCH] The process pid does not exist. SEE ALSO kill(2), sysconf(2), signal(5).
sigsend(2) sigsend(2) NAME sigsend(), sigsendset() - send a signal to a process or a group of processes SYNOPSIS #include #include int sigsend (idtype_t idtype, id_t id, int sig); int sigsendset (const procset_t *psp, int sig); DESCRIPTION The sigsend() system call sends a signal to a process or a group of processes. The process or group of processes to which the signal is to be sent is specified by id and idtype.
sigsend(2) sigsend(2) RETURN VALUE Upon successful completion, sigsend() returns a value of 0. Otherwise, it returns a value of -1 and sets errno to indicate the error. ERRORS If sigsend() fails, it sets errno (see errno(2)) to one of the following values: [EINVAL] sig is neither a valid signal number nor zero. [EINVAL] idtype is not a valid value. [EINVAL] sig is SIGKILL , idtype is P_PID , and id is 1. [ESRCH] No process can be found corresponding to that specified by id and idtype.
sigsetmask(2) sigsetmask(2) (TO BE OBSOLETED) NAME sigsetmask() - set current signal mask SYNOPSIS #include long sigsetmask(long mask); DESCRIPTION sigsetmask() sets the current signal mask (those signals that are blocked from delivery). Signal i is blocked if the i-th bit in mask, as specified with the macro sigmask( i), is a 1. It is not possible to mask signals that cannot be ignored, as documented in signal(5); this restriction is silently imposed by the system.
sigspace(2) sigspace(2) NAME sigspace() - assure sufficient signal stack space SYNOPSIS #include ssize_t sigspace(ssize_t stacksize); DESCRIPTION sigspace() requests additional stack space that is guaranteed to be available for processing signals received by the calling process. If the value of stacksize is positive, it specifies the size of a space, in bytes, which the system guarantees to be available when processing a signal.
sigspace(2) sigspace(2) LWP (Lightweight Processes) Considerations Each LWP may define an alternate signal handling stack. AUTHOR sigspace() was developed by HP. SEE ALSO sigaction(2), sigstack(2), sigvector(2), malloc(3C), setjmp(3C).
sigstack(2) sigstack(2) (TO BE OBSOLETED) NAME sigstack() - set and/or get alternate signal stack context SYNOPSIS #include int sigstack( struct sigstack *ss, struct sigstack *oss ); DESCRIPTION The sigstack() function allows the calling process to indicate to the system an area of its address space to be used for processing signals received by the process. The sigstack() function requires the application to have knowledge of the underlying system’s stack architecture.
sigstack(2) sigstack(2) (TO BE OBSOLETED) WARNINGS Do not use sigstack() in conjunction with sigspace() . The direction of stack growth is not indicated in the historical definition of struct sigstack. The only way to portably establish a stack pointer is for the application to determine stack growth direction, or to allocate a block of storage and set the stack pointer to the middle. An application can assume that the size of the signal stack is SIGSTKSZ .
sigsuspend(2) sigsuspend(2) NAME sigsuspend() - wait for a signal SYNOPSIS #include int sigsuspend(const sigset_t *sigmask); DESCRIPTION The sigsuspend() function replaces the current signal mask of the calling thread with the set of signals pointed to by sigmask and then suspends the thread until delivery of a signal whose action is either to execute a signal-catching function or to terminate the process.
sigvector(2) sigvector(2) (TO BE OBSOLETED) NAME sigvector() - software signal facilities SYNOPSIS #include int sigvector( int sig, const struct sigvec *vec, struct sigvec *ovec ); DESCRIPTION The system defines a set of signals that can be delivered to a process. The set of signals is defined in signal(5), along with the meaning and side effects of each signal.
sigvector(2) sigvector(2) (TO BE OBSOLETED) Use the Berkeley signal semantics. SV_BSDSIG SV_RESETHAND Use the semantics of signal(2). If SV_ONSTACK is set, the system uses or permits the use of the space reserved for signal processing in the sigspace() system call. If SV_BSDSIG is set, the signal is given the Berkeley semantics.
sigvector(2) sigvector(2) (TO BE OBSOLETED) Call read (slow devices) readv (slow devices) write (slow devices) writev (slow devices) open (slow devices) ioctl (slow requests) close (slow requests) wait select pause sigpause semop msgsnd msgrcv sc_syscall value SYS_READ SYS_READV SYS_WRITE SYS_WRITEV SYS_OPEN SYS_IOCTL SYS_CLOSE SYS_WAIT SYS_SELECT SYS_PAUSE SYS_SIGPAUSE SYS_SEMOP SYS_MSGSND SYS_MSGRCV These system calls are not defined if the preprocessor macro _XPG2 is defined when
sigvector(2) sigvector(2) (TO BE OBSOLETED) APPLICATION USAGE Threads Considerations The signal disposition (such as catch/ignore/default) established by sigvector() is shared by all threads in the process. Each thread maintains its own blocked signal mask. For more information regarding signals and threads, refer to signal(5). AUTHOR sigvector() was developed by HP and the University of California, Berkeley.
sigwait(2) sigwait(2) NAME sigwait(), sigwaitinfo(), sigtimedwait() - synchronously accept a signal SYNOPSIS #include int sigwait(const sigset_t *set, int *sig); int sigwaitinfo(const sigset_t *set, siginfo_t *info); int sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout); DESCRIPTION The sigwait() function atomically selects and clears a pending signal from set and returns the signal number in the location pointed to by sig.
sigwait(2) sigwait(2) Upon successful completion, sigwaitinfo() and sigtimedwait() will return the selected signal number. Otherwise a value of -1 is returned and errno is set to indicate the error. ERRORS If any of the following conditions occur, the sigwait family of routines will return the following error number: [EAGAIN] sigtimedwait() was called and no signal in the set parameter was delivered within the time interval specified by the timeout parameter.
socket(2) socket(2) NAME socket() - create an endpoint for communication SYNOPSIS #include AF_CCITT Only #include int socket(int af, int type, int protocol); DESCRIPTION The socket() system call creates an endpoint for communication and returns a descriptor. The socket descriptor returned is used in all subsequent socket-related system calls. The af parameter specifies an address family to be used to interpret addresses in later operations that specify the socket.
socket(2) socket(2) X.25 Only Socket endpoints for communication over an X.25/9000 link can be in either address family, AF_INET or AF_CCITT. If the socket is in the AF_INET family, the connection behaves as described above. TCP is used if the socket type is SOCK_STREAM. UDP is used if the socket type is SOCK_DGRAM. In both cases, Internet protocol (IP) and the X.25-to-IP interface module are used. If the socket is in the AF_CCITT address family, only the SOCK_STREAM socket type is supported.
socket(2) [EPROTOTYPE] socket(2) The type of socket and protocol do not match. [ESOCKTNOSUPPORT] The specified socket type is not supported in this address family. [ETIMEDOUT] Connection timed out. WARNINGS Not all possible errno values are documented in each socket related manpage due to dependencies from the underlying protocol modules. Refer to the errno(2) manpage for a complete list of error codes. IPv6 is supported on HP-UX 11i Version 1.0, with the optional IPv6 software installed.
socketpair(2) socketpair(2) NAME socketpair() - create a pair of connected sockets SYNOPSIS #include int socketpair(int af, int type, int protocol, int sv[2]); DESCRIPTION The socketpair() system call creates an unnamed pair of connected sockets and returns two file descriptors in sv[0] and sv[1]. The two sockets are indistinguishable. af specifies the address family. See socket(2). type specifies the semantics of communication for the socket.
sprofil(2) sprofil(2) NAME sprofil() - execution time profile for disjointed text spaces SYNOPSIS #include #include int sprofil( struct prof *profp, int profcnt, struct timeval *tvp, unsigned int flags ); DESCRIPTION sprofil() controls profiling, by which the system maintains estimates of the amount of time the calling program spends executing at various places in its address space.
sprofil(2) sprofil(2) one element. If the pc value did not fall within the range of one of the preceding descriptors, the single element specified by the pr_base field is incremented, unless that would result in overflow. Each call to sprofil() disables profiling if it was enabled and then enables profiling of the regions specified by the prof array entries. Due to variations in instruction length on different architectures, the pr_scale setting results in different entry-to-instruction ratios.
sprofil(2) sprofil(2) should always be last in the list of specified regions. Notes Profiling is turned off when an exec(2) is executed, but remains on in both child and parent processes after a fork(2). A call to profil(2) has the same effect as calling sprofil() with just one member in the profp array with the fields profcnt , tvp , and flags taking on the values of 1, NULL , and PROF_USHORT respectively. RETURN VALUE On success, sprofil() returns 0.
stat(2) stat(2) NAME stat() - get file status SYNOPSIS #include #include int stat(const char *path, struct stat *buf); DESCRIPTION The stat() function obtains information about the named file and writes it to the area pointed to by the buf argument. The path argument is a pointer to a path name of any file within the mounted file system. (All directories listed in the path name must be searchable).
stat(2) stat(2) ERRORS The stat() function will fail if: [EACCES] Search permission is denied for a component of the path prefix. [EFAULT] buf or path points to an invalid address. The reliable detection of this error is implementation dependent. [EIO] An error occurred while reading from the file system. [ELOOP] Too many symbolic links were encountered in resolving path. [ENAMETOOLONG] The length of the path argument exceeds {PATH_MAX} or a pathname component is longer than {NAME_MAX} .
statfs(2) statfs(2) NAME statfs(), fstatfs() - get file system statistics SYNOPSIS #include int statfs(const char *path, struct statfs *buf); int fstatfs(int fildes, struct statfs *buf); DESCRIPTION statfs() returns status information for a mounted file system. fstatfs() returns similar information for an open file. The parameters for the statfs() and fstatfs() functions are as follows: path is a pointer to a path name of any file within the mounted file system.
statfs(2) statfs(2) [ENOTDIR] A component of the path prefix is not a directory. [EOVERFLOW] Result would overflow one or more fields of the statfs struct. If fstatfs() fails, errno is set to one of the following values: [EBADF] fildes is not a valid open file descriptor. [EFAULT] buf points to an invalid address. [EIO] An I/O error occurs while reading from or writing to the file system. WARNINGS statfs() is deprecated and should be used only by legacy 32-bit applications.
statvfs(2) statvfs(2) NAME statvfs(), fstatvfs() - get file system information SYNOPSIS #include #include int statvfs (const char *path, struct statvfs *buf); int fstatvfs (int fildes, struct statvfs *buf); DESCRIPTION statvfs() returns information about a mounted file system. fstatvfs() returns similar information about an open file.
statvfs(2) statvfs(2) Security Restrictions The field f_bavail is the number of blocks available to non-superusers or users without the LIMIT privilege. The field f_favail is the number of file node available to non-superusers or users without the LIMIT privilege. See privileges(5) for more information about privileged access on systems that support fine-grained privileges. RETURN VALUE statvfs() and fstatvfs() return 0 upon successful completion.
stime(2) stime(2) NAME stime() - set time and date SYNOPSIS #include int stime(const time_t *tp); DESCRIPTION The stime() system call sets the system time and date. tp points to the value of time as measured in seconds from 00:00:00 on January 1, 1970, Coordinated Universal Time (UTC). Security Restrictions Some or all of the actions associated with this system call require the SYSATTR privilege. Processes owned by the superuser will have this privilege.
stream(2) stream(2) NAME stream() - STREAMS enhancements to standard system calls DESCRIPTION The open() , close() , read() , readv() , write() , writev() , ioctl() , select() , and signal() system calls are enhanced to support STREAMS. The new functionality is described below for each system call. Open Enhancements When calling open for a STREAMS device, the oflag parameter can only be constructed from the O_NONBLOCK flag values that are OR-ed with the O_RDONLY , O_WRONLY , or O_RDWR flag values.
stream(2) • stream(2) If the read mode is message-discard or message-nondiscard, the read() function returns zero, and then consumes the message. The read() function reads the data at the front of the stream head read queue. It reads both priority band and normal data. The read() function processes control messages according to the STREAMS read flags: RPROTNORM , RPROTDAT , and RPROTDIS . The default is for RPROTNORM to be set; however, the user can change this by issuing the I_SRDOPT ioctl() call.
stream(2) EAGAIN stream(2) The O_NONBLOCK flag is set, and the stream cannot accept write() data because it is flow controlled. EINVAL The write() function attempts to write to a stream that is linked below a multiplexor. ENXIO A hangup occurs on a stream while the write() function is writing to the stream. ERANGE The nbytes parameter is not within the allowable range.
stty(2) stty(2) (TO BE OBSOLETED) NAME stty(), gtty() - control terminal device (Bell Version 6 compatibility) SYNOPSIS #include int stty(int fildes, const struct sgttyb *argp); int gtty(int fildes, struct sgttyb *argp); Remarks These system calls are preserved for backward compatibility with Bell Version 6. They provide as close an approximation as possible to the old Version 6 functions. All new code should use the TCSETA and TCGETA ioctl() calls described in termio(7).
swapon(2) swapon(2) NAME swapon() - add swap space for interleaved paging/swapping SYNOPSIS #include int swapon(const char *path, ... /* [int min, int limit, int reserve,] int priority */ ); Remarks The ANSI C ", ... " construct denotes a variable length argument list whose optional and required members are given in the associated comment (/* */ ). DESCRIPTION The swapon() system call makes a block device or a directory named path available to the system for paging and swapping.
swapon(2) swapon(2) [EIO] Unable to read the device associated with path. [ELOOP] Too many symbolic links were encountered in translating the path name. [ENAMETOOLONG] The length of the specified path name exceeds PATH_MAX bytes, or the length of a component of the path name exceeds NAME_MAX bytes while _POSIX_NO_TRUNC is in effect. [ENODEV] The device associated with path does not exist. [ENOENT] The system-imposed limit on the number of swap file entries has been reached.
symlink(2) symlink(2) NAME symlink() - make symbolic link to a file SYNOPSIS #include int symlink(const char *path1, const char *path2); DESCRIPTION The symlink() function creates a symbolic link. Its name is the pathname pointed to by path2, which must be a pathname that does not name an existing file or symbolic link. The contents of the symbolic link are the string pointed to by path1. RETURN VALUE Upon successful completion, symlink() returns 0.
symlink(2) symlink(2) STANDARDS CONFORMANCE symlink() : AES, SVID3 CHANGE HISTORY First released in Issue 4, Version 2.
sync(2) sync(2) NAME sync() - update disk SYNOPSIS #include void sync(void); DESCRIPTION sync() causes all information in memory that should be on disk to be written out. This includes modified file system meta-data and delayed block I/O. It should be used by commands and programs that examine a file system, such as fsck , df , etc. It is mandatory before a shutdown. The writing, although scheduled, is not necessarily complete upon return from sync.
sysconf(2) sysconf(2) NAME sysconf(), CPU_IS_PA_RISC() - get configurable system variables SYNOPSIS #include long sysconf(int name ); int CPU_IS_PA_RISC(long cpuvers ); DESCRIPTION The sysconf() system call provides a way for applications to determine the current value of a configurable limit or variable. The name argument represents the system variable being queried.
sysconf(2) sysconf(2) CLOCKS_PER_SEC _SC_CLOCKS_PER_SEC Number of clock ticks per second for clock() (see clock(3C)). COLL_WEIGHTS_ MAX _SC_COLL_ WEIGHTS_MAX Maximum number of weights that can be assigned to an entry of the LC_COLLATE order keyword in a localedef input file (see localedef(1M)). CPU_CHIP_TYPE _SC_CPU_CHIP_TYPE Itanium-based systems: CPUID Register 3 of the Itanium-based processor identification registers.
sysconf(2) s sysconf(2) KERNEL_BITS _SC_KERNEL_BITS Returns the number of bits used by the kernel for pointer and long data types. Current values include 32 and 64. LIBC_VERSION _SC_LIBC_VERSION The version of libc that is in use by the application that is requesting this information. See below for details. LINE_MAX _SC_LINE_MAX Maximum number of bytes in an input line (including the newline) for POSIX.2 utilities.
sysconf(2) sysconf(2) POSIX_ PRIORITIZED_IO _SC_PRIORITIZED_IO Positive if the system supports POSIX message queues. POSIX_PRIORITY_ SCHEDULING _SC_PRIORITY_ SCHEDULING Positive if the system supports POSIX.4 priority scheduling -1 otherwise. POSIX_REALTIME_ SIGNALS _SC_REALTIME_ SIGNALS Positive if the system supports POSIX.4 real time signal extensions; -1 otherwise. POSIX_SAVED_IDS _SC_SAVED_IDS Positive if each process has a saved setuser-ID and a saved set-group-ID; -1 otherwise.
sysconf(2) sysconf(2) POSIX_TTY_ NAME_MAX _SC_TTY_NAME_MAX Maximum length of a terminal device name. POSIX2_C_BIND _SC_2_C_BIND Equal to 1 if the POSIX.2 C Language Bindings Option is available through the c89 utility; -1 otherwise POSIX2_C_DEV _SC_2_C_DEV Equal to 1 if the POSIX.2 C Language Development Utilities Option is supported; -1 otherwise. POSIX2_C_VERSION _SC_2_C_VERSION Current version of the POSIX.2 C Language Binding Option supported (same format as _POSIX_VERSION); -1 otherwise.
sysconf(2) SECURITY_CLASS sysconf(2) _SC_SECURITY_CLASS SEC_CLASS-NONE (No DoD security level supported). SEMAPHORES _SC_SEMAPHORES Positive if the system supports POSIX semaphores. SEM_NSEMS_MAX _SC_SEM_NSEMS_MAX Maximum number of open semaphores per process. SEM_VALUE_MAX _SC_SEM_VALUE_MAX Maximum semaphore value. SHARED_MEMORY_ OBJECTS _SC_SHARED_MEMORY_ OBJECTS Positive if the system supports POSIX shared memory.
sysconf(2) sysconf(2) _CS_XBS5_LP64_OFF64_LINTFLAGS are supported by confstr(3C). A return value of -1 indicates they are not supported. XBS5_LPBIG_ OFFBIG A _SC_XBS5_LPBIG_ OFFBIG flag which denotes whether _CS_XBS5_LPBIG_OFFBIG_CFLAGS, _CS_XBS5_LPBIG_OFFBIG_LDFLAGS, _CS_XBS5_LPBIG_OFFBIG_LIBS and _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS are supported by confstr(3C). A return value of -1 indicates they are not supported. Some of the variables in the table are defined as constants in
sysconf(2) sysconf(2) EXAMPLES The following example determines the number of times the system clock ticks each second: #include long ticks; ... ticks = sysconf(_SC_CLK_TCK); The following example determines if the current processor is an HP PA-RISC machine: #include if (CPU_IS_PA_RISC(sysconf(_SC_CPU_VERSION))) ... WARNINGS CPU_IS_PA_RISC() is implemented as a macro. Normally, the values returned from sysconf() do not change during the lifetime of the calling process.
sysfs(2) sysfs(2) NAME sysfs() - get file system type information SYNOPSIS #include int sysfs(int opcode, const char *fsname); int sysfs(int opcode, int fs_index, char *buf ); int sysfs(int opcode); DESCRIPTION sysfs is used to return information about the file system types configured in the system. The number arguments accepted by sysfs varies and depends on the opcode.
time(2) time(2) NAME time() - get time SYNOPSIS #include time_t time(time_t *tloc); DESCRIPTION time() returns the value of time in seconds since the Epoch. If tloc is not a null pointer, the return value is also assigned to the object to which it points. RETURN VALUE Upon successful completion, time() returns the value of time. Otherwise, a value of (time_t )-1 is returned and errno is set to indicate the error. ERRORS [EFAULT] time() fails if tloc points to an illegal address.
timers(2) timers(2) NAME timers: timer_create(), timer_delete(), timer_settime(), timer_gettime(), timer_getoverrun() - timer operations SYNOPSIS #include
timers(2) timers(2) If the flag TIMER_ABSTIME is set in the argument flags, timer_settime() behaves as if the time until next expiration is set equal to the difference between the absolute time specified by the it_value member of value and the current value of the clock associated with timerid. That is, the timer will expire when the clock reaches the value specified by the it_value member of value.
timers(2) timers(2) [EFAULT] The timerid or evp argument points to an invalid address. [ENOSYS] The function timer_create() is not supported by this implementation. If any of the following conditions occur, the timer_delete() function returns -1 and sets errno to the corresponding value: [EINVAL] The timer ID specified by timerid is not a valid timer ID. [ENOSYS] The function timer_delete() is not supported by this implementation.
timers(2) timers(2) perror("timer_create"); exit(1); } pause(); if (timer_delete(timerid) == -1) { perror("timer_delete"); exit(1); } return 0; } AUTHOR timer_create(), timer_delete(), timer_settime(), timer_gettime(), timer_getoverrun() were derived from the proposed IEEE POSIX P1003.4 standard, draft 14. and SEE ALSO clocks(2), getitimer(2). STANDARDS CONFORMANCE timer_create(): POSIX.4 timer_delete(): POSIX.4 timer_getoverrun(): POSIX.4 timer_gettime(): POSIX.4 timer_settime(): POSIX.
times(2) times(2) NAME times() - get process and child process times SYNOPSIS #include clock_t times(struct tms *buffer); DESCRIPTION times() fills the structure pointed to by buffer with time-accounting information. The structure defined in
truncate(2) truncate(2) NAME ftruncate(), truncate() - truncate a file to a specified length SYNOPSIS #include int ftruncate(int fildes, off_t length); int truncate(const char *path, off_t length); DESCRIPTION The ftruncate() function causes the regular file referenced by fildes to have a size of length bytes. The truncate() function causes the regular file named by path to have a size of length bytes. The effect of ftruncate() and truncate() on other types of files is unspecified.
truncate(2) truncate(2) [ENOTDIR] A component of the path prefix of path is not a directory. [EROFS] The named file resides on a read-only file system. [ETXTBSY] The file is a pure procedure (shared text) file that is being executed. AUTHOR truncate() was developed by the University of California, Berkeley. SEE ALSO ftruncate64(2), open(2), truncate64(2), . CHANGE HISTORY First released in Issue 4, Version 2.
ttrace(2) ttrace(2) NAME ttrace() - tracing facility for multithreaded processes SYNOPSIS #include int ttrace (ttreq_t request, pid_t pid, lwpid_t lwpid, uint64_t addr, uint64_t data, uint64_t addr2); Remarks While the POSIX API is defined and will not change, the present underlying system calls are not guaranteed to be compatible with future versions. Much of the functionality of this capability is highly dependent on the underlying hardware.
ttrace(2) ttrace(2) TT_PROC_RDTEXT TT_PROC_RDDATA TT_PROC_RDTEXT_NOATTACH TT_PROC_RDDATA_NOATTACH These requests allow reading from the target process text (TT_PROC_RDTEXT and TT_PROC_RDTEXT_NOATTACH) or data space (TT_PROC_RDDATA and TT_PROC_RDDATA_NOATTACH). The addr argument specifies the offset to be read from. The data argument specifies the number of bytes to read and the addr2 argument specifies where to store that data in the tracing process. The lwpid argument must be set to zero.
ttrace(2) ttrace(2) The ttevent_t data structure is as follows: typedef struct { sigset_t tte_signals; ttevents_t tte_events; tteopt_t tte_opts; } ttevent_t; The options provided in tte_opts control the behavior of child processes produced by fork() and are as follows: TTEO_NONE = TTEO_NOSTRCCHLD = TTEO_PROC_INHERIT = TTEO_LWP_INHERIT = TTEO_NORM_SIGTRAP = If TTEO_NOSTRCCHLD is set, 0x0000 0x0001 0x0002 0x0004 0x0008 the child process resulting from a fork() will not be This makes it possible for a de
ttrace(2) ttrace(2) TT_PROC_GET_FIRST_LWP_STATE This request returns the ttstate_t structure associated with the first thread on the stopped list. It resets the list pointer to the first entry in the list. The TT_PROC_GET_NEXT_LWP_STATE request (see below) provides the means to examine the state of other stopped threads. The data argument specifies the number bytes to be read from the context of the traced process into the ttstate_t data structure in the user space pointed to by addr.
ttrace(2) ttrace(2) tts_scarg is the argument list of the system call. The data associated with a TTEVT_EXEC event is as follows: typedef struct { int tts_pathlen; } ttexec_data_t; tts_pathlen is the length of the pathname of the exec() system call. The data associated with a TTEVT_FORK , TTEVT_VFORK or TTEVT_FORK_FAIL event is as follows: typedef struct { pid_t tts_fpid; lwpid_t tts_flwpid; int tts_isparent; int tts_errno; } ttfork_data_t; tts_fpid is the process ID of the other side of the fork.
ttrace(2) ttrace(2) typedef struct { lwpid_t tts_target_lwpid; } ttthread_data_t; tts_target_lwpid is the lwpid of the targeted lwp. The data associated with a TTEVT_SYSCALL event is as follows: typedef struct { int64_t tts_rval[2]; int tts_errno; } ttsyscall_data_t; The tts_rval fields are the return value(s) of the system call. tts_errno is the error status if the system call failed.
ttrace(2) ttrace(2) For this request, the lwpid argument must be set to zero. TT_PROC_SET_SCBM This request allows the debugger to pass a bitmap to the kernel indicating which system calls should cause a debugger stop. The addr argument must be set to TTSCBM_SELECT or TTSCBM_UNSELECT to indicate whether the bitmap represents a positive (meaning that the calls in the bitmap will result in a stop) or a negative (meaning that all calls except those in the bit map will result in a stop) list.
ttrace(2) ttrace(2) process at execve(2) time. (i.e. argc, argv, envp) If the target process has not overwritten these arguments, this address can be used to retrieve the full argument and environment list. Note: This request is not supported on PA-RISC versions of HP-UX. Other Requests All other requests, except non debug-related requests below, are targeted to a specific thread in the target process.
ttrace(2) ttrace(2) identical to TT_PROC_SET_IBPT_REGS and TT_PROC_SET_DBPT_REGS respectively in other respects. Note: The available breakpoint registers must be shared between process-wide breakpoints and perthread breakpoints. If a breakpoint register is currently being used as a process-wide breakpoint within the target process, it may not be used for a per-thread breakpoint in any thread of the target process. Note: These requests are not supported on PA-RISC versions of HP-UX.
ttrace(2) ttrace(2) in the context of the process, all threads in the process respond to the event. When set in the context of a thread, only the specific thread will respond to the event. Important If an event is requested by the process, the event mask of the thread is not examined. For the event mask of the thread to be significant, the process event must be be unset. Similarly, if an event option is enabled in the process, the option for the thread is not considered.
ttrace(2) ttrace(2) TTEVT_SYSCALL_RETURN This event flag indicates that the traced process will notify the debugger upon return of all system calls. The traced process will also provide the following information: the system call number, its number of arguments and all its arguments, its return value and its error return in the ttstate_t structure.
ttrace(2) Reg __gp __r1 __r2-__r3 __r4-__r7 __ret0-__ret3 __r8-__r11 __sp __r12 __tp __r13 __r14-__r31 __r32-__r127 t 492 ttrace(2) Interruption Syscall Notes R/W R/W Global Pointer R/W R/W Reads as 0 R/W Scratch registers R/W R/W R/W R/W R/W R/W R/W Reads as 0 See TT_LWP_RDRSEBS TT_LWP_WRRSEBS and __f2-__f5 __f6-__f15 __f16-__f31 __f32-__f127 R/W R/W R/W R/W __pr R/W __p1-__p5 __p6-__p11 __p12-__p63 __b0/__rp __b1-__b5 __b6-__b7 __um __ar_kr7 __ar7 __ar_rsc __ar16 __ar_bsp __ar17
ttrace(2) ttrace(2) __ar_ec __ar66 __reason R/W R/W R R __ip __cfm __ed __cr_isr __cr17 __cr_iipa __cr22 R/W R/W R/W R/W R/W Reads as 0 0 == syscall context, non-zero == interruption context Low-order 2-bits indicate slot number. Current Frame Marker corresponding to __ip May not be set if not previously set. R R On PA-RISC, the words at offset addr in the save_state structure are returned to the calling process. The data argument is the size of the read.
ttrace(2) t ttrace(2) [EINVAL] An offset in the save_state structure is not word-aligned. [EINVAL] An invalid register is targeted by TT_LWP_WUREGS. [EINVAL] The core file argument to a TT_PROC_CORE request exists and is not a regular file. [ENOENT] The directory portion of the core file argument to a TT_PROC_CORE request does not exist. [EINVAL] The size argument to a TT_PROC_GET_PATHNAME is larger than MAXPATHLEN . [EACCES] The pid argument to the TT_PROC_ATTACH is the pid of the invoker.
ttrace(2) ttrace(2) static char * gen_name(_exp_t *base, int val) { _exp_t *rp; for (rp = base; rp->name; rp++) { if (val == rp->val) { return rp->name; } } return NULL; } static char * ev_name(ttevents_t ev) { char buf[32]; char *p; static _exp_t tab[] = { TTEVT_SIGNAL, "SIGNAL", TTEVT_FORK, "FORK", TTEVT_EXEC, "EXEC", TTEVT_EXIT, "EXIT", TTEVT_VFORK, "VFORK", TTEVT_SYSCALL, "SYSCALL", TTEVT_SYSCALL_ENTRY, "SYSCALL_ENTRY", TTEVT_LWP_CREATE, "LWP_CREATE", TTEVT_LWP_TERMINATE, "LWP_TERMINATE", TTEVT_LWP_EX
ttrace(2) ttrace(2) TT_PROC_DETACH, TT_PROC_CONTINUE, TT_PROC_SET_EVENT_MASK, TT_PROC_GET_FIRST_LWP_STATE, TT_PROC_GET_NEXT_LWP_STATE, TT_LWP_CONTINUE, -1, "PROC_DETACH", "PROC_CONTINUE", "PROC_SET_EVENT_MASK", "PROC_GET_FIRST_LWP_STATE", "PROC_GET_NEXT_LWP_STATE", "LWP_CONTINUE", NULL }; rval = ttrace(req, pid, lwpid, addr, data, addr2); if (rval == -1) { p = gen_name(tab, req); errexit(p ? p : "ttrace"); } } static void show_syscall(const ttstate_t *stp) { int nargs = stp->tts_scnargs; ttevents_t evt
ttrace(2) ttrace(2) (void) printf("("); for (i = 0, argp = stp->tts_scarg; i < nargs; i++, argp++) { (void) printf("%#llx", *argp); (void) printf("%s", (i == nargs - 1) ? "" : ", "); } (void) printf(")"); } if (stp->tts_event == TTEVT_SYSCALL_RETURN) { if (stp->tts_u.tts_syscall.tts_errno) { (void) printf(" ERR%d", stp->tts_u.tts_syscall.tts_errno); } else { (void) printf(" = %lld", stp->tts_u.tts_syscall.tts_rval[0]); } } else { (void) printf(" ...
ttrace(2) ttrace(2) ev.tte_events = TTEVT_SYSCALL|TTEVT_EXEC|TTEVT_EXIT; ev.tte_opts = TTEO_NONE; if (pid) { siginfo_t si; dottrace(TT_PROC_ATTACH, pid, 0, TT_DETACH_ON_EXIT, TT_VERSION, 0); if (waitid(P_PID, pid, &si, WEXITED|WSTOPPED) < 0 || si.si_pid != pid || si.
ttrace(2) ttrace(2) int rval = ttrace_wait(pid, 0, TTRACE_WAITOK, &st, sizeof st); if (rval < 0) { errexit("ttrace_wait"); } show_event(&st); if (st.tts_event == TTEVT_EXIT) { break; } dottrace(TT_LWP_CONTINUE, pid, st.tts_lwpid, TT_NOPC, st.tts_event == TTEVT_SIGNAL ? (uint64_t) st.tts_u.tts_signal.
ttrace_wait(2) ttrace_wait(2) NAME ttrace_wait() - wait for ttrace event SYNOPSIS int ttrace_wait(pid_t pid, lwpid_t lwpid, ttwopt_t option, ttstate_t *tsp, size_t size); DESCRIPTION The ttrace_wait() system call provides a means to wait for a ttrace() event to occur. A tracing process (debugger) will normally invoke ttrace_wait() after a process or any of its threads has been set running. ttrace_wait() synchronizes tracing requests directed at threads within the traced process.
ttrace_wait(2) ttrace_wait(2) SEE ALSO ttrace(2), wait(2).
tuneinfo2(2) tuneinfo2(2) NAME tuneinfo2() - retrieve detailed information about kernel tunable parameters SYNOPSIS #include int tuneinfo2(int version, const char *tunable, tuneinfo2_t *buf, size_t *bufsize); TUNEINFO_STRING(tunable, string) DESCRIPTION This function provides detailed information about one or all kernel tunable parameters. If a particular parameter is of interest, specify it by name in tunable.
tuneinfo2(2) tuneinfo2(2) any restrictions on the tunable value based on transient factors like the current usage pattern of the system. For example, the maximum value returned for maxfiles (the number of files a process may have open) will be no greater than the current value of nfile (the number of files the system may have open). However, the minimum value returned for maxfiles may very well be less than the number of files that some existing process has open.
tuneinfo2(2) tuneinfo2(2) } /* 2. Allocate that much space: */ buf = (tuneinfo2_t *)malloc(bufsize); if (buf == NULL) { ... } /* 3. Query the data: */ count = tuneinfo2(TUNEINFO_VERSION, NULL, buf, &bufsize); if (count < 0) { ... } /* 4.
ualarm(2) ualarm(2) NAME ualarm() - set the interval timer SYNOPSIS #include useconds_t ualarm(useconds_t useconds, useconds_t interval); DESCRIPTION The ualarm() function causes the SIGALRM signal to be generated for the calling process after the number of real-time microseconds specified by the useconds argument has elapsed. When the interval argument is non-zero, repeated timeout notification occurs with a period in microseconds specified by the interval argument.
ulimit(2) ulimit(2) NAME ulimit() - get and set user limits SYNOPSIS #include long ulimit(int cmd, ...); Remarks The ANSI C ", ... " construct denotes a variable length argument list whose optional [or required] members are given in the associated comment (/* */ ). DESCRIPTION ulimit() provides for control over process limits. Available values for cmd are: UL_GETFSIZE Get the file size limit of the process. The limit is in units of 512-byte blocks and is inherited by child processes.
umask(2) umask(2) NAME umask() - set and get file creation mask SYNOPSIS #include mode_t umask(mode_t cmask); DESCRIPTION umask() sets the process’s file mode creation mask to umask() and returns the previous value of the mask. Only the file access permission bits of the masks are used. The bits set in cmask specify which permission bits to turn off in the mode of the created file, and should be specified using the symbolic values defined in stat(5).
umount(2) umount(2) NAME umount() - unmount a file system SYNOPSIS #include int umount(const char *name); DESCRIPTION umount() requests that a previously mounted file system contained on the block special device identified by name be unmounted. name is a pointer to a path name. After unmounting the file system, the directory upon which the file system was mounted reverts to its ordinary interpretation.
uname(2) uname(2) NAME uname(), setuname() - get information about computer system; set node name (system name) SYNOPSIS #include int uname(struct utsname *name); int setuname(const char *name, size_t namelen); DESCRIPTION uname() The uname() system call places information identifying the computer system in the utsname structure pointed to by name. The utsname structure, defined in
uname(2) uname(2) ERRORS If uname() or setuname() fails, errno is set to one of the following values. [EFAULT] name points to an illegal address. The reliable detection of this error is implementation dependent. [EPERM] setuname() was attempted by a process lacking appropriate privileges. WARNINGS uname() returns one of two versions of the utsname structure. • HP-UX compatible version (compatible with all OS versions and updates).
unlink(2) unlink(2) NAME unlink() - remove directory entry; delete file SYNOPSIS #include int unlink(const char *path); DESCRIPTION The unlink() system call removes the directory entry named by the path name pointed to by path. When all links to a file have been removed and no process has the file open, the space occupied by the file is freed and the file ceases to exist.
unlink(2) unlink(2) SEE ALSO rm(1), close(2), link(2), open(2), rmdir(2), remove(3C). STANDARDS CONFORMANCE unlink() : AES, SVID2, SVID3, XPG2, XPG3, XPG4, FIPS 151-2, POSIX.
usleep(2) usleep(2) NAME usleep() - suspend execution for an interval SYNOPSIS #include int usleep(useconds_t useconds); DESCRIPTION The usleep() function will cause the calling thread to be suspended from execution until either the number of real-time microseconds specified by the argument useconds has elapsed, or a signal is delivered to the calling thread and its action is to invoke a signal-catching function or to terminate the process.
ustat(2) ustat(2) NAME ustat() - get mounted file system statistics SYNOPSIS #include int ustat(dev_t dev, struct ustat *buf); DESCRIPTION The ustat() system call returns information about a mounted file system. dev is a device number identifying a device containing a mounted file system. buf is a pointer to a ustat structure (defined in
utime(2) utime(2) NAME utime() - set file access and modification times SYNOPSIS #include int utime(const char *path, const struct utimbuf *times); DESCRIPTION The utime() system call sets the access and modification times of the file to which the path argument refers. If times is a NULL pointer, the access and modification times of the file are set to the current time. A process must be the owner of the file or have write permission on the file to use utime() in this manner.
utime(2) utime(2) See privileges(5) for more information about privileged access on systems that support fine-grained privileges. SEE ALSO touch(1), stat(2), privileges(5). STANDARDS CONFORMANCE utime() : AES, SVID2, SVID3, XPG2, XPG3, XPG4, FIPS 151-2, POSIX.
utimes(2) utimes(2) NAME utimes() - set file access and modification times SYNOPSIS #include int utimes(const char *path, const struct timeval times[2]); DESCRIPTION The utimes() function sets the access and modification times of the file pointed to by the path argument to the value of the times argument. The utimes() function allows time specifications accurate to the microsecond. For utimes() , the times argument is an array of timeval structures.
vfork(2) vfork(2) NAME vfork() - spawn new process, share virtual memory SYNOPSIS #include pid_t vfork(void); Remarks vfork() is a higher performance version of fork() that is provided on some systems where a performance advantage can be attained. If the calling process is multi-threaded, the newly created child process will only contain one thread. This one thread will be a copy of the thread calling vfork() .
vfork(2) vfork(2) function, for example), it is likely that the parent and child processes will be killed with signal SIGSEGV or SIGBUS . In the [vfork ,exec ] window, a call to signal() (see signal(2) that installs a catching function can affect handling of the signal by the parent. The parent is not affected if the handling is being set to SIG_DFL or SIG_IGN , or if either sigaction() or sigvector() is used (see sigaction(2) and sigvector (2)).
vfsmount(2) vfsmount(2) (TO BE OBSOLETED) NAME vfsmount() - mount a file system SYNOPSIS #include int vfsmount(int type, const char *dir, int flags, caddr_t data); Remarks This routine is included only for compatibility with past releases. It works only with UFS (HFS), NFS, and CDFS file systems. For maximum portability and improved functionality, new applications should use the mount() system call (see mount(2)). DESCRIPTION The vfsmount() system call attaches a file system to a directory.
vfsmount(2) vfsmount(2) (TO BE OBSOLETED) MS_BEHIND and MS_DELAY are mutually exclusive. MS_NO_FSASYNC Specify that rigorous posting of file system metadata is to be used. This is the default. MS_FSASYNC Specify that relaxed posting of file system metadata is to be used. This may lead to better performance for certain applications; but there is increased potential for data loss in case of a crash. MS_FSASYNC and MS_NO_FSASYNC are mutually exclusive.
vfsmount(2) vfsmount(2) (TO BE OBSOLETED) [EINVAL] A value in a field of data is out of proper range. See mountd(1M), getfh(2), and inet(7F) for more information. WARNINGS The mount command (see mount(1M)) is preferred over vfsmount() because mount supports all mounting options that are available from vfsmount() directly, plus mount also maintains the /etc/mnttab file which lists what file systems are mounted. Obsolescent Interfaces vfsmount() is to be obsoleted at a future date.
wait(2) wait(2) NAME wait(), waitpid() - wait for child process to stop or terminate SYNOPSIS #include #include pid_t wait(int *stat_loc); pid_t waitpid(pid_t pid, int *stat_loc, int options); DESCRIPTION The wait() and waitpid() functions shall obtain status information pertaining to one of the caller’s child processes. Various options permit status information to be obtained for child processes that have terminated or stopped.
wait(2) wait(2) If the calling process has the signal action SA_NOCLDWAIT set or has SIGCHLD set to SIG_IGN , and the process has no unwaited-for children that were transformed into zombie processes, the calling thread shall block until all of the children of the process containing the calling thread terminate, and wait() and waitpid() shall fail and set errno to [ECHILD].
wait(2) wait(2) If the information pointed to by stat_loc was stored by a call to waitpid() that did not specify the WUNTRACED flag and specified the WCONTINUED lag, or by a call to the wait() function, exactly one of the WIFEXITED(*stat_loc), macros WIFSIGNALED(*stat_loc), and WIFCONTINUED(*stat_loc) shall evaluate to a non-zero value. There may be additional implementation-dependent circumstances under which wait() , waitpid() report status.
wait(2) wait(2) wait() and waitpid() will not return until all threads in the process have reached the desired state. For example, the wait() , waitpid() calls will not return until all threads have terminated. If the WUNTRACED or WCONTINUED options are specified for the waitpid() call, it will not return until all threads have stopped or continued, respectively. SEE ALSO Exit conditions ($?) in sh(1); exec(2), exit(2), fork(2), pause(2), ptrace(2), signal(5), wait3(2), waitid(2),
wait3(2) wait3(2) NAME wait3(), wait4() - wait for child process to change state SYNOPSIS #include pid_t wait3 (int *stat_loc, int options, struct rusage *resource_usage); pid_t wait4 (pid_t pid, int *stat_loc, int options, struct rusage *resource_usage); DESCRIPTION The wait3() and wait4() functions allow the calling process to obtain various status information for a caller’s child process based on the options specified.
wait3(2) wait3(2) The resource_usage argument points to the resource utilization structure. APPLICATION USAGE Threads Considerations In a multi-threaded application, only the calling thread is suspended by wait3() and wait4() . The wait3() and wait4() functions will not return until all threads in the process have reached the desired state. For example, wait3() and wait4() will not return until all threads have terminated.
waitid(2) waitid(2) NAME waitid() - wait for child process to change state SYNOPSIS #include int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options); DESCRIPTION The waitid() function suspends the calling process until one of its children changes state. It records the current state of a child in the structure pointed to by infop. If a child process changed state prior to the call to waitid() , waitid() returns immediately.
write(2) write(2) NAME write(), writev(), pwrite() - write on a file SYNOPSIS #include ssize_t write(int fildes, const void *buf, size_t nbyte); ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset); #include ssize_t writev(int fildes, const struct iovec *iov, int iovcnt); DESCRIPTION The write() function attempts to write nbyte bytes from the buffer pointed to by buf to the file associated with the open file descriptor, fildes.
write(2) write(2) • The system-dependent maximum number of bytes that a pipe or FIFO can store is PIPSIZ as defined in . • The minimum value of PIPSIZ on any HP-UX system is 8192. When writing a pipe with the O_NDELAY or O_NONBLOCK file status flag set, the following apply: • If nbyte is less than or equal to PIPSIZ and sufficient room exists in the pipe or FIFO , the write() succeeds and returns the number of bytes written.
write(2) write(2) performed by the owner or a user who has appropriate privileges, the behavior is file-system dependent. In some file systems, the write clears the set-user-ID, set-group-ID, and sticky bits on a nondirectory file. In other file systems, the write does not clear these bits on a nondirectory file. For directories, write() does not clear the set-user-ID, set-group-ID, and sticky bits.
write(2) write(2) [ENOSPC] Not enough space on the file system. The process does not possess the limit effective privilege to override this restriction. [ENXIO] A request was made of a non-existent device, or the request was outside the capabilities of the device. [ENXIO] A hangup occurred on the STREAM being written to. [EPIPE] An attempt is made to write to a pipe or FIFO that is not open for reading by any process, or that only has one end open. A SIGPIPE signal will also be sent to the process.
write(2) write(2) STANDARDS CONFORMANCE write() : AES, SVID2, SVID3, XPG2, XPG3, XPG4, FIPS 151-2, POSIX.1, POSIX.
