Merge tag 'nfs-for-3.6-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs

Pull NFS client updates from Trond Myklebust:
 "Features include:
   - More preparatory patches for modularising NFSv2/v3/v4.  Split out
     the various NFSv2/v3/v4-specific code into separate files
   - More preparation for the NFSv4 migration code
   - Ensure that OPEN(O_CREATE) observes the pNFS mds threshold
     parameters
   - pNFS fast failover when the data servers are down
   - Various cleanups and debugging patches"

* tag 'nfs-for-3.6-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs: (67 commits)
  nfs: fix fl_type tests in NFSv4 code
  NFS: fix pnfs regression with directio writes
  NFS: fix pnfs regression with directio reads
  sunrpc: clnt: Add missing braces
  nfs: fix stub return type warnings
  NFS: exit_nfs_v4() shouldn't be an __exit function
  SUNRPC: Add a missing spin_unlock to gss_mech_list_pseudoflavors
  NFS: Split out NFS v4 client functions
  NFS: Split out the NFS v4 filesystem types
  NFS: Create a single nfs_clone_super() function
  NFS: Split out NFS v4 server creating code
  NFS: Initialize the NFS v4 client from init_nfs_v4()
  NFS: Move the v4 getroot code to nfs4getroot.c
  NFS: Split out NFS v4 file operations
  NFS: Initialize v4 sysctls from nfs_init_v4()
  NFS: Create an init_nfs_v4() function
  NFS: Split out NFS v4 inode operations
  NFS: Split out NFS v3 inode operations
  NFS: Split out NFS v2 inode operations
  NFS: Clean up nfs4_proc_setclientid() and friends
  ...

1 files changed, 218 insertions, 85 deletions

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index c157b2089b47..6843e0a37de8 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -43,7 +43,6 @@
 #include <linux/printk.h>
 #include <linux/slab.h>
 #include <linux/sunrpc/clnt.h>
-#include <linux/sunrpc/gss_api.h>
 #include <linux/nfs.h>
 #include <linux/nfs4.h>
 #include <linux/nfs_fs.h>
@@ -259,7 +258,12 @@ static int nfs4_wait_clnt_recover(struct nfs_client *clp)
 
         res = wait_on_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,
                         nfs_wait_bit_killable, TASK_KILLABLE);
-        return res;
+        if (res)
+                return res;
+
+        if (clp->cl_cons_state < 0)
+                return clp->cl_cons_state;
+        return 0;
 }
 
 static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
@@ -294,8 +298,8 @@ static int nfs4_handle_exception(struct nfs_server *server, int errorcode, struc
                 case 0:
                         return 0;
                 case -NFS4ERR_OPENMODE:
-                        if (inode && nfs_have_delegation(inode, FMODE_READ)) {
-                                nfs_inode_return_delegation(inode);
+                        if (inode && nfs4_have_delegation(inode, FMODE_READ)) {
+                                nfs4_inode_return_delegation(inode);
                                 exception->retry = 1;
                                 return 0;
                         }
@@ -1065,7 +1069,7 @@ static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmo
                 return;
         }
         rcu_read_unlock();
-        nfs_inode_return_delegation(inode);
+        nfs4_inode_return_delegation(inode);
 }
 
 static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
@@ -1756,33 +1760,70 @@ static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *sta
 }
 
 #if defined(CONFIG_NFS_V4_1)
