[linux.git] / fs / nfs / client.c

/* client.c: NFS client sharing and management code
 *
 * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells ([email protected])
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */


#include <linux/config.h>
#include <linux/module.h>
#include <linux/init.h>

#include <linux/time.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/stat.h>
#include <linux/errno.h>
#include <linux/unistd.h>
#include <linux/sunrpc/clnt.h>
#include <linux/sunrpc/stats.h>
#include <linux/sunrpc/metrics.h>
#include <linux/nfs_fs.h>
#include <linux/nfs_mount.h>
#include <linux/nfs4_mount.h>
#include <linux/lockd/bind.h>
#include <linux/smp_lock.h>
#include <linux/seq_file.h>
#include <linux/mount.h>
#include <linux/nfs_idmap.h>
#include <linux/vfs.h>
#include <linux/inet.h>
#include <linux/nfs_xdr.h>

#include <asm/system.h>

#include "nfs4_fs.h"
#include "callback.h"
#include "delegation.h"
#include "iostat.h"
#include "internal.h"

#define NFSDBG_FACILITY		NFSDBG_CLIENT

static DEFINE_SPINLOCK(nfs_client_lock);
static LIST_HEAD(nfs_client_list);
static DECLARE_WAIT_QUEUE_HEAD(nfs_client_active_wq);

/*
 * RPC cruft for NFS
 */
static struct rpc_version *nfs_version[5] = {
	[2]			= &nfs_version2,
#ifdef CONFIG_NFS_V3
	[3]			= &nfs_version3,
#endif
#ifdef CONFIG_NFS_V4
	[4]			= &nfs_version4,
#endif
};

struct rpc_program nfs_program = {
	.name			= "nfs",
	.number			= NFS_PROGRAM,
	.nrvers			= ARRAY_SIZE(nfs_version),
	.version		= nfs_version,
	.stats			= &nfs_rpcstat,
	.pipe_dir_name		= "/nfs",
};

struct rpc_stat nfs_rpcstat = {
	.program		= &nfs_program
};


#ifdef CONFIG_NFS_V3_ACL
static struct rpc_stat		nfsacl_rpcstat = { &nfsacl_program };
static struct rpc_version *	nfsacl_version[] = {
	[3]			= &nfsacl_version3,
};

struct rpc_program		nfsacl_program = {
	.name			= "nfsacl",
	.number			= NFS_ACL_PROGRAM,
	.nrvers			= ARRAY_SIZE(nfsacl_version),
	.version		= nfsacl_version,
	.stats			= &nfsacl_rpcstat,
};
#endif  /* CONFIG_NFS_V3_ACL */

/*
 * Allocate a shared client record
 *
 * Since these are allocated/deallocated very rarely, we don't
 * bother putting them in a slab cache...
 */
static struct nfs_client *nfs_alloc_client(const char *hostname,
					   const struct sockaddr_in *addr,
					   int nfsversion)
{
	struct nfs_client *clp;
	int error;

	if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)
		goto error_0;

	error = rpciod_up();
	if (error < 0) {
		dprintk("%s: couldn't start rpciod! Error = %d\n",
				__FUNCTION__, error);
		__set_bit(NFS_CS_RPCIOD, &clp->cl_res_state);
		goto error_1;
	}

	if (nfsversion == 4) {
		if (nfs_callback_up() < 0)
			goto error_2;
		__set_bit(NFS_CS_CALLBACK, &clp->cl_res_state);
	}

	atomic_set(&clp->cl_count, 1);
	clp->cl_cons_state = NFS_CS_INITING;

	clp->cl_nfsversion = nfsversion;
	memcpy(&clp->cl_addr, addr, sizeof(clp->cl_addr));

	if (hostname) {
		clp->cl_hostname = kstrdup(hostname, GFP_KERNEL);
		if (!clp->cl_hostname)
			goto error_3;
	}

	INIT_LIST_HEAD(&clp->cl_superblocks);
	clp->cl_rpcclient = ERR_PTR(-EINVAL);

