Merge branch 'flexfiles'

[deliverable/linux.git] / fs / nfs / nfs4proc.c

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 89818036f035b01eaaa4e45797205d53f48e9934..adae525edec4e932b1298676a672648016a19ef5 100644 (file)
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -1598,6 +1598,7 @@ _nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
 
        if (!data->rpc_done) {
                state = nfs4_try_open_cached(data);
+               trace_nfs4_cached_open(data->state);
                goto out;
        }
 
@@ -2015,6 +2016,7 @@ static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
        }
        return;
 unlock_no_action:
+       trace_nfs4_cached_open(data->state);
        rcu_read_unlock();
 out_no_action:
        task->tk_action = NULL;
@@ -2703,6 +2705,7 @@ static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
        status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
        if (status == 0 && state != NULL)
                renew_lease(server, timestamp);
+       trace_nfs4_setattr(inode, &arg.stateid, status);
        return status;
 }
 
@@ -2719,7 +2722,6 @@ static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
        int err;
        do {
                err = _nfs4_do_setattr(inode, cred, fattr, sattr, state, ilabel, olabel);
-               trace_nfs4_setattr(inode, err);
                switch (err) {
                case -NFS4ERR_OPENMODE:
                        if (!(sattr->ia_valid & ATTR_SIZE)) {
@@ -5048,7 +5050,6 @@ static void nfs4_init_boot_verifier(const struct nfs_client *clp,
 static int
 nfs4_init_nonuniform_client_string(struct nfs_client *clp)
 {
-       int result;
        size_t len;
        char *str;
 
@@ -5076,7 +5077,7 @@ nfs4_init_nonuniform_client_string(struct nfs_client *clp)
                return -ENOMEM;
 
        rcu_read_lock();
-       result = scnprintf(str, len, "Linux NFSv4.0 %s/%s %s",
+       scnprintf(str, len, "Linux NFSv4.0 %s/%s %s",
                        clp->cl_ipaddr,
                        rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR),
                        rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_PROTO));
@@ -5089,7 +5090,6 @@ nfs4_init_nonuniform_client_string(struct nfs_client *clp)
 static int
 nfs4_init_uniquifier_client_string(struct nfs_client *clp)
 {
-       int result;
        size_t len;
        char *str;
 
@@ -5109,7 +5109,7 @@ nfs4_init_uniquifier_client_string(struct nfs_client *clp)
        if (!str)
                return -ENOMEM;
 
-       result = scnprintf(str, len, "Linux NFSv%u.%u %s/%s",
+       scnprintf(str, len, "Linux NFSv%u.%u %s/%s",
                        clp->rpc_ops->version, clp->cl_minorversion,
                        nfs4_client_id_uniquifier,
                        clp->cl_rpcclient->cl_nodename);
@@ -5120,7 +5120,6 @@ nfs4_init_uniquifier_client_string(struct nfs_client *clp)
 static int
 nfs4_init_uniform_client_string(struct nfs_client *clp)
 {
-       int result;
        size_t len;
        char *str;
 
@@ -5145,7 +5144,7 @@ nfs4_init_uniform_client_string(struct nfs_client *clp)
        if (!str)
                return -ENOMEM;
 
-       result = scnprintf(str, len, "Linux NFSv%u.%u %s",
+       scnprintf(str, len, "Linux NFSv%u.%u %s",
                        clp->rpc_ops->version, clp->cl_minorversion,
                        clp->cl_rpcclient->cl_nodename);
        clp->cl_owner_id = str;
@@ -5384,6 +5383,11 @@ static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, co
        if (data == NULL)
                return -ENOMEM;
        nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
+
+       nfs4_state_protect(server->nfs_client,
+                       NFS_SP4_MACH_CRED_CLEANUP,
+                       &task_setup_data.rpc_client, &msg);
+
        data->args.fhandle = &data->fh;
        data->args.stateid = &data->stateid;
        data->args.bitmask = server->cache_consistency_bitmask;
@@ -5426,7 +5430,7 @@ int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4
        int err;
        do {
                err = _nfs4_proc_delegreturn(inode, cred, stateid, issync);
-               trace_nfs4_delegreturn(inode, err);
+               trace_nfs4_delegreturn(inode, stateid, err);
                switch (err) {
                        case -NFS4ERR_STALE_STATEID:
                        case -NFS4ERR_EXPIRED:
@@ -5936,6 +5940,7 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *f
                data->cancelled = 1;
        rpc_put_task(task);
        dprintk("%s: done, ret = %d!\n", __func__, ret);
+       trace_nfs4_set_lock(fl, state, &data->res.stateid, cmd, ret);
        return ret;
 }
 
@@ -5952,7 +5957,6 @@ static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request
                if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
                        return 0;
                err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM);
-               trace_nfs4_lock_reclaim(request, state, F_SETLK, err);
                if (err != -NFS4ERR_DELAY)
                        break;
                nfs4_handle_exception(server, err, &exception);
@@ -5979,7 +5983,6 @@ static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request
                if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
                        return 0;
                err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED);
-               trace_nfs4_lock_expired(request, state, F_SETLK, err);
                switch (err) {
                default:
                        goto out;
@@ -6087,7 +6090,6 @@ static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *
 
        do {
                err = _nfs4_proc_setlk(state, cmd, request);
-               trace_nfs4_set_lock(request, state, cmd, err);
                if (err == -NFS4ERR_DENIED)
                        err = -EAGAIN;
                err = nfs4_handle_exception(NFS_SERVER(state->inode),
@@ -6862,10 +6864,13 @@ static const struct nfs41_state_protection nfs4_sp4_mach_cred_request = {
        },
        .allow.u.words = {
                [0] = 1 << (OP_CLOSE) |
+                     1 << (OP_OPEN_DOWNGRADE) |
                      1 << (OP_LOCKU) |
+                     1 << (OP_DELEGRETURN) |
                      1 << (OP_COMMIT),
                [1] = 1 << (OP_SECINFO - 32) |
                      1 << (OP_SECINFO_NO_NAME - 32) |
+                     1 << (OP_LAYOUTRETURN - 32) |
                      1 << (OP_TEST_STATEID - 32) |
                      1 << (OP_FREE_STATEID - 32) |
                      1 << (OP_WRITE - 32)
@@ -6930,11 +6935,19 @@ static int nfs4_sp4_select_mode(struct nfs_client *clp,
                }
 
                if (test_bit(OP_CLOSE, sp->allow.u.longs) &&
+                   test_bit(OP_OPEN_DOWNGRADE, sp->allow.u.longs) &&
+                   test_bit(OP_DELEGRETURN, sp->allow.u.longs) &&
                    test_bit(OP_LOCKU, sp->allow.u.longs)) {
                        dfprintk(MOUNT, "  cleanup mode enabled\n");
                        set_bit(NFS_SP4_MACH_CRED_CLEANUP, &clp->cl_sp4_flags);
                }
 
+               if (test_bit(OP_LAYOUTRETURN, sp->allow.u.longs)) {
+                       dfprintk(MOUNT, "  pnfs cleanup mode enabled\n");
+                       set_bit(NFS_SP4_MACH_CRED_PNFS_CLEANUP,
+                               &clp->cl_sp4_flags);
+               }
+
                if (test_bit(OP_SECINFO, sp->allow.u.longs) &&
                    test_bit(OP_SECINFO_NO_NAME, sp->allow.u.longs)) {
                        dfprintk(MOUNT, "  secinfo mode enabled\n");
@@ -7798,6 +7811,15 @@ static void nfs4_layoutget_done(struct rpc_task *task, void *calldata)
        switch (task->tk_status) {
        case 0:
                goto out;
+
+       /*
+        * NFS4ERR_LAYOUTUNAVAILABLE means we are not supposed to use pnfs
+        * on the file. set tk_status to -ENODATA to tell upper layer to
+        * retry go inband.
+        */
+       case -NFS4ERR_LAYOUTUNAVAILABLE:
+               task->tk_status = -ENODATA;
+               goto out;
        /*
         * NFS4ERR_BADLAYOUT means the MDS cannot return a layout of
         * length lgp->args.minlength != 0 (see RFC5661 section 18.43.3).
@@ -7994,6 +8016,7 @@ nfs4_proc_layoutget(struct nfs4_layoutget *lgp, gfp_t gfp_flags)
        trace_nfs4_layoutget(lgp->args.ctx,
                        &lgp->args.range,
                        &lgp->res.range,
+                       &lgp->res.stateid,
                        status);
        /* if layoutp->len is 0, nfs4_layoutget_prepare called rpc_exit */
        if (status == 0 && lgp->res.layoutp->len)
@@ -8086,6 +8109,10 @@ int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync)
        };
        int status = 0;
 
+       nfs4_state_protect(NFS_SERVER(lrp->args.inode)->nfs_client,
+                       NFS_SP4_MACH_CRED_PNFS_CLEANUP,
+                       &task_setup_data.rpc_client, &msg);
+
        dprintk("--> %s\n", __func__);
        if (!sync) {
                lrp->inode = nfs_igrab_and_active(lrp->args.inode);
@@ -8101,7 +8128,7 @@ int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync)
                return PTR_ERR(task);
        if (sync)
                status = task->tk_status;
-       trace_nfs4_layoutreturn(lrp->args.inode, status);
+       trace_nfs4_layoutreturn(lrp->args.inode, &lrp->args.stateid, status);
        dprintk("<-- %s status=%d\n", __func__, status);
        rpc_put_task(task);
        return status;
@@ -8249,7 +8276,7 @@ nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)
                return PTR_ERR(task);
        if (sync)
                status = task->tk_status;
-       trace_nfs4_layoutcommit(data->args.inode, status);
+       trace_nfs4_layoutcommit(data->args.inode, &data->args.stateid, status);
        dprintk("%s: status %d\n", __func__, status);
        rpc_put_task(task);
        return status;