Mutual Exclusion and Running a Single Copy [open,lockf,getpid]

[hosseinyounesi]

Hi,
I'm writing a daemon and now that must be run in a single process (two instance of process should not be executed at the same time). I tried this code, but it didn't work:

    int lfp=open(LOCK_FILE, O_RDWR|O_CREAT,0640);
    if (lfp<0)
        cout << "Could not open lockfile" << endl;

    if ( lockf(lfp,F_TLOCK,0)<0 )
        exit(0); /* can not lock */
    
    /* first instance continues */

    char str[10];
    sprintf(str,"%d\n",getpid());
    write(lfp,str,strlen(str)); /* record pid to lockfile */
    close(lfp);

What's wrong?!

Thanks

[valaris]

What are the errors/problems?

[hosseinyounesi]

There is no compile error, but two or more instance of the program can still be executed at the same time (simultaneously)

[MisterIO]

Try using the library "unique", instead of reinventing the wheel.

[hosseinyounesi]

"unique" library?! What do you mean?! It's a C library or ... ?!

[MisterIO]

Yes, it's a c library. Debian -- Details of package libunique-1.0-0 in sid

[Codeplug]

Well, that's Gnome specific (with X11 dependencies). Internally it uses either Unix domain sockets or D-Bus.

>> What's wrong?!
Only thing I see wrong is that "if (lfp<0)" allows execution to continue.

gg

[brewbuck]

A more reliable way is to use a UNIX socket. Two processes cannot both bind to the same UNIX socket name. As part of your startup, open and bind a UNIX socket at some known location (probably somewhere in /var). If you fail to bind, you know another instance is already running.

[MisterIO]

Well, that's Gnome specific (with X11 dependencies). Internally it uses either Unix domain sockets or D-Bus.

>> What's wrong?!
Only thing I see wrong is that "if (lfp<0)" allows execution to continue.

gg

It's not gnome specific. It has dependencies(as can be seen from the link), but that's different from being gnome specific.

[Codeplug]

I would say it's "as realiable", since advisory-locks held by a process are removed when the descriptor is closed - and all descriptors are closed when the process exits. But sockets provide a comm. channel which may be useful.

Which brings up the question: Are you sure that both processes are just acquiring and releasing the lock, one after another? If the code you posted is the code you're running, then that's probably the case.

Also, you may want to ftruncate() the file once you acquire the lock to prevent any "left-overs" from previous write() of longer pids.

>> It's not gnome specific.
Sorry, GTK+, X11 dependent would be more accurate.

gg

[hosseinyounesi]

channel which may be useful.

What's this?!

Which brings up the question: Are you sure that both processes are just acquiring and releasing the lock, one after another? If the code you posted is the code you're running, then that's probably the case.

With the code I posted, two execution of the program can be executed and the lockf return 0 for each of them!!!

[hosseinyounesi]

Hi,
I used flock and it is working now
flock(2) - Linux man page

    int fd=open(LOCK_FILE, O_RDWR|O_CREAT,0640);
    if (fd<0)
        cout << "Could not open lockfile" << endl;

    int x=flock(fd,LOCK_EX | LOCK_NB);
    if( x<0 )
        exit(1);
    /* first instance continues */