-static int nfs41_check_expired_stateid(struct nfs4_state *state, nfs4_stateid *stateid, unsigned int flags)
+static void nfs41_clear_delegation_stateid(struct nfs4_state *state)
 {
-        int status = NFS_OK;
         struct nfs_server *server = NFS_SERVER(state->inode);
+        nfs4_stateid *stateid = &state->stateid;
+        int status;
+
+        /* If a state reset has been done, test_stateid is unneeded */
+        if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
+                return;
 
-        if (state->flags & flags) {
-                status = nfs41_test_stateid(server, stateid);
-                if (status != NFS_OK) {
+        status = nfs41_test_stateid(server, stateid);
+        if (status != NFS_OK) {
+                /* Free the stateid unless the server explicitly
+                 * informs us the stateid is unrecognized. */
+                if (status != -NFS4ERR_BAD_STATEID)
                         nfs41_free_stateid(server, stateid);
-                        state->flags &= ~flags;
-                }
+
+                clear_bit(NFS_DELEGATED_STATE, &state->flags);
+        }
+}
+
+/**
+ * nfs41_check_open_stateid - possibly free an open stateid
+ *
+ * @state: NFSv4 state for an inode
+ *
+ * Returns NFS_OK if recovery for this stateid is now finished.
+ * Otherwise a negative NFS4ERR value is returned.
+ */
+static int nfs41_check_open_stateid(struct nfs4_state *state)
+{
+        struct nfs_server *server = NFS_SERVER(state->inode);
+        nfs4_stateid *stateid = &state->stateid;
+        int status;
+
+        /* If a state reset has been done, test_stateid is unneeded */
+        if ((test_bit(NFS_O_RDONLY_STATE, &state->flags) == 0) &&
+            (test_bit(NFS_O_WRONLY_STATE, &state->flags) == 0) &&
+            (test_bit(NFS_O_RDWR_STATE, &state->flags) == 0))
+                return -NFS4ERR_BAD_STATEID;
+
+        status = nfs41_test_stateid(server, stateid);
+        if (status != NFS_OK) {
+                /* Free the stateid unless the server explicitly
+                 * informs us the stateid is unrecognized. */
+                if (status != -NFS4ERR_BAD_STATEID)
+                        nfs41_free_stateid(server, stateid);
+
+                clear_bit(NFS_O_RDONLY_STATE, &state->flags);
+                clear_bit(NFS_O_WRONLY_STATE, &state->flags);
+                clear_bit(NFS_O_RDWR_STATE, &state->flags);
         }
         return status;
 }
 
 static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
 {
-        int deleg_status, open_status;
-        int deleg_flags = 1 << NFS_DELEGATED_STATE;
-        int open_flags = (1 << NFS_O_RDONLY_STATE) | (1 << NFS_O_WRONLY_STATE) | (1 << NFS_O_RDWR_STATE);
-
-        deleg_status = nfs41_check_expired_stateid(state, &state->stateid, deleg_flags);
-        open_status = nfs41_check_expired_stateid(state,  &state->open_stateid, open_flags);
+        int status;
 
-        if ((deleg_status == NFS_OK) && (open_status == NFS_OK))
-                return NFS_OK;
-        return nfs4_open_expired(sp, state);
+        nfs41_clear_delegation_stateid(state);
+        status = nfs41_check_open_stateid(state);
+        if (status != NFS_OK)
+                status = nfs4_open_expired(sp, state);
+        return status;
 }
 #endif
 
@@ -2375,11 +2416,15 @@ static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
         int i, len, status = 0;
         rpc_authflavor_t flav_array[NFS_MAX_SECFLAVORS];
 
-        len = gss_mech_list_pseudoflavors(&flav_array[0]);
-        flav_array[len] = RPC_AUTH_NULL;
-        len += 1;
+        len = rpcauth_list_flavors(flav_array, ARRAY_SIZE(flav_array));
+        BUG_ON(len < 0);
 
         for (i = 0; i < len; i++) {
+                /* AUTH_UNIX is the default flavor if none was specified,
+                 * thus has already been tried. */
+                if (flav_array[i] == RPC_AUTH_UNIX)
+                        continue;
+
                 status = nfs4_lookup_root_sec(server, fhandle, info, flav_array[i]);
                 if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
                         continue;
@@ -2766,9 +2811,7 @@ static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
  *
  * In the case of WRITE, we also want to put the GETATTR after
  * the operation -- in this case because we want to make sure
- * we get the post-operation mtime and size.  This means that
- * we can't use xdr_encode_pages() as written: we need a variant
- * of it which would leave room in the 'tail' iovec.
+ * we get the post-operation mtime and size.
  *
  * Both of these changes to the XDR layer would in fact be quite
  * minor, but I decided to leave them for a subsequent patch.
@@ -2821,7 +2864,9 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
                 return PTR_ERR(ctx);
 
         sattr->ia_mode &= ~current_umask();
-        state = nfs4_do_open(dir, dentry, ctx->mode, flags, sattr, ctx->cred, NULL);
+        state = nfs4_do_open(dir, dentry, ctx->mode,
+                        flags, sattr, ctx->cred,
+                        &ctx->mdsthreshold);
         d_drop(dentry);
         if (IS_ERR(state)) {
                 status = PTR_ERR(state);
@@ -3315,8 +3360,14 @@ static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, str
 
 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
 {
+        int error;
+
         nfs_fattr_init(fsinfo->fattr);
-        return nfs4_do_fsinfo(server, fhandle, fsinfo);
+        error = nfs4_do_fsinfo(server, fhandle, fsinfo);
+        if (error == 0)
+                set_pnfs_layoutdriver(server, fhandle, fsinfo->layouttype);
+
+        return error;
 }
 
 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
@@ -3443,7 +3494,7 @@ bool nfs4_write_need_cache_consistency_data(const struct nfs_write_data *data)
         /* Otherwise, request attributes if and only if we don't hold
          * a delegation
          */
-        return nfs_have_delegation(hdr->inode, FMODE_READ) == 0;
+        return nfs4_have_delegation(hdr->inode, FMODE_READ) == 0;
 }
 
 static void nfs4_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
@@ -3732,7 +3783,8 @@ static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t bu
                 .rpc_argp = &args,
                 .rpc_resp = &res,
         };
-        int ret = -ENOMEM, npages, i, acl_len = 0;
+        int ret = -ENOMEM, npages, i;
+        size_t acl_len = 0;
 
         npages = (buflen + PAGE_SIZE - 1) >> PAGE_SHIFT;
         /* As long as we're doing a round trip to the server anyway,
@@ -3847,7 +3899,7 @@ static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t bufl
         i = buf_to_pages_noslab(buf, buflen, arg.acl_pages, &arg.acl_pgbase);
         if (i < 0)
                 return i;
-        nfs_inode_return_delegation(inode);
+        nfs4_inode_return_delegation(inode);
         ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
 
         /*
@@ -3961,6 +4013,16 @@ static void nfs4_init_boot_verifier(const struct nfs_client *clp,
         memcpy(bootverf->data, verf, sizeof(bootverf->data));
 }
 
+/**
+ * nfs4_proc_setclientid - Negotiate client ID
+ * @clp: state data structure
+ * @program: RPC program for NFSv4 callback service
+ * @port: IP port number for NFS4 callback service
+ * @cred: RPC credential to use for this call
+ * @res: where to place the result
+ *
+ * Returns zero, a negative errno, or a negative NFS4ERR status code.
+ */
 int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
                 unsigned short port, struct rpc_cred *cred,
                 struct nfs4_setclientid_res *res)
