libmount: add mtab locking code

Signed-off-by: Karel Zak <kzak@redhat.com>

1 files changed, 510 insertions, 0 deletions

diff --git a/shlibs/mount/src/lock.c b/shlibs/mount/src/lock.c
new file mode 100644
index 000000000..2d2b3c07c
--- /dev/null
+++ b/shlibs/mount/src/lock.c
@@ -0,0 +1,510 @@
+/*
+ * 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 */