Lines Matching defs:server
100 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr, struct nfs4_label *label, struct inode *inode);
117 struct nfs_server *server,
151 static inline u32 *nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)
154 return server->attr_bitmask;
156 return server->attr_bitmask_nl;
167 nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)
168 { return server->attr_bitmask; }
342 * when talking to the server, we always send cookie 0
386 static void nfs4_test_and_free_stateid(struct nfs_server *server,
390 const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
392 ops->test_and_free_expired(server, stateid, cred);
395 static void __nfs4_free_revoked_stateid(struct nfs_server *server,
400 nfs4_test_and_free_stateid(server, stateid, cred);
403 static void nfs4_free_revoked_stateid(struct nfs_server *server,
410 __nfs4_free_revoked_stateid(server, &tmp, cred);
474 static int nfs4_do_handle_exception(struct nfs_server *server,
477 struct nfs_client *clp = server->nfs_client;
525 ret = nfs4_schedule_stateid_recovery(server, state);
534 ret = nfs4_schedule_migration_recovery(server);
562 nfs_inc_server_stats(server, NFSIOS_DELAY);
576 /* The following works around a Linux server bug! */
578 if (server->caps & NFS_CAP_UIDGID_NOMAP) {
579 server->caps &= ~NFS_CAP_UIDGID_NOMAP;
581 printk(KERN_WARNING "NFS: v4 server %s "
585 server->nfs_client->cl_hostname);
598 int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
600 struct nfs_client *clp = server->nfs_client;
603 ret = nfs4_do_handle_exception(server, errorcode, exception);
613 if (test_bit(NFS_MIG_FAILED, &server->mig_status))
625 nfs4_async_handle_exception(struct rpc_task *task, struct nfs_server *server,
628 struct nfs_client *clp = server->nfs_client;
631 ret = nfs4_do_handle_exception(server, errorcode, exception);
644 if (test_bit(NFS_MIG_FAILED, &server->mig_status))
661 nfs4_async_handle_error(struct rpc_task *task, struct nfs_server *server,
672 task->tk_status = nfs4_async_handle_exception(task, server,
700 static void renew_lease(const struct nfs_server *server, unsigned long timestamp)
702 struct nfs_client *clp = server->nfs_client;
766 /* Be nice to the server: try to ensure that the last transmitted
854 * The server may or may not have processed the sequence
861 /* The server detected a resend of the RPC call and
873 * The server thinks we tried to replay a request.
890 * If the server never received the request, then our
892 * if the server did receive the request then it might
895 * to the server on the same slot.
1146 struct nfs_server *server,
1152 struct nfs_client *clp = server->nfs_client;
1154 .seq_server = server,
1170 struct nfs_server *server,
1175 return nfs4_do_call_sync(clnt, server, msg, args, res, 0);
1180 struct nfs_server *server,
1187 return nfs4_call_sync_sequence(clnt, server, msg, args, res);
1257 static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server,
1262 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
1264 server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1;
1282 nfs4_map_atomic_open_share(struct nfs_server *server,
1297 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
1307 nfs4_map_atomic_open_claim(struct nfs_server *server,
1310 if (server->caps & NFS_CAP_ATOMIC_OPEN_V1)
1330 p->o_res.server = p->o_arg.server;
1344 struct nfs_server *server = NFS_SERVER(dir);
1353 p->f_label = nfs4_label_alloc(server, gfp_mask);
1357 p->a_label = nfs4_label_alloc(server, gfp_mask);
1361 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
1372 p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim);
1373 p->o_arg.share_access = nfs4_map_atomic_open_share(server,
1389 /* ask server to check for all possible rights as results
1401 if (server->caps & NFS_CAP_XATTR)
1408 p->o_arg.clientid = server->nfs_client->cl_clientid;
1412 p->o_arg.server = server;
1413 p->o_arg.bitmask = nfs4_bitmask(server, label);
1596 * Note: This function relies heavily on the server implementing
1612 /* The server returned a new stateid */
1702 * in which the server processed them by delaying the
1796 struct nfs_server *server = NFS_SERVER(state->inode);
1797 struct nfs_client *clp = server->nfs_client;
1841 nfs4_test_and_free_stateid(server, &freeme,
1943 pr_err_ratelimited("NFS: Broken NFSv4 server %s is "
2134 struct nfs_server *server = NFS_SB(opendata->dentry->d_sb);
2142 nfs4_map_atomic_open_share(server, fmode, openflags);
2189 * reclaim state on the server after a reboot.
2215 struct nfs_server *server = NFS_SERVER(state->inode);
2221 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
2225 nfs4_handle_exception(server, err, &exception);
2245 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)
2266 nfs4_schedule_lease_recovery(server->nfs_client);
2269 nfs4_schedule_migration_recovery(server);
2272 nfs4_schedule_lease_moved_recovery(server->nfs_client);
2281 nfs4_schedule_stateid_recovery(server, state);
2302 struct nfs_server *server = NFS_SERVER(state->inode);
2329 return nfs4_handle_delegation_recall_error(server, state, stateid, NULL, err);
2336 nfs4_setup_sequence(data->o_arg.server->nfs_client,
2350 renew_lease(data->o_res.server, data->timestamp);
2384 struct nfs_server *server = NFS_SERVER(d_inode(data->dir));
2393 .rpc_client = server->client,
2460 if (nfs4_setup_sequence(data->o_arg.server->nfs_client,
2509 renew_lease(data->o_res.server, data->timestamp);
2547 struct nfs_server *server = NFS_SERVER(dir);
2558 .rpc_client = server->client,
2628 /* access call failed or for some reason the server doesn't
2665 struct nfs_server *server = NFS_SERVER(dir);
2680 nfs_fattr_map_and_free_names(server, &data->f_attr);
2694 server->caps &= ~NFS_CAP_POSIX_LOCK;
2702 nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr,
2710 * reclaim state on the server after a network partition.
2736 struct nfs_server *server = NFS_SERVER(state->inode);
2743 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
2750 nfs4_handle_exception(server, err, &exception);
2792 static int nfs40_test_and_free_expired_stateid(struct nfs_server *server,
2800 static int nfs41_test_and_free_expired_stateid(struct nfs_server *server,
2816 status = nfs41_test_stateid(server, stateid, cred);
2826 /* Ack the revoked state to the server */
2827 nfs41_free_stateid(server, stateid, cred, true);
2833 struct nfs_server *server = NFS_SERVER(state->inode);
2862 status = nfs41_test_and_free_expired_stateid(server, &stateid, cred);
2898 struct nfs_server *server = NFS_SERVER(state->inode);
2914 status = nfs41_test_and_free_expired_stateid(server,
2948 struct nfs_server *server = NFS_SERVER(state->inode);
2955 status = nfs41_test_and_free_expired_stateid(server, stateid, cred);
2987 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
2994 const __u32 *bitmask = opendata->o_arg.server->exclcreat_bitmask;
3031 struct nfs_server *server = sp->so_server;
3052 if (server->caps & NFS_CAP_POSIX_LOCK)
3095 nfs4_schedule_stateid_recovery(server, state);
3120 struct nfs_server *server = NFS_SERVER(dir);
3134 sp = nfs4_get_state_owner(server, cred, GFP_KERNEL);
3139 status = nfs4_client_recover_expired_lease(server->nfs_client);
3153 olabel = nfs4_label_alloc(server, GFP_KERNEL);
3160 if (server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) {
3202 if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server)) {
3230 struct nfs_server *server = NFS_SERVER(dir);
3251 /* NOTE: BAD_SEQID means the server and client disagree about the
3254 * It is actually a sign of a bug on the client or on the server.
3263 pr_warn_ratelimited("NFS: v4 server %s "
3270 * BAD_STATEID on OPEN means that the server cancelled our
3280 nfs4_schedule_lease_recovery(server->nfs_client);
3289 if (nfs4_clear_cap_atomic_open_v1(server, status, &exception))
3291 res = ERR_PTR(nfs4_handle_exception(server,
3303 struct nfs_server *server = NFS_SERVER(inode);
3347 status = nfs4_call_sync(server->client, server, &msg, &arg->seq_args, &res->seq_res, 1);
3351 renew_lease(server, timestamp);
3361 struct nfs_server *server = NFS_SERVER(inode);
3367 .server = server,
3374 .server = server,
3385 nfs4_bitmask(server, olabel),
3392 pr_warn_once("NFSv4: server %s is incorrectly "
3396 server->nfs_client->cl_hostname);
3405 err = nfs4_handle_exception(server, err, &exception);
3488 /* server says we're behind but we haven't seen the update yet */
3552 struct nfs_server *server = NFS_SERVER(calldata->inode);
3576 renew_lease(server, calldata->timestamp);
3595 nfs4_free_revoked_stateid(server,
3605 server, task->tk_status, &exception);
3628 struct nfs_server *server = NFS_SERVER(inode);
3686 server->cache_consistency_bitmask,
3687 inode, server, NULL);
3726 * NFSv4 citizens - we do not indicate to the server to update the file's
3734 struct nfs_server *server = NFS_SERVER(state->inode);
3744 .rpc_client = server->client,
3752 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP,
3765 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
3774 calldata->res.server = server;
3836 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
3838 u32 bitmask[3] = {}, minorversion = server->nfs_client->cl_minorversion;
3860 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3862 /* Sanity check the server answers */
3874 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
3875 server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS|
3883 server->caps |= NFS_CAP_ACLS;
3885 server->caps |= NFS_CAP_HARDLINKS;
3887 server->caps |= NFS_CAP_SYMLINKS;
3889 server->caps |= NFS_CAP_FILEID;
3891 server->caps |= NFS_CAP_MODE;
3893 server->caps |= NFS_CAP_NLINK;
3895 server->caps |= NFS_CAP_OWNER;
3897 server->caps |= NFS_CAP_OWNER_GROUP;
3899 server->caps |= NFS_CAP_ATIME;
3901 server->caps |= NFS_CAP_CTIME;
3903 server->caps |= NFS_CAP_MTIME;
3906 server->caps |= NFS_CAP_SECURITY_LABEL;
3908 memcpy(server->attr_bitmask_nl, res.attr_bitmask,
3909 sizeof(server->attr_bitmask));
3910 server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
3912 memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
3913 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
3914 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
3915 server->cache_consistency_bitmask[2] = 0;
3917 /* Avoid a regression due to buggy server */
3920 memcpy(server->exclcreat_bitmask, res.exclcreat_bitmask,
3921 sizeof(server->exclcreat_bitmask));
3923 server->acl_bitmask = res.acl_bitmask;
3924 server->fh_expire_type = res.fh_expire_type;
3930 int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
3937 err = nfs4_handle_exception(server,
3938 _nfs4_server_capabilities(server, fhandle),
3944 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
3952 .server = server,
3970 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3973 static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
3981 err = _nfs4_lookup_root(server, fhandle, info);
3982 trace_nfs4_lookup_root(server, fhandle, info->fattr, err);
3988 err = nfs4_handle_exception(server, err, &exception);
3995 static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
4003 auth = rpcauth_create(&auth_args, server->client);
4006 return nfs4_lookup_root(server, fhandle, info);
4013 * NFSv4.1: the server does not support the SECINFO_NO_NAME operation
4018 static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
4032 if (server->auth_info.flavor_len > 0) {
4034 for (i = 0; i < server->auth_info.flavor_len; i++) {
4035 status = nfs4_lookup_root_sec(server, fhandle, info,
4036 server->auth_info.flavors[i]);
4044 status = nfs4_lookup_root_sec(server, fhandle, info,
4065 * nfs4_proc_get_rootfh - get file handle for server's pseudoroot
4066 * @server: initialized nfs_server handle
4073 int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle,
4080 status = nfs4_lookup_root(server, fhandle, info);
4083 status = server->nfs_client->cl_mvops->find_root_sec(server,
4087 status = nfs4_server_capabilities(server, fhandle);
4089 status = nfs4_do_fsinfo(server, fhandle, info);
4094 static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
4101 error = nfs4_server_capabilities(server, mntfh);
4107 error = nfs4_proc_getattr(server, mntfh, fattr, label, NULL);
4114 !nfs_fsid_equal(&server->fsid, &fattr->fsid))
4115 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
4151 dprintk("%s: server did not return a different fsid for"
4169 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
4181 .server = server,
4191 if (inode && (server->flags & NFS_MOUNT_SOFTREVAL))
4194 nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, label), inode);
4198 return nfs4_do_call_sync(server->client, server, &msg,
4202 int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
4211 err = _nfs4_proc_getattr(server, fhandle, fattr, label, inode);
4212 trace_nfs4_getattr(server, fhandle, fattr, err);
4213 err = nfs4_handle_exception(server, err,
4290 struct nfs_server *server = NFS_SERVER(dir);
4293 .bitmask = server->attr_bitmask,
4298 .server = server,
4314 args.bitmask = nfs4_bitmask(server, label);
4320 status = nfs4_do_call_sync(clnt, server, &msg,
4413 struct nfs_server *server = NFS_SERVER(inode);
4416 .bitmask = server->attr_bitmask,
4420 .server = server,
4431 args.bitmask = nfs4_bitmask(server, label);
4436 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args,
4460 struct nfs_server *server = NFS_SERVER(inode);
4466 .server = server,
4480 args.bitmask = server->cache_consistency_bitmask;
4482 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4571 struct nfs_server *server = NFS_SERVER(dir);
4583 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
4599 struct nfs_server *server = NFS_SERVER(dir);
4605 .server = server,
4615 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
4674 res->server = NFS_SB(dentry->d_sb);
4699 if (nfs4_async_handle_error(task, res->server, NULL,
4723 res->server = NFS_SB(old_dentry->d_sb);
4743 if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN)
4767 struct nfs_server *server = NFS_SERVER(inode);
4776 .server = server,
4790 res.label = nfs4_label_alloc(server, GFP_KERNEL);
4797 nfs4_bitmap_copy_adjust_setattr(bitmask, nfs4_bitmask(server, res.label), inode);
4799 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
4846 struct nfs_server *server = NFS_SERVER(dir);
4848 data->label = nfs4_label_alloc(server, GFP_KERNEL);
4856 data->arg.server = server;
4860 data->arg.bitmask = nfs4_bitmask(server, data->label);
4862 data->res.server = server;
4968 struct nfs_server *server = NFS_SERVER(dir);
4977 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
4994 struct nfs_server *server = NFS_SERVER(dir);
5014 if (!(server->caps & NFS_CAP_SECURITY_LABEL))
5015 args.bitmask = server->attr_bitmask_nl;
5017 args.bitmask = server->attr_bitmask;
5021 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args,
5089 struct nfs_server *server = NFS_SERVER(dir);
5098 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
5112 static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
5117 .bitmask = server->attr_bitmask,
5129 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
5132 static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)
5139 err = nfs4_handle_exception(server,
5140 _nfs4_proc_statfs(server, fhandle, fsstat),
5146 static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
5151 .bitmask = server->attr_bitmask,
5162 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
5165 static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
5173 err = _nfs4_do_fsinfo(server, fhandle, fsinfo);
5174 trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err);
5176 nfs4_set_lease_period(server->nfs_client, fsinfo->lease_time * HZ);
5179 err = nfs4_handle_exception(server, err, &exception);
5184 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
5189 error = nfs4_do_fsinfo(server, fhandle, fsinfo);
5192 server->pnfs_blksize = fsinfo->blksize;
5193 set_pnfs_layoutdriver(server, fhandle, fsinfo);
5199 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
5204 .bitmask = server->attr_bitmask,
5222 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
5225 static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
5234 err = nfs4_handle_exception(server,
5235 _nfs4_proc_pathconf(server, fhandle, pathconf),
5280 struct nfs_server *server = NFS_SERVER(hdr->inode);
5290 server, task->tk_status, &exception);
5298 renew_lease(server, hdr->timestamp);
5319 struct nfs_server *server = NFS_SERVER(hdr->inode);
5323 server->caps & NFS_CAP_READ_PLUS && task->tk_status == -ENOTSUPP) {
5324 server->caps &= ~NFS_CAP_READ_PLUS;
5349 static void nfs42_read_plus_support(struct nfs_server *server, struct rpc_message *msg)
5351 if (server->caps & NFS_CAP_READ_PLUS)
5357 static void nfs42_read_plus_support(struct nfs_server *server, struct rpc_message *msg)
5454 struct inode *inode, struct nfs_server *server,
5487 bitmask[i] &= server->attr_bitmask[i];
5494 struct nfs_server *server = NFS_SERVER(hdr->inode);
5501 server->cache_consistency_bitmask,
5502 hdr->inode, server, NULL);
5508 hdr->res.server = server;
5513 nfs4_state_protect_write(hdr->ds_clp ? hdr->ds_clp : server->nfs_client, clnt, msg, hdr);
5547 struct nfs_server *server = NFS_SERVER(data->inode);
5551 data->res.server = server;
5554 nfs4_state_protect(data->ds_clp ? data->ds_clp : server->nfs_client,
5562 struct nfs_server *server = NFS_SERVER(dst_inode);
5570 return nfs4_call_sync(server->client, server, &msg,
5684 static inline int nfs4_server_supports_acls(struct nfs_server *server)
5686 return server->caps & NFS_CAP_ACLS;
5795 * the required buf. On a NULL buf, we send a page of data to the server
5800 * the server, this time with the input buf of the required size.
5819 struct nfs_server *server = NFS_SERVER(inode);
5822 buflen = server->rsize;
5896 struct nfs_server *server = NFS_SERVER(inode);
5899 if (!nfs4_server_supports_acls(server))
5901 ret = nfs_revalidate_inode(server, inode);
5916 struct nfs_server *server = NFS_SERVER(inode);
5935 if (!nfs4_server_supports_acls(server))
5943 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
5991 struct nfs_server *server = NFS_SERVER(inode);
6003 .server = server,
6014 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0);
6049 struct nfs_server *server = NFS_SERVER(inode);
6054 .server = server,
6061 .server = server,
6072 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
6437 renew_lease(data->res.server, data->timestamp);
6442 nfs4_free_revoked_stateid(data->res.server,
6468 data->res.server, task->tk_status,
6516 nfs4_setup_sequence(d_data->res.server->nfs_client,
6531 struct nfs_server *server = NFS_SERVER(inode);
6538 .rpc_client = server->client,
6549 nfs4_state_protect(server->nfs_client,
6556 server->cache_consistency_bitmask, inode, server,
6562 data->res.server = server;
6603 struct nfs_server *server = NFS_SERVER(inode);
6615 err = nfs4_handle_exception(server, err, &exception);
6623 struct nfs_server *server = NFS_SERVER(inode);
6624 struct nfs_client *clp = server->nfs_client;
6647 arg.lock_owner.s_dev = server->s_dev;
6648 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
6721 struct nfs_server *server;
6747 p->server = NFS_SERVER(inode);
6776 renew_lease(calldata->server, calldata->timestamp);
6784 nfs4_free_revoked_stateid(calldata->server,
6801 calldata->server, task->tk_status,
6824 if (nfs4_setup_sequence(calldata->server->nfs_client,
6941 struct nfs_server *server;
6950 struct nfs_server *server = NFS_SERVER(inode);
6962 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
6966 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
6968 p->arg.lock_owner.s_dev = server->s_dev;
6971 p->server = server;
7011 if (nfs4_setup_sequence(data->server->nfs_client,
7029 struct nfs_server *server = NFS_SERVER(d_inode(data->ctx->dentry));
7039 renew_lease(server, data->timestamp);
7067 else if (nfs4_async_handle_error(task, server, lsp->ls_state, NULL) == -EAGAIN)
7109 static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error)
7118 nfs4_schedule_stateid_recovery(server, lsp->ls_state);
7122 nfs4_schedule_lease_recovery(server->nfs_client);
7168 nfs4_handle_setlk_error(data->server, data->lsp,
7180 struct nfs_server *server = NFS_SERVER(state->inode);
7193 nfs4_handle_exception(server, err, &exception);
7200 struct nfs_server *server = NFS_SERVER(state->inode);
7222 nfs4_handle_exception(server, err, &exception);
7360 struct nfs_server *server = NFS_SERVER(state->inode);
7361 struct nfs_client *clp = server->nfs_client;
7365 .s_dev = server->s_dev };
7460 struct nfs_server *server = NFS_SERVER(state->inode);
7472 return nfs4_handle_delegation_recall_error(server, state, stateid, fl, err);
7477 struct nfs_server *server;
7486 struct nfs_server *server = data->server;
7487 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
7489 data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
7496 struct nfs_server *server = data->server;
7502 renew_lease(server, data->timestamp);
7506 nfs4_schedule_lease_recovery(server->nfs_client);
7510 if (nfs4_async_handle_error(task, server,
7519 nfs4_free_lock_state(data->server, data->lsp);
7530 nfs4_release_lockowner(struct nfs_server *server, struct nfs4_lock_state *lsp)
7537 if (server->nfs_client->cl_mvops->minor_version != 0)
7544 data->server = server;
7545 data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
7547 data->args.lock_owner.s_dev = server->s_dev;
7552 rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data);
7645 * Just in case the server has other ideas (which RFC 8276 allows),
7777 struct nfs_server *server = NFS_SERVER(dir);
7808 fs_locations->server = server;
7810 status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0);
7835 * This operation also signals the server that this client is
7836 * performing migration recovery. The server can stop returning
7845 struct nfs_server *server = NFS_SERVER(inode);
7846 struct rpc_clnt *clnt = server->client;
7851 .clientid = server->nfs_client->cl_clientid,
7873 locations->server = server;
7877 status = nfs4_call_sync_sequence(clnt, server, &msg,
7882 renew_lease(server, now);
7889 * This operation also signals the server that this client is
7890 * performing migration recovery. The server can stop asserting
7902 struct nfs_server *server = NFS_SERVER(inode);
7903 struct rpc_clnt *clnt = server->client;
7926 locations->server = server;
7930 status = nfs4_call_sync_sequence(clnt, server, &msg,
7950 * On success, "locations" is filled in, but if the server has
7954 * -NFS4ERR_LEASE_MOVED is returned if the server still has leases
7961 struct nfs_server *server = NFS_SERVER(inode);
7962 struct nfs_client *clp = server->nfs_client;
7971 (unsigned long long)server->fsid.major,
7972 (unsigned long long)server->fsid.minor,
7980 nfs4_handle_exception(server, status, &exception);
7986 * This operation also signals the server that this client is
7987 * performing "lease moved" recovery. The server can stop
7994 struct nfs_server *server = NFS_SERVER(inode);
7996 struct rpc_clnt *clnt = server->client;
8019 status = nfs4_call_sync_sequence(clnt, server, &msg,
8032 * This operation also signals the server that this client is
8033 * performing "lease moved" recovery. The server can stop asserting
8040 struct nfs_server *server = NFS_SERVER(inode);
8041 struct rpc_clnt *clnt = server->client;
8060 status = nfs4_call_sync_sequence(clnt, server, &msg,
8072 * nfs4_proc_fsid_present - Is this FSID present or absent on server?
8080 * Returns NFS4_OK if the FSID is present on this server,
8082 * NFS4ERR code if some error occurred on the server, or a
8087 struct nfs_server *server = NFS_SERVER(inode);
8088 struct nfs_client *clp = server->nfs_client;
8097 (unsigned long long)server->fsid.major,
8098 (unsigned long long)server->fsid.minor,
8106 nfs4_handle_exception(server, status, &exception);
8201 * Check the exchange flags returned by the server for invalid flags, having
8313 dprintk("NFS: %s: Unexpected direction from server\n",
8381 * Select the state protection mode for client `clp' given the server results
8752 dprintk("NFS: Got error %d from the server %s on "
8944 * So, no point even trying to continue if the server won't
9053 * Issues a CREATE_SESSION operation to the server.
9108 dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
9299 dprintk("%s: failed to reclaim complete error %d for server %s, retrying\n",
9383 struct nfs_server *server = NFS_SERVER(lgp->args.inode);
9386 nfs4_setup_sequence(server->nfs_client, &lgp->args.seq_args,
9405 struct nfs_server *server = NFS_SERVER(inode);
9480 err = nfs4_handle_exception(server, nfs4err, exception);
9492 size_t max_response_pages(struct nfs_server *server)
9494 u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
9518 struct nfs_server *server = NFS_SERVER(inode);
9527 .rpc_client = server->client,
9592 struct nfs_server *server;
9608 server = NFS_SERVER(lrp->args.inode);
9622 if (nfs4_async_handle_error(task, server, NULL, NULL) != -EAGAIN)
9706 _nfs4_proc_getdeviceinfo(struct nfs_server *server,
9727 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
9738 int nfs4_proc_getdeviceinfo(struct nfs_server *server,
9746 err = nfs4_handle_exception(server,
9747 _nfs4_proc_getdeviceinfo(server, pdev, cred),
9757 struct nfs_server *server = NFS_SERVER(data->args.inode);
9759 nfs4_setup_sequence(server->nfs_client,
9769 struct nfs_server *server = NFS_SERVER(data->args.inode);
9783 if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) {
9857 _nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
9873 .seq_server = server,
9878 .rpc_client = server->client,
9880 .callback_ops = server->nfs_client->cl_mvops->call_sync_ops,
9888 task_setup.rpc_client = server->nfs_client->cl_rpcclient;
9890 cred = nfs4_get_clid_cred(server->nfs_client);
9905 nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
9917 if (_nfs4_is_integrity_protected(server->nfs_client))
9918 err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
9928 err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
9937 err = nfs4_handle_exception(server, err, &exception);
9945 nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
9962 err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);
9966 * the server doesn't support SECINFO_NO_NAME
9969 err = nfs4_find_root_sec(server, fhandle, info);
9990 if (!nfs_auth_info_match(&server->auth_info, flavor))
9994 err = nfs4_lookup_root_sec(server, fhandle,
10012 static int _nfs41_test_stateid(struct nfs_server *server,
10027 struct rpc_clnt *rpc_client = server->client;
10029 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
10034 status = nfs4_call_sync_sequence(rpc_client, server, &msg,
10044 static void nfs4_handle_delay_or_session_error(struct nfs_server *server,
10051 nfs4_handle_exception(server, err, exception);
10058 nfs4_do_handle_exception(server, err, exception);
10065 * @server: server / transport on which to perform the operation
10069 * Returns NFS_OK if the server recognizes that "stateid" is valid.
10073 static int nfs41_test_stateid(struct nfs_server *server,
10082 err = _nfs41_test_stateid(server, stateid, cred);
10083 nfs4_handle_delay_or_session_error(server, err, &exception);
10089 struct nfs_server *server;
10097 nfs4_setup_sequence(data->server->nfs_client,
10111 if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN)
10130 * @server: server / transport on which to perform the operation
10137 static int nfs41_free_stateid(struct nfs_server *server,
10147 .rpc_client = server->client,
10155 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
10162 data->server = server;
10178 nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
10182 nfs41_free_stateid(server, &lsp->ls_stateid, cred, false);
10183 nfs4_free_lock_state(server, lsp);