/*
* Copyright (C) 2009 Karel Zak <kzak@redhat.com>
*
* This file may be redistributed under the terms of the
* GNU Lesser General Public License.
*/
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <sys/time.h>
#include <time.h>
#include <signal.h>
#include <fcntl.h>
#include <limits.h>
#include "pathnames.h"
#include "nls.h"
#include "mountP.h"
/*
* lock handler
*/
struct _mnt_lock {
pid_t id; /* getpid() or so (see linkfile)... */
char *lockfile; /* path to lock file (e.g. /etc/mtab~) */
char *linkfile; /* path to link file (e.g. /etc/mtab~.<id>) */
int lockfile_fd; /* lock file descriptor */
int locked; /* do we own the lock? */
};
/**
* mnt_new_lock:
* @lockfile: path to lockfile or NULL (default is _PATH_MOUNTED_LOCK)
* @id: unique linkfile identifier or 0 (default is getpid())
*
* Returns newly allocated lock handler or NULL on case of error.
*/
mnt_lock *mnt_new_lock(const char *lockfile, pid_t id)
{
mnt_lock *ml = calloc(1, sizeof(struct _mnt_lock));
if (!ml)
return NULL;
ml->lockfile_fd = -1;
ml->id = id;
if (lockfile) {
ml->lockfile = strdup(lockfile);
if (!ml->lockfile) {
free(ml);
return NULL;
}
}
return ml;
}
/**
* mnt_free_lock:
* @ml: mnt_lock handler
*
* Deallocates mnt_lock.
*/
void mnt_free_lock(mnt_lock *ml)
{
if (!ml)
return;
free(ml->lockfile);
free(ml->linkfile);
free(ml);
}
/**
* mnt_lock_get_lockfile:
* @ml: mnt_lock handler
*
* Returns path to lockfile.
*/
const char *mnt_lock_get_lockfile(mnt_lock *ml)
{
if (!ml)
return NULL;
if (ml->lockfile)
return ml->lockfile;
return _PATH_MOUNTED_LOCK;
}
/**
* mnt_lock_get_linkfile:
* @ml: mnt_lock handler
*
* Returns unique (per process) path to linkfile.
*/
const char *mnt_lock_get_linkfile(mnt_lock *ml)
{
if (!ml)
return NULL;
if (!ml->linkfile) {
const char *lf = mnt_lock_get_lockfile(ml);
size_t sz;
if (!lf)
return NULL;
sz = strlen(lf) + 32;
ml->linkfile = malloc(sz);
if (ml->linkfile)
snprintf(ml->linkfile, sz, "%s.%d",
lf, ml->id ? ml->id : getpid());
}
return ml->linkfile;
}
static void mnt_lockalrm_handler(int sig)
{
/* do nothing, say nothing, be nothing */
}
/*
* Waits for F_SETLKW, unfortunately we have to use SIGALRM here to interrupt
* fcntl() to avoid never ending waiting.
*
* Returns 0 on success, 1 on timeout, -errno on error.
*/
static int mnt_wait_lock(mnt_lock *ml, struct flock *fl, time_t maxtime)
{
struct timeval now;
struct sigaction sa, osa;
int ret = 0;
gettimeofday(&now, NULL);
if (now.tv_sec >= maxtime)
return 1; /* timeout */
/* setup ALARM handler -- we don't want to wait forever */
sa.sa_flags = 0;
sa.sa_handler = mnt_lockalrm_handler;
sigfillset (&sa.sa_mask);
sigaction(SIGALRM, &sa, &osa);
DBG(DEBUG_LOCKS, fprintf(stderr,
"LOCK: (%d) waiting for F_SETLKW.\n", getpid()));
alarm(maxtime - now.tv_sec);
if (fcntl(ml->lockfile_fd, F_SETLKW, fl) == -1)
ret = errno == EINTR ? 1 : -errno;
alarm(0);
/* restore old sigaction */
sigaction(SIGALRM, &osa, NULL);
DBG(DEBUG_LOCKS, fprintf(stderr,
"LOCK: (%d) leaving mnt_wait_setlkw(), rc=%d.\n", getpid(), ret));
return ret;
}
/*
* Create the lock file.
*
* The old code here used flock on a lock file /etc/mtab~ and deleted
* this lock file afterwards. However, as rgooch remarks, that has a
* race: a second mount may be waiting on the lock and proceed as
* soon as the lock file is deleted by the first mount, and immediately
* afterwards a third mount comes, creates a new /etc/mtab~, applies
* flock to that, and also proceeds, so that the second and third mount
* now both are scribbling in /etc/mtab.
*
* The new code uses a link() instead of a creat(), where we proceed
* only if it was us that created the lock, and hence we always have
* to delete the lock afterwards. Now the use of flock() is in principle
* superfluous, but avoids an arbitrary sleep().
*
* Where does the link point to? Obvious choices are mtab and mtab~~.
* HJLu points out that the latter leads to races. Right now we use
* mtab~.<pid> instead.
*
*
* The original mount locking code has used sleep(1) between attempts and
* maximal number of attempts has been 5.
*
* There was very small number of attempts and extremely long waiting (1s)
* that is useless on machines with large number of mount processes.
*
* Now we wait few thousand microseconds between attempts and we have global
* time limit (30s) rather than limit for number of attempts. The advantage
* is that this method also counts time which we spend in fcntl(F_SETLKW) and
* number of attempts is not restricted.
* -- kzak@redhat.com [Mar-2007]
*
*
* This mtab locking code has been refactored and moved to libmount. The mtab
* locking is really not perfect (e.g. SIGALRM), but it's stable, reliable and
* backwardly compatible code. Don't forget that this code has to be compatible
* with 3rd party mounts (/sbin/mount.<foo>) and has to work with NFS.
* -- kzak@redhat.com [May-2009]
*/
/* maximum seconds between first and last attempt */
#define MOUNTLOCK_MAXTIME 30
/* sleep time (in microseconds, max=999999) between attempts */
#define MOUNTLOCK_WAITTIME 5000
/* Remove lock file. */
void mnt_unlock_file(mnt_lock *ml)
{
if (!ml)
return;
DBG(DEBUG_LOCKS, fprintf(stderr, "LOCK: (%d) unlocking/cleaning.\n", getpid()));
if (ml->locked == 0 && ml->lockfile && ml->linkfile)
{
/* We have (probably) all files, but we don't own the lock,
* Really? Check it! Maybe ml->locked wasn't set properly
* because code was interrupted by signal. Paranoia? Yes.
*
* We own the lock when linkfile == lockfile.
*/
struct stat lo, li;
if (!stat(ml->lockfile, &lo) && !stat(ml->linkfile, &li) &&
lo.st_dev == li.st_dev && lo.st_ino == li.st_ino)
ml->locked = 1;
}
if (ml->linkfile)
unlink(ml->linkfile);
if (ml->lockfile_fd >= 0)
close(ml->lockfile_fd);
if (ml->locked == 1 && ml->lockfile)
unlink(ml->lockfile);
ml->locked = 0;
ml->lockfile_fd = -1;
}
/**
* mnt_lock:
* @ml: pointer to mnt_lock instance
*
* Creates lock file (e.g. /etc/mtab~). Note that this function uses
* alarm().
*
* Your application has to always call mnt_unlock_file() before exit.
*
* Locking scheme:
*
* 1. create linkfile (e.g. /etc/mtab~.<pid>)
* 2. link linkfile --> lockfile (e.g. /etc/mtab~.<pid> --> /etc/mtab~)
*
* 3. a) link() successful: setups F_SETLK lock (see fcnlt(2))
* b) link() failed: wait (max 30s) on F_SETLKW lock, goto 2.
*
* Example:
*
* mnt_lock *ml;
*
* void unlock_fallback(void)
* {
* if (!ml)
* return;
* mnt_unlock_file(ml);
* mnt_free_lock(ml);
* }
*
* int update_mtab()
* {
* int sig = 0;
*
* atexit(unlock_fallback);
*
* ml = mnt_new_lock(NULL, 0);
*
* if (mnt_lock_file(ml) != 0) {
* printf(stderr, "cannot create %s lockfile\n",
* mnt_lock_get_lockfile(ml));
* return -1;
* }
*
* ... modify mtab ...
*
* mnt_unlock_file(ml);
* mnt_free_lock(ml);
* ml = NULL;
* return 0;
* }
*
* Returns 0 on success or -1 in case of error.
*/
int mnt_lock_file(mnt_lock *ml)
{
int i;
struct timespec waittime;
struct timeval maxtime;
const char *lockfile, *linkfile;
if (!ml)
return -1;
if (ml->locked)
return 0;
lockfile = mnt_lock_get_lockfile(ml);
if (!lockfile)
return -1;
linkfile = mnt_lock_get_linkfile(ml);
if (!linkfile)
return -1;
i = open(linkfile, O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR);
if (i < 0)
/* linkfile does not exist (as a file)
and we cannot create it. Read-only filesystem?
Too many files open in the system?
Filesystem full? */
goto failed;
close(i);
gettimeofday(&maxtime, NULL);
maxtime.tv_sec += MOUNTLOCK_MAXTIME;
waittime.tv_sec = 0;
waittime.tv_nsec = (1000 * MOUNTLOCK_WAITTIME);
/* Repeat until it was us who made the link */
while (ml->locked == 0) {
struct timeval now;
struct flock flock;
int j;
j = link(linkfile, lockfile);
if (j == 0)
ml->locked = 1;
if (j < 0 && errno != EEXIST)
goto failed;
ml->lockfile_fd = open(lockfile, O_WRONLY);
if (ml->lockfile_fd < 0) {
/* Strange... Maybe the file was just deleted? */
int errsv = errno;
gettimeofday(&now, NULL);
if (errsv == ENOENT && now.tv_sec < maxtime.tv_sec) {
ml->locked = 0;
continue;
}
goto failed;
}
flock.l_type = F_WRLCK;
flock.l_whence = SEEK_SET;
flock.l_start = 0;
flock.l_len = 0;
if (ml->locked) {
/* We made the link. Now claim the lock. */
if (fcntl (ml->lockfile_fd, F_SETLK, &flock) == -1) {
DBG(DEBUG_LOCKS, fprintf(stderr,
"%s: can't F_SETLK lockfile, errno=%d\n",
lockfile, errno));
/* proceed, since it was us who created the lockfile anyway */
}
break;
} else {
/* Someone else made the link. Wait. */
int err = mnt_wait_lock(ml, &flock, maxtime.tv_sec);
if (err == 1) {
DBG(DEBUG_LOCKS, fprintf(stderr,
"%s: can't create link: time out (perhaps "
"there is a stale lock file?)", lockfile));
goto failed;
} else if (err < 0)
goto failed;
nanosleep(&waittime, NULL);
close(ml->lockfile_fd);
ml->lockfile_fd = -1;
}
}
DBG(DEBUG_LOCKS, fprintf(stderr,
"LOCK: %s: (%d) successfully locked\n",
ml->lockfile, getpid()));
unlink(linkfile);
return 0;
failed:
mnt_unlock_file(ml);
return -1;
}
#ifdef TEST_PROGRAM
#include <err.h>
mnt_lock *lock;
/*
* read number from @filename, increment the number and
* write the number back to the file
*/
void increment_data(const char *filename, int verbose, int loopno)
{
long num;
FILE *f;
char buf[256];
if (!(f = fopen(filename, "r")))
err(EXIT_FAILURE, "%d: failed to open: %s", getpid(), filename);
if (!fgets(buf, sizeof(buf), f))
err(EXIT_FAILURE, "%d failed read: %s", getpid(), filename);
fclose(f);
num = atol(buf) + 1;
if (!(f = fopen(filename, "w")))
err(EXIT_FAILURE, "%d: failed to open: %s", getpid(), filename);
fprintf(f, "%ld", num);
fclose(f);
if (verbose)
fprintf(stderr, "%d: %s: %ld --> %ld (loop=%d)\n", getpid(),
filename, num - 1, num, loopno);
}
void clean_lock(void)
{
fprintf(stderr, "%d: cleaning\n", getpid());
if (!lock)
return;
mnt_unlock_file(lock);
mnt_free_lock(lock);
}
void sig_handler(int sig)
{
errx(EXIT_FAILURE, "\n%d: catch signal: %s\n", getpid(), strsignal(sig));
}
int test_lock(struct mtest *ts, int argc, char *argv[])
{
const char *lockfile, *datafile;
int verbose = 0, loops, l;
if (argc < 4)
return -1;
lockfile = argv[1];
datafile = argv[2];
loops = atoi(argv[3]);
if (argc == 5 && strcmp(argv[4], "--verbose") == 0)
verbose = 1;
atexit(clean_lock);
/* be paranoid and call exit() (=clean_lock()) for all signals */
{
int sig = 0;
struct sigaction sa;
sa.sa_handler = sig_handler;
sa.sa_flags = 0;
sigfillset(&sa.sa_mask);
while (sigismember(&sa.sa_mask, ++sig) != -1 && sig != SIGCHLD)
sigaction (sig, &sa, (struct sigaction *) 0);
}
for (l = 0; l < loops; l++) {
lock = mnt_new_lock(lockfile, 0);
if (mnt_lock_file(lock) == -1) {
fprintf(stderr, "%d: failed to create lock file: %s\n",
getpid(), lockfile);
return -1;
}
increment_data(datafile, verbose, l);
mnt_unlock_file(lock);
mnt_free_lock(lock);
lock = NULL;
}
return 0;
}
int main(int argc, char *argv[])
{
struct mtest tss[] = {
{ "--lock", test_lock, " <lockfile> <datafile> <loops> [--verbose] increment number in datafile" },
{ NULL }
};
return mnt_run_test(tss, argc, argv);
}
#endif /* TEST_PROGRAM */
