lockd: unlock lockd locks held for a certain filesystem

Add /proc/fs/nfsd/unlock_filesystem, which allows e.g.:

shell> echo /mnt/sfs1 > /proc/fs/nfsd/unlock_filesystem

so that a filesystem can be unmounted before allowing a peer nfsd to
take over nfs service for the filesystem.

Signed-off-by: S. Wendy Cheng <wcheng@redhat.com>
Cc: Lon Hohberger  <lhh@redhat.com>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
 fs/lockd/svcsubs.c          |   66 +++++++++++++++++++++++++++++++++++++++-----
 fs/nfsd/nfsctl.c            |   65 +++++++++++++++++++++++++++++++++++++++++++
 include/linux/lockd/lockd.h |    7 ++++
 3 files changed, 131 insertions(+), 7 deletions(-)

diff --git a/fs/lockd/svcsubs.c b/fs/lockd/svcsubs.c
index 1adcf93cb6e6f21f4af47248d3d96af8f1167225..d1c48b539df8723bd8979e502448eee35d4f9adf 100644 (file)
--- a/fs/lockd/svcsubs.c
+++ b/fs/lockd/svcsubs.c
@@ -196,6 +196,12 @@ again:
        return 0;
 }
 
+static int
+nlmsvc_always_match(void *dummy1, struct nlm_host *dummy2)
+{
+       return 1;
+}
+
 /*
  * Inspect a single file
  */
@@ -232,7 +238,8 @@ nlm_file_inuse(struct nlm_file *file)
  * Loop over all files in the file table.
  */
 static int
