Lines Matching full:server
96 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
144 static inline u32 *nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label) in nfs4_bitmask() argument
147 return server->attr_bitmask; in nfs4_bitmask()
149 return server->attr_bitmask_nl; in nfs4_bitmask()
160 nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label) in nfs4_bitmask() argument
161 { return server->attr_bitmask; } in nfs4_bitmask()
348 * when talking to the server, we always send cookie 0 in nfs4_setup_readdir()
392 static void nfs4_test_and_free_stateid(struct nfs_server *server, in nfs4_test_and_free_stateid() argument
396 const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops; in nfs4_test_and_free_stateid()
398 ops->test_and_free_expired(server, stateid, cred); in nfs4_test_and_free_stateid()
401 static void __nfs4_free_revoked_stateid(struct nfs_server *server, in __nfs4_free_revoked_stateid() argument
406 nfs4_test_and_free_stateid(server, stateid, cred); in __nfs4_free_revoked_stateid()
409 static void nfs4_free_revoked_stateid(struct nfs_server *server, in nfs4_free_revoked_stateid() argument
416 __nfs4_free_revoked_stateid(server, &tmp, cred); in nfs4_free_revoked_stateid()
481 static int nfs4_do_handle_exception(struct nfs_server *server, in nfs4_do_handle_exception() argument
484 struct nfs_client *clp = server->nfs_client; in nfs4_do_handle_exception()
532 ret = nfs4_schedule_stateid_recovery(server, state); in nfs4_do_handle_exception()
541 ret = nfs4_schedule_migration_recovery(server); in nfs4_do_handle_exception()
569 nfs_inc_server_stats(server, NFSIOS_DELAY); in nfs4_do_handle_exception()
583 /* The following works around a Linux server bug! */ in nfs4_do_handle_exception()
585 if (server->caps & NFS_CAP_UIDGID_NOMAP) { in nfs4_do_handle_exception()
586 server->caps &= ~NFS_CAP_UIDGID_NOMAP; in nfs4_do_handle_exception()
588 printk(KERN_WARNING "NFS: v4 server %s " in nfs4_do_handle_exception()
592 server->nfs_client->cl_hostname); in nfs4_do_handle_exception()
607 static int nfs4_exception_should_retrans(const struct nfs_server *server, in nfs4_exception_should_retrans() argument
610 if (server->flags & NFS_MOUNT_SOFTERR && nfs_delay_retrans >= 0) { in nfs4_exception_should_retrans()
620 int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exceptio… in nfs4_handle_exception() argument
622 struct nfs_client *clp = server->nfs_client; in nfs4_handle_exception()
625 ret = nfs4_do_handle_exception(server, errorcode, exception); in nfs4_handle_exception()
627 int ret2 = nfs4_exception_should_retrans(server, exception); in nfs4_handle_exception()
640 if (test_bit(NFS_MIG_FAILED, &server->mig_status)) in nfs4_handle_exception()
652 nfs4_async_handle_exception(struct rpc_task *task, struct nfs_server *server, in nfs4_async_handle_exception() argument
655 struct nfs_client *clp = server->nfs_client; in nfs4_async_handle_exception()
658 ret = nfs4_do_handle_exception(server, errorcode, exception); in nfs4_async_handle_exception()
660 int ret2 = nfs4_exception_should_retrans(server, exception); in nfs4_async_handle_exception()
676 if (test_bit(NFS_MIG_FAILED, &server->mig_status)) in nfs4_async_handle_exception()
693 nfs4_async_handle_error(struct rpc_task *task, struct nfs_server *server, in nfs4_async_handle_error() argument
704 task->tk_status = nfs4_async_handle_exception(task, server, in nfs4_async_handle_error()
732 static void renew_lease(const struct nfs_server *server, unsigned long timestamp) in renew_lease() argument
734 struct nfs_client *clp = server->nfs_client; in renew_lease()
798 /* Be nice to the server: try to ensure that the last transmitted in nfs41_release_slot()
886 * The server may or may not have processed the sequence in nfs41_sequence_process()
893 /* The server detected a resend of the RPC call and in nfs41_sequence_process()
905 * The server thinks we tried to replay a request. in nfs41_sequence_process()
922 * If the server never received the request, then our in nfs41_sequence_process()
924 * if the server did receive the request then it might in nfs41_sequence_process()
927 * to the server on the same slot. in nfs41_sequence_process()
1178 struct nfs_server *server, in nfs4_do_call_sync() argument
1184 struct nfs_client *clp = server->nfs_client; in nfs4_do_call_sync()
1186 .seq_server = server, in nfs4_do_call_sync()
1202 struct nfs_server *server, in nfs4_call_sync_sequence() argument
1209 if (server->caps & NFS_CAP_MOVEABLE) in nfs4_call_sync_sequence()
1211 return nfs4_do_call_sync(clnt, server, msg, args, res, task_flags); in nfs4_call_sync_sequence()
1216 struct nfs_server *server, in nfs4_call_sync() argument
1223 return nfs4_call_sync_sequence(clnt, server, msg, args, res); in nfs4_call_sync()
1311 static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server, in nfs4_clear_cap_atomic_open_v1() argument
1316 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1)) in nfs4_clear_cap_atomic_open_v1()
1318 server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1; in nfs4_clear_cap_atomic_open_v1()
1354 nfs4_map_atomic_open_share(struct nfs_server *server, in nfs4_map_atomic_open_share() argument
1359 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1)) in nfs4_map_atomic_open_share()
1367 if (server->caps & NFS_CAP_DELEGTIME) in nfs4_map_atomic_open_share()
1369 if (server->caps & NFS_CAP_OPEN_XOR) in nfs4_map_atomic_open_share()
1376 nfs4_map_atomic_open_claim(struct nfs_server *server, in nfs4_map_atomic_open_claim() argument
1379 if (server->caps & NFS_CAP_ATOMIC_OPEN_V1) in nfs4_map_atomic_open_claim()
1398 p->o_res.server = p->o_arg.server; in nfs4_init_opendata_res()
1412 struct nfs_server *server = NFS_SERVER(dir); in nfs4_opendata_alloc() local
1421 p->f_attr.label = nfs4_label_alloc(server, gfp_mask); in nfs4_opendata_alloc()
1425 p->a_label = nfs4_label_alloc(server, gfp_mask); in nfs4_opendata_alloc()
1429 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid; in nfs4_opendata_alloc()
1440 p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim); in nfs4_opendata_alloc()
1441 p->o_arg.share_access = nfs4_map_atomic_open_share(server, in nfs4_opendata_alloc()
1454 /* ask server to check for all possible rights as results in nfs4_opendata_alloc()
1464 nfs_access_xattr_mask(server); in nfs4_opendata_alloc()
1466 p->o_arg.clientid = server->nfs_client->cl_clientid; in nfs4_opendata_alloc()
1470 p->o_arg.server = server; in nfs4_opendata_alloc()
1471 p->o_arg.bitmask = nfs4_bitmask(server, label); in nfs4_opendata_alloc()
1654 * Note: This function relies heavily on the server implementing
1670 /* The server returned a new stateid */ in nfs_stateid_is_sequential()
1760 * in which the server processed them by delaying the in nfs_set_open_stateid_locked()
1854 struct nfs_server *server = NFS_SERVER(state->inode); in update_open_stateid() local
1855 struct nfs_client *clp = server->nfs_client; in update_open_stateid()
1899 nfs4_test_and_free_stateid(server, &freeme, in update_open_stateid()
2001 pr_err_ratelimited("NFS: Broken NFSv4 server %s is " in nfs4_process_delegation()
2202 struct nfs_server *server = NFS_SB(opendata->dentry->d_sb); in nfs4_open_recover_helper() local
2210 nfs4_map_atomic_open_share(server, fmode, openflags); in nfs4_open_recover_helper()
2257 * reclaim state on the server after a reboot.
2295 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_do_open_reclaim() local
2301 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception)) in nfs4_do_open_reclaim()
2305 nfs4_handle_exception(server, err, &exception); in nfs4_do_open_reclaim()
2325 static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct nfs4_state *state,… in nfs4_handle_delegation_recall_error() argument
2347 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_handle_delegation_recall_error()
2350 nfs4_schedule_migration_recovery(server); in nfs4_handle_delegation_recall_error()
2353 nfs4_schedule_lease_moved_recovery(server->nfs_client); in nfs4_handle_delegation_recall_error()
2362 nfs4_schedule_stateid_recovery(server, state); in nfs4_handle_delegation_recall_error()
2383 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_open_delegation_recall() local
2410 return nfs4_handle_delegation_recall_error(server, state, stateid, NULL, err); in nfs4_open_delegation_recall()
2417 nfs4_setup_sequence(data->o_arg.server->nfs_client, in nfs4_open_confirm_prepare()
2431 renew_lease(data->o_res.server, data->timestamp); in nfs4_open_confirm_done()
2465 struct nfs_server *server = NFS_SERVER(d_inode(data->dir)); in _nfs4_proc_open_confirm() local
2474 .rpc_client = server->client, in _nfs4_proc_open_confirm()
2541 if (nfs4_setup_sequence(data->o_arg.server->nfs_client, in nfs4_open_prepare()
2594 renew_lease(data->o_res.server, data->timestamp); in nfs4_open_done()
2632 struct nfs_server *server = NFS_SERVER(dir); in nfs4_run_open_task() local
2643 .rpc_client = server->client, in nfs4_run_open_task()
2715 /* access call failed or for some reason the server doesn't in nfs4_opendata_access()
2747 struct nfs_server *server = NFS_SERVER(dir); in _nfs4_proc_open() local
2762 nfs_fattr_map_and_free_names(server, &data->f_attr); in _nfs4_proc_open()
2776 server->caps &= ~NFS_CAP_POSIX_LOCK; in _nfs4_proc_open()
2788 nfs4_proc_getattr(server, fh, o_res->f_attr, NULL); in _nfs4_proc_open()
2795 * reclaim state on the server after a network partition.
2821 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_do_open_expired() local
2828 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception)) in nfs4_do_open_expired()
2835 nfs4_handle_exception(server, err, &exception); in nfs4_do_open_expired()
2877 static int nfs40_test_and_free_expired_stateid(struct nfs_server *server, in nfs40_test_and_free_expired_stateid() argument
2885 static int nfs41_test_and_free_expired_stateid(struct nfs_server *server, in nfs41_test_and_free_expired_stateid() argument
2901 status = nfs41_test_stateid(server, stateid, cred); in nfs41_test_and_free_expired_stateid()
2911 /* Ack the revoked state to the server */ in nfs41_test_and_free_expired_stateid()
2912 nfs41_free_stateid(server, stateid, cred, true); in nfs41_test_and_free_expired_stateid()
2918 struct nfs_server *server = NFS_SERVER(state->inode); in nfs41_check_delegation_stateid() local
2947 status = nfs41_test_and_free_expired_stateid(server, &stateid, cred); in nfs41_check_delegation_stateid()
2983 struct nfs_server *server = NFS_SERVER(state->inode); in nfs41_check_expired_locks() local
2999 status = nfs41_test_and_free_expired_stateid(server, in nfs41_check_expired_locks()
3033 struct nfs_server *server = NFS_SERVER(state->inode); in nfs41_check_open_stateid() local
3040 status = nfs41_test_and_free_expired_stateid(server, stateid, cred); in nfs41_check_open_stateid()
3072 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
3079 const __u32 *bitmask = opendata->o_arg.server->exclcreat_bitmask; in nfs4_exclusive_attrset()
3116 struct nfs_server *server = sp->so_server; in _nfs4_open_and_get_state() local
3135 if (server->caps & NFS_CAP_POSIX_LOCK) in _nfs4_open_and_get_state()
3201 struct nfs_server *server = NFS_SERVER(dir); in _nfs4_do_open() local
3214 sp = nfs4_get_state_owner(server, cred, GFP_KERNEL); in _nfs4_do_open()
3219 status = nfs4_client_recover_expired_lease(server->nfs_client); in _nfs4_do_open()
3232 if (server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) { in _nfs4_do_open()
3274 if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server)) { in _nfs4_do_open()
3298 struct nfs_server *server = NFS_SERVER(dir); in nfs4_do_open() local
3319 /* NOTE: BAD_SEQID means the server and client disagree about the in nfs4_do_open()
3322 * It is actually a sign of a bug on the client or on the server. in nfs4_do_open()
3331 pr_warn_ratelimited("NFS: v4 server %s " in nfs4_do_open()
3338 * BAD_STATEID on OPEN means that the server cancelled our in nfs4_do_open()
3348 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_do_open()
3357 if (nfs4_clear_cap_atomic_open_v1(server, status, &exception)) in nfs4_do_open()
3359 res = ERR_PTR(nfs4_handle_exception(server, in nfs4_do_open()
3371 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_do_setattr() local
3415 status = nfs4_call_sync(server->client, server, &msg, &arg->seq_args, &res->seq_res, 1); in _nfs4_do_setattr()
3419 renew_lease(server, timestamp); in _nfs4_do_setattr()
3428 struct nfs_server *server = NFS_SERVER(inode); in nfs4_do_setattr() local
3434 .server = server, in nfs4_do_setattr()
3440 .server = server, in nfs4_do_setattr()
3457 nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, fattr->label), in nfs4_do_setattr()
3464 pr_warn_once("NFSv4: server %s is incorrectly " in nfs4_do_setattr()
3468 server->nfs_client->cl_hostname); in nfs4_do_setattr()
3477 err = nfs4_handle_exception(server, err, &exception); in nfs4_do_setattr()
3560 /* server says we're behind but we haven't seen the update yet */ in nfs4_refresh_open_old_stateid()
3624 struct nfs_server *server = NFS_SERVER(calldata->inode); in nfs4_close_done() local
3647 renew_lease(server, calldata->timestamp); in nfs4_close_done()
3666 nfs4_free_revoked_stateid(server, in nfs4_close_done()
3676 server, task->tk_status, &exception); in nfs4_close_done()
3699 struct nfs_server *server = NFS_SERVER(inode); in nfs4_close_prepare() local
3756 server->cache_consistency_bitmask, in nfs4_close_prepare()
3794 * NFSv4 citizens - we do not indicate to the server to update the file's
3802 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_do_close() local
3812 .rpc_client = server->client, in nfs4_do_close()
3823 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP, in nfs4_do_close()
3836 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid; in nfs4_do_close()
3845 calldata->res.server = server; in nfs4_do_close()
3919 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) in _nfs4_server_capabilities() argument
3921 u32 minorversion = server->nfs_client->cl_minorversion; in _nfs4_server_capabilities()
3949 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_server_capabilities()
3959 /* Sanity check the server answers */ in _nfs4_server_capabilities()
3976 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask)); in _nfs4_server_capabilities()
3977 server->caps &= ~(NFS_CAP_ACLS | NFS_CAP_HARDLINKS | in _nfs4_server_capabilities()
3979 server->fattr_valid = NFS_ATTR_FATTR_V4; in _nfs4_server_capabilities()
3982 server->caps |= NFS_CAP_ACLS; in _nfs4_server_capabilities()
3984 server->caps |= NFS_CAP_HARDLINKS; in _nfs4_server_capabilities()
3986 server->caps |= NFS_CAP_SYMLINKS; in _nfs4_server_capabilities()
3988 server->caps |= NFS_CAP_CASE_INSENSITIVE; in _nfs4_server_capabilities()
3990 server->caps |= NFS_CAP_CASE_PRESERVING; in _nfs4_server_capabilities()
3993 server->caps |= NFS_CAP_SECURITY_LABEL; in _nfs4_server_capabilities()
3996 server->caps |= NFS_CAP_FS_LOCATIONS; in _nfs4_server_capabilities()
3998 server->fattr_valid &= ~NFS_ATTR_FATTR_FILEID; in _nfs4_server_capabilities()
4000 server->fattr_valid &= ~NFS_ATTR_FATTR_MODE; in _nfs4_server_capabilities()
4002 server->fattr_valid &= ~NFS_ATTR_FATTR_NLINK; in _nfs4_server_capabilities()
4004 server->fattr_valid &= ~(NFS_ATTR_FATTR_OWNER | in _nfs4_server_capabilities()
4007 server->fattr_valid &= ~(NFS_ATTR_FATTR_GROUP | in _nfs4_server_capabilities()
4010 server->fattr_valid &= ~NFS_ATTR_FATTR_SPACE_USED; in _nfs4_server_capabilities()
4012 server->fattr_valid &= ~NFS_ATTR_FATTR_ATIME; in _nfs4_server_capabilities()
4014 server->fattr_valid &= ~NFS_ATTR_FATTR_CTIME; in _nfs4_server_capabilities()
4016 server->fattr_valid &= ~NFS_ATTR_FATTR_MTIME; in _nfs4_server_capabilities()
4017 memcpy(server->attr_bitmask_nl, res.attr_bitmask, in _nfs4_server_capabilities()
4018 sizeof(server->attr_bitmask)); in _nfs4_server_capabilities()
4019 server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL; in _nfs4_server_capabilities()
4023 server->caps |= NFS_CAP_OPEN_XOR; in _nfs4_server_capabilities()
4025 server->caps |= NFS_CAP_DELEGTIME; in _nfs4_server_capabilities()
4027 …memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitma… in _nfs4_server_capabilities()
4028 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE; in _nfs4_server_capabilities()
4029 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY; in _nfs4_server_capabilities()
4030 server->cache_consistency_bitmask[2] = 0; in _nfs4_server_capabilities()
4032 /* Avoid a regression due to buggy server */ in _nfs4_server_capabilities()
4035 memcpy(server->exclcreat_bitmask, res.exclcreat_bitmask, in _nfs4_server_capabilities()
4036 sizeof(server->exclcreat_bitmask)); in _nfs4_server_capabilities()
4038 server->acl_bitmask = res.acl_bitmask; in _nfs4_server_capabilities()
4039 server->fh_expire_type = res.fh_expire_type; in _nfs4_server_capabilities()
4045 int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) in nfs4_server_capabilities() argument
4052 nfs4_server_set_init_caps(server); in nfs4_server_capabilities()
4054 err = nfs4_handle_exception(server, in nfs4_server_capabilities()
4055 _nfs4_server_capabilities(server, fhandle), in nfs4_server_capabilities()
4063 struct nfs_server *server) in test_fs_location_for_trunking() argument
4089 clp->cl_net, server->port); in test_fs_location_for_trunking()
4128 static int _nfs4_discover_trunking(struct nfs_server *server, in _nfs4_discover_trunking() argument
4134 struct nfs_client *clp = server->nfs_client; in _nfs4_discover_trunking()
4156 status = nfs4_proc_get_locations(server, fhandle, locations, page, in _nfs4_discover_trunking()
4166 server); in _nfs4_discover_trunking()
4179 static int nfs4_discover_trunking(struct nfs_server *server, in nfs4_discover_trunking() argument
4185 struct nfs_client *clp = server->nfs_client; in nfs4_discover_trunking()
4191 err = nfs4_handle_exception(server, in nfs4_discover_trunking()
4192 _nfs4_discover_trunking(server, fhandle), in nfs4_discover_trunking()
4199 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, in _nfs4_lookup_root() argument
4207 .server = server, in _nfs4_lookup_root()
4225 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_lookup_root()
4228 static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, in nfs4_lookup_root() argument
4236 err = _nfs4_lookup_root(server, fhandle, info); in nfs4_lookup_root()
4237 trace_nfs4_lookup_root(server, fhandle, info->fattr, err); in nfs4_lookup_root()
4243 err = nfs4_handle_exception(server, err, &exception); in nfs4_lookup_root()
4250 static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle, in nfs4_lookup_root_sec() argument
4258 auth = rpcauth_create(&auth_args, server->client); in nfs4_lookup_root_sec()
4261 return nfs4_lookup_root(server, fhandle, info); in nfs4_lookup_root_sec()
4268 * NFSv4.1: the server does not support the SECINFO_NO_NAME operation
4273 static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle, in nfs4_find_root_sec() argument
4287 if (server->auth_info.flavor_len > 0) { in nfs4_find_root_sec()
4289 for (i = 0; i < server->auth_info.flavor_len; i++) { in nfs4_find_root_sec()
4290 status = nfs4_lookup_root_sec(server, fhandle, info, in nfs4_find_root_sec()
4291 server->auth_info.flavors[i]); in nfs4_find_root_sec()
4299 status = nfs4_lookup_root_sec(server, fhandle, info, in nfs4_find_root_sec()
4320 * nfs4_proc_get_rootfh - get file handle for server's pseudoroot
4321 * @server: initialized nfs_server handle
4328 int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle, in nfs4_proc_get_rootfh() argument
4335 status = nfs4_lookup_root(server, fhandle, info); in nfs4_proc_get_rootfh()
4338 status = server->nfs_client->cl_mvops->find_root_sec(server, in nfs4_proc_get_rootfh()
4342 status = nfs4_server_capabilities(server, fhandle); in nfs4_proc_get_rootfh()
4344 status = nfs4_do_fsinfo(server, fhandle, info); in nfs4_proc_get_rootfh()
4349 static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh, in nfs4_proc_get_root() argument
4355 error = nfs4_server_capabilities(server, mntfh); in nfs4_proc_get_root()
4361 error = nfs4_proc_getattr(server, mntfh, fattr, NULL); in nfs4_proc_get_root()
4368 !nfs_fsid_equal(&server->fsid, &fattr->fsid)) in nfs4_proc_get_root()
4369 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid)); in nfs4_proc_get_root()
4407 dprintk("%s: server did not return a different fsid for" in nfs4_get_referral()
4422 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, in _nfs4_proc_getattr() argument
4432 .server = server, in _nfs4_proc_getattr()
4441 if (nfs4_has_session(server->nfs_client)) in _nfs4_proc_getattr()
4445 if (inode && (server->flags & NFS_MOUNT_SOFTREVAL)) in _nfs4_proc_getattr()
4448 nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, fattr->label), inode, 0); in _nfs4_proc_getattr()
4451 return nfs4_do_call_sync(server->client, server, &msg, in _nfs4_proc_getattr()
4455 int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, in nfs4_proc_getattr() argument
4463 err = _nfs4_proc_getattr(server, fhandle, fattr, inode); in nfs4_proc_getattr()
4464 trace_nfs4_getattr(server, fhandle, fattr, err); in nfs4_proc_getattr()
4465 err = nfs4_handle_exception(server, err, in nfs4_proc_getattr()
4536 struct nfs_server *server = NFS_SERVER(dir); in _nfs4_proc_lookup() local
4539 .bitmask = server->attr_bitmask, in _nfs4_proc_lookup()
4544 .server = server, in _nfs4_proc_lookup()
4562 args.bitmask = nfs4_bitmask(server, fattr->label); in _nfs4_proc_lookup()
4568 status = nfs4_do_call_sync(clnt, server, &msg, in _nfs4_proc_lookup()
4659 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_proc_lookupp() local
4662 .bitmask = server->attr_bitmask, in _nfs4_proc_lookupp()
4666 .server = server, in _nfs4_proc_lookupp()
4680 args.bitmask = nfs4_bitmask(server, fattr->label); in _nfs4_proc_lookupp()
4685 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, in _nfs4_proc_lookupp()
4710 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_proc_access() local
4716 .server = server, in _nfs4_proc_access()
4730 args.bitmask = server->cache_consistency_bitmask; in _nfs4_proc_access()
4732 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_access()
4822 struct nfs_server *server = NFS_SERVER(dir); in nfs4_proc_create() local
4834 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK)) in nfs4_proc_create()
4850 struct nfs_server *server = NFS_SERVER(dir); in _nfs4_proc_remove() local
4856 .server = server, in _nfs4_proc_remove()
4866 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1); in _nfs4_proc_remove()
4925 res->server = NFS_SB(dentry->d_sb); in nfs4_proc_unlink_setup()
4952 if (nfs4_async_handle_error(task, res->server, NULL, in nfs4_proc_unlink_done()
4976 res->server = NFS_SB(old_dentry->d_sb); in nfs4_proc_rename_setup()
4996 if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN) in nfs4_proc_rename_done()
5021 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_proc_link() local
5030 .server = server, in _nfs4_proc_link()
5039 res.fattr = nfs_alloc_fattr_with_label(server); in _nfs4_proc_link()
5044 nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, res.fattr->label), in _nfs4_proc_link()
5047 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in _nfs4_proc_link()
5091 struct nfs_server *server = NFS_SERVER(dir); in nfs4_alloc_createdata() local
5093 data->fattr.label = nfs4_label_alloc(server, GFP_KERNEL); in nfs4_alloc_createdata()
5101 data->arg.server = server; in nfs4_alloc_createdata()
5105 data->arg.bitmask = nfs4_bitmask(server, data->fattr.label); in nfs4_alloc_createdata()
5107 data->res.server = server; in nfs4_alloc_createdata()
5213 struct nfs_server *server = NFS_SERVER(dir); in nfs4_proc_mkdir() local
5222 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK)) in nfs4_proc_mkdir()
5239 struct nfs_server *server = NFS_SERVER(dir); in _nfs4_proc_readdir() local
5258 if (!(server->caps & NFS_CAP_SECURITY_LABEL)) in _nfs4_proc_readdir()
5259 args.bitmask = server->attr_bitmask_nl; in _nfs4_proc_readdir()
5261 args.bitmask = server->attr_bitmask; in _nfs4_proc_readdir()
5265 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, in _nfs4_proc_readdir()
5332 struct nfs_server *server = NFS_SERVER(dir); in nfs4_proc_mknod() local
5341 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK)) in nfs4_proc_mknod()
5355 static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, in _nfs4_proc_statfs() argument
5360 .bitmask = server->attr_bitmask, in _nfs4_proc_statfs()
5372 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_statfs()
5375 static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *f… in nfs4_proc_statfs() argument
5382 err = nfs4_handle_exception(server, in nfs4_proc_statfs()
5383 _nfs4_proc_statfs(server, fhandle, fsstat), in nfs4_proc_statfs()
5389 static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, in _nfs4_do_fsinfo() argument
5394 .bitmask = server->attr_bitmask, in _nfs4_do_fsinfo()
5405 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_do_fsinfo()
5408 static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsi… in nfs4_do_fsinfo() argument
5416 err = _nfs4_do_fsinfo(server, fhandle, fsinfo); in nfs4_do_fsinfo()
5417 trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err); in nfs4_do_fsinfo()
5419 nfs4_set_lease_period(server->nfs_client, fsinfo->lease_time * HZ); in nfs4_do_fsinfo()
5422 err = nfs4_handle_exception(server, err, &exception); in nfs4_do_fsinfo()
5427 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *f… in nfs4_proc_fsinfo() argument
5432 error = nfs4_do_fsinfo(server, fhandle, fsinfo); in nfs4_proc_fsinfo()
5435 server->pnfs_blksize = fsinfo->blksize; in nfs4_proc_fsinfo()
5436 set_pnfs_layoutdriver(server, fhandle, fsinfo); in nfs4_proc_fsinfo()
5442 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, in _nfs4_proc_pathconf() argument
5447 .bitmask = server->attr_bitmask, in _nfs4_proc_pathconf()
5465 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_pathconf()
5468 static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, in nfs4_proc_pathconf() argument
5477 err = nfs4_handle_exception(server, in nfs4_proc_pathconf()
5478 _nfs4_proc_pathconf(server, fhandle, pathconf), in nfs4_proc_pathconf()
5523 struct nfs_server *server = NFS_SERVER(hdr->inode); in nfs4_read_done_cb() local
5533 server, task->tk_status, &exception); in nfs4_read_done_cb()
5541 renew_lease(server, hdr->timestamp); in nfs4_read_done_cb()
5562 struct nfs_server *server = NFS_SERVER(hdr->inode); in nfs4_read_plus_not_supported() local
5567 server->caps &= ~NFS_CAP_READ_PLUS; in nfs4_read_plus_not_supported()
5702 struct nfs_server *server = NFS_SERVER(inode); in nfs4_bitmask_set() local
5729 bitmask[i] &= server->attr_bitmask[i]; in nfs4_bitmask_set()
5736 struct nfs_server *server = NFS_SERVER(hdr->inode); in nfs4_proc_write_setup() local
5743 server->cache_consistency_bitmask, in nfs4_proc_write_setup()
5750 hdr->res.server = server; in nfs4_proc_write_setup()
5755 nfs4_state_protect_write(hdr->ds_clp ? hdr->ds_clp : server->nfs_client, clnt, msg, hdr); in nfs4_proc_write_setup()
5789 struct nfs_server *server = NFS_SERVER(data->inode); in nfs4_proc_commit_setup() local
5793 data->res.server = server; in nfs4_proc_commit_setup()
5796 nfs4_state_protect(data->ds_clp ? data->ds_clp : server->nfs_client, in nfs4_proc_commit_setup()
5804 struct nfs_server *server = NFS_SERVER(dst_inode); in _nfs4_proc_commit() local
5812 return nfs4_call_sync(server->client, server, &msg, in _nfs4_proc_commit()
5926 static bool nfs4_server_supports_acls(const struct nfs_server *server, in nfs4_server_supports_acls() argument
5931 return server->attr_bitmask[0] & FATTR4_WORD0_ACL; in nfs4_server_supports_acls()
5933 return server->attr_bitmask[1] & FATTR4_WORD1_DACL; in nfs4_server_supports_acls()
5935 return server->attr_bitmask[1] & FATTR4_WORD1_SACL; in nfs4_server_supports_acls()
6052 * the required buf. On a NULL buf, we send a page of data to the server
6057 * the server, this time with the input buf of the required size.
6079 struct nfs_server *server = NFS_SERVER(inode); in __nfs4_get_acl_uncached() local
6082 buflen = server->rsize; in __nfs4_get_acl_uncached()
6159 struct nfs_server *server = NFS_SERVER(inode); in nfs4_proc_get_acl() local
6162 if (!nfs4_server_supports_acls(server, type)) in nfs4_proc_get_acl()
6180 struct nfs_server *server = NFS_SERVER(inode); in __nfs4_proc_set_acl() local
6200 if (!nfs4_server_supports_acls(server, type)) in __nfs4_proc_set_acl()
6208 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in __nfs4_proc_set_acl()
6257 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_get_security_label() local
6270 .server = server, in _nfs4_get_security_label()
6281 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0); in _nfs4_get_security_label()
6315 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_do_set_security_label() local
6320 .server = server, in _nfs4_do_set_security_label()
6326 .server = server, in _nfs4_do_set_security_label()
6337 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in _nfs4_do_set_security_label()
6715 renew_lease(data->res.server, data->timestamp); in nfs4_delegreturn_done()
6720 nfs4_free_revoked_stateid(data->res.server, in nfs4_delegreturn_done()
6746 data->res.server, task->tk_status, in nfs4_delegreturn_done()
6794 nfs4_setup_sequence(d_data->res.server->nfs_client, in nfs4_delegreturn_prepare()
6812 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_proc_delegreturn() local
6819 .rpc_client = server->client, in _nfs4_proc_delegreturn()
6833 nfs4_state_protect(server->nfs_client, in _nfs4_proc_delegreturn()
6840 server->cache_consistency_bitmask, inode, 0); in _nfs4_proc_delegreturn()
6845 data->res.server = server; in _nfs4_proc_delegreturn()
6903 struct nfs_server *server = NFS_SERVER(inode); in nfs4_proc_delegreturn() local
6916 err = nfs4_handle_exception(server, err, &exception); in nfs4_proc_delegreturn()
6924 struct nfs_server *server = NFS_SERVER(inode); in _nfs4_proc_getlk() local
6925 struct nfs_client *clp = server->nfs_client; in _nfs4_proc_getlk()
6948 arg.lock_owner.s_dev = server->s_dev; in _nfs4_proc_getlk()
6949 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in _nfs4_proc_getlk()
7022 struct nfs_server *server; member
7048 p->server = NFS_SERVER(inode); in nfs4_alloc_unlockdata()
7077 renew_lease(calldata->server, calldata->timestamp); in nfs4_locku_done()
7085 nfs4_free_revoked_stateid(calldata->server, in nfs4_locku_done()
7102 calldata->server, task->tk_status, in nfs4_locku_done()
7125 if (nfs4_setup_sequence(calldata->server->nfs_client, in nfs4_locku_prepare()
7248 struct nfs_server *server; member
7257 struct nfs_server *server = NFS_SERVER(inode); in nfs4_alloc_lockdata() local
7269 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid; in nfs4_alloc_lockdata()
7273 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid; in nfs4_alloc_lockdata()
7275 p->arg.lock_owner.s_dev = server->s_dev; in nfs4_alloc_lockdata()
7278 p->server = server; in nfs4_alloc_lockdata()
7317 if (nfs4_setup_sequence(data->server->nfs_client, in nfs4_lock_prepare()
7409 static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new… in nfs4_handle_setlk_error() argument
7418 nfs4_schedule_stateid_recovery(server, lsp->ls_state); in nfs4_handle_setlk_error()
7422 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_handle_setlk_error()
7470 nfs4_handle_setlk_error(data->server, data->lsp, in _nfs4_do_setlk()
7482 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_lock_reclaim() local
7495 nfs4_handle_exception(server, err, &exception); in nfs4_lock_reclaim()
7502 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_lock_expired() local
7524 nfs4_handle_exception(server, err, &exception); in nfs4_lock_expired()
7656 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_retry_setlk() local
7657 struct nfs_client *clp = server->nfs_client; in nfs4_retry_setlk()
7663 .s_dev = server->s_dev }, in nfs4_retry_setlk()
7790 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_lock_delegation_recall() local
7802 return nfs4_handle_delegation_recall_error(server, state, stateid, fl, err); in nfs4_lock_delegation_recall()
7807 struct nfs_server *server; member
7816 struct nfs_server *server = data->server; in nfs4_release_lockowner_prepare() local
7817 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args, in nfs4_release_lockowner_prepare()
7819 data->args.lock_owner.clientid = server->nfs_client->cl_clientid; in nfs4_release_lockowner_prepare()
7826 struct nfs_server *server = data->server; in nfs4_release_lockowner_done() local
7832 renew_lease(server, data->timestamp); in nfs4_release_lockowner_done()
7836 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_release_lockowner_done()
7840 if (nfs4_async_handle_error(task, server, in nfs4_release_lockowner_done()
7849 nfs4_free_lock_state(data->server, data->lsp); in nfs4_release_lockowner_release()
7860 nfs4_release_lockowner(struct nfs_server *server, struct nfs4_lock_state *lsp) in nfs4_release_lockowner() argument
7867 if (server->nfs_client->cl_mvops->minor_version != 0) in nfs4_release_lockowner()
7874 data->server = server; in nfs4_release_lockowner()
7875 data->args.lock_owner.clientid = server->nfs_client->cl_clientid; in nfs4_release_lockowner()
7877 data->args.lock_owner.s_dev = server->s_dev; in nfs4_release_lockowner()
7882 rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data); in nfs4_release_lockowner()
8027 * Just in case the server has other ideas (which RFC 8276 allows), in nfs4_xattr_set_nfs4_user()
8159 struct nfs_server *server = NFS_SERVER(dir); in _nfs4_proc_fs_locations() local
8190 fs_locations->server = server; in _nfs4_proc_fs_locations()
8192 status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_fs_locations()
8217 * This operation also signals the server that this client is
8218 * performing migration recovery. The server can stop returning
8223 static int _nfs40_proc_get_locations(struct nfs_server *server, in _nfs40_proc_get_locations() argument
8228 struct rpc_clnt *clnt = server->client; in _nfs40_proc_get_locations()
8233 .clientid = server->nfs_client->cl_clientid, in _nfs40_proc_get_locations()
8255 locations->server = server; in _nfs40_proc_get_locations()
8259 status = nfs4_call_sync_sequence(clnt, server, &msg, in _nfs40_proc_get_locations()
8264 renew_lease(server, now); in _nfs40_proc_get_locations()
8271 * This operation also signals the server that this client is
8272 * performing migration recovery. The server can stop asserting
8280 static int _nfs41_proc_get_locations(struct nfs_server *server, in _nfs41_proc_get_locations() argument
8285 struct rpc_clnt *clnt = server->client; in _nfs41_proc_get_locations()
8306 .seq_server = server, in _nfs41_proc_get_locations()
8313 .callback_ops = server->nfs_client->cl_mvops->call_sync_ops, in _nfs41_proc_get_locations()
8320 locations->server = server; in _nfs41_proc_get_locations()
8335 * @server: pointer to nfs_server to process
8344 * On success, "locations" is filled in, but if the server has
8348 * -NFS4ERR_LEASE_MOVED is returned if the server still has leases
8351 int nfs4_proc_get_locations(struct nfs_server *server, in nfs4_proc_get_locations() argument
8356 struct nfs_client *clp = server->nfs_client; in nfs4_proc_get_locations()
8365 (unsigned long long)server->fsid.major, in nfs4_proc_get_locations()
8366 (unsigned long long)server->fsid.minor, in nfs4_proc_get_locations()
8371 status = ops->get_locations(server, fhandle, locations, page, in nfs4_proc_get_locations()
8375 nfs4_handle_exception(server, status, &exception); in nfs4_proc_get_locations()
8381 * This operation also signals the server that this client is
8382 * performing "lease moved" recovery. The server can stop
8389 struct nfs_server *server = NFS_SERVER(inode); in _nfs40_proc_fsid_present() local
8391 struct rpc_clnt *clnt = server->client; in _nfs40_proc_fsid_present()
8414 status = nfs4_call_sync_sequence(clnt, server, &msg, in _nfs40_proc_fsid_present()
8427 * This operation also signals the server that this client is
8428 * performing "lease moved" recovery. The server can stop asserting
8435 struct nfs_server *server = NFS_SERVER(inode); in _nfs41_proc_fsid_present() local
8436 struct rpc_clnt *clnt = server->client; in _nfs41_proc_fsid_present()
8455 status = nfs4_call_sync_sequence(clnt, server, &msg, in _nfs41_proc_fsid_present()
8467 * nfs4_proc_fsid_present - Is this FSID present or absent on server?
8471 * Server indicates whether the FSID is present, moved, or not
8475 * Returns NFS4_OK if the FSID is present on this server,
8477 * NFS4ERR code if some error occurred on the server, or a
8482 struct nfs_server *server = NFS_SERVER(inode); in nfs4_proc_fsid_present() local
8483 struct nfs_client *clp = server->nfs_client; in nfs4_proc_fsid_present()
8492 (unsigned long long)server->fsid.major, in nfs4_proc_fsid_present()
8493 (unsigned long long)server->fsid.minor, in nfs4_proc_fsid_present()
8501 nfs4_handle_exception(server, status, &exception); in nfs4_proc_fsid_present()
8596 * Check the exchange flags returned by the server for invalid flags, having
8708 dprintk("NFS: %s: Unexpected direction from server\n", in nfs4_proc_bind_one_conn_to_session()
8713 dprintk("NFS: %s: Server returned RDMA mode = true\n", in nfs4_proc_bind_one_conn_to_session()
8776 * Select the state protection mode for client `clp' given the server results
8797 dfprintk(MOUNT, "Server SP4_MACH_CRED support:\n"); in nfs4_sp4_select_mode()
9159 dprintk("NFS: Got error %d from the server %s on " in _nfs4_proc_destroy_clientid()
9346 * So, no point even trying to continue if the server won't in nfs4_verify_fore_channel_attrs()
9455 * Issues a CREATE_SESSION operation to the server.
9515 dprintk("NFS: Got error %d from the server on DESTROY_SESSION. " in nfs4_proc_destroy_session()
9703 dprintk("%s: failed to reclaim complete error %d for server %s, retrying\n", in nfs41_reclaim_complete_handle_errors()
9784 struct nfs_server *server = NFS_SERVER(lgp->args.inode); in nfs4_layoutget_prepare() local
9786 nfs4_setup_sequence(server->nfs_client, &lgp->args.seq_args, in nfs4_layoutget_prepare()
9802 struct nfs_server *server = NFS_SERVER(inode); in nfs4_layoutget_handle_exception() local
9879 err = nfs4_handle_exception(server, nfs4err, exception); in nfs4_layoutget_handle_exception()
9890 size_t max_response_pages(struct nfs_server *server) in max_response_pages() argument
9892 u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz; in max_response_pages()
9915 struct nfs_server *server = NFS_SERVER(inode); in nfs4_proc_layoutget() local
9924 .rpc_client = server->client, in nfs4_proc_layoutget()
9984 struct nfs_server *server; in nfs4_layoutreturn_done() local
10003 server = NFS_SERVER(lrp->args.inode); in nfs4_layoutreturn_done()
10020 nfs4_schedule_session_recovery(server->nfs_client->cl_session, in nfs4_layoutreturn_done()
10027 if (nfs4_async_handle_error(task, server, NULL, NULL) == in nfs4_layoutreturn_done()
10117 _nfs4_proc_getdeviceinfo(struct nfs_server *server, in _nfs4_proc_getdeviceinfo() argument
10137 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_getdeviceinfo()
10143 trace_nfs4_getdeviceinfo(server, &pdev->dev_id, status); in _nfs4_proc_getdeviceinfo()
10150 int nfs4_proc_getdeviceinfo(struct nfs_server *server, in nfs4_proc_getdeviceinfo() argument
10158 err = nfs4_handle_exception(server, in nfs4_proc_getdeviceinfo()
10159 _nfs4_proc_getdeviceinfo(server, pdev, cred), in nfs4_proc_getdeviceinfo()
10169 struct nfs_server *server = NFS_SERVER(data->args.inode); in nfs4_layoutcommit_prepare() local
10171 nfs4_setup_sequence(server->nfs_client, in nfs4_layoutcommit_prepare()
10181 struct nfs_server *server = NFS_SERVER(data->args.inode); in nfs4_layoutcommit_done() local
10196 if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) { in nfs4_layoutcommit_done()
10271 _nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle, in _nfs41_proc_secinfo_no_name() argument
10287 .seq_server = server, in _nfs41_proc_secinfo_no_name()
10292 .rpc_client = server->client, in _nfs41_proc_secinfo_no_name()
10294 .callback_ops = server->nfs_client->cl_mvops->call_sync_ops, in _nfs41_proc_secinfo_no_name()
10302 task_setup.rpc_client = server->nfs_client->cl_rpcclient; in _nfs41_proc_secinfo_no_name()
10304 cred = nfs4_get_clid_cred(server->nfs_client); in _nfs41_proc_secinfo_no_name()
10318 nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle, in nfs41_proc_secinfo_no_name() argument
10330 if (_nfs4_is_integrity_protected(server->nfs_client)) in nfs41_proc_secinfo_no_name()
10331 err = _nfs41_proc_secinfo_no_name(server, fhandle, info, in nfs41_proc_secinfo_no_name()
10341 err = _nfs41_proc_secinfo_no_name(server, fhandle, info, in nfs41_proc_secinfo_no_name()
10350 err = nfs4_handle_exception(server, err, &exception); in nfs41_proc_secinfo_no_name()
10358 nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle, in nfs41_find_root_sec() argument
10375 err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors); in nfs41_find_root_sec()
10379 * the server doesn't support SECINFO_NO_NAME in nfs41_find_root_sec()
10382 err = nfs4_find_root_sec(server, fhandle, info); in nfs41_find_root_sec()
10403 if (!nfs_auth_info_match(&server->auth_info, flavor)) in nfs41_find_root_sec()
10407 err = nfs4_lookup_root_sec(server, fhandle, in nfs41_find_root_sec()
10425 static int _nfs41_test_stateid(struct nfs_server *server, in _nfs41_test_stateid() argument
10440 struct rpc_clnt *rpc_client = server->client; in _nfs41_test_stateid()
10442 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID, in _nfs41_test_stateid()
10447 status = nfs4_call_sync_sequence(rpc_client, server, &msg, in _nfs41_test_stateid()
10457 static void nfs4_handle_delay_or_session_error(struct nfs_server *server, in nfs4_handle_delay_or_session_error() argument
10464 nfs4_handle_exception(server, err, exception); in nfs4_handle_delay_or_session_error()
10471 nfs4_do_handle_exception(server, err, exception); in nfs4_handle_delay_or_session_error()
10478 * @server: server / transport on which to perform the operation
10482 * Returns NFS_OK if the server recognizes that "stateid" is valid.
10486 static int nfs41_test_stateid(struct nfs_server *server, in nfs41_test_stateid() argument
10495 err = _nfs41_test_stateid(server, stateid, cred); in nfs41_test_stateid()
10496 nfs4_handle_delay_or_session_error(server, err, &exception); in nfs41_test_stateid()
10502 struct nfs_server *server; member
10510 nfs4_setup_sequence(data->server->nfs_client, in nfs41_free_stateid_prepare()
10524 if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN) in nfs41_free_stateid_done()
10532 struct nfs_client *clp = data->server->nfs_client; in nfs41_free_stateid_release()
10547 * @server: server / transport on which to perform the operation
10554 static int nfs41_free_stateid(struct nfs_server *server, in nfs41_free_stateid() argument
10564 .rpc_client = server->client, in nfs41_free_stateid()
10571 struct nfs_client *clp = server->nfs_client; in nfs41_free_stateid()
10576 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID, in nfs41_free_stateid()
10583 data->server = server; in nfs41_free_stateid()
10599 nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp) in nfs41_free_lock_state() argument
10603 nfs41_free_stateid(server, &lsp->ls_stateid, cred, false); in nfs41_free_lock_state()
10604 nfs4_free_lock_state(server, lsp); in nfs41_free_lock_state()