locks: implement delegations

Implement NFSv4 delegations at the vfs level using the new FL_DELEG lock
type.

Note nfsd is the only delegation user and is only using read
delegations.  Warn on any attempt to set a write delegation for now.
We'll come back to that case later.

Acked-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

1 files changed, 45 insertions, 10 deletions

diff --git a/fs/locks.c b/fs/locks.c
index 079abcd8a836..f99d52bdd05a 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -1292,28 +1292,40 @@ static void time_out_leases(struct inode *inode)
         }
 }
 
+static bool leases_conflict(struct file_lock *lease, struct file_lock *breaker)
+{
+        if ((breaker->fl_flags & FL_DELEG) && (lease->fl_flags & FL_LEASE))
+                return false;
+        return locks_conflict(breaker, lease);
+}
+
 /**
  *      __break_lease   -       revoke all outstanding leases on file
  *      @inode: the inode of the file to return
- *      @mode: the open mode (read or write)
+ *      @mode: O_RDONLY: break only write leases; O_WRONLY or O_RDWR:
+ *          break all leases
+ *      @type: FL_LEASE: break leases and delegations; FL_DELEG: break
+ *          only delegations
  *
  *      break_lease (inlined for speed) has checked there already is at least
  *      some kind of lock (maybe a lease) on this file.  Leases are broken on
  *      a call to open() or truncate().  This function can sleep unless you
  *      specified %O_NONBLOCK to your open().
  */
-int __break_lease(struct inode *inode, unsigned int mode)
+int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
 {
         int error = 0;
         struct file_lock *new_fl, *flock;
         struct file_lock *fl;
         unsigned long break_time;
         int i_have_this_lease = 0;
+        bool lease_conflict = false;
         int want_write = (mode & O_ACCMODE) != O_RDONLY;
 
         new_fl = lease_alloc(NULL, want_write ? F_WRLCK : F_RDLCK);
         if (IS_ERR(new_fl))
                 return PTR_ERR(new_fl);
+        new_fl->fl_flags = type;
 
         spin_lock(&inode->i_lock);
 
@@ -1323,13 +1335,16 @@ int __break_lease(struct inode *inode, unsigned int mode)
         if ((flock == NULL) || !IS_LEASE(flock))
                 goto out;
 
-        if (!locks_conflict(flock, new_fl))
+        for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) {
+                if (leases_conflict(fl, new_fl)) {
+                        lease_conflict = true;
+                        if (fl->fl_owner == current->files)
+                                i_have_this_lease = 1;
+                }
+        }
+        if (!lease_conflict)
                 goto out;
 
-        for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next)
-                if (fl->fl_owner == current->files)
-                        i_have_this_lease = 1;
-
         break_time = 0;
         if (lease_break_time > 0) {
                 break_time = jiffies + lease_break_time * HZ;
@@ -1338,6 +1353,8 @@ int __break_lease(struct inode *inode, unsigned int mode)
         }
 
         for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) {
+                if (!leases_conflict(fl, new_fl))
+                        continue;
                 if (want_write) {
                         if (fl->fl_flags & FL_UNLOCK_PENDING)
                                 continue;
@@ -1379,7 +1396,7 @@ restart:
                  */
                 for (flock = inode->i_flock; flock && IS_LEASE(flock);
                                 flock = flock->fl_next) {
-                        if (locks_conflict(new_fl, flock))
+                        if (leases_conflict(new_fl, flock))
                                 goto restart;
                 }
                 error = 0;
@@ -1460,9 +1477,26 @@ static int generic_add_lease(struct file *filp, long arg, struct file_lock **flp
         struct file_lock *fl, **before, **my_before = NULL, *lease;
         struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
+        bool is_deleg = (*flp)->fl_flags & FL_DELEG;
         int error;
 
         lease = *flp;
+        /*
+         * In the delegation case we need mutual exclusion with
+         * a number of operations that take the i_mutex.  We trylock
+         * because delegations are an optional optimization, and if
+         * there's some chance of a conflict--we'd rather not
+         * bother, maybe that's a sign this just isn't a good file to
+         * hand out a delegation on.
+         */
+        if (is_deleg && !mutex_trylock(&inode->i_mutex))
+                return -EAGAIN;
+
+        if (is_deleg && arg == F_WRLCK) {
+                /* Write delegations are not currently supported: */
+                WARN_ON_ONCE(1);
+                return -EINVAL;
+        }
 
         error = -EAGAIN;
         if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0))
@@ -1514,9 +1548,10 @@ static int generic_add_lease(struct file *filp, long arg, struct file_lock **flp
                 goto out;
 
         locks_insert_lock(before, lease);
-        return 0;
-
+        error = 0;
 out:
+        if (is_deleg)
+                mutex_unlock(&inode->i_mutex);
         return error;
 }