Mention argp_parse in places that previously mentioned only getopt.
[kopensolaris-gnu/glibc.git] / manual / startup.texi
1 @node Process Startup
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 @cindex arguments, to program
29
30 @cindex program startup
31 @cindex startup of program
32 @cindex invocation of program
33 @cindex @code{main} function
34 @findex main
35 The system starts a C program by calling the function @code{main}.  It
36 is up to you to write a function named @code{main}---otherwise, you
37 won't even be able to link your program without errors.
38
39 In @w{ISO C} you can define @code{main} either to take no arguments, or to
40 take two arguments that represent the command line arguments to the
41 program, like this:
42
43 @smallexample
44 int main (int @var{argc}, char *@var{argv}[])
45 @end smallexample
46
47 @cindex argc (program argument count)
48 @cindex argv (program argument vector)
49 The command line arguments are the whitespace-separated tokens given in
50 the shell command used to invoke the program; thus, in @samp{cat foo
51 bar}, the arguments are @samp{foo} and @samp{bar}.  The only way a
52 program can look at its command line arguments is via the arguments of
53 @code{main}.  If @code{main} doesn't take arguments, then you cannot get
54 at the command line.
55
56 The value of the @var{argc} argument is the number of command line
57 arguments.  The @var{argv} argument is a vector of C strings; its
58 elements are the individual command line argument strings.  The file
59 name of the program being run is also included in the vector as the
60 first element; the value of @var{argc} counts this element.  A null
61 pointer always follows the last element: @code{@var{argv}[@var{argc}]}
62 is this null pointer.
63
64 For the command @samp{cat foo bar}, @var{argc} is 3 and @var{argv} has
65 three elements, @code{"cat"}, @code{"foo"} and @code{"bar"}.
66
67 In Unix systems you can define @code{main} a third way, using three arguments:
68
69 @smallexample
70 int main (int @var{argc}, char *@var{argv}[], char *@var{envp})
71 @end smallexample
72
73 The first two arguments are just the same.  The third argument
74 @var{envp} gives the process's environment; it is the same as the value
75 of @code{environ}.  @xref{Environment Variables}.  POSIX.1 does not
76 allow this three-argument form, so to be portable it is best to write
77 @code{main} to take two arguments, and use the value of @code{environ}.
78
79 @menu
80 * Argument Syntax::             By convention, options start with a hyphen.
81 * Parsing Program Arguments::   Ways to parse program options and arguments.
82 @end menu
83
84 @node Argument Syntax
85 @subsection Program Argument Syntax Conventions
86 @cindex program argument syntax
87 @cindex syntax, for program arguments
88 @cindex command argument syntax
89
90 POSIX recommends these conventions for command line arguments.
91 @code{getopt} (@pxref{Getopt}) and @code{argp_parse} (@pxref{Argp}) make
92 it easy to implement them.
93
94 @itemize @bullet
95 @item
96 Arguments are options if they begin with a hyphen delimiter (@samp{-}).
97
98 @item
99 Multiple options may follow a hyphen delimiter in a single token if
100 the options do not take arguments.  Thus, @samp{-abc} is equivalent to
101 @samp{-a -b -c}.
102
103 @item
104 Option names are single alphanumeric characters (as for @code{isalnum};
105 see @ref{Classification of Characters}).
106
107 @item
108 Certain options require an argument.  For example, the @samp{-o} command
109 of the @code{ld} command requires an argument---an output file name.
110
111 @item
112 An option and its argument may or may not appear as separate tokens.  (In
113 other words, the whitespace separating them is optional.)  Thus,
114 @w{@samp{-o foo}} and @samp{-ofoo} are equivalent.
115
116 @item
117 Options typically precede other non-option arguments.
118
119 The implementations of @code{getopt} and @code{argp_parse} in the GNU C
120 library normally make it appear as if all the option arguments were
121 specified before all the non-option arguments for the purposes of
122 parsing, even if the user of your program intermixed option and
123 non-option arguments.  They do this by reordering the elements of the
124 @var{argv} array.  This behavior is nonstandard; if you want to suppress
125 it, define the @code{_POSIX_OPTION_ORDER} environment variable.
126 @xref{Standard Environment}.
127
128 @item
129 The argument @samp{--} terminates all options; any following arguments
130 are treated as non-option arguments, even if they begin with a hyphen.
131
132 @item
133 A token consisting of a single hyphen character is interpreted as an
134 ordinary non-option argument.  By convention, it is used to specify
135 input from or output to the standard input and output streams.
136
137 @item
138 Options may be supplied in any order, or appear multiple times.  The
139 interpretation is left up to the particular application program.
140 @end itemize
141
142 @cindex long-named options
143 GNU adds @dfn{long options} to these conventions.  Long options consist
144 of @samp{--} followed by a name made of alphanumeric characters and
145 dashes.  Option names are typically one to three words long, with
146 hyphens to separate words.  Users can abbreviate the option names as
147 long as the abbreviations are unique.
148
149 To specify an argument for a long option, write
150 @samp{--@var{name}=@var{value}}.  This syntax enables a long option to
151 accept an argument that is itself optional.
152
153 Eventually, the GNU system will provide completion for long option names
154 in the shell.
155
156 @node Parsing Program Arguments
157 @subsection Parsing Program Arguments
158
159 @cindex program arguments, parsing
160 @cindex command arguments, parsing
161 @cindex parsing program arguments
162 If the syntax for the command line arguments to your program is simple
163 enough, you can simply pick the arguments off from @var{argv} by hand.
164 But unless your program takes a fixed number of arguments, or all of the
165 arguments are interpreted in the same way (as file names, for example),
166 you are usually better off using @code{getopt} (@pxref{Getopt}) or
167 @code{argp_parse} (@pxref{Argp}) to do the parsing.
168
169 @code{getopt} is more standard (the short-option only version of it is a
170 part of the POSIX standard), but using @code{argp_parse} is often
171 easier, both for very simple and very complex option structures, because
172 it does more of the dirty work for you.
173
174 @menu
175 * Getopt::                      Parsing program options using @code{getopt}.
176 * Argp::                        Parsing program options using @code{argp_parse}.
177 * Suboptions::                  Some programs need more detailed options.
178 * Suboptions Example::          This shows how it could be done for @code{mount}.
179 @end menu
180
181 @c Getopt and argp start at the @section level so that there's
182 @c enough room for their internal hierarchy (mostly a problem with
183 @c argp).         -Miles
184
185 @include getopt.texi
186 @include argp.texi
187
188 @node Suboptions, Suboptions Example, Argp, Parsing Program Arguments
189 @c This is a @section so that it's at the same level as getopt and argp
190 @section Parsing of Suboptions
191
192 Having a single level of options is sometimes not enough.  There might
193 be too many options which have to be available or a set of options is
194 closely related.
195
196 For this case some programs use suboptions.  One of the most prominent
197 programs is certainly @code{mount}(8).  The @code{-o} option take one
198 argument which itself is a comma separated list of options.  To ease the
199 programming of code like this the function @code{getsubopt} is
200 available.
201
202 @comment stdlib.h
203 @deftypefun int getsubopt (char **@var{optionp}, const char* const *@var{tokens}, char **@var{valuep})
204
205 The @var{optionp} parameter must be a pointer to a variable containing
206 the address of the string to process.  When the function returns the
207 reference is updated to point to the next suboption or to the
208 terminating @samp{\0} character if there is no more suboption available.
209
210 The @var{tokens} parameter references an array of strings containing the
211 known suboptions.  All strings must be @samp{\0} terminated and to mark
212 the end a null pointer must be stored.  When @code{getsubopt} finds a
213 possible legal suboption it compares it with all strings available in
214 the @var{tokens} array and returns the index in the string as the
215 indicator.
216
217 In case the suboption has an associated value introduced by a @samp{=}
218 character, a pointer to the value is returned in @var{valuep}.  The
219 string is @samp{\0} terminated.  If no argument is available
220 @var{valuep} is set to the null pointer.  By doing this the caller can
221 check whether a necessary value is given or whether no unexpected value
222 is present.
223
224 In case the next suboption in the string is not mentioned in the
225 @var{tokens} array the starting address of the suboption including a
226 possible value is returned in @var{valuep} and the return value of the
227 function is @samp{-1}.
228 @end deftypefun
229
230 @node Suboptions Example, , Suboptions, Parsing Program Arguments
231 @subsection Parsing of Suboptions Example
232
233 The code which might appear in the @code{mount}(8) program is a perfect
234 example of the use of @code{getsubopt}:
235
236 @smallexample
237 @include subopt.c.texi
238 @end smallexample
239
240
241 @node Environment Variables
242 @section Environment Variables
243
244 @cindex environment variable
245 When a program is executed, it receives information about the context in
246 which it was invoked in two ways.  The first mechanism uses the
247 @var{argv} and @var{argc} arguments to its @code{main} function, and is
248 discussed in @ref{Program Arguments}.  The second mechanism uses
249 @dfn{environment variables} and is discussed in this section.
250
251 The @var{argv} mechanism is typically used to pass command-line
252 arguments specific to the particular program being invoked.  The
253 environment, on the other hand, keeps track of information that is
254 shared by many programs, changes infrequently, and that is less
255 frequently used.
256
257 The environment variables discussed in this section are the same
258 environment variables that you set using assignments and the
259 @code{export} command in the shell.  Programs executed from the shell
260 inherit all of the environment variables from the shell.
261 @c !!! xref to right part of bash manual when it exists
262
263 @cindex environment
264 Standard environment variables are used for information about the user's
265 home directory, terminal type, current locale, and so on; you can define
266 additional variables for other purposes.  The set of all environment
267 variables that have values is collectively known as the
268 @dfn{environment}.
269
270 Names of environment variables are case-sensitive and must not contain
271 the character @samp{=}.  System-defined environment variables are
272 invariably uppercase.
273
274 The values of environment variables can be anything that can be
275 represented as a string.  A value must not contain an embedded null
276 character, since this is assumed to terminate the string.
277
278
279 @menu
280 * Environment Access::          How to get and set the values of
281                            environment variables.
282 * Standard Environment::        These environment variables have
283                            standard interpretations.
284 @end menu
285
286 @node Environment Access
287 @subsection Environment Access
288 @cindex environment access
289 @cindex environment representation
290
291 The value of an environment variable can be accessed with the
292 @code{getenv} function.  This is declared in the header file
293 @file{stdlib.h}.
294 @pindex stdlib.h
295
296 @comment stdlib.h
297 @comment ISO
298 @deftypefun {char *} getenv (const char *@var{name})
299 This function returns a string that is the value of the environment
300 variable @var{name}.  You must not modify this string.  In some non-Unix
301 systems not using the GNU library, it might be overwritten by subsequent
302 calls to @code{getenv} (but not by any other library function).  If the
303 environment variable @var{name} is not defined, the value is a null
304 pointer.
305 @end deftypefun
306
307
308 @comment stdlib.h
309 @comment SVID
310 @deftypefun int putenv (const char *@var{string})
311 The @code{putenv} function adds or removes definitions from the environment.
312 If the @var{string} is of the form @samp{@var{name}=@var{value}}, the
313 definition is added to the environment.  Otherwise, the @var{string} is
314 interpreted as the name of an environment variable, and any definition
315 for this variable in the environment is removed.
316
317 The GNU library provides this function for compatibility with SVID; it
318 may not be available in other systems.
319 @end deftypefun
320
321 @c !!! BSD function setenv
322
323 You can deal directly with the underlying representation of environment
324 objects to add more variables to the environment (for example, to
325 communicate with another program you are about to execute; see
326 @ref{Executing a File}).
327
328 @comment unistd.h
329 @comment POSIX.1
330 @deftypevar {char **} environ
331 The environment is represented as an array of strings.  Each string is
332 of the format @samp{@var{name}=@var{value}}.  The order in which
333 strings appear in the environment is not significant, but the same
334 @var{name} must not appear more than once.  The last element of the
335 array is a null pointer.
336
337 This variable is declared in the header file @file{unistd.h}.
338
339 If you just want to get the value of an environment variable, use
340 @code{getenv}.
341 @end deftypevar
342
343 Unix systems, and the GNU system, pass the initial value of
344 @code{environ} as the third argument to @code{main}.
345 @xref{Program Arguments}.
346
347 @node Standard Environment
348 @subsection Standard Environment Variables
349 @cindex standard environment variables
350
351 These environment variables have standard meanings.  This doesn't mean
352 that they are always present in the environment; but if these variables
353 @emph{are} present, they have these meanings.  You shouldn't try to use
354 these environment variable names for some other purpose.
355
356 @comment Extra blank lines make it look better.
357 @table @code
358 @item HOME
359 @cindex HOME environment variable
360 @cindex home directory
361
362 This is a string representing the user's @dfn{home directory}, or
363 initial default working directory.
364
365 The user can set @code{HOME} to any value.
366 If you need to make sure to obtain the proper home directory
367 for a particular user, you should not use @code{HOME}; instead,
368 look up the user's name in the user database (@pxref{User Database}).
369
370 For most purposes, it is better to use @code{HOME}, precisely because
371 this lets the user specify the value.
372
373 @c !!! also USER
374 @item LOGNAME
375 @cindex LOGNAME environment variable
376
377 This is the name that the user used to log in.  Since the value in the
378 environment can be tweaked arbitrarily, this is not a reliable way to
379 identify the user who is running a process; a function like
380 @code{getlogin} (@pxref{Who Logged In}) is better for that purpose.
381
382 For most purposes, it is better to use @code{LOGNAME}, precisely because
383 this lets the user specify the value.
384
385 @item PATH
386 @cindex PATH environment variable
387
388 A @dfn{path} is a sequence of directory names which is used for
389 searching for a file.  The variable @code{PATH} holds a path used
390 for searching for programs to be run.
391
392 The @code{execlp} and @code{execvp} functions (@pxref{Executing a File})
393 use this environment variable, as do many shells and other utilities
394 which are implemented in terms of those functions.
395
396 The syntax of a path is a sequence of directory names separated by
397 colons.  An empty string instead of a directory name stands for the
398 current directory (@pxref{Working Directory}).
399
400 A typical value for this environment variable might be a string like:
401
402 @smallexample
403 :/bin:/etc:/usr/bin:/usr/new/X11:/usr/new:/usr/local/bin
404 @end smallexample
405
406 This means that if the user tries to execute a program named @code{foo},
407 the system will look for files named @file{foo}, @file{/bin/foo},
408 @file{/etc/foo}, and so on.  The first of these files that exists is
409 the one that is executed.
410
411 @c !!! also TERMCAP
412 @item TERM
413 @cindex TERM environment variable
414
415 This specifies the kind of terminal that is receiving program output.
416 Some programs can make use of this information to take advantage of
417 special escape sequences or terminal modes supported by particular kinds
418 of terminals.  Many programs which use the termcap library
419 (@pxref{Finding a Terminal Description,Find,,termcap,The Termcap Library
420 Manual}) use the @code{TERM} environment variable, for example.
421
422 @item TZ
423 @cindex TZ environment variable
424
425 This specifies the time zone.  @xref{TZ Variable}, for information about
426 the format of this string and how it is used.
427
428 @item LANG
429 @cindex LANG environment variable
430
431 This specifies the default locale to use for attribute categories where
432 neither @code{LC_ALL} nor the specific environment variable for that
433 category is set.  @xref{Locales}, for more information about
434 locales.
435
436 @ignore
437 @c I doubt this really exists
438 @item LC_ALL
439 @cindex LC_ALL environment variable
440
441 This is similar to the @code{LANG} environment variable.  However, its
442 value takes precedence over any values provided for the individual
443 attribute category environment variables, or for the @code{LANG}
444 environment variable.
445 @end ignore
446
447 @item LC_COLLATE
448 @cindex LC_COLLATE environment variable
449
450 This specifies what locale to use for string sorting.
451
452 @item LC_CTYPE
453 @cindex LC_CTYPE environment variable
454
455 This specifies what locale to use for character sets and character
456 classification.
457
458 @item LC_MONETARY
459 @cindex LC_MONETARY environment variable
460
461 This specifies what locale to use for formatting monetary values.
462
463 @item LC_NUMERIC
464 @cindex LC_NUMERIC environment variable
465
466 This specifies what locale to use for formatting numbers.
467
468 @item LC_TIME
469 @cindex LC_TIME environment variable
470
471 This specifies what locale to use for formatting date/time values.
472
473 @item _POSIX_OPTION_ORDER
474 @cindex _POSIX_OPTION_ORDER environment variable.
475
476 If this environment variable is defined, it suppresses the usual
477 reordering of command line arguments by @code{getopt} and
478 @code{argp_parse}.  @xref{Argument Syntax}.
479
480 @c !!! GNU also has COREFILE, CORESERVER, EXECSERVERS
481 @end table
482
483 @node Program Termination
484 @section Program Termination
485 @cindex program termination
486 @cindex process termination
487
488 @cindex exit status value
489 The usual way for a program to terminate is simply for its @code{main}
490 function to return.  The @dfn{exit status value} returned from the
491 @code{main} function is used to report information back to the process's
492 parent process or shell.
493
494 A program can also terminate normally by calling the @code{exit}
495 function.
496
497 In addition, programs can be terminated by signals; this is discussed in
498 more detail in @ref{Signal Handling}.  The @code{abort} function causes
499 a signal that kills the program.
500
501 @menu
502 * Normal Termination::          If a program calls @code{exit}, a
503                                  process terminates normally.
504 * Exit Status::                 The @code{exit status} provides information
505                                  about why the process terminated.
506 * Cleanups on Exit::            A process can run its own cleanup
507                                  functions upon normal termination.
508 * Aborting a Program::          The @code{abort} function causes
509                                  abnormal program termination.
510 * Termination Internals::       What happens when a process terminates.
511 @end menu
512
513 @node Normal Termination
514 @subsection Normal Termination
515
516 A process terminates normally when the program calls @code{exit}.
517 Returning from @code{main} is equivalent to calling @code{exit}, and
518 the value that @code{main} returns is used as the argument to @code{exit}.
519
520 @comment stdlib.h
521 @comment ISO
522 @deftypefun void exit (int @var{status})
523 The @code{exit} function terminates the process with status
524 @var{status}.  This function does not return.
525 @end deftypefun
526
527 Normal termination causes the following actions:
528
529 @enumerate
530 @item
531 Functions that were registered with the @code{atexit} or @code{on_exit}
532 functions are called in the reverse order of their registration.  This
533 mechanism allows your application to specify its own ``cleanup'' actions
534 to be performed at program termination.  Typically, this is used to do
535 things like saving program state information in a file, or unlocking
536 locks in shared data bases.
537
538 @item
539 All open streams are closed, writing out any buffered output data.  See
540 @ref{Closing Streams}.  In addition, temporary files opened
541 with the @code{tmpfile} function are removed; see @ref{Temporary Files}.
542
543 @item
544 @code{_exit} is called, terminating the program.  @xref{Termination Internals}.
545 @end enumerate
546
547 @node Exit Status
548 @subsection Exit Status
549 @cindex exit status
550
551 When a program exits, it can return to the parent process a small
552 amount of information about the cause of termination, using the
553 @dfn{exit status}.  This is a value between 0 and 255 that the exiting
554 process passes as an argument to @code{exit}.
555
556 Normally you should use the exit status to report very broad information
557 about success or failure.  You can't provide a lot of detail about the
558 reasons for the failure, and most parent processes would not want much
559 detail anyway.
560
561 There are conventions for what sorts of status values certain programs
562 should return.  The most common convention is simply 0 for success and 1
563 for failure.  Programs that perform comparison use a different
564 convention: they use status 1 to indicate a mismatch, and status 2 to
565 indicate an inability to compare.  Your program should follow an
566 existing convention if an existing convention makes sense for it.
567
568 A general convention reserves status values 128 and up for special
569 purposes.  In particular, the value 128 is used to indicate failure to
570 execute another program in a subprocess.  This convention is not
571 universally obeyed, but it is a good idea to follow it in your programs.
572
573 @strong{Warning:} Don't try to use the number of errors as the exit
574 status.  This is actually not very useful; a parent process would
575 generally not care how many errors occurred.  Worse than that, it does
576 not work, because the status value is truncated to eight bits.
577 Thus, if the program tried to report 256 errors, the parent would
578 receive a report of 0 errors---that is, success.
579
580 For the same reason, it does not work to use the value of @code{errno}
581 as the exit status---these can exceed 255.
582
583 @strong{Portability note:} Some non-POSIX systems use different
584 conventions for exit status values.  For greater portability, you can
585 use the macros @code{EXIT_SUCCESS} and @code{EXIT_FAILURE} for the
586 conventional status value for success and failure, respectively.  They
587 are declared in the file @file{stdlib.h}.
588 @pindex stdlib.h
589
590 @comment stdlib.h
591 @comment ISO
592 @deftypevr Macro int EXIT_SUCCESS
593 This macro can be used with the @code{exit} function to indicate
594 successful program completion.
595
596 On POSIX systems, the value of this macro is @code{0}.  On other
597 systems, the value might be some other (possibly non-constant) integer
598 expression.
599 @end deftypevr
600
601 @comment stdlib.h
602 @comment ISO
603 @deftypevr Macro int EXIT_FAILURE
604 This macro can be used with the @code{exit} function to indicate
605 unsuccessful program completion in a general sense.
606
607 On POSIX systems, the value of this macro is @code{1}.  On other
608 systems, the value might be some other (possibly non-constant) integer
609 expression.  Other nonzero status values also indicate failures.  Certain
610 programs use different nonzero status values to indicate particular
611 kinds of "non-success".  For example, @code{diff} uses status value
612 @code{1} to mean that the files are different, and @code{2} or more to
613 mean that there was difficulty in opening the files.
614 @end deftypevr
615
616 @node Cleanups on Exit
617 @subsection Cleanups on Exit
618
619 Your program can arrange to run its own cleanup functions if normal
620 termination happens.  If you are writing a library for use in various
621 application programs, then it is unreliable to insist that all
622 applications call the library's cleanup functions explicitly before
623 exiting.  It is much more robust to make the cleanup invisible to the
624 application, by setting up a cleanup function in the library itself
625 using @code{atexit} or @code{on_exit}.
626
627 @comment stdlib.h
628 @comment ISO
629 @deftypefun int atexit (void (*@var{function}) (void))
630 The @code{atexit} function registers the function @var{function} to be
631 called at normal program termination.  The @var{function} is called with
632 no arguments.
633
634 The return value from @code{atexit} is zero on success and nonzero if
635 the function cannot be registered.
636 @end deftypefun
637
638 @comment stdlib.h
639 @comment SunOS
640 @deftypefun int on_exit (void (*@var{function})(int @var{status}, void *@var{arg}), void *@var{arg})
641 This function is a somewhat more powerful variant of @code{atexit}.  It
642 accepts two arguments, a function @var{function} and an arbitrary
643 pointer @var{arg}.  At normal program termination, the @var{function} is
644 called with two arguments:  the @var{status} value passed to @code{exit},
645 and the @var{arg}.
646
647 This function is included in the GNU C library only for compatibility
648 for SunOS, and may not be supported by other implementations.
649 @end deftypefun
650
651 Here's a trivial program that illustrates the use of @code{exit} and
652 @code{atexit}:
653
654 @smallexample
655 @include atexit.c.texi
656 @end smallexample
657
658 @noindent
659 When this program is executed, it just prints the message and exits.
660
661 @node Aborting a Program
662 @subsection Aborting a Program
663 @cindex aborting a program
664
665 You can abort your program using the @code{abort} function.  The prototype
666 for this function is in @file{stdlib.h}.
667 @pindex stdlib.h
668
669 @comment stdlib.h
670 @comment ISO
671 @deftypefun void abort (void)
672 The @code{abort} function causes abnormal program termination.  This
673 does not execute cleanup functions registered with @code{atexit} or
674 @code{on_exit}.
675
676 This function actually terminates the process by raising a
677 @code{SIGABRT} signal, and your program can include a handler to
678 intercept this signal; see @ref{Signal Handling}.
679 @end deftypefun
680
681 @c Put in by rms.  Don't remove.
682 @cartouche
683 @strong{Future Change Warning:} Proposed Federal censorship regulations
684 may prohibit us from giving you information about the possibility of
685 calling this function.  We would be required to say that this is not an
686 acceptable way of terminating a program.
687 @end cartouche
688
689 @node Termination Internals
690 @subsection Termination Internals
691
692 The @code{_exit} function is the primitive used for process termination
693 by @code{exit}.  It is declared in the header file @file{unistd.h}.
694 @pindex unistd.h
695
696 @comment unistd.h
697 @comment POSIX.1
698 @deftypefun void _exit (int @var{status})
699 The @code{_exit} function is the primitive for causing a process to
700 terminate with status @var{status}.  Calling this function does not
701 execute cleanup functions registered with @code{atexit} or
702 @code{on_exit}.
703 @end deftypefun
704
705 When a process terminates for any reason---either by an explicit
706 termination call, or termination as a result of a signal---the
707 following things happen:
708
709 @itemize @bullet
710 @item
711 All open file descriptors in the process are closed.  @xref{Low-Level I/O}.
712 Note that streams are not flushed automatically when the process
713 terminates; @xref{I/O on Streams}.
714
715 @item
716 The low-order 8 bits of the return status code are saved to be reported
717 back to the parent process via @code{wait} or @code{waitpid}; see
718 @ref{Process Completion}.
719
720 @item
721 Any child processes of the process being terminated are assigned a new
722 parent process.  (On most systems, including GNU, this is the @code{init}
723 process, with process ID 1.)
724
725 @item
726 A @code{SIGCHLD} signal is sent to the parent process.
727
728 @item
729 If the process is a session leader that has a controlling terminal, then
730 a @code{SIGHUP} signal is sent to each process in the foreground job,
731 and the controlling terminal is disassociated from that session.
732 @xref{Job Control}.
733
734 @item
735 If termination of a process causes a process group to become orphaned,
736 and any member of that process group is stopped, then a @code{SIGHUP}
737 signal and a @code{SIGCONT} signal are sent to each process in the
738 group.  @xref{Job Control}.
739 @end itemize