file-lock: fix type confusion in broken lease restore

When restoring a breaking lease, CRIU needs to first restore the
pre-breaking state of the lease and then trigger the break again.

Previously, restore_lease_prebreaking_state() was incorrectly using the
file descriptor type (e.g., FD_TYPES__REG) instead of the lease type to
determine which lease to set. This caused it to use O_RDONLY/O_WRONLY
logic on a value that wasn't an open flag.

Fix this by:
1. Passing the target lease type (with the LEASE_BREAKING bit cleared)
   to restore_lease_prebreaking_state().
2. Updating set_file_lease() to optionally suppress error messages when
   a lease cannot be set (EWOULDBLOCK), which happens when we try to
   guess the original lease type.
3. In restore_lease_prebreaking_state(), try to set a read lease first
   if the target type is F_UNLCK. If it fails, or if the target type is
   F_RDLCK, try a write lease.

This ensures that we correctly attempt to restore the original lease
type even though it's not explicitly stored in the image when it's
in the process of being broken.

Reported-by: Prateek Singh Rathour <rathourprateek8@gmail.com>
Signed-off-by: Andrei Vagin <avagin@google.com>

Author: avagin

criu/file-lock.c

@@ -495,9 +495,9 @@ static int break_lease(int lease_type, struct file_desc *desc)
 	return open_path(desc, open_break_cb, (void *)&break_flags);
 }
 
-static int set_file_lease(int fd, int type)
+static int set_file_lease(int fd, int type, bool can_fail)
 {
-	int old_fsuid, ret;
+	int saved_errno, old_fsuid, ret;
 	struct stat st;
 
 	if (fstat(fd, &st)) {
@@ -512,19 +512,33 @@ static int set_file_lease(int fd, int type)
 	old_fsuid = setfsuid(st.st_uid);
 
 	ret = fcntl(fd, F_SETLEASE, type);
-	if (ret < 0)
-		pr_perror("Can't set lease");
+	saved_errno = errno;
+	if (ret < 0) {
+		if (!can_fail || errno != EWOULDBLOCK)
+			pr_perror("Can't set lease");
+		else
+			pr_debug("The requested lease isn't available\n");
+	}
 
 	setfsuid(old_fsuid);
+	errno = saved_errno;
 	return ret;
 }
 
-static int restore_lease_prebreaking_state(int fd, int fd_type)
+static int restore_lease_prebreaking_state(int fd, int target_lease_type)
 {
-	int access_flags = fd_type & O_ACCMODE;
-	int lease_type = (access_flags == O_RDONLY) ? F_RDLCK : F_WRLCK;
+	int lease_type = (target_lease_type == F_UNLCK) ? F_RDLCK : F_WRLCK;
 
-	return set_file_lease(fd, lease_type);
+	/*
+	 * The origin lease type is unknown. Let's try the read one
+	 * then the write one.
+	 */
+	if (set_file_lease(fd, lease_type, /* can_fail = */ true)) {
+		if (lease_type == F_WRLCK)
+			return -1;
+		return set_file_lease(fd, F_WRLCK, false);
+	}
+	return 0;
 }
 
 static struct fdinfo_list_entry *find_fd_unordered(struct pstree_item *task, int fd)
@@ -550,7 +564,7 @@ static int restore_breaking_file_lease(FileLockEntry *fle)
 		return -1;
 	}
 
-	ret = restore_lease_prebreaking_state(fle->fd, fdle->desc->ops->type);
+	ret = restore_lease_prebreaking_state(fle->fd, fle->type & (~LEASE_BREAKING));
 	if (ret)
 		return ret;
 
@@ -594,7 +608,7 @@ static int restore_file_lease(FileLockEntry *fle)
 		}
 		return ret;
 	} else {
-		ret = set_file_lease(fle->fd, fle->type);
+		ret = set_file_lease(fle->fd, fle->type, /* can_fail = */ false);
 		if (ret < 0)
 			pr_perror("Can't restore non breaking lease");
 		return ret;