How to lock and unlock pid file using "fcntl ()"

Question

I am doing a survey on the network and even in the stackoverflow inorder to find an example of using fcntl() to lock and unlock the pid file "/var/run/myapp.pid" , but I did not find a clear example for this.

Could you give me an example using fcntl() to lock and unlock a pid file?

Lock should not be locked (if the file is locked)

Answer 1

As you noted Linux, verbatim form man lockf (highlighted by me):

On Linux, lockf () is just an interface on top of fcntl (2) locks. Many other systems implement lockf () this way, but note that POSIX.1-2001 leaves the connection between lockf () and fcntl (2) unspecified locks. Perhaps the portable application should avoid mixing calls with these interfaces.

So, looking through the current glibc sources ( eglibc-2.11.3/io/lockf.c ), a possible use of fcntl() to implement locking is as follows:

 /* Copyright (C) 1994,1996,1997,1998,2000,2003 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ #include <sys/types.h> #include <unistd.h> #include <fcntl.h> #include <errno.h> #include <string.h> /* lockf is a simplified interface to fcntl locking facilities. */ int lockf (int fd, int cmd, off_t len) { struct flock fl; memset ((char *) &fl, '\0', sizeof (fl)); /* lockf is always relative to the current file position. */ fl.l_whence = SEEK_CUR; fl.l_start = 0; fl.l_len = len; switch (cmd) { case F_TEST: /* Test the lock: return 0 if FD is unlocked or locked by this process; return -1, set errno to EACCES, if another process holds the lock. */ fl.l_type = F_RDLCK; if (__fcntl (fd, F_GETLK, &fl) < 0) return -1; if (fl.l_type == F_UNLCK || fl.l_pid == __getpid ()) return 0; __set_errno (EACCES); return -1; case F_ULOCK: fl.l_type = F_UNLCK; cmd = F_SETLK; break; case F_LOCK: fl.l_type = F_WRLCK; cmd = F_SETLKW; break; case F_TLOCK: fl.l_type = F_WRLCK; cmd = F_SETLK; break; default: __set_errno (EINVAL); return -1; } /* lockf() is a cancellation point but so is fcntl() if F_SETLKW is used. Therefore we don't have to care about cancellation here, the fcntl() function will take care of it. */ return __fcntl (fd, cmd, &fl); } 

In order to first perform this compilation, you need several mods:

• replace __fcntl with fcntl
• replace __set_errno(<errno-define>) with errno = <errno-define>

.. and secondly so that it becomes async-signal-save:

• replace the call with memset() with the appropriate settings for the struct fcntl variable.