@@ -3977,44 +4039,44 @@ int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
                 .rpc_resp = res,
                 .rpc_cred = cred,
         };
-        int loop = 0;
         int status;
 
+        /* nfs_client_id4 */
         nfs4_init_boot_verifier(clp, &sc_verifier);
-
-        for(;;) {
-                rcu_read_lock();
-                setclientid.sc_name_len = scnprintf(setclientid.sc_name,
-                                sizeof(setclientid.sc_name), "%s/%s %s %s %u",
-                                clp->cl_ipaddr,
-                                rpc_peeraddr2str(clp->cl_rpcclient,
-                                                        RPC_DISPLAY_ADDR),
-                                rpc_peeraddr2str(clp->cl_rpcclient,
-                                                        RPC_DISPLAY_PROTO),
-                                clp->cl_rpcclient->cl_auth->au_ops->au_name,
-                                clp->cl_id_uniquifier);
-                setclientid.sc_netid_len = scnprintf(setclientid.sc_netid,
+        rcu_read_lock();
+        setclientid.sc_name_len = scnprintf(setclientid.sc_name,
+                        sizeof(setclientid.sc_name), "%s/%s %s",
+                        clp->cl_ipaddr,
+                        rpc_peeraddr2str(clp->cl_rpcclient,
+                                                RPC_DISPLAY_ADDR),
+                        rpc_peeraddr2str(clp->cl_rpcclient,
+                                                RPC_DISPLAY_PROTO));
+        /* cb_client4 */
+        setclientid.sc_netid_len = scnprintf(setclientid.sc_netid,
                                 sizeof(setclientid.sc_netid),
                                 rpc_peeraddr2str(clp->cl_rpcclient,
                                                         RPC_DISPLAY_NETID));
-                setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,
+        rcu_read_unlock();
+        setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,
                                 sizeof(setclientid.sc_uaddr), "%s.%u.%u",
                                 clp->cl_ipaddr, port >> 8, port & 255);
-                rcu_read_unlock();
 
-                status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
-                if (status != -NFS4ERR_CLID_INUSE)
-                        break;
-                if (loop != 0) {
-                        ++clp->cl_id_uniquifier;
-                        break;
-                }
-                ++loop;
-                ssleep(clp->cl_lease_time / HZ + 1);
-        }
+        dprintk("NFS call  setclientid auth=%s, '%.*s'\n",
+                clp->cl_rpcclient->cl_auth->au_ops->au_name,
+                setclientid.sc_name_len, setclientid.sc_name);
+        status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
+        dprintk("NFS reply setclientid: %d\n", status);
         return status;
 }
 
