nfs_client
nfs4_delete_deviceid(node->ld, node->nfs_client, id);
struct net *net = server->nfs_client->cl_net;
check_gss_callback_principal(struct nfs_client *clp, struct svc_rqst *rqstp)
extern int check_gss_callback_principal(struct nfs_client *, struct svc_rqst *);
struct nfs_client *clp;
static struct inode *nfs_layout_find_inode_by_stateid(struct nfs_client *clp,
static struct inode *nfs_layout_find_inode_by_fh(struct nfs_client *clp,
static struct inode *nfs_layout_find_inode(struct nfs_client *clp,
static u32 initiate_file_draining(struct nfs_client *clp,
static u32 initiate_bulk_draining(struct nfs_client *clp,
static u32 do_callback_layoutrecall(struct nfs_client *clp,
static void pnfs_recall_all_layouts(struct nfs_client *clp,
static int referring_call_exists(struct nfs_client *clp,
struct nfs_client *clp;
struct nfs_client *clp = server->nfs_client;
struct nfs_client *clp = server->nfs_client;
nfs_put_client(server->nfs_client);
if (server->nfs_client->rpc_ops->version == 3) {
server->nfs_client = source->nfs_client;
refcount_inc(&server->nfs_client->cl_count);
server->nfs_client->cl_rpcclient, "_state");
struct nfs_client *clp;
clp = list_entry(v, struct nfs_client, cl_share_link);
struct nfs_client *clp;
clp = server->nfs_client;
struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *cl_init)
struct nfs_client *clp;
static void nfs_cb_idr_remove_locked(struct nfs_client *clp)
static void nfs_cb_idr_remove_locked(struct nfs_client *clp)
void nfs_free_client(struct nfs_client *clp)
void nfs_put_client(struct nfs_client *clp)
static struct nfs_client *nfs_match_client(const struct nfs_client_initdata *data)
struct nfs_client *clp;
bool nfs_client_init_is_complete(const struct nfs_client *clp)
int nfs_client_init_status(const struct nfs_client *clp)
int nfs_wait_client_init_complete(const struct nfs_client *clp)
static struct nfs_client *
struct nfs_client *clp)
struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_init)
struct nfs_client *clp, *new = NULL;
void nfs_mark_client_ready(struct nfs_client *clp, int state)
int nfs_create_rpc_client(struct nfs_client *clp,
struct nfs_client *clp = server->nfs_client;
struct nfs_client *clp = server->nfs_client;
struct nfs_client *nfs_init_client(struct nfs_client *clp,
server->caps = server->nfs_client->cl_mvops->init_caps;
if (server->nfs_client->cl_proto == XPRT_TRANSPORT_RDMA)
switch (server->nfs_client->rpc_ops->version) {
struct nfs_client *clp;
server->nfs_client = clp;
server->nfs_client = NULL;
struct nfs_client *clp = server->nfs_client;
struct nfs_client *clp = server->nfs_client;
void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags)
set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
struct nfs_client *clp = server->nfs_client;
struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
void nfs_delegation_mark_reclaim(struct nfs_client *clp)
void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
static inline bool nfs4_server_rebooted(const struct nfs_client *clp)
set_bit(NFS4CLNT_DELEGATION_EXPIRED, &server->nfs_client->cl_state);
void nfs_mark_test_expired_all_delegations(struct nfs_client *clp)
void nfs_test_expired_all_delegations(struct nfs_client *clp)
const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
if (!nfs4_server_rebooted(server->nfs_client)) {
&server->nfs_client->cl_state);
void nfs_reap_expired_delegations(struct nfs_client *clp)
struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
int nfs_delegations_present(struct nfs_client *clp)
struct nfs_client *clp)
struct nfs_client *clp = server->nfs_client;
struct nfs_client *clp = server->nfs_client;
err = nfs4_wait_clnt_recover(server->nfs_client);
set_bit(NFS4CLNT_DELEGRETURN_DELAYED, &server->nfs_client->cl_state);
set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
nfs4_schedule_state_manager(server->nfs_client);
static bool nfs_client_clear_delayed_delegations(struct nfs_client *clp)
int nfs_client_return_marked_delegations(struct nfs_client *clp)
if (!nfs4_has_session(NFS_SERVER(inode)->nfs_client) ||
static void nfs_delegation_run_state_manager(struct nfs_client *clp)
void nfs_expire_all_delegations(struct nfs_client *clp)
struct nfs_client *clp = server->nfs_client;
struct inode *nfs_delegation_find_inode(struct nfs_client *clp, const struct nfs_fh *fhandle);
void nfs_expire_all_delegations(struct nfs_client *clp);
void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags);
void nfs_expire_unreferenced_delegations(struct nfs_client *clp);
int nfs_client_return_marked_delegations(struct nfs_client *clp);
int nfs_delegations_present(struct nfs_client *clp);
void nfs_delegation_mark_reclaim(struct nfs_client *clp);
void nfs_delegation_reap_unclaimed(struct nfs_client *clp);
void nfs_mark_test_expired_all_delegations(struct nfs_client *clp);
void nfs_test_expired_all_delegations(struct nfs_client *clp);
void nfs_reap_expired_delegations(struct nfs_client *clp);
error = server->nfs_client->rpc_ops->getattr(server, fhandle,
rpc_ops = NFS_SB(sb)->nfs_client->rpc_ops;
struct nfs_rpc_ops const *ops = server->nfs_client->rpc_ops;
struct nfs_client *cl = NFS_SERVER(inode)->nfs_client;
struct nfs_client *cl = NFS_SERVER(inode)->nfs_client;
struct nfs_client *clp,
s->nfs_client->cl_minorversion);
struct net *net = server->nfs_client->cl_net;
struct nfs_client *clp,
nfs4_delete_deviceid(devid->ld, devid->nfs_client,
struct nfs_client *clp,
nfs4_delete_deviceid(devid->ld, devid->nfs_client,
struct nfs_client *clp,
struct nfs_client *clp, const struct cred *cred,
struct nfs_client *ds_clp;
struct nfs_client *ds_clp,
server->nfs_client->cl_proto);
server->nfs_client->cl_proto);
struct nfs_client *ds_clp, struct inode *inode,
struct net *net = server->nfs_client->cl_net;
struct net *net = nfss->nfs_client->cl_net;
ctx->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
ctx->version = nfss->nfs_client->rpc_ops->version;
ctx->minorversion = nfss->nfs_client->cl_minorversion;
memcpy(&ctx->nfs_server._address, &nfss->nfs_client->cl_addr,
ctx->nfs_mod = nfss->nfs_client->cl_nfs_mod;
if (!nfs_fscache_get_client_key(nfss->nfs_client, key, &len) ||
static bool nfs_fscache_get_client_key(struct nfs_client *clp,
if (NFS_SERVER(inode)->nfs_client->rpc_ops->version == 4)
error = server->nfs_client->rpc_ops->getroot(server, ctx->mntfh, &fsinfo);
NFS_SERVER(inode)->nfs_client->cl_hostname,
inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops;
inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
extern struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *);
int nfs_create_rpc_client(struct nfs_client *, const struct nfs_client_initdata *, rpc_authflavor_t);
struct nfs_client *nfs_get_client(const struct nfs_client_initdata *);
extern void nfs_put_client(struct nfs_client *);
extern void nfs_free_client(struct nfs_client *);
extern struct nfs_client *nfs4_find_client_ident(struct net *, int);
extern struct nfs_client *
extern bool nfs_client_init_is_complete(const struct nfs_client *clp);
extern int nfs_client_init_status(const struct nfs_client *clp);
extern int nfs_wait_client_init_complete(const struct nfs_client *clp);
extern void nfs_mark_client_ready(struct nfs_client *clp, int state);
extern struct nfs_client *nfs4_set_ds_client(struct nfs_server *mds_srv,
extern struct rpc_clnt *nfs4_find_or_create_ds_client(struct nfs_client *,
extern struct nfs_client *nfs3_set_ds_client(struct nfs_server *mds_srv,
extern struct nfs_client *nfs_init_client(struct nfs_client *clp,
extern void nfs_local_probe_async(struct nfs_client *);
extern struct nfsd_file *nfs_local_open_fh(struct nfs_client *,
extern int nfs_local_doio(struct nfs_client *,
extern bool nfs_server_is_local(const struct nfs_client *clp);
static inline void nfs_local_probe(struct nfs_client *clp) {}
static inline void nfs_local_probe_async(struct nfs_client *clp) {}
nfs_local_open_fh(struct nfs_client *clp, const struct cred *cred,
static inline int nfs_local_doio(struct nfs_client *clp,
static inline bool nfs_server_is_local(const struct nfs_client *clp)
extern int nfs_client_for_each_server(struct nfs_client *clp,
extern struct nfs_client *nfs4_init_client(struct nfs_client *clp,
extern int nfs41_walk_client_list(struct nfs_client *clp,
struct nfs_client **result,
static struct rpc_clnt *nfs_init_localioclient(struct nfs_client *clp)
static bool nfs_server_uuid_is_local(struct nfs_client *clp)
static void nfs_local_probe(struct nfs_client *clp)
struct nfs_client *clp =
container_of(work, struct nfs_client, cl_local_probe_work);
void nfs_local_probe_async(struct nfs_client *clp)
__nfs_local_open_fh(struct nfs_client *clp, const struct cred *cred,
nfs_local_open_fh(struct nfs_client *clp, const struct cred *cred,
static inline bool nfs_client_is_local(const struct nfs_client *clp)
bool nfs_server_is_local(const struct nfs_client *clp)
struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
int nfs_local_doio(struct nfs_client *clp, struct nfsd_file *localio,
struct nfs_client *client = server->nfs_client;
err = server->nfs_client->rpc_ops->lookup(d_inode(parent), dentry, &dentry->d_name,
struct nfs_netns_client *nfs_client;
struct nfs_client *clp;
struct nfs_client *nfs3_set_ds_client(struct nfs_server *mds_srv,
struct nfs_client *mds_clp = mds_srv->nfs_client;
if (status && server->nfs_client->cl_rpcclient != server->client)
status = do_proc_fsinfo(server->nfs_client->cl_rpcclient, fhandle, info);
struct nfs_client *clp = server->nfs_client;
if (status && server->nfs_client->cl_rpcclient != server->client)
status = do_proc_get_root(server->nfs_client->cl_rpcclient, fhandle, info);
int nfs40_discover_server_trunking(struct nfs_client *clp,
struct nfs_client **result,
void nfs40_shutdown_client(struct nfs_client *);
int nfs40_init_client(struct nfs_client *);
void nfs40_handle_cb_pathdown(struct nfs_client *clp);
void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
static int nfs40_walk_client_list(struct nfs_client *new,
struct nfs_client **result,
struct nfs_client *pos, *prev = NULL;
static void nfs4_swap_callback_idents(struct nfs_client *keep,
int nfs40_discover_server_trunking(struct nfs_client *clp,
struct nfs_client **result,
struct nfs_client *drop)
void nfs40_shutdown_client(struct nfs_client *clp)
int nfs40_init_client(struct nfs_client *clp)
void nfs40_handle_cb_pathdown(struct nfs_client *clp)
static int nfs4_proc_async_renew(struct nfs_client *clp, const struct cred *cred, unsigned renew_flags)
static int nfs4_proc_renew(struct nfs_client *clp, const struct cred *cred)
nfs4_setup_sequence(data->seq_server->nfs_client,
struct nfs_client *clp = server->nfs_client;
struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
nfs4_schedule_lease_recovery(server->nfs_client);
struct nfs_client *clp = server->nfs_client;
struct nfs_client *client;
struct nfs_client *clp = data->client;
struct nfs_client *clp = data->client;
struct nfs_client *c_in = (NFS_SERVER(file_inode(in)))->nfs_client;
struct nfs_client *c_out = (NFS_SERVER(file_inode(out)))->nfs_client;
nfs4_init_sequence(server->nfs_client, &data->args.seq_args,
nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
nfs4_init_sequence(server->nfs_client, &data->args.seq_args,
spin_lock(&dst_server->nfs_client->cl_lock);
spin_unlock(&dst_server->nfs_client->cl_lock);
spin_lock(&src_server->nfs_client->cl_lock);
spin_unlock(&src_server->nfs_client->cl_lock);
struct nfs_client *clp = dst_server->nfs_client;
spin_lock(&dst_server->nfs_client->cl_lock);
&dst_server->nfs_client->pending_cb_stateids,
spin_unlock(&dst_server->nfs_client->cl_lock);
spin_unlock(&dst_server->nfs_client->cl_lock);
spin_lock(&src_server->nfs_client->cl_lock);
spin_unlock(&src_server->nfs_client->cl_lock);
struct nfs_client *clp = (NFS_SERVER(file_inode(filep)))->nfs_client;
nfs4_setup_sequence(data->seq_server->nfs_client,
nfs4_init_sequence(dst_server->nfs_client, &data->args.osa_seq_args,
nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
int (*establish_clid)(struct nfs_client *, const struct cred *);
int (*reclaim_complete)(struct nfs_client *, const struct cred *);
int (*detect_trunking)(struct nfs_client *, struct nfs_client **,
struct nfs_client *clp;
int (*sched_state_renewal)(struct nfs_client *, const struct cred *, unsigned);
const struct cred * (*get_state_renewal_cred)(struct nfs_client *);
int (*renew_lease)(struct nfs_client *, const struct cred *);
int nfs4_match_client(struct nfs_client *pos, struct nfs_client *new,
struct nfs_client **prev, struct nfs_net *nn);
extern void nfs4_init_sequence(struct nfs_client *clp, struct nfs4_sequence_args *,
extern int nfs4_proc_setclientid(struct nfs_client *, u32, unsigned short, const struct cred *, struct nfs4_setclientid_res *);
extern int nfs4_proc_setclientid_confirm(struct nfs_client *, struct nfs4_setclientid_res *arg, const struct cred *);
extern int nfs4_proc_bind_conn_to_session(struct nfs_client *, const struct cred *cred);
extern int nfs4_proc_exchange_id(struct nfs_client *clp, const struct cred *cred);
extern int nfs4_destroy_clientid(struct nfs_client *clp);
extern int nfs4_init_clientid(struct nfs_client *, const struct cred *);
extern int nfs41_init_clientid(struct nfs_client *, const struct cred *);
extern int nfs4_proc_get_lease_time(struct nfs_client *clp,
extern void do_renew_lease(struct nfs_client *clp, unsigned long timestamp);
extern int nfs4_proc_create_session(struct nfs_client *, const struct cred *);
extern int nfs4_detect_session_trunking(struct nfs_client *clp,
is_ds_only_client(struct nfs_client *clp)
is_ds_client(struct nfs_client *clp)
_nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
nfs4_state_protect_write(struct nfs_client *clp, struct rpc_clnt **clntp,
void nfs41_shutdown_client(struct nfs_client *);
int nfs41_init_client(struct nfs_client *);
void nfs4_free_client(struct nfs_client *);
struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *);
extern void nfs4_schedule_state_renewal(struct nfs_client *);
extern void nfs4_kill_renewd(struct nfs_client *);
extern void nfs4_set_lease_period(struct nfs_client *clp, u32 period);
const struct cred *nfs4_get_clid_cred(struct nfs_client *clp);
const struct cred *nfs4_get_machine_cred(struct nfs_client *clp);
const struct cred *nfs4_get_renew_cred(struct nfs_client *clp);
int nfs4_discover_server_trunking(struct nfs_client *clp,
struct nfs_client **);
int nfs40_discover_server_trunking(struct nfs_client *clp,
struct nfs_client **, const struct cred *);
int nfs41_discover_server_trunking(struct nfs_client *clp,
struct nfs_client **, const struct cred *);
extern void nfs41_notify_server(struct nfs_client *);
extern int nfs4_state_mark_reclaim_nograce(struct nfs_client *, struct nfs4_state *);
extern void nfs4_schedule_lease_recovery(struct nfs_client *);
extern int nfs4_wait_clnt_recover(struct nfs_client *clp);
extern int nfs4_client_recover_expired_lease(struct nfs_client *clp);
extern void nfs4_schedule_state_manager(struct nfs_client *);
extern void nfs4_schedule_path_down_recovery(struct nfs_client *clp);
extern void nfs4_schedule_lease_moved_recovery(struct nfs_client *);
extern void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags, bool);
extern void nfs41_handle_server_scope(struct nfs_client *,
extern int nfs4_setup_sequence(struct nfs_client *client,
int (*init_client)(struct nfs_client *);
void (*shutdown_client)(struct nfs_client *);
nfs_io_size(ctx->rsize, server->nfs_client->cl_proto);
nfs_io_size(ctx->wsize, server->nfs_client->cl_proto);
struct nfs_client *parent_client = parent_server->nfs_client;
struct nfs_client *clp = server->nfs_client;
if (server->nfs_client->cl_hostname == NULL) {
server->nfs_client->cl_hostname = kstrdup(hostname, GFP_KERNEL);
if (server->nfs_client->cl_hostname == NULL)
nfs4_find_or_create_ds_client(struct nfs_client *ds_clp, struct inode *inode)
nfs4_shutdown_ds_clients(struct nfs_client *clp)
nfs4_cleanup_callback(struct nfs_client *clp)
void nfs41_shutdown_client(struct nfs_client *clp)
struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *cl_init)
struct nfs_client *clp = nfs_alloc_client(cl_init);
static void nfs4_destroy_callback(struct nfs_client *clp)
static void nfs4_shutdown_client(struct nfs_client *clp)
void nfs4_free_client(struct nfs_client *clp)
static int nfs_get_cb_ident_idr(struct nfs_client *clp, int minorversion)
static int nfs4_init_callback(struct nfs_client *clp)
int nfs41_init_client(struct nfs_client *clp)
static int nfs4_init_client_minor_version(struct nfs_client *clp)
static void nfs4_add_trunk(struct nfs_client *clp, struct nfs_client *old)
struct nfs_client *nfs4_init_client(struct nfs_client *clp,
struct nfs_client *old;
static bool nfs4_match_client_owner_id(const struct nfs_client *clp1,
const struct nfs_client *clp2)
int nfs4_match_client(struct nfs_client *pos, struct nfs_client *new,
struct nfs_client **prev, struct nfs_net *nn)
int nfs4_detect_session_trunking(struct nfs_client *clp,
int nfs41_walk_client_list(struct nfs_client *new,
struct nfs_client **result,
struct nfs_client *pos, *prev = NULL;
nfs4_find_ds_client(struct nfs_client *ds_clp, rpc_authflavor_t flavor)
struct nfs_client *
struct nfs_client *clp;
struct nfs_client *clp, u32 minorversion)
struct nfs_client *
struct nfs_client *clp;
struct nfs_client *clp;
if (server->nfs_client == clp) {
server->nfs_client = clp;
nfs4_add_ds_client(struct nfs_client *ds_clp, rpc_authflavor_t flavor,
struct nfs_client *nfs4_set_ds_client(struct nfs_server *mds_srv,
struct nfs_client *mds_clp = mds_srv->nfs_client;
if (mds_srv->nfs_client->cl_xprtsec.policy != RPC_XPRTSEC_NONE)
cl_init.xprtsec = mds_srv->nfs_client->cl_xprtsec;
if (!nfs4_has_session(server->nfs_client))
sess = server->nfs_client->cl_session;
if (!nfs4_has_session(server->nfs_client))
sess = server->nfs_client->cl_session;
if (is_ds_only_client(server->nfs_client))
error = nfs4_init_session(server->nfs_client);
nfs4_alloc_ds_server(struct nfs_client *ds_clp, rpc_authflavor_t flavor)
nfs_idmap_new(struct nfs_client *clp)
nfs_idmap_delete(struct nfs_client *clp)
struct idmap *idmap = server->nfs_client->cl_idmap;
struct idmap *idmap = server->nfs_client->cl_idmap;
struct idmap *idmap = server->nfs_client->cl_idmap;
struct idmap *idmap = server->nfs_client->cl_idmap;
struct nfs_client;
int nfs_idmap_new(struct nfs_client *);
void nfs_idmap_delete(struct nfs_client *);
nfs4_setup_sequence(data->seq_server->nfs_client,
nfs4_init_sequence(NFS_SERVER(data->args.inode)->nfs_client,
struct nfs_client *clp = server->nfs_client;
if (_nfs4_is_integrity_protected(server->nfs_client))
static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
struct nfs_client *clp = server->nfs_client;
nfs4_setup_sequence(data->server->nfs_client,
struct nfs_client *clp = data->server->nfs_client;
struct nfs_client *clp = server->nfs_client;
struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
int nfs4_setup_sequence(struct nfs_client *client,
struct nfs_client *clp = server->nfs_client;
nfs4_init_sequence(server->nfs_client, args, res, cache_reply, 0);
alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
p->o_arg.clientid = server->nfs_client->cl_clientid;
struct nfs_client *clp = state->owner->so_server->nfs_client;
nfs4_schedule_state_manager(state->owner->so_server->nfs_client);
if (!nfs4_has_session(NFS_SERVER(state->inode)->nfs_client))
struct nfs_client *clp = server->nfs_client;
NFS_SERVER(inode)->nfs_client->cl_hostname);
nfs4_schedule_lease_recovery(server->nfs_client);
nfs4_schedule_lease_moved_recovery(server->nfs_client);
nfs4_setup_sequence(data->o_arg.server->nfs_client,
nfs4_init_sequence(server->nfs_client, &data->c_arg.seq_args,
struct nfs_client *clp = sp->so_server->nfs_client;
if (nfs4_setup_sequence(data->o_arg.server->nfs_client,
struct nfs_client *clp = server->nfs_client;
status = nfs4_client_recover_expired_lease(server->nfs_client);
NFS_SERVER(dir)->nfs_client->cl_hostname);
nfs4_schedule_lease_recovery(server->nfs_client);
server->nfs_client->cl_hostname);
if (nfs4_setup_sequence(NFS_SERVER(inode)->nfs_client,
struct nfs_client *clp = server->nfs_client;
u32 minorversion = server->nfs_client->cl_minorversion;
struct nfs_client *clp,
struct nfs_client *clp = server->nfs_client;
const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
struct nfs_client *clp = server->nfs_client;
status = server->nfs_client->cl_mvops->find_root_sec(
nfs4_setup_sequence(data->seq_server->nfs_client, data->seq_args,
struct nfs_client *clp = server->nfs_client;
nfs4_init_sequence(server->nfs_client, &args.seq_args, &res.seq_res, 0, 0);
nfs4_init_sequence(server->nfs_client, &args.seq_args, &res.seq_res, 0, 0);
nfs4_init_sequence(server->nfs_client, &args->seq_args,
nfs4_setup_sequence(NFS_SB(data->dentry->d_sb)->nfs_client,
nfs4_init_sequence(server->nfs_client, &arg->seq_args,
nfs4_setup_sequence(NFS_SERVER(data->old_dir)->nfs_client,
struct nfs_client *clp = server->nfs_client;
nfs4_set_lease_period(server->nfs_client, fsinfo->lease_time);
nfs4_init_sequence(NFS_SERVER(hdr->inode)->nfs_client,
if (nfs4_setup_sequence(NFS_SERVER(hdr->inode)->nfs_client,
nfs4_init_sequence(server->nfs_client, &hdr->args.seq_args,
nfs4_state_protect_write(hdr->ds_clp ? hdr->ds_clp : server->nfs_client, clnt, msg, hdr);
nfs4_setup_sequence(NFS_SERVER(data->inode)->nfs_client,
nfs4_init_sequence(server->nfs_client, &data->args.seq_args,
nfs4_state_protect(data->ds_clp ? data->ds_clp : server->nfs_client,
server->nfs_client->cl_hostname);
static void nfs4_init_boot_verifier(const struct nfs_client *clp,
nfs4_get_uniquifier(struct nfs_client *clp, char *buf, size_t buflen)
struct nfs_netns_client *nn_clp = nn->nfs_client;
struct nfs_client *clp = server->nfs_client;
nfs4_init_nonuniform_client_string(struct nfs_client *clp)
nfs4_init_uniform_client_string(struct nfs_client *clp)
nfs4_init_callback_netid(const struct nfs_client *clp, char *buf, size_t len)
int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
struct nfs_client *clp = server->nfs_client;
nfs4_setup_sequence(d_data->res.server->nfs_client,
nfs4_state_protect(server->nfs_client,
nfs4_init_sequence(server->nfs_client, &data->args.seq_args,
struct nfs_client *clp = server->nfs_client;
if (nfs4_setup_sequence(calldata->server->nfs_client,
struct nfs_client *clp = NFS_SERVER(lsp->ls_state->inode)->nfs_client;
alloc_seqid = NFS_SERVER(inode)->nfs_client->cl_mvops->alloc_seqid;
alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
if (nfs4_setup_sequence(data->server->nfs_client,
nfs4_schedule_lease_recovery(server->nfs_client);
struct nfs_client *clp = NFS_SERVER(state->inode)->nfs_client;
static bool _nfs4_is_integrity_protected(struct nfs_client *clp)
void do_renew_lease(struct nfs_client *clp, unsigned long timestamp)
struct nfs_client *clp = server->nfs_client;
struct nfs_client *clp = server->nfs_client;
void nfs4_init_sequence(struct nfs_client *clp,
struct nfs_client *clp = server->nfs_client;
struct nfs_client *clp = server->nfs_client;
nfs4_init_sequence(server->nfs_client, &args.seq_args, &res.seq_res, 0, 1);
struct nfs_client *clp = server->nfs_client;
struct nfs_client *clp = NFS_SERVER(dir)->nfs_client;
if (_nfs4_is_integrity_protected(NFS_SERVER(dir)->nfs_client))
static void nfs4_probe_sequence(struct nfs_client *client, const struct cred *cred,
struct nfs_client *clp = args->client;
struct nfs_client *clp,
struct nfs_client *clp;
struct nfs_client *clp;
int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, const struct cred *cred)
static int nfs4_sp4_select_mode(struct nfs_client *clp,
nfs4_run_exchange_id(struct nfs_client *clp, const struct cred *cred,
static int _nfs4_proc_exchange_id(struct nfs_client *clp, const struct cred *cred,
int nfs4_proc_exchange_id(struct nfs_client *clp, const struct cred *cred)
static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
static int nfs4_proc_destroy_clientid(struct nfs_client *clp,
int nfs4_destroy_clientid(struct nfs_client *clp)
struct nfs_client *clp;
int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)
static int _nfs4_proc_create_session(struct nfs_client *clp,
int nfs4_proc_create_session(struct nfs_client *clp, const struct cred *cred)
struct nfs_client *clp;
struct nfs_client *clp = calldata->clp;
static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp)
struct nfs_client *clp = calldata->clp;
struct nfs_client *clp = calldata->clp;
static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
static int nfs41_proc_async_sequence(struct nfs_client *clp, const struct cred *cred, unsigned renew_flags)
static int nfs4_proc_sequence(struct nfs_client *clp, const struct cred *cred)
struct nfs_client *clp;
static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp)
struct nfs_client *clp = calldata->clp;
static int nfs41_proc_reclaim_complete(struct nfs_client *clp,
nfs4_setup_sequence(server->nfs_client, &lgp->args.seq_args,
u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
nfs4_init_sequence(server->nfs_client, &lgp->args.seq_args,
nfs4_schedule_session_recovery(server->nfs_client->cl_session,
struct nfs_client *clp = NFS_SERVER(lrp->args.inode)->nfs_client;
nfs4_setup_sequence(server->nfs_client,
nfs4_schedule_state_renewal(struct nfs_client *clp)
nfs4_kill_renewd(struct nfs_client *clp)
void nfs4_set_lease_period(struct nfs_client *clp, u32 period)
struct nfs_client *clp =
container_of(work, struct nfs_client, cl_renewd.work);
struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp)
static int nfs41_check_session_ready(struct nfs_client *clp)
int nfs4_init_session(struct nfs_client *clp)
int nfs4_init_ds_session(struct nfs_client *clp, unsigned long lease_time)
static inline struct nfs4_session *nfs4_get_session(const struct nfs_client *clp)
extern struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp);
extern int nfs4_init_session(struct nfs_client *clp);
extern int nfs4_init_ds_session(struct nfs_client *, unsigned long);
static inline int nfs4_has_session(const struct nfs_client *clp)
static inline int nfs4_has_persistent_session(const struct nfs_client *clp)
struct nfs_client *clp;
if (!nfs4_has_session(sp->so_server->nfs_client))
static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
int nfs4_init_clientid(struct nfs_client *clp, const struct cred *cred)
void nfs4_schedule_state_manager(struct nfs_client *clp)
void nfs4_schedule_lease_recovery(struct nfs_client *clp)
struct nfs_client *clp = server->nfs_client;
void nfs4_schedule_lease_moved_recovery(struct nfs_client *clp)
int nfs4_wait_clnt_recover(struct nfs_client *clp)
int nfs4_client_recover_expired_lease(struct nfs_client *clp)
static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
struct nfs_client *clp = server->nfs_client;
struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
const struct cred *nfs4_get_machine_cred(struct nfs_client *clp)
spin_lock(&sp->so_server->nfs_client->cl_lock);
static void nfs4_root_machine_cred(struct nfs_client *clp)
spin_unlock(&sp->so_server->nfs_client->cl_lock);
nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
struct nfs_client *clp = server->nfs_client;
static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp,
int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
static int nfs4_reclaim_complete(struct nfs_client *clp,
struct nfs_client *clp = server->nfs_client;
static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
const struct cred *nfs4_get_renew_cred(struct nfs_client *clp)
static int nfs4_check_lease(struct nfs_client *clp)
static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
static int nfs4_establish_lease(struct nfs_client *clp)
static int nfs4_reclaim_lease(struct nfs_client *clp)
static int nfs4_purge_lease(struct nfs_client *clp)
struct nfs_client *clp = server->nfs_client;
static int nfs4_handle_migration(struct nfs_client *clp)
static int nfs4_handle_lease_moved(struct nfs_client *clp)
static void nfs4_end_drain_session(struct nfs_client *clp)
int nfs4_discover_server_trunking(struct nfs_client *clp,
struct nfs_client **result)
struct nfs_client *clp = session->clp;
void nfs41_notify_server(struct nfs_client *clp)
static void nfs4_reset_all_state(struct nfs_client *clp)
static void nfs41_handle_server_reboot(struct nfs_client *clp)
static void nfs41_handle_all_state_revoked(struct nfs_client *clp)
static void nfs41_handle_some_state_revoked(struct nfs_client *clp)
static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
static void nfs41_handle_backchannel_fault(struct nfs_client *clp)
static void nfs41_handle_cb_path_down(struct nfs_client *clp)
void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags,
static int nfs4_reset_session(struct nfs_client *clp)
static int nfs4_begin_drain_session(struct nfs_client *clp)
static int nfs4_bind_conn_to_session(struct nfs_client *clp)
static void nfs4_layoutreturn_any_run(struct nfs_client *clp)
static void nfs4_state_manager(struct nfs_client *clp)
static void nfs41_finish_session_reset(struct nfs_client *clp)
struct nfs_client *clp = ptr;
int nfs41_init_clientid(struct nfs_client *clp, const struct cred *cred)
int nfs41_discover_server_trunking(struct nfs_client *clp,
struct nfs_client **result,
const struct cred *nfs4_get_clid_cred(struct nfs_client *clp)
struct nfs_client *clp = server->nfs_client;
struct nfs_client *clp = server->nfs_client;
struct nfs_client *clp = server->nfs_client;
struct nfs_client *clp = server->nfs_client;
static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp);
struct nfs_client *clp = server->nfs_client;
static int nfs4_setup_state_renewal(struct nfs_client *clp)
const struct nfs_client *clp,
const struct nfs_client *clp, \
const struct nfs_client *clp,
const struct nfs_client *clp, \
const struct nfs_client *clp,
TP_PROTO(const struct nfs_client *clp, \
__string(dstaddr, server->nfs_client->cl_hostname)
__string(mds_addr, server->nfs_client->cl_hostname)
const struct nfs_client *clp
const struct nfs_client *clp,
const struct nfs_client *clp,
const struct nfs_client *clp, \
const struct nfs_client *clp,
struct nfs_client *clp = args->client;
const struct nfs_client *clp = data;
const struct nfs_client *clp = data;
return nfs_local_doio(NFS_SERVER(hdr->inode)->nfs_client,
struct nfs_client *clp = NFS_SERVER(hdr->inode)->nfs_client;
if (NFS_SERVER(hdr->inode)->nfs_client->cl_minorversion)
int pnfs_layout_handle_reboot(struct nfs_client *clp)
if (atomic_dec_and_test(&nfss->nfs_client->cl_mds_count))
nfs4_deviceid_purge_client(nfss->nfs_client);
lrp->clp = NFS_SERVER(ino)->nfs_client;
if (!(server->nfs_client->cl_exchange_flags &
__func__, server->nfs_client->cl_exchange_flags);
atomic_inc(&server->nfs_client->cl_mds_count);
struct nfs_client *clp = server->nfs_client;
struct nfs_client *clp = server->nfs_client;
struct nfs_client *clp = server->nfs_client;
pnfs_layout_return_unused_byclid(struct nfs_client *clp,
pnfs_layout_bulk_destroy_byserver_locked(struct nfs_client *clp,
int pnfs_layout_destroy_byfsid(struct nfs_client *clp, struct nfs_fsid *fsid,
static void pnfs_layout_build_destroy_list_byclient(struct nfs_client *clp,
static int pnfs_layout_do_destroy_byclid(struct nfs_client *clp,
int pnfs_layout_destroy_byclid(struct nfs_client *clp,
pnfs_destroy_all_layouts(struct nfs_client *clp)
static void pnfs_layout_build_recover_list_byclient(struct nfs_client *clp,
void pnfs_destroy_all_layouts(struct nfs_client *);
int pnfs_layout_destroy_byfsid(struct nfs_client *clp, struct nfs_fsid *fsid,
int pnfs_layout_destroy_byclid(struct nfs_client *clp,
void nfs4_deviceid_mark_client_invalid(struct nfs_client *clp);
void pnfs_layout_return_unused_byclid(struct nfs_client *clp,
int pnfs_layout_handle_reboot(struct nfs_client *clp);
const struct nfs_client *nfs_client;
void nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *, const struct nfs_client *, const struct nfs4_deviceid *);
void nfs4_deviceid_purge_client(const struct nfs_client *);
struct nfs_client *ds_clp;
static inline void pnfs_destroy_all_layouts(struct nfs_client *clp)
static inline int pnfs_layout_handle_reboot(struct nfs_client *clp)
max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
d = _lookup_deviceid(server->pnfs_curr_ld, server->nfs_client, id,
const struct nfs_client *clp, const struct nfs4_deviceid *id)
d->nfs_client = server->nfs_client;
nfs4_delete_deviceid(d->ld, d->nfs_client, &d->deviceid);
trace_nfs4_deviceid_free(d->nfs_client, &d->deviceid);
_deviceid_purge_client(const struct nfs_client *clp, long hash)
if (d->nfs_client == clp && atomic_read(&d->ref)) {
nfs4_deviceid_purge_client(const struct nfs_client *clp)
nfs4_deviceid_mark_client_invalid(struct nfs_client *clp)
if (d->nfs_client == clp)
const struct nfs_client *clp, const struct nfs4_deviceid *id,
if (d->ld == ld && d->nfs_client == clp &&
static struct nfs_client *(*get_v3_ds_connect)(
struct nfs_client *clp = ERR_PTR(-EIO);
struct nfs_client *mds_clp = mds_srv->nfs_client;
struct nfs_client *clp = ERR_PTR(-EIO);
struct nfs_client *mds_clp = mds_srv->nfs_client;
mds_srv->nfs_client->cl_lease_time);
if (status && server->nfs_client->cl_rpcclient != server->client)
status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
if (status && server->nfs_client->cl_rpcclient != server->client)
status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
ctx->version != nfss->nfs_client->rpc_ops->version ||
ctx->minorversion != nfss->nfs_client->cl_minorversion ||
ctx->nfs_server.addrlen != nfss->nfs_client->cl_addrlen ||
(struct sockaddr *)&nfss->nfs_client->cl_addr))
sb->s_xattr = server->nfs_client->cl_nfs_mod->xattr;
sb->s_op = server->nfs_client->cl_nfs_mod->sops;
switch (server->nfs_client->rpc_ops->version) {
if (a->nfs_client != b->nfs_client)
set_default_d_op(s, server->nfs_client->rpc_ops->dentry_ops);
sap1 = (struct sockaddr *)&server1->nfs_client->cl_addr;
sap2 = (struct sockaddr *)&server2->nfs_client->cl_addr;
int nfs_client_for_each_server(struct nfs_client *clp,
error = server->nfs_client->rpc_ops->statfs(server, fh, &res);
struct nfs_client *clp = nfss->nfs_client;
struct nfs_client *clp = nfss->nfs_client;
rpc_peeraddr2str(nfss->nfs_client->cl_rpcclient,
struct nfs_client *clp = server->nfs_client;
if (nfs4_has_session(server->nfs_client))
if (nfss->nfs_client && nfss->nfs_client->cl_implid) {
struct nfs41_impl_id *impl_id = nfss->nfs_client->cl_implid;
if (nfss->nfs_client->rpc_ops->version == 4) {
netns->nfs_client = clp;
struct nfs_netns_client *clp = netns->nfs_client;
netns->nfs_client = NULL;
static void shutdown_nfs_client(struct nfs_client *clp)
shutdown_nfs_client(server->nfs_client);
struct nfs41_impl_id *impl_id = server->nfs_client->cl_implid;
struct nfs41_impl_id *impl_id = server->nfs_client->cl_implid;
kobj)->nfs_client->cl_net);
if (!server->nfs_client->cl_implid)
bool localio = nfs_server_is_local(server->nfs_client);
NFS_SERVER(inode)->nfs_client->cl_hostname,
if (NFS_SERVER(inode)->nfs_client->cl_minorversion)
localio = nfs_local_open_fh(NFS_SERVER(inode)->nfs_client, data->cred,
const struct nfs_client *clp
const struct nfs_client *clp \
void nfs_localio_enable_client(struct nfs_client *clp)
void nfs_localio_disable_client(struct nfs_client *clp)
struct nfs_client *clp;
clp = container_of(nfs_uuid, struct nfs_client, cl_uuid);
return NFS_SERVER(inode)->nfs_client->rpc_ops;
struct nfs_client * nfs_client; /* shared client and NFS4 state */
struct nfs_client *sc_clnt;
struct nfs_client *client;
struct nfs_client *client;
struct nfs_client *client;
struct nfs_client *ds_clp; /* pNFS data server */
struct nfs_client *ds_clp; /* pNFS data server */
struct nfs_client;
struct nfs_client *(*alloc_client) (const struct nfs_client_initdata *);
struct nfs_client *(*init_client) (struct nfs_client *,
void (*free_client) (struct nfs_client *);
struct nfs_client *clp;
struct nfs_client;
static inline void nfs_localio_disable_client(struct nfs_client *clp)
struct nfs_client;
void nfs_localio_enable_client(struct nfs_client *clp);
void nfs_localio_disable_client(struct nfs_client *clp);