#ifdef CONFIG_NFS_V4
	init_rwsem(&clp->cl_sem);
	INIT_LIST_HEAD(&clp->cl_delegations);
	INIT_LIST_HEAD(&clp->cl_state_owners);
	INIT_LIST_HEAD(&clp->cl_unused);
	spin_lock_init(&clp->cl_lock);
	INIT_WORK(&clp->cl_renewd, nfs4_renew_state, clp);
	rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");
	clp->cl_boot_time = CURRENT_TIME;
	clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED;
#endif

	return clp;

error_3:
	nfs_callback_down();
	__clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state);
error_2:
	rpciod_down();
	__clear_bit(NFS_CS_RPCIOD, &clp->cl_res_state);
error_1:
	kfree(clp);
error_0:
	return NULL;
}

/*
 * Destroy a shared client record
 */
static void nfs_free_client(struct nfs_client *clp)
{
	dprintk("--> nfs_free_client(%d)\n", clp->cl_nfsversion);

#ifdef CONFIG_NFS_V4
	if (__test_and_clear_bit(NFS_CS_IDMAP, &clp->cl_res_state)) {
		while (!list_empty(&clp->cl_unused)) {
			struct nfs4_state_owner *sp;

			sp = list_entry(clp->cl_unused.next,
					struct nfs4_state_owner,
					so_list);
			list_del(&sp->so_list);
			kfree(sp);
		}
		BUG_ON(!list_empty(&clp->cl_state_owners));
		nfs_idmap_delete(clp);
	}
#endif

	/* -EIO all pending I/O */
	if (!IS_ERR(clp->cl_rpcclient))
		rpc_shutdown_client(clp->cl_rpcclient);

	if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
		nfs_callback_down();

	if (__test_and_clear_bit(NFS_CS_RPCIOD, &clp->cl_res_state))
	rpciod_down();

	kfree(clp->cl_hostname);
	kfree(clp);

	dprintk("<-- nfs_free_client()\n");
}

/*
 * Release a reference to a shared client record
 */
void nfs_put_client(struct nfs_client *clp)
{
	dprintk("--> nfs_put_client({%d})\n", atomic_read(&clp->cl_count));

	if (atomic_dec_and_lock(&clp->cl_count, &nfs_client_lock)) {
		list_del(&clp->cl_share_link);
		spin_unlock(&nfs_client_lock);

		BUG_ON(!list_empty(&clp->cl_superblocks));

		nfs_free_client(clp);
	}
}

/*
 * Find a client by address
 * - caller must hold nfs_client_lock
 */
static struct nfs_client *__nfs_find_client(const struct sockaddr_in *addr, int nfsversion)
{
	struct nfs_client *clp;

	list_for_each_entry(clp, &nfs_client_list, cl_share_link) {
		/* Different NFS versions cannot share the same nfs_client */
		if (clp->cl_nfsversion != nfsversion)
			continue;

		if (memcmp(&clp->cl_addr.sin_addr, &addr->sin_addr,
			   sizeof(clp->cl_addr.sin_addr)) != 0)
			continue;

		if (clp->cl_addr.sin_port == addr->sin_port)
			goto found;
	}

	return NULL;

found:
	atomic_inc(&clp->cl_count);
	return clp;
}

/*
 * Find a client by IP address and protocol version
 * - returns NULL if no such client
 */
struct nfs_client *nfs_find_client(const struct sockaddr_in *addr, int nfsversion)
{
	struct nfs_client *clp;

	spin_lock(&nfs_client_lock);
	clp = __nfs_find_client(addr, nfsversion);
	spin_unlock(&nfs_client_lock);

	BUG_ON(clp->cl_cons_state == 0);

	return clp;
}

/*
 * Look up a client by IP address and protocol version
 * - creates a new record if one doesn't yet exist
 */
