Lines Matching defs:data
97 static int _nfs4_recover_proc_open(struct nfs4_opendata *data);
994 struct nfs4_call_sync_data *data = calldata;
996 dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server);
998 nfs4_setup_sequence(data->seq_server->nfs_client,
999 data->seq_args, data->seq_res, task);
1004 struct nfs4_call_sync_data *data = calldata;
1006 nfs41_sequence_done(task, data->seq_res);
1115 struct nfs4_call_sync_data *data = calldata;
1116 nfs4_setup_sequence(data->seq_server->nfs_client,
1117 data->seq_args, data->seq_res, task);
1122 struct nfs4_call_sync_data *data = calldata;
1123 nfs4_sequence_done(task, data->seq_res);
1153 struct nfs4_call_sync_data data = {
1162 .callback_data = &data,
1382 memcpy(p->o_arg.u.verifier.data, c->verf,
1383 sizeof(p->o_arg.u.verifier.data));
1927 nfs4_opendata_check_deleg(struct nfs4_opendata *data, struct nfs4_state *state)
1938 switch (data->o_arg.claim) {
1951 data->owner->so_cred,
1952 data->o_res.delegation_type,
1953 &data->o_res.delegation,
1954 data->o_res.pagemod_limit);
1957 data->owner->so_cred,
1958 data->o_res.delegation_type,
1959 &data->o_res.delegation,
1960 data->o_res.pagemod_limit);
1962 if (data->o_res.do_recall)
1964 &data->o_res.delegation);
1972 _nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data)
1974 struct inode *inode = data->state->inode;
1975 struct nfs4_state *state = data->state;
1978 if (!data->rpc_done) {
1979 if (data->rpc_status)
1980 return ERR_PTR(data->rpc_status);
1981 return nfs4_try_open_cached(data);
1984 ret = nfs_refresh_inode(inode, &data->f_attr);
1988 if (data->o_res.delegation_type != 0)
1989 nfs4_opendata_check_deleg(data, state);
1991 if (!update_open_stateid(state, &data->o_res.stateid,
1992 NULL, data->o_arg.fmode))
2000 nfs4_opendata_get_inode(struct nfs4_opendata *data)
2004 switch (data->o_arg.claim) {
2008 if (!(data->f_attr.valid & NFS_ATTR_FATTR))
2010 inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh,
2011 &data->f_attr, data->f_label);
2014 inode = d_inode(data->dentry);
2016 nfs_refresh_inode(inode, &data->f_attr);
2022 nfs4_opendata_find_nfs4_state(struct nfs4_opendata *data)
2027 inode = nfs4_opendata_get_inode(data);
2030 if (data->state != NULL && data->state->inode == inode) {
2031 state = data->state;
2034 state = nfs4_get_open_state(inode, data->owner);
2042 _nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
2046 if (!data->rpc_done) {
2047 state = nfs4_try_open_cached(data);
2048 trace_nfs4_cached_open(data->state);
2052 state = nfs4_opendata_find_nfs4_state(data);
2056 if (data->o_res.delegation_type != 0)
2057 nfs4_opendata_check_deleg(data, state);
2058 if (!update_open_stateid(state, &data->o_res.stateid,
2059 NULL, data->o_arg.fmode)) {
2064 nfs_release_seqid(data->o_arg.seqid);
2069 nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
2073 if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS)
2074 ret =_nfs4_opendata_reclaim_to_nfs4_state(data);
2076 ret = _nfs4_opendata_to_nfs4_state(data);
2077 nfs4_sequence_free_slot(&data->o_res.seq_res);
2334 struct nfs4_opendata *data = calldata;
2336 nfs4_setup_sequence(data->o_arg.server->nfs_client,
2337 &data->c_arg.seq_args, &data->c_res.seq_res, task);
2342 struct nfs4_opendata *data = calldata;
2344 nfs40_sequence_done(task, &data->c_res.seq_res);
2346 data->rpc_status = task->tk_status;
2347 if (data->rpc_status == 0) {
2348 nfs4_stateid_copy(&data->o_res.stateid, &data->c_res.stateid);
2349 nfs_confirm_seqid(&data->owner->so_seqid, 0);
2350 renew_lease(data->o_res.server, data->timestamp);
2351 data->rpc_done = true;
2357 struct nfs4_opendata *data = calldata;
2361 if (!data->cancelled)
2364 if (!data->rpc_done)
2366 state = nfs4_opendata_to_nfs4_state(data);
2368 nfs4_close_state(state, data->o_arg.fmode);
2370 nfs4_opendata_put(data);
2382 static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
2384 struct nfs_server *server = NFS_SERVER(d_inode(data->dir));
2388 .rpc_argp = &data->c_arg,
2389 .rpc_resp = &data->c_res,
2390 .rpc_cred = data->owner->so_cred,
2396 .callback_data = data,
2402 nfs4_init_sequence(&data->c_arg.seq_args, &data->c_res.seq_res, 1,
2403 data->is_recover);
2404 kref_get(&data->kref);
2405 data->rpc_done = false;
2406 data->rpc_status = 0;
2407 data->timestamp = jiffies;
2413 data->cancelled = true;
2416 status = data->rpc_status;
2423 struct nfs4_opendata *data = calldata;
2424 struct nfs4_state_owner *sp = data->owner;
2426 enum open_claim_type4 claim = data->o_arg.claim;
2428 if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
2434 if (data->state != NULL) {
2437 if (can_open_cached(data->state, data->o_arg.fmode,
2438 data->o_arg.open_flags, claim))
2441 delegation = nfs4_get_valid_delegation(data->state->inode);
2442 if (can_open_delegated(delegation, data->o_arg.fmode, claim))
2447 data->o_arg.clientid = clp->cl_clientid;
2454 data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0];
2459 data->timestamp = jiffies;
2460 if (nfs4_setup_sequence(data->o_arg.server->nfs_client,
2461 &data->o_arg.seq_args,
2462 &data->o_res.seq_res,
2464 nfs_release_seqid(data->o_arg.seqid);
2467 data->o_arg.createmode = NFS4_CREATE_UNCHECKED;
2468 if (data->o_arg.open_flags & O_EXCL) {
2469 data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE;
2471 data->o_arg.createmode = NFS4_CREATE_GUARDED;
2473 data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE4_1;
2477 trace_nfs4_cached_open(data->state);
2482 nfs4_sequence_done(task, &data->o_res.seq_res);
2487 struct nfs4_opendata *data = calldata;
2489 data->rpc_status = task->tk_status;
2491 if (!nfs4_sequence_process(task, &data->o_res.seq_res))
2495 if (data->o_res.f_attr->valid & NFS_ATTR_FATTR_TYPE) {
2496 switch (data->o_res.f_attr->mode & S_IFMT) {
2500 data->rpc_status = -ELOOP;
2503 data->rpc_status = -EISDIR;
2506 data->rpc_status = -ENOTDIR;
2509 renew_lease(data->o_res.server, data->timestamp);
2510 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))
2511 nfs_confirm_seqid(&data->owner->so_seqid, 0);
2513 data->rpc_done = true;
2518 struct nfs4_opendata *data = calldata;
2522 if (!data->cancelled)
2525 if (data->rpc_status != 0 || !data->rpc_done)
2528 if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)
2530 state = nfs4_opendata_to_nfs4_state(data);
2532 nfs4_close_state(state, data->o_arg.fmode);
2534 nfs4_opendata_put(data);
2543 static int nfs4_run_open_task(struct nfs4_opendata *data,
2546 struct inode *dir = d_inode(data->dir);
2548 struct nfs_openargs *o_arg = &data->o_arg;
2549 struct nfs_openres *o_res = &data->o_res;
2555 .rpc_cred = data->owner->so_cred,
2561 .callback_data = data,
2567 kref_get(&data->kref);
2568 data->rpc_done = false;
2569 data->rpc_status = 0;
2570 data->cancelled = false;
2571 data->is_recover = false;
2574 data->is_recover = true;
2578 pnfs_lgopen_prepare(data, ctx);
2585 data->cancelled = true;
2588 status = data->rpc_status;
2594 static int _nfs4_recover_proc_open(struct nfs4_opendata *data)
2596 struct inode *dir = d_inode(data->dir);
2597 struct nfs_openres *o_res = &data->o_res;
2600 status = nfs4_run_open_task(data, NULL);
2601 if (status != 0 || !data->rpc_done)
2604 nfs_fattr_map_and_free_names(NFS_SERVER(dir), &data->f_attr);
2607 status = _nfs4_proc_open_confirm(data);
2661 static int _nfs4_proc_open(struct nfs4_opendata *data,
2664 struct inode *dir = d_inode(data->dir);
2666 struct nfs_openargs *o_arg = &data->o_arg;
2667 struct nfs_openres *o_res = &data->o_res;
2670 status = nfs4_run_open_task(data, ctx);
2671 if (!data->rpc_done)
2680 nfs_fattr_map_and_free_names(server, &data->f_attr);
2684 data->file_created = true;
2686 data->file_created = true;
2687 if (data->file_created ||
2696 status = _nfs4_proc_open_confirm(data);
3532 static void nfs4_free_closedata(void *data)
3534 struct nfs4_closedata *calldata = data;
3548 static void nfs4_close_done(struct rpc_task *task, void *data)
3550 struct nfs4_closedata *calldata = data;
3623 static void nfs4_close_prepare(struct rpc_task *task, void *data)
3625 struct nfs4_closedata *calldata = data;
3722 * It is possible for data to be read/written from a mem-mapped file
4515 * align the READ data correctly. This means that the GETATTR
4519 * of data received, which doesn't seem to be available outside
4684 static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
4686 nfs4_setup_sequence(NFS_SB(data->dentry->d_sb)->nfs_client,
4687 &data->args.seq_args,
4688 &data->res.seq_res,
4694 struct nfs_unlinkdata *data = task->tk_calldata;
4695 struct nfs_removeres *res = &data->res;
4700 &data->timeout) == -EAGAIN)
4727 static void nfs4_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
4729 nfs4_setup_sequence(NFS_SERVER(data->old_dir)->nfs_client,
4730 &data->args.seq_args,
4731 &data->res.seq_res,
4738 struct nfs_renamedata *data = task->tk_calldata;
4739 struct nfs_renameres *res = &data->res;
4743 if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN)
4842 struct nfs4_createdata *data;
4844 data = kzalloc(sizeof(*data), GFP_KERNEL);
4845 if (data != NULL) {
4848 data->label = nfs4_label_alloc(server, GFP_KERNEL);
4849 if (IS_ERR(data->label))
4852 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
4853 data->msg.rpc_argp = &data->arg;
4854 data->msg.rpc_resp = &data->res;
4855 data->arg.dir_fh = NFS_FH(dir);
4856 data->arg.server = server;
4857 data->arg.name = name;
4858 data->arg.attrs = sattr;
4859 data->arg.ftype = ftype;
4860 data->arg.bitmask = nfs4_bitmask(server, data->label);
4861 data->arg.umask = current_umask();
4862 data->res.server = server;
4863 data->res.fh = &data->fh;
4864 data->res.fattr = &data->fattr;
4865 data->res.label = data->label;
4866 nfs_fattr_init(data->res.fattr);
4868 return data;
4870 kfree(data);
4874 static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
4876 int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg,
4877 &data->arg.seq_args, &data->res.seq_res, 1);
4880 nfs4_update_changeattr_locked(dir, &data->res.dir_cinfo,
4881 data->res.fattr->time_start,
4884 if (data->arg.ftype == NF4DIR)
4887 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, data->res.label);
4892 static void nfs4_free_createdata(struct nfs4_createdata *data)
4894 nfs4_label_free(data->label);
4895 kfree(data);
4902 struct nfs4_createdata *data;
4909 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK);
4910 if (data == NULL)
4913 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];
4914 data->arg.u.symlink.pages = &page;
4915 data->arg.u.symlink.len = len;
4916 data->arg.label = label;
4918 status = nfs4_do_create(dir, dentry, data);
4920 nfs4_free_createdata(data);
4950 struct nfs4_createdata *data;
4953 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR);
4954 if (data == NULL)
4957 data->arg.label = label;
4958 status = nfs4_do_create(dir, dentry, data);
4960 nfs4_free_createdata(data);
5024 memcpy(NFS_I(dir)->cookieverf, res.verifier.data, NFS4_VERIFIER_SIZE);
5054 struct nfs4_createdata *data;
5058 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK);
5059 if (data == NULL)
5063 data->arg.ftype = NF4FIFO;
5065 data->arg.ftype = NF4BLK;
5066 data->arg.u.device.specdata1 = MAJOR(rdev);
5067 data->arg.u.device.specdata2 = MINOR(rdev);
5070 data->arg.ftype = NF4CHR;
5071 data->arg.u.device.specdata1 = MAJOR(rdev);
5072 data->arg.u.device.specdata2 = MINOR(rdev);
5078 data->arg.label = label;
5079 status = nfs4_do_create(dir, dentry, data);
5081 nfs4_free_createdata(data);
5516 static void nfs4_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
5518 nfs4_setup_sequence(NFS_SERVER(data->inode)->nfs_client,
5519 &data->args.seq_args,
5520 &data->res.seq_res,
5524 static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_commit_data *data)
5526 struct inode *inode = data->inode;
5528 trace_nfs4_commit(data, task->tk_status);
5537 static int nfs4_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
5539 if (!nfs4_sequence_done(task, &data->res.seq_res))
5541 return data->commit_done_cb(task, data);
5544 static void nfs4_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg,
5547 struct nfs_server *server = NFS_SERVER(data->inode);
5549 if (data->commit_done_cb == NULL)
5550 data->commit_done_cb = nfs4_commit_done_cb;
5551 data->res.server = server;
5553 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, 0);
5554 nfs4_state_protect(data->ds_clp ? data->ds_clp : server->nfs_client,
5603 struct nfs4_renewdata *data = calldata;
5604 struct nfs_client *clp = data->client;
5609 kfree(data);
5614 struct nfs4_renewdata *data = calldata;
5615 struct nfs_client *clp = data->client;
5616 unsigned long timestamp = data->timestamp;
5650 struct nfs4_renewdata *data;
5656 data = kmalloc(sizeof(*data), GFP_NOFS);
5657 if (data == NULL) {
5661 data->client = clp;
5662 data->timestamp = jiffies;
5664 &nfs4_renew_ops, data);
5727 char data[];
5762 memcpy(buf, acl->data, acl->len);
5780 _copy_from_pages(acl->data, pages, pgbase, acl_len);
5795 * the required buf. On a NULL buf, we send a page of data to the server
5797 * up to the page of ACL data, and the 2nd call to getxattr is serviced by
5909 * but no cached acl data, just the acl length */
6148 memcpy(bootverf->data, verf, sizeof(bootverf->data));
6296 * @clp: state data structure
6371 * @clp: state data structure
6418 struct nfs4_delegreturndata *data = calldata;
6420 .inode = data->inode,
6421 .stateid = &data->stateid,
6422 .task_is_privileged = data->args.seq_args.sa_privileged,
6425 if (!nfs4_sequence_done(task, &data->res.seq_res))
6428 trace_nfs4_delegreturn_exit(&data->args, &data->res, task->tk_status);
6431 if (pnfs_roc_done(task, &data->args.lr_args, &data->res.lr_res,
6432 &data->res.lr_ret) == -EAGAIN)
6437 renew_lease(data->res.server, data->timestamp);
6442 nfs4_free_revoked_stateid(data->res.server,
6443 data->args.stateid,
6452 if (!nfs4_refresh_delegation_stateid(&data->stateid, data->inode))
6453 nfs4_stateid_seqid_inc(&data->stateid);
6454 if (data->args.bitmask) {
6455 data->args.bitmask = NULL;
6456 data->res.fattr = NULL;
6460 if (data->args.bitmask) {
6461 data->args.bitmask = NULL;
6462 data->res.fattr = NULL;
6468 data->res.server, task->tk_status,
6473 nfs_delegation_mark_returned(data->inode, data->args.stateid);
6474 data->rpc_status = task->tk_status;
6483 struct nfs4_delegreturndata *data = calldata;
6484 struct inode *inode = data->inode;
6486 if (data->lr.roc)
6487 pnfs_roc_release(&data->lr.arg, &data->lr.res,
6488 data->res.lr_ret);
6490 nfs4_fattr_set_prechange(&data->fattr,
6492 nfs_refresh_inode(inode, &data->fattr);
6498 static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data)
6503 d_data = (struct nfs4_delegreturndata *)data;
6530 struct nfs4_delegreturndata *data;
6545 data = kzalloc(sizeof(*data), GFP_NOFS);
6546 if (data == NULL)
6553 data->args.fhandle = &data->fh;
6554 data->args.stateid = &data->stateid;
6555 nfs4_bitmask_set(data->args.bitmask_store,
6558 data->args.bitmask = data->args.bitmask_store;
6559 nfs_copy_fh(&data->fh, NFS_FH(inode));
6560 nfs4_stateid_copy(&data->stateid, stateid);
6561 data->res.fattr = &data->fattr;
6562 data->res.server = server;
6563 data->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
6564 data->lr.arg.ld_private = &data->lr.ld_private;
6565 nfs_fattr_init(data->res.fattr);
6566 data->timestamp = jiffies;
6567 data->rpc_status = 0;
6568 data->inode = nfs_igrab_and_active(inode);
6569 if (data->inode || issync) {
6570 data->lr.roc = pnfs_roc(inode, &data->lr.arg, &data->lr.res,
6572 if (data->lr.roc) {
6573 data->args.lr_args = &data->lr.arg;
6574 data->res.lr_res = &data->lr.res;
6578 if (!data->inode)
6579 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1,
6582 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1,
6584 task_setup_data.callback_data = data;
6585 msg.rpc_argp = &data->args;
6586 msg.rpc_resp = &data->res;
6595 status = data->rpc_status;
6754 static void nfs4_locku_release_calldata(void *data)
6756 struct nfs4_unlockdata *calldata = data;
6764 static void nfs4_locku_done(struct rpc_task *task, void *data)
6766 struct nfs4_unlockdata *calldata = data;
6809 static void nfs4_locku_prepare(struct rpc_task *task, void *data)
6811 struct nfs4_unlockdata *calldata = data;
6847 struct nfs4_unlockdata *data;
6870 data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
6871 if (data == NULL) {
6876 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1, 0);
6877 msg.rpc_argp = &data->arg;
6878 msg.rpc_resp = &data->res;
6879 task_setup_data.callback_data = data;
6985 struct nfs4_lockdata *data = calldata;
6986 struct nfs4_state *state = data->lsp->ls_state;
6989 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
6992 if (!test_bit(NFS_LOCK_INITIALIZED, &data->lsp->ls_flags)) {
6993 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) {
6996 nfs4_stateid_copy(&data->arg.open_stateid,
6998 data->arg.new_lock_owner = 1;
6999 data->res.open_seqid = data->arg.open_seqid;
7001 data->arg.new_lock_owner = 0;
7002 nfs4_stateid_copy(&data->arg.lock_stateid,
7003 &data->lsp->ls_stateid);
7006 data->rpc_status = -EBADF;
7010 data->timestamp = jiffies;
7011 if (nfs4_setup_sequence(data->server->nfs_client,
7012 &data->arg.seq_args,
7013 &data->res.seq_res,
7017 nfs_release_seqid(data->arg.open_seqid);
7019 nfs_release_seqid(data->arg.lock_seqid);
7021 nfs4_sequence_done(task, &data->res.seq_res);
7022 dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);
7027 struct nfs4_lockdata *data = calldata;
7028 struct nfs4_lock_state *lsp = data->lsp;
7029 struct nfs_server *server = NFS_SERVER(d_inode(data->ctx->dentry));
7033 if (!nfs4_sequence_done(task, &data->res.seq_res))
7036 data->rpc_status = task->tk_status;
7039 renew_lease(server, data->timestamp);
7040 if (data->arg.new_lock && !data->cancelled) {
7041 data->fl.fl_flags &= ~(FL_SLEEP | FL_ACCESS);
7042 if (locks_lock_inode_wait(lsp->ls_state->inode, &data->fl) < 0)
7045 if (data->arg.new_lock_owner != 0) {
7047 nfs4_stateid_copy(&lsp->ls_stateid, &data->res.stateid);
7049 } else if (!nfs4_update_lock_stateid(lsp, &data->res.stateid))
7053 if (data->arg.new_lock_owner != 0 &&
7054 nfs4_refresh_open_old_stateid(&data->arg.open_stateid,
7057 if (nfs4_refresh_lock_old_stateid(&data->arg.lock_stateid, lsp))
7063 if (data->arg.new_lock_owner != 0) {
7064 if (!nfs4_stateid_match(&data->arg.open_stateid,
7069 } else if (!nfs4_stateid_match(&data->arg.lock_stateid,
7074 dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);
7077 if (!data->cancelled)
7084 struct nfs4_lockdata *data = calldata;
7087 nfs_free_seqid(data->arg.open_seqid);
7088 if (data->cancelled && data->rpc_status == 0) {
7090 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
7091 data->arg.lock_seqid);
7096 nfs_free_seqid(data->arg.lock_seqid);
7097 nfs4_put_lock_state(data->lsp);
7098 put_nfs_open_context(data->ctx);
7099 kfree(data);
7128 struct nfs4_lockdata *data;
7144 data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
7147 if (data == NULL)
7150 data->arg.block = 1;
7151 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1,
7153 msg.rpc_argp = &data->arg;
7154 msg.rpc_resp = &data->res;
7155 task_setup_data.callback_data = data;
7158 data->arg.reclaim = NFS_LOCK_RECLAIM;
7160 data->arg.new_lock = 1;
7166 ret = data->rpc_status;
7168 nfs4_handle_setlk_error(data->server, data->lsp,
7169 data->arg.new_lock_owner, ret);
7171 data->cancelled = true;
7172 trace_nfs4_set_lock(fl, state, &data->res.stateid, cmd, ret);
7485 struct nfs_release_lockowner_data *data = calldata;
7486 struct nfs_server *server = data->server;
7487 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
7488 &data->res.seq_res, task);
7489 data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
7490 data->timestamp = jiffies;
7495 struct nfs_release_lockowner_data *data = calldata;
7496 struct nfs_server *server = data->server;
7498 nfs40_sequence_done(task, &data->res.seq_res);
7502 renew_lease(server, data->timestamp);
7518 struct nfs_release_lockowner_data *data = calldata;
7519 nfs4_free_lock_state(data->server, data->lsp);
7532 struct nfs_release_lockowner_data *data;
7540 data = kmalloc(sizeof(*data), GFP_NOFS);
7541 if (!data)
7543 data->lsp = lsp;
7544 data->server = server;
7545 data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
7546 data->args.lock_owner.id = lsp->ls_seqid.owner_id;
7547 data->args.lock_owner.s_dev = server->s_dev;
7549 msg.rpc_argp = &data->args;
7550 msg.rpc_resp = &data->res;
7551 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0);
7552 rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data);
8135 struct nfs4_call_sync_data data = {
8144 .callback_data = &data,
8307 if (memcmp(res.sessionid.data,
8308 clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) {
8344 struct rpc_bind_conn_calldata data = {
8349 nfs4_proc_bind_conn_to_session_callback, &data);
8486 static void nfs4_exchange_id_release(void *data)
8489 (struct nfs41_exchange_id_data *)data;
8571 memcpy(calldata->args.verifier.data, clp->cl_confirm.data,
8572 sizeof(calldata->args.verifier.data));
8655 memcpy(clp->cl_confirm.data, argp->verifier.data,
8656 sizeof(clp->cl_confirm.data));
8705 * @data: call data for _nfs4_proc_exchange_id.
8708 void *data)
8710 struct nfs4_add_xprt_data *adata = (struct nfs4_add_xprt_data *)data;
8811 struct nfs4_get_lease_time_data *data =
8817 nfs4_setup_sequence(data->clp,
8818 &data->args->la_seq_args,
8819 &data->res->lr_seq_res,
8830 struct nfs4_get_lease_time_data *data =
8834 if (!nfs4_sequence_done(task, &data->res->lr_seq_res))
8861 struct nfs4_get_lease_time_data data = {
8875 .callback_data = &data,
9075 ptr = (unsigned *)&session->sess_id.data[0];
9124 static void nfs41_sequence_release(void *data)
9126 struct nfs4_sequence_data *calldata = data;
9147 static void nfs41_sequence_call_done(struct rpc_task *task, void *data)
9149 struct nfs4_sequence_data *calldata = data;
9171 static void nfs41_sequence_prepare(struct rpc_task *task, void *data)
9173 struct nfs4_sequence_data *calldata = data;
9275 static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data)
9277 struct nfs4_reclaim_complete_data *calldata = data;
9312 static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data)
9314 struct nfs4_reclaim_complete_data *calldata = data;
9330 static void nfs4_free_reclaim_complete_data(void *data)
9332 struct nfs4_reclaim_complete_data *calldata = data;
9756 struct nfs4_layoutcommit_data *data = calldata;
9757 struct nfs_server *server = NFS_SERVER(data->args.inode);
9760 &data->args.seq_args,
9761 &data->res.seq_res,
9768 struct nfs4_layoutcommit_data *data = calldata;
9769 struct nfs_server *server = NFS_SERVER(data->args.inode);
9771 if (!nfs41_sequence_done(task, &data->res.seq_res))
9792 struct nfs4_layoutcommit_data *data = calldata;
9794 pnfs_cleanup_layoutcommit(data);
9795 nfs_post_op_update_inode_force_wcc(data->args.inode,
9796 data->res.fattr);
9797 put_cred(data->cred);
9798 nfs_iput_and_deactive(data->inode);
9799 kfree(data);
9809 nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)
9813 .rpc_argp = &data->args,
9814 .rpc_resp = &data->res,
9815 .rpc_cred = data->cred,
9818 .task = &data->task,
9819 .rpc_client = NFS_CLIENT(data->args.inode),
9822 .callback_data = data,
9829 data->args.lastbytewritten,
9830 data->args.inode->i_ino);
9833 data->inode = nfs_igrab_and_active(data->args.inode);
9834 if (data->inode == NULL) {
9835 nfs4_layoutcommit_release(data);
9840 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, 0);
9846 trace_nfs4_layoutcommit(data->args.inode, &data->args.stateid, status);
9872 struct nfs4_call_sync_data data = {
9881 .callback_data = &data,
10096 struct nfs_free_stateid_data *data = calldata;
10097 nfs4_setup_sequence(data->server->nfs_client,
10098 &data->args.seq_args,
10099 &data->res.seq_res,
10105 struct nfs_free_stateid_data *data = calldata;
10107 nfs41_sequence_done(task, &data->res.seq_res);
10111 if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN)
10152 struct nfs_free_stateid_data *data;
10159 data = kmalloc(sizeof(*data), GFP_NOFS);
10160 if (!data)
10162 data->server = server;
10163 nfs4_stateid_copy(&data->args.stateid, stateid);
10165 task_setup.callback_data = data;
10167 msg.rpc_argp = &data->args;
10168 msg.rpc_resp = &data->res;
10169 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, privileged);