nohup(1) 맨 페이지 - 윈디하나의 솔라나라

개요

섹션
맨페이지이름
검색(S)

nohup

Name
     nohup - run a command immune to hangups

Synopsis
     /usr/bin/nohup command [argument]...


     /usr/bin/nohup -p [-Fa] pid [pid]...


     /usr/bin/nohup -g [-Fa] gpid [gpid]...


     /usr/xpg4/bin/nohup command [argument]...

Description
     The nohup utility invokes the named command with  the  argu-
     ments  supplied. When the command is invoked, nohup arranges
     for the SIGHUP signal to be ignored by the process.


     When invoked with the -p or -g  flags,  nohup  arranges  for
     processes already running as identified by a list of process
     IDs or a list of process group IDs to become immune to hang-
     ups.


     The nohup utility can be used when it is known that  command
     takes  a  long  time to run and the user wants to log out of
     the terminal. When a shell exits, the system sends its chil-
     dren  SIGHUP  signals,  which  by  default  cause them to be
     killed. All stopped, running, and  background  jobs  ignores
     SIGHUP and continue running, if their invocation is preceded
     by the nohup command or if the process programmatically  has
     chosen to ignore SIGHUP.


     The nohup utility causes processes to ignore SIGHUP but does
     not  in  any way protect those processes from other signals.
     Since modern shells sometimes send signals other than SIGHUP
     upon   logout,   it  is  possible  for  jobs  running  under
     /usr/bin/nohup to  be  killed  when  the  controlling  shell
     exits.

     /usr/bin/nohup
                                Processes run  by  /usr/bin/nohup
                                are immune to SIGHUP (hangup) and
                                SIGQUIT (quit) signals.


     /usr/bin/nohup -p [-Fa]
                                Processes  specified  by  ID  are
                                made   immune   to   SIGHUP   and

                                SIGQUIT, and all  output  to  the
                                controlling      terminal    is
                                redirected to nohup.out. If -F is
                                specified,  nohup  forces control
                                of each process. If -a is  speci-
                                fied,  nohup  changes  the signal
                                disposition of SIGHUP and SIGQUIT
                                even if the process has installed
                                a handler for either signal.


     /usr/bin/nohup -g [-Fa]
                                Every process in the same process
                                group  as the processes specified
                                by ID are made immune  to  SIGHUP
                                and  SIGQUIT,  and  all output to
                                the   controlling   terminal   is
                                redirected to nohup.out. If -F is
                                specified, nohup  forces  control
                                of  each process. If -a is speci-
                                fied, nohup  changes  the  signal
                                disposition of SIGHUP and SIGQUIT
                                even if the process has installed
                                a handler for either signal.


     /usr/xpg4/bin/nohup
                                Processes         run          by
                                /usr/xpg4/bin/nohup are immune to
                                SIGHUP.

                                The  nohup   utility   does   not
                                arrange  to make processes immune
                                to a SIGTERM (terminate)  signal,
                                so  unless  they  arrange  to  be
                                immune to SIGTERM  or  the  shell
                                makes  them  immune  to  SIGTERM,
                                they receive it.

                                If nohup.out is not  writable  in
                                the  current directory, output is
                                redirected to $HOME/nohup.out. If
                                a  file  is created, the file has
                                read and write  permission  (600.
                                See  chmod(1).  If  the  standard
                                error  is  a  terminal,   it   is
                                redirected  to  the standard out-
                                put,   otherwise   it   is    not
                                redirected.  The  priority of the
                                process  run  by  nohup  is   not
                                altered.

Options
     The following options are supported:

     -a
           Always  changes  the  signal  disposition  of   target
           processes.  This  option  is valid only when specified
           with -p or -g.


     -F
           Force. Grabs the target processes even if another pro-
           cess  has  control.  This  option  is  valid only when
           specified with -p or -g.


     -g
           Operates on a list of process groups. This  option  is
           not valid with -p.


     -p
           Operates on a list of processes. This  option  is  not
           valid with -g.

Operands
     The following operands are supported:

     pid
                 A decimal process ID to be manipulated by  nohup
                 -p.


     pgid
                 A decimal process group ID to be manipulated  by
                 nohup -g.


     command
                 The name of a command that is to be invoked.  If
                 the  command  operand  names  any of the special
                 shell_builtins(1)  utilities,  the  results  are
                 undefined.


     argument
                 Any string to be supplied as  an  argument  when
                 invoking the command operand.

Usage
     Caution should be exercised when using the -F flag. Imposing
     two  controlling processes on one victim process can lead to
     chaos. Safety is assured only  if  the  primary  controlling
     process,  typically  a debugger, has stopped the victim pro-
     cess and the primary controlling process is doing nothing at
     the moment of application of the proc tool in question.

Examples

     Example 1 Applying nohup to Pipelines or Command Lists


     It is frequently desirable to apply nohup  to  pipelines  or
     lists  of  commands.  This can be done only by placing pipe-
     lines and command lists in a single  file,  called  a  shell
     script. One can then issue:


       example$ nohup sh file




     and the nohup applies to everything in file.  If  the  shell
     script  file  is to be executed often, then the need to type
     sh can be eliminated by giving file execute permission.



     Add an ampersand and the contents of file  are  run  in  the
     background with interrupts also ignored (see sh(1)):


       example$ nohup file &



     Example 2 Applying nohup -p to a Process

       example$ long_running_command &
       example$ nohup -p `pgrep long_running_command`



     Example 3 Applying nohup -g to a Process Group

       example$ make &
       example$ ps -o sid -p $$
          SID
       81079
       example$ nohup -g `pgrep -s 81079 make`

Environment Variables
     See environ(5) for descriptions of the following environment
     variables  that affect the execution of nohup: LANG, LC_ALL,
     LC_CTYPE, LC_MESSAGES, PATH, NLSPATH, and PATH.

     HOME
             Determine the path name of the  user's  home  direc-
             tory: if the output file nohup.out cannot be created
             in the current directory, the nohup command uses the
             directory named by HOME to create the file.

Exit Status
     The following exit values are returned:

     126
            command was found but could not be invoked.


     127
            An error occurred in nohup, or command could  not  be
            found



     Otherwise, the exit values of nohup are those of the command
     operand.

Files
     nohup.out
                        The output file of the nohup execution if
                        standard  output is a terminal and if the
                        current directory is writable.


     $HOME/nohup.out
                        The output file of the nohup execution if
                        standard  output is a terminal and if the
                        current directory is not writable.

Attributes
     See attributes(5) for descriptions of the  following  attri-
     butes:

  /usr/bin/nohup
     tab() box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i)  ATTRI-
     BUTE  TYPEATTRIBUTE  VALUE  _  Availabilitysystem/core-os  _
     CSIEnabled


  /usr/xpg4/bin/nohup
     tab() box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i)  ATTRI-
     BUTE  TYPEATTRIBUTE  VALUE _ Availabilitysystem/xopen/xcu4 _
     CSIEnabled  _  Interface  StabilityCommitted  _  StandardSee
     standards(5).

See Also
     bash(1), batch(1), chmod(1),  csh(1),  disown(1),  ksh88(1),
     nice(1), pgrep(1), proc(1), ps(1), sh(1), shell_builtins(1),
     setpgrp(1), signal(3C), proc(4), attributes(5),  environ(5),
     standards(5)

Warnings
     If you are running the Korn shell (ksh88(1)) as  your  login
     shell,  and  have  nohup'ed jobs running when you attempt to
     log out, you are warned with the message:

       You have jobs running.




     You need to log out a second time to actually log out.  How-
     ever, your background jobs continues to run.

Notes
     The C-shell (csh(1)) has a built-in command nohup that  pro-
     vides  immunity from SIGHUP, but does not redirect output to
     nohup.out. Commands  executed  with  `&'  are  automatically
     immune to HUP signals while in the background.


     nohup does not recognize command sequences. In the  case  of
     the following command,

       example$ nohup command1; command2




     the nohup utility applies only to command1. The command,

       example$ nohup (command1; command2)




     is syntactically incorrect.
맨 페이지 내용의 저작권은 맨 페이지 작성자에게 있습니다.
RSS ATOM XHTML 1.0 CSS3