nfsd: prepare for supporting admin-revocation of state

The NFSv4 protocol allows state to be revoked by the admin and has error
codes which allow this to be communicated to the client.

This patch
 - introduces a new state-id status SC_STATUS_ADMIN_REVOKED
   which can be set on open, lock, or delegation state.
 - reports NFS4ERR_ADMIN_REVOKED when these are accessed
 - introduces a per-client counter of these states and returns
   SEQ4_STATUS_ADMIN_STATE_REVOKED when the counter is not zero.
   Decrements this when freeing any admin-revoked state.
 - introduces stub code to find all interesting states for a given
   superblock so they can be revoked via the 'unlock_filesystem'
   file in /proc/fs/nfsd/
   No actual states are handled yet.

Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>

diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 86b28dbf1bf22bcb57066071ad692de768bb8705..80b02b528f61d01221f4e7012880e1149321903b 100644 (file)
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -1210,6 +1210,8 @@ nfs4_put_stid(struct nfs4_stid *s)
                return;
        }
        idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
+       if (s->sc_status & SC_STATUS_ADMIN_REVOKED)
+               atomic_dec(&s->sc_client->cl_admin_revoked);
        nfs4_free_cpntf_statelist(clp->net, s);
        spin_unlock(&clp->cl_lock);
        s->sc_free(s);
@@ -1529,6 +1531,8 @@ static void put_ol_stateid_locked(struct nfs4_ol_stateid *stp,
        }
 
        idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
+       if (s->sc_status & SC_STATUS_ADMIN_REVOKED)
+               atomic_dec(&s->sc_client->cl_admin_revoked);
        list_add(&stp->st_locks, reaplist);
 }
 
@@ -1674,6 +1678,68 @@ static void release_openowner(struct nfs4_openowner *oo)
        nfs4_put_stateowner(&oo->oo_owner);
 }
 
+static struct nfs4_stid *find_one_sb_stid(struct nfs4_client *clp,
+                                         struct super_block *sb,
+                                         unsigned int sc_types)
+{
+       unsigned long id, tmp;
+       struct nfs4_stid *stid;
+
+       spin_lock(&clp->cl_lock);
+       idr_for_each_entry_ul(&clp->cl_stateids, stid, tmp, id)
+               if ((stid->sc_type & sc_types) &&
+                   stid->sc_status == 0 &&
+                   stid->sc_file->fi_inode->i_sb == sb) {
+                       refcount_inc(&stid->sc_count);
+                       break;
+               }
+       spin_unlock(&clp->cl_lock);
+       return stid;
+}
+
+/**
+ * nfsd4_revoke_states - revoke all nfsv4 states associated with given filesystem
+ * @net:  used to identify instance of nfsd (there is one per net namespace)
+ * @sb:   super_block used to identify target filesystem
+ *
+ * All nfs4 states (open, lock, delegation, layout) held by the server instance
+ * and associated with a file on the given filesystem will be revoked resulting
+ * in any files being closed and so all references from nfsd to the filesystem
+ * being released.  Thus nfsd will no longer prevent the filesystem from being
+ * unmounted.
+ *
+ * The clients which own the states will subsequently being notified that the
+ * states have been "admin-revoked".
+ */
+void nfsd4_revoke_states(struct net *net, struct super_block *sb)
+{
+       struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+       unsigned int idhashval;
+       unsigned int sc_types;
+
+       sc_types = 0;
+
+       spin_lock(&nn->client_lock);
+       for (idhashval = 0; idhashval < CLIENT_HASH_MASK; idhashval++) {
+               struct list_head *head = &nn->conf_id_hashtbl[idhashval];
+               struct nfs4_client *clp;
+       retry:
+               list_for_each_entry(clp, head, cl_idhash) {
+                       struct nfs4_stid *stid = find_one_sb_stid(clp, sb,
+                                                                 sc_types);
+                       if (stid) {
+                               spin_unlock(&nn->client_lock);
+                               switch (stid->sc_type) {
+                               }
+                               nfs4_put_stid(stid);
+                               spin_lock(&nn->client_lock);
+                               goto retry;
+                       }
+               }
+       }
+       spin_unlock(&nn->client_lock);
+}
+
 static inline int
 hash_sessionid(struct nfs4_sessionid *sessionid)
 {
@@ -2545,6 +2611,8 @@ static int client_info_show(struct seq_file *m, void *v)
        }
        seq_printf(m, "callback state: %s\n", cb_state2str(clp->cl_cb_state));
        seq_printf(m, "callback address: %pISpc\n", &clp->cl_cb_conn.cb_addr);
