These two patches do some final cleanup of SP4_MACH_CRED:
- actually call put_rpccred() if we get_rpccred(clp->cl_machine_cred)
- advertise to server that we support WRITE and COMMIT
Tested against a linux nfsd hacked to "support" sp4_mach_cred for the
client supported ops. Also tested building with v4.1 disabled and v4 disabled.
Trond - it's (obviously) up to you if these get in during this merge window.
I think they're pretty straightforward. Also, these patches are independent
from eachother, so it's ok to select one but not the other.
Weston Andros Adamson (2):
NFSv4.1: clean up after using machine cred
NFSv4.1: sp4_mach_cred: ask for WRITE and COMMIT
fs/nfs/nfs4_fs.h | 58 ++++++++++++++++++++++++++++++++++++-------------------
fs/nfs/nfs4proc.c | 58 +++++++++++++++++++++++++++++++++++++------------------
fs/nfs/write.c | 18 +++++++++++------
3 files changed, 89 insertions(+), 45 deletions(-)
--
1.7.12.4 (Apple Git-37)
Request SP4_MACH_CRED WRITE and COMMIT support in spo_must_allow list --
they're already supported by the client.
Signed-off-by: Weston Andros Adamson <[email protected]>
---
fs/nfs/nfs4proc.c | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index ee0d1eb..10feb7b 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -6162,11 +6162,13 @@ static const struct nfs41_state_protection nfs4_sp4_mach_cred_request = {
},
.allow.u.words = {
[0] = 1 << (OP_CLOSE) |
- 1 << (OP_LOCKU),
+ 1 << (OP_LOCKU) |
+ 1 << (OP_COMMIT),
[1] = 1 << (OP_SECINFO - 32) |
1 << (OP_SECINFO_NO_NAME - 32) |
1 << (OP_TEST_STATEID - 32) |
- 1 << (OP_FREE_STATEID - 32)
+ 1 << (OP_FREE_STATEID - 32) |
+ 1 << (OP_WRITE - 32)
}
};
--
1.7.12.4 (Apple Git-37)
T24gVHVlLCAyMDEzLTA5LTEwIGF0IDIxOjA4ICswMDAwLCBBZGFtc29uLCBEcm9zIHdyb3RlOg0K
PiBZZXMsIEkgdGhvdWdodCBhYm91dCB0aGlzIGFwcHJvYWNoLCBidXQgYmFja2VkIGF3YXkgc2lu
Y2Ugd2UgZG8gZ2V0L3B1dF9ycGNjcmVkIG9uIHRoZSBjbF9tYWNoaW5lX2NyZWQgZWxzZXdoZXJl
IChsaWtlIG5mczRfZ2V0X21hY2hpbmVfY3JlZF9sb2NrZWQpLg0KPiANCj4gU2hhbGwgSSBzdWJt
aXQgYSBuZXcgcGF0Y2ggdGhhdCBnZXRzIHJpZCBvZiBnZXQvcHV0X3JwY2NyZWQ/DQoNClBsZWFz
ZSBkby4NCg0KPiBEbyB3ZSBhbHNvIHdhbnQgdG8gY2hhbmdlIG90aGVyIHVzZXMgb2YgY2xfbWFj
aGluZV9jcmVkPw0KDQpOb3QgZm9yIG5vdzsgbGV0J3Mgd2FpdCBmb3IgYW5vdGhlciBtZXJnZSBj
eWNsZSBiZWZvcmUgZG9pbmcgdGhhdC4NCg0KPiBUaGFua3MsDQo+IC1kcm9zDQo+IA0KPiBPbiBT
ZXAgMTAsIDIwMTMsIGF0IDM6MzEgUE0sICJNeWtsZWJ1c3QsIFRyb25kIiA8VHJvbmQuTXlrbGVi
dXN0QG5ldGFwcC5jb20+DQo+ICB3cm90ZToNCj4gDQo+ID4gT24gVHVlLCAyMDEzLTA5LTEwIGF0
IDE0OjU1IC0wNDAwLCBXZXN0b24gQW5kcm9zIEFkYW1zb24gd3JvdGU6DQo+ID4+IENsaWVudCBj
YWxscyBnZXRfcnBjY3JlZCB3aGVuIHJlZmVyZW5jaW5nIHRoZSBtYWNoaW5lIGNyZWQsIHNvIGl0
IG11c3QgY2FsbA0KPiA+PiBwdXRfcnBjY3JlZCBhZnRlciBwYXNzaW5nIGNyZWQgdG8gcnBjIGxh
eWVyLg0KPiA+PiANCj4gPj4gVGhpcyBwYXRjaCBhbHNvIG1vdmVzIG5mczRfc3A0X2luaXQgKGZv
cm1lcmx5IG5mczRfc3RhdGVfcHJvdGVjdCkgdG8gcmlnaHQNCj4gPj4gYmVmb3JlIHRoZSBjYWxs
IHRvIHJwY19ydW5fdGFzayAoYW5kIHdyYXBwZXJzIG9mIHJwY19ydW5fdGFzaykgdG8gbWluaW1p
emUNCj4gPj4gZXJyb3IgcGF0aCBjbGVhbnVwIGNvZGUuDQo+ID4+IA0KPiA+IA0KPiA+IERvIHdl
IHJlYWxseSBuZWVkIHRoaXM/IEFGQUlDUyBvbmNlIHRoZSBjbHAtPmNsX21hY2hpbmVfY3JlZCBp
cyBzZXQsIGl0DQo+ID4gaXNuJ3QgZnJlZWQgdW50aWwgdGhlIGNhbGwgdG8gbmZzX2ZyZWVfY2xp
ZW50KCkuIEluIGZhY3QsIHdlIHByb2JhYmx5DQo+ID4gX3JlbHlfIG9uIHRoaXMgYmVpbmcgdGhl
IGNhc2UgZm9yIFNQNF9NQUNIX0NSRUQsIHNpbmNlIGlmIHRoZSBtYWNoaW5lDQo+ID4gY3JlZCB3
ZXJlIHRvIGNoYW5nZSwgd2UnZCBubyBsb25nZXIgYmUgYWJsZSB0byBjaGFuZ2Ugb3VyIHNlc3Np
b24gb3INCj4gPiBsZWFzZS4NCj4gPiANCj4gPiBJT1c6IGluc3RlYWQgb2YgcmVmZXJlbmNpbmcg
dGhlIGNyZWQgdmlhIGdldC9wdXRfcnBjY3JlZCgpLCBtYXliZSB3ZSBjYW4NCj4gPiBqdXN0IGZl
ZWQgdGhlIGN1cnJlbnQgdmFsdWUgb2YgY2xwLT5jbF9tYWNoaW5lX2NyZWQgaW50byB0aGUNCj4g
PiBtc2ctPnJwY19jcmVkLg0KPiA+IA0KPiA+IC0tIA0KPiA+IFRyb25kIE15a2xlYnVzdA0KPiA+
IExpbnV4IE5GUyBjbGllbnQgbWFpbnRhaW5lcg0KPiA+IA0KPiA+IE5ldEFwcA0KPiA+IFRyb25k
Lk15a2xlYnVzdEBuZXRhcHAuY29tDQo+ID4gd3d3Lm5ldGFwcC5jb20NCj4gDQoNCi0tIA0KVHJv
bmQgTXlrbGVidXN0DQpMaW51eCBORlMgY2xpZW50IG1haW50YWluZXINCg0KTmV0QXBwDQpUcm9u
ZC5NeWtsZWJ1c3RAbmV0YXBwLmNvbQ0Kd3d3Lm5ldGFwcC5jb20NCg==
Yes, I thought about this approach, but backed away since we do get/put_rpccred on the cl_machine_cred elsewhere (like nfs4_get_machine_cred_locked).
Shall I submit a new patch that gets rid of get/put_rpccred?
Do we also want to change other uses of cl_machine_cred?
Thanks,
-dros
On Sep 10, 2013, at 3:31 PM, "Myklebust, Trond" <[email protected]>
wrote:
> On Tue, 2013-09-10 at 14:55 -0400, Weston Andros Adamson wrote:
>> Client calls get_rpccred when referencing the machine cred, so it must call
>> put_rpccred after passing cred to rpc layer.
>>
>> This patch also moves nfs4_sp4_init (formerly nfs4_state_protect) to right
>> before the call to rpc_run_task (and wrappers of rpc_run_task) to minimize
>> error path cleanup code.
>>
>
> Do we really need this? AFAICS once the clp->cl_machine_cred is set, it
> isn't freed until the call to nfs_free_client(). In fact, we probably
> _rely_ on this being the case for SP4_MACH_CRED, since if the machine
> cred were to change, we'd no longer be able to change our session or
> lease.
>
> IOW: instead of referencing the cred via get/put_rpccred(), maybe we can
> just feed the current value of clp->cl_machine_cred into the
> msg->rpc_cred.
>
> --
> Trond Myklebust
> Linux NFS client maintainer
>
> NetApp
> [email protected]
> http://www.netapp.com
T24gVHVlLCAyMDEzLTA5LTEwIGF0IDE0OjU1IC0wNDAwLCBXZXN0b24gQW5kcm9zIEFkYW1zb24g
d3JvdGU6DQo+IENsaWVudCBjYWxscyBnZXRfcnBjY3JlZCB3aGVuIHJlZmVyZW5jaW5nIHRoZSBt
YWNoaW5lIGNyZWQsIHNvIGl0IG11c3QgY2FsbA0KPiBwdXRfcnBjY3JlZCBhZnRlciBwYXNzaW5n
IGNyZWQgdG8gcnBjIGxheWVyLg0KPiANCj4gVGhpcyBwYXRjaCBhbHNvIG1vdmVzIG5mczRfc3A0
X2luaXQgKGZvcm1lcmx5IG5mczRfc3RhdGVfcHJvdGVjdCkgdG8gcmlnaHQNCj4gYmVmb3JlIHRo
ZSBjYWxsIHRvIHJwY19ydW5fdGFzayAoYW5kIHdyYXBwZXJzIG9mIHJwY19ydW5fdGFzaykgdG8g
bWluaW1pemUNCj4gZXJyb3IgcGF0aCBjbGVhbnVwIGNvZGUuDQo+IA0KDQpEbyB3ZSByZWFsbHkg
bmVlZCB0aGlzPyBBRkFJQ1Mgb25jZSB0aGUgY2xwLT5jbF9tYWNoaW5lX2NyZWQgaXMgc2V0LCBp
dA0KaXNuJ3QgZnJlZWQgdW50aWwgdGhlIGNhbGwgdG8gbmZzX2ZyZWVfY2xpZW50KCkuIEluIGZh
Y3QsIHdlIHByb2JhYmx5DQpfcmVseV8gb24gdGhpcyBiZWluZyB0aGUgY2FzZSBmb3IgU1A0X01B
Q0hfQ1JFRCwgc2luY2UgaWYgdGhlIG1hY2hpbmUNCmNyZWQgd2VyZSB0byBjaGFuZ2UsIHdlJ2Qg
bm8gbG9uZ2VyIGJlIGFibGUgdG8gY2hhbmdlIG91ciBzZXNzaW9uIG9yDQpsZWFzZS4NCg0KSU9X
OiBpbnN0ZWFkIG9mIHJlZmVyZW5jaW5nIHRoZSBjcmVkIHZpYSBnZXQvcHV0X3JwY2NyZWQoKSwg
bWF5YmUgd2UgY2FuDQpqdXN0IGZlZWQgdGhlIGN1cnJlbnQgdmFsdWUgb2YgY2xwLT5jbF9tYWNo
aW5lX2NyZWQgaW50byB0aGUNCm1zZy0+cnBjX2NyZWQuDQoNCi0tIA0KVHJvbmQgTXlrbGVidXN0
DQpMaW51eCBORlMgY2xpZW50IG1haW50YWluZXINCg0KTmV0QXBwDQpUcm9uZC5NeWtsZWJ1c3RA
bmV0YXBwLmNvbQ0Kd3d3Lm5ldGFwcC5jb20NCg==
Client calls get_rpccred when referencing the machine cred, so it must call
put_rpccred after passing cred to rpc layer.
This patch also moves nfs4_sp4_init (formerly nfs4_state_protect) to right
before the call to rpc_run_task (and wrappers of rpc_run_task) to minimize
error path cleanup code.
Signed-off-by: Weston Andros Adamson <[email protected]>
---
fs/nfs/nfs4_fs.h | 58 ++++++++++++++++++++++++++++++++++++-------------------
fs/nfs/nfs4proc.c | 52 +++++++++++++++++++++++++++++++++----------------
fs/nfs/write.c | 18 +++++++++++------
3 files changed, 85 insertions(+), 43 deletions(-)
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index f520a11..63e3936 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -269,9 +269,10 @@ is_ds_client(struct nfs_client *clp)
return clp->cl_exchange_flags & EXCHGID4_FLAG_USE_PNFS_DS;
}
-static inline bool
-_nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
- struct rpc_clnt **clntp, struct rpc_message *msg)
+static inline void
+_nfs4_sp4_init(struct nfs_client *clp, unsigned long sp4_mode,
+ struct rpc_clnt **clntp, struct rpc_message *msg,
+ bool *did_sp4)
{
struct rpc_cred *newcred = NULL;
rpc_authflavor_t flavor;
@@ -290,9 +291,9 @@ _nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
flavor != RPC_AUTH_GSS_KRB5P);
*clntp = clp->cl_rpcclient;
- return true;
- }
- return false;
+ *did_sp4 = true;
+ } else
+ *did_sp4 = false;
}
/*
@@ -302,25 +303,34 @@ _nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
* Should be called before rpc_call_sync/rpc_call_async.
*/
static inline void
-nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
- struct rpc_clnt **clntp, struct rpc_message *msg)
+nfs4_sp4_init(struct nfs_client *clp, unsigned long sp4_mode,
+ struct rpc_clnt **clntp, struct rpc_message *msg,
+ bool *did_sp4)
{
- _nfs4_state_protect(clp, sp4_mode, clntp, msg);
+ _nfs4_sp4_init(clp, sp4_mode, clntp, msg, did_sp4);
}
/*
- * Special wrapper to nfs4_state_protect for write.
+ * Special wrapper to nfs4_sp4_init for write.
* If WRITE can use machine cred but COMMIT cannot, make sure all writes
* that use machine cred use NFS_FILE_SYNC.
*/
static inline void
-nfs4_state_protect_write(struct nfs_client *clp, struct rpc_clnt **clntp,
- struct rpc_message *msg, struct nfs_write_data *wdata)
+nfs4_sp4_write_init(struct nfs_client *clp, struct rpc_clnt **clntp,
+ struct rpc_message *msg, struct nfs_write_data *wdata,
+ bool *did_sp4)
{
- if (_nfs4_state_protect(clp, NFS_SP4_MACH_CRED_WRITE, clntp, msg) &&
- !test_bit(NFS_SP4_MACH_CRED_COMMIT, &clp->cl_sp4_flags))
+ _nfs4_sp4_init(clp, NFS_SP4_MACH_CRED_WRITE, clntp, msg, did_sp4);
+ if (*did_sp4 && !test_bit(NFS_SP4_MACH_CRED_COMMIT, &clp->cl_sp4_flags))
wdata->args.stable = NFS_FILE_SYNC;
}
+
+static inline void
+nfs4_sp4_cleanup(struct rpc_message *msg, bool did_sp4)
+{
+ if (did_sp4)
+ put_rpccred(msg->rpc_cred);
+}
#else /* CONFIG_NFS_v4_1 */
static inline struct nfs4_session *nfs4_get_session(const struct nfs_server *server)
{
@@ -340,14 +350,20 @@ is_ds_client(struct nfs_client *clp)
}
static inline void
-nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_flags,
- struct rpc_clnt **clntp, struct rpc_message *msg)
+nfs4_sp4_init(struct nfs_client *clp, unsigned long sp4_flags,
+ struct rpc_clnt **clntp, struct rpc_message *msg, bool *did_sp4)
+{
+}
+
+static inline void
+nfs4_sp4_write_init(struct nfs_client *clp, struct rpc_clnt **clntp,
+ struct rpc_message *msg, struct nfs_write_data *wdata,
+ bool *did_sp4)
{
}
static inline void
-nfs4_state_protect_write(struct nfs_client *clp, struct rpc_clnt **clntp,
- struct rpc_message *msg, struct nfs_write_data *wdata)
+nfs4_sp4_cleanup(struct rpc_message *msg, bool did_sp4)
{
}
#endif /* CONFIG_NFS_V4_1 */
@@ -485,8 +501,10 @@ static inline bool nfs4_valid_open_stateid(const struct nfs4_state *state)
#define nfs4_close_state(a, b) do { } while (0)
#define nfs4_close_sync(a, b) do { } while (0)
-#define nfs4_state_protect(a, b, c, d) do { } while (0)
-#define nfs4_state_protect_write(a, b, c, d) do { } while (0)
+/* nfs4_sp4_*_init sets bool "did_sp4" to avoid warning */
+#define nfs4_sp4_init(a, b, c, d, e) (*e = false)
+#define nfs4_sp4_write_init(a, b, c, d, e) (*e = false)
+#define nfs4_sp4_cleanup(a, b) do { } while (0)
#endif /* CONFIG_NFS_V4 */
#endif /* __LINUX_FS_NFS_NFS4_FS.H */
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 39b6cf2..ee0d1eb 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -2615,9 +2615,7 @@ int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
.flags = RPC_TASK_ASYNC,
};
int status = -ENOMEM;
-
- nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP,
- &task_setup_data.rpc_client, &msg);
+ bool did_sp4;
calldata = kzalloc(sizeof(*calldata), gfp_mask);
if (calldata == NULL)
@@ -2642,7 +2640,12 @@ int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
msg.rpc_argp = &calldata->arg;
msg.rpc_resp = &calldata->res;
task_setup_data.callback_data = calldata;
+
+ nfs4_sp4_init(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP,
+ &task_setup_data.rpc_client, &msg, &did_sp4);
task = rpc_run_task(&task_setup_data);
+ nfs4_sp4_cleanup(&msg, did_sp4);
+
if (IS_ERR(task))
return PTR_ERR(task);
status = 0;
@@ -5242,9 +5245,8 @@ static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
.workqueue = nfsiod_workqueue,
.flags = RPC_TASK_ASYNC,
};
-
- nfs4_state_protect(NFS_SERVER(lsp->ls_state->inode)->nfs_client,
- NFS_SP4_MACH_CRED_CLEANUP, &task_setup_data.rpc_client, &msg);
+ struct rpc_task *task;
+ bool did_sp4;
/* Ensure this is an unlock - when canceling a lock, the
* canceled lock is passed in, and it won't be an unlock.
@@ -5261,7 +5263,14 @@ static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
msg.rpc_argp = &data->arg;
msg.rpc_resp = &data->res;
task_setup_data.callback_data = data;
- return rpc_run_task(&task_setup_data);
+
+ nfs4_sp4_init(NFS_SERVER(lsp->ls_state->inode)->nfs_client,
+ NFS_SP4_MACH_CRED_CLEANUP, &task_setup_data.rpc_client, &msg,
+ &did_sp4);
+ task = rpc_run_task(&task_setup_data);
+ nfs4_sp4_cleanup(&msg, did_sp4);
+
+ return task;
}
static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)
@@ -6001,6 +6010,7 @@ static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct
.rpc_resp = &res,
};
struct rpc_clnt *clnt = NFS_SERVER(dir)->client;
+ bool did_sp4;
if (use_integrity) {
clnt = NFS_SERVER(dir)->nfs_client->cl_rpcclient;
@@ -6009,11 +6019,12 @@ static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct
dprintk("NFS call secinfo %s\n", name->name);
- nfs4_state_protect(NFS_SERVER(dir)->nfs_client,
- NFS_SP4_MACH_CRED_SECINFO, &clnt, &msg);
-
+ nfs4_sp4_init(NFS_SERVER(dir)->nfs_client,
+ NFS_SP4_MACH_CRED_SECINFO, &clnt, &msg, &did_sp4);
status = nfs4_call_sync(clnt, NFS_SERVER(dir), &msg, &args.seq_args,
&res.seq_res, 0);
+ nfs4_sp4_cleanup(&msg, did_sp4);
+
dprintk("NFS reply secinfo: %d\n", status);
if (msg.rpc_cred)
@@ -7609,15 +7620,18 @@ static int _nfs41_test_stateid(struct nfs_server *server,
.rpc_cred = cred,
};
struct rpc_clnt *rpc_client = server->client;
-
- nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
- &rpc_client, &msg);
+ bool did_sp4;
dprintk("NFS call test_stateid %p\n", stateid);
nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
nfs4_set_sequence_privileged(&args.seq_args);
+
+ nfs4_sp4_init(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
+ &rpc_client, &msg, &did_sp4);
status = nfs4_call_sync_sequence(rpc_client, server, &msg,
&args.seq_args, &res.seq_res);
+ nfs4_sp4_cleanup(&msg, did_sp4);
+
if (status != NFS_OK) {
dprintk("NFS reply test_stateid: failed, %d\n", status);
return status;
@@ -7707,9 +7721,8 @@ static struct rpc_task *_nfs41_free_stateid(struct nfs_server *server,
.flags = RPC_TASK_ASYNC,
};
struct nfs_free_stateid_data *data;
-
- nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
- &task_setup.rpc_client, &msg);
+ struct rpc_task *task;
+ bool did_sp4;
dprintk("NFS call free_stateid %p\n", stateid);
data = kmalloc(sizeof(*data), GFP_NOFS);
@@ -7726,7 +7739,12 @@ static struct rpc_task *_nfs41_free_stateid(struct nfs_server *server,
if (privileged)
nfs4_set_sequence_privileged(&data->args.seq_args);
- return rpc_run_task(&task_setup);
+ nfs4_sp4_init(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
+ &task_setup.rpc_client, &msg, &did_sp4);
+ task = rpc_run_task(&task_setup);
+ nfs4_sp4_cleanup(&msg, did_sp4);
+
+ return task;
}
/**
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index ac1dc33..da306c0 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -1010,6 +1010,7 @@ int nfs_initiate_write(struct rpc_clnt *clnt,
.priority = priority,
};
int ret = 0;
+ bool did_sp4;
/* Set up the initial task struct. */
NFS_PROTO(inode)->write_setup(data, &msg);
@@ -1022,10 +1023,11 @@ int nfs_initiate_write(struct rpc_clnt *clnt,
data->args.count,
(unsigned long long)data->args.offset);
- nfs4_state_protect_write(NFS_SERVER(inode)->nfs_client,
- &task_setup_data.rpc_client, &msg, data);
-
+ nfs4_sp4_write_init(NFS_SERVER(inode)->nfs_client,
+ &task_setup_data.rpc_client, &msg, data, &did_sp4);
task = rpc_run_task(&task_setup_data);
+ nfs4_sp4_cleanup(&msg, did_sp4);
+
if (IS_ERR(task)) {
ret = PTR_ERR(task);
goto out;
@@ -1486,15 +1488,19 @@ int nfs_initiate_commit(struct rpc_clnt *clnt, struct nfs_commit_data *data,
.flags = RPC_TASK_ASYNC | flags,
.priority = priority,
};
+ bool did_sp4;
+
/* Set up the initial task struct. */
NFS_PROTO(data->inode)->commit_setup(data, &msg);
dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid);
- nfs4_state_protect(NFS_SERVER(data->inode)->nfs_client,
- NFS_SP4_MACH_CRED_COMMIT, &task_setup_data.rpc_client, &msg);
-
+ nfs4_sp4_init(NFS_SERVER(data->inode)->nfs_client,
+ NFS_SP4_MACH_CRED_COMMIT, &task_setup_data.rpc_client, &msg,
+ &did_sp4);
task = rpc_run_task(&task_setup_data);
+ nfs4_sp4_cleanup(&msg, did_sp4);
+
if (IS_ERR(task))
return PTR_ERR(task);
if (how & FLUSH_SYNC)
--
1.7.12.4 (Apple Git-37)