-nlm_traverse_files(void *data, nlm_host_match_fn_t match)
+nlm_traverse_files(void *data, nlm_host_match_fn_t match,
+               int (*is_failover_file)(void *data, struct nlm_file *file))
 {
        struct hlist_node *pos, *next;
        struct nlm_file *file;
@@ -241,6 +248,8 @@ nlm_traverse_files(void *data, nlm_host_match_fn_t match)
        mutex_lock(&nlm_file_mutex);
        for (i = 0; i < FILE_NRHASH; i++) {
                hlist_for_each_entry_safe(file, pos, next, &nlm_files[i], f_list) {
+                       if (is_failover_file && !is_failover_file(data, file))
+                               continue;
                        file->f_count++;
                        mutex_unlock(&nlm_file_mutex);
 
@@ -345,7 +354,7 @@ void
 nlmsvc_mark_resources(void)
 {
        dprintk("lockd: nlmsvc_mark_resources\n");
-       nlm_traverse_files(NULL, nlmsvc_mark_host);
+       nlm_traverse_files(NULL, nlmsvc_mark_host, NULL);
 }
 
 /*
@@ -356,7 +365,7 @@ nlmsvc_free_host_resources(struct nlm_host *host)
 {
        dprintk("lockd: nlmsvc_free_host_resources\n");
 
-       if (nlm_traverse_files(host, nlmsvc_same_host)) {
+       if (nlm_traverse_files(host, nlmsvc_same_host, NULL)) {
                printk(KERN_WARNING
                        "lockd: couldn't remove all locks held by %s\n",
                        host->h_name);
@@ -376,8 +385,26 @@ nlmsvc_invalidate_all(void)
         * turn, which is about as inefficient as it gets.
         * Now we just do it once in nlm_traverse_files.
         */
-       nlm_traverse_files(NULL, nlmsvc_is_client);
+       nlm_traverse_files(NULL, nlmsvc_is_client, NULL);
+}
+
+static int
+nlmsvc_match_sb(void *datap, struct nlm_file *file)
+{
+       struct super_block *sb = datap;
+
+       return sb == file->f_file->f_path.mnt->mnt_sb;
+}
+
+int
+nlmsvc_unlock_all_by_sb(struct super_block *sb)
+{
+       int ret;
+
+       ret = nlm_traverse_files(sb, nlmsvc_always_match, nlmsvc_match_sb);
+       return ret ? -EIO : 0;
 }
+EXPORT_SYMBOL_GPL(nlmsvc_unlock_all_by_sb);
 
 static int
 nlmsvc_match_ip(void *datap, struct nlm_host *host)
@@ -391,7 +418,7 @@ int
 nlmsvc_unlock_all_by_ip(__be32 server_addr)
 {
        int ret;
-       ret = nlm_traverse_files(&server_addr, nlmsvc_match_ip);
+       ret = nlm_traverse_files(&server_addr, nlmsvc_match_ip, NULL);
        return ret ? -EIO : 0;
 
 }

diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c
index 7706f6c9ab8a4c66d7879131d98e637c64752a1c..42f3820ee8f543ca022d019b3b1de49e5907648c 100644 (file)
--- a/fs/nfsd/nfsctl.c
+++ b/fs/nfsd/nfsctl.c
@@ -56,6 +56,7 @@ enum {
        NFSD_List,
        NFSD_Fh,
        NFSD_FO_UnlockIP,
+       NFSD_FO_UnlockFS,
        NFSD_Threads,
        NFSD_Pool_Threads,
        NFSD_Versions,
@@ -93,6 +94,7 @@ static ssize_t write_recoverydir(struct file *file, char *buf, size_t size);
 #endif
 
 static ssize_t failover_unlock_ip(struct file *file, char *buf, size_t size);
+static ssize_t failover_unlock_fs(struct file *file, char *buf, size_t size);
 
 static ssize_t (*write_op[])(struct file *, char *, size_t) = {
        [NFSD_Svc] = write_svc,
@@ -104,6 +106,7 @@ static ssize_t (*write_op[])(struct file *, char *, size_t) = {
        [NFSD_Getfs] = write_getfs,
        [NFSD_Fh] = write_filehandle,
        [NFSD_FO_UnlockIP] = failover_unlock_ip,
+       [NFSD_FO_UnlockFS] = failover_unlock_fs,
        [NFSD_Threads] = write_threads,
        [NFSD_Pool_Threads] = write_pool_threads,
        [NFSD_Versions] = write_versions,
@@ -329,6 +332,33 @@ static ssize_t failover_unlock_ip(struct file *file, char *buf, size_t size)
        return nlmsvc_unlock_all_by_ip(server_ip);
 }
 
+static ssize_t failover_unlock_fs(struct file *file, char *buf, size_t size)
+{
+       struct nameidata nd;
+       char *fo_path;
+       int error;
+
+       /* sanity check */
+       if (size == 0)
+               return -EINVAL;
+
+       if (buf[size-1] != '\n')
+               return -EINVAL;
+
+       fo_path = buf;
+       if (qword_get(&buf, fo_path, size) < 0)
+               return -EINVAL;
+
+       error = path_lookup(fo_path, 0, &nd);
+       if (error)
+               return error;
+
+       error = nlmsvc_unlock_all_by_sb(nd.path.mnt->mnt_sb);
+
+       path_put(&nd.path);
+       return error;
+}
+
 static ssize_t write_filehandle(struct file *file, char *buf, size_t size)
 {
        /* request is:
@@ -733,6 +763,8 @@ static int nfsd_fill_super(struct super_block * sb, void * data, int silent)
                [NFSD_List] = {"exports", &exports_operations, S_IRUGO},
                [NFSD_FO_UnlockIP] = {"unlock_ip",
                                        &transaction_ops, S_IWUSR|S_IRUSR},
+               [NFSD_FO_UnlockFS] = {"unlock_filesystem",
+                                       &transaction_ops, S_IWUSR|S_IRUSR},
                [NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR},
                [NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR},
                [NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR},

diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h
index bcb93fc1fce7ada6a1ed5d563b7ba4a177781990..102d928f7206b4bce0e242c8779b2de01117e8d5 100644 (file)
--- a/include/linux/lockd/lockd.h
+++ b/include/linux/lockd/lockd.h
@@ -223,6 +223,7 @@ void                  nlmsvc_invalidate_all(void);
 /*
  * Cluster failover support
  */
+int           nlmsvc_unlock_all_by_sb(struct super_block *sb);
 int           nlmsvc_unlock_all_by_ip(__be32 server_addr);
 
 static inline struct inode *nlmsvc_file_inode(struct nlm_file *file)