Skip site navigation (1)Skip section navigation (2)

FreeBSD Man Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
home | help
Intro(2)							      Intro(2)

NAME
       Intro, intro - introduction to system calls and error numbers

SYNOPSIS
       #include	<errno.h>

       A  system call is a C library function that requests a service from the
       system, such as getting the time	of day.	This request is	 performed  in
       the  kernel.  The  library  interface  executes a trap into the kernel,
       which actually executes the system call code.

       Most system calls return	one or more error conditions. An error	condi-
       tion  is	 indicated  by	an  otherwise impossible return	value. This is
       almost always -1	or the null pointer; the individual descriptions spec-
       ify the details.	An error number	is also	made available in the external
       variable	errno, which is	not cleared on successful calls, so it	should
       be tested only after an error has been indicated.

       In the case of multithreaded applications, the -mt option must be spec-
       ified on	the command line at compilation	time  (see  threads(5)).  When
       the  -mt	 option	 is specified, errno becomes a macro that enables each
       thread to have its own errno. This errno	macro can be  used  on	either
       side of the assignment as though	it were	a variable.

       An error	value listed as	"will fail" describes a	condition whose	detec-
       tion and	reporting is mandatory for an implementation that conforms  to
       the  Single  UNIX  Specification	(SUS). An application can rely on this
       condition being detected	and reported. An error value  listed  as  "may
       fail"  describes	a condition whose detection and	reporting is  optional
       for an implementation that conforms to the SUS. An  application	should
       not  rely  this	condition  being detected and reported.	An application
       that relies on such behavior cannot be assured to  be  portable	across
       conforming  implementations.  If	more than one error occurs in process-
       ing a function call, any	one  of	 the  possible	errors	might  may  be
       returned,  as the order of detection is undefined. See standards(5) for
       additional information regarding	the Single UNIX	Specification.

       Each system call	description attempts to	list all possible  error  num-
       bers.  The  following is	a complete list	of the error numbers and their
       names as	defined	in <errno.h>.

       1 EPERM		       Lacking appropriate privileges

			       Typically this error indicates  an  attempt  to
			       modify  a  file in some way forbidden except to
			       its  owner  or  an   appropriately   privileged
			       process.	  It  is also returned for attempts by
			       ordinary	users to  perform  operations  allowed
			       only to processes with certain privileges.

			       The manual pages	for individual functions docu-
			       ment which privileges are  needed  to  override
			       the restriction.

       2 ENOENT		       No such file or directory

			       A  file	name  is specified and the file	should
			       exist but doesn't, or one of the	directories in
			       a path name does	not exist.

       3 ESRCH		       No such process,	LWP, or	thread

			       No process can be found in the system that cor-
			       responds	to  the	 specified  PID,  LWPID_t,  or
			       thread_t.

       4 EINTR		       Interrupted system call

			       An  asynchronous	 signal	 (such as interrupt or
			       quit), which the	user  has  elected  to	catch,
			       occurred	 during	 a system service function. If
			       execution is resumed after processing the  sig-
			       nal, it will appear as if the interrupted func-
			       tion call returned this error condition.

			       In a multithreaded application,	EINTR  may  be
			       returned	 whenever  another thread or LWP calls
			       fork(2).

       5 EIO		       I/O error

			       Some physical  I/O  error  has  occurred.  This
			       error may in some cases occur on	a call follow-
			       ing the one to which it actually	applies.

       6 ENXIO		       No such device or address

			       I/O on a	special	file  refers  to  a  subdevice
			       which  does  not	 exist,	 or  exists beyond the
			       limit of	the device. It may  also  occur	 when,
			       for  example, a tape drive is not on-line or no
			       disk pack is loaded on a	drive.

       7 E2BIG		       Arg list	too long

			       An argument list	longer than  ARG_MAX bytes  is
			       presented  to  a	 member	 of the	exec family of
			       functions  (see	exec(2)).  The	argument  list
			       limit  is  the  sum of the size of the argument
			       list  plus  the	size  of   the	 environment's
			       exported	shell variables.

       8 ENOEXEC	       Exec format error

			       A  request  is  made  to	 execute a file	which,
			       although	it has	the  appropriate  permissions,
			       does   not  start  with	a  valid  format  (see
			       a.out(4)).

       9 EBADF		       Bad file	number

			       Either a	file  descriptor  refers  to  no  open
			       file,  or  a  read(2) (respectively,  write(2))
			       request is made to a file that is open only for
			       writing (respectively, reading).

       10 ECHILD	       No child	processes

			       A  wait(3C)  function  call  was	 executed by a
			       process that had	no  existing  or  unwaited-for
			       child processes.

       11 EAGAIN	       No more processes, or no	more LWPs

			       For   example,	the  fork(2)  function	failed
			       because the system's process table is  full  or
			       the user	is not allowed to create any more pro-
			       cesses, or a call failed	 because  of  insuffi-
			       cient memory or swap space.

       12 ENOMEM	       Not enough space

			       During	execution  of  brk()  or  sbrk()  (see
			       brk(2)),	or one of the  exec  family  of	 func-
			       tions,  a  program asks for more	space than the
			       system is able to supply. This is not a	tempo-
			       rary  condition;	 the  maximum size is a	system
			       parameter. On some architectures, the error may
			       also  occur  if	the arrangement	of text, data,
			       and stack segments requires too many  segmenta-
			       tion  registers,	or if there is not enough swap
			       space during the	fork(2)	function.

       13 EACCES	       Permission denied

			       An attempt was made to access a file in	a  way
			       forbidden by the	protection system.

			       The manual pages	for individual functions docu-
			       ment which privileges are  needed  to  override
			       the protection system.

       14 EFAULT	       Bad address

			       The  system  encountered	 a  hardware  fault in
			       attempting to use an argument of	a routine. For
			       example,	  errno	 potentially  may  be  set  to
			       EFAULT any time a routine that takes a  pointer
			       argument	 is  passed an invalid address,	if the
			       system can detect the condition.	 Because  sys-
			       tems  will  differ in their ability to reliably
			       detect a	bad address, on	 some  implementations
			       passing	a bad address to a routine will	result
			       in undefined behavior.

       15 ENOTBLK	       Block device required

			       A non-block device or file was mentioned	 where
			       a  block	device was required (for example, in a
			       call to the mount(2) function).

       16 EBUSY		       Device busy

			       An attempt was made to mount a device that  was
			       already	mounted	 or  an	 attempt  was  made to
			       unmount a device	on which there	is  an	active
			       file  (open file, current directory, mounted-on
			       file, active text segment). It will also	 occur
			       if an attempt is	made to	enable accounting when
			       it is already enabled.  The device or  resource
			       is  currently unavailable.   EBUSY is also used
			       by mutexes,  semaphores,	 condition  variables,
			       and  r/w	 locks,	 to  indicate  that  a lock is
			       held,  and by the  processor  control  function
			       P_ONLINE.

       17 EEXIST	       File exists

			       An  existing  file was mentioned	in an inappro-
			       priate  context	(for  example,	call  to   the
			       link(2) function).

       18 EXDEV		       Cross-device link

			       A  hard	link  to  a file on another device was
			       attempted.

       19 ENODEV	       No such device

			       An attempt was made to apply  an	 inappropriate
			       operation  to  a	 device	 (for  example,	read a
			       write-only device).

       20 ENOTDIR	       Not a directory

			       A non-directory was specified where a directory
			       is  required  (for example, in a	path prefix or
			       as an argument to the chdir(2) function).

       21 EISDIR	       Is a directory

			       An attempt was made to write on a directory.

       22 EINVAL	       Invalid argument

			       An invalid argument was specified (for example,
			       unmounting a non-mounted	device), mentioning an
			       undefined signal	in a call to the signal(3C) or
			       kill(2)	function,  or an unsupported operation
			       related to extended attributes was attempted.

       23 ENFILE	       File table overflow

			       The  system  file  table	 is  full  (that   is,
			       SYS_OPEN	 files	are  open,  and	temporarily no
			       more files can be opened).

       24 EMFILE	       Too many	open files

			       No process may have more	 than	OPEN_MAX  file
			       descriptors open	at a time.

       25 ENOTTY	       Inappropriate ioctl for device

			       A call was made to the ioctl(2) function	speci-
			       fying a file that is not	 a  special  character
			       device.

       26 ETXTBSY	       Text file busy (obsolete)

			       An attempt was made to execute a	pure-procedure
			       program that is	currently  open	 for  writing.
			       Also  an	 attempt  to  open  for	 writing or to
			       remove a	pure-procedure program that  is	 being
			       executed. (This message is obsolete.)

       27 EFBIG		       File too	large

			       The  size of the	file exceeded the limit	speci-
			       fied by resource	 RLIMIT_FSIZEn;	the file  size
			       exceeds	the maximum supported by the file sys-
			       tem; or the file	size exceeds the offset	 maxi-
			       mum  of	the  file  descriptor.	 See  the File
			       Descriptor subsection of	the  DEFINITIONS  sec-
			       tion below.

       28 ENOSPC	       No space	left on	device

			       While  writing  an  ordinary file or creating a
			       directory entry,	there is no free space left on
			       the  device. In the fcntl(2) function, the set-
			       ting or removing	of record locks	on a file can-
			       not  be	accomplished because there are no more
			       record entries left on the system.

       29 ESPIPE	       Illegal seek

			       A call to the  lseek(2) function	was issued  to
			       a pipe.

       30 EROFS		       Read-only file system

			       An  attempt  to	modify a file or directory was
			       made on a device	mounted	read-only.

       31 EMLINK	       Too many	links

			       An attempt to make more than the	maximum	number
			       of links,  LINK_MAX, to a file.

       32 EPIPE		       Broken pipe

			       A write on a pipe for which there is no process
			       to read the data. This condition	normally  gen-
			       erates  a  signal; the error is returned	if the
			       signal is ignored.

       33 EDOM		       Math argument out of domain of function

			       The argument of a function in the math  package
			       (3M) is out of the domain of the	function.

       34 ERANGE	       Math result not representable

			       The  value  of  a  function in the math package
			       (3M) is not representable within	machine	preci-
			       sion.

       35 ENOMSG	       No message of desired type

			       An  attempt  was	made to	receive	a message of a
			       type that does not exist	on the specified  mes-
			       sage queue (see msgrcv(2)).

       36 EIDRM		       Identifier removed

			       This error is returned to processes that	resume
			       execution due to	the removal of	an  identifier
			       from   the   file   system's  name  space  (see
			       msgctl(2), semctl(2), and shmctl(2)).

       37 ECHRNG	       Channel number out of range

       38 EL2NSYNC	       Level 2 not synchronized

       39 EL3HLT	       Level 3 halted

       40 EL3RST	       Level 3 reset

       41 ELNRNG	       Link number out of range

       42 EUNATCH	       Protocol	driver not attached

       43 ENOCSI	       No CSI structure	available

       44 EL2HLT	       Level 2 halted

       45 EDEADLK	       Deadlock	condition

			       A deadlock situation was	detected and  avoided.
			       This error pertains to file and record locking,
			       and also	applies	to mutexes, semaphores,	condi-
			       tion variables, and r/w locks.

       46 ENOLCK	       No record locks available

			       There  are  no more locks available. The	system
			       lock table is full (see fcntl(2)).

       47 ECANCELED	       Operation canceled

			       The associated asynchronous operation was  can-
			       celed before completion.

       48 ENOTSUP	       Not supported

			       This  version  of  the  system does not support
			       this feature. Future versions of	the system may
			       provide support.

       49 EDQUOT	       Disc quota exceeded

			       A write(2) to an	ordinary file, the creation of
			       a directory or symbolic link, or	 the  creation
			       of  a directory entry failed because the	user's
			       quota of	disk  blocks  was  exhausted,  or  the
			       allocation of an	inode for a newly created file
			       failed because the user's quota of  inodes  was
			       exhausted.

       58-59		       Reserved

       60 ENOSTR	       Device not a stream

			       A  putmsg(2) or getmsg(2) call was attempted on
			       a file descriptor that is not a STREAMS device.

       61 ENODATA	       No data available

       62 ETIME		       Timer expired

			       The  timer  set for a STREAMS ioctl(2) call has
			       expired.	The cause of this error	is device-spe-
			       cific  and  could indicate either a hardware or
			       software	failure, or perhaps  a	timeout	 value
			       that  is	 too short for the specific operation.
			       The status of the ioctl() operation is indeter-
			       minate.	This  is  also returned	in the case of
			       _lwp_cond_timedwait(2) or cond_timedwait(3C).

       63 ENOSR		       Out of stream resources

			       During  a   STREAMS  open(2)  call,  either  no
			       STREAMS	queues	or no STREAMS head data	struc-
			       tures were available. This is a temporary  con-
			       dition;	one  may recover from it if other pro-
			       cesses release resources.

       65 ENOPKG	       Package not installed

			       This error occurs when users attempt to	use  a
			       call   from   a	package	 which	has  not  been
			       installed.

       71 EPROTO	       Protocol	error

			       Some protocol error occurred.   This  error  is
			       device-specific,	 but  is generally not related
			       to a hardware failure.

       77 EBADMSG	       Not a data message

			       During  a  read(2),  getmsg(2),	 or   ioctl(2)
			       I_RECVFD	 call  to  a STREAMS device, something
			       has come	to the head of the queue that can  not
			       be  processed.	That  something	depends	on the
			       call:

			       read():	       control information  or	passed
					       file descriptor.

			       getmsg():       passed file descriptor.

			       ioctl():	       control or data information.

       78 ENAMETOOLONG	       File name too long

			       The   length   of  the  path  argument  exceeds
			       PATH_MAX, or the	length	of  a  path  component
			       exceeds	NAME_MAX  while	 _POSIX_NO_TRUNC is in
			       effect; see limits.h(3HEAD).

       79 EOVERFLOW	       Value too large for defined data	type.

       80 ENOTUNIQ	       Name not	unique on network

			       Given log name not unique.

       81 EBADFD	       File descriptor in bad state

			       Either a	file descriptor	refers to no open file
			       or  a  read  request was	made to	a file that is
			       open only for writing.

       82 EREMCHG	       Remote address changed

       83 ELIBACC	       Cannot access a needed share library

			       Trying to exec an a.out that requires a	static
			       shared  library	and  the static	shared library
			       does not	exist or the user does not  have  per-
			       mission to use it.

       84 ELIBBAD	       Accessing a corrupted shared library

			       Trying  to exec an a.out	that requires a	static
			       shared library (to be linked in)	and exec could
			       not  load the static shared library. The	static
			       shared library is probably corrupted.

       85 ELIBSCN	       .lib section in a.out corrupted

			       Trying to exec an a.out that requires a	static
			       shared  library (to be linked in) and there was
			       erroneous data  in  the	.lib  section  of  the
			       a.out.  The .lib	section	tells exec what	static
			       shared libraries	are needed. The	a.out is prob-
			       ably corrupted.

       86 ELIBMAX	       Attempting  to  link  in	 more shared libraries
			       than system limit

			       Trying to exec  an  a.out  that	requires  more
			       static  shared libraries	than is	allowed	on the
			       current configuration of	the system. See

       87 ELIBEXEC	       Cannot exec a shared library directly

			       Attempting to exec a shared library directly.

       88 EILSEQ	       Error 88

			       Illegal byte sequence. Handle multiple  charac-
			       ters as a single	character.

       89 ENOSYS	       Operation not applicable

       90 ELOOP		       Number  of  symbolic  links  encountered	during
			       path name traversal exceeds MAXSYMLINKS

       91 ESTART	       Restartable system call

			       Interrupted system call should be restarted.

       92 ESTRPIPE	       If pipe/FIFO, don't sleep in stream head

			       Streams pipe error (not externally visible).

       93 ENOTEMPTY	       Directory not empty

       94 EUSERS	       Too many	users

       95 ENOTSOCK	       Socket operation	on non-socket

       96 EDESTADDRREQ	       Destination address required

			       A required address was omitted from  an	opera-
			       tion   on  a  transport	endpoint.  Destination
			       address required.

       97 EMGSIZE	       Message too long

			       A message sent  on  a  transport	 provider  was
			       larger than the internal	message	buffer or some
			       other network limit.

       98 EPROTOTYPE	       Protocol	wrong type for socket

			       A protocol was specified	that does not  support
			       the semantics of	the socket type	requested.

       99 ENOPROTOOPT	       Protocol	not available

			       A  bad  option or level was specified when get-
			       ting or setting options for a protocol.

       120 EPROTONOSUPPORT     Protocol	not supported

			       The protocol has	not been configured  into  the
			       system or no implementation for it exists.

       121 ESOCKTNOSUPPORT     Socket type not supported

			       The  support  for  the socket type has not been
			       configured into the system or no	implementation
			       for it exists.

       122 EOPNOTSUPP	       Operation not supported on transport endpoint

			       For example, trying to accept a connection on a
			       datagram	transport endpoint.

       123 EPFNOSUPPORT	       Protocol	family not supported

			       The protocol family  has	 not  been  configured
			       into  the  system  or  no implementation	for it
			       exists. Used for	the Internet protocols.

       124 EAFNOSUPPORT	       Address family not supported by protocol	family

			       An address incompatible with the	requested pro-
			       tocol was used.

       125 EADDRINUSE	       Address already in use

			       User attempted to use  an  address  already  in
			       use, and	the protocol does not allow this.

       126 EADDRNOTAVAIL       Cannot assign requested address

			       Results	from  an attempt to create a transport
			       endpoint	with an	address	 not  on  the  current
			       machine.

       127 ENETDOWN	       Network is down

			       Operation encountered a dead network.

       128 ENETUNREACH	       Network is unreachable

			       Operation  was attempted	to an unreachable net-
			       work.

       129 ENETRESET	       Network dropped connection because of reset

			       The host	you  were  connected  to  crashed  and
			       rebooted.

       130 ECONNABORTED	       Software	caused connection abort

			       A  connection abort was caused internal to your
			       host machine.

       131 ECONNRESET	       Connection reset	by peer

			       A connection was	forcibly  closed  by  a	 peer.
			       This  normally  results from a loss of the con-
			       nection on the remote host due to a timeout  or
			       a reboot.

       132 ENOBUFS	       No buffer space available

			       An  operation  on  a transport endpoint or pipe
			       was not performed  because  the	system	lacked
			       sufficient  buffer space	or because a queue was
			       full.

       133 EISCONN	       Transport endpoint is already connected

			       A connect request was made on an	 already  con-
			       nected	  transport	endpoint;     or,    a
			       sendto(3SOCKET) or sendmsg(3SOCKET) request  on
			       a connected transport endpoint specified	a des-
			       tination	when already connected.

       134 ENOTCONN	       Transport endpoint is not connected

			       A request to send or receive  data  was	disal-
			       lowed  because  the  transport  endpoint	is not
			       connected and  (when  sending  a	 datagram)  no
			       address was supplied.

       143 ESHUTDOWN	       Cannot send after transport endpoint shutdown

			       A  request  to send data	was disallowed because
			       the transport endpoint has  already  been  shut
			       down.

       144 ETOOMANYREFS	       Too many	references: cannot splice

       145 ETIMEDOUT	       Connection timed	out

			       A   connect(3SOCKET)  or	 send(3SOCKET) request
			       failed because  the  connected  party  did  not
			       properly	 respond  after	a period of time; or a
			       write(2)	or  fsync(3C) request failed because a
			       file is on an  NFS file system mounted with the
			       soft option.

       146 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 remote host.

       147 EHOSTDOWN	       Host is down

			       A  transport  provider operation	failed because
			       the destination host was	down.

       148 EHOSTUNREACH	       No route	to host

			       A transport provider operation was attempted to
			       an unreachable host.

       149 EALREADY	       Operation already in progress

			       An  operation  was  attempted on	a non-blocking
			       object  that  already  had  an	operation   in
			       progress.

       150 EINPROGRESS	       Operation now in	progress

			       An operation that takes a long time to complete
			       (such as	a connect()) was attempted on  a  non-
			       blocking	object.

       151 ESTALE	       Stale NFS file handle

DEFINITIONS
   Background Process Group
       Any  process  group that	is not the foreground process group  of	a ses-
       sion that has established a connection with a controlling terminal.

   Controlling Process
       A session leader	that established a connection to a controlling	termi-
       nal.

   Controlling Terminal
       A  terminal  that is associated with a session.	Each session may have,
       at most,	one controlling	terminal associated with it and	a  controlling
       terminal	 may  be  associated  with  only  one  session.	 Certain input
       sequences from the controlling terminal cause signals  to  be  sent  to
       process groups in the session associated	with the controlling terminal;
       see termio(7I).

   Directory
       Directories organize files into a hierarchical system where directories
       are the nodes in	the hierarchy. A directory is a	file that catalogs the
       list  of	 files,	 including  directories	 (sub-directories),  that  are
       directly	 beneath  it in	the hierarchy. Entries in a directory file are
       called links. A link associates a file identifier with a	 filename.  By
       convention,  a  directory  contains  at least two links,	. (dot)	and ..
       (dot-dot). The link called dot refers to	 the  directory	 itself	 while
       dot-dot	refers	to  its	parent directory. The root directory, which is
       the top-most node of the	hierarchy, has itself as its parent directory.
       The pathname of the root	directory is / and the parent directory	of the
       root directory is /.

   Downstream
       In a stream, the	direction from stream head to driver.

   Driver
       In a stream, the	driver provides	the interface between peripheral hard-
       ware  and  the  stream. A driver	can also be a pseudo-driver, such as a
       multiplexor or log driver (see log(7D)),	which is not associated	with a
       hardware	device.

   Effective User ID and Effective Group ID
       An  active  process  has	an effective user ID and an effective group ID
       that are	used to	determine file access  permissions  (see  below).  The
       effective  user	ID  and	 effective group ID are	equal to the process's
       real user ID and	real group ID, respectively, unless the	process	or one
       of  its	ancestors evolved from a file that had the  set-user-ID	bit or
       set-group-ID bit	set  (see exec(2)).

   File	Access Permissions
       Read, write, and	execute/search permissions for a file are granted to a
       process if one or more of the following are true:

	 o  The	 effective  user  ID of	the process matches the	user ID	of the
	    owner of the file and the appropriate access bit  of  the  "owner"
	    portion (0700) of the file mode is set.

	 o  The	 effective  user  ID of	the process does not match the user ID
	    of the owner of the	file, but either the effective group ID	or one
	    of the supplementary group	IDs of the process match the group  ID
	    of the file	and the	appropriate access bit of the "group"  portion
	    (0070) of the file mode is set.

	 o  The	effective user ID of the process does not match	the user ID of
	    the	owner of the file, and neither the effective group ID nor  any
	    of	the  supplementary group IDs of	the process match the group ID
	    of the file, but the appropriate access bit	of the "other" portion
	    (0007) of the file mode is set.

	 o  The	 read,	write,	or execute mode	bit is not set but the process
	    has	the discretionary file access override privilege for the  cor-
	    responding	 mode  bit:  {PRIV_FILE_DAC_READ}  for	the  read  bit
	    {PRIV_FILE_DAC_WRITE} for the  write  bit,	{PRIV_FILE_DAC_SEARCH}
	    for	 the  execute  bit on directories, and {PRIV_FILE_DAC_EXECUTE}
	    for	the executable bit on plain files.

       Otherwise, the corresponding permissions	are denied.

   File	Descriptor
       A file descriptor is a small integer used to perform I/O	on a file. The
       value of	a file descriptor is from 0 to (NOFILES-1). A process may have
       no more than  NOFILES file descriptors
	open simultaneously. A file descriptor is returned by  calls  such  as
       open(2)	or  pipe(2).   The  file  descriptor is	used as	an argument by
       calls such as read(2), write(2),	ioctl(2), and close(2).

       Each file descriptor has	a corresponding	offset	maximum.  For  regular
       files that were opened without setting the O_LARGEFILE flag, the	offset
       maximum is 2 Gbyte - 1 byte (2**31 -1 bytes). For  regular  files  that
       were  opened with the O_LARGEFILE flag set, the offset maximum is 2**63
       -1 bytes.

   File	Name
       Names consisting	of 1 to	 NAME_MAX characters may be used  to  name  an
       ordinary	file, special file or directory.

       These  characters  may be selected from the set of all character	values
       excluding \0 (null) and the ASCII code for / (slash).

       Note that it is generally unwise	to use *, ?, [,	or ] as	part  of  file
       names  because  of  the special meaning attached	to these characters by
       the shell (see sh(1), csh(1), and ksh(1)). Although permitted, the  use
       of unprintable characters in file names should be avoided.

       A  file	name  is  sometimes  referred to as a pathname component.  The
       interpretation of a pathname component is dependent on  the  values  of
       NAME_MAX	 and   _POSIX_NO_TRUNC associated with the path	prefix of that
       component.  If any pathname  component  is  longer  than	 NAME_MAX  and
       _POSIX_NO_TRUNC is in effect for	the path prefix	of that	component (see
       fpathconf(2) and	limits.h(3HEAD)), it shall be considered an error con-
       dition in  that implementation. Otherwise, the implementation shall use
       the first NAME_MAX bytes	of the pathname	component.

   Foreground Process Group
       Each session that has established a connection with a controlling  ter-
       minal  will  distinguish	 one process group of the session as the fore-
       ground process group of the controlling terminal.  This group has  cer-
       tain privileges when accessing its controlling terminal that are	denied
       to background process groups.

   {IOV_MAX}
       Maximum number of entries in a struct iovec array.

   {LIMIT}
       The braces notation, {LIMIT}, is	used to	denote a magnitude  limitation
       imposed	by  the	 implementation.  This	indicates a value which	may be
       defined by a header file	(without the braces), or the actual value  may
       be  obtained  at	 runtime  by a call to the configuration inquiry path-
       conf(2) with the	name argument  _PC_LIMIT.

   Masks
       The file	mode creation mask of the process used during any create func-
       tion  calls  to turn off	permission bits	in the mode argument supplied.
       Bit positions that are set in umask(cmask) are cleared in the  mode  of
       the created file.

   Message
       In a stream, one	or more	blocks of data or information, with associated
       STREAMS control structures. Messages can	be of several  defined	types,
       which  identify	the  message  contents.	Messages are the only means of
       transferring data and communicating within a stream.

   Message Queue
       In a stream, a linked list of messages awaiting processing by a	module
       or driver.

   Message Queue Identifier
       A message queue identifier (msqid) is a unique positive integer created
       by a msgget(2) call. Each msqid has a message queue and a  data	struc-
       ture  associated	with it. The data structure is referred	to as msqid_ds
       and contains the	following members:

	      struct	 ipc_perm msg_perm;
	      struct	 msg *msg_first;
	      struct	 msg *msg_last;
	      ulong_t	 msg_cbytes;
	      ulong_t	 msg_qnum;
	      ulong_t	 msg_qbytes;
	      pid_t	 msg_lspid;
	      pid_t	 msg_lrpid;
	      time_t	 msg_stime;
	      time_t	 msg_rtime;
	      time_t	 msg_ctime;

       The following are descriptions of the msqid_ds structure	members:

       The msg_perm member is an ipc_perm structure that specifies the message
       operation permission (see below). This structure	includes the following
       members:

       uid_t	cuid;	/* creator user	id */
       gid_t	cgid;	/* creator group id */
       uid_t	uid;	/* user	id */
       gid_t	gid;	/* group id */
       mode_t	mode;	/* r/w permission */
       ulong_t	seq;	/* slot	usage sequence # */
       key_t	key;	/* key */

       The *msg_first member is	a pointer to the first message on the queue.

       The *msg_last member is a pointer to the	last message on	the queue.

       The msg_cbytes member is	the current number of bytes on the queue.

       The msg_qnum member is the number of messages currently on the queue.

       The msg_qbytes member is	the maximum number of  bytes  allowed  on  the
       queue.

       The  msg_lspid  member  is the process ID of the	last process that per-
       formed a	msgsnd() operation.

       The msg_lrpid member is the process id of the last  process  that  per-
       formed a	msgrcv() operation.

       The msg_stime member is the time	of the last msgsnd() operation.

       The msg_rtime member is the time	of the last msgrcv() operation.

       The  msg_ctime  member  is the time of the last msgctl()	operation that
       changed a member	of the above structure.

   Message Operation Permissions
       In the msgctl(2), msgget(2), msgrcv(2), and msgsnd(2) function descrip-
       tions,  the  permission	required for an	operation is given as {token},
       where token is the type of permission needed, interpreted as follows:

       00400   READ by user
       00200   WRITE by	user
       00040   READ by group
       00020   WRITE by	group
       00004   READ by others
       00002   WRITE by	others

       Read and	write permissions for a	msqid are granted to a process if  one
       or more of the following	are true:

	 o  The	  {PRIV_IPC_DAC_READ}  or  {PRIV_IPC_DAC_WRITE}	 privilege  is
	    present in the effective set.

	 o  The	effective user ID of  the  process  matches  msg_perm.cuid  or
	    msg_perm.uid  in  the data structure associated with msqid and the
	    appropriate	bit of the "user" portion (0600) of  msg_perm.mode  is
	    set.

	 o  Any	 group	ID  in	the  process credentials from the set (cr_gid,
	    cr_groups) matches msg_perm.cgid or	msg_perm.gid and the appropri-
	    ate	bit of the "group" portion (060) of msg_perm.mode is set.

	 o  The	 appropriate bit of the	"other"	portion	(006) of msg_perm.mode
	    is set."

       Otherwise, the corresponding permissions	are denied.

   Module
       A module	is an entity containing	processing routines for	input and out-
       put  data.  It  always  exists  in  the middle of a stream, between the
       stream's	head and a driver. A module is the STREAMS counterpart to  the
       commands	 in  a	shell pipeline except that a module contains a pair of
       functions  which	 allow	independent  bidirectional   (downstream   and
       upstream) data flow and processing.

   Multiplexor
       A  multiplexor  is a driver that	allows streams associated with several
       user processes to be connected to a single driver, or  several  drivers
       to  be  connected  to a single user process. STREAMS does not provide a
       general multiplexing driver, but	does provide the facilities  for  con-
       structing   them	 and  for  connecting  multiplexed  configurations  of
       streams.

   Offset Maximum
       An offset maximum is an attribute of an open  file  description	repre-
       senting the largest value that can be used as a file offset.

   Orphaned Process Group
       A  process  group  in  which the	parent of every	member in the group is
       either itself a member of the group, or is not a	member of the  process
       group's session.

   Path	Name
       A  path	name  is  a  null-terminated character string starting with an
       optional	slash (/), followed by zero or more directory names  separated
       by slashes, optionally followed by a file name.

       If  a path name begins with a slash, the	path search begins at the root
       directory. Otherwise, the search	begins from the	current	working	direc-
       tory.

       A slash by itself names the root	directory.

       Unless  specifically stated otherwise, the null path name is treated as
       if it named a non-existent file.

   Privileged User
       Solaris software	implements a set  of  privileges  that	provide	 fine-
       grained	control	 over the actions of processes.	The possession of of a
       certain privilege allows	 a  process  to	 perform  a  specific  set  of
       restricted  operations. Prior to	the Solaris 10 release,	a process run-
       ning with uid 0 was granted all privileges. See privileges(5)  for  the
       semantics and the degree	of backward compatibility awarded to processes
       with an effective uid of	0.

   Process ID
       Each process in the system is uniquely identified during	 its  lifetime
       by  a  positive	integer	 called	 a  process ID.	A process ID cannot be
       reused by the system until the process lifetime,	 process  group	 life-
       time,  and  session lifetime ends for any process ID, process group ID,
       and session ID equal to that process ID.	There  are  threads  within  a
       process	with  thread  IDs  thread_t and	LWPID_t. These threads are not
       visible to the outside process.

   Parent Process ID
       A new process is	created	by a currently active process  (see  fork(2)).
       The parent process ID of	a process is the process ID of its creator.

   Privilege
       Having  appropriate  privilege  means having the	capability to override
       system restrictions.

   Process Group
       Each process in the system is a member of a process group that is iden-
       tified  by a process group ID.  Any process that	is not a process group
       leader may create a new	process	 group	and  become  its  leader.  Any
       process	that  is  not  a  process  group  leader  may join an existing
       process group that shares the same session as  the  process.   A	 newly
       created process joins the process group of its parent.

   Process Group Leader
       A process group leader is a process whose process ID is the same	as its
       process group ID.

   Process Group ID
       Each active process is a	member of a process group and is identified by
       a  positive integer called the process group ID.	This ID	is the process
       ID of the group leader. This grouping permits the signaling of  related
       processes (see kill(2)).

   Process Lifetime
       A  process lifetime begins when the process is forked and ends after it
       exits, when  its	 termination  has  been	 acknowledged  by  its	parent
       process.	See wait(3C).

   Process Group Lifetime
       A  process  group  lifetime begins when the process group is created by
       its process group leader, and  ends  when  the  lifetime	 of  the  last
       process	in the group ends or when the last process in the group	leaves
       the group.

   Processor Set ID
       The processors in a system may be divided into subsets, known  as  pro-
       cessor sets. A process bound to one of these sets will run only on pro-
       cessors in that set, and	the processors in the set  will	 normally  run
       only  processes	that have been bound to	the set. Each active processor
       set is identified by a positive integer.	See pset_create(2).

   Read	Queue
       In a stream, the	message	queue in a module or  driver  containing  mes-
       sages moving upstream.

   Real	User ID	and Real Group ID
       Each user allowed on the	system is  identified by a positive integer (0
       to  MAXUID) called a real user ID.

       Each user is also a member of a group. The group	 is  identified	 by  a
       positive	integer	called the real	group ID.

       An  active process has a	real user ID and real group ID that are	set to
       the real	user ID	and real group ID, respectively, of the	user responsi-
       ble for the creation of the process.

   Root	Directory and Current Working Directory
       Each process has	associated with	it a concept of	a root directory and a
       current working directory  for  the  purpose  of	 resolving  path  name
       searches.  The  root directory of a process need	not be the root	direc-
       tory of the root	file system.

   Saved Resource Limits
       Saved resource limits is	an attribute of	a process that	provides  some
       flexibility  in	the  handling  of  unrepresentable resource limits, as
       described in the	exec family of functions and setrlimit(2).

   Saved User ID and Saved Group ID
       The saved user ID and saved group ID are	the values of  the   effective
       user  ID	 and effective group ID	just after an exec of a	file whose set
       user or set group file mode bit has been	set (see exec(2)).

   Semaphore Identifier
       A semaphore identifier (semid) is a unique positive  integer created by
       a  semget(2) call. Each semid has a set of semaphores and a data	struc-
       ture associated with it.	The data structure is referred to as  semid_ds
       and contains the	following members:

       struct ipc_perm	 sem_perm;    /* operation permission struct */
       struct sem	 *sem_base;   /* ptr to	first semaphore	in set */
       ushort_t		 sem_nsems;   /* number	of sems	in set */
       time_t		 sem_otime;   /* last operation	time */
       time_t		 sem_ctime;   /* last change time */
				      /* Times measured	in secs	since */
				      /* 00:00:00 GMT, Jan. 1, 1970 */

       The following are descriptions of the semid_ds structure	members:

       The  sem_perm  member is	an ipc_perm structure that specifies the sema-
       phore operation permission (see below).	This  structure	 includes  the
       following members:

       uid_t	 uid;	 /* user id */
       gid_t	 gid;	 /* group id */
       uid_t	 cuid;	 /* creator user id */
       gid_t	 cgid;	 /* creator group id */
       mode_t	 mode;	 /* r/a	permission */
       ulong_t	 seq;	 /* slot usage sequence	number */
       key_t	 key;	 /* key	*/

       The  sem_nsems  member is equal to the number of	semaphores in the set.
       Each semaphore in the  set  is  referenced  by  a  nonnegative  integer
       referred	to as a	sem_num. sem_num values	run sequentially from 0	to the
       value of	sem_nsems minus	1.

       The sem_otime member is the time	of the last semop(2) operation.

       The sem_ctime member is the time	of the last semctl(2)  operation  that
       changed a member	of the above structure.

       A  semaphore is a data structure	called sem that	contains the following
       members:

       ushort_t	  semval;    /*	semaphore value	*/
       pid_t	  sempid;    /*	pid of last operation  */
       ushort_t	  semncnt;   /*	# awaiting semval > cval */
       ushort_t	  semzcnt;   /*	# awaiting semval = 0 */

       The following are descriptions of the sem structure members:

	      The semval member	is a non-negative integer that is  the	actual
	      value of the semaphore.
	      The sempid member	is equal to the	process	ID of the last process
	      that performed a semaphore operation on this semaphore.
	      The semncnt member is a count of the number  of  processes  that
	      are  currently  suspended	 awaiting  this	 semaphore's semval to
	      become greater than its current value.
	      The semzcnt member is a count of the number  of  processes  that
	      are  currently  suspended	 awaiting  this	 semaphore's semval to
	      become 0.

   Semaphore Operation Permissions
       In the semop(2) and semctl(2)  function	descriptions,  the  permission
       required	 for an	operation is given as {token}, where token is the type
       of permission needed interpreted	as follows:

       00400	   READ	by user
       00200   ALTER by	user
       00040   READ by group
       00020   ALTER by	group
       00004   READ by others
       00002   ALTER by	others

       Read and	alter permissions for a	semid are granted to a process if  one
       or more of the following	are true:

	 o  The	  {PRIV_IPC_DAC_READ}  or  {PRIV_IPC_DAC_WRITE}	 privilege  is
	    present in the effective set.

	 o  The	effective user ID of  the  process  matches  sem_perm.cuid  or
	    sem_perm.uid  in  the data structure associated with semid and the
	    appropriate	bit of the "user" portion (0600) of  sem_perm.mode  is
	    set.

	 o  The	 effective  group  ID  of the process matches sem_perm.cgid or
	    sem_perm.gid and the appropriate bit of the	"group"	portion	 (060)
	    of sem_perm.mode is	set.

	 o  The	 appropriate  bit of the "other" portion (06) of sem_perm.mode
	    is set.

       Otherwise, the corresponding permissions	are denied.

   Session
       A session is a group of processes identified by a common	 ID  called  a
       session	 ID,  capable  of establishing a connection with a controlling
       terminal.   Any process that is not a process group leader may create a
       new session  and	process	group, becoming	the session leader of the ses-
       sion and	process	group leader of	the process group.   A	newly  created
       process joins the session of its	creator.

   Session ID
       Each  session  in the system is uniquely	identified during its lifetime
       by  a positive integer called a session ID, the process ID of its  ses-
       sion leader.

   Session Leader
       A  session  leader  is  a  process  whose session ID is the same	as its
       process and process group ID.

   Session Lifetime
       A session lifetime begins when the session is created  by  its  session
       leader, and ends	when the lifetime of the last process that is a	member
       of the session ends, or when the	last process that is a member  in  the
       session leaves the session.

   Shared Memory Identifier
       A shared	memory identifier (shmid) is a unique positive integer created
       by a shmget(2) call. Each shmid has a segment of	memory (referred to as
       a shared	memory segment)	and a data structure associated	with it. (Note
       that these shared memory	segments must be  explicitly  removed  by  the
       user  after  the	last reference to them is removed.) The	data structure
       is referred to as shmid_ds and contains the following members:

       struct ipc_perm	 shm_perm;     /* operation permission struct */
       size_t		 shm_segsz;    /* size of segment */
       struct anon_map	 *shm_amp;     /* ptr to region	structure */
       char		 pad[4];       /* for swap compatibility */
       pid_t		 shm_lpid;     /* pid of last operation	*/
       pid_t		 shm_cpid;     /* creator pid */
       shmatt_t		 shm_nattch;   /* number of current attaches */
       ulong_t		 shm_cnattch;  /* used only for	shminfo	*/
       time_t		 shm_atime;    /* last attach time */
       time_t		 shm_dtime;    /* last detach time */
       time_t		 shm_ctime;    /* last change time */
				       /* Times	measured in secs since */
				       /* 00:00:00 GMT,	Jan. 1,	1970 */

       The following are descriptions of the shmid_ds structure	members:

	      The shm_perm member is an	ipc_perm structure that	specifies  the
	      shared  memory  operation	permission (see	below).	This structure
	      includes the following members:

	      uid_t	cuid;	/* creator user	id */
	      gid_t	cgid;	/* creator group id */
	      uid_t	uid;	/* user	id */
	      gid_t	gid;	/* group id */
	      mode_t	mode;	/* r/w permission */
	      ulong_t	seq;	/* slot	usage sequence # */
	      key_t	key;	/* key */

	      The shm_segsz member specifies the size  of  the	shared	memory
	      segment in bytes.
	      The  shm_cpid  member is the process ID of the process that cre-
	      ated the shared memory identifier.
	      The shm_lpid member is the process ID of the last	 process  that
	      performed	a shmat() or shmdt() operation (see shmop(2)).
	      The  shm_nattch member is	the number of processes	that currently
	      have this	segment	attached.
	      The shm_atime member is the time of the last  shmat()  operation
	      (see shmop(2)).
	      The  shm_dtime  member is	the time of the	last shmdt() operation
	      (see shmop(2)).
	      The shm_ctime member is the time of the last shmctl(2) operation
	      that changed one of the members of the above structure.

   Shared Memory Operation Permissions
       In the shmctl(2), shmat(), and shmdt() (see shmop(2)) function descrip-
       tions, the permission required for an operation is  given  as  {token},
       where token is the type of permission needed interpreted	as follows:

       00400   READ by user
       00200   WRITE by	user
       00040   READ by group
       00020   WRITE by	group
       00004   READ by others
       00002   WRITE by	others

       Read  and write permissions for a shmid are granted to a	process	if one
       or more of the following	are true:

	 o  The	 {PRIV_IPC_DAC_READ}  or  {PRIV_IPC_DAC_WRITE}	privilege   is
	    present in the effective set.

	 o  The	 effective  user  ID  of  the process matches shm_perm.cuid or
	    shm_perm.uid in the	data structure associated with shmid  and  the
	    appropriate	 bit  of the "user" portion (0600) of shm_perm.mode is
	    set.

	 o  The	effective group	ID of the  process  matches  shm_perm.cgid  or
	    shm_perm.gid  and the appropriate bit of the "group" portion (060)
	    of shm_perm.mode is	set.

	 o  The	appropriate bit	of the "other" portion (06)  of	 shm_perm.mode
	    is set.

       Otherwise, the corresponding permissions	are denied.

   Special Processes
       The  process  with ID 0 and the process with ID 1 are special processes
       referred	to as proc0 and	proc1;	see  kill(2).  proc0  is  the  process
       scheduler.  proc1  is  the  initialization process (init); proc1	is the
       ancestor	of every other process in the system and is  used  to  control
       the process structure.

   STREAMS
       A set of	kernel mechanisms that support the development of network ser-
       vices and data communication drivers. It	 defines  interface  standards
       for character input/output within the kernel and	between	the kernel and
       user level processes. The STREAMS mechanism is composed of utility rou-
       tines, kernel facilities	and a set of data structures.

   Stream
       A  stream  is a full-duplex data	path within the	kernel	between	a user
       process and driver routines. The	primary	components are a stream	 head,
       a  driver, and zero or more modules between the stream head and driver.
       A stream	is analogous to	a shell	pipeline, except that  data  flow  and
       processing are bidirectional.

   Stream Head
       In a stream, the	stream head is the end of the stream that provides the
       interface between the stream and	a user process.	 The  principal	 func-
       tions  of  the  stream head are processing STREAMS-related system calls
       and passing data	and information	between	a user process and the stream.

   Upstream
       In a stream, the	direction from driver to stream	head.

   Write Queue
       In  a  stream,  the message queue in a module or	driver containing mes-
       sages moving downstream.

       standards(5), threads(5)

				  4 Oct	2005			      Intro(2)

NAME | SYNOPSIS | DEFINITIONS

Want to link to this manual page? Use this URL:
<http://www.freebsd.org/cgi/man.cgi?query=intro&sektion=2&manpath=SunOS+5.10>

home | help