struct nfs_client *nfs_get_client(const char *hostname,
				  const struct sockaddr_in *addr,
				  int nfsversion)
{
	struct nfs_client *clp, *new = NULL;
	int error;

	dprintk("--> nfs_get_client(%s,"NIPQUAD_FMT":%d,%d)\n",
		hostname ?: "", NIPQUAD(addr->sin_addr),
		addr->sin_port, nfsversion);

	/* see if the client already exists */
	do {
		spin_lock(&nfs_client_lock);

		clp = __nfs_find_client(addr, nfsversion);
		if (clp)
			goto found_client;
		if (new)
			goto install_client;

		spin_unlock(&nfs_client_lock);

		new = nfs_alloc_client(hostname, addr, nfsversion);
	} while (new);

	return ERR_PTR(-ENOMEM);

	/* install a new client and return with it unready */
install_client:
	clp = new;
	list_add(&clp->cl_share_link, &nfs_client_list);
	spin_unlock(&nfs_client_lock);
	dprintk("--> nfs_get_client() = %p [new]\n", clp);
	return clp;

	/* found an existing client
	 * - make sure it's ready before returning
	 */
found_client:
	spin_unlock(&nfs_client_lock);

	if (new)
		nfs_free_client(new);

	if (clp->cl_cons_state == NFS_CS_INITING) {
		DECLARE_WAITQUEUE(myself, current);

		add_wait_queue(&nfs_client_active_wq, &myself);

		for (;;) {
			set_current_state(TASK_INTERRUPTIBLE);
			if (signal_pending(current) ||
			    clp->cl_cons_state > NFS_CS_READY)
				break;
			schedule();
		}

		remove_wait_queue(&nfs_client_active_wq, &myself);

		if (signal_pending(current)) {
			nfs_put_client(clp);
			return ERR_PTR(-ERESTARTSYS);
		}
	}

	if (clp->cl_cons_state < NFS_CS_READY) {
		error = clp->cl_cons_state;
		nfs_put_client(clp);
		return ERR_PTR(error);
	}

	dprintk("--> nfs_get_client() = %p [share]\n", clp);
	return clp;
}

/*
 * Mark a server as ready or failed
 */
void nfs_mark_client_ready(struct nfs_client *clp, int state)
{
	clp->cl_cons_state = state;
	wake_up_all(&nfs_client_active_wq);
}

/*
 * Initialise the timeout values for a connection
 */
static void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
				    unsigned int timeo, unsigned int retrans)
{
	to->to_initval = timeo * HZ / 10;
	to->to_retries = retrans;
	if (!to->to_retries)
		to->to_retries = 2;

	switch (proto) {
	case IPPROTO_TCP:
		if (!to->to_initval)
			to->to_initval = 60 * HZ;
		if (to->to_initval > NFS_MAX_TCP_TIMEOUT)
			to->to_initval = NFS_MAX_TCP_TIMEOUT;
		to->to_increment = to->to_initval;
		to->to_maxval = to->to_initval + (to->to_increment * to->to_retries);
		to->to_exponential = 0;
		break;
	case IPPROTO_UDP:
	default:
		if (!to->to_initval)
			to->to_initval = 11 * HZ / 10;
		if (to->to_initval > NFS_MAX_UDP_TIMEOUT)
			to->to_initval = NFS_MAX_UDP_TIMEOUT;
		to->to_maxval = NFS_MAX_UDP_TIMEOUT;
		to->to_exponential = 1;
		break;
	}
}

/*
 * Create an RPC client handle
 */
