Process Termination

• This is somewhat more complex that one might think.
• There are two ways for a process to terminate
  • An abnormal termination occurs when a process receives a signal which causes termination.
    • This includes a kill signal
    • Or a a segmentation violation, or an abort or ...
  • A normal termination is when the program
    • returns from the main routine
    • Or calls some form of exit
    • both of which call _exit()
• _exit()

  •        #include <unistd.h>
           void _exit(int status);
    	

  • Terminates the process immediately.
    • File descriptors are closed
    • Children become children of 1.
    • A sigchild is sent to the parent process with this process's id and exit status.
  • This system call NEVER returns.
  • Our author states that we should not use exit values greater than 128
• Most programs exit via the library routine exit()

  •        #include <stdlib.h>
           void exit(int status);
    	

  • status & 0377 is returned to the parent. (0 to 255)
  • Exit handlers are called.
  • Stdio is flushed
  • _exit() is called.
• Returning from main is equivalent to calling exit(n), where
  • n is the value of return, ie return 0
  • n is the return value of the last statement executed if there is no return.
  • C-90 specifies that no return is equivalent to exit(0)
• Exit handlers
  • Exit handlers are functions that can be called during the exit() process.
  • These programs to clean up when exit is called.
  • Especially for libraries.
  • Exit handlers are registered in one of two ways
    • atexit()

      • 	       #include <stdlib.h>
        	       int atexit(void (*function)(void));
        		

      • Registers a function to be called when exit() is called.
      • Functions are called in reverse order registered.
      • See doExit.C
      • These functions can call atexit
      • But they should not call exit()
      • If they call _exit() all other calls are abandon.
      • They can not be deregistered, but you can check a global variable to see if they should do anything.
      • These are inherited by child processes
      • But they are cleared by exec (whatever that is)
    • on_exit

      • 		#include 
                        int on_exit(void (*function)(int , void *), void *arg);
        	        

      • The first parameter is the staus argument given to exit.
      • The the second parameter is a pointer to any argument type.
      • Your author says that this should be avoided.