Lines Matching defs: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)
147 return server->attr_bitmask;
149 return server->attr_bitmask_nl;
160 nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)
161 { return server->attr_bitmask; }
336 * when talking to the server, we always send cookie 0
380 static void nfs4_test_and_free_stateid(struct nfs_server *server,
384 const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
386 ops->test_and_free_expired(server, stateid, cred);
389 static void __nfs4_free_revoked_stateid(struct nfs_server *server,
394 nfs4_test_and_free_stateid(server, stateid, cred);
397 static void nfs4_free_revoked_stateid(struct nfs_server *server,
404 __nfs4_free_revoked_stateid(server, &tmp, cred);
469 static int nfs4_do_handle_exception(struct nfs_server *server,
472 struct nfs_client *clp = server->nfs_client;
520 ret = nfs4_schedule_stateid_recovery(server, state);
529 ret = nfs4_schedule_migration_recovery(server);
557 nfs_inc_server_stats(server, NFSIOS_DELAY);
571 /* The following works around a Linux server bug! */
573 if (server->caps & NFS_CAP_UIDGID_NOMAP) {
574 server->caps &= ~NFS_CAP_UIDGID_NOMAP;
576 printk(KERN_WARNING "NFS: v4 server %s "
580 server->nfs_client->cl_hostname);
595 static int nfs4_exception_should_retrans(const struct nfs_server *server,
598 if (server->flags & NFS_MOUNT_SOFTERR && nfs_delay_retrans >= 0) {
608 int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
610 struct nfs_client *clp = server->nfs_client;
613 ret = nfs4_do_handle_exception(server, errorcode, exception);
615 int ret2 = nfs4_exception_should_retrans(server, exception);
628 if (test_bit(NFS_MIG_FAILED, &server->mig_status))
640 nfs4_async_handle_exception(struct rpc_task *task, struct nfs_server *server,
643 struct nfs_client *clp = server->nfs_client;
646 ret = nfs4_do_handle_exception(server, errorcode, exception);
648 int ret2 = nfs4_exception_should_retrans(server, exception);
664 if (test_bit(NFS_MIG_FAILED, &server->mig_status))
681 nfs4_async_handle_error(struct rpc_task *task, struct nfs_server *server,
692 task->tk_status = nfs4_async_handle_exception(task, server,
720 static void renew_lease(const struct nfs_server *server, unsigned long timestamp)
722 struct nfs_client *clp = server->nfs_client;
786 /* Be nice to the server: try to ensure that the last transmitted
874 * The server may or may not have processed the sequence
881 /* The server detected a resend of the RPC call and
893 * The server thinks we tried to replay a request.
910 * If the server never received the request, then our
912 * if the server did receive the request then it might
915 * to the server on the same slot.
1166 struct nfs_server *server,
1172 struct nfs_client *clp = server->nfs_client;
1174 .seq_server = server,
1190 struct nfs_server *server,
1197 if (server->caps & NFS_CAP_MOVEABLE)
1199 return nfs4_do_call_sync(clnt, server, msg, args, res, task_flags);
1204 struct nfs_server *server,
1211 return nfs4_call_sync_sequence(clnt, server, msg, args, res);
1298 static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server,
1303 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
1305 server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1;
1323 nfs4_map_atomic_open_share(struct nfs_server *server,
1338 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
1348 nfs4_map_atomic_open_claim(struct nfs_server *server,
1351 if (server->caps & NFS_CAP_ATOMIC_OPEN_V1)
1370 p->o_res.server = p->o_arg.server;
1384 struct nfs_server *server = NFS_SERVER(dir);
1393 p->f_attr.label = nfs4_label_alloc(server, gfp_mask);
1397 p->a_label = nfs4_label_alloc(server, gfp_mask);
1401 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
1412 p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim);
1413 p->o_arg.share_access = nfs4_map_atomic_open_share(server,
1426 /* ask server to check for all possible rights as results
1436 nfs_access_xattr_mask(server);
1438 p->o_arg.clientid = server->nfs_client->cl_clientid;
1442 p->o_arg.server = server;
1443 p->o_arg.bitmask = nfs4_bitmask(server, label);
1626 * Note: This function relies heavily on the server implementing
1642 /* The server returned a new stateid */
1732 * in which the server processed them by delaying the
1826 struct nfs_server *server = NFS_SERVER(state->inode);
1827 struct nfs_client *clp = server->nfs_client;
1871 nfs4_test_and_free_stateid(server, &freeme,
1973 pr_err_ratelimited("NFS: Broken NFSv4 server %s is "
2164 struct nfs_server *server = NFS_SB(opendata->dentry->d_sb);
2172 nfs4_map_atomic_open_share(server, fmode, openflags);
2219 * reclaim state on the server after a reboot.
2245 struct nfs_server *server = NFS_SERVER(state->inode);
2251 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
2255 nfs4_handle_exception(server, err, &exception);
2275 static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct nfs4_state *state, const nfs4_stateid *stateid, struct file_lock *fl, int err)
2297 nfs4_schedule_lease_recovery(server->nfs_client);
2300 nfs4_schedule_migration_recovery(server);
2303 nfs4_schedule_lease_moved_recovery(server->nfs_client);
2312 nfs4_schedule_stateid_recovery(server, state);
2333 struct nfs_server *server = NFS_SERVER(state->inode);
2360 return nfs4_handle_delegation_recall_error(server, state, stateid, NULL, err);
2367 nfs4_setup_sequence(data->o_arg.server->nfs_client,
2381 renew_lease(data->o_res.server, data->timestamp);
2415 struct nfs_server *server = NFS_SERVER(d_inode(data->dir));
2424 .rpc_client = server->client,
2491 if (nfs4_setup_sequence(data->o_arg.server->nfs_client,
2544 renew_lease(data->o_res.server, data->timestamp);
2582 struct nfs_server *server = NFS_SERVER(dir);
2593 .rpc_client = server->client,
2665 /* access call failed or for some reason the server doesn't
2697 struct nfs_server *server = NFS_SERVER(dir);
2712 nfs_fattr_map_and_free_names(server, &data->f_attr);
2726 server->caps &= ~NFS_CAP_POSIX_LOCK;
2738 nfs4_proc_getattr(server, fh, o_res->f_attr, NULL);
2745 * reclaim state on the server after a network partition.
2771 struct nfs_server *server = NFS_SERVER(state->inode);
2778 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
2785 nfs4_handle_exception(server, err, &exception);
2827 static int nfs40_test_and_free_expired_stateid(struct nfs_server *server,
2835 static int nfs41_test_and_free_expired_stateid(struct nfs_server *server,
2851 status = nfs41_test_stateid(server, stateid, cred);
2861 /* Ack the revoked state to the server */
2862 nfs41_free_stateid(server, stateid, cred, true);
2868 struct nfs_server *server = NFS_SERVER(state->inode);
2897 status = nfs41_test_and_free_expired_stateid(server, &stateid, cred);
2933 struct nfs_server *server = NFS_SERVER(state->inode);
2949 status = nfs41_test_and_free_expired_stateid(server,
2983 struct nfs_server *server = NFS_SERVER(state->inode);
2990 status = nfs41_test_and_free_expired_stateid(server, stateid, cred);
3022 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
3029 const __u32 *bitmask = opendata->o_arg.server->exclcreat_bitmask;
3066 struct nfs_server *server = sp->so_server;
3085 if (server->caps & NFS_CAP_POSIX_LOCK)
3151 struct nfs_server *server = NFS_SERVER(dir);
3164 sp = nfs4_get_state_owner(server, cred, GFP_KERNEL);
3169 status = nfs4_client_recover_expired_lease(server->nfs_client);
3182 if (server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) {
3224 if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server)) {
3248 struct nfs_server *server = NFS_SERVER(dir);
3269 /* NOTE: BAD_SEQID means the server and client disagree about the
3272 * It is actually a sign of a bug on the client or on the server.
3281 pr_warn_ratelimited("NFS: v4 server %s "
3288 * BAD_STATEID on OPEN means that the server cancelled our
3298 nfs4_schedule_lease_recovery(server->nfs_client);
3307 if (nfs4_clear_cap_atomic_open_v1(server, status, &exception))
3309 res = ERR_PTR(nfs4_handle_exception(server,
3321 struct nfs_server *server = NFS_SERVER(inode);
3365 status = nfs4_call_sync(server->client, server, &msg, &arg->seq_args, &res->seq_res, 1);
3369 renew_lease(server, timestamp);
3378 struct nfs_server *server = NFS_SERVER(inode);
3384 .server = server,
3390 .server = server,
3406 nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, fattr->label),
3413 pr_warn_once("NFSv4: server %s is incorrectly "
3417 server->nfs_client->cl_hostname);
3426 err = nfs4_handle_exception(server, err, &exception);
3509 /* server says we're behind but we haven't seen the update yet */
3573 struct nfs_server *server = NFS_SERVER(calldata->inode);
3596 renew_lease(server, calldata->timestamp);
3615 nfs4_free_revoked_stateid(server,
3625 server, task->tk_status, &exception);
3648 struct nfs_server *server = NFS_SERVER(inode);
3705 server->cache_consistency_bitmask,
3744 * NFSv4 citizens - we do not indicate to the server to update the file's
3752 struct nfs_server *server = NFS_SERVER(state->inode);
3762 .rpc_client = server->client,
3773 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP,
3786 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
3795 calldata->res.server = server;
3857 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
3859 u32 bitmask[3] = {}, minorversion = server->nfs_client->cl_minorversion;
3883 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3885 /* Sanity check the server answers */
3897 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
3898 server->caps &= ~(NFS_CAP_ACLS | NFS_CAP_HARDLINKS |
3900 server->fattr_valid = NFS_ATTR_FATTR_V4;
3903 server->caps |= NFS_CAP_ACLS;
3905 server->caps |= NFS_CAP_HARDLINKS;
3907 server->caps |= NFS_CAP_SYMLINKS;
3909 server->caps |= NFS_CAP_CASE_INSENSITIVE;
3911 server->caps |= NFS_CAP_CASE_PRESERVING;
3914 server->caps |= NFS_CAP_SECURITY_LABEL;
3917 server->caps |= NFS_CAP_FS_LOCATIONS;
3919 server->fattr_valid &= ~NFS_ATTR_FATTR_FILEID;
3921 server->fattr_valid &= ~NFS_ATTR_FATTR_MODE;
3923 server->fattr_valid &= ~NFS_ATTR_FATTR_NLINK;
3925 server->fattr_valid &= ~(NFS_ATTR_FATTR_OWNER |
3928 server->fattr_valid &= ~(NFS_ATTR_FATTR_GROUP |
3931 server->fattr_valid &= ~NFS_ATTR_FATTR_SPACE_USED;
3933 server->fattr_valid &= ~NFS_ATTR_FATTR_ATIME;
3935 server->fattr_valid &= ~NFS_ATTR_FATTR_CTIME;
3937 server->fattr_valid &= ~NFS_ATTR_FATTR_MTIME;
3938 memcpy(server->attr_bitmask_nl, res.attr_bitmask,
3939 sizeof(server->attr_bitmask));
3940 server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
3942 memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
3943 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
3944 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
3945 server->cache_consistency_bitmask[2] = 0;
3947 /* Avoid a regression due to buggy server */
3950 memcpy(server->exclcreat_bitmask, res.exclcreat_bitmask,
3951 sizeof(server->exclcreat_bitmask));
3953 server->acl_bitmask = res.acl_bitmask;
3954 server->fh_expire_type = res.fh_expire_type;
3960 int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
3967 nfs4_server_set_init_caps(server);
3969 err = nfs4_handle_exception(server,
3970 _nfs4_server_capabilities(server, fhandle),
3978 struct nfs_server *server)
4004 clp->cl_net, server->port);
4026 static int _nfs4_discover_trunking(struct nfs_server *server,
4032 struct nfs_client *clp = server->nfs_client;
4054 status = nfs4_proc_get_locations(server, fhandle, locations, page,
4061 server);
4073 static int nfs4_discover_trunking(struct nfs_server *server,
4079 struct nfs_client *clp = server->nfs_client;
4085 err = nfs4_handle_exception(server,
4086 _nfs4_discover_trunking(server, fhandle),
4093 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
4101 .server = server,
4119 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4122 static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
4130 err = _nfs4_lookup_root(server, fhandle, info);
4131 trace_nfs4_lookup_root(server, fhandle, info->fattr, err);
4137 err = nfs4_handle_exception(server, err, &exception);
4144 static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
4152 auth = rpcauth_create(&auth_args, server->client);
4155 return nfs4_lookup_root(server, fhandle, info);
4162 * NFSv4.1: the server does not support the SECINFO_NO_NAME operation
4167 static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
4181 if (server->auth_info.flavor_len > 0) {
4183 for (i = 0; i < server->auth_info.flavor_len; i++) {
4184 status = nfs4_lookup_root_sec(server, fhandle, info,
4185 server->auth_info.flavors[i]);
4193 status = nfs4_lookup_root_sec(server, fhandle, info,
4214 * nfs4_proc_get_rootfh - get file handle for server's pseudoroot
4215 * @server: initialized nfs_server handle
4222 int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle,
4229 status = nfs4_lookup_root(server, fhandle, info);
4232 status = server->nfs_client->cl_mvops->find_root_sec(server,
4236 status = nfs4_server_capabilities(server, fhandle);
4238 status = nfs4_do_fsinfo(server, fhandle, info);
4243 static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
4249 error = nfs4_server_capabilities(server, mntfh);
4255 error = nfs4_proc_getattr(server, mntfh, fattr, NULL);
4262 !nfs_fsid_equal(&server->fsid, &fattr->fsid))
4263 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
4301 dprintk("%s: server did not return a different fsid for"
4316 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
4326 .server = server,
4335 if (nfs4_has_session(server->nfs_client))
4339 if (inode && (server->flags & NFS_MOUNT_SOFTREVAL))
4342 nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, fattr->label), inode, 0);
4345 return nfs4_do_call_sync(server->client, server, &msg,
4349 int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
4357 err = _nfs4_proc_getattr(server, fhandle, fattr, inode);
4358 trace_nfs4_getattr(server, fhandle, fattr, err);
4359 err = nfs4_handle_exception(server, err,
4430 struct nfs_server *server = NFS_SERVER(dir);
4433 .bitmask = server->attr_bitmask,
4438 .server = server,
4456 args.bitmask = nfs4_bitmask(server, fattr->label);
4462 status = nfs4_do_call_sync(clnt, server, &msg,
4553 struct nfs_server *server = NFS_SERVER(inode);
4556 .bitmask = server->attr_bitmask,
4560 .server = server,
4574 args.bitmask = nfs4_bitmask(server, fattr->label);
4579 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args,
4604 struct nfs_server *server = NFS_SERVER(inode);
4610 .server = server,
4624 args.bitmask = server->cache_consistency_bitmask;
4626 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4716 struct nfs_server *server = NFS_SERVER(dir);
4728 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
4744 struct nfs_server *server = NFS_SERVER(dir);
4750 .server = server,
4760 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
4819 res->server = NFS_SB(dentry->d_sb);
4846 if (nfs4_async_handle_error(task, res->server, NULL,
4870 res->server = NFS_SB(old_dentry->d_sb);
4890 if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN)
4915 struct nfs_server *server = NFS_SERVER(inode);
4924 .server = server,
4933 res.fattr = nfs_alloc_fattr_with_label(server);
4938 nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, res.fattr->label), inode,
4940 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
4984 struct nfs_server *server = NFS_SERVER(dir);
4986 data->fattr.label = nfs4_label_alloc(server, GFP_KERNEL);
4994 data->arg.server = server;
4998 data->arg.bitmask = nfs4_bitmask(server, data->fattr.label);
5000 data->res.server = server;
5106 struct nfs_server *server = NFS_SERVER(dir);
5115 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
5132 struct nfs_server *server = NFS_SERVER(dir);
5151 if (!(server->caps & NFS_CAP_SECURITY_LABEL))
5152 args.bitmask = server->attr_bitmask_nl;
5154 args.bitmask = server->attr_bitmask;
5158 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args,
5225 struct nfs_server *server = NFS_SERVER(dir);
5234 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
5248 static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
5253 .bitmask = server->attr_bitmask,
5265 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
5268 static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)
5275 err = nfs4_handle_exception(server,
5276 _nfs4_proc_statfs(server, fhandle, fsstat),
5282 static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
5287 .bitmask = server->attr_bitmask,
5298 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
5301 static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
5309 err = _nfs4_do_fsinfo(server, fhandle, fsinfo);
5310 trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err);
5312 nfs4_set_lease_period(server->nfs_client, fsinfo->lease_time * HZ);
5315 err = nfs4_handle_exception(server, err, &exception);
5320 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
5325 error = nfs4_do_fsinfo(server, fhandle, fsinfo);
5328 server->pnfs_blksize = fsinfo->blksize;
5329 set_pnfs_layoutdriver(server, fhandle, fsinfo);
5335 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
5340 .bitmask = server->attr_bitmask,
5358 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
5361 static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
5370 err = nfs4_handle_exception(server,
5371 _nfs4_proc_pathconf(server, fhandle, pathconf),
5416 struct nfs_server *server = NFS_SERVER(hdr->inode);
5426 server, task->tk_status, &exception);
5434 renew_lease(server, hdr->timestamp);
5455 struct nfs_server *server = NFS_SERVER(hdr->inode);
5459 server->caps & NFS_CAP_READ_PLUS && task->tk_status == -ENOTSUPP) {
5460 server->caps &= ~NFS_CAP_READ_PLUS;
5595 struct nfs_server *server = NFS_SERVER(inode);
5622 bitmask[i] &= server->attr_bitmask[i];
5629 struct nfs_server *server = NFS_SERVER(hdr->inode);
5636 server->cache_consistency_bitmask,
5643 hdr->res.server = server;
5648 nfs4_state_protect_write(hdr->ds_clp ? hdr->ds_clp : server->nfs_client, clnt, msg, hdr);
5682 struct nfs_server *server = NFS_SERVER(data->inode);
5686 data->res.server = server;
5689 nfs4_state_protect(data->ds_clp ? data->ds_clp : server->nfs_client,
5697 struct nfs_server *server = NFS_SERVER(dst_inode);
5705 return nfs4_call_sync(server->client, server, &msg,
5819 static bool nfs4_server_supports_acls(const struct nfs_server *server,
5824 return server->attr_bitmask[0] & FATTR4_WORD0_ACL;
5826 return server->attr_bitmask[1] & FATTR4_WORD1_DACL;
5828 return server->attr_bitmask[1] & FATTR4_WORD1_SACL;
5945 * the required buf. On a NULL buf, we send a page of data to the server
5950 * the server, this time with the input buf of the required size.
5972 struct nfs_server *server = NFS_SERVER(inode);
5975 buflen = server->rsize;
6052 struct nfs_server *server = NFS_SERVER(inode);
6055 if (!nfs4_server_supports_acls(server, type))
6073 struct nfs_server *server = NFS_SERVER(inode);
6093 if (!nfs4_server_supports_acls(server, type))
6101 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
6150 struct nfs_server *server = NFS_SERVER(inode);
6163 .server = server,
6174 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0);
6208 struct nfs_server *server = NFS_SERVER(inode);
6213 .server = server,
6219 .server = server,
6230 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
6582 renew_lease(data->res.server, data->timestamp);
6587 nfs4_free_revoked_stateid(data->res.server,
6613 data->res.server, task->tk_status,
6661 nfs4_setup_sequence(d_data->res.server->nfs_client,
6676 struct nfs_server *server = NFS_SERVER(inode);
6683 .rpc_client = server->client,
6697 nfs4_state_protect(server->nfs_client,
6704 server->cache_consistency_bitmask, inode, 0);
6709 data->res.server = server;
6750 struct nfs_server *server = NFS_SERVER(inode);
6762 err = nfs4_handle_exception(server, err, &exception);
6770 struct nfs_server *server = NFS_SERVER(inode);
6771 struct nfs_client *clp = server->nfs_client;
6794 arg.lock_owner.s_dev = server->s_dev;
6795 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
6868 struct nfs_server *server;
6894 p->server = NFS_SERVER(inode);
6923 renew_lease(calldata->server, calldata->timestamp);
6931 nfs4_free_revoked_stateid(calldata->server,
6948 calldata->server, task->tk_status,
6971 if (nfs4_setup_sequence(calldata->server->nfs_client,
7094 struct nfs_server *server;
7103 struct nfs_server *server = NFS_SERVER(inode);
7115 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
7119 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
7121 p->arg.lock_owner.s_dev = server->s_dev;
7124 p->server = server;
7163 if (nfs4_setup_sequence(data->server->nfs_client,
7255 static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error)
7264 nfs4_schedule_stateid_recovery(server, lsp->ls_state);
7268 nfs4_schedule_lease_recovery(server->nfs_client);
7316 nfs4_handle_setlk_error(data->server, data->lsp,
7328 struct nfs_server *server = NFS_SERVER(state->inode);
7341 nfs4_handle_exception(server, err, &exception);
7348 struct nfs_server *server = NFS_SERVER(state->inode);
7370 nfs4_handle_exception(server, err, &exception);
7502 struct nfs_server *server = NFS_SERVER(state->inode);
7503 struct nfs_client *clp = server->nfs_client;
7509 .s_dev = server->s_dev },
7636 struct nfs_server *server = NFS_SERVER(state->inode);
7648 return nfs4_handle_delegation_recall_error(server, state, stateid, fl, err);
7653 struct nfs_server *server;
7662 struct nfs_server *server = data->server;
7663 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
7665 data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
7672 struct nfs_server *server = data->server;
7678 renew_lease(server, data->timestamp);
7682 nfs4_schedule_lease_recovery(server->nfs_client);
7686 if (nfs4_async_handle_error(task, server,
7695 nfs4_free_lock_state(data->server, data->lsp);
7706 nfs4_release_lockowner(struct nfs_server *server, struct nfs4_lock_state *lsp)
7713 if (server->nfs_client->cl_mvops->minor_version != 0)
7720 data->server = server;
7721 data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
7723 data->args.lock_owner.s_dev = server->s_dev;
7728 rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data);
7873 * Just in case the server has other ideas (which RFC 8276 allows),
8005 struct nfs_server *server = NFS_SERVER(dir);
8036 fs_locations->server = server;
8038 status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0);
8063 * This operation also signals the server that this client is
8064 * performing migration recovery. The server can stop returning
8069 static int _nfs40_proc_get_locations(struct nfs_server *server,
8074 struct rpc_clnt *clnt = server->client;
8079 .clientid = server->nfs_client->cl_clientid,
8101 locations->server = server;
8105 status = nfs4_call_sync_sequence(clnt, server, &msg,
8110 renew_lease(server, now);
8117 * This operation also signals the server that this client is
8118 * performing migration recovery. The server can stop asserting
8126 static int _nfs41_proc_get_locations(struct nfs_server *server,
8131 struct rpc_clnt *clnt = server->client;
8152 .seq_server = server,
8159 .callback_ops = server->nfs_client->cl_mvops->call_sync_ops,
8166 locations->server = server;
8181 * @server: pointer to nfs_server to process
8190 * On success, "locations" is filled in, but if the server has
8194 * -NFS4ERR_LEASE_MOVED is returned if the server still has leases
8197 int nfs4_proc_get_locations(struct nfs_server *server,
8202 struct nfs_client *clp = server->nfs_client;
8211 (unsigned long long)server->fsid.major,
8212 (unsigned long long)server->fsid.minor,
8217 status = ops->get_locations(server, fhandle, locations, page,
8221 nfs4_handle_exception(server, status, &exception);
8227 * This operation also signals the server that this client is
8228 * performing "lease moved" recovery. The server can stop
8235 struct nfs_server *server = NFS_SERVER(inode);
8237 struct rpc_clnt *clnt = server->client;
8260 status = nfs4_call_sync_sequence(clnt, server, &msg,
8273 * This operation also signals the server that this client is
8274 * performing "lease moved" recovery. The server can stop asserting
8281 struct nfs_server *server = NFS_SERVER(inode);
8282 struct rpc_clnt *clnt = server->client;
8301 status = nfs4_call_sync_sequence(clnt, server, &msg,
8313 * nfs4_proc_fsid_present - Is this FSID present or absent on server?
8321 * Returns NFS4_OK if the FSID is present on this server,
8323 * NFS4ERR code if some error occurred on the server, or a
8328 struct nfs_server *server = NFS_SERVER(inode);
8329 struct nfs_client *clp = server->nfs_client;
8338 (unsigned long long)server->fsid.major,
8339 (unsigned long long)server->fsid.minor,
8347 nfs4_handle_exception(server, status, &exception);
8442 * Check the exchange flags returned by the server for invalid flags, having
8554 dprintk("NFS: %s: Unexpected direction from server\n",
8622 * Select the state protection mode for client `clp' given the server results
9005 dprintk("NFS: Got error %d from the server %s on "
9192 * So, no point even trying to continue if the server won't
9301 * Issues a CREATE_SESSION operation to the server.
9361 dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
9549 dprintk("%s: failed to reclaim complete error %d for server %s, retrying\n",
9630 struct nfs_server *server = NFS_SERVER(lgp->args.inode);
9632 nfs4_setup_sequence(server->nfs_client, &lgp->args.seq_args,
9648 struct nfs_server *server = NFS_SERVER(inode);
9725 err = nfs4_handle_exception(server, nfs4err, exception);
9736 size_t max_response_pages(struct nfs_server *server)
9738 u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
9761 struct nfs_server *server = NFS_SERVER(inode);
9770 .rpc_client = server->client,
9830 struct nfs_server *server;
9844 server = NFS_SERVER(lrp->args.inode);
9858 if (nfs4_async_handle_error(task, server, NULL, NULL) != -EAGAIN)
9939 _nfs4_proc_getdeviceinfo(struct nfs_server *server,
9959 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
9965 trace_nfs4_getdeviceinfo(server, &pdev->dev_id, status);
9972 int nfs4_proc_getdeviceinfo(struct nfs_server *server,
9980 err = nfs4_handle_exception(server,
9981 _nfs4_proc_getdeviceinfo(server, pdev, cred),
9991 struct nfs_server *server = NFS_SERVER(data->args.inode);
9993 nfs4_setup_sequence(server->nfs_client,
10003 struct nfs_server *server = NFS_SERVER(data->args.inode);
10018 if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) {
10093 _nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
10109 .seq_server = server,
10114 .rpc_client = server->client,
10116 .callback_ops = server->nfs_client->cl_mvops->call_sync_ops,
10124 task_setup.rpc_client = server->nfs_client->cl_rpcclient;
10126 cred = nfs4_get_clid_cred(server->nfs_client);
10140 nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
10152 if (_nfs4_is_integrity_protected(server->nfs_client))
10153 err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
10163 err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
10172 err = nfs4_handle_exception(server, err, &exception);
10180 nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
10197 err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);
10201 * the server doesn't support SECINFO_NO_NAME
10204 err = nfs4_find_root_sec(server, fhandle, info);
10225 if (!nfs_auth_info_match(&server->auth_info, flavor))
10229 err = nfs4_lookup_root_sec(server, fhandle,
10247 static int _nfs41_test_stateid(struct nfs_server *server,
10262 struct rpc_clnt *rpc_client = server->client;
10264 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
10269 status = nfs4_call_sync_sequence(rpc_client, server, &msg,
10279 static void nfs4_handle_delay_or_session_error(struct nfs_server *server,
10286 nfs4_handle_exception(server, err, exception);
10293 nfs4_do_handle_exception(server, err, exception);
10300 * @server: server / transport on which to perform the operation
10304 * Returns NFS_OK if the server recognizes that "stateid" is valid.
10308 static int nfs41_test_stateid(struct nfs_server *server,
10317 err = _nfs41_test_stateid(server, stateid, cred);
10318 nfs4_handle_delay_or_session_error(server, err, &exception);
10324 struct nfs_server *server;
10332 nfs4_setup_sequence(data->server->nfs_client,
10346 if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN)
10354 struct nfs_client *clp = data->server->nfs_client;
10369 * @server: server / transport on which to perform the operation
10376 static int nfs41_free_stateid(struct nfs_server *server,
10386 .rpc_client = server->client,
10393 struct nfs_client *clp = server->nfs_client;
10398 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
10405 data->server = server;
10421 nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
10425 nfs41_free_stateid(server, &lsp->ls_stateid, cred, false);
10426 nfs4_free_lock_state(server, lsp);