+       seq_printf(m, "admin-revoked states: %d\n",
+                  atomic_read(&clp->cl_admin_revoked));
        drop_client(clp);
 
        return 0;
@@ -4058,6 +4126,8 @@ out:
        }
        if (!list_empty(&clp->cl_revoked))
                seq->status_flags |= SEQ4_STATUS_RECALLABLE_STATE_REVOKED;
+       if (atomic_read(&clp->cl_admin_revoked))
+               seq->status_flags |= SEQ4_STATUS_ADMIN_STATE_REVOKED;
        trace_nfsd_seq4_status(rqstp, seq);
 out_no_session:
        if (conn)
@@ -4547,7 +4617,9 @@ nfsd4_verify_open_stid(struct nfs4_stid *s)
 {
        __be32 ret = nfs_ok;
 
-       if (s->sc_status & SC_STATUS_REVOKED)
+       if (s->sc_status & SC_STATUS_ADMIN_REVOKED)
+               ret = nfserr_admin_revoked;
+       else if (s->sc_status & SC_STATUS_REVOKED)
                ret = nfserr_deleg_revoked;
        else if (s->sc_status & SC_STATUS_CLOSED)
                ret = nfserr_bad_stateid;
@@ -5136,6 +5208,11 @@ nfs4_check_deleg(struct nfs4_client *cl, struct nfsd4_open *open,
        deleg = find_deleg_stateid(cl, &open->op_delegate_stateid);
        if (deleg == NULL)
                goto out;
+       if (deleg->dl_stid.sc_status & SC_STATUS_ADMIN_REVOKED) {
+               nfs4_put_stid(&deleg->dl_stid);
+               status = nfserr_admin_revoked;
+               goto out;
+       }
        if (deleg->dl_stid.sc_status & SC_STATUS_REVOKED) {
                nfs4_put_stid(&deleg->dl_stid);
                status = nfserr_deleg_revoked;
@@ -6443,6 +6520,8 @@ nfsd4_lookup_stateid(struct nfsd4_compound_state *cstate,
                 */
                statusmask |= SC_STATUS_REVOKED;
 
+       statusmask |= SC_STATUS_ADMIN_REVOKED;
+
        if (ZERO_STATEID(stateid) || ONE_STATEID(stateid) ||
                CLOSE_STATEID(stateid))
                return nfserr_bad_stateid;
@@ -6461,6 +6540,10 @@ nfsd4_lookup_stateid(struct nfsd4_compound_state *cstate,
                nfs4_put_stid(stid);
                return nfserr_deleg_revoked;
        }
+       if (stid->sc_status & SC_STATUS_ADMIN_REVOKED) {
+               nfs4_put_stid(stid);
+               return nfserr_admin_revoked;
+       }
        *s = stid;
        return nfs_ok;
 }

diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c
index 5a5547bd6ecf7e5412a6ebb715bde8a2e89d8db3..ecd18bffeebc7599f789bd46244e9d52f0adbf2f 100644 (file)
--- a/fs/nfsd/nfsctl.c
+++ b/fs/nfsd/nfsctl.c
@@ -281,6 +281,7 @@ static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size)
         * 3.  Is that directory the root of an exported file system?
         */
        error = nlmsvc_unlock_all_by_sb(path.dentry->d_sb);
+       nfsd4_revoke_states(netns(file), path.dentry->d_sb);
 
        path_put(&path);
        return error;

diff --git a/fs/nfsd/nfsd.h b/fs/nfsd/nfsd.h
index be2ea3d6d2a28935416860932a2f70f195f5a8cf..8daf22d766c60a9e20c74ab11c5d5ac63dec3312 100644 (file)
--- a/fs/nfsd/nfsd.h
+++ b/fs/nfsd/nfsd.h
@@ -275,6 +275,7 @@ void                nfsd_lockd_shutdown(void);
 #define        nfserr_no_grace         cpu_to_be32(NFSERR_NO_GRACE)
 #define        nfserr_reclaim_bad      cpu_to_be32(NFSERR_RECLAIM_BAD)
 #define        nfserr_badname          cpu_to_be32(NFSERR_BADNAME)
+#define        nfserr_admin_revoked    cpu_to_be32(NFS4ERR_ADMIN_REVOKED)
 #define        nfserr_cb_path_down     cpu_to_be32(NFSERR_CB_PATH_DOWN)
 #define        nfserr_locked           cpu_to_be32(NFSERR_LOCKED)
 #define        nfserr_wrongsec         cpu_to_be32(NFSERR_WRONGSEC)

diff --git a/fs/nfsd/state.h b/fs/nfsd/state.h
index 1d4bf1a7d229c5665c95366e099f20071562df98..be02bf1a16bdd9e7e008c7335e5b22b44dbe51b1 100644 (file)
--- a/fs/nfsd/state.h
+++ b/fs/nfsd/state.h
@@ -112,6 +112,7 @@ struct nfs4_stid {
 #define SC_STATUS_CLOSED       BIT(0)
 /* For a deleg stateid kept around only to process free_stateid's: */
 #define SC_STATUS_REVOKED      BIT(1)
+#define SC_STATUS_ADMIN_REVOKED        BIT(2)
        unsigned short          sc_status;
 
        struct list_head        sc_cp_list;
@@ -367,6 +368,7 @@ struct nfs4_client {
        clientid_t              cl_clientid;    /* generated by server */
        nfs4_verifier           cl_confirm;     /* generated by server */
        u32                     cl_minorversion;
+       atomic_t                cl_admin_revoked; /* count of admin-revoked states */
        /* NFSv4.1 client implementation id: */
        struct xdr_netobj       cl_nii_domain;
        struct xdr_netobj       cl_nii_name;
@@ -730,6 +732,14 @@ static inline void get_nfs4_file(struct nfs4_file *fi)
 }
 struct nfsd_file *find_any_file(struct nfs4_file *f);
 
+#ifdef CONFIG_NFSD_V4
+void nfsd4_revoke_states(struct net *net, struct super_block *sb);
+#else
+static inline void nfsd4_revoke_states(struct net *net, struct super_block *sb)
+{
+}
+#endif
+
 /* grace period management */
 void nfsd4_end_grace(struct nfsd_net *nn);
 

diff --git a/fs/nfsd/trace.h b/fs/nfsd/trace.h
index f87dad1fa1d66d924a5fbfa4284f1a338d3e3821..d8e56268a250ba3b64c7e0a3237f7afcda36dc3b 100644 (file)
--- a/fs/nfsd/trace.h
+++ b/fs/nfsd/trace.h
@@ -653,7 +653,8 @@ DEFINE_STATESEQID_EVENT(open_confirm);
 #define show_stid_status(x)                                            \
        __print_flags(x, "|",                                           \
                { SC_STATUS_CLOSED,             "CLOSED" },             \
-               { SC_STATUS_REVOKED,            "REVOKED" })            \
+               { SC_STATUS_REVOKED,            "REVOKED" },            \
+               { SC_STATUS_ADMIN_REVOKED,      "ADMIN_REVOKED" })
 
 DECLARE_EVENT_CLASS(nfsd_stid_class,
        TP_PROTO(