ccache-3.3.4HEADccache-3.3.4master

1 files changed, 214 insertions, 0 deletions

diff --git a/lockfile.c b/lockfile.c
new file mode 100644
index 0000000..ce3dcf4
--- /dev/null
+++ b/lockfile.c
@@ -0,0 +1,214 @@
+// Copyright (C) 2010-2016 Joel Rosdahl
+//
+// This program is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program 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 General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the Free Software Foundation, Inc., 51
+// Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+#include "ccache.h"
+
+// This function acquires a lockfile for the given path. Returns true if the
+// lock was acquired, otherwise false. If the lock has been considered stale
+// for the number of microseconds specified by staleness_limit, the function
+// will (if possible) break the lock and then try to acquire it again. The
+// staleness limit should be reasonably larger than the longest time the lock
+// can be expected to be held, and the updates of the locked path should
+// probably be made with an atomic rename(2) to avoid corruption in the rare
+// case that the lock is broken by another process.
+bool
+lockfile_acquire(const char *path, unsigned staleness_limit)
+{
+	char *lockfile = format("%s.lock", path);
+	char *my_content = NULL;
+	char *content = NULL;
+	char *initial_content = NULL;
+	const char *hostname = get_hostname();
+	bool acquired = false;
+	unsigned to_sleep = 1000; // Microseconds.
+	unsigned slept = 0; // Microseconds.
+
+	while (true) {
+		free(my_content);
+		my_content = format("%s:%d:%d", hostname, (int)getpid(), (int)time(NULL));
+
+#ifdef _WIN32
+		int fd = open(lockfile, O_WRONLY|O_CREAT|O_EXCL|O_BINARY, 0666);
+		if (fd == -1) {
+			int saved_errno = errno;
+			cc_log("lockfile_acquire: open WRONLY %s: %s", lockfile, strerror(errno));
+			if (saved_errno == ENOENT) {
+				// Directory doesn't exist?
+				if (create_parent_dirs(lockfile) == 0) {
+					// OK. Retry.
+					continue;
+				}
+			}
+			if (saved_errno != EEXIST) {
+				// Directory doesn't exist or isn't writable?
+				goto out;
+			}
+			// Someone else has the lock.
+			fd = open(lockfile, O_RDONLY|O_BINARY);
+			if (fd == -1) {
+				if (errno == ENOENT) {
+					// The file was removed after the open() call above, so retry
+					// acquiring it.
+					continue;
+				} else {
+					cc_log("lockfile_acquire: open RDONLY %s: %s",
+					       lockfile, strerror(errno));
+					goto out;
+				}
+			}
+			free(content);
+			const size_t bufsize = 1024;
+			content = x_malloc(bufsize);
+			int len = read(fd, content, bufsize - 1);
+			if (len == -1) {
+				cc_log("lockfile_acquire: read %s: %s", lockfile, strerror(errno));
+				close(fd);
+				goto out;
+			}
+			close(fd);
+			content[len] = '\0';
+		} else {
+			// We got the lock.
+			if (write(fd, my_content, strlen(my_content)) == -1) {
+				cc_log("lockfile_acquire: write %s: %s", lockfile, strerror(errno));
+				close(fd);
+				x_unlink(lockfile);
+				goto out;
+			}
+			close(fd);
+			acquired = true;
+			goto out;
+		}
+#else
+		if (symlink(my_content, lockfile) == 0) {
+			// We got the lock.
+			acquired = true;
+			goto out;
+		}
+		int saved_errno = errno;
+		cc_log("lockfile_acquire: symlink %s: %s", lockfile, strerror(saved_errno));
+		if (saved_errno == ENOENT) {
+			// Directory doesn't exist?
+			if (create_parent_dirs(lockfile) == 0) {
+				// OK. Retry.
+				continue;
+			}
+		}
+		if (saved_errno == EPERM) {
+			// The file system does not support symbolic links. We have no choice but
+			// to grant the lock anyway.
+			acquired = true;
+			goto out;
+		}
+		if (saved_errno != EEXIST) {
+			// Directory doesn't exist or isn't writable?
+			goto out;
+		}
+		free(content);
+		content = x_readlink(lockfile);
+		// cppcheck-suppress nullPointer - false positive
+		if (!content) {
+			if (errno == ENOENT) {
+				// The symlink was removed after the symlink() call above, so retry
+				// acquiring it.
+				continue;
+			} else {
+				cc_log("lockfile_acquire: readlink %s: %s", lockfile, strerror(errno));
+				goto out;
+			}
+		}
+#endif
+
+		if (str_eq(content, my_content)) {
+			// Lost NFS reply?
+			cc_log("lockfile_acquire: symlink %s failed but we got the lock anyway",
+			       lockfile);
+			acquired = true;
+			goto out;
+		}
+		// A possible improvement here would be to check if the process holding the
+		// lock is still alive and break the lock early if it isn't.
+		cc_log("lockfile_acquire: lock info for %s: %s", lockfile, content);
+		if (!initial_content) {
+			initial_content = x_strdup(content);
+		}
+		if (slept > staleness_limit) {
+			if (str_eq(content, initial_content)) {
+				// The lock seems to be stale -- break it.
+				cc_log("lockfile_acquire: breaking %s", lockfile);
+				// Try to acquire path.lock.lock:
+				if (lockfile_acquire(lockfile, staleness_limit)) {
+					lockfile_release(path); // Remove path.lock
+					lockfile_release(lockfile); // Remove path.lock.lock
+					to_sleep = 1000;
+					slept = 0;
+					continue;
+				}
+			}
+			cc_log("lockfile_acquire: gave up acquiring %s", lockfile);
+			goto out;
+		}
+		cc_log("lockfile_acquire: failed to acquire %s; sleeping %u microseconds",
+		       lockfile, to_sleep);
+		usleep(to_sleep);
+		slept += to_sleep;
+		to_sleep *= 2;
+	}
+
+out:
+	if (acquired) {
+		cc_log("Acquired lock %s", lockfile);
+	} else {
+		cc_log("Failed to acquire lock %s", lockfile);
+	}
+	free(lockfile);
+	free(my_content);
+	free(initial_content);
+	free(content);
+	return acquired;
+}
+
+// Release the lockfile for the given path. Assumes that we are the legitimate
+// owner.
+void
+lockfile_release(const char *path)
+{
+	char *lockfile = format("%s.lock", path);
+	cc_log("Releasing lock %s", lockfile);
+	tmp_unlink(lockfile);
+	free(lockfile);
+}
+
+#ifdef TEST_LOCKFILE
+int
+main(int argc, char **argv)
+{
+	extern char *cache_logfile;
+	cache_logfile = "/dev/stdout";
+	if (argc == 4) {
+		unsigned staleness_limit = atoi(argv[1]);
+		if (str_eq(argv[2], "acquire")) {
+			return lockfile_acquire(argv[3], staleness_limit) == 0;
+		} else if (str_eq(argv[2], "release")) {
+			lockfile_release(argv[3]);
+			return 0;
+		}
+	}
+	fprintf(stderr,
+	        "Usage: testlockfile <staleness_limit> <acquire|release> <path>\n");
+	return 1;
+}
+#endif