What's the difference between running a program as a daemon and forking it into background with '&'?

Question

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

Solution 1

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.

Solution 2

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, close all possible file descriptors, you chdir("/") (one can't close the current working directory to release that resource like for file descriptors, making / the current working directories at least doesn't prevent unmounting directories).

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)...

Solution 3

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.

Solution 4

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

Sysadmins have access to some workarounds, 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.

View more solutions

Comments

[user1561108]

so if a terminal that spawns a background process (&) is closed the background process will also terminate?

[Dennis Kaarsemaker]

The process will receive SIGHUP when the terminal exits, the default handler for that signal is to terminate the process.

[Vignesh]

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 &"

[ekoeppen]

Please add the & part explanation to your answer. It seems to be incomplete.. if you check the original question.

[Dennis Kaarsemaker]

That's because running things in the background with & doesn't make the process do anything special :)

[math]

Just to note that with with ZSH you can decouple a command & later from shell with disown which then works as a post-nohup.

[Timothy Leung]

what is the use for chdir("/")? to close file descriptor?

[Stéphane Chazelas]

@TimothyLeung, see edit.

[GypsyCosmonaut]

@StéphaneChazelas How about doing COMMAND & disown. This detaches the process from the terminal, right ? What's the difference between & disown and daemon assuming I did & disown with the process running with current directory being /