int nfs_create_rpc_client(struct nfs_client *clp, int proto,
			  unsigned int timeo,
			  unsigned int retrans,
			  rpc_authflavor_t flavor)
{
	struct rpc_timeout	timeparms;
	struct rpc_xprt		*xprt = NULL;
	struct rpc_clnt		*clnt = NULL;

	if (!IS_ERR(clp->cl_rpcclient))
		return 0;

	nfs_init_timeout_values(&timeparms, proto, timeo, retrans);
	clp->retrans_timeo = timeparms.to_initval;
	clp->retrans_count = timeparms.to_retries;

	/* create transport and client */
	xprt = xprt_create_proto(proto, &clp->cl_addr, &timeparms);
	if (IS_ERR(xprt)) {
		dprintk("%s: cannot create RPC transport. Error = %ld\n",
				__FUNCTION__, PTR_ERR(xprt));
		return PTR_ERR(xprt);
	}

	/* Bind to a reserved port! */
	xprt->resvport = 1;
	/* Create the client RPC handle */
	clnt = rpc_create_client(xprt, clp->cl_hostname, &nfs_program,
				 clp->rpc_ops->version, RPC_AUTH_UNIX);
	if (IS_ERR(clnt)) {
		dprintk("%s: cannot create RPC client. Error = %ld\n",
				__FUNCTION__, PTR_ERR(clnt));
		return PTR_ERR(clnt);
	}

	clnt->cl_intr     = 1;
	clnt->cl_softrtry = 1;
	clp->cl_rpcclient = clnt;
	return 0;
}
Commit	Line	Data
24c8dbbb DH	1	/* client.c: NFS client sharing and management code
	2	*
	3	* Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells ([email protected])
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
	12
	13	#include <linux/config.h>
	14	#include <linux/module.h>
	15	#include <linux/init.h>
	16
	17	#include <linux/time.h>
	18	#include <linux/kernel.h>
	19	#include <linux/mm.h>
	20	#include <linux/string.h>
	21	#include <linux/stat.h>
	22	#include <linux/errno.h>
	23	#include <linux/unistd.h>
	24	#include <linux/sunrpc/clnt.h>
	25	#include <linux/sunrpc/stats.h>
	26	#include <linux/sunrpc/metrics.h>
	27	#include <linux/nfs_fs.h>
	28	#include <linux/nfs_mount.h>
	29	#include <linux/nfs4_mount.h>
	30	#include <linux/lockd/bind.h>
	31	#include <linux/smp_lock.h>
	32	#include <linux/seq_file.h>
	33	#include <linux/mount.h>
	34	#include <linux/nfs_idmap.h>
	35	#include <linux/vfs.h>
	36	#include <linux/inet.h>
	37	#include <linux/nfs_xdr.h>
	38
	39	#include <asm/system.h>
	40
	41	#include "nfs4_fs.h"
	42	#include "callback.h"
	43	#include "delegation.h"
	44	#include "iostat.h"
	45	#include "internal.h"
	46
	47	#define NFSDBG_FACILITY NFSDBG_CLIENT
	48
	49	static DEFINE_SPINLOCK(nfs_client_lock);
	50	static LIST_HEAD(nfs_client_list);
	51	static DECLARE_WAIT_QUEUE_HEAD(nfs_client_active_wq);
	52
5006a76c DH	53	/*
	54	* RPC cruft for NFS
	55	*/
	56	static struct rpc_version *nfs_version[5] = {
	57	[2] = &nfs_version2,
	58	#ifdef CONFIG_NFS_V3
	59	[3] = &nfs_version3,
	60	#endif
	61	#ifdef CONFIG_NFS_V4
	62	[4] = &nfs_version4,
	63	#endif
	64	};
	65
	66	struct rpc_program nfs_program = {
	67	.name = "nfs",
	68	.number = NFS_PROGRAM,
	69	.nrvers = ARRAY_SIZE(nfs_version),
	70	.version = nfs_version,
	71	.stats = &nfs_rpcstat,
	72	.pipe_dir_name = "/nfs",
	73	};
	74
	75	struct rpc_stat nfs_rpcstat = {
	76	.program = &nfs_program
	77	};
	78
	79
	80	#ifdef CONFIG_NFS_V3_ACL
	81	static struct rpc_stat nfsacl_rpcstat = { &nfsacl_program };
	82	static struct rpc_version * nfsacl_version[] = {
	83	[3] = &nfsacl_version3,
	84	};
	85
	86	struct rpc_program nfsacl_program = {
	87	.name = "nfsacl",
	88	.number = NFS_ACL_PROGRAM,
	89	.nrvers = ARRAY_SIZE(nfsacl_version),
	90	.version = nfsacl_version,
	91	.stats = &nfsacl_rpcstat,
	92	};
	93	#endif /* CONFIG_NFS_V3_ACL */
	94
