Linux Development Magazine

Linux programming articles

  • Linux logo
  • Categories

  • Calendar

    May 2010
    M T W T F S S

How to create a Linux daemon

Posted by jajcarmona on 2010/05/18

In Linux, a daemon is a program that runs in the background, rather than under the direct control of a user. It can be initiated by the user or by the system at boot time (in this case, it would be a system service).

The parent process of a daemon forks a child process that do the work and immediately after the forking, the parent exits. The child process keep running and the interface that launched the daemon (the parent process) doesn’t block.

An example of a Python daemon will be the next: file:

#!/usr/bin/env python

import sys, os, time, atexit
from signal import SIGTERM

class Daemon:
    A generic daemon class.

    Usage: Subclass this class and override the ‘run’ method
    def __init__(self, pidfile, stdin=’/dev/null’, stdout=’/dev/null’, stderr=’/dev/null’):
        self.stdin = stdin
        self.stdout = stdout
        self.stderr = stderr
        self.pidfile = pidfile

    def daemonize(self):
        Do the ‘UNIX double-fork magic’
            pid = os.fork()
            if pid > 0:
                # Exit first parent
        except OSError, e:
            sys.stderr.write(“Fork #1 failed: %d (%s)\n” % (e.errno, e.strerror))

        # Decouple from parent environment

        # Do second fork
            pid = os.fork()
            if pid > 0:
                # Exit from second parent
        except OSError, e:
            sys.stderr.write(“Fork #2 failed: %d (%s)\n” % (e.errno, e.strerror))

        # Redirect standard file descriptors
        si = file(self.stdin, ‘r’)
        so = file(self.stdout, ‘a+’)
        se = file(self.stderr, ‘a+’, 0)
        os.dup2(si.fileno(), sys.stdin.fileno())
        os.dup2(so.fileno(), sys.stdout.fileno())
        os.dup2(se.fileno(), sys.stderr.fileno())

        # Write pidfile
        pid = str(os.getpid())
        file(self.pidfile,’w+’).write(“%s\n” % pid)

    def delpid(self):

    def start(self):
        # Check for a pidfile to see if the daemon already runs
            pf = file(self.pidfile,’r’)
            pid = int(
        except IOError:
            pid = None

        if pid:
            message = “Pidfile %s already exist. Daemon already running?\n”
            sys.stderr.write(message % self.pidfile)

        # Start the daemon

    def stop(self):
        # Get the pid from the pidfile
            pf = file(self.pidfile,’r’)
            pid = int(
        except IOError:
            pid = None

        if not pid:
            message = “Pidfile %s does not exist. Daemon not running?\n”
            sys.stderr.write(message % self.pidfile)
            return # not an error in a restart

        # Try killing the daemon process
            while 1:
                os.kill(pid, SIGTERM)
        except OSError, err:
            err = str(err)
            if err.find(“No such process”) > 0:
                if os.path.exists(self.pidfile):
                print str(err)

    def restart(self):

    def run(self):
        You should override this method when you subclass Daemon. It will be called after the process has been
        daemonized by start() or restart().
        “”” file:

#!/usr/bin/env python

import sys, time
from daemon import Daemon

class MyDaemon(Daemon):
    def run(self):
        while True:
         # Do any task here

if __name__ == “__main__”:
    daemon = MyDaemon(‘/tmp/’)
    if len(sys.argv) == 2:
        if ‘start’ == sys.argv[1]:
        elif ‘stop’ == sys.argv[1]:
        elif ‘restart’ == sys.argv[1]:
            print “Unknown command”
        print “Usage: %s start|stop|restart” % sys.argv[0]

Note that in Daemon class, we check if a file named exists (the PID file), because if exists, it means that daemon is currently running and it’s not necessary to run it again. The file is created in a temporal files folder when we start the daemon and is deleted when we stop the daemon. If we want to run the daemon simultaneously in more than one user session, one solution could be the concatenation of the current user name to the PID file name (for example,

In a terminal, to start the daemon, we should run the next command:

python start

to stop the daemon we should run the next command:

python stop

and to restart the daemon we should run the next command:

python restart

Try out to launch the daemon two times without stopping to see how the daemon doesn’t run again if is currently running.


Article about Linux daemons:

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: