Attachment 596682 Details for Bug 818588 – locks - begin enforcing LOCK_MAND locks by default

[patch] locks - begin enforcing LOCK_MAND locks by default

0001-locks-add-enforcement-of-LOCK_MAND-locks.patch (text/plain), 3.13 KB, created by Jeff Layton on 2012-07-06 20:11:17 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Jeff Layton

Created: 2012-07-06 20:11:17 UTC

Size: 3.13 KB

patch

obsolete

>From 66bbf71c2ff0058128eee9a5dd1936d80b8f939a Mon Sep 17 00:00:00 2001
>From: Jeff Layton <jlayton@redhat.com>
>Date: Fri, 6 Jul 2012 09:10:03 -0400
>Subject: [PATCH] locks: add enforcement of LOCK_MAND locks
>
>The LOCK_MAND lock mechanism is currently a no-op for any in-tree
>filesystem. The flags are passed to f_ops->flock, but the standard
>flock routines basically ignore them.
>
>Change this by adding enforcement against other LOCK_MAND locks. Also,
>assume that LOCK_MAND also implies LOCK_NB.
>
>Signed-off-by: Jeff Layton <jlayton@redhat.com>
>---
> fs/locks.c |   45 ++++++++++++++++++++++++++++++++++++++++++---
> 1 files changed, 42 insertions(+), 3 deletions(-)
>
>diff --git a/fs/locks.c b/fs/locks.c
>index 814c51d..736e38b 100644
>--- a/fs/locks.c
>+++ b/fs/locks.c
>@@ -625,6 +625,43 @@ static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *s
> 	return (locks_conflict(caller_fl, sys_fl));
> }
> 
>+/*
>+ * locks_mand_conflict - Determine if there's a share reservation conflict
>+ * @caller_fl: lock we're attempting to acquire
>+ * @sys_fl: lock already present on system that we're checking against
>+ *
>+ * Check to see if there's a share_reservation conflict. LOCK_READ/LOCK_WRITE
>+ * tell us whether the reservation allows other readers and writers.
>+ *
>+ * We only check against other LOCK_MAND locks, so applications that want to
>+ * use share mode locking will only conflict against one another. "normal"
>+ * applications that open files won't be affected by and won't themselves
>+ * affect the share reservations.
>+ */
>+static int locks_mand_conflict(struct file_lock *caller_fl,
>+				struct file_lock *sys_fl)
>+{
>+	unsigned char caller_type = caller_fl->fl_type;
>+	unsigned char sys_type = sys_fl->fl_type;
>+	fmode_t	caller_fmode = caller_fl->fl_file->f_mode;
>+	fmode_t sys_fmode = sys_fl->fl_file->f_mode;
>+
>+	/* they can only conflict if they're both LOCK_MAND */
>+	if (!(caller_type & LOCK_MAND) || !(sys_type & LOCK_MAND))
>+		return 0;
>+
>+	if (!(caller_type & LOCK_READ) && (sys_fmode & FMODE_READ))
>+		return 1;
>+	if (!(caller_type & LOCK_WRITE) && (sys_fmode & FMODE_WRITE))
>+		return 1;
>+	if (!(sys_type & LOCK_READ) && (caller_fmode & FMODE_READ))
>+		return 1;
>+	if (!(sys_type & LOCK_WRITE) && (caller_fmode & FMODE_WRITE))
>+		return 1;
>+
>+	return 0;
>+}
>+
> /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific
>  * checking before calling the locks_conflict().
>  */
>@@ -633,9 +670,11 @@ static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *s
> 	/* FLOCK locks referring to the same filp do not conflict with
> 	 * each other.
> 	 */
>-	if (!IS_FLOCK(sys_fl) || (caller_fl->fl_file == sys_fl->fl_file))
>-		return (0);
>+	if (!IS_FLOCK(sys_fl))
>+		return 0;
> 	if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND))
>+		return locks_mand_conflict(caller_fl, sys_fl);
>+	if (caller_fl->fl_file == sys_fl->fl_file)
> 		return 0;
> 
> 	return (locks_conflict(caller_fl, sys_fl));
>@@ -1646,7 +1685,7 @@ SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd)
> 	if (!filp)
> 		goto out;
> 
>-	can_sleep = !(cmd & LOCK_NB);
>+	can_sleep = !(cmd & (LOCK_NB|LOCK_MAND));
> 	cmd &= ~LOCK_NB;
> 	unlock = (cmd == LOCK_UN);
> 
>-- 
>1.7.7.6
>

Actions: View | Diff

Attachments on bug 818588: 596682