cross-process locking in linux

Question

I am looking to make an application in Linux, where only one instance of the application can run at a time. I want to make it robust, such that if an instance of the app crashes, that it won't block all the other instances indefinitely. I would really appreciate some example code on how to do this (as there's lots of discussion on this topic on the web, but I couldn't find anything which worked when I tried it).

Answer 1

You can use file locking facilities that Linux provides. You haven't specified the language, however you might find this capability pretty much everywhere in some form or another.

Here is a simple idea how to do that in a C program. When the program starts you can take an exclusive non-blocking lock on the whole file using fcntl system call. When another instance of the applications is attempted to be started, it will get an error trying to lock the file, which will mean the application is already running.

Here is a small example how to take the full file lock using fcntl (this function provides facilities for putting byte range locks, but when length is 0, the full file is locked).

   struct flock lock_struct;

   memset(&lock_struct, 0, sizeof(lock_struct));

   lock_struct.l_type = F_WRLCK;
   lock_struct.l_whence = SEEK_SET;
   lock_struct.l_pid = getpid();

   ret = fcntl(fd, F_SETLK, &lock_struct);

Please note that you need to open a file first to put a lock. This means you need to have a file around to use for locking. It might be useful to put the it somewhere where it won't cause any distraction/confusion for other applications.

When the process terminates, all locks that it has taken will be released, so nothing will be blocked.

This is just one of the ideas. I'm pretty sure there are other ways around.

Answer 2

The conventional UNIX way of doing this is with PID files.

Before a process starts, it checks to see if a pre-determined file - usually /var/run/<process_name>.pid exists. If found, its an indication that a process is already running and this process quits.

If the file does not exist, this is the first process to run. It creates the file /var/run/<process_name>.pid and writes its PID into it. The process unlinks the file on exit.

Update:

To handle cases where a daemon has crashed & left behind the pid file, additional checks can be made during startup if a pid file was found:

• Do a ps and ensure that a process with that PID doesn't exist
• If it exists ensure that its a different process
  • from the said ps output
  • from /proc/$PID/stat