*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->Tru64 Unix man pages -> exit (2)              



NAME    [Toc]    [Back]

       exit, atexit, _exit - Terminate a process

SYNOPSIS    [Toc]    [Back]

       #include <stdlib.h>

       int atexit(
               void (*function)(void) ); void exit(
               int status ); #include <unistd.h>

       void _exit(
               int status );

LIBRARY    [Toc]    [Back]

       Standard C Library (libc)

STANDARDS    [Toc]    [Back]

       Interfaces  documented  on  this reference page conform to
       industry standards as follows:

       exit(), _exit(), atexit(): XSH4.0, XSH4.2, XSH5.0

       Refer to the standards(5) reference page for more information
 about industry standards and associated tags.

PARAMETERS    [Toc]    [Back]

       Indicates the status of the process.  Points to a function
       that is called at normal process termination  for  cleanup
       processing. The number of exit handlers that can be specified
 with the atexit() function is limited by  the  amount
       of available virtual memory.

DESCRIPTION    [Toc]    [Back]

       The  atexit() function registers functions to be called at
       normal process termination  for  cleanup  processing.  The
       function  adds a single exit handler to a list of handlers
       to be called at process termination.  The system calls the
       functions  in  reverse  order, calling the function at the
       top of the list first. Any  function  that  is  registered
       more than once will be repeated.

       The  exit()  function terminates the calling process after
       calling the _cleanup() function to flush any buffered output.
 Then it calls any functions registered previously for
       the process by the atexit() function, in the reverse order
       to  that  in  which they were registered. In addition, the
       exit() function flushes all open  output  streams,  closes
       all  open  streams,  and  removes all files created by the
       tmpfile() function. Finally, it calls  the  _exit()  function,
  which  completes  process  termination and does not

       The _exit() and exit()  functions  terminate  the  calling
       process  and cause the following to occur: All of the file
       descriptors and directory streams open in the calling process
  are closed. Since the exit() function terminates the
       process, any errors encountered during these close  operations
  go unreported. Message catalog descriptors and conversion
 descriptors opened in the calling process are also
       closed with no reporting of errors.  The parent process ID
       of all the calling process' existing child  processes  and
       zombie  processes  is  reset. The child processes continue
       executing; however, their parent process ID is set to  the
       process  ID  of  the  init  process. The init process thus
       adopts each of these processes, catches the  SIGCHLD  signals
 that they generate, and calls the wait() function for
       each of them.  If the parent process of the  calling  process
  is running a wait() or waitpid() function, that parent
 process is notified that the calling process is  being
       terminated.  The  low-order  8 bits (that is, bits 0377 or
       0xFF) of the status parameter are made  available  to  the
       parent process.

              [XSH4.2]  [XSH5.0]  This  behavior  also applies if
              the parent process is running a wait3() or waitid()
              function.   In addition, this behavior only applies
              when the parent process of the calling process  has
              neither  set  its SA_NOCLDWAIT flag nor set SIGCHLD
              to SIG_IGN.  If the parent process is not running a
              wait() or waitpid() function when the child process
              terminates, the parent process receives  a  SIGCHLD
              signal  to notify it that the child process is terminating.
 The child process is transformed  into  a
              zombie process.

              Once  the  parent process calls the wait() or waitpid()
 routine, the child process completes termination
  and  the low-order 8 bits (that is, bits 0377
              or 0xFF) of the status parameter are made available
              to it.

              [XSH4.2]  [XSH5.0]  This  behavior  also applies to
              the wait3() and waitid()  functions.  In  addition,
              this  behavior only applies when the parent process
              has not set its SA_NOCLDWAIT flag or set SIGCHLD to
              SIG_IGN.  The parent process is sent a SIGCHLD signal
 when a child  terminates;  however,  since  the
              default action for this signal is to ignore it, the
              signal usually is not seen.  If the  process  is  a
              controlling process, the system sends a SIGHUP signal
 to each process executing in the foreground  on
              the  terminal  that belongs to the calling process.
              The terminal is  disassociated  from  the  session,
              allowing  it  to  be  acquired by a new controlling
              process.  If the termination of a process causes  a
              process group to become orphaned, and if any member
              of the newly orphaned process group is  stopped,  a
              SIGHUP  signal,  followed  by  a SIGCONT signal, is
              sent    to    each    newly    orphaned    process.
              [XSH4.2]  [XSH5.0]    If the parent process has set
              its SA_NOCLDWAIT flag or set  SIGCHLD  to  SIG_IGN,
              the  status  is  discarded, and the lifetime of the
              calling       process       ends       immediately.
              [XSH4.2]  [XSH5.0]  Each  mapped  memory  object is
              unmapped.  Each attached shared memory  segment  is
              detached  and  the value of shm_nattach in the data
              structure associated with its shared memory identifier
 is decremented by 1. (See shmget(2) for information
  about  the  data  structure.)    For   each
              semaphore  for  which the calling process has set a
              semadj value, that semadj value  is  added  to  the
              semval of the specified semaphore. (See semop(2)for
              information about  semaphore  operations.)   [Tru64
              UNIX]  If  the  process  has  a  process lock, text
              lock, or data lock, an unlock() is performed.  (See
              plock(2)   for  information  on  locking.)   [Tru64
              UNIX]  An  accounting  record  is  written  to  the
              accounting file if the system accounting routine is
              enabled.  (See  acct(2)   for   information   about
              enabling accounting routines.)  [Tru64 UNIX]  Locks
              set by the fcntl(), flock(), and lockf()  functions
              are removed.

       [Tru64  UNIX]  If a thread calls the _exit() function, the
       entire process exits and all threads  within  the  process
       are terminated.

NOTES    [Toc]    [Back]

       [XSH4.2]  [XSH5.0]  An  application  should call sysconf()
       to obtain the value of ATEXIT_MAX, the number of  handlers
       that can be registered. There is no way for an application
       to tell how many functions have  already  been  registered
       with atexit().

       To  prematurely terminate atexit() handler processing from
       within a handler, _exit() can be called. It is not  recommended
 to call exit() from within an atexit() handler.

RETURN VALUES    [Toc]    [Back]

       The exit() function and _exit() function do not return.

       The atexit() function returns 0 (zero) if successful.  The
       function fails if an application attempts to register more
       process  cleanup  functions  than available virtual memory
       allows. In this  case,  the  function  returns  a  nonzero

SEE ALSO    [Toc]    [Back]

       Functions:   acct(2),  sigaction(2),  sigvec(2),  wait(2),
       ldr_atexit(3), times(3)

       Standards: standards(5)

[ Back ]
 Similar pages
Name OS Title
kill HP-UX send a signal to a process; terminate a process
_exit HP-UX terminate process
exit IRIX terminate process
exit HP-UX terminate process
_exit OpenBSD terminate the calling process
kill OpenBSD terminate or signal a process
_exit FreeBSD terminate the calling process
kill FreeBSD terminate or signal a process
_exit NetBSD terminate the calling process
_exit Linux terminate the current process
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service