Changed all @example to @smallexample; misc changes for formatting.
[kopensolaris-gnu/glibc.git] / manual / startup.texi
1 @node Process Startup, Child Processes, Signal Handling, Top
2 @chapter Process Startup and Termination
3
4 @cindex process
5 @dfn{Processes} are the primitive units for allocation of system
6 resources.  Each process has its own address space and (usually) one
7 thread of control.  A process executes a program; you can have multiple
8 processes executing the same program, but each process has its own copy
9 of the program within its own address space and executes it
10 independently of the other copies.
11
12 This chapter explains what your program should do to handle the startup
13 of a process, to terminate its process, and to receive information
14 (arguments and the environment) from the parent process.
15
16 @menu
17 * Program Arguments::           Parsing your program's command-line arguments.
18 * Environment Variables::       How to access parameters inherited from
19                                  a parent process.
20 * Program Termination::         How to cause a process to terminate and
21                                  return status information to its parent.
22 @end menu
23
24 @node Program Arguments
25 @section Program Arguments
26 @cindex program arguments
27 @cindex command line arguments
28
29 @cindex @code{main} function
30 The system starts a C program by calling the function @code{main}.  It
31 is up to you to write a function named @code{main}---otherwise, you
32 won't even be able to link your program without errors.
33
34 You can define @code{main} either to take no arguments, or to take two
35 arguments that represent the command line arguments to the program, like
36 this:
37
38 @smallexample
39 int main (int @var{argc}, char *@var{argv}[])
40 @end smallexample
41
42 @cindex argc (program argument count)
43 @cindex argv (program argument vector)
44 The command line arguments are the whitespace-separated tokens given in
45 the shell command used to invoke the program; thus, in @samp{cat foo
46 bar}, the arguments are @samp{foo} and @samp{bar}.  The only way a
47 program can look at its command line arguments is via the arguments of
48 @code{main}.  If @code{main} doesn't take arguments, then you cannot get
49 at the command line.
50
51 The value of the @var{argc} argument is the number of command line
52 arguments.  The @var{argv} argument is a vector of C strings; its
53 elements are the individual command line argument strings.  The file
54 name of the program being run is also included in the vector as the
55 first element; the value of @var{argc} counts this element.  A null
56 pointer always follows the last element: @code{@var{argv}[@var{argc}]}
57 is this null pointer.
58
59 For the command @samp{cat foo bar}, @var{argc} is 3 and @var{argv} has
60 three elements, @code{"cat"}, @code{"foo"} and @code{"bar"}.
61
62 If the syntax for the command line arguments to your program is simple
63 enough, you can simply pick the arguments off from @var{argv} by hand.
64 But unless your program takes a fixed number of arguments, or all of the
65 arguments are interpreted in the same way (as file names, for example),
66 you are usually better off using @code{getopt} to do the parsing.
67
68 @menu
69 * Argument Syntax::       By convention, options start with a hyphen.
70 * Parsing Options::       The @code{getopt} function.
71 * Example of Getopt::     An example of parsing options with @code{getopt}.
72 * Long Options::          GNU suggests utilities accept long-named options.
73                            Here is how to do that.
74 * Long Option Example::   An example of using @code{getopt_long}.
75 @end menu
76
77 @node Argument Syntax
78 @subsection Program Argument Syntax Conventions
79 @cindex program argument syntax
80 @cindex syntax, for program arguments
81 @cindex command argument syntax
82
83 POSIX recommends these conventions for command line arguments.
84 @code{getopt} (@pxref{Parsing Options}) makes it easy to implement them.
85
86 @itemize @bullet
87 @item
88 Arguments are options if they begin with a hyphen delimiter (@samp{-}).
89
90 @item
91 Multiple options may follow a hyphen delimiter in a single token if
92 the options do not take arguments.  Thus, @samp{-abc} is equivalent to
93 @samp{-a -b -c}.
94
95 @item
96 Option names are single alphanumeric characters (as for @code{isalnum};
97 see @ref{Classification of Characters}).
98
99 @item
100 Certain options require an argument.  For example, the @samp{-o} command
101 of the @code{ld} command requires an argument---an output file name.
102
103 @item
104 An option and its argument may or may not appear as separate tokens.  (In
105 other words, the whitespace separating them is optional.)  Thus,
106 @samp{-o foo} and @samp{-ofoo} are equivalent.
107
108 @item
109 Options typically precede other non-option arguments.
110
111 The implementation of @code{getopt} in the GNU C library normally makes
112 it appear as if all the option arguments were specified before all the
113 non-option arguments for the purposes of parsing, even if the user of
114 your program intermixed option and non-option arguments.  It does this
115 by reordering the elements of the @var{argv} array.  This behavior is
116 nonstandard; if you want to suppress it, define the
117 @code{_POSIX_OPTION_ORDER} environment variable.  @xref{Standard
118 Environment}.
119
120 @item
121 The argument @samp{--} terminates all options; any following arguments
122 are treated as non-option arguments, even if they begin with a hyphen.
123
124 @item
125 A token consisting of a single hyphen character is interpreted as an
126 ordinary non-option argument.  By convention, it is used to specify
127 input from or output to the standard input and output streams.
128
129 @item
130 Options may be supplied in any order, or appear multiple times.  The
131 interpretation is left up to the particular application program.
132 @end itemize
133
134 @cindex long-named options
135 GNU adds @dfn{long options} to these conventions.  Long options consist
136 of @samp{--} followed by a name made of alphanumeric characters and
137 dashes.  Option names are typically one to three words long, with
138 hyphens to separate words.  Users can abbreviate the option names as
139 long as the abbreviations are unique.
140
141 To specify an argument for a long option, write
142 @samp{--@var{name}=@var{value}}.  This syntax enables a long option to
143 accept an argument that is itself optional.
144
145 Eventually, the GNU system will provide completion for long option names
146 in the shell.
147
148 @node Parsing Options
149 @subsection Parsing Program Options
150 @cindex program arguments, parsing
151 @cindex command arguments, parsing
152 @cindex parsing program arguments
153
154 Here are the details about how to call the @code{getopt} function.  To
155 use this facility, your program must include the header file
156 @file{unistd.h}.
157 @pindex unistd.h
158
159 @comment unistd.h
160 @comment POSIX.2
161 @deftypevar int opterr
162 If the value of this variable is nonzero, then @code{getopt} prints an
163 error message to the standard error stream if it encounters an unknown
164 option character or an option with a missing required argument.  This is
165 the default behavior.  If you set this variable to zero, @code{getopt}
166 does not print any messages, but it still returns the character @code{?}
167 to indicate an error.
168 @end deftypevar
169
170 @comment unistd.h
171 @comment POSIX.2
172 @deftypevar int optopt
173 When @code{getopt} encounters an unknown option character or an option
174 with a missing required argument, it stores that option character in
175 this variable.  You can use this for providing your own diagnostic
176 messages.
177 @end deftypevar
178
179 @comment unistd.h
180 @comment POSIX.2
181 @deftypevar int optind
182 This variable is set by @code{getopt} to the index of the next element
183 of the @var{argv} array to be processed.  Once @code{getopt} has found
184 all of the option arguments, you can use this variable to determine
185 where the remaining non-option arguments begin.  The initial value of
186 this variable is @code{1}.
187 @end deftypevar
188
189 @comment unistd.h
190 @comment POSIX.2
191 @deftypevar {char *} optarg
192 This variable is set by @code{getopt} to point at the value of the
193 option argument, for those options that accept arguments.
194 @end deftypevar
195
196 @comment unistd.h
197 @comment POSIX.2
198 @deftypefun int getopt (int @var{argc}, char **@var{argv}, const char *@var{options})
199 The @code{getopt} function gets the next option argument from the
200 argument list specified by the @var{argv} and @var{argc} arguments.
201 Normally these values come directly from the arguments received by
202 @code{main}.
203
204 The @var{options} argument is a string that specifies the option
205 characters that are valid for this program.  An option character in this
206 string can be followed by a colon (@samp{:}) to indicate that it takes a
207 required argument.
208
209 If the @var{options} argument string begins with a hyphen (@samp{-}), this
210 is treated specially.  It permits arguments that are not options to be
211 returned as if they were associated with option character @samp{\0}.
212
213 The @code{getopt} function returns the option character for the next
214 command line option.  When no more option arguments are available, it
215 returns @code{-1}.  There may still be more non-option arguments; you
216 must compare the external variable @code{optind} against the @var{argc}
217 parameter to check this.
218
219 If the option has an argument, @code{getopt} returns the argument by
220 storing it in the varables @var{optarg}.  You don't ordinarily need to
221 copy the @code{optarg} string, since it is a pointer into the original
222 @var{argv} array, not into a static area that might be overwritten.
223
224 If @code{getopt} finds an option character in @var{argv} that was not
225 included in @var{options}, or a missing option argument, it returns
226 @samp{?} and sets the external variable @code{optopt} to the actual
227 option character.  If the first character of @var{options} is a colon
228 (@samp{:}), then @code{getopt} returns @samp{:} instead of @samp{?} to
229 indicate a missing option argument.  In addition, if the external
230 variable @code{opterr} is nonzero (which is the default), @code{getopt}
231 prints an error message.
232 @end deftypefun
233
234 @node Example of Getopt
235 @subsection Example of Parsing Arguments with @code{getopt}
236
237 Here is an example showing how @code{getopt} is typically used.  The
238 key points to notice are:
239
240 @itemize @bullet
241 @item
242 Normally, @code{getopt} is called in a loop.  When @code{getopt} returns
243 @code{-1}, indicating no more options are present, the loop terminates.
244
245 @item
246 A @code{switch} statement is used to dispatch on the return value from
247 @code{getopt}.  In typical use, each case just sets a variable that
248 is used later in the program.
249
250 @item
251 A second loop is used to process the remaining non-option arguments.
252 @end itemize
253
254 @smallexample
255 @include testopt.c.texi
256 @end smallexample
257
258 Here are some examples showing what this program prints with different
259 combinations of arguments:
260
261 @smallexample
262 % testopt
263 aflag = 0, bflag = 0, cvalue = (null)
264
265 % testopt -a -b
266 aflag = 1, bflag = 1, cvalue = (null)
267
268 % testopt -ab
269 aflag = 1, bflag = 1, cvalue = (null)
270
271 % testopt -c foo
272 aflag = 0, bflag = 0, cvalue = foo
273
274 % testopt -cfoo
275 aflag = 0, bflag = 0, cvalue = foo
276
277 % testopt arg1
278 aflag = 0, bflag = 0, cvalue = (null)
279 Non-option argument arg1
280
281 % testopt -a arg1
282 aflag = 1, bflag = 0, cvalue = (null)
283 Non-option argument arg1
284
285 % testopt -c foo arg1
286 aflag = 0, bflag = 0, cvalue = foo
287 Non-option argument arg1
288
289 % testopt -a -- -b
290 aflag = 1, bflag = 0, cvalue = (null)
291 Non-option argument -b
292
293 % testopt -a -
294 aflag = 1, bflag = 0, cvalue = (null)
295 Non-option argument -
296 @end smallexample
297
298 @node Long Options
299 @subsection Parsing Long Options
300
301 To accept GNU-style long options as well as single-character options,
302 use @code{getopt_long} instead of @code{getopt}.  You should make every
303 program accept long options if it uses any options, for this takes
304 little extra work and helps beginners remember how to use the program.
305
306 @comment getopt.h
307 @comment GNU
308 @deftp {Data Type} {struct option}
309 This structure describes a single long option name for the sake of
310 @code{getopt_long}.  The argument @var{longopts} must be an array of
311 these structures, one for each long option.  Terminate the array with an
312 element containing all zeros.
313
314 The @code{struct option} structure has these fields:
315
316 @table @code
317 @item const char *name
318 This field is the name of the option.  It is a string.
319
320 @item int has_arg
321 This field says whether the option takes an argument.  It is an integer,
322 and there are three legitimate values: @code{no_argument},
323 @code{required_argument} and @code{optional_argument}.
324
325 @item int *flag
326 @itemx int val
327 These fields control how to report or act on the option when it occurs.
328
329 If @code{flag} is a null pointer, then the @code{val} is a value which
330 identifies this option.  Often these values are chosen to uniquely
331 identify particular long options.
332
333 If @code{flag} is not a null pointer, it should be the address of an
334 @code{int} variable which is the flag for this option.  The value in
335 @code{val} is the value to store in the flag to indicate that the option
336 was seen.
337 @end table
338 @end deftp
339
340 @comment getopt.h
341 @comment GNU
342 @deftypefun int getopt_long (int @var{argc}, char **@var{argv}, const char *@var{shortopts}, struct option *@var{longopts}, int *@var{indexptr})
343 Decode options from the vector @var{argv} (whose length is @var{argc}).
344 The argument @var{shortopts} describes the short options to accept, just as
345 it does in @code{getopt}.  The argument @var{longopts} describes the long
346 options to accept (see above).
347
348 When @code{getopt_long} encounters a short option, it does the same
349 thing that @code{getopt} would do: it returns the character code for the
350 option, and stores the options argument (if it has one) in @code{optarg}.
351
352 When @code{getopt_long} encounters a long option, it takes actions based
353 on the @code{flag} and @code{val} fields of the definition of that
354 option.
355
356 If @code{flag} is a null pointer, then @code{getopt_long} returns the
357 contents of @code{val} to indicate which option it found.  You should
358 arrange distinct values in the @code{val} field for options with
359 different meanings, so you can decode these values after
360 @code{getopt_long} returns.  If the long option is equivalent to a short
361 option, you can use the short option's character code in @code{val}.
362
363 If @code{flag} is not a null pointer, that means this option should just
364 set a flag in the program.  The flag is a variable of type @code{int}
365 that you define.  Put the address of the flag in the @code{flag} field.
366 Put in the @code{val} field the value you would like this option to
367 store in the flag.  In this case, @code{getopt_long} returns @code{0}.
368
369 For any long option, @code{getopt_long} tells you the index in the array
370 @var{longopts} of the options definition, by storing it into
371 @code{*@var{indexptr}}.  You can get the name of the option with
372 @code{@var{longopts}[*@var{indexptr}].name}.  So you can distinguish among
373 long options either by the values in their @code{val} fields or by their
374 indices.  You can also distinguish in this way among long options that
375 set flags.
376
377 When a long option has an argument, @code{getopt_long} puts the argument
378 value in the variable @code{optarg} before returning.  When the option
379 has no argument, the value in @code{optarg} is a null pointer.  This is
380 how you can tell whether an optional argument was supplied.
381
382 When @code{getopt_long} has no more options to handle, it returns
383 @code{-1}, and leaves in the variable @code{optind} the index in
384 @var{argv} of the next remaining argument.
385 @end deftypefun
386
387 @node Long Option Example
388 @subsection Example of Parsing Long Options
389
390 @smallexample
391 @include longopt.c.texi
392 @end smallexample
393
394 @node Environment Variables
395 @section Environment Variables
396
397 @cindex environment variable
398 When a program is executed, it receives information about the context in
399 which it was invoked in two ways.  The first mechanism uses the
400 @var{argv} and @var{argc} arguments to its @code{main} function, and is
401 discussed in @ref{Program Arguments}.  The second mechanism uses
402 @dfn{environment variables} and is discussed in this section.
403
404 The @var{argv} mechanism is typically used to pass command-line
405 arguments specific to the particular program being invoked.  The
406 environment, on the other hand, keeps track of information that is
407 shared by many programs, changes infrequently, and that is less
408 frequently accessed.
409
410 The environment variables discussed in this section are the same
411 environment variables that you set using assignments and the
412 @code{export} command in the shell.  Programs executed from the shell
413 inherit all of the environment variables from the shell.
414 @c !!! xref to right part of bash manual when it exists
415
416 @cindex environment
417 Standard environment variables are used for information about the user's
418 home directory, terminal type, current locale, and so on; you can define
419 additional variables for other purposes.  The set of all environment
420 variables that have values is collectively known as the
421 @dfn{environment}.
422
423 Names of environment variables are case-sensitive and must not contain
424 the character @samp{=}.  System-defined environment variables are
425 invariably uppercase.
426
427 The values of environment variables can be anything that can be
428 represented as a string.  A value must not contain an embedded null
429 character, since this is assumed to terminate the string.
430
431
432 @menu
433 * Environment Access::    How to get and set the values of
434                            environment variables.
435 * Standard Environment::  These environment variables have
436                            standard interpretations.
437 @end menu
438
439 @node Environment Access
440 @subsection Environment Access
441 @cindex environment access
442 @cindex environment representation
443
444 The value of an environment variable can be accessed with the
445 @code{getenv} function.  This is declared in the header file
446 @file{stdlib.h}.
447 @pindex stdlib.h
448
449 @comment stdlib.h
450 @comment ANSI
451 @deftypefun {char *} getenv (const char *@var{name})
452 This function returns a string that is the value of the environment
453 variable @var{name}.  You must not modify this string.  In some non-Unix
454 systems not using the GNU library, it might be overwritten by subsequent
455 calls to @code{getenv} (but not by any other library function).  If the
456 environment variable @var{name} is not defined, the value is a null
457 pointer.
458 @end deftypefun
459
460
461 @comment stdlib.h
462 @comment SVID
463 @deftypefun int putenv (const char *@var{string})
464 The @code{putenv} function adds or removes definitions from the environment.
465 If the @var{string} is of the form @samp{@var{name}=@var{value}}, the
466 definition is added to the environment.  Otherwise, the @var{string} is
467 interpreted as the name of an environment variable, and any definition
468 for this variable in the environment is removed.
469
470 The GNU library provides this function for compatibility with SVID; it
471 may not be available in other systems.
472 @end deftypefun
473
474 @c !!! BSD function setenv
475
476 You can deal directly with the underlying representation of environment
477 objects to add more variables to the environment (for example, to
478 communicate with another program you are about to execute; see
479 @ref{Executing a File}).  
480
481 @comment unistd.h
482 @comment POSIX.1
483 @deftypevar {char **} environ
484 The environment is represented as an array of strings.  Each string is
485 of the format @samp{@var{name}=@var{value}}.  The order in which
486 strings appear in the environment is not significant, but the same
487 @var{name} must not appear more than once.  The last element of the
488 array is a null pointer.
489
490 This variable is declared in the header file @file{unistd.h}.
491
492 If you just want to get the value of an environment variable, use
493 @code{getenv}.
494 @end deftypevar
495
496 @node Standard Environment
497 @subsection Standard Environment Variables
498 @cindex standard environment variables
499
500 These environment variables have standard meanings.  This doesn't mean
501 that they are always present in the environment; but if these variables
502 @emph{are} present, they have these meanings, and that you shouldn't try
503 to use these environment variable names for some other purpose.
504
505 @comment Extra blank lines make it look better.
506 @table @code
507 @item HOME
508 @cindex HOME environment variable
509 @cindex home directory
510
511 This is a string representing the user's @dfn{home directory}, or
512 initial default working directory.
513
514 The user can set @code{HOME} to any value.
515 If you need to make sure to obtain the proper home directory
516 for a particular user, you should not use @code{HOME}; instead,
517 look up the user's name in the user database (@pxref{User Database}).
518
519 For most purposes, it is better to use @code{HOME}, precisely because
520 this lets the user specify the value.
521
522 @c !!! also USER
523 @item LOGNAME
524 @cindex LOGNAME environment variable
525
526 This is the name that the user used to log in.  Since the value in the
527 environment can be tweaked arbitrarily, this is not a reliable way to
528 identify the user who is running a process; a function like
529 @code{getlogin} (@pxref{Who Logged In}) is better for that purpose.
530
531 For most purposes, it is better to use @code{LOGNAME}, precisely because
532 this lets the user specify the value.
533
534 @item PATH
535 @cindex PATH environment variable
536
537 A @dfn{path} is a sequence of directory names which is used for
538 searching for a file.  The variable @code{PATH} holds a path used
539 for searching for programs to be run.
540
541 The @code{execlp} and @code{execvp} functions (@pxref{Executing a File})
542 use this environment variable, as do many shells and other utilities
543 which are implemented in terms of those functions.
544
545 The syntax of a path is a sequence of directory names separated by
546 colons.  An empty string instead of a directory name stands for the 
547 current directory (@pxref{Working Directory}).
548
549 A typical value for this environment variable might be a string like:
550
551 @smallexample
552 :/bin:/etc:/usr/bin:/usr/new/X11:/usr/new:/usr/local/bin
553 @end smallexample
554
555 This means that if the user tries to execute a program named @code{foo},
556 the system will look for files named @file{foo}, @file{/bin/foo},
557 @file{/etc/foo}, and so on.  The first of these files that exists is
558 the one that is executed.
559
560 @c !!! also TERMCAP
561 @item TERM
562 @cindex TERM environment variable
563
564 This specifies the kind of terminal that is receiving program output.
565 Some programs can make use of this information to take advantage of
566 special escape sequences or terminal modes supported by particular kinds
567 of terminals.  Many programs which use the termcap library
568 (@pxref{Finding a Terminal Description,Find,,termcap,The Termcap Library
569 Manual}) use the @code{TERM} environment variable, for example.
570
571 @item TZ
572 @cindex TZ environment variable
573
574 This specifies the time zone.  @xref{TZ Variable}, for information about
575 the format of this string and how it is used.
576
577 @item LANG
578 @cindex LANG environment variable
579
580 This specifies the default locale to use for attribute categories where
581 neither @code{LC_ALL} nor the specific environment variable for that
582 category is set.  @xref{Locales}, for more information about
583 locales.
584
585 @ignore
586 @c I doubt this really exists
587 @item LC_ALL
588 @cindex LC_ALL environment variable
589
590 This is similar to the @code{LANG} environment variable.  However, its
591 value takes precedence over any values provided for the individual
592 attribute category environment variables, or for the @code{LANG}
593 environment variable.
594 @end ignore
595
596 @item LC_COLLATE
597 @cindex LC_COLLATE environment variable
598
599 This specifies what locale to use for string sorting.
600
601 @item LC_CTYPE
602 @cindex LC_CTYPE environment variable
603
604 This specifies what locale to use for character sets and character
605 classification.
606
607 @item LC_MONETARY
608 @cindex LC_MONETARY environment variable
609
610 This specifies what locale to use for formatting monetary values.
611
612 @item LC_NUMERIC
613 @cindex LC_NUMERIC environment variable
614
615 This specifies what locale to use for formatting numbers.
616
617 @item LC_TIME
618 @cindex LC_TIME environment variable
619
620 This specifies what locale to use for formatting date/time values.
621
622 @item _POSIX_OPTION_ORDER
623 @cindex _POSIX_OPTION_ORDER environment variable.
624
625 If this environment variable is defined, it suppresses the usual
626 reordering of command line arguments by @code{getopt}.  @xref{Argument Syntax}.
627
628 @c !!! GNU also has COREFILE, CORESERVER, EXECSERVERS
629 @end table
630
631 @node Program Termination
632 @section Program Termination
633 @cindex program termination
634 @cindex process termination
635
636 @cindex exit status value
637 The usual way for a program to terminate is simply for its @code{main}
638 function to return.  The @dfn{exit status value} returned from the
639 @code{main} function is used to report information back to the process's
640 parent process or shell.
641
642 A program can also terminate normally by calling the @code{exit}
643 function.
644
645 In addition, programs can be terminated by signals; this is discussed in
646 more detail in @ref{Signal Handling}.  The @code{abort} function causes
647 a signal that kills the program.
648
649 @menu
650 * Normal Termination::          If a program calls @code{exit}, a
651                                  process terminates normally.
652 * Exit Status::                 The @code{exit status} provides information 
653                                  about why the process terminated. 
654 * Cleanups on Exit::            A process can run its own cleanup
655                                  functions upon normal termination. 
656 * Aborting a Program::          The @code{abort} function causes
657                                  abnormal program termination. 
658 * Termination Internals::       What happens when a process terminates.
659 @end menu
660
661 @node Normal Termination
662 @subsection Normal Termination
663
664 A process terminates normally when the program calls @code{exit}.
665 Returning from @code{main} is equivalent to calling @code{exit}, and
666 the value that @code{main} returns is used as the argument to @code{exit}.
667
668 @comment stdlib.h
669 @comment ANSI
670 @deftypefun void exit (int @var{status})
671 The @code{exit} function terminates the process with status
672 @var{status}.  This function does not return.
673 @end deftypefun
674
675 Normal termination causes the following actions:
676
677 @enumerate
678 @item 
679 Functions that were registered with the @code{atexit} or @code{on_exit}
680 functions are called in the reverse order of their registration.  This
681 mechanism allows your application to specify its own ``cleanup'' actions
682 to be performed at program termination.  Typically, this is used to do
683 things like saving program state information in a file, or unlocking
684 locks in shared data bases.
685
686 @item 
687 All open streams are closed, writing out any buffered output data.  See
688 @ref{Closing Streams}.  In addition, temporary files opened
689 with the @code{tmpfile} function are removed; see @ref{Temporary Files}.
690
691 @item 
692 @code{_exit} is called, terminating the program.  @xref{Termination Internals}.
693 @end enumerate
694
695 @node Exit Status
696 @subsection Exit Status
697 @cindex exit status
698
699 When a program exits, it can return to the parent process a small
700 amount of information about the cause of termination, using the
701 @dfn{exit status}.  This is a value between 0 and 255 that the exiting
702 process passes as an argument to @code{exit}.
703
704 Normally you should use the exit status to report very broad information
705 about success or failure.  You can't provide a lot of detail about the
706 reasons for the failure, and most parent processes would not want much
707 detail anyway.
708
709 There are conventions for what sorts of status values certain programs
710 should return.  The most common convention is simply 0 for success and 1
711 for failure.  Programs that perform comparison use a different
712 convention: they use status 1 to indicate a mismatch, and status 2 to
713 indicate an inability to compare.  Your program should follow an
714 existing convention if an existing convention makes sense for it.
715
716 A general convention reserves status values 128 and up for special
717 purposes.  In particular, the value 128 is used to indicate failure to
718 execute another program in a subprocess.  This convention is not
719 universally obeyed, but it is a good idea to follow it in your programs.
720
721 @strong{Warning:} Don't try to use the number of errors as the exit
722 status.  This is actually not very useful; a parent process would
723 generally not care how many errors occurred.  Worse than that, it does
724 not work, because the status value is truncated to eight bits.
725 Thus, if the program tried to report 256 errors, the parent would
726 receive a report of 0 errors---that is, success.
727
728 For the same reason, it does not work to use the value of @code{errno}
729 as the exit status---these can exceed 255.
730
731 @strong{Portability note:} Some non-POSIX systems use different
732 conventions for exit status values.  For greater portability, you can
733 use the macros @code{EXIT_SUCCESS} and @code{EXIT_FAILURE} for the
734 conventional status value for success and failure, respectively.  They
735 are declared in the file @file{stdlib.h}.
736 @pindex stdlib.h
737
738 @comment stdlib.h
739 @comment ANSI
740 @deftypevr Macro int EXIT_SUCCESS
741 This macro can be used with the @code{exit} function to indicate
742 successful program completion.
743
744 On POSIX systems, the value of this macro is @code{0}.  On other
745 systems, the value might be some other (possibly non-constant) integer
746 expression.
747 @end deftypevr
748
749 @comment stdlib.h
750 @comment ANSI
751 @deftypevr Macro int EXIT_FAILURE
752 This macro can be used with the @code{exit} function to indicate
753 unsuccessful program completion in a general sense.
754
755 On POSIX systems, the value of this macro is @code{1}.  On other
756 systems, the value might be some other (possibly non-constant) integer
757 expression.  Other nonzero status values also indicate future.  Certain
758 programs use different nonzero status values to indicate particular
759 kinds of "non-success".  For example, @code{diff} uses status value
760 @code{1} to mean that the files are different, and @code{2} or more to
761 mean that there was difficulty in opening the files.
762 @end deftypevr
763
764 @node Cleanups on Exit
765 @subsection Cleanups on Exit
766
767 Your program can arrange to run its own cleanup functions if normal
768 termination happens.  If you are writing a library for use in various
769 application programs, then it is unreliable to insist that all
770 applications call the library's cleanup functions explicitly before
771 exiting.  It is much more robust to make the cleanup invisible to the
772 application, by setting up a cleanup function in the library itself
773 using @code{atexit} or @code{on_exit}.
774
775 @comment stdlib.h
776 @comment ANSI
777 @deftypefun int atexit (void (*@var{function}) (void))
778 The @code{atexit} function registers the function @var{function} to be
779 called at normal program termination.  The @var{function} is called with
780 no arguments.
781
782 The return value from @code{atexit} is zero on success and nonzero if
783 the function cannot be registered. 
784 @end deftypefun
785
786 @comment stdlib.h
787 @comment SunOS
788 @deftypefun int on_exit (void (*@var{function})(int @var{status}, void *@var{arg}), void *@var{arg})
789 This function is a somewhat more powerful variant of @code{atexit}.  It
790 accepts two arguments, a function @var{function} and an arbitrary
791 pointer @var{arg}.  At normal program termination, the @var{function} is
792 called with two arguments:  the @var{status} value passed to @code{exit},
793 and the @var{arg}.
794
795 This function is included in the GNU C library only for compatibility
796 for SunOS, and may not be supported by other implementations.
797 @end deftypefun
798
799 Here's a trivial program that illustrates the use of @code{exit} and
800 @code{atexit}:
801
802 @smallexample
803 @include atexit.c.texi
804 @end smallexample
805
806 @noindent
807 When this program is executed, it just prints the message and exits.
808
809 @node Aborting a Program
810 @subsection Aborting a Program
811 @cindex aborting a program
812
813 You can abort your program using the @code{abort} function.  The prototype
814 for this function is in @file{stdlib.h}.
815 @pindex stdlib.h
816
817 @comment stdlib.h
818 @comment ANSI
819 @deftypefun void abort (void)
820 The @code{abort} function causes abnormal program termination.  This
821 does not execute cleanup functions registered with @code{atexit} or
822 @code{on_exit}.
823
824 This function actually terminates the process by raising a
825 @code{SIGABRT} signal, and your program can include a handler to
826 intercept this signal; see @ref{Signal Handling}.
827 @end deftypefun
828
829 @c Put in by rms.  Don't remove.
830 @cartouche
831 @strong{Future Change Warning:} Proposed Federal censorship regulations
832 may prohibit us from giving you information about the possibility of
833 calling this function.  We would be required to say that this is not an
834 acceptable way of terminating a program.
835 @end cartouche
836
837 @node Termination Internals
838 @subsection Termination Internals
839
840 The @code{_exit} function is the primitive used for process termination
841 by @code{exit}.  It is declared in the header file @file{unistd.h}.
842 @pindex unistd.h
843
844 @comment unistd.h
845 @comment POSIX.1
846 @deftypefun void _exit (int @var{status})
847 The @code{_exit} function is the primitive for causing a process to
848 terminate with status @var{status}.  Calling this function does not
849 execute cleanup functions registered with @code{atexit} or
850 @code{on_exit}.
851 @end deftypefun
852
853 When a process terminates for any reason---either by an explicit
854 termination call, or termination as a result of a signal---the
855 following things happen:
856
857 @itemize @bullet
858 @item
859 All open file descriptors in the process are closed.  @xref{Low-Level I/O}.
860
861 @item
862 The low-order 8 bits of the return status code are saved to be reported
863 back to the parent process via @code{wait} or @code{waitpid}; see
864 @ref{Process Completion}.
865
866 @item
867 Any child processes of the process being terminated are assigned a new
868 parent process.  (This is the @code{init} process, with process ID 1.)
869
870 @item
871 A @code{SIGCHLD} signal is sent to the parent process.
872
873 @item
874 If the process is a session leader that has a controlling terminal, then
875 a @code{SIGHUP} signal is sent to each process in the foreground job,
876 and the controlling terminal is disassociated from that session.
877 @xref{Job Control}.
878
879 @item
880 If termination of a process causes a process group to become orphaned,
881 and any member of that process group is stopped, then a @code{SIGHUP}
882 signal and a @code{SIGCONT} signal are sent to each process in the
883 group.  @xref{Job Control}.
884 @end itemize