24c8dbbb DH	95	/*
	96	* Allocate a shared client record
	97	*
	98	* Since these are allocated/deallocated very rarely, we don't
	99	* bother putting them in a slab cache...
	100	*/
	101	static struct nfs_client nfs_alloc_client(const char hostname,
	102	const struct sockaddr_in *addr,
	103	int nfsversion)
	104	{
	105	struct nfs_client *clp;
	106	int error;
	107
	108	if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)
	109	goto error_0;
	110
	111	error = rpciod_up();
	112	if (error < 0) {
	113	dprintk("%s: couldn't start rpciod! Error = %d\n",
	114	__FUNCTION__, error);
	115	__set_bit(NFS_CS_RPCIOD, &clp->cl_res_state);
	116	goto error_1;
	117	}
	118
	119	if (nfsversion == 4) {
	120	if (nfs_callback_up() < 0)
	121	goto error_2;
	122	__set_bit(NFS_CS_CALLBACK, &clp->cl_res_state);
	123	}
	124
	125	atomic_set(&clp->cl_count, 1);
	126	clp->cl_cons_state = NFS_CS_INITING;
	127
	128	clp->cl_nfsversion = nfsversion;
	129	memcpy(&clp->cl_addr, addr, sizeof(clp->cl_addr));
	130
	131	if (hostname) {
	132	clp->cl_hostname = kstrdup(hostname, GFP_KERNEL);
	133	if (!clp->cl_hostname)
	134	goto error_3;
	135	}
	136
	137	INIT_LIST_HEAD(&clp->cl_superblocks);
	138	clp->cl_rpcclient = ERR_PTR(-EINVAL);
	139
	140	#ifdef CONFIG_NFS_V4
	141	init_rwsem(&clp->cl_sem);
	142	INIT_LIST_HEAD(&clp->cl_delegations);
	143	INIT_LIST_HEAD(&clp->cl_state_owners);
	144	INIT_LIST_HEAD(&clp->cl_unused);
	145	spin_lock_init(&clp->cl_lock);
	146	INIT_WORK(&clp->cl_renewd, nfs4_renew_state, clp);
	147	rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");
	148	clp->cl_boot_time = CURRENT_TIME;
	149	clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED;
	150	#endif
	151
	152	return clp;
	153
	154	error_3:
	155	nfs_callback_down();
	156	__clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state);
	157	error_2:
	158	rpciod_down();
