From 4bf96b66804c9e69311c47cfe7a1912d4acd2ba7 Mon Sep 17 00:00:00 2001
From: Qiang Huang <h.huangqiang@huawei.com>
Date: Thu, 17 Jan 2013 16:09:34 +0800
Subject: [PATCH] crtools: restore flock&posix file locks

According to the file lock information from the image, we recall
flock or fcntl with proper parameters, so we can rehold the file
locks as we were dumped.
We only support flock and posix file locks so far.

Changelog since the initial version:
a. Use prepare_file_locks instead of restore function directly.
b. Fix some bugs.

Originally-signed-off-by: Zheng Gu <cengku.gu@huawei.com>
Signed-off-by: Qiang Huang <h.huangqiang@huawei.com>
Signed-off-by: Pavel Emelyanov <xemul@parallels.com>
---
 cr-restore.c        |   4 ++
 file-lock.c         | 102 ++++++++++++++++++++++++++++++++++++++++++++
 include/file-lock.h |   8 ++++
 3 files changed, 114 insertions(+)

diff --git a/cr-restore.c b/cr-restore.c
index 26dbe539f..309a54895 100644
--- a/cr-restore.c
+++ b/cr-restore.c
@@ -55,6 +55,7 @@
 #include "tty.h"
 #include "cpu.h"
 #include "fpu.h"
+#include "file-lock.h"
 
 #include "protobuf.h"
 #include "protobuf/sa.pb-c.h"
@@ -599,6 +600,9 @@ static int restore_one_alive_task(int pid, CoreEntry *core)
 	if (prepare_fs(pid))
 		return -1;
 
+	if (prepare_file_locks(pid))
+		return -1;
+
 	if (prepare_sigactions(pid))
 		return -1;
 
diff --git a/file-lock.c b/file-lock.c
index 3d4183d1b..80a0c8f34 100644
--- a/file-lock.c
+++ b/file-lock.c
@@ -1,5 +1,8 @@
 #include <stdlib.h>
 #include <unistd.h>
+#include <sys/file.h>
+#include <fcntl.h>
+#include <string.h>
 
 #include "file-lock.h"
 
@@ -37,3 +40,102 @@ int dump_one_file_lock(FileLockEntry *fle, const struct cr_fdset *fdset)
 	return pb_write_one(fdset_fd(fdset, CR_FD_FILE_LOCKS),
 			fle, PB_FILE_LOCK);
 }
+
+static int restore_file_lock(FileLockEntry *fle)
+{
+	int ret = -1;
+	unsigned int cmd;
+
+	if (fle->flag & FL_FLOCK) {
+		if (fle->type & LOCK_MAND) {
+			cmd = fle->type;
+		} else if (fle->type == F_RDLCK) {
+			cmd = LOCK_SH;
+		} else if (fle->type == F_WRLCK) {
+			cmd = LOCK_EX;
+		} else if (fle->type == F_UNLCK) {
+			cmd = LOCK_UN;
+		} else {
+			pr_err("Unknow flock type!\n");
+			goto err;
+		}
+
+		pr_info("(flock)flag: %d, type: %d, cmd: %d, pid: %d, fd: %d\n",
+			fle->flag, fle->type, cmd, fle->pid, fle->fd);
+
+		ret = flock(fle->fd, cmd);
+		if (ret < 0) {
+			pr_err("Can not set flock!\n");
+			goto err;
+		}
+	} else if (fle->flag & FL_POSIX) {
+		struct flock flk;
+		memset(&flk, 0, sizeof(flk));
+
+		flk.l_whence = SEEK_SET;
+		flk.l_start  = fle->start;
+		flk.l_len    = fle->len;
+		flk.l_pid    = fle->pid;
+		flk.l_type   = fle->type;
+
+		pr_info("(posix)flag: %d, type: %d, pid: %d, fd: %d, "
+			"start: %8lx, len: %8lx\n",
+			fle->flag, fle->type, fle->pid, fle->fd,
+			fle->start, fle->len);
+
+		ret = fcntl(fle->fd, F_SETLKW, &flk);
+		if (ret < 0) {
+			pr_err("Can not set posix lock!\n");
+			goto err;
+		}
+	} else {
+		pr_err("Unknow file lock style!\n");
+		goto err;
+	}
+
+	return 0;
+err:
+	return ret;
+}
+
+static int restore_file_locks(int pid)
+{
+	int fd, ret = -1;
+	FileLockEntry *fle;
+
+	fd = open_image_ro(CR_FD_FILE_LOCKS, pid);
+	if (fd < 0) {
+		if (errno == ENOENT)
+			return 0;
+		else
+			return -1;
+	}
+
+	while (1) {
+		ret = pb_read_one_eof(fd, &fle, PB_FILE_LOCK);
+		if (ret <= 0)
+			break;
+
+		ret = restore_file_lock(fle);
+		file_lock_entry__free_unpacked(fle, NULL);
+
+		if (ret)
+			goto err;
+	}
+
+	close_safe(&fd);
+	return 0;
+err:
+	close_safe(&fd);
+	return ret;
+}
+
+int prepare_file_locks(int pid)
+{
+	if (!opts.handle_file_locks)
+		return 0;
+
+	pr_info("Restore file locks.\n");
+
+	return restore_file_locks(pid);
+}
diff --git a/include/file-lock.h b/include/file-lock.h
index d6d2397a5..dddc808f4 100644
--- a/include/file-lock.h
+++ b/include/file-lock.h
@@ -16,6 +16,12 @@
 #endif
 
 /* operations for bsd flock(), also used by the kernel implementation */
+#define LOCK_SH		1	/* shared lock */
+#define LOCK_EX		2	/* exclusive lock */
+#define LOCK_NB		4	/* or'd with one of the above to prevent
+				   blocking */
+#define LOCK_UN		8	/* remove lock */
+
 #define LOCK_MAND	32	/* This is a mandatory flock ... */
 #define LOCK_READ	64	/* which allows concurrent read operations */
 #define LOCK_WRITE	128	/* which allows concurrent write operations */
@@ -42,4 +48,6 @@ extern struct file_lock *alloc_file_lock(void);
 extern void free_file_locks(void);
 extern int dump_one_file_lock(FileLockEntry *fle, const struct cr_fdset *fdset);
 
+extern int prepare_file_locks(int pid);
+
 #endif /* __FILE_LOCK_H__ */