Lines Matching full:server
100 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *…
117 struct nfs_server *server,
151 static inline u32 *nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label) in nfs4_bitmask() argument
154 return server->attr_bitmask; in nfs4_bitmask()
156 return server->attr_bitmask_nl; in nfs4_bitmask()
167 nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label) in nfs4_bitmask() argument
168 { return server->attr_bitmask; } in nfs4_bitmask()
341 * when talking to the server, we always send cookie 0 in nfs4_setup_readdir()
385 static void nfs4_test_and_free_stateid(struct nfs_server *server, in nfs4_test_and_free_stateid() argument
389 const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops; in nfs4_test_and_free_stateid()
391 ops->test_and_free_expired(server, stateid, cred); in nfs4_test_and_free_stateid()
394 static void __nfs4_free_revoked_stateid(struct nfs_server *server, in __nfs4_free_revoked_stateid() argument
399 nfs4_test_and_free_stateid(server, stateid, cred); in __nfs4_free_revoked_stateid()
402 static void nfs4_free_revoked_stateid(struct nfs_server *server, in nfs4_free_revoked_stateid() argument
409 __nfs4_free_revoked_stateid(server, &tmp, cred); in nfs4_free_revoked_stateid()
473 static int nfs4_do_handle_exception(struct nfs_server *server, in nfs4_do_handle_exception() argument
476 struct nfs_client *clp = server->nfs_client; in nfs4_do_handle_exception()
524 ret = nfs4_schedule_stateid_recovery(server, state); in nfs4_do_handle_exception()
533 ret = nfs4_schedule_migration_recovery(server); in nfs4_do_handle_exception()
561 nfs_inc_server_stats(server, NFSIOS_DELAY); in nfs4_do_handle_exception()
574 /* The following works around a Linux server bug! */ in nfs4_do_handle_exception()
576 if (server->caps & NFS_CAP_UIDGID_NOMAP) { in nfs4_do_handle_exception()
577 server->caps &= ~NFS_CAP_UIDGID_NOMAP; in nfs4_do_handle_exception()
579 printk(KERN_WARNING "NFS: v4 server %s " in nfs4_do_handle_exception()
583 server->nfs_client->cl_hostname); in nfs4_do_handle_exception()
596 int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exceptio… in nfs4_handle_exception() argument
598 struct nfs_client *clp = server->nfs_client; in nfs4_handle_exception()
601 ret = nfs4_do_handle_exception(server, errorcode, exception); in nfs4_handle_exception()
611 if (test_bit(NFS_MIG_FAILED, &server->mig_status)) in nfs4_handle_exception()
623 nfs4_async_handle_exception(struct rpc_task *task, struct nfs_server *server, in nfs4_async_handle_exception() argument
626 struct nfs_client *clp = server->nfs_client; in nfs4_async_handle_exception()
629 ret = nfs4_do_handle_exception(server, errorcode, exception); in nfs4_async_handle_exception()
642 if (test_bit(NFS_MIG_FAILED, &server->mig_status)) in nfs4_async_handle_exception()
659 nfs4_async_handle_error(struct rpc_task *task, struct nfs_server *server, in nfs4_async_handle_error() argument
670 task->tk_status = nfs4_async_handle_exception(task, server, in nfs4_async_handle_error()
698 static void renew_lease(const struct nfs_server *server, unsigned long timestamp) in renew_lease() argument
700 struct nfs_client *clp = server->nfs_client; in renew_lease()
764 /* Be nice to the server: try to ensure that the last transmitted in nfs41_release_slot()
852 * The server may or may not have processed the sequence in nfs41_sequence_process()
859 /* The server detected a resend of the RPC call and in nfs41_sequence_process()
871 * The server thinks we tried to replay a request. in nfs41_sequence_process()
888 * If the server never received the request, then our in nfs41_sequence_process()
890 * if the server did receive the request then it might in nfs41_sequence_process()
893 * to the server on the same slot. in nfs41_sequence_process()
1143 struct nfs_server *server, in nfs4_do_call_sync() argument
1149 struct nfs_client *clp = server->nfs_client; in nfs4_do_call_sync()
1151 .seq_server = server, in nfs4_do_call_sync()
1167 struct nfs_server *server, in nfs4_call_sync_sequence() argument
1172 return nfs4_do_call_sync(clnt, server, msg, args, res, 0); in nfs4_call_sync_sequence()
1177 struct nfs_server *server, in nfs4_call_sync() argument
1184 return nfs4_call_sync_sequence(clnt, server, msg, args, res); in nfs4_call_sync()
1254 static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server, in nfs4_clear_cap_atomic_open_v1() argument
1259 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1)) in nfs4_clear_cap_atomic_open_v1()
1261 server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1; in nfs4_clear_cap_atomic_open_v1()
1279 nfs4_map_atomic_open_share(struct nfs_server *server, in nfs4_map_atomic_open_share() argument
1294 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1)) in nfs4_map_atomic_open_share()
1304 nfs4_map_atomic_open_claim(struct nfs_server *server, in nfs4_map_atomic_open_claim() argument
1307 if (server->caps & NFS_CAP_ATOMIC_OPEN_V1) in nfs4_map_atomic_open_claim()
1327 p->o_res.server = p->o_arg.server; in nfs4_init_opendata_res()
1341 struct nfs_server *server = NFS_SERVER(dir); in nfs4_opendata_alloc() local
1350 p->f_label = nfs4_label_alloc(server, gfp_mask); in nfs4_opendata_alloc()
1354 p->a_label = nfs4_label_alloc(server, gfp_mask); in nfs4_opendata_alloc()
1358 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid; in nfs4_opendata_alloc()
1369 p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim); in nfs4_opendata_alloc()
1370 p->o_arg.share_access = nfs4_map_atomic_open_share(server, in nfs4_opendata_alloc()
1386 /* ask server to check for all possible rights as results in nfs4_opendata_alloc()
1398 if (server->caps & NFS_CAP_XATTR) in nfs4_opendata_alloc()
1405 p->o_arg.clientid = server->nfs_client->cl_clientid; in nfs4_opendata_alloc()
1409 p->o_arg.server = server; in nfs4_opendata_alloc()
1410 p->o_arg.bitmask = nfs4_bitmask(server, label); in nfs4_opendata_alloc()
1593 * Note: This function relies heavily on the server implementing
1609 /* The server returned a new stateid */ in nfs_stateid_is_sequential()
1699 * in which the server processed them by delaying the in nfs_set_open_stateid_locked()
1793 struct nfs_server *server = NFS_SERVER(state->inode); in update_open_stateid() local
1794 struct nfs_client *clp = server->nfs_client; in update_open_stateid()
1838 nfs4_test_and_free_stateid(server, &freeme, in update_open_stateid()
1940 pr_err_ratelimited("NFS: Broken NFSv4 server %s is " in nfs4_opendata_check_deleg()
2131 struct nfs_server *server = NFS_SB(opendata->dentry->d_sb); in nfs4_open_recover_helper() local
2139 nfs4_map_atomic_open_share(server, fmode, openflags); in nfs4_open_recover_helper()
2186 * reclaim state on the server after a reboot.
2212 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_do_open_reclaim() local
2218 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception)) in nfs4_do_open_reclaim()
2222 nfs4_handle_exception(server, err, &exception); in nfs4_do_open_reclaim()
2242 static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct nfs4_state *state,… in nfs4_handle_delegation_recall_error() argument
2263 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_handle_delegation_recall_error()
2266 nfs4_schedule_migration_recovery(server); in nfs4_handle_delegation_recall_error()
2269 nfs4_schedule_lease_moved_recovery(server->nfs_client); in nfs4_handle_delegation_recall_error()
2278 nfs4_schedule_stateid_recovery(server, state); in nfs4_handle_delegation_recall_error()
2299 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_open_delegation_recall() local
2326 return nfs4_handle_delegation_recall_error(server, state, stateid, NULL, err); in nfs4_open_delegation_recall()
2333 nfs4_setup_sequence(data->o_arg.server->nfs_client, in nfs4_open_confirm_prepare()
2347 renew_lease(data->o_res.server, data->timestamp); in nfs4_open_confirm_done()
2381 struct nfs_server *server = NFS_SERVER(d_inode(data->dir)); in _nfs4_proc_open_confirm() local
2390 .rpc_client = server->client, in _nfs4_proc_open_confirm()
2457 if (nfs4_setup_sequence(data->o_arg.server->nfs_client, in nfs4_open_prepare()
2506 renew_lease(data->o_res.server, data->timestamp); in nfs4_open_done()
2544 struct nfs_server *server = NFS_SERVER(dir); in nfs4_run_open_task() local
2555 .rpc_client = server->client, in nfs4_run_open_task()
2625 /* access call failed or for some reason the server doesn't in nfs4_opendata_access()
2662 struct nfs_server *server = NFS_SERVER(dir); in _nfs4_proc_open() local
2677 nfs_fattr_map_and_free_names(server, &data->f_attr); in _nfs4_proc_open()
2691 server->caps &= ~NFS_CAP_POSIX_LOCK; in _nfs4_proc_open()
2699 nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr, in _nfs4_proc_open()
2707 * reclaim state on the server after a network partition.
2733 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_do_open_expired() local
2740 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception)) in nfs4_do_open_expired()
2747 nfs4_handle_exception(server, err, &exception); in nfs4_do_open_expired()
2789 static int nfs40_test_and_free_expired_stateid(struct nfs_server *server, in nfs40_test_and_free_expired_stateid() argument
2797 static int nfs41_test_and_free_expired_stateid(struct nfs_server *server, in nfs41_test_and_free_expired_stateid() argument
2813 status = nfs41_test_stateid(server, stateid, cred); in nfs41_test_and_free_expired_stateid()
2823 /* Ack the revoked state to the server */ in nfs41_test_and_free_expired_stateid()
2824 nfs41_free_stateid(server, stateid, cred, true); in nfs41_test_and_free_expired_stateid()
2830 struct nfs_server *server = NFS_SERVER(state->inode); in nfs41_check_delegation_stateid() local
2859 status = nfs41_test_and_free_expired_stateid(server, &stateid, cred); in nfs41_check_delegation_stateid()
2895 struct nfs_server *server = NFS_SERVER(state->inode); in nfs41_check_expired_locks() local
2911 status = nfs41_test_and_free_expired_stateid(server, in nfs41_check_expired_locks()
2945 struct nfs_server *server = NFS_SERVER(state->inode); in nfs41_check_open_stateid() local
2952 status = nfs41_test_and_free_expired_stateid(server, stateid, cred); in nfs41_check_open_stateid()
2984 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
2991 const __u32 *bitmask = opendata->o_arg.server->exclcreat_bitmask; in nfs4_exclusive_attrset()
3028 struct nfs_server *server = sp->so_server; in _nfs4_open_and_get_state() local
3049 if (server->caps & NFS_CAP_POSIX_LOCK) in _nfs4_open_and_get_state()
3092 nfs4_schedule_stateid_recovery(server, state); in _nfs4_open_and_get_state()
3117 struct nfs_server *server = NFS_SERVER(dir); in _nfs4_do_open() local
3131 sp = nfs4_get_state_owner(server, cred, GFP_KERNEL); in _nfs4_do_open()
3136 status = nfs4_client_recover_expired_lease(server->nfs_client); in _nfs4_do_open()
3150 olabel = nfs4_label_alloc(server, GFP_KERNEL); in _nfs4_do_open()
3157 if (server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) { in _nfs4_do_open()
3199 if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server)) { in _nfs4_do_open()
3227 struct nfs_server *server = NFS_SERVER(dir); in nfs4_do_open() local
3248 /* NOTE: BAD_SEQID means the server and client disagree about the in nfs4_do_open()
3251 * It is actually a sign of a bug on the client or on the server. in nfs4_do_open()
3260 pr_warn_ratelimited("NFS: v4 server %s " in nfs4_do_open()
3267 * BAD_STATEID on OPEN means that the server cancelled our in nfs4_do_open()
3277 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_do_open()
3286 if (nfs4_clear_cap_atomic_open_v1(server, status, &exception)) in nfs4_do_open()
3288 res = ERR_PTR(nfs4_handle_exception(server, in nfs4_do_open()
3300 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_do_setattr() local
3344 status = nfs4_call_sync(server->client, server, &msg, &arg->seq_args, &res->seq_res, 1); in _nfs4_do_setattr()
3348 renew_lease(server, timestamp); in _nfs4_do_setattr()
3358 struct nfs_server *server = NFS_SERVER(inode); in nfs4_do_setattr() local
3364 .server = server, in nfs4_do_setattr()
3371 .server = server, in nfs4_do_setattr()
3382 nfs4_bitmask(server, olabel), in nfs4_do_setattr()
3389 pr_warn_once("NFSv4: server %s is incorrectly " in nfs4_do_setattr()
3393 server->nfs_client->cl_hostname); in nfs4_do_setattr()
3402 err = nfs4_handle_exception(server, err, &exception); in nfs4_do_setattr()
3485 /* server says we're behind but we haven't seen the update yet */ in nfs4_refresh_open_old_stateid()
3549 struct nfs_server *server = NFS_SERVER(calldata->inode); in nfs4_close_done() local
3573 renew_lease(server, calldata->timestamp); in nfs4_close_done()
3592 nfs4_free_revoked_stateid(server, in nfs4_close_done()
3602 server, task->tk_status, &exception); in nfs4_close_done()
3625 struct nfs_server *server = NFS_SERVER(inode); in nfs4_close_prepare() local
3683 server->cache_consistency_bitmask, in nfs4_close_prepare()
3684 inode, server, NULL); in nfs4_close_prepare()
3723 * NFSv4 citizens - we do not indicate to the server to update the file's
3731 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_do_close() local
3741 .rpc_client = server->client, in nfs4_do_close()
3749 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP, in nfs4_do_close()
3762 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid; in nfs4_do_close()
3771 calldata->res.server = server; in nfs4_do_close()
3833 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) in _nfs4_server_capabilities() argument
3835 u32 bitmask[3] = {}, minorversion = server->nfs_client->cl_minorversion; in _nfs4_server_capabilities()
3857 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_server_capabilities()
3859 /* Sanity check the server answers */ in _nfs4_server_capabilities()
3871 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask)); in _nfs4_server_capabilities()
3872 server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS| in _nfs4_server_capabilities()
3880 server->caps |= NFS_CAP_ACLS; in _nfs4_server_capabilities()
3882 server->caps |= NFS_CAP_HARDLINKS; in _nfs4_server_capabilities()
3884 server->caps |= NFS_CAP_SYMLINKS; in _nfs4_server_capabilities()
3886 server->caps |= NFS_CAP_FILEID; in _nfs4_server_capabilities()
3888 server->caps |= NFS_CAP_MODE; in _nfs4_server_capabilities()
3890 server->caps |= NFS_CAP_NLINK; in _nfs4_server_capabilities()
3892 server->caps |= NFS_CAP_OWNER; in _nfs4_server_capabilities()
3894 server->caps |= NFS_CAP_OWNER_GROUP; in _nfs4_server_capabilities()
3896 server->caps |= NFS_CAP_ATIME; in _nfs4_server_capabilities()
3898 server->caps |= NFS_CAP_CTIME; in _nfs4_server_capabilities()
3900 server->caps |= NFS_CAP_MTIME; in _nfs4_server_capabilities()
3903 server->caps |= NFS_CAP_SECURITY_LABEL; in _nfs4_server_capabilities()
3905 memcpy(server->attr_bitmask_nl, res.attr_bitmask, in _nfs4_server_capabilities()
3906 sizeof(server->attr_bitmask)); in _nfs4_server_capabilities()
3907 server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL; in _nfs4_server_capabilities()
3909 …memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitma… in _nfs4_server_capabilities()
3910 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE; in _nfs4_server_capabilities()
3911 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY; in _nfs4_server_capabilities()
3912 server->cache_consistency_bitmask[2] = 0; in _nfs4_server_capabilities()
3914 /* Avoid a regression due to buggy server */ in _nfs4_server_capabilities()
3917 memcpy(server->exclcreat_bitmask, res.exclcreat_bitmask, in _nfs4_server_capabilities()
3918 sizeof(server->exclcreat_bitmask)); in _nfs4_server_capabilities()
3920 server->acl_bitmask = res.acl_bitmask; in _nfs4_server_capabilities()
3921 server->fh_expire_type = res.fh_expire_type; in _nfs4_server_capabilities()
3927 int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) in nfs4_server_capabilities() argument
3934 err = nfs4_handle_exception(server, in nfs4_server_capabilities()
3935 _nfs4_server_capabilities(server, fhandle), in nfs4_server_capabilities()
3941 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, in _nfs4_lookup_root() argument
3949 .server = server, in _nfs4_lookup_root()
3967 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_lookup_root()
3970 static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, in nfs4_lookup_root() argument
3978 err = _nfs4_lookup_root(server, fhandle, info); in nfs4_lookup_root()
3979 trace_nfs4_lookup_root(server, fhandle, info->fattr, err); in nfs4_lookup_root()
3985 err = nfs4_handle_exception(server, err, &exception); in nfs4_lookup_root()
3992 static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle, in nfs4_lookup_root_sec() argument
4000 auth = rpcauth_create(&auth_args, server->client); in nfs4_lookup_root_sec()
4003 return nfs4_lookup_root(server, fhandle, info); in nfs4_lookup_root_sec()
4010 * NFSv4.1: the server does not support the SECINFO_NO_NAME operation
4015 static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle, in nfs4_find_root_sec() argument
4029 if (server->auth_info.flavor_len > 0) { in nfs4_find_root_sec()
4031 for (i = 0; i < server->auth_info.flavor_len; i++) { in nfs4_find_root_sec()
4032 status = nfs4_lookup_root_sec(server, fhandle, info, in nfs4_find_root_sec()
4033 server->auth_info.flavors[i]); in nfs4_find_root_sec()
4041 status = nfs4_lookup_root_sec(server, fhandle, info, in nfs4_find_root_sec()
4062 * nfs4_proc_get_rootfh - get file handle for server's pseudoroot
4063 * @server: initialized nfs_server handle
4070 int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle, in nfs4_proc_get_rootfh() argument
4077 status = nfs4_lookup_root(server, fhandle, info); in nfs4_proc_get_rootfh()
4080 status = server->nfs_client->cl_mvops->find_root_sec(server, in nfs4_proc_get_rootfh()
4084 status = nfs4_server_capabilities(server, fhandle); in nfs4_proc_get_rootfh()
4086 status = nfs4_do_fsinfo(server, fhandle, info); in nfs4_proc_get_rootfh()
4091 static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh, in nfs4_proc_get_root() argument
4098 error = nfs4_server_capabilities(server, mntfh); in nfs4_proc_get_root()
4104 error = nfs4_proc_getattr(server, mntfh, fattr, label, NULL); in nfs4_proc_get_root()
4111 !nfs_fsid_equal(&server->fsid, &fattr->fsid)) in nfs4_proc_get_root()
4112 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid)); in nfs4_proc_get_root()
4148 dprintk("%s: server did not return a different fsid for" in nfs4_get_referral()
4166 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, in _nfs4_proc_getattr() argument
4178 .server = server, in _nfs4_proc_getattr()
4188 if (inode && (server->flags & NFS_MOUNT_SOFTREVAL)) in _nfs4_proc_getattr()
4191 nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, label), inode); in _nfs4_proc_getattr()
4195 return nfs4_do_call_sync(server->client, server, &msg, in _nfs4_proc_getattr()
4199 int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, in nfs4_proc_getattr() argument
4208 err = _nfs4_proc_getattr(server, fhandle, fattr, label, inode); in nfs4_proc_getattr()
4209 trace_nfs4_getattr(server, fhandle, fattr, err); in nfs4_proc_getattr()
4210 err = nfs4_handle_exception(server, err, in nfs4_proc_getattr()
4287 struct nfs_server *server = NFS_SERVER(dir); in _nfs4_proc_lookup() local
4290 .bitmask = server->attr_bitmask, in _nfs4_proc_lookup()
4295 .server = server, in _nfs4_proc_lookup()
4311 args.bitmask = nfs4_bitmask(server, label); in _nfs4_proc_lookup()
4317 status = nfs4_do_call_sync(clnt, server, &msg, in _nfs4_proc_lookup()
4410 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_proc_lookupp() local
4413 .bitmask = server->attr_bitmask, in _nfs4_proc_lookupp()
4417 .server = server, in _nfs4_proc_lookupp()
4428 args.bitmask = nfs4_bitmask(server, label); in _nfs4_proc_lookupp()
4433 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, in _nfs4_proc_lookupp()
4457 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_proc_access() local
4463 .server = server, in _nfs4_proc_access()
4477 args.bitmask = server->cache_consistency_bitmask; in _nfs4_proc_access()
4479 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_access()
4568 struct nfs_server *server = NFS_SERVER(dir); in nfs4_proc_create() local
4580 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK)) in nfs4_proc_create()
4596 struct nfs_server *server = NFS_SERVER(dir); in _nfs4_proc_remove() local
4602 .server = server, in _nfs4_proc_remove()
4612 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1); in _nfs4_proc_remove()
4671 res->server = NFS_SB(dentry->d_sb); in nfs4_proc_unlink_setup()
4696 if (nfs4_async_handle_error(task, res->server, NULL, in nfs4_proc_unlink_done()
4720 res->server = NFS_SB(old_dentry->d_sb); in nfs4_proc_rename_setup()
4740 if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN) in nfs4_proc_rename_done()
4764 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_proc_link() local
4773 .server = server, in _nfs4_proc_link()
4787 res.label = nfs4_label_alloc(server, GFP_KERNEL); in _nfs4_proc_link()
4794 nfs4_bitmap_copy_adjust_setattr(bitmask, nfs4_bitmask(server, res.label), inode); in _nfs4_proc_link()
4796 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in _nfs4_proc_link()
4843 struct nfs_server *server = NFS_SERVER(dir); in nfs4_alloc_createdata() local
4845 data->label = nfs4_label_alloc(server, GFP_KERNEL); in nfs4_alloc_createdata()
4853 data->arg.server = server; in nfs4_alloc_createdata()
4857 data->arg.bitmask = nfs4_bitmask(server, data->label); in nfs4_alloc_createdata()
4859 data->res.server = server; in nfs4_alloc_createdata()
4965 struct nfs_server *server = NFS_SERVER(dir); in nfs4_proc_mkdir() local
4974 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK)) in nfs4_proc_mkdir()
4991 struct nfs_server *server = NFS_SERVER(dir); in _nfs4_proc_readdir() local
5011 if (!(server->caps & NFS_CAP_SECURITY_LABEL)) in _nfs4_proc_readdir()
5012 args.bitmask = server->attr_bitmask_nl; in _nfs4_proc_readdir()
5014 args.bitmask = server->attr_bitmask; in _nfs4_proc_readdir()
5018 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, in _nfs4_proc_readdir()
5086 struct nfs_server *server = NFS_SERVER(dir); in nfs4_proc_mknod() local
5095 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK)) in nfs4_proc_mknod()
5109 static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, in _nfs4_proc_statfs() argument
5114 .bitmask = server->attr_bitmask, in _nfs4_proc_statfs()
5126 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_statfs()
5129 static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *f… in nfs4_proc_statfs() argument
5136 err = nfs4_handle_exception(server, in nfs4_proc_statfs()
5137 _nfs4_proc_statfs(server, fhandle, fsstat), in nfs4_proc_statfs()
5143 static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, in _nfs4_do_fsinfo() argument
5148 .bitmask = server->attr_bitmask, in _nfs4_do_fsinfo()
5159 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_do_fsinfo()
5162 static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsi… in nfs4_do_fsinfo() argument
5170 err = _nfs4_do_fsinfo(server, fhandle, fsinfo); in nfs4_do_fsinfo()
5171 trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err); in nfs4_do_fsinfo()
5173 nfs4_set_lease_period(server->nfs_client, fsinfo->lease_time * HZ); in nfs4_do_fsinfo()
5176 err = nfs4_handle_exception(server, err, &exception); in nfs4_do_fsinfo()
5181 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *f… in nfs4_proc_fsinfo() argument
5186 error = nfs4_do_fsinfo(server, fhandle, fsinfo); in nfs4_proc_fsinfo()
5189 server->pnfs_blksize = fsinfo->blksize; in nfs4_proc_fsinfo()
5190 set_pnfs_layoutdriver(server, fhandle, fsinfo); in nfs4_proc_fsinfo()
5196 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, in _nfs4_proc_pathconf() argument
5201 .bitmask = server->attr_bitmask, in _nfs4_proc_pathconf()
5219 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_pathconf()
5222 static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, in nfs4_proc_pathconf() argument
5231 err = nfs4_handle_exception(server, in nfs4_proc_pathconf()
5232 _nfs4_proc_pathconf(server, fhandle, pathconf), in nfs4_proc_pathconf()
5277 struct nfs_server *server = NFS_SERVER(hdr->inode); in nfs4_read_done_cb() local
5287 server, task->tk_status, &exception); in nfs4_read_done_cb()
5295 renew_lease(server, hdr->timestamp); in nfs4_read_done_cb()
5316 struct nfs_server *server = NFS_SERVER(hdr->inode); in nfs4_read_plus_not_supported() local
5320 server->caps & NFS_CAP_READ_PLUS && task->tk_status == -ENOTSUPP) { in nfs4_read_plus_not_supported()
5321 server->caps &= ~NFS_CAP_READ_PLUS; in nfs4_read_plus_not_supported()
5346 static void nfs42_read_plus_support(struct nfs_server *server, struct rpc_message *msg) in nfs42_read_plus_support() argument
5348 if (server->caps & NFS_CAP_READ_PLUS) in nfs42_read_plus_support()
5354 static void nfs42_read_plus_support(struct nfs_server *server, struct rpc_message *msg) in nfs42_read_plus_support() argument
5451 struct inode *inode, struct nfs_server *server, in nfs4_bitmask_set() argument
5484 bitmask[i] &= server->attr_bitmask[i]; in nfs4_bitmask_set()
5491 struct nfs_server *server = NFS_SERVER(hdr->inode); in nfs4_proc_write_setup() local
5498 server->cache_consistency_bitmask, in nfs4_proc_write_setup()
5499 hdr->inode, server, NULL); in nfs4_proc_write_setup()
5505 hdr->res.server = server; in nfs4_proc_write_setup()
5510 nfs4_state_protect_write(server->nfs_client, clnt, msg, hdr); in nfs4_proc_write_setup()
5544 struct nfs_server *server = NFS_SERVER(data->inode); in nfs4_proc_commit_setup() local
5548 data->res.server = server; in nfs4_proc_commit_setup()
5551 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_COMMIT, clnt, msg); in nfs4_proc_commit_setup()
5558 struct nfs_server *server = NFS_SERVER(dst_inode); in _nfs4_proc_commit() local
5566 return nfs4_call_sync(server->client, server, &msg, in _nfs4_proc_commit()
5680 static inline int nfs4_server_supports_acls(struct nfs_server *server) in nfs4_server_supports_acls() argument
5682 return server->caps & NFS_CAP_ACLS; in nfs4_server_supports_acls()
5791 * the required buf. On a NULL buf, we send a page of data to the server
5796 * the server, this time with the input buf of the required size.
5815 struct nfs_server *server = NFS_SERVER(inode); in __nfs4_get_acl_uncached() local
5818 buflen = server->rsize; in __nfs4_get_acl_uncached()
5893 struct nfs_server *server = NFS_SERVER(inode); in nfs4_proc_get_acl() local
5896 if (!nfs4_server_supports_acls(server)) in nfs4_proc_get_acl()
5898 ret = nfs_revalidate_inode(server, inode); in nfs4_proc_get_acl()
5913 struct nfs_server *server = NFS_SERVER(inode); in __nfs4_proc_set_acl() local
5932 if (!nfs4_server_supports_acls(server)) in __nfs4_proc_set_acl()
5940 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in __nfs4_proc_set_acl()
5988 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_get_security_label() local
6000 .server = server, in _nfs4_get_security_label()
6011 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0); in _nfs4_get_security_label()
6046 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_do_set_security_label() local
6051 .server = server, in _nfs4_do_set_security_label()
6058 .server = server, in _nfs4_do_set_security_label()
6069 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in _nfs4_do_set_security_label()
6434 renew_lease(data->res.server, data->timestamp); in nfs4_delegreturn_done()
6439 nfs4_free_revoked_stateid(data->res.server, in nfs4_delegreturn_done()
6465 data->res.server, task->tk_status, in nfs4_delegreturn_done()
6513 nfs4_setup_sequence(d_data->res.server->nfs_client, in nfs4_delegreturn_prepare()
6528 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_proc_delegreturn() local
6535 .rpc_client = server->client, in _nfs4_proc_delegreturn()
6546 nfs4_state_protect(server->nfs_client, in _nfs4_proc_delegreturn()
6553 server->cache_consistency_bitmask, inode, server, in _nfs4_proc_delegreturn()
6559 data->res.server = server; in _nfs4_proc_delegreturn()
6600 struct nfs_server *server = NFS_SERVER(inode); in nfs4_proc_delegreturn() local
6612 err = nfs4_handle_exception(server, err, &exception); in nfs4_proc_delegreturn()
6620 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_proc_getlk() local
6621 struct nfs_client *clp = server->nfs_client; in _nfs4_proc_getlk()
6644 arg.lock_owner.s_dev = server->s_dev; in _nfs4_proc_getlk()
6645 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in _nfs4_proc_getlk()
6718 struct nfs_server *server; member
6744 p->server = NFS_SERVER(inode); in nfs4_alloc_unlockdata()
6773 renew_lease(calldata->server, calldata->timestamp); in nfs4_locku_done()
6781 nfs4_free_revoked_stateid(calldata->server, in nfs4_locku_done()
6798 calldata->server, task->tk_status, in nfs4_locku_done()
6821 if (nfs4_setup_sequence(calldata->server->nfs_client, in nfs4_locku_prepare()
6938 struct nfs_server *server; member
6947 struct nfs_server *server = NFS_SERVER(inode); in nfs4_alloc_lockdata() local
6959 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid; in nfs4_alloc_lockdata()
6963 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid; in nfs4_alloc_lockdata()
6965 p->arg.lock_owner.s_dev = server->s_dev; in nfs4_alloc_lockdata()
6968 p->server = server; in nfs4_alloc_lockdata()
7008 if (nfs4_setup_sequence(data->server->nfs_client, in nfs4_lock_prepare()
7026 struct nfs_server *server = NFS_SERVER(d_inode(data->ctx->dentry)); in nfs4_lock_done() local
7036 renew_lease(server, data->timestamp); in nfs4_lock_done()
7057 else if (nfs4_async_handle_error(task, server, lsp->ls_state, NULL) == -EAGAIN) in nfs4_lock_done()
7099 static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new… in nfs4_handle_setlk_error() argument
7108 nfs4_schedule_stateid_recovery(server, lsp->ls_state); in nfs4_handle_setlk_error()
7112 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_handle_setlk_error()
7158 nfs4_handle_setlk_error(data->server, data->lsp, in _nfs4_do_setlk()
7170 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_lock_reclaim() local
7183 nfs4_handle_exception(server, err, &exception); in nfs4_lock_reclaim()
7190 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_lock_expired() local
7212 nfs4_handle_exception(server, err, &exception); in nfs4_lock_expired()
7350 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_retry_setlk() local
7351 struct nfs_client *clp = server->nfs_client; in nfs4_retry_setlk()
7355 .s_dev = server->s_dev }; in nfs4_retry_setlk()
7450 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_lock_delegation_recall() local
7462 return nfs4_handle_delegation_recall_error(server, state, stateid, fl, err); in nfs4_lock_delegation_recall()
7467 struct nfs_server *server; member
7476 struct nfs_server *server = data->server; in nfs4_release_lockowner_prepare() local
7477 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args, in nfs4_release_lockowner_prepare()
7479 data->args.lock_owner.clientid = server->nfs_client->cl_clientid; in nfs4_release_lockowner_prepare()
7486 struct nfs_server *server = data->server; in nfs4_release_lockowner_done() local
7492 renew_lease(server, data->timestamp); in nfs4_release_lockowner_done()
7496 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_release_lockowner_done()
7500 if (nfs4_async_handle_error(task, server, in nfs4_release_lockowner_done()
7509 nfs4_free_lock_state(data->server, data->lsp); in nfs4_release_lockowner_release()
7520 nfs4_release_lockowner(struct nfs_server *server, struct nfs4_lock_state *lsp) in nfs4_release_lockowner() argument
7527 if (server->nfs_client->cl_mvops->minor_version != 0) in nfs4_release_lockowner()
7534 data->server = server; in nfs4_release_lockowner()
7535 data->args.lock_owner.clientid = server->nfs_client->cl_clientid; in nfs4_release_lockowner()
7537 data->args.lock_owner.s_dev = server->s_dev; in nfs4_release_lockowner()
7542 rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data); in nfs4_release_lockowner()
7635 * Just in case the server has other ideas (which RFC 8276 allows), in nfs4_xattr_set_nfs4_user()
7767 struct nfs_server *server = NFS_SERVER(dir); in _nfs4_proc_fs_locations() local
7798 fs_locations->server = server; in _nfs4_proc_fs_locations()
7800 status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_fs_locations()
7825 * This operation also signals the server that this client is
7826 * performing migration recovery. The server can stop returning
7835 struct nfs_server *server = NFS_SERVER(inode); in _nfs40_proc_get_locations() local
7836 struct rpc_clnt *clnt = server->client; in _nfs40_proc_get_locations()
7841 .clientid = server->nfs_client->cl_clientid, in _nfs40_proc_get_locations()
7863 locations->server = server; in _nfs40_proc_get_locations()
7867 status = nfs4_call_sync_sequence(clnt, server, &msg, in _nfs40_proc_get_locations()
7872 renew_lease(server, now); in _nfs40_proc_get_locations()
7879 * This operation also signals the server that this client is
7880 * performing migration recovery. The server can stop asserting
7892 struct nfs_server *server = NFS_SERVER(inode); in _nfs41_proc_get_locations() local
7893 struct rpc_clnt *clnt = server->client; in _nfs41_proc_get_locations()
7916 locations->server = server; in _nfs41_proc_get_locations()
7920 status = nfs4_call_sync_sequence(clnt, server, &msg, in _nfs41_proc_get_locations()
7940 * On success, "locations" is filled in, but if the server has
7944 * -NFS4ERR_LEASE_MOVED is returned if the server still has leases
7951 struct nfs_server *server = NFS_SERVER(inode); in nfs4_proc_get_locations() local
7952 struct nfs_client *clp = server->nfs_client; in nfs4_proc_get_locations()
7961 (unsigned long long)server->fsid.major, in nfs4_proc_get_locations()
7962 (unsigned long long)server->fsid.minor, in nfs4_proc_get_locations()
7970 nfs4_handle_exception(server, status, &exception); in nfs4_proc_get_locations()
7976 * This operation also signals the server that this client is
7977 * performing "lease moved" recovery. The server can stop
7984 struct nfs_server *server = NFS_SERVER(inode); in _nfs40_proc_fsid_present() local
7986 struct rpc_clnt *clnt = server->client; in _nfs40_proc_fsid_present()
8009 status = nfs4_call_sync_sequence(clnt, server, &msg, in _nfs40_proc_fsid_present()
8022 * This operation also signals the server that this client is
8023 * performing "lease moved" recovery. The server can stop asserting
8030 struct nfs_server *server = NFS_SERVER(inode); in _nfs41_proc_fsid_present() local
8031 struct rpc_clnt *clnt = server->client; in _nfs41_proc_fsid_present()
8050 status = nfs4_call_sync_sequence(clnt, server, &msg, in _nfs41_proc_fsid_present()
8062 * nfs4_proc_fsid_present - Is this FSID present or absent on server?
8066 * Server indicates whether the FSID is present, moved, or not
8070 * Returns NFS4_OK if the FSID is present on this server,
8072 * NFS4ERR code if some error occurred on the server, or a
8077 struct nfs_server *server = NFS_SERVER(inode); in nfs4_proc_fsid_present() local
8078 struct nfs_client *clp = server->nfs_client; in nfs4_proc_fsid_present()
8087 (unsigned long long)server->fsid.major, in nfs4_proc_fsid_present()
8088 (unsigned long long)server->fsid.minor, in nfs4_proc_fsid_present()
8096 nfs4_handle_exception(server, status, &exception); in nfs4_proc_fsid_present()
8191 * Check the exchange flags returned by the server for invalid flags, having
8303 dprintk("NFS: %s: Unexpected direction from server\n", in nfs4_proc_bind_one_conn_to_session()
8308 dprintk("NFS: %s: Server returned RDMA mode = true\n", in nfs4_proc_bind_one_conn_to_session()
8371 * Select the state protection mode for client `clp' given the server results
8392 dfprintk(MOUNT, "Server SP4_MACH_CRED support:\n"); in nfs4_sp4_select_mode()
8742 dprintk("NFS: Got error %d from the server %s on " in _nfs4_proc_destroy_clientid()
8934 * So, no point even trying to continue if the server won't in nfs4_verify_fore_channel_attrs()
9043 * Issues a CREATE_SESSION operation to the server.
9098 dprintk("NFS: Got error %d from the server on DESTROY_SESSION. " in nfs4_proc_destroy_session()
9289 dprintk("%s: failed to reclaim complete error %d for server %s, retrying\n", in nfs41_reclaim_complete_handle_errors()
9373 struct nfs_server *server = NFS_SERVER(lgp->args.inode); in nfs4_layoutget_prepare() local
9376 nfs4_setup_sequence(server->nfs_client, &lgp->args.seq_args, in nfs4_layoutget_prepare()
9395 struct nfs_server *server = NFS_SERVER(inode); in nfs4_layoutget_handle_exception() local
9469 err = nfs4_handle_exception(server, nfs4err, exception); in nfs4_layoutget_handle_exception()
9481 size_t max_response_pages(struct nfs_server *server) in max_response_pages() argument
9483 u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz; in max_response_pages()
9507 struct nfs_server *server = NFS_SERVER(inode); in nfs4_proc_layoutget() local
9516 .rpc_client = server->client, in nfs4_proc_layoutget()
9581 struct nfs_server *server; in nfs4_layoutreturn_done() local
9597 server = NFS_SERVER(lrp->args.inode); in nfs4_layoutreturn_done()
9611 if (nfs4_async_handle_error(task, server, NULL, NULL) != -EAGAIN) in nfs4_layoutreturn_done()
9695 _nfs4_proc_getdeviceinfo(struct nfs_server *server, in _nfs4_proc_getdeviceinfo() argument
9716 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_getdeviceinfo()
9727 int nfs4_proc_getdeviceinfo(struct nfs_server *server, in nfs4_proc_getdeviceinfo() argument
9735 err = nfs4_handle_exception(server, in nfs4_proc_getdeviceinfo()
9736 _nfs4_proc_getdeviceinfo(server, pdev, cred), in nfs4_proc_getdeviceinfo()
9746 struct nfs_server *server = NFS_SERVER(data->args.inode); in nfs4_layoutcommit_prepare() local
9748 nfs4_setup_sequence(server->nfs_client, in nfs4_layoutcommit_prepare()
9758 struct nfs_server *server = NFS_SERVER(data->args.inode); in nfs4_layoutcommit_done() local
9772 if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) { in nfs4_layoutcommit_done()
9846 _nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle, in _nfs41_proc_secinfo_no_name() argument
9862 .seq_server = server, in _nfs41_proc_secinfo_no_name()
9867 .rpc_client = server->client, in _nfs41_proc_secinfo_no_name()
9869 .callback_ops = server->nfs_client->cl_mvops->call_sync_ops, in _nfs41_proc_secinfo_no_name()
9877 task_setup.rpc_client = server->nfs_client->cl_rpcclient; in _nfs41_proc_secinfo_no_name()
9879 cred = nfs4_get_clid_cred(server->nfs_client); in _nfs41_proc_secinfo_no_name()
9894 nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle, in nfs41_proc_secinfo_no_name() argument
9906 if (_nfs4_is_integrity_protected(server->nfs_client)) in nfs41_proc_secinfo_no_name()
9907 err = _nfs41_proc_secinfo_no_name(server, fhandle, info, in nfs41_proc_secinfo_no_name()
9917 err = _nfs41_proc_secinfo_no_name(server, fhandle, info, in nfs41_proc_secinfo_no_name()
9926 err = nfs4_handle_exception(server, err, &exception); in nfs41_proc_secinfo_no_name()
9934 nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle, in nfs41_find_root_sec() argument
9951 err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors); in nfs41_find_root_sec()
9955 * the server doesn't support SECINFO_NO_NAME in nfs41_find_root_sec()
9958 err = nfs4_find_root_sec(server, fhandle, info); in nfs41_find_root_sec()
9979 if (!nfs_auth_info_match(&server->auth_info, flavor)) in nfs41_find_root_sec()
9983 err = nfs4_lookup_root_sec(server, fhandle, in nfs41_find_root_sec()
10001 static int _nfs41_test_stateid(struct nfs_server *server, in _nfs41_test_stateid() argument
10016 struct rpc_clnt *rpc_client = server->client; in _nfs41_test_stateid()
10018 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID, in _nfs41_test_stateid()
10023 status = nfs4_call_sync_sequence(rpc_client, server, &msg, in _nfs41_test_stateid()
10033 static void nfs4_handle_delay_or_session_error(struct nfs_server *server, in nfs4_handle_delay_or_session_error() argument
10040 nfs4_handle_exception(server, err, exception); in nfs4_handle_delay_or_session_error()
10047 nfs4_do_handle_exception(server, err, exception); in nfs4_handle_delay_or_session_error()
10054 * @server: server / transport on which to perform the operation
10058 * Returns NFS_OK if the server recognizes that "stateid" is valid.
10062 static int nfs41_test_stateid(struct nfs_server *server, in nfs41_test_stateid() argument
10071 err = _nfs41_test_stateid(server, stateid, cred); in nfs41_test_stateid()
10072 nfs4_handle_delay_or_session_error(server, err, &exception); in nfs41_test_stateid()
10078 struct nfs_server *server; member
10086 nfs4_setup_sequence(data->server->nfs_client, in nfs41_free_stateid_prepare()
10100 if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN) in nfs41_free_stateid_done()
10119 * @server: server / transport on which to perform the operation
10126 static int nfs41_free_stateid(struct nfs_server *server, in nfs41_free_stateid() argument
10136 .rpc_client = server->client, in nfs41_free_stateid()
10144 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID, in nfs41_free_stateid()
10151 data->server = server; in nfs41_free_stateid()
10167 nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp) in nfs41_free_lock_state() argument
10171 nfs41_free_stateid(server, &lsp->ls_stateid, cred, false); in nfs41_free_lock_state()
10172 nfs4_free_lock_state(server, lsp); in nfs41_free_lock_state()