159	__clear_bit(NFS_CS_RPCIOD, &clp->cl_res_state);
160	error_1:
161	kfree(clp);
162	error_0:
163	return NULL;
164	}
165
166	/*
167	* Destroy a shared client record
168	*/
169	static void nfs_free_client(struct nfs_client *clp)
170	{
171	dprintk("--> nfs_free_client(%d)\n", clp->cl_nfsversion);
172
173	#ifdef CONFIG_NFS_V4
174	if (__test_and_clear_bit(NFS_CS_IDMAP, &clp->cl_res_state)) {
175	while (!list_empty(&clp->cl_unused)) {
176	struct nfs4_state_owner *sp;
177
178	sp = list_entry(clp->cl_unused.next,
179	struct nfs4_state_owner,
180	so_list);
181	list_del(&sp->so_list);
182	kfree(sp);
183	}
184	BUG_ON(!list_empty(&clp->cl_state_owners));
185	nfs_idmap_delete(clp);
186	}
187	#endif
188
189	/* -EIO all pending I/O */
190	if (!IS_ERR(clp->cl_rpcclient))
191	rpc_shutdown_client(clp->cl_rpcclient);
192
193	if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
194	nfs_callback_down();
195
196	if (__test_and_clear_bit(NFS_CS_RPCIOD, &clp->cl_res_state))
197	rpciod_down();
198
199	kfree(clp->cl_hostname);
200	kfree(clp);
201
202	dprintk("<-- nfs_free_client()\n");
203	}
204
205	/*
206	* Release a reference to a shared client record
207	*/
208	void nfs_put_client(struct nfs_client *clp)
209	{
210	dprintk("--> nfs_put_client({%d})\n", atomic_read(&clp->cl_count));
211
212	if (atomic_dec_and_lock(&clp->cl_count, &nfs_client_lock)) {
213	list_del(&clp->cl_share_link);
214	spin_unlock(&nfs_client_lock);
215
216	BUG_ON(!list_empty(&clp->cl_superblocks));
217
218	nfs_free_client(clp);
219	}
220	}
221
222	/*
223	* Find a client by address
224	* - caller must hold nfs_client_lock
225	*/
226	static struct nfs_client __nfs_find_client(const struct sockaddr_in addr, int nfsversion)
227	{
228	struct nfs_client *clp;
229
230	list_for_each_entry(clp, &nfs_client_list, cl_share_link) {
231	/* Different NFS versions cannot share the same nfs_client */
232	if (clp->cl_nfsversion != nfsversion)
233	continue;
234
235	if (memcmp(&clp->cl_addr.sin_addr, &addr->sin_addr,
236	sizeof(clp->cl_addr.sin_addr)) != 0)
237	continue;
238
239	if (clp->cl_addr.sin_port == addr->sin_port)
240	goto found;
241	}
242
243	return NULL;
244
245	found:
246	atomic_inc(&clp->cl_count);
247	return clp;
248	}
249
250	/*
251	* Find a client by IP address and protocol version
252	* - returns NULL if no such client
253	*/
254	struct nfs_client nfs_find_client(const struct sockaddr_in addr, int nfsversion)
255	{
256	struct nfs_client *clp;
257
258	spin_lock(&nfs_client_lock);
259	clp = __nfs_find_client(addr, nfsversion);
260	spin_unlock(&nfs_client_lock);
261
262	BUG_ON(clp->cl_cons_state == 0);
263
264	return clp;
265	}
266
267	/*
268	* Look up a client by IP address and protocol version
269	* - creates a new record if one doesn't yet exist
270	*/
271	struct nfs_client nfs_get_client(const char hostname,
272	const struct sockaddr_in *addr,
273	int nfsversion)
274	{
275	struct nfs_client clp, new = NULL;
276	int error;
277
278	dprintk("--> nfs_get_client(%s,"NIPQUAD_FMT":%d,%d)\n",
279	hostname ?: "", NIPQUAD(addr->sin_addr),
280	addr->sin_port, nfsversion);
281
282	/* see if the client already exists */
283	do {
284	spin_lock(&nfs_client_lock);
285
286	clp = __nfs_find_client(addr, nfsversion);
287	if (clp)
288	goto found_client;
289	if (new)
290	goto install_client;
291
292	spin_unlock(&nfs_client_lock);
293
294	new = nfs_alloc_client(hostname, addr, nfsversion);
295	} while (new);
296
297	return ERR_PTR(-ENOMEM);
298
299	/* install a new client and return with it unready */
300	install_client:
301	clp = new;
302	list_add(&clp->cl_share_link, &nfs_client_list);
303	spin_unlock(&nfs_client_lock);
304	dprintk("--> nfs_get_client() = %p [new]\n", clp);
305	return clp;
306
307	/* found an existing client
308	* - make sure it's ready before returning
309	*/
310	found_client:
311	spin_unlock(&nfs_client_lock);
312
313	if (new)
314	nfs_free_client(new);
315
316	if (clp->cl_cons_state == NFS_CS_INITING) {
317	DECLARE_WAITQUEUE(myself, current);
318
319	add_wait_queue(&nfs_client_active_wq, &myself);
320
321	for (;;) {
322	set_current_state(TASK_INTERRUPTIBLE);
323	if (signal_pending(current) \|\|
324	clp->cl_cons_state > NFS_CS_READY)
325	break;
326	schedule();
327	}
328
329	remove_wait_queue(&nfs_client_active_wq, &myself);
330
331	if (signal_pending(current)) {
332	nfs_put_client(clp);
333	return ERR_PTR(-ERESTARTSYS);
334	}
335	}
336
337	if (clp->cl_cons_state < NFS_CS_READY) {
338	error = clp->cl_cons_state;
339	nfs_put_client(clp);
340	return ERR_PTR(error);
341	}
342
343	dprintk("--> nfs_get_client() = %p [share]\n", clp);
344	return clp;
345	}
346
347	/*
348	* Mark a server as ready or failed
349	*/
350	void nfs_mark_client_ready(struct nfs_client *clp, int state)
351	{
352	clp->cl_cons_state = state;
353	wake_up_all(&nfs_client_active_wq);
354	}
5006a76c DH	355
	356	/*
	357	* Initialise the timeout values for a connection
	358	*/
	359	static void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
	360	unsigned int timeo, unsigned int retrans)
	361	{
	362	to->to_initval = timeo * HZ / 10;
	363	to->to_retries = retrans;
	364	if (!to->to_retries)
	365	to->to_retries = 2;
	366
	367	switch (proto) {
	368	case IPPROTO_TCP:
	369	if (!to->to_initval)
	370	to->to_initval = 60 * HZ;
	371	if (to->to_initval > NFS_MAX_TCP_TIMEOUT)
	372	to->to_initval = NFS_MAX_TCP_TIMEOUT;
	373	to->to_increment = to->to_initval;
	374	to->to_maxval = to->to_initval + (to->to_increment * to->to_retries);
	375	to->to_exponential = 0;
	376	break;
	377	case IPPROTO_UDP:
	378	default:
	379	if (!to->to_initval)
	380	to->to_initval = 11 * HZ / 10;
	381	if (to->to_initval > NFS_MAX_UDP_TIMEOUT)
	382	to->to_initval = NFS_MAX_UDP_TIMEOUT;
	383	to->to_maxval = NFS_MAX_UDP_TIMEOUT;
	384	to->to_exponential = 1;
	385	break;
	386	}
	387	}
	388
	389	/*
	390	* Create an RPC client handle
	391	*/
	392	int nfs_create_rpc_client(struct nfs_client *clp, int proto,
	393	unsigned int timeo,
	394	unsigned int retrans,
	395	rpc_authflavor_t flavor)
	396	{
	397	struct rpc_timeout timeparms;
	398	struct rpc_xprt *xprt = NULL;
	399	struct rpc_clnt *clnt = NULL;
	400
	401	if (!IS_ERR(clp->cl_rpcclient))
	402	return 0;
	403
	404	nfs_init_timeout_values(&timeparms, proto, timeo, retrans);
	405	clp->retrans_timeo = timeparms.to_initval;
	406	clp->retrans_count = timeparms.to_retries;
	407
	408	/* create transport and client */
	409	xprt = xprt_create_proto(proto, &clp->cl_addr, &timeparms);
	410	if (IS_ERR(xprt)) {
	411	dprintk("%s: cannot create RPC transport. Error = %ld\n",
	412	__FUNCTION__, PTR_ERR(xprt));
	413	return PTR_ERR(xprt);
	414	}
	415
	416	/* Bind to a reserved port! */
	417	xprt->resvport = 1;
	418	/* Create the client RPC handle */
419	clnt = rpc_create_client(xprt, clp->cl_hostname, &nfs_program,
420	clp->rpc_ops->version, RPC_AUTH_UNIX);
421	if (IS_ERR(clnt)) {
422	dprintk("%s: cannot create RPC client. Error = %ld\n",
423	__FUNCTION__, PTR_ERR(clnt));
424	return PTR_ERR(clnt);
425	}
426
427	clnt->cl_intr = 1;
428	clnt->cl_softrtry = 1;
429	clp->cl_rpcclient = clnt;
430	return 0;
431	}