restricting multiple instance of a program

Hi,

I have written one server program(daemon) in C/Fedora core II. I want to resrict the multiple instance of the same server program running in one machine? How to do that? Thanx in advance.

--Ganesh.

Well..........I can think of 2 options -
1. Put some kind of flag in the filesystem. OR
2. Scan thro the /proc directory to check if another instance is alive or not

In Windows you would use something known as "atoms" to accomplish that. Maybe some googling will reveal if there's something similar in *nix?

there is this file called cmdline in every dir of /proc
which tells you the exact location of the executable and path used
so you could use that to identify your process
man proc for details

Well, maybe it's good enough for the OP but that won't do if the you have an exakt copy of the program somewhere, only with a different name.

you could create some file in /tmp dir when ever the daemon is started
which could be checked when the process is starting.. so that even
if the exact same copy with a different name is executing you can stop.
Well but then there might be a situation when the process is killed and
the file may be left without deletion.. this might again cause problem.

Maybe he can use a global mutex? That would be the neatest solution but I don't know if such a thing exists for *nix, but I am looking into it now.

This seems to work pretty well:

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>

int fdlock;

int get_lock(void)
{
  struct flock fl;

  fl.l_type = F_WRLCK;
  fl.l_whence = SEEK_SET;
  fl.l_start = 0;
  fl.l_len = 1;

  if((fdlock = open("oneproc.lock", O_WRONLY|O_CREAT, 0666)) == -1)
    return 0;

  if(fcntl(fdlock, F_SETLK, &fl) == -1)
    return 0;

  return 1;
}

int main(void)
{
  if(!get_lock())
  {
    fputs("Process already running!\n", stderr);
    return 1;
  }

  getchar();
  return 0;
}

It leaves a file sitting there (you probably want to put it in /tmp), but it only complains when another process actually has a lock on the file...just the fact that the file exists isn't enough to make it complain.

Will the lock be lost if the process is killed??

Originally posted by gizmo_thunder Will the lock be lost if the process is killed??

Yes, I tested that. The lock only exists as long as the program is running, which is what I thought you wanted.

thanks pal that helped

Thanx. I think file lock solution is the gud one and it works.

Originally Posted by itsme86 This seems to work pretty well: It leaves a file sitting there (you probably want to put it in /tmp), but it only complains when another process actually has a lock on the file...just the fact that the file exists isn't enough to make it complain.

I have created the oneproc.lock in my temp directory. For the lock file oneproc.lock do I need to give permission to the file as 666?

Depends who is running the prog. Remember perms are ugo (user/group/other). The only 'people' who need access to the file are those that are likely to be using the prog...
If it's always only run by users in one group, then 'other' aka world needs no perms on the file.

Linux can use semaphores as well. There is the old stye using semctl and the new POSIX style using sem_open. The old style is available on most all Linux boxes, but the new POSIX style may not be available.
For the old style, you use a ftok to get a key, then use the key to get a semaphore, using IPC_EXCL|IPC_CREAT. These semaphores must be explicitly removed with semctl and the flag IPC_RMID.

If you use the file locking above and want to be able to write to more than one byte of the file, set fl.l_len = 0; This is a special case and will lock the whole file.