[pnfs] [PATCH 5/6] 2.6-latest-pnfs-client-data-server-create-session
andros at umich.edu
andros at umich.edu
Fri Oct 19 14:13:21 EDT 2007
From: Andy Adamson <andros at umich.edu>
Data Servers don't use a struct nfs_server.
Call _nfs4_proc_exchange_id() because data servers have no
associated nfs_server structs.
Change the struct nfs_server interface to nfs4_proc_create_session to
a struct nfs_client and struct nfs4_session.
Call nfs41_recover_session_sync() when GETDEVICELIST processing creates
a data server
Don't get a lease.
Signed-off by Andy Adamson<andros at umich.edu>
---
fs/nfs/Makefile | 3 +-
fs/nfs/client.c | 20 ++++---
fs/nfs/nfs41_session_recovery.c | 92 ++++++++++++++++++--------------
fs/nfs/nfs4filelayoutdev.c | 57 ++++++++++++--------
fs/nfs/nfs4proc.c | 82 +++++++++++++++++-----------
fs/nfs/nfs4state.c | 1 -
include/linux/nfs41_session_recovery.h | 15 +++---
7 files changed, 157 insertions(+), 113 deletions(-)
diff --git a/fs/nfs/Makefile b/fs/nfs/Makefile
index 127977e..c71f4ee 100644
--- a/fs/nfs/Makefile
+++ b/fs/nfs/Makefile
@@ -13,8 +13,9 @@ nfs-$(CONFIG_NFS_V3_ACL) += nfs3acl.o
nfs-$(CONFIG_NFS_V4) += nfs4proc.o nfs4xdr.o nfs4state.o nfs4renewd.o \
delegation.o idmap.o \
callback.o callback_xdr.o callback_proc.o \
- nfs4namespace.o pnfs.o
+ nfs4namespace.o
nfs-$(CONFIG_NFS_V4_1) += nfs41_session_recovery.o
+nfs-$(CONFIG_PNFS) += pnfs.o
nfs-$(CONFIG_NFS_DIRECTIO) += direct.o
nfs-$(CONFIG_SYSCTL) += sysctl.o
nfs-objs := $(nfs-y)
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 1688f1d..7c92a2d 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -206,6 +206,7 @@ void nfs_put_client(struct nfs_client *clp)
nfs_free_client(clp);
}
}
+EXPORT_SYMBOL(nfs_put_client);
/*
* Find a client by address
@@ -991,14 +992,13 @@ static int nfs4_init_server(struct nfs_server *server,
/*
* Allocate and initialize a session if required
*/
-int nfs4_init_session(struct nfs_server *server)
+int nfs4_init_session(struct nfs_client *clp, struct nfs4_session **spp, struct rpc_clnt *clnt)
{
int error = 0;
# if defined (CONFIG_NFS_V4_1)
- struct nfs_client *clp;
+ struct nfs4_session *session;
- clp = server->nfs_client;
switch (clp->cl_minorversion) {
case 1:
/*
@@ -1006,22 +1006,24 @@ int nfs4_init_session(struct nfs_server *server)
* encounters the expired session it will do session recovery to
* initialize it.
*/
- server->session = nfs4_alloc_session();
- if (!server->session)
+ session = nfs4_alloc_session();
+ if (!session)
error = NFSERR_RESOURCE;
else {
- server->session->clnt = server->client;
- rpc_init_wait_queue(&server->session->recovery_waitq,
+ session->clnt = clnt;
+ rpc_init_wait_queue(&session->recovery_waitq,
"Session recovery wait queue");
}
+ *spp = session;
break;
case 0:
- server->session = NULL;
+ session = NULL;
break;
}
#endif
return error;
}
+EXPORT_SYMBOL(nfs4_init_session);
/*
* Create a version 4 volume record
@@ -1060,7 +1062,7 @@ struct nfs_server *nfs4_create_server(const struct nfs4_mount_data *data,
BUG_ON(!server->nfs_client->rpc_ops);
BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
- error = nfs4_init_session(server);
+ error = nfs4_init_session(server->nfs_client, &server->session, server->client);
if (error)
goto error;
diff --git a/fs/nfs/nfs41_session_recovery.c b/fs/nfs/nfs41_session_recovery.c
index 9683699..7bee5b9 100644
--- a/fs/nfs/nfs41_session_recovery.c
+++ b/fs/nfs/nfs41_session_recovery.c
@@ -65,22 +65,28 @@ static int nfs41_start_session_recovery(struct nfs4_session *session)
return ret;
}
-static int nfs41_end_session_recovery(struct nfs4_session *session)
+struct reclaimer_arg {
+ struct nfs_client *clp;
+ struct nfs4_session *session;
+};
+
+static int nfs41_end_session_recovery(struct reclaimer_arg *rec)
{
smp_mb__before_clear_bit();
- clear_bit(NFS41_SESSION_RECOVER, &session->session_state);
+ clear_bit(NFS41_SESSION_RECOVER, &rec->session->session_state);
smp_mb__after_clear_bit();
/*
* Wake up async tasks
*/
- rpc_wake_up(&session->recovery_waitq);
+ rpc_wake_up(&rec->session->recovery_waitq);
/*
* Wake up sync tasks
*/
- wake_up_bit(&session->session_state, NFS41_SESSION_RECOVER);
+ wake_up_bit(&rec->session->session_state, NFS41_SESSION_RECOVER);
+ kfree(rec);
return 0;
}
@@ -90,11 +96,10 @@ static int nfs41_recovery_complete(struct nfs4_session *session)
}
extern int nfs4_wait_bit_interruptible(void *word);
-static int nfs41_wait_session_recover_sync(struct rpc_clnt *clnt, struct nfs_server *server)
+static int nfs41_wait_session_recover_sync(struct rpc_clnt *clnt, struct nfs4_session *session)
{
sigset_t oldset;
int ret;
- struct nfs4_session *session = server->session;
might_sleep();
@@ -107,9 +112,9 @@ static int nfs41_wait_session_recover_sync(struct rpc_clnt *clnt, struct nfs_ser
return ret;
}
-static int nfs41_wait_session_recover_async(struct rpc_task *task, struct nfs_server *server)
+static int nfs41_wait_session_recover_async(struct rpc_task *task, struct nfs4_session *session)
{
- if (nfs41_recovery_complete(server->session)) {
+ if (nfs41_recovery_complete(session)) {
rpc_wake_up_task(task);
return 0;
}
@@ -117,48 +122,46 @@ static int nfs41_wait_session_recover_async(struct rpc_task *task, struct nfs_se
return -EAGAIN;
}
-int nfs4_proc_create_session(struct nfs_server *sp);
+int nfs4_proc_create_session(struct nfs_client *clp, struct nfs4_session *session);
static int session_reclaimer(void *arg)
{
int ret;
- struct nfs_server *server = (struct nfs_server *)arg;
- struct nfs4_session *session = server->session;
- struct nfs_client *clp = server->nfs_client;
+ struct reclaimer_arg *rec = (struct reclaimer_arg *)arg;
allow_signal(SIGKILL);
- ret = nfs4_proc_create_session(server);
+ ret = nfs4_proc_create_session(rec->clp, rec->session);
if (ret)
goto out_error;
out:
- nfs41_end_session_recovery(session);
+ nfs41_end_session_recovery(rec);
module_put_and_exit(0);
return ret;
out_error:
printk(KERN_WARNING "Error: session recovery failed on NFSv4.1 server %u.%u.%u.%u with error %d\n",
- NIPQUAD(server->nfs_client->cl_addr.sin_addr),
+ NIPQUAD(rec->clp->cl_addr.sin_addr),
-ret);
- nfs41_set_session_expired(server->session);
+ nfs41_set_session_expired(rec->session);
switch (ret) {
case -NFS4ERR_STALE_CLIENTID:
case -NFS4ERR_STALE_STATEID:
case -NFS4ERR_EXPIRED:
- set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
+ set_bit(NFS4CLNT_LEASE_EXPIRED, &rec->clp->cl_state);
break;
}
goto out;
}
-static int nfs41_schedule_session_recovery(struct nfs_server *server)
+static int nfs41_schedule_session_recovery(struct reclaimer_arg *rec)
{
struct task_struct *task;
__module_get(THIS_MODULE);
- task = kthread_run(session_reclaimer, server, "%llx-session-reclaim",
- (u64 *)server->session->sess_id);
+ task = kthread_run(session_reclaimer, rec, "%llx-session-reclaim",
+ (u64 *)rec->session->sess_id);
if (!IS_ERR(task))
return 0;
@@ -172,11 +175,21 @@ static int nfs41_schedule_session_recovery(struct nfs_server *server)
* Session recovery
* Called when an op receives a session related error
*/
-int nfs41_recover_session(struct nfs_server *server)
+int nfs41_recover_session(struct nfs_client *clp, struct nfs4_session *session)
{
+ struct reclaimer_arg *rec;
int ret;
- ret = nfs41_start_session_recovery(server->session);
+ printk("--> %s clp %p session %p\n", __func__, clp, session);
+ /* freed in nfs41_end_session_recovery */
+ rec = kmalloc(sizeof(*rec), GFP_KERNEL);
+ if (!rec)
+ return -ENOMEM;
+ rec->clp = clp;
+ rec->session = session;
+
+ printk("%s rec %p\n", __func__, rec);
+ ret = nfs41_start_session_recovery(session);
/*
* If we get 1, it means some other thread beat us to us here, so we
@@ -185,76 +198,75 @@ int nfs41_recover_session(struct nfs_server *server)
if (ret)
return 0;
- ret = nfs41_schedule_session_recovery(server);
+ ret = nfs41_schedule_session_recovery(rec);
if (!ret)
goto out;
/*
* We got an error creating the reclaiming thread, so end the recovery
* and bail out
*/
- nfs41_end_session_recovery(server->session);
+ nfs41_end_session_recovery(rec);
out:
return ret;
}
-int nfs41_recover_session_sync(struct rpc_clnt *clnt, struct nfs_server *server)
+int nfs41_recover_session_sync(struct rpc_clnt *clnt, struct nfs_client *clp, struct nfs4_session *session)
{
int ret;
- ret = nfs41_recover_session(server);
+ ret = nfs41_recover_session(clp, session);
if (ret)
return ret;
- return nfs41_wait_session_recover_sync(clnt, server);
+ return nfs41_wait_session_recover_sync(clnt, session);
}
+EXPORT_SYMBOL(nfs41_recover_session_sync);
int nfs41_recover_session_async(struct rpc_task *task, struct nfs_server *server)
{
int ret;
rpc_sleep_on(&server->session->recovery_waitq, task, NULL, NULL);
- ret = nfs41_recover_session(server);
+ ret = nfs41_recover_session(server->nfs_client, server->session);
- ret = nfs41_wait_session_recover_async(task, server);
+ ret = nfs41_wait_session_recover_async(task, server->session);
return ret;
}
-int nfs41_recover_expired_session1(struct rpc_clnt *clnt, struct nfs_server
-*server)
+int nfs41_recover_expired_session1(struct rpc_clnt *clnt, struct nfs_client *clp, struct nfs4_session *session)
{
int ret;
while(1) {
- ret = nfs41_wait_session_recover_sync(clnt, server);
+ ret = nfs41_wait_session_recover_sync(clnt, session);
if (ret)
return ret;
- if (!nfs41_set_session_valid(server->session))
+ if (!nfs41_set_session_valid(session))
break;
- ret = nfs41_recover_session_sync(clnt, server);
+ ret = nfs41_recover_session_sync(clnt, clp, session);
}
return ret;
}
-int nfs41_recover_expired_session(struct rpc_task *task, struct nfs_server
-*server)
+int nfs41_recover_expired_session(struct rpc_task *task, struct nfs_client *clp, struct nfs4_session *session)
{
int ret = 0;
while (1) {
- rpc_sleep_on(&server->session->recovery_waitq, task, NULL, NULL);
+ rpc_sleep_on(&session->recovery_waitq, task, NULL, NULL);
- if ((ret = nfs41_wait_session_recover_async(task, server)) ==
+ if ((ret = nfs41_wait_session_recover_async(task, session)) ==
-EAGAIN) {
break;
}
- if (!(ret = nfs41_set_session_valid(server->session)))
+ if (!(ret = nfs41_set_session_valid(session)))
break;
- nfs41_recover_session(server);
+ nfs41_recover_session(clp, session);
}
return ret;
diff --git a/fs/nfs/nfs4filelayoutdev.c b/fs/nfs/nfs4filelayoutdev.c
index 96f87d7..e761546 100644
--- a/fs/nfs/nfs4filelayoutdev.c
+++ b/fs/nfs/nfs4filelayoutdev.c
@@ -54,21 +54,15 @@
#define NFSDBG_FACILITY NFSDBG_FILELAYOUT
-extern int nfs4_set_client(struct nfs_server *server,
- const char *hostname, const struct sockaddr_in *addr,
- const char *ip_addr,
- rpc_authflavor_t authflavour,
- int proto, int timeo, int retrans);
+extern int
+nfs4_set_client(struct nfs_server *, const char *, const struct sockaddr_in *, const char *r, rpc_authflavor_t, int, int, int);
+extern int
+nfs4_init_session(struct nfs_client *, struct nfs4_session **, struct rpc_clnt *);
+extern void nfs_put_client(struct nfs_client *);
+extern int _nfs4_proc_exchange_id(struct nfs_client *, struct rpc_cred *);
extern struct pnfs_client_operations * pnfs_callback_ops;
-struct rpc_clnt*
-create_nfs_rpcclient(struct rpc_xprt *xprt,
- char* server_name,
- u32 version,
- rpc_authflavor_t authflavor,
- int *err);
-
void
print_ds_list(struct nfs4_pnfs_dev *fdev)
{
@@ -172,6 +166,8 @@ _data_server_add(struct nfs4_pnfs_dev_hlist *hlist, struct nfs4_pnfs_ds *ds)
hlist_add_head(&ds->ds_node, &hlist->dev_dslist[hash]);
}
+int nfs41_recover_session_sync(struct rpc_clnt *, struct nfs_client *, struct nfs4_session *);
+
/* Create an rpc to the data server defined in 'dev_list' */
static int
nfs4_pnfs_ds_create(struct nfs_server *mds_srv, struct nfs4_pnfs_ds *ds)
@@ -181,9 +177,12 @@ nfs4_pnfs_ds_create(struct nfs_server *mds_srv, struct nfs4_pnfs_ds *ds)
};
struct sockaddr_in sin;
struct rpc_clnt *mds_clnt = mds_srv->client;
+ struct nfs_client *clp;
+ struct rpc_cred *cred = NULL;
char ip_addr[16];
int err = 0;
+ dprintk("--> %s\n", __func__);
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = ds->ds_ip_addr;
sin.sin_port = ds->ds_port;
@@ -217,23 +216,37 @@ nfs4_pnfs_ds_create(struct nfs_server *mds_srv, struct nfs4_pnfs_ds *ds)
if (err < 0)
goto out;
+ clp = tmp.nfs_client;
+ err = nfs4_init_session(clp, &clp->cl_ds_session, clp->cl_rpcclient);
+ if (err)
+ goto out_put;
- dprintk("%s: cl_ipaddr %s\n", __func__, tmp.nfs_client->cl_ipaddr);
+ /* Set exchange id and create session flags
+ *
+ * XXX Need to find the proper credential...
+ */
+ dprintk("%s EXCHANGE_ID for clp %p\n", __func__, clp);
+ clp->cl_exchange_flags = EXCHGID4_FLAG_USE_PNFS_DS;
- dprintk("%s: ip=%x, port=%hu, rpcclient %p\n", __func__,
- ntohl(ds->ds_ip_addr), ntohs(ds->ds_port),
- tmp.nfs_client->cl_rpcclient);
+ err = _nfs4_proc_exchange_id(clp, cred);
+ if (err)
+ goto out_put;
- if (tmp.nfs_client->cl_ds_session == NULL) {
- /* Set exchange id and create session flags */
- tmp.nfs_client->cl_exchange_flags = EXCHGID4_FLAG_USE_PNFS_DS;
+ dprintk("%s CREATE_SESSION for clp %p\n", __func__,clp);
+ err = nfs41_recover_session_sync(clp->cl_rpcclient, clp, clp->cl_ds_session);
+ if (err)
+ goto out_put;
+ ds->ds_clp = clp;
- nfs4_schedule_state_recovery(tmp.nfs_client);
- }
- ds->ds_clp = tmp.nfs_client;
+ dprintk("%s: ip=%x, port=%hu, rpcclient %p\n", __func__,
+ ntohl(ds->ds_ip_addr), ntohs(ds->ds_port),
+ clp->cl_rpcclient);
out:
dprintk("%s Returns %d\n", __func__, err);
return err;
+out_put:
+ nfs_put_client(clp);
+ goto out;
}
/* Assumes lock is held */
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 2a856b6..3be6871 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -250,18 +250,17 @@ int nfs4_wait_bit_interruptible(void *word)
}
#ifdef CONFIG_NFS_V4_1
-static int nfs41_sequence_done(struct nfs_server *server,
+static int nfs41_sequence_done(struct nfs_client *clp,
+ struct nfs4_session *session,
struct nfs41_sequence_res *res, int status)
{
unsigned long timestamp;
- struct nfs_client *clp;
struct nfs4_slot_table *tbl;
struct nfs4_slot *slot;
- clp = server->nfs_client;
BUG_ON(clp == NULL);
- tbl = &server->session->fore_channel.slot_table;
+ tbl = &session->fore_channel.slot_table;
slot = res->sr_slot;
switch (status) {
@@ -309,7 +308,9 @@ static int nfs4_sequence_done(struct nfs_server *server,
switch (server->nfs_client->cl_minorversion) {
case 1:
- ret = nfs41_sequence_done(server, res, status);
+ ret = nfs41_sequence_done(server->nfs_client,
+ server->session,
+ res, status);
break;
default:
ret = 0;
@@ -393,7 +394,8 @@ static int nfs41_validate_seq_args(struct nfs_server *server,
cache_this, task);
}
-static int nfs4_setup_sequence(struct nfs_server *server,
+static int nfs4_setup_sequence(struct nfs_client *clp,
+ struct nfs4_session *session,
struct nfs41_sequence_args *args,
struct nfs41_sequence_res *res,
int cache_reply,
@@ -401,12 +403,12 @@ static int nfs4_setup_sequence(struct nfs_server *server,
{
int ret;
- switch (server->nfs_client->cl_minorversion) {
+ switch (clp->cl_minorversion) {
case 1:
if ((ret = nfs41_recover_expired_session(task,
-server)))
+clp, session)))
break;
- ret = nfs41_setup_sequence(server->session, args,
+ ret = nfs41_setup_sequence(session, args,
res, cache_reply, task);
break;
default:
@@ -456,7 +458,9 @@ void nfs41_call_sync_validate_args(struct rpc_task *task, void *calldata)
int ret;
struct nfs41_call_sync_data *data = calldata;
- ret = nfs4_setup_sequence(data->server, data->seq_args,
+printk("--> %s data->server->session %p\n", __func__, data->server->session);
+ ret = nfs4_setup_sequence(data->server->nfs_client,
+ data->server->session, data->seq_args,
data->seq_res, data->cache_reply, task);
if (ret != -EAGAIN)
@@ -1250,7 +1254,8 @@ static void nfs4_open_validate(struct rpc_task *task, void *data)
struct nfs4_opendata *odata = (struct nfs4_opendata *)data;
server = odata->o_arg.server;
- ret = nfs4_setup_sequence(server,
+ ret = nfs4_setup_sequence(server->nfs_client,
+ server->session,
&odata->o_arg.seq_args,
&odata->o_res.seq_res, 1, task);
@@ -1688,7 +1693,8 @@ void nfs4_close_validate(struct rpc_task *task, void *data)
cdata = (struct nfs4_closedata *)data;
server = NFS_SERVER(cdata->inode);
- ret = nfs4_setup_sequence(server,
+ ret = nfs4_setup_sequence(server->nfs_client,
+ server->session,
&cdata->arg.seq_args,
&cdata->res.seq_res, 1, task);
@@ -3170,6 +3176,7 @@ void nfs41_sequence_call_done(struct rpc_task *task, void *data)
{
struct nfs_server *server = (struct nfs_server *)data;
struct nfs_client *clp = server->nfs_client;
+ struct nfs4_session *session = server->session;
nfs4_sequence_done(server, task->tk_msg.rpc_resp, task->tk_status);
@@ -3191,7 +3198,7 @@ void nfs41_sequence_call_done(struct rpc_task *task, void *data)
case -NFS4ERR_RETRY_UNCACHED_REP:
case -NFS4ERR_TOO_MANY_OPS:
case -NFS4ERR_OP_NOT_IN_SESSION:
- nfs41_recover_session(server);
+ nfs41_recover_session(clp, session);
}
}
}
@@ -3207,7 +3214,7 @@ static void nfs41_sequence_validate(struct rpc_task *task, void *data)
args = task->tk_msg.rpc_argp;
res = task->tk_msg.rpc_resp;
- ret = nfs4_setup_sequence(server, args, res, 0, task);
+ ret = nfs4_setup_sequence(server->nfs_client, server->session, args, res, 0, task);
if (ret != -EAGAIN)
rpc_start_call(task);
@@ -3597,7 +3604,7 @@ static int nfs4_handle_exception(const struct nfs_server *server, int errorcode,
case -NFS4ERR_TOO_MANY_OPS:
case -NFS4ERR_OP_NOT_IN_SESSION:
ret = nfs41_recover_session_sync(server->session->clnt,
- server);
+ server->nfs_client, server->session);
if (!ret) {
exception->retry = 1;
break;
@@ -3714,6 +3721,7 @@ int _nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
dprintk("<-- %s status= %d\n", __FUNCTION__, status);
return status;
}
+EXPORT_SYMBOL(_nfs4_proc_exchange_id);
int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
{
@@ -3777,7 +3785,8 @@ int nfs4_proc_setclientid_confirm(struct nfs_client *clp, struct rpc_cred *cred)
struct nfs4_get_lease_time_data {
struct nfs4_get_lease_time_args *args;
struct nfs4_get_lease_time_res *res;
- struct nfs_server *server;
+ struct nfs_client *clp;
+ struct nfs4_session *session;
};
static void nfs4_get_lease_time_prepare(struct rpc_task *task,
@@ -3795,7 +3804,7 @@ static void nfs4_get_lease_time_prepare(struct rpc_task *task,
rpc_call_setup(task, &msg, 0);
- ret = nfs41_setup_sequence(data->server->session,
+ ret = nfs41_setup_sequence(data->session,
&data->args->la_seq_args,
&data->res->lr_seq_res, 0, task);
@@ -3808,7 +3817,7 @@ static void nfs4_get_lease_time_done(struct rpc_task *task,
struct nfs4_get_lease_time_data *data =
(struct nfs4_get_lease_time_data *)calldata;
- nfs41_sequence_done(data->server, &data->res->lr_seq_res,
+ nfs41_sequence_done(data->clp, data->session, &data->res->lr_seq_res,
task->tk_status);
}
@@ -3817,7 +3826,8 @@ struct rpc_call_ops nfs4_get_lease_time_ops = {
.rpc_call_done = nfs4_get_lease_time_done,
};
-int nfs4_proc_get_lease_time(struct nfs_server *sp, struct nfs_fsinfo *fsinfo)
+int nfs4_proc_get_lease_time(struct nfs_client *clp,
+ struct nfs4_session *session, struct nfs_fsinfo *fsinfo)
{
struct rpc_task *task;
struct nfs4_get_lease_time_args args;
@@ -3828,11 +3838,12 @@ int nfs4_proc_get_lease_time(struct nfs_server *sp, struct nfs_fsinfo *fsinfo)
struct nfs4_get_lease_time_data data = {
.args = &args,
.res = &res,
- .server = sp,
+ .clp = clp,
+ .session = session,
};
int status;
- task = rpc_run_task(sp->session->clnt, 0,
+ task = rpc_run_task(session->clnt, 0,
&nfs4_get_lease_time_ops, &data);
if (IS_ERR(task))
@@ -4041,21 +4052,18 @@ int _nfs4_proc_create_session(struct nfs_client *clp, struct nfs4_session *sessi
* It is the responsibility of the caller to verify the session is
* expired before calling this routine.
*/
-int nfs4_proc_create_session(struct nfs_server *sp) {
+int nfs4_proc_create_session(struct nfs_client *clp, struct nfs4_session *session) {
int status;
- struct nfs4_session *session;
- struct nfs_client *clp = sp->nfs_client;
u32 *ptr;
struct nfs_fsinfo fsinfo;
dprintk("--> %s()\n", __FUNCTION__);
- BUG_ON(sp->session == NULL);
+ BUG_ON(session == NULL);
- status = _nfs4_proc_create_session(clp, sp->session, clp->cl_rpcclient);
+ status = _nfs4_proc_create_session(clp, session, clp->cl_rpcclient);
if (status)
goto out;
- session = sp->session;
session->clnt = clp->cl_rpcclient;
/* Init the fore channel */
@@ -4077,8 +4085,15 @@ int nfs4_proc_create_session(struct nfs_server *sp) {
dprintk("%s client>seqid %d\n",__FUNCTION__,clp->cl_seqid);
ptr = (int *)session->sess_id;
dprintk("sessionid is: %d:%d:%d:%d\n", ptr[0], ptr[1], ptr[2], ptr[3]);
+
+#ifdef CONFIG_PNFS
+ /* Data servers do not have a lease */
+ if (clp->cl_ds_session != NULL)
+ goto out;
+#endif /* CONFIG_PNFS */
+
/* Get the lease time */
- status = nfs4_proc_get_lease_time(sp, &fsinfo);
+ status = nfs4_proc_get_lease_time(clp, session, &fsinfo);
if (status == 0) {
/* Update lease time and schedule renewal */
spin_lock(&clp->cl_lock);
@@ -4090,7 +4105,7 @@ int nfs4_proc_create_session(struct nfs_server *sp) {
nfs4_schedule_state_renewal(clp);
} /*else {
- nfs4_put_session(&sp->session);
+ nfs4_put_session(&session);
}*/
out:
@@ -4186,7 +4201,8 @@ void nfs4_delegreturn_validate(struct rpc_task *task, void *data)
d_data = (struct nfs4_delegreturndata *)data;
server = d_data->res.server;
- ret = nfs4_setup_sequence(server,
+ ret = nfs4_setup_sequence(server->nfs_client,
+ server->session,
&d_data->args.seq_args,
&d_data->res.seq_res, 1, task);
@@ -4444,7 +4460,8 @@ void nfs4_locku_validate(struct rpc_task *task, void *data)
struct nfs_server *server = calldata->server;
- ret = nfs4_setup_sequence(server,
+ ret = nfs4_setup_sequence(server->nfs_client,
+ server->session,
&calldata->arg.seq_args,
&calldata->res.seq_res, 1, task);
@@ -4651,7 +4668,8 @@ void nfs4_lock_validate(struct rpc_task *task, void *data)
struct nfs4_lockdata *ldata = (struct nfs4_lockdata *)data;
struct nfs_server *server = ldata->server;
- ret = nfs4_setup_sequence(server,
+ ret = nfs4_setup_sequence(server->nfs_client,
+ server->session,
&ldata->arg.seq_args,
&ldata->res.seq_res, 1, task);
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 3ab8ca3..505260a 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -804,7 +804,6 @@ void nfs4_schedule_state_recovery(struct nfs_client *clp)
if (test_and_set_bit(NFS4CLNT_STATE_RECOVER, &clp->cl_state) == 0)
nfs4_recover_state(clp);
}
-EXPORT_SYMBOL(nfs4_schedule_state_recovery);
static int nfs4_reclaim_locks(struct nfs4_state_recovery_ops *ops, struct nfs4_state *state)
{
diff --git a/include/linux/nfs41_session_recovery.h b/include/linux/nfs41_session_recovery.h
index 8911195..5135c50 100644
--- a/include/linux/nfs41_session_recovery.h
+++ b/include/linux/nfs41_session_recovery.h
@@ -11,14 +11,13 @@
#if defined (CONFIG_NFS_V4_1)
-int nfs41_set_session_expired(struct nfs4_session *session);
-int nfs41_set_session_valid(struct nfs4_session *session);
-int nfs41_recover_session(struct nfs_server *server);
-int nfs41_recover_session_sync(struct rpc_clnt *, struct nfs_server *server);
-int nfs41_recover_session_async(struct rpc_task *, struct nfs_server *server);
-int nfs41_recover_expired_session(struct rpc_task *task, struct nfs_server
-*server);
-int nfs41_test_session_expired(struct nfs4_session *session);
+int nfs41_set_session_expired(struct nfs4_session *);
+int nfs41_set_session_valid(struct nfs4_session *);
+int nfs41_recover_session(struct nfs_client *, struct nfs4_session *);
+int nfs41_recover_session_sync(struct rpc_clnt *, struct nfs_client *, struct nfs4_session *);
+int nfs41_recover_session_async(struct rpc_task *, struct nfs_server *);
+int nfs41_recover_expired_session(struct rpc_task *, struct nfs_client *, struct nfs4_session *);
+int nfs41_test_session_expired(struct nfs4_session *);
#endif /* CONFIG_NFS_V4_1 */
#endif /* __NFS41_SESSION_RECOVERY_H__ */
--
1.5.0.2
More information about the pNFS
mailing list