Take the 2-minute tour ×
Unix & Linux Stack Exchange is a question and answer site for users of Linux, FreeBSD and other Un*x-like operating systems.. It's 100% free, no registration required.

What are the practical differences from a sysadmin point of view when deploying services on a unix based system?

share|improve this question
add comment

4 Answers 4

up vote 18 down vote accepted

The traditional way of daemonizing is:

fork()
setsid()
close(0) /* and /dev/null as fd 0, 1 and 2 */
close(1)
close(2)
fork()

This ensures that the process is no longer in the same process group as the terminal and thus won't be killed together with it. The IO redirection is to make output not appear on the terminal.

share|improve this answer
3  
so if a terminal that spawns a background process (&) is closed the background process will also terminate? –  user1561108 Nov 23 '12 at 19:33
4  
The process will receive SIGHUP when the terminal exits, the default handler for that signal is to terminate the process. –  Dennis Kaarsemaker Nov 23 '12 at 19:35
5  
Please add the & part explanation to your answer. It seems to be incomplete.. if you check the original question. –  mtk Nov 28 '12 at 16:24
    
That's because running things in the background with & doesn't make the process do anything special :) –  Dennis Kaarsemaker Nov 28 '12 at 17:42
add comment

For a daemon, what you want is a process that has no tie to anything. At the very least, you want it to be in its own session, not be attached to a terminal, not have any file descriptor inherited from the parent open to anything, not have a parent caring for you (other than init) have the current directory in / so as not to prevent a umount...

To detach from a terminal, you create a new session, however, to create a session, you must not be a group (or session) leader, so best is to fork a new process. Assuming the parent exits, that also means that process will not have a parent anymore and will be adopted by init. Then, you chdir("/"), close all possible file descriptors.

Because that process is a session leader, there's a risk that if it ever opens a terminal device, it becomes the controlling process of that terminal. Forking a second time ensures it doesn't happen.

On the other end, &, in interactive shells, forks and creates a new process group (so as not to be in the terminal's foreground process group), and in non-interactive shells, forks a process and ignores SIGINT in it. It doesn't detach from the terminal, doesn't close file descriptors (though some shells will reopen stdin to /dev/null)...

share|improve this answer
add comment

With command & Your process will be killed by a SIGHUP signal when the parent dies.

Sysadmins have access to some workaround, though.

On a bash system, you can use:

(trap '' HUP; command) &

This opens a subshell, traps the HUP signal with an empty handler and ampersand/forks it.

Output might still get redirected to the wrong tty. Or get lost.
You may fix that with &>command.out, 1>output.out, or 2>errors.out

You might also have access, on most systems, to the nohup command.
nohup simplifies this process greatly. it's quite standard, but I found many busybox embedded ARM distributions missing it. You just write:

nohup command &

..and you're done. Output gets redirected, IIRC, to nohup.out, but this filename can be changed with an option.

share|improve this answer
1  
Just to note that with with ZSH you can decouple a command & later from shell with disown which then works as a post-nohup. –  math Sep 24 '13 at 7:26
add comment

The difference between running a program/process as a daemon and forking it to the background using the ampersand is basically related to ownership.

Most often, the parent process of a daemon is the init process (the very first process to be started on a Unix system), the daemon being a child of that process means that it is not under your direct control as an non-privileged user. While on the other hand, forking a program/process to the background means that you can at any time call it back to the foreground and/or kill it.

share|improve this answer
1  
Also to answer the above technical side of detaching a process versus keeping it as a child of the terminal, you can try running "nohup firefox &" –  Sicp Nov 23 '12 at 20:01
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.