+/**
+ * nfs4_proc_setclientid_confirm - Confirm client ID
+ * @clp: state data structure
+ * @res: result of a previous SETCLIENTID
+ * @cred: RPC credential to use for this call
+ *
+ * Returns zero, a negative errno, or a negative NFS4ERR status code.
+ */
 int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
                 struct nfs4_setclientid_res *arg,
                 struct rpc_cred *cred)
@@ -4029,6 +4091,9 @@ int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
         unsigned long now;
         int status;
 
+        dprintk("NFS call  setclientid_confirm auth=%s, (client ID %llx)\n",
+                clp->cl_rpcclient->cl_auth->au_ops->au_name,
+                clp->cl_clientid);
         now = jiffies;
         status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
         if (status == 0) {
@@ -4037,6 +4102,7 @@ int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
                 clp->cl_last_renewal = now;
                 spin_unlock(&clp->cl_lock);
         }
+        dprintk("NFS reply setclientid_confirm: %d\n", status);
         return status;
 }
 
@@ -4681,9 +4747,17 @@ out:
 }
 
 #if defined(CONFIG_NFS_V4_1)
+/**
+ * nfs41_check_expired_locks - possibly free a lock stateid
+ *
+ * @state: NFSv4 state for an inode
+ *
+ * Returns NFS_OK if recovery for this stateid is now finished.
+ * Otherwise a negative NFS4ERR value is returned.
+ */
 static int nfs41_check_expired_locks(struct nfs4_state *state)
 {
-        int status, ret = NFS_OK;
+        int status, ret = -NFS4ERR_BAD_STATEID;
         struct nfs4_lock_state *lsp;
         struct nfs_server *server = NFS_SERVER(state->inode);
 
@@ -4691,7 +4765,11 @@ static int nfs41_check_expired_locks(struct nfs4_state *state)
                 if (lsp->ls_flags & NFS_LOCK_INITIALIZED) {
                         status = nfs41_test_stateid(server, &lsp->ls_stateid);
                         if (status != NFS_OK) {
-                                nfs41_free_stateid(server, &lsp->ls_stateid);
+                                /* Free the stateid unless the server
+                                 * informs us the stateid is unrecognized. */
+                                if (status != -NFS4ERR_BAD_STATEID)
+                                        nfs41_free_stateid(server,
+                                                        &lsp->ls_stateid);
                                 lsp->ls_flags &= ~NFS_LOCK_INITIALIZED;
                                 ret = status;
                         }
@@ -4707,9 +4785,9 @@ static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *reques
 
         if (test_bit(LK_STATE_IN_USE, &state->flags))
                 status = nfs41_check_expired_locks(state);
-        if (status == NFS_OK)
-                return status;
-        return nfs4_lock_expired(state, request);
+        if (status != NFS_OK)
+                status = nfs4_lock_expired(state, request);
+        return status;
 }
 #endif
 
@@ -4807,7 +4885,7 @@ nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
          * Don't rely on the VFS having checked the file open mode,
          * since it won't do this for flock() locks.
          */
-        switch (request->fl_type & (F_RDLCK|F_WRLCK|F_UNLCK)) {
+        switch (request->fl_type) {
         case F_RDLCK:
                 if (!(filp->f_mode & FMODE_READ))
                         return -EBADF;
@@ -5168,6 +5246,8 @@ out:
 /*
  * nfs4_proc_exchange_id()
  *
+ * Returns zero, a negative errno, or a negative NFS4ERR status code.
+ *
  * Since the clientid has expired, all compounds using sessions
  * associated with the stale clientid will be returning
  * NFS4ERR_BADSESSION in the sequence operation, and will therefore
@@ -5192,16 +5272,14 @@ int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
                 .rpc_cred = cred,
         };
 
-        dprintk("--> %s\n", __func__);
-        BUG_ON(clp == NULL);
-
         nfs4_init_boot_verifier(clp, &verifier);
-
         args.id_len = scnprintf(args.id, sizeof(args.id),
-                                "%s/%s/%u",
+                                "%s/%s",
                                 clp->cl_ipaddr,
-                                clp->cl_rpcclient->cl_nodename,
-                                clp->cl_rpcclient->cl_auth->au_flavor);
+                                clp->cl_rpcclient->cl_nodename);
+        dprintk("NFS call  exchange_id auth=%s, '%.*s'\n",
+                clp->cl_rpcclient->cl_auth->au_ops->au_name,
+                args.id_len, args.id);
 
         res.server_owner = kzalloc(sizeof(struct nfs41_server_owner),
                                         GFP_NOFS);
@@ -5264,12 +5342,12 @@ out_server_scope:
         kfree(res.server_scope);
 out:
         if (clp->cl_implid != NULL)
-                dprintk("%s: Server Implementation ID: "
+                dprintk("NFS reply exchange_id: Server Implementation ID: "
                         "domain: %s, name: %s, date: %llu,%u\n",
-                        __func__, clp->cl_implid->domain, clp->cl_implid->name,
+                        clp->cl_implid->domain, clp->cl_implid->name,
                         clp->cl_implid->date.seconds,
                         clp->cl_implid->date.nseconds);
-        dprintk("<-- %s status= %d\n", __func__, status);
+        dprintk("NFS reply exchange_id: %d\n", status);
         return status;
 }
 
@@ -6570,22 +6648,36 @@ static int _nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
                 .rpc_resp = &res,
         };
 
+        dprintk("NFS call  test_stateid %p\n", stateid);
         nfs41_init_sequence(&args.seq_args, &res.seq_res, 0);
         status = nfs4_call_sync_sequence(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
-
-        if (status == NFS_OK)
-                return res.status;
-        return status;
+        if (status != NFS_OK) {
+                dprintk("NFS reply test_stateid: failed, %d\n", status);
+                return status;
+        }
+        dprintk("NFS reply test_stateid: succeeded, %d\n", -res.status);
+        return -res.status;
 }
 
+/**
+ * nfs41_test_stateid - perform a TEST_STATEID operation
+ *
+ * @server: server / transport on which to perform the operation
+ * @stateid: state ID to test
+ *
+ * Returns NFS_OK if the server recognizes that "stateid" is valid.
+ * Otherwise a negative NFS4ERR value is returned if the operation
+ * failed or the state ID is not currently valid.
+ */
 static int nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
 {
         struct nfs4_exception exception = { };
         int err;
         do {
-                err = nfs4_handle_exception(server,
-                                _nfs41_test_stateid(server, stateid),
-                                &exception);
+                err = _nfs41_test_stateid(server, stateid);
+                if (err != -NFS4ERR_DELAY)
+                        break;
+                nfs4_handle_exception(server, err, &exception);
         } while (exception.retry);
         return err;
 }
@@ -6601,19 +6693,34 @@ static int _nfs4_free_stateid(struct nfs_server *server, nfs4_stateid *stateid)
                 .rpc_argp = &args,
                 .rpc_resp = &res,
         };
+        int status;
 
+        dprintk("NFS call  free_stateid %p\n", stateid);
         nfs41_init_sequence(&args.seq_args, &res.seq_res, 0);
-        return nfs4_call_sync_sequence(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
+        status = nfs4_call_sync_sequence(server->client, server, &msg,
+                                         &args.seq_args, &res.seq_res, 1);
+        dprintk("NFS reply free_stateid: %d\n", status);
+        return status;
 }
 
+/**
+ * nfs41_free_stateid - perform a FREE_STATEID operation
+ *
+ * @server: server / transport on which to perform the operation
+ * @stateid: state ID to release
+ *
+ * Returns NFS_OK if the server freed "stateid".  Otherwise a
+ * negative NFS4ERR value is returned.
+ */
 static int nfs41_free_stateid(struct nfs_server *server, nfs4_stateid *stateid)
 {
         struct nfs4_exception exception = { };
         int err;
         do {
-                err = nfs4_handle_exception(server,
-                                _nfs4_free_stateid(server, stateid),
-                                &exception);
+                err = _nfs4_free_stateid(server, stateid);
+                if (err != -NFS4ERR_DELAY)
+                        break;
+                nfs4_handle_exception(server, err, &exception);
         } while (exception.retry);
         return err;
 }
@@ -6725,6 +6832,26 @@ const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {
 #endif
 };
 
+const struct inode_operations nfs4_dir_inode_operations = {
+        .create         = nfs_create,
+        .lookup         = nfs_lookup,
+        .atomic_open    = nfs_atomic_open,
+        .link           = nfs_link,
+        .unlink         = nfs_unlink,
+        .symlink        = nfs_symlink,
+        .mkdir          = nfs_mkdir,
+        .rmdir          = nfs_rmdir,
+        .mknod          = nfs_mknod,
+        .rename         = nfs_rename,
+        .permission     = nfs_permission,
+        .getattr        = nfs_getattr,
+        .setattr        = nfs_setattr,
+        .getxattr       = generic_getxattr,
+        .setxattr       = generic_setxattr,
+        .listxattr      = generic_listxattr,
+        .removexattr    = generic_removexattr,
+};
+
 static const struct inode_operations nfs4_file_inode_operations = {
         .permission     = nfs_permission,
         .getattr        = nfs_getattr,
@@ -6769,9 +6896,11 @@ const struct nfs_rpc_ops nfs_v4_clientops = {
         .set_capabilities = nfs4_server_capabilities,
         .decode_dirent  = nfs4_decode_dirent,
         .read_setup     = nfs4_proc_read_setup,
+        .read_pageio_init = pnfs_pageio_init_read,
         .read_rpc_prepare = nfs4_proc_read_rpc_prepare,
         .read_done      = nfs4_read_done,
         .write_setup    = nfs4_proc_write_setup,
+        .write_pageio_init = pnfs_pageio_init_write,
         .write_rpc_prepare = nfs4_proc_write_rpc_prepare,
         .write_done     = nfs4_write_done,
         .commit_setup   = nfs4_proc_commit_setup,
@@ -6781,7 +6910,11 @@ const struct nfs_rpc_ops nfs_v4_clientops = {
         .clear_acl_cache = nfs4_zap_acl_attr,
         .close_context  = nfs4_close_context,
         .open_context   = nfs4_atomic_open,
+        .have_delegation = nfs4_have_delegation,
+        .return_delegation = nfs4_inode_return_delegation,
+        .alloc_client   = nfs4_alloc_client,
         .init_client    = nfs4_init_client,
+        .free_client    = nfs4_free_client,
 };
 
 static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {