blob: b3dc2b88b65b139bae97fab53ad46be6b51846ab [file] [log] [blame]
David Howells24c8dbb2006-08-22 20:06:10 -04001/* client.c: NFS client sharing and management code
2 *
3 * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
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
David Howells24c8dbb2006-08-22 20:06:10 -040013#include <linux/module.h>
14#include <linux/init.h>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040015#include <linux/sched.h>
David Howells24c8dbb2006-08-22 20:06:10 -040016#include <linux/time.h>
17#include <linux/kernel.h>
18#include <linux/mm.h>
19#include <linux/string.h>
20#include <linux/stat.h>
21#include <linux/errno.h>
22#include <linux/unistd.h>
23#include <linux/sunrpc/clnt.h>
24#include <linux/sunrpc/stats.h>
25#include <linux/sunrpc/metrics.h>
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -040026#include <linux/sunrpc/xprtsock.h>
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -040027#include <linux/sunrpc/xprtrdma.h>
David Howells24c8dbb2006-08-22 20:06:10 -040028#include <linux/nfs_fs.h>
29#include <linux/nfs_mount.h>
30#include <linux/nfs4_mount.h>
31#include <linux/lockd/bind.h>
David Howells24c8dbb2006-08-22 20:06:10 -040032#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>
Trond Myklebust3b0d3f92008-01-03 13:28:58 -050037#include <linux/in6.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090038#include <linux/slab.h>
Trond Myklebust3b0d3f92008-01-03 13:28:58 -050039#include <net/ipv6.h>
David Howells24c8dbb2006-08-22 20:06:10 -040040#include <linux/nfs_xdr.h>
Andy Adamson0b5b7ae2009-04-01 09:23:15 -040041#include <linux/sunrpc/bc_xprt.h>
David Howells24c8dbb2006-08-22 20:06:10 -040042
43#include <asm/system.h>
44
45#include "nfs4_fs.h"
46#include "callback.h"
47#include "delegation.h"
48#include "iostat.h"
49#include "internal.h"
David Howells14727282009-04-03 16:42:42 +010050#include "fscache.h"
Ricardo Labiaga85e174b2010-10-20 00:17:58 -040051#include "pnfs.h"
David Howells24c8dbb2006-08-22 20:06:10 -040052
53#define NFSDBG_FACILITY NFSDBG_CLIENT
54
55static DEFINE_SPINLOCK(nfs_client_lock);
56static LIST_HEAD(nfs_client_list);
David Howells54ceac42006-08-22 20:06:13 -040057static LIST_HEAD(nfs_volume_list);
David Howells24c8dbb2006-08-22 20:06:10 -040058static DECLARE_WAIT_QUEUE_HEAD(nfs_client_active_wq);
Andy Adamsonf4eecd52011-01-06 02:04:30 +000059#ifdef CONFIG_NFS_V4
60static DEFINE_IDR(cb_ident_idr); /* Protected by nfs_client_lock */
61
62/*
63 * Get a unique NFSv4.0 callback identifier which will be used
64 * by the V4.0 callback service to lookup the nfs_client struct
65 */
66static int nfs_get_cb_ident_idr(struct nfs_client *clp, int minorversion)
67{
68 int ret = 0;
69
70 if (clp->rpc_ops->version != 4 || minorversion != 0)
71 return ret;
72retry:
73 if (!idr_pre_get(&cb_ident_idr, GFP_KERNEL))
74 return -ENOMEM;
75 spin_lock(&nfs_client_lock);
76 ret = idr_get_new(&cb_ident_idr, clp, &clp->cl_cb_ident);
77 spin_unlock(&nfs_client_lock);
78 if (ret == -EAGAIN)
79 goto retry;
80 return ret;
81}
82#endif /* CONFIG_NFS_V4 */
David Howells24c8dbb2006-08-22 20:06:10 -040083
84/*
Trond Myklebustb064eca22011-02-22 15:44:32 -080085 * Turn off NFSv4 uid/gid mapping when using AUTH_SYS
86 */
87static int nfs4_disable_idmapping = 0;
88
89/*
David Howells5006a762006-08-22 20:06:12 -040090 * RPC cruft for NFS
91 */
92static struct rpc_version *nfs_version[5] = {
93 [2] = &nfs_version2,
94#ifdef CONFIG_NFS_V3
95 [3] = &nfs_version3,
96#endif
97#ifdef CONFIG_NFS_V4
98 [4] = &nfs_version4,
99#endif
100};
101
102struct rpc_program nfs_program = {
103 .name = "nfs",
104 .number = NFS_PROGRAM,
105 .nrvers = ARRAY_SIZE(nfs_version),
106 .version = nfs_version,
107 .stats = &nfs_rpcstat,
108 .pipe_dir_name = "/nfs",
109};
110
111struct rpc_stat nfs_rpcstat = {
112 .program = &nfs_program
113};
114
115
116#ifdef CONFIG_NFS_V3_ACL
117static struct rpc_stat nfsacl_rpcstat = { &nfsacl_program };
118static struct rpc_version * nfsacl_version[] = {
119 [3] = &nfsacl_version3,
120};
121
122struct rpc_program nfsacl_program = {
123 .name = "nfsacl",
124 .number = NFS_ACL_PROGRAM,
125 .nrvers = ARRAY_SIZE(nfsacl_version),
126 .version = nfsacl_version,
127 .stats = &nfsacl_rpcstat,
128};
129#endif /* CONFIG_NFS_V3_ACL */
130
Trond Myklebust3a498022007-12-14 14:56:04 -0500131struct nfs_client_initdata {
132 const char *hostname;
Chuck Leverd7422c42007-12-10 14:58:51 -0500133 const struct sockaddr *addr;
Chuck Lever6e4cffd2007-12-10 14:58:15 -0500134 size_t addrlen;
Trond Myklebust40c553192007-12-14 14:56:07 -0500135 const struct nfs_rpc_ops *rpc_ops;
Trond Myklebust59dca3b2008-01-03 16:29:06 -0500136 int proto;
Benny Halevy5aae4a92009-04-01 09:21:50 -0400137 u32 minorversion;
Trond Myklebust3a498022007-12-14 14:56:04 -0500138};
139
David Howells5006a762006-08-22 20:06:12 -0400140/*
David Howells24c8dbb2006-08-22 20:06:10 -0400141 * Allocate a shared client record
142 *
143 * Since these are allocated/deallocated very rarely, we don't
144 * bother putting them in a slab cache...
145 */
Trond Myklebust3a498022007-12-14 14:56:04 -0500146static struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *cl_init)
David Howells24c8dbb2006-08-22 20:06:10 -0400147{
148 struct nfs_client *clp;
Trond Myklebust7c67db32008-04-07 20:50:11 -0400149 struct rpc_cred *cred;
Chuck Levera21bdd92009-06-17 18:02:10 -0700150 int err = -ENOMEM;
David Howells24c8dbb2006-08-22 20:06:10 -0400151
152 if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)
153 goto error_0;
154
Trond Myklebust40c553192007-12-14 14:56:07 -0500155 clp->rpc_ops = cl_init->rpc_ops;
156
David Howells24c8dbb2006-08-22 20:06:10 -0400157 atomic_set(&clp->cl_count, 1);
158 clp->cl_cons_state = NFS_CS_INITING;
159
Chuck Lever6e4cffd2007-12-10 14:58:15 -0500160 memcpy(&clp->cl_addr, cl_init->addr, cl_init->addrlen);
161 clp->cl_addrlen = cl_init->addrlen;
David Howells24c8dbb2006-08-22 20:06:10 -0400162
Trond Myklebust3a498022007-12-14 14:56:04 -0500163 if (cl_init->hostname) {
Chuck Levera21bdd92009-06-17 18:02:10 -0700164 err = -ENOMEM;
Trond Myklebust3a498022007-12-14 14:56:04 -0500165 clp->cl_hostname = kstrdup(cl_init->hostname, GFP_KERNEL);
David Howells24c8dbb2006-08-22 20:06:10 -0400166 if (!clp->cl_hostname)
Benny Halevy71468512009-04-01 09:22:56 -0400167 goto error_cleanup;
David Howells24c8dbb2006-08-22 20:06:10 -0400168 }
169
170 INIT_LIST_HEAD(&clp->cl_superblocks);
171 clp->cl_rpcclient = ERR_PTR(-EINVAL);
172
Trond Myklebust59dca3b2008-01-03 16:29:06 -0500173 clp->cl_proto = cl_init->proto;
174
David Howells24c8dbb2006-08-22 20:06:10 -0400175#ifdef CONFIG_NFS_V4
Andy Adamsonf4eecd52011-01-06 02:04:30 +0000176 err = nfs_get_cb_ident_idr(clp, cl_init->minorversion);
177 if (err)
178 goto error_cleanup;
179
David Howells24c8dbb2006-08-22 20:06:10 -0400180 spin_lock_init(&clp->cl_lock);
David Howells65f27f32006-11-22 14:55:48 +0000181 INIT_DELAYED_WORK(&clp->cl_renewd, nfs4_renew_state);
David Howells24c8dbb2006-08-22 20:06:10 -0400182 rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");
183 clp->cl_boot_time = CURRENT_TIME;
184 clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED;
Benny Halevy5aae4a92009-04-01 09:21:50 -0400185 clp->cl_minorversion = cl_init->minorversion;
Trond Myklebust97dc1352010-06-16 09:52:26 -0400186 clp->cl_mvops = nfs_v4_minor_ops[cl_init->minorversion];
David Howells24c8dbb2006-08-22 20:06:10 -0400187#endif
Trond Myklebust7c67db32008-04-07 20:50:11 -0400188 cred = rpc_lookup_machine_cred();
189 if (!IS_ERR(cred))
190 clp->cl_machine_cred = cred;
Andy Adamson974cec82010-10-20 00:18:02 -0400191#if defined(CONFIG_NFS_V4_1)
192 INIT_LIST_HEAD(&clp->cl_layouts);
193#endif
David Howells14727282009-04-03 16:42:42 +0100194 nfs_fscache_get_client_cookie(clp);
195
David Howells24c8dbb2006-08-22 20:06:10 -0400196 return clp;
197
Benny Halevy71468512009-04-01 09:22:56 -0400198error_cleanup:
David Howells24c8dbb2006-08-22 20:06:10 -0400199 kfree(clp);
200error_0:
Chuck Levera21bdd92009-06-17 18:02:10 -0700201 return ERR_PTR(err);
David Howells24c8dbb2006-08-22 20:06:10 -0400202}
203
Trond Myklebust5dd31772006-08-24 01:03:05 -0400204#ifdef CONFIG_NFS_V4
Andy Adamson557134a2009-04-01 09:21:53 -0400205#ifdef CONFIG_NFS_V4_1
Andy Adamsonea005282011-01-06 02:04:29 +0000206static void nfs4_shutdown_session(struct nfs_client *clp)
207{
208 if (nfs4_has_session(clp))
Andy Adamson557134a2009-04-01 09:21:53 -0400209 nfs4_destroy_session(clp->cl_session);
Andy Adamson557134a2009-04-01 09:21:53 -0400210}
Andy Adamsonea005282011-01-06 02:04:29 +0000211#else /* CONFIG_NFS_V4_1 */
212static void nfs4_shutdown_session(struct nfs_client *clp)
213{
214}
215#endif /* CONFIG_NFS_V4_1 */
Andy Adamson557134a2009-04-01 09:21:53 -0400216
217/*
Alexandros Batsakis888ef2e2010-02-05 03:45:03 -0800218 * Destroy the NFS4 callback service
219 */
220static void nfs4_destroy_callback(struct nfs_client *clp)
221{
222 if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
Trond Myklebust97dc1352010-06-16 09:52:26 -0400223 nfs_callback_down(clp->cl_mvops->minor_version);
Alexandros Batsakis888ef2e2010-02-05 03:45:03 -0800224}
225
226static void nfs4_shutdown_client(struct nfs_client *clp)
227{
228 if (__test_and_clear_bit(NFS_CS_RENEWD, &clp->cl_res_state))
229 nfs4_kill_renewd(clp);
Andy Adamsonea005282011-01-06 02:04:29 +0000230 nfs4_shutdown_session(clp);
Alexandros Batsakis888ef2e2010-02-05 03:45:03 -0800231 nfs4_destroy_callback(clp);
232 if (__test_and_clear_bit(NFS_CS_IDMAP, &clp->cl_res_state))
233 nfs_idmap_delete(clp);
234
235 rpc_destroy_wait_queue(&clp->cl_rpcwaitq);
236}
Andy Adamsonf4eecd52011-01-06 02:04:30 +0000237
238/* idr_remove_all is not needed as all id's are removed by nfs_put_client */
239void nfs_cleanup_cb_ident_idr(void)
240{
241 idr_destroy(&cb_ident_idr);
242}
243
244/* nfs_client_lock held */
245static void nfs_cb_idr_remove_locked(struct nfs_client *clp)
246{
247 if (clp->cl_cb_ident)
248 idr_remove(&cb_ident_idr, clp->cl_cb_ident);
249}
250
Fred Isamanf7e89172011-01-06 11:36:32 +0000251static void pnfs_init_server(struct nfs_server *server)
252{
253 rpc_init_wait_queue(&server->roc_rpcwaitq, "pNFS ROC");
254}
255
Alexandros Batsakis888ef2e2010-02-05 03:45:03 -0800256#else
257static void nfs4_shutdown_client(struct nfs_client *clp)
258{
259}
Andy Adamsonf4eecd52011-01-06 02:04:30 +0000260
261void nfs_cleanup_cb_ident_idr(void)
262{
263}
264
265static void nfs_cb_idr_remove_locked(struct nfs_client *clp)
266{
267}
Fred Isamanf7e89172011-01-06 11:36:32 +0000268
269static void pnfs_init_server(struct nfs_server *server)
270{
271}
272
Alexandros Batsakis888ef2e2010-02-05 03:45:03 -0800273#endif /* CONFIG_NFS_V4 */
274
275/*
David Howells24c8dbb2006-08-22 20:06:10 -0400276 * Destroy a shared client record
277 */
278static void nfs_free_client(struct nfs_client *clp)
279{
Trond Myklebust40c553192007-12-14 14:56:07 -0500280 dprintk("--> nfs_free_client(%u)\n", clp->rpc_ops->version);
David Howells24c8dbb2006-08-22 20:06:10 -0400281
Trond Myklebust5dd31772006-08-24 01:03:05 -0400282 nfs4_shutdown_client(clp);
David Howells24c8dbb2006-08-22 20:06:10 -0400283
David Howells14727282009-04-03 16:42:42 +0100284 nfs_fscache_release_client_cookie(clp);
285
David Howells24c8dbb2006-08-22 20:06:10 -0400286 /* -EIO all pending I/O */
287 if (!IS_ERR(clp->cl_rpcclient))
288 rpc_shutdown_client(clp->cl_rpcclient);
289
Trond Myklebust7c67db32008-04-07 20:50:11 -0400290 if (clp->cl_machine_cred != NULL)
291 put_rpccred(clp->cl_machine_cred);
292
Benny Halevy1775bc32011-05-20 13:47:33 +0200293 nfs4_deviceid_purge_client(clp);
294
David Howells24c8dbb2006-08-22 20:06:10 -0400295 kfree(clp->cl_hostname);
296 kfree(clp);
297
298 dprintk("<-- nfs_free_client()\n");
299}
300
301/*
302 * Release a reference to a shared client record
303 */
304void nfs_put_client(struct nfs_client *clp)
305{
David Howells27ba8512006-07-30 14:40:56 -0400306 if (!clp)
307 return;
308
David Howells24c8dbb2006-08-22 20:06:10 -0400309 dprintk("--> nfs_put_client({%d})\n", atomic_read(&clp->cl_count));
310
311 if (atomic_dec_and_lock(&clp->cl_count, &nfs_client_lock)) {
312 list_del(&clp->cl_share_link);
Andy Adamsonf4eecd52011-01-06 02:04:30 +0000313 nfs_cb_idr_remove_locked(clp);
David Howells24c8dbb2006-08-22 20:06:10 -0400314 spin_unlock(&nfs_client_lock);
315
316 BUG_ON(!list_empty(&clp->cl_superblocks));
317
318 nfs_free_client(clp);
319 }
320}
Andy Adamson16b374c2010-10-20 00:18:04 -0400321EXPORT_SYMBOL_GPL(nfs_put_client);
David Howells24c8dbb2006-08-22 20:06:10 -0400322
Trond Myklebust9082a5c2008-12-23 15:21:53 -0500323#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Trond Myklebust9f4c8992009-03-12 14:51:32 -0400324/*
325 * Test if two ip6 socket addresses refer to the same socket by
326 * comparing relevant fields. The padding bytes specifically, are not
327 * compared. sin6_flowinfo is not compared because it only affects QoS
328 * and sin6_scope_id is only compared if the address is "link local"
329 * because "link local" addresses need only be unique to a specific
330 * link. Conversely, ordinary unicast addresses might have different
331 * sin6_scope_id.
332 *
333 * The caller should ensure both socket addresses are AF_INET6.
334 */
Chuck Lever3c8c45d2009-03-18 20:48:14 -0400335static int nfs_sockaddr_match_ipaddr6(const struct sockaddr *sa1,
336 const struct sockaddr *sa2)
Trond Myklebust9f4c8992009-03-12 14:51:32 -0400337{
Chuck Lever3c8c45d2009-03-18 20:48:14 -0400338 const struct sockaddr_in6 *sin1 = (const struct sockaddr_in6 *)sa1;
339 const struct sockaddr_in6 *sin2 = (const struct sockaddr_in6 *)sa2;
Trond Myklebust9f4c8992009-03-12 14:51:32 -0400340
Chuck Lever3c8c45d2009-03-18 20:48:14 -0400341 if (ipv6_addr_scope(&sin1->sin6_addr) == IPV6_ADDR_SCOPE_LINKLOCAL &&
342 sin1->sin6_scope_id != sin2->sin6_scope_id)
Trond Myklebust9f4c8992009-03-12 14:51:32 -0400343 return 0;
Trond Myklebust3b0d3f92008-01-03 13:28:58 -0500344
Trond Myklebustb20d37c2010-09-12 19:55:26 -0400345 return ipv6_addr_equal(&sin1->sin6_addr, &sin2->sin6_addr);
Trond Myklebust3b0d3f92008-01-03 13:28:58 -0500346}
Chuck Lever3c8c45d2009-03-18 20:48:14 -0400347#else /* !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE) */
348static int nfs_sockaddr_match_ipaddr6(const struct sockaddr *sa1,
349 const struct sockaddr *sa2)
Trond Myklebust9f4c8992009-03-12 14:51:32 -0400350{
351 return 0;
352}
Trond Myklebust9082a5c2008-12-23 15:21:53 -0500353#endif
Trond Myklebust3b0d3f92008-01-03 13:28:58 -0500354
David Howells24c8dbb2006-08-22 20:06:10 -0400355/*
Ian Dalld7371c42009-03-10 20:33:22 -0400356 * Test if two ip4 socket addresses refer to the same socket, by
357 * comparing relevant fields. The padding bytes specifically, are
358 * not compared.
359 *
360 * The caller should ensure both socket addresses are AF_INET.
361 */
Chuck Lever3c8c45d2009-03-18 20:48:14 -0400362static int nfs_sockaddr_match_ipaddr4(const struct sockaddr *sa1,
363 const struct sockaddr *sa2)
364{
365 const struct sockaddr_in *sin1 = (const struct sockaddr_in *)sa1;
366 const struct sockaddr_in *sin2 = (const struct sockaddr_in *)sa2;
367
368 return sin1->sin_addr.s_addr == sin2->sin_addr.s_addr;
369}
370
371static int nfs_sockaddr_cmp_ip6(const struct sockaddr *sa1,
372 const struct sockaddr *sa2)
373{
374 const struct sockaddr_in6 *sin1 = (const struct sockaddr_in6 *)sa1;
375 const struct sockaddr_in6 *sin2 = (const struct sockaddr_in6 *)sa2;
376
377 return nfs_sockaddr_match_ipaddr6(sa1, sa2) &&
378 (sin1->sin6_port == sin2->sin6_port);
379}
380
Trond Myklebust9f4c8992009-03-12 14:51:32 -0400381static int nfs_sockaddr_cmp_ip4(const struct sockaddr *sa1,
382 const struct sockaddr *sa2)
Ian Dalld7371c42009-03-10 20:33:22 -0400383{
Chuck Lever3c8c45d2009-03-18 20:48:14 -0400384 const struct sockaddr_in *sin1 = (const struct sockaddr_in *)sa1;
385 const struct sockaddr_in *sin2 = (const struct sockaddr_in *)sa2;
Trond Myklebust9f4c8992009-03-12 14:51:32 -0400386
Chuck Lever3c8c45d2009-03-18 20:48:14 -0400387 return nfs_sockaddr_match_ipaddr4(sa1, sa2) &&
388 (sin1->sin_port == sin2->sin_port);
Ian Dalld7371c42009-03-10 20:33:22 -0400389}
390
391/*
Ian Dalld7371c42009-03-10 20:33:22 -0400392 * Test if two socket addresses represent the same actual socket,
Chuck Lever3c8c45d2009-03-18 20:48:14 -0400393 * by comparing (only) relevant fields, excluding the port number.
394 */
395static int nfs_sockaddr_match_ipaddr(const struct sockaddr *sa1,
396 const struct sockaddr *sa2)
397{
398 if (sa1->sa_family != sa2->sa_family)
399 return 0;
400
401 switch (sa1->sa_family) {
402 case AF_INET:
403 return nfs_sockaddr_match_ipaddr4(sa1, sa2);
404 case AF_INET6:
405 return nfs_sockaddr_match_ipaddr6(sa1, sa2);
406 }
407 return 0;
408}
409
410/*
411 * Test if two socket addresses represent the same actual socket,
412 * by comparing (only) relevant fields, including the port number.
Ian Dalld7371c42009-03-10 20:33:22 -0400413 */
414static int nfs_sockaddr_cmp(const struct sockaddr *sa1,
415 const struct sockaddr *sa2)
416{
417 if (sa1->sa_family != sa2->sa_family)
418 return 0;
419
420 switch (sa1->sa_family) {
421 case AF_INET:
Trond Myklebust9f4c8992009-03-12 14:51:32 -0400422 return nfs_sockaddr_cmp_ip4(sa1, sa2);
Ian Dalld7371c42009-03-10 20:33:22 -0400423 case AF_INET6:
Trond Myklebust9f4c8992009-03-12 14:51:32 -0400424 return nfs_sockaddr_cmp_ip6(sa1, sa2);
Ian Dalld7371c42009-03-10 20:33:22 -0400425 }
426 return 0;
427}
428
Andy Adamsonc36fca52011-01-06 02:04:32 +0000429/* Common match routine for v4.0 and v4.1 callback services */
430bool
431nfs4_cb_match_client(const struct sockaddr *addr, struct nfs_client *clp,
432 u32 minorversion)
Trond Myklebustc81468a2007-12-14 14:56:05 -0500433{
Andy Adamsonc36fca52011-01-06 02:04:32 +0000434 struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
Trond Myklebustc81468a2007-12-14 14:56:05 -0500435
Andy Adamsonc36fca52011-01-06 02:04:32 +0000436 /* Don't match clients that failed to initialise */
437 if (!(clp->cl_cons_state == NFS_CS_READY ||
438 clp->cl_cons_state == NFS_CS_SESSION_INITING))
439 return false;
Trond Myklebust3b0d3f92008-01-03 13:28:58 -0500440
Andy Adamsonc36fca52011-01-06 02:04:32 +0000441 /* Match the version and minorversion */
442 if (clp->rpc_ops->version != 4 ||
443 clp->cl_minorversion != minorversion)
444 return false;
Trond Myklebustc81468a2007-12-14 14:56:05 -0500445
Andy Adamsonc36fca52011-01-06 02:04:32 +0000446 /* Match only the IP address, not the port number */
447 if (!nfs_sockaddr_match_ipaddr(addr, clap))
448 return false;
Trond Myklebustc81468a2007-12-14 14:56:05 -0500449
Andy Adamsonc36fca52011-01-06 02:04:32 +0000450 return true;
Trond Myklebust3fbd67a2008-01-26 01:06:40 -0500451}
452
453/*
Trond Myklebustc81468a2007-12-14 14:56:05 -0500454 * Find an nfs_client on the list that matches the initialisation data
455 * that is supplied.
456 */
457static struct nfs_client *nfs_match_client(const struct nfs_client_initdata *data)
David Howells24c8dbb2006-08-22 20:06:10 -0400458{
459 struct nfs_client *clp;
Ian Dalld7371c42009-03-10 20:33:22 -0400460 const struct sockaddr *sap = data->addr;
David Howells24c8dbb2006-08-22 20:06:10 -0400461
462 list_for_each_entry(clp, &nfs_client_list, cl_share_link) {
Ian Dalld7371c42009-03-10 20:33:22 -0400463 const struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
Trond Myklebust13bbc062006-10-19 23:28:40 -0700464 /* Don't match clients that failed to initialise properly */
465 if (clp->cl_cons_state < 0)
466 continue;
467
David Howells24c8dbb2006-08-22 20:06:10 -0400468 /* Different NFS versions cannot share the same nfs_client */
Trond Myklebust40c553192007-12-14 14:56:07 -0500469 if (clp->rpc_ops != data->rpc_ops)
David Howells24c8dbb2006-08-22 20:06:10 -0400470 continue;
471
Trond Myklebust59dca3b2008-01-03 16:29:06 -0500472 if (clp->cl_proto != data->proto)
473 continue;
Benny Halevy5aae4a92009-04-01 09:21:50 -0400474 /* Match nfsv4 minorversion */
475 if (clp->cl_minorversion != data->minorversion)
476 continue;
Trond Myklebustc81468a2007-12-14 14:56:05 -0500477 /* Match the full socket address */
Ian Dalld7371c42009-03-10 20:33:22 -0400478 if (!nfs_sockaddr_cmp(sap, clap))
David Howells24c8dbb2006-08-22 20:06:10 -0400479 continue;
480
Trond Myklebustc81468a2007-12-14 14:56:05 -0500481 atomic_inc(&clp->cl_count);
482 return clp;
David Howells24c8dbb2006-08-22 20:06:10 -0400483 }
David Howells24c8dbb2006-08-22 20:06:10 -0400484 return NULL;
David Howells24c8dbb2006-08-22 20:06:10 -0400485}
486
487/*
488 * Look up a client by IP address and protocol version
489 * - creates a new record if one doesn't yet exist
490 */
Andy Adamson45a52a02011-03-01 01:34:08 +0000491static struct nfs_client *
492nfs_get_client(const struct nfs_client_initdata *cl_init,
493 const struct rpc_timeout *timeparms,
494 const char *ip_addr,
495 rpc_authflavor_t authflavour,
496 int noresvport)
David Howells24c8dbb2006-08-22 20:06:10 -0400497{
498 struct nfs_client *clp, *new = NULL;
499 int error;
500
Chuck Leverd7422c42007-12-10 14:58:51 -0500501 dprintk("--> nfs_get_client(%s,v%u)\n",
502 cl_init->hostname ?: "", cl_init->rpc_ops->version);
David Howells24c8dbb2006-08-22 20:06:10 -0400503
504 /* see if the client already exists */
505 do {
506 spin_lock(&nfs_client_lock);
507
Trond Myklebustc81468a2007-12-14 14:56:05 -0500508 clp = nfs_match_client(cl_init);
David Howells24c8dbb2006-08-22 20:06:10 -0400509 if (clp)
510 goto found_client;
511 if (new)
512 goto install_client;
513
514 spin_unlock(&nfs_client_lock);
515
Trond Myklebust3a498022007-12-14 14:56:04 -0500516 new = nfs_alloc_client(cl_init);
Chuck Levera21bdd92009-06-17 18:02:10 -0700517 } while (!IS_ERR(new));
David Howells24c8dbb2006-08-22 20:06:10 -0400518
Chuck Levera21bdd92009-06-17 18:02:10 -0700519 dprintk("--> nfs_get_client() = %ld [failed]\n", PTR_ERR(new));
520 return new;
David Howells24c8dbb2006-08-22 20:06:10 -0400521
522 /* install a new client and return with it unready */
523install_client:
524 clp = new;
525 list_add(&clp->cl_share_link, &nfs_client_list);
526 spin_unlock(&nfs_client_lock);
Andy Adamson45a52a02011-03-01 01:34:08 +0000527
528 error = cl_init->rpc_ops->init_client(clp, timeparms, ip_addr,
529 authflavour, noresvport);
530 if (error < 0) {
531 nfs_put_client(clp);
532 return ERR_PTR(error);
533 }
David Howells24c8dbb2006-08-22 20:06:10 -0400534 dprintk("--> nfs_get_client() = %p [new]\n", clp);
535 return clp;
536
537 /* found an existing client
538 * - make sure it's ready before returning
539 */
540found_client:
541 spin_unlock(&nfs_client_lock);
542
543 if (new)
544 nfs_free_client(new);
545
Matthew Wilcox150030b2007-12-06 16:24:39 -0500546 error = wait_event_killable(nfs_client_active_wq,
Andy Adamson76db6d92009-04-01 09:22:38 -0400547 clp->cl_cons_state < NFS_CS_INITING);
Trond Myklebust0bae89e2006-10-08 14:33:24 -0400548 if (error < 0) {
549 nfs_put_client(clp);
550 return ERR_PTR(-ERESTARTSYS);
David Howells24c8dbb2006-08-22 20:06:10 -0400551 }
552
553 if (clp->cl_cons_state < NFS_CS_READY) {
554 error = clp->cl_cons_state;
555 nfs_put_client(clp);
556 return ERR_PTR(error);
557 }
558
David Howells54ceac42006-08-22 20:06:13 -0400559 BUG_ON(clp->cl_cons_state != NFS_CS_READY);
560
David Howells24c8dbb2006-08-22 20:06:10 -0400561 dprintk("--> nfs_get_client() = %p [share]\n", clp);
562 return clp;
563}
564
565/*
566 * Mark a server as ready or failed
567 */
Andy Adamson76db6d92009-04-01 09:22:38 -0400568void nfs_mark_client_ready(struct nfs_client *clp, int state)
David Howells24c8dbb2006-08-22 20:06:10 -0400569{
570 clp->cl_cons_state = state;
571 wake_up_all(&nfs_client_active_wq);
572}
David Howells5006a762006-08-22 20:06:12 -0400573
574/*
Benny Halevy008f55d2009-04-01 09:22:50 -0400575 * With sessions, the client is not marked ready until after a
576 * successful EXCHANGE_ID and CREATE_SESSION.
577 *
578 * Map errors cl_cons_state errors to EPROTONOSUPPORT to indicate
579 * other versions of NFS can be tried.
580 */
581int nfs4_check_client_ready(struct nfs_client *clp)
582{
583 if (!nfs4_has_session(clp))
584 return 0;
585 if (clp->cl_cons_state < NFS_CS_READY)
586 return -EPROTONOSUPPORT;
587 return 0;
588}
589
590/*
David Howells5006a762006-08-22 20:06:12 -0400591 * Initialise the timeout values for a connection
592 */
593static void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
594 unsigned int timeo, unsigned int retrans)
595{
596 to->to_initval = timeo * HZ / 10;
597 to->to_retries = retrans;
David Howells5006a762006-08-22 20:06:12 -0400598
599 switch (proto) {
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -0400600 case XPRT_TRANSPORT_TCP:
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -0400601 case XPRT_TRANSPORT_RDMA:
Trond Myklebust259875e2008-07-02 14:43:47 -0400602 if (to->to_retries == 0)
603 to->to_retries = NFS_DEF_TCP_RETRANS;
Trond Myklebust7a3e3e12007-12-20 16:03:57 -0500604 if (to->to_initval == 0)
Trond Myklebust259875e2008-07-02 14:43:47 -0400605 to->to_initval = NFS_DEF_TCP_TIMEO * HZ / 10;
David Howells5006a762006-08-22 20:06:12 -0400606 if (to->to_initval > NFS_MAX_TCP_TIMEOUT)
607 to->to_initval = NFS_MAX_TCP_TIMEOUT;
608 to->to_increment = to->to_initval;
609 to->to_maxval = to->to_initval + (to->to_increment * to->to_retries);
Trond Myklebust7a3e3e12007-12-20 16:03:57 -0500610 if (to->to_maxval > NFS_MAX_TCP_TIMEOUT)
611 to->to_maxval = NFS_MAX_TCP_TIMEOUT;
612 if (to->to_maxval < to->to_initval)
613 to->to_maxval = to->to_initval;
David Howells5006a762006-08-22 20:06:12 -0400614 to->to_exponential = 0;
615 break;
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -0400616 case XPRT_TRANSPORT_UDP:
Trond Myklebust259875e2008-07-02 14:43:47 -0400617 if (to->to_retries == 0)
618 to->to_retries = NFS_DEF_UDP_RETRANS;
David Howells5006a762006-08-22 20:06:12 -0400619 if (!to->to_initval)
Trond Myklebust259875e2008-07-02 14:43:47 -0400620 to->to_initval = NFS_DEF_UDP_TIMEO * HZ / 10;
David Howells5006a762006-08-22 20:06:12 -0400621 if (to->to_initval > NFS_MAX_UDP_TIMEOUT)
622 to->to_initval = NFS_MAX_UDP_TIMEOUT;
623 to->to_maxval = NFS_MAX_UDP_TIMEOUT;
624 to->to_exponential = 1;
625 break;
Trond Myklebust259875e2008-07-02 14:43:47 -0400626 default:
627 BUG();
David Howells5006a762006-08-22 20:06:12 -0400628 }
629}
630
631/*
632 * Create an RPC client handle
633 */
Trond Myklebust59dca3b2008-01-03 16:29:06 -0500634static int nfs_create_rpc_client(struct nfs_client *clp,
Trond Myklebust33170232007-12-20 16:03:59 -0500635 const struct rpc_timeout *timeparms,
636 rpc_authflavor_t flavor,
Chuck Lever4a01b8a2008-12-23 15:21:35 -0500637 int discrtry, int noresvport)
David Howells5006a762006-08-22 20:06:12 -0400638{
David Howells5006a762006-08-22 20:06:12 -0400639 struct rpc_clnt *clnt = NULL;
Chuck Lever41877d22006-08-22 20:06:20 -0400640 struct rpc_create_args args = {
Pavel Emelyanovc653ce32010-09-29 16:04:45 +0400641 .net = &init_net,
Trond Myklebust59dca3b2008-01-03 16:29:06 -0500642 .protocol = clp->cl_proto,
Chuck Lever41877d22006-08-22 20:06:20 -0400643 .address = (struct sockaddr *)&clp->cl_addr,
Chuck Lever6e4cffd2007-12-10 14:58:15 -0500644 .addrsize = clp->cl_addrlen,
Trond Myklebust33170232007-12-20 16:03:59 -0500645 .timeout = timeparms,
Chuck Lever41877d22006-08-22 20:06:20 -0400646 .servername = clp->cl_hostname,
647 .program = &nfs_program,
648 .version = clp->rpc_ops->version,
649 .authflavor = flavor,
650 };
David Howells5006a762006-08-22 20:06:12 -0400651
Chuck Lever4a01b8a2008-12-23 15:21:35 -0500652 if (discrtry)
653 args.flags |= RPC_CLNT_CREATE_DISCRTRY;
654 if (noresvport)
655 args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
656
David Howells5006a762006-08-22 20:06:12 -0400657 if (!IS_ERR(clp->cl_rpcclient))
658 return 0;
659
Chuck Lever41877d22006-08-22 20:06:20 -0400660 clnt = rpc_create(&args);
David Howells5006a762006-08-22 20:06:12 -0400661 if (IS_ERR(clnt)) {
662 dprintk("%s: cannot create RPC client. Error = %ld\n",
Harvey Harrison3110ff82008-05-02 13:42:44 -0700663 __func__, PTR_ERR(clnt));
David Howells5006a762006-08-22 20:06:12 -0400664 return PTR_ERR(clnt);
665 }
666
David Howells5006a762006-08-22 20:06:12 -0400667 clp->cl_rpcclient = clnt;
668 return 0;
669}
David Howells54ceac42006-08-22 20:06:13 -0400670
671/*
672 * Version 2 or 3 client destruction
673 */
674static void nfs_destroy_server(struct nfs_server *server)
675{
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400676 if (!(server->flags & NFS_MOUNT_LOCAL_FLOCK) ||
677 !(server->flags & NFS_MOUNT_LOCAL_FCNTL))
Chuck Lever9289e7f2008-01-11 17:09:52 -0500678 nlmclnt_done(server->nlm_host);
David Howells54ceac42006-08-22 20:06:13 -0400679}
680
681/*
682 * Version 2 or 3 lockd setup
683 */
684static int nfs_start_lockd(struct nfs_server *server)
685{
Chuck Lever9289e7f2008-01-11 17:09:52 -0500686 struct nlm_host *host;
687 struct nfs_client *clp = server->nfs_client;
Chuck Lever883bb162008-01-15 16:04:20 -0500688 struct nlmclnt_initdata nlm_init = {
689 .hostname = clp->cl_hostname,
690 .address = (struct sockaddr *)&clp->cl_addr,
691 .addrlen = clp->cl_addrlen,
Chuck Lever883bb162008-01-15 16:04:20 -0500692 .nfs_version = clp->rpc_ops->version,
Chuck Lever0cb26592008-12-23 15:21:38 -0500693 .noresvport = server->flags & NFS_MOUNT_NORESVPORT ?
694 1 : 0,
Chuck Lever883bb162008-01-15 16:04:20 -0500695 };
David Howells54ceac42006-08-22 20:06:13 -0400696
Chuck Lever883bb162008-01-15 16:04:20 -0500697 if (nlm_init.nfs_version > 3)
Chuck Lever9289e7f2008-01-11 17:09:52 -0500698 return 0;
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400699 if ((server->flags & NFS_MOUNT_LOCAL_FLOCK) &&
700 (server->flags & NFS_MOUNT_LOCAL_FCNTL))
Chuck Lever9289e7f2008-01-11 17:09:52 -0500701 return 0;
702
Trond Myklebust8a6e5de2009-09-23 14:36:37 -0400703 switch (clp->cl_proto) {
704 default:
705 nlm_init.protocol = IPPROTO_TCP;
706 break;
707 case XPRT_TRANSPORT_UDP:
708 nlm_init.protocol = IPPROTO_UDP;
709 }
710
Chuck Lever883bb162008-01-15 16:04:20 -0500711 host = nlmclnt_init(&nlm_init);
Chuck Lever9289e7f2008-01-11 17:09:52 -0500712 if (IS_ERR(host))
713 return PTR_ERR(host);
714
715 server->nlm_host = host;
716 server->destroy = nfs_destroy_server;
717 return 0;
David Howells54ceac42006-08-22 20:06:13 -0400718}
719
720/*
721 * Initialise an NFSv3 ACL client connection
722 */
723#ifdef CONFIG_NFS_V3_ACL
724static void nfs_init_server_aclclient(struct nfs_server *server)
725{
Trond Myklebust40c553192007-12-14 14:56:07 -0500726 if (server->nfs_client->rpc_ops->version != 3)
David Howells54ceac42006-08-22 20:06:13 -0400727 goto out_noacl;
728 if (server->flags & NFS_MOUNT_NOACL)
729 goto out_noacl;
730
731 server->client_acl = rpc_bind_new_program(server->client, &nfsacl_program, 3);
732 if (IS_ERR(server->client_acl))
733 goto out_noacl;
734
735 /* No errors! Assume that Sun nfsacls are supported */
736 server->caps |= NFS_CAP_ACLS;
737 return;
738
739out_noacl:
740 server->caps &= ~NFS_CAP_ACLS;
741}
742#else
743static inline void nfs_init_server_aclclient(struct nfs_server *server)
744{
745 server->flags &= ~NFS_MOUNT_NOACL;
746 server->caps &= ~NFS_CAP_ACLS;
747}
748#endif
749
750/*
751 * Create a general RPC client
752 */
Trond Myklebust33170232007-12-20 16:03:59 -0500753static int nfs_init_server_rpcclient(struct nfs_server *server,
754 const struct rpc_timeout *timeo,
755 rpc_authflavor_t pseudoflavour)
David Howells54ceac42006-08-22 20:06:13 -0400756{
757 struct nfs_client *clp = server->nfs_client;
758
759 server->client = rpc_clone_client(clp->cl_rpcclient);
760 if (IS_ERR(server->client)) {
Harvey Harrison3110ff82008-05-02 13:42:44 -0700761 dprintk("%s: couldn't create rpc_client!\n", __func__);
David Howells54ceac42006-08-22 20:06:13 -0400762 return PTR_ERR(server->client);
763 }
764
Trond Myklebust33170232007-12-20 16:03:59 -0500765 memcpy(&server->client->cl_timeout_default,
766 timeo,
767 sizeof(server->client->cl_timeout_default));
768 server->client->cl_timeout = &server->client->cl_timeout_default;
769
David Howells54ceac42006-08-22 20:06:13 -0400770 if (pseudoflavour != clp->cl_rpcclient->cl_auth->au_flavor) {
771 struct rpc_auth *auth;
772
773 auth = rpcauth_create(pseudoflavour, server->client);
774 if (IS_ERR(auth)) {
Harvey Harrison3110ff82008-05-02 13:42:44 -0700775 dprintk("%s: couldn't create credcache!\n", __func__);
David Howells54ceac42006-08-22 20:06:13 -0400776 return PTR_ERR(auth);
777 }
778 }
779 server->client->cl_softrtry = 0;
780 if (server->flags & NFS_MOUNT_SOFT)
781 server->client->cl_softrtry = 1;
782
David Howells54ceac42006-08-22 20:06:13 -0400783 return 0;
784}
785
786/*
787 * Initialise an NFS2 or NFS3 client
788 */
Andy Adamson45a52a02011-03-01 01:34:08 +0000789int nfs_init_client(struct nfs_client *clp, const struct rpc_timeout *timeparms,
790 const char *ip_addr, rpc_authflavor_t authflavour,
791 int noresvport)
David Howells54ceac42006-08-22 20:06:13 -0400792{
David Howells54ceac42006-08-22 20:06:13 -0400793 int error;
794
795 if (clp->cl_cons_state == NFS_CS_READY) {
796 /* the client is already initialised */
797 dprintk("<-- nfs_init_client() = 0 [already %p]\n", clp);
798 return 0;
799 }
800
David Howells54ceac42006-08-22 20:06:13 -0400801 /*
802 * Create a client RPC handle for doing FSSTAT with UNIX auth only
803 * - RFC 2623, sec 2.3.2
804 */
Chuck Leverd7403512008-12-23 15:21:37 -0500805 error = nfs_create_rpc_client(clp, timeparms, RPC_AUTH_UNIX,
Andy Adamson45a52a02011-03-01 01:34:08 +0000806 0, noresvport);
David Howells54ceac42006-08-22 20:06:13 -0400807 if (error < 0)
808 goto error;
809 nfs_mark_client_ready(clp, NFS_CS_READY);
810 return 0;
811
812error:
813 nfs_mark_client_ready(clp, error);
814 dprintk("<-- nfs_init_client() = xerror %d\n", error);
815 return error;
816}
817
818/*
819 * Create a version 2 or 3 client
820 */
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -0400821static int nfs_init_server(struct nfs_server *server,
822 const struct nfs_parsed_mount_data *data)
David Howells54ceac42006-08-22 20:06:13 -0400823{
Trond Myklebust3a498022007-12-14 14:56:04 -0500824 struct nfs_client_initdata cl_init = {
825 .hostname = data->nfs_server.hostname,
Chuck Leverd7422c42007-12-10 14:58:51 -0500826 .addr = (const struct sockaddr *)&data->nfs_server.address,
Chuck Lever4c568012007-12-10 14:59:28 -0500827 .addrlen = data->nfs_server.addrlen,
Trond Myklebust40c553192007-12-14 14:56:07 -0500828 .rpc_ops = &nfs_v2_clientops,
Trond Myklebust59dca3b2008-01-03 16:29:06 -0500829 .proto = data->nfs_server.protocol,
Trond Myklebust3a498022007-12-14 14:56:04 -0500830 };
Trond Myklebust33170232007-12-20 16:03:59 -0500831 struct rpc_timeout timeparms;
David Howells54ceac42006-08-22 20:06:13 -0400832 struct nfs_client *clp;
Trond Myklebust3a498022007-12-14 14:56:04 -0500833 int error;
David Howells54ceac42006-08-22 20:06:13 -0400834
835 dprintk("--> nfs_init_server()\n");
836
837#ifdef CONFIG_NFS_V3
Trond Myklebust8a6e5de2009-09-23 14:36:37 -0400838 if (data->version == 3)
Trond Myklebust40c553192007-12-14 14:56:07 -0500839 cl_init.rpc_ops = &nfs_v3_clientops;
David Howells54ceac42006-08-22 20:06:13 -0400840#endif
841
Andy Adamson45a52a02011-03-01 01:34:08 +0000842 nfs_init_timeout_values(&timeparms, data->nfs_server.protocol,
843 data->timeo, data->retrans);
844
David Howells54ceac42006-08-22 20:06:13 -0400845 /* Allocate or find a client reference we can use */
Andy Adamson45a52a02011-03-01 01:34:08 +0000846 clp = nfs_get_client(&cl_init, &timeparms, NULL, RPC_AUTH_UNIX,
847 data->flags & NFS_MOUNT_NORESVPORT);
David Howells54ceac42006-08-22 20:06:13 -0400848 if (IS_ERR(clp)) {
849 dprintk("<-- nfs_init_server() = error %ld\n", PTR_ERR(clp));
850 return PTR_ERR(clp);
851 }
852
David Howells54ceac42006-08-22 20:06:13 -0400853 server->nfs_client = clp;
854
855 /* Initialise the client representation from the mount data */
Trond Myklebustff3525a2008-08-15 16:59:14 -0400856 server->flags = data->flags;
David Howellsb797cac2009-04-03 16:42:48 +0100857 server->options = data->options;
Trond Myklebust62ab4602009-08-09 15:06:19 -0400858 server->caps |= NFS_CAP_HARDLINKS|NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
859 NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|NFS_CAP_OWNER_GROUP|
860 NFS_CAP_ATIME|NFS_CAP_CTIME|NFS_CAP_MTIME;
David Howells54ceac42006-08-22 20:06:13 -0400861
862 if (data->rsize)
863 server->rsize = nfs_block_size(data->rsize, NULL);
864 if (data->wsize)
865 server->wsize = nfs_block_size(data->wsize, NULL);
866
867 server->acregmin = data->acregmin * HZ;
868 server->acregmax = data->acregmax * HZ;
869 server->acdirmin = data->acdirmin * HZ;
870 server->acdirmax = data->acdirmax * HZ;
871
872 /* Start lockd here, before we might error out */
873 error = nfs_start_lockd(server);
874 if (error < 0)
875 goto error;
876
Chuck Leverf22d6d72008-03-14 14:10:22 -0400877 server->port = data->nfs_server.port;
878
Trond Myklebust33170232007-12-20 16:03:59 -0500879 error = nfs_init_server_rpcclient(server, &timeparms, data->auth_flavors[0]);
David Howells54ceac42006-08-22 20:06:13 -0400880 if (error < 0)
881 goto error;
882
Chuck Lever3f8400d2008-03-14 14:10:30 -0400883 /* Preserve the values of mount_server-related mount options */
884 if (data->mount_server.addrlen) {
885 memcpy(&server->mountd_address, &data->mount_server.address,
886 data->mount_server.addrlen);
887 server->mountd_addrlen = data->mount_server.addrlen;
888 }
889 server->mountd_version = data->mount_server.version;
890 server->mountd_port = data->mount_server.port;
891 server->mountd_protocol = data->mount_server.protocol;
892
David Howells54ceac42006-08-22 20:06:13 -0400893 server->namelen = data->namlen;
894 /* Create a client RPC handle for the NFSv3 ACL management interface */
895 nfs_init_server_aclclient(server);
David Howells54ceac42006-08-22 20:06:13 -0400896 dprintk("<-- nfs_init_server() = 0 [new %p]\n", clp);
897 return 0;
898
899error:
900 server->nfs_client = NULL;
901 nfs_put_client(clp);
902 dprintk("<-- nfs_init_server() = xerror %d\n", error);
903 return error;
904}
905
906/*
907 * Load up the server record from information gained in an fsinfo record
908 */
909static void nfs_server_set_fsinfo(struct nfs_server *server, struct nfs_fsinfo *fsinfo)
910{
911 unsigned long max_rpc_payload;
912
913 /* Work out a lot of parameters */
914 if (server->rsize == 0)
915 server->rsize = nfs_block_size(fsinfo->rtpref, NULL);
916 if (server->wsize == 0)
917 server->wsize = nfs_block_size(fsinfo->wtpref, NULL);
918
919 if (fsinfo->rtmax >= 512 && server->rsize > fsinfo->rtmax)
920 server->rsize = nfs_block_size(fsinfo->rtmax, NULL);
921 if (fsinfo->wtmax >= 512 && server->wsize > fsinfo->wtmax)
922 server->wsize = nfs_block_size(fsinfo->wtmax, NULL);
923
924 max_rpc_payload = nfs_block_size(rpc_max_payload(server->client), NULL);
925 if (server->rsize > max_rpc_payload)
926 server->rsize = max_rpc_payload;
927 if (server->rsize > NFS_MAX_FILE_IO_SIZE)
928 server->rsize = NFS_MAX_FILE_IO_SIZE;
929 server->rpages = (server->rsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
Peter Zijlstrae0bf68d2007-10-16 23:25:46 -0700930
Jens Axboed9938312009-06-12 14:45:52 +0200931 server->backing_dev_info.name = "nfs";
David Howells54ceac42006-08-22 20:06:13 -0400932 server->backing_dev_info.ra_pages = server->rpages * NFS_MAX_READAHEAD;
933
934 if (server->wsize > max_rpc_payload)
935 server->wsize = max_rpc_payload;
936 if (server->wsize > NFS_MAX_FILE_IO_SIZE)
937 server->wsize = NFS_MAX_FILE_IO_SIZE;
938 server->wpages = (server->wsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
Ricardo Labiaga85e174b2010-10-20 00:17:58 -0400939 set_pnfs_layoutdriver(server, fsinfo->layouttype);
940
David Howells54ceac42006-08-22 20:06:13 -0400941 server->wtmult = nfs_block_bits(fsinfo->wtmult, NULL);
942
943 server->dtsize = nfs_block_size(fsinfo->dtpref, NULL);
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400944 if (server->dtsize > PAGE_CACHE_SIZE * NFS_MAX_READDIR_PAGES)
945 server->dtsize = PAGE_CACHE_SIZE * NFS_MAX_READDIR_PAGES;
David Howells54ceac42006-08-22 20:06:13 -0400946 if (server->dtsize > server->rsize)
947 server->dtsize = server->rsize;
948
949 if (server->flags & NFS_MOUNT_NOAC) {
950 server->acregmin = server->acregmax = 0;
951 server->acdirmin = server->acdirmax = 0;
952 }
953
954 server->maxfilesize = fsinfo->maxfilesize;
955
Ricardo Labiaga6b967242010-10-12 16:30:05 -0700956 server->time_delta = fsinfo->time_delta;
957
David Howells54ceac42006-08-22 20:06:13 -0400958 /* We're airborne Set socket buffersize */
959 rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
960}
961
962/*
963 * Probe filesystem information, including the FSID on v2/v3
964 */
965static int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *mntfh, struct nfs_fattr *fattr)
966{
967 struct nfs_fsinfo fsinfo;
968 struct nfs_client *clp = server->nfs_client;
969 int error;
970
971 dprintk("--> nfs_probe_fsinfo()\n");
972
973 if (clp->rpc_ops->set_capabilities != NULL) {
974 error = clp->rpc_ops->set_capabilities(server, mntfh);
975 if (error < 0)
976 goto out_error;
977 }
978
979 fsinfo.fattr = fattr;
Ricardo Labiaga85e174b2010-10-20 00:17:58 -0400980 fsinfo.layouttype = 0;
David Howells54ceac42006-08-22 20:06:13 -0400981 error = clp->rpc_ops->fsinfo(server, mntfh, &fsinfo);
982 if (error < 0)
983 goto out_error;
984
985 nfs_server_set_fsinfo(server, &fsinfo);
986
987 /* Get some general file system info */
988 if (server->namelen == 0) {
989 struct nfs_pathconf pathinfo;
990
991 pathinfo.fattr = fattr;
992 nfs_fattr_init(fattr);
993
994 if (clp->rpc_ops->pathconf(server, mntfh, &pathinfo) >= 0)
995 server->namelen = pathinfo.max_namelen;
996 }
997
998 dprintk("<-- nfs_probe_fsinfo() = 0\n");
999 return 0;
1000
1001out_error:
1002 dprintk("nfs_probe_fsinfo: error = %d\n", -error);
1003 return error;
1004}
1005
1006/*
1007 * Copy useful information when duplicating a server record
1008 */
1009static void nfs_server_copy_userdata(struct nfs_server *target, struct nfs_server *source)
1010{
1011 target->flags = source->flags;
Chuck Lever356e76b2010-04-22 15:35:56 -04001012 target->rsize = source->rsize;
1013 target->wsize = source->wsize;
David Howells54ceac42006-08-22 20:06:13 -04001014 target->acregmin = source->acregmin;
1015 target->acregmax = source->acregmax;
1016 target->acdirmin = source->acdirmin;
1017 target->acdirmax = source->acdirmax;
1018 target->caps = source->caps;
David Howells2df54802009-09-23 14:36:39 -04001019 target->options = source->options;
David Howells54ceac42006-08-22 20:06:13 -04001020}
1021
Chuck Leverfca52382010-12-24 01:32:32 +00001022static void nfs_server_insert_lists(struct nfs_server *server)
1023{
1024 struct nfs_client *clp = server->nfs_client;
1025
1026 spin_lock(&nfs_client_lock);
1027 list_add_tail_rcu(&server->client_link, &clp->cl_superblocks);
1028 list_add_tail(&server->master_link, &nfs_volume_list);
Andy Adamsond3b4c9d2011-03-01 01:34:10 +00001029 clear_bit(NFS_CS_STOP_RENEW, &clp->cl_res_state);
Chuck Leverfca52382010-12-24 01:32:32 +00001030 spin_unlock(&nfs_client_lock);
1031
1032}
1033
1034static void nfs_server_remove_lists(struct nfs_server *server)
1035{
Andy Adamsond3b4c9d2011-03-01 01:34:10 +00001036 struct nfs_client *clp = server->nfs_client;
1037
Chuck Leverfca52382010-12-24 01:32:32 +00001038 spin_lock(&nfs_client_lock);
1039 list_del_rcu(&server->client_link);
Andy Adamsond3b4c9d2011-03-01 01:34:10 +00001040 if (clp && list_empty(&clp->cl_superblocks))
1041 set_bit(NFS_CS_STOP_RENEW, &clp->cl_res_state);
Chuck Leverfca52382010-12-24 01:32:32 +00001042 list_del(&server->master_link);
1043 spin_unlock(&nfs_client_lock);
1044
1045 synchronize_rcu();
1046}
1047
David Howells54ceac42006-08-22 20:06:13 -04001048/*
1049 * Allocate and initialise a server record
1050 */
1051static struct nfs_server *nfs_alloc_server(void)
1052{
1053 struct nfs_server *server;
1054
1055 server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
1056 if (!server)
1057 return NULL;
1058
1059 server->client = server->client_acl = ERR_PTR(-EINVAL);
1060
1061 /* Zero out the NFS state stuff */
1062 INIT_LIST_HEAD(&server->client_link);
1063 INIT_LIST_HEAD(&server->master_link);
Chuck Leverd3978bb2010-12-24 01:33:04 +00001064 INIT_LIST_HEAD(&server->delegations);
David Howells54ceac42006-08-22 20:06:13 -04001065
Steve Dicksonef818a22007-11-08 04:05:04 -05001066 atomic_set(&server->active, 0);
1067
David Howells54ceac42006-08-22 20:06:13 -04001068 server->io_stats = nfs_alloc_iostats();
1069 if (!server->io_stats) {
1070 kfree(server);
1071 return NULL;
1072 }
1073
Jens Axboe48d07642009-09-21 09:59:39 +02001074 if (bdi_init(&server->backing_dev_info)) {
1075 nfs_free_iostats(server->io_stats);
1076 kfree(server);
1077 return NULL;
1078 }
1079
Fred Isamanf7e89172011-01-06 11:36:32 +00001080 pnfs_init_server(server);
1081
David Howells54ceac42006-08-22 20:06:13 -04001082 return server;
1083}
1084
1085/*
1086 * Free up a server record
1087 */
1088void nfs_free_server(struct nfs_server *server)
1089{
1090 dprintk("--> nfs_free_server()\n");
1091
Chuck Leverfca52382010-12-24 01:32:32 +00001092 nfs_server_remove_lists(server);
Ricardo Labiaga85e174b2010-10-20 00:17:58 -04001093 unset_pnfs_layoutdriver(server);
David Howells54ceac42006-08-22 20:06:13 -04001094
1095 if (server->destroy != NULL)
1096 server->destroy(server);
Trond Myklebust5cef3382007-12-11 22:01:56 -05001097
1098 if (!IS_ERR(server->client_acl))
1099 rpc_shutdown_client(server->client_acl);
David Howells54ceac42006-08-22 20:06:13 -04001100 if (!IS_ERR(server->client))
1101 rpc_shutdown_client(server->client);
1102
1103 nfs_put_client(server->nfs_client);
1104
1105 nfs_free_iostats(server->io_stats);
Peter Zijlstrae0bf68d2007-10-16 23:25:46 -07001106 bdi_destroy(&server->backing_dev_info);
David Howells54ceac42006-08-22 20:06:13 -04001107 kfree(server);
1108 nfs_release_automount_timer();
1109 dprintk("<-- nfs_free_server()\n");
1110}
1111
1112/*
1113 * Create a version 2 or 3 volume record
1114 * - keyed on server and FSID
1115 */
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001116struct nfs_server *nfs_create_server(const struct nfs_parsed_mount_data *data,
David Howells54ceac42006-08-22 20:06:13 -04001117 struct nfs_fh *mntfh)
1118{
1119 struct nfs_server *server;
Trond Myklebustfbca7792010-04-16 16:22:46 -04001120 struct nfs_fattr *fattr;
David Howells54ceac42006-08-22 20:06:13 -04001121 int error;
1122
1123 server = nfs_alloc_server();
1124 if (!server)
1125 return ERR_PTR(-ENOMEM);
1126
Trond Myklebustfbca7792010-04-16 16:22:46 -04001127 error = -ENOMEM;
1128 fattr = nfs_alloc_fattr();
1129 if (fattr == NULL)
1130 goto error;
1131
David Howells54ceac42006-08-22 20:06:13 -04001132 /* Get a client representation */
1133 error = nfs_init_server(server, data);
1134 if (error < 0)
1135 goto error;
1136
1137 BUG_ON(!server->nfs_client);
1138 BUG_ON(!server->nfs_client->rpc_ops);
1139 BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
1140
1141 /* Probe the root fh to retrieve its FSID */
Trond Myklebustfbca7792010-04-16 16:22:46 -04001142 error = nfs_probe_fsinfo(server, mntfh, fattr);
David Howells54ceac42006-08-22 20:06:13 -04001143 if (error < 0)
1144 goto error;
Trond Myklebust54af3bb2007-09-28 12:27:41 -04001145 if (server->nfs_client->rpc_ops->version == 3) {
1146 if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
1147 server->namelen = NFS3_MAXNAMLEN;
1148 if (!(data->flags & NFS_MOUNT_NORDIRPLUS))
1149 server->caps |= NFS_CAP_READDIRPLUS;
1150 } else {
1151 if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
1152 server->namelen = NFS2_MAXNAMLEN;
1153 }
1154
Trond Myklebustfbca7792010-04-16 16:22:46 -04001155 if (!(fattr->valid & NFS_ATTR_FATTR)) {
1156 error = server->nfs_client->rpc_ops->getattr(server, mntfh, fattr);
David Howells54ceac42006-08-22 20:06:13 -04001157 if (error < 0) {
1158 dprintk("nfs_create_server: getattr error = %d\n", -error);
1159 goto error;
1160 }
1161 }
Trond Myklebustfbca7792010-04-16 16:22:46 -04001162 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
David Howells54ceac42006-08-22 20:06:13 -04001163
David Howells6daabf12006-08-24 15:44:16 -04001164 dprintk("Server FSID: %llx:%llx\n",
1165 (unsigned long long) server->fsid.major,
1166 (unsigned long long) server->fsid.minor);
David Howells54ceac42006-08-22 20:06:13 -04001167
Chuck Leverfca52382010-12-24 01:32:32 +00001168 nfs_server_insert_lists(server);
David Howells54ceac42006-08-22 20:06:13 -04001169 server->mount_time = jiffies;
Trond Myklebustfbca7792010-04-16 16:22:46 -04001170 nfs_free_fattr(fattr);
David Howells54ceac42006-08-22 20:06:13 -04001171 return server;
1172
1173error:
Trond Myklebustfbca7792010-04-16 16:22:46 -04001174 nfs_free_fattr(fattr);
David Howells54ceac42006-08-22 20:06:13 -04001175 nfs_free_server(server);
1176 return ERR_PTR(error);
1177}
1178
1179#ifdef CONFIG_NFS_V4
1180/*
Andy Adamsonc36fca52011-01-06 02:04:32 +00001181 * NFSv4.0 callback thread helper
1182 *
1183 * Find a client by IP address, protocol version, and minorversion
1184 *
1185 * Called from the pg_authenticate method. The callback identifier
1186 * is not used as it has not been decoded.
1187 *
1188 * Returns NULL if no such client
1189 */
1190struct nfs_client *
1191nfs4_find_client_no_ident(const struct sockaddr *addr)
1192{
1193 struct nfs_client *clp;
1194
1195 spin_lock(&nfs_client_lock);
1196 list_for_each_entry(clp, &nfs_client_list, cl_share_link) {
1197 if (nfs4_cb_match_client(addr, clp, 0) == false)
1198 continue;
1199 atomic_inc(&clp->cl_count);
1200 spin_unlock(&nfs_client_lock);
1201 return clp;
1202 }
1203 spin_unlock(&nfs_client_lock);
1204 return NULL;
1205}
1206
1207/*
1208 * NFSv4.0 callback thread helper
1209 *
1210 * Find a client by callback identifier
1211 */
1212struct nfs_client *
1213nfs4_find_client_ident(int cb_ident)
1214{
1215 struct nfs_client *clp;
1216
1217 spin_lock(&nfs_client_lock);
1218 clp = idr_find(&cb_ident_idr, cb_ident);
1219 if (clp)
1220 atomic_inc(&clp->cl_count);
1221 spin_unlock(&nfs_client_lock);
1222 return clp;
1223}
1224
1225#if defined(CONFIG_NFS_V4_1)
1226/*
1227 * NFSv4.1 callback thread helper
1228 * For CB_COMPOUND calls, find a client by IP address, protocol version,
1229 * minorversion, and sessionID
1230 *
Andy Adamsonc36fca52011-01-06 02:04:32 +00001231 * Returns NULL if no such client
1232 */
1233struct nfs_client *
1234nfs4_find_client_sessionid(const struct sockaddr *addr,
Andy Adamson778be232011-01-25 15:38:01 +00001235 struct nfs4_sessionid *sid)
Andy Adamsonc36fca52011-01-06 02:04:32 +00001236{
1237 struct nfs_client *clp;
1238
1239 spin_lock(&nfs_client_lock);
1240 list_for_each_entry(clp, &nfs_client_list, cl_share_link) {
1241 if (nfs4_cb_match_client(addr, clp, 1) == false)
1242 continue;
1243
1244 if (!nfs4_has_session(clp))
1245 continue;
1246
Andy Adamson778be232011-01-25 15:38:01 +00001247 /* Match sessionid*/
1248 if (memcmp(clp->cl_session->sess_id.data,
1249 sid->data, NFS4_MAX_SESSIONID_LEN) != 0)
Andy Adamsonc36fca52011-01-06 02:04:32 +00001250 continue;
1251
1252 atomic_inc(&clp->cl_count);
1253 spin_unlock(&nfs_client_lock);
1254 return clp;
1255 }
1256 spin_unlock(&nfs_client_lock);
1257 return NULL;
1258}
1259
1260#else /* CONFIG_NFS_V4_1 */
1261
1262struct nfs_client *
1263nfs4_find_client_sessionid(const struct sockaddr *addr,
Andy Adamson778be232011-01-25 15:38:01 +00001264 struct nfs4_sessionid *sid)
Andy Adamsonc36fca52011-01-06 02:04:32 +00001265{
1266 return NULL;
1267}
1268#endif /* CONFIG_NFS_V4_1 */
1269
1270/*
Benny Halevy9bdaa862009-04-01 09:22:55 -04001271 * Initialize the NFS4 callback service
1272 */
1273static int nfs4_init_callback(struct nfs_client *clp)
1274{
1275 int error;
1276
1277 if (clp->rpc_ops->version == 4) {
Andy Adamson0b5b7ae2009-04-01 09:23:15 -04001278 if (nfs4_has_session(clp)) {
1279 error = xprt_setup_backchannel(
1280 clp->cl_rpcclient->cl_xprt,
1281 NFS41_BC_MIN_CALLBACKS);
1282 if (error < 0)
1283 return error;
1284 }
1285
Trond Myklebust97dc1352010-06-16 09:52:26 -04001286 error = nfs_callback_up(clp->cl_mvops->minor_version,
Benny Halevy71468512009-04-01 09:22:56 -04001287 clp->cl_rpcclient->cl_xprt);
Benny Halevy9bdaa862009-04-01 09:22:55 -04001288 if (error < 0) {
1289 dprintk("%s: failed to start callback. Error = %d\n",
1290 __func__, error);
1291 return error;
1292 }
1293 __set_bit(NFS_CS_CALLBACK, &clp->cl_res_state);
1294 }
1295 return 0;
1296}
1297
1298/*
Andy Adamson557134a2009-04-01 09:21:53 -04001299 * Initialize the minor version specific parts of an NFS4 client record
1300 */
1301static int nfs4_init_client_minor_version(struct nfs_client *clp)
1302{
1303#if defined(CONFIG_NFS_V4_1)
Trond Myklebust97dc1352010-06-16 09:52:26 -04001304 if (clp->cl_mvops->minor_version) {
Andy Adamson557134a2009-04-01 09:21:53 -04001305 struct nfs4_session *session = NULL;
1306 /*
1307 * Create the session and mark it expired.
1308 * When a SEQUENCE operation encounters the expired session
1309 * it will do session recovery to initialize it.
1310 */
1311 session = nfs4_alloc_session(clp);
1312 if (!session)
1313 return -ENOMEM;
1314
1315 clp->cl_session = session;
Trond Myklebustfe74ba32010-06-16 09:52:27 -04001316 /*
1317 * The create session reply races with the server back
1318 * channel probe. Mark the client NFS_CS_SESSION_INITING
1319 * so that the client back channel can find the
1320 * nfs_client struct
1321 */
1322 clp->cl_cons_state = NFS_CS_SESSION_INITING;
Andy Adamson557134a2009-04-01 09:21:53 -04001323 }
1324#endif /* CONFIG_NFS_V4_1 */
1325
Benny Halevy71468512009-04-01 09:22:56 -04001326 return nfs4_init_callback(clp);
Andy Adamson557134a2009-04-01 09:21:53 -04001327}
1328
1329/*
David Howells54ceac42006-08-22 20:06:13 -04001330 * Initialise an NFS4 client record
1331 */
Andy Adamson45a52a02011-03-01 01:34:08 +00001332int nfs4_init_client(struct nfs_client *clp,
1333 const struct rpc_timeout *timeparms,
1334 const char *ip_addr,
1335 rpc_authflavor_t authflavour,
1336 int noresvport)
David Howells54ceac42006-08-22 20:06:13 -04001337{
1338 int error;
1339
1340 if (clp->cl_cons_state == NFS_CS_READY) {
1341 /* the client is initialised already */
1342 dprintk("<-- nfs4_init_client() = 0 [already %p]\n", clp);
1343 return 0;
1344 }
1345
1346 /* Check NFS protocol revision and initialize RPC op vector */
1347 clp->rpc_ops = &nfs_v4_clientops;
1348
Trond Myklebust59dca3b2008-01-03 16:29:06 -05001349 error = nfs_create_rpc_client(clp, timeparms, authflavour,
Andy Adamson45a52a02011-03-01 01:34:08 +00001350 1, noresvport);
David Howells54ceac42006-08-22 20:06:13 -04001351 if (error < 0)
1352 goto error;
Ben Hutchingsf4373bf2009-10-06 15:42:18 -04001353 strlcpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr));
David Howells54ceac42006-08-22 20:06:13 -04001354
1355 error = nfs_idmap_new(clp);
1356 if (error < 0) {
1357 dprintk("%s: failed to create idmapper. Error = %d\n",
Harvey Harrison3110ff82008-05-02 13:42:44 -07001358 __func__, error);
David Howells54ceac42006-08-22 20:06:13 -04001359 goto error;
1360 }
Trond Myklebust9c5bf382006-08-22 20:06:14 -04001361 __set_bit(NFS_CS_IDMAP, &clp->cl_res_state);
David Howells54ceac42006-08-22 20:06:13 -04001362
Andy Adamson557134a2009-04-01 09:21:53 -04001363 error = nfs4_init_client_minor_version(clp);
1364 if (error < 0)
1365 goto error;
1366
Andy Adamson76db6d92009-04-01 09:22:38 -04001367 if (!nfs4_has_session(clp))
1368 nfs_mark_client_ready(clp, NFS_CS_READY);
David Howells54ceac42006-08-22 20:06:13 -04001369 return 0;
1370
1371error:
1372 nfs_mark_client_ready(clp, error);
1373 dprintk("<-- nfs4_init_client() = xerror %d\n", error);
1374 return error;
1375}
1376
1377/*
1378 * Set up an NFS4 client
1379 */
1380static int nfs4_set_client(struct nfs_server *server,
Chuck Leverdcecae02007-12-10 14:58:59 -05001381 const char *hostname,
1382 const struct sockaddr *addr,
1383 const size_t addrlen,
J. Bruce Fields7d9ac062006-10-19 23:28:39 -07001384 const char *ip_addr,
David Howells54ceac42006-08-22 20:06:13 -04001385 rpc_authflavor_t authflavour,
Benny Halevy94a417f2009-04-01 09:21:49 -04001386 int proto, const struct rpc_timeout *timeparms,
1387 u32 minorversion)
David Howells54ceac42006-08-22 20:06:13 -04001388{
Trond Myklebust3a498022007-12-14 14:56:04 -05001389 struct nfs_client_initdata cl_init = {
1390 .hostname = hostname,
Chuck Leverdcecae02007-12-10 14:58:59 -05001391 .addr = addr,
1392 .addrlen = addrlen,
Trond Myklebust40c553192007-12-14 14:56:07 -05001393 .rpc_ops = &nfs_v4_clientops,
Trond Myklebust59dca3b2008-01-03 16:29:06 -05001394 .proto = proto,
Benny Halevy5aae4a92009-04-01 09:21:50 -04001395 .minorversion = minorversion,
Trond Myklebust3a498022007-12-14 14:56:04 -05001396 };
David Howells54ceac42006-08-22 20:06:13 -04001397 struct nfs_client *clp;
1398 int error;
1399
1400 dprintk("--> nfs4_set_client()\n");
1401
1402 /* Allocate or find a client reference we can use */
Andy Adamson45a52a02011-03-01 01:34:08 +00001403 clp = nfs_get_client(&cl_init, timeparms, ip_addr, authflavour,
1404 server->flags & NFS_MOUNT_NORESVPORT);
David Howells54ceac42006-08-22 20:06:13 -04001405 if (IS_ERR(clp)) {
1406 error = PTR_ERR(clp);
1407 goto error;
1408 }
David Howells54ceac42006-08-22 20:06:13 -04001409
Andy Adamsond6fb79d2011-03-01 01:34:11 +00001410 /*
1411 * Query for the lease time on clientid setup or renewal
1412 *
1413 * Note that this will be set on nfs_clients that were created
1414 * only for the DS role and did not set this bit, but now will
1415 * serve a dual role.
1416 */
1417 set_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state);
1418
David Howells54ceac42006-08-22 20:06:13 -04001419 server->nfs_client = clp;
1420 dprintk("<-- nfs4_set_client() = 0 [new %p]\n", clp);
1421 return 0;
David Howells54ceac42006-08-22 20:06:13 -04001422error:
1423 dprintk("<-- nfs4_set_client() = xerror %d\n", error);
1424 return error;
1425}
1426
Andy Adamsond83217c2011-03-01 01:34:17 +00001427/*
1428 * Set up a pNFS Data Server client.
1429 *
1430 * Return any existing nfs_client that matches server address,port,version
1431 * and minorversion.
1432 *
1433 * For a new nfs_client, use a soft mount (default), a low retrans and a
1434 * low timeout interval so that if a connection is lost, we retry through
1435 * the MDS.
1436 */
1437struct nfs_client *nfs4_set_ds_client(struct nfs_client* mds_clp,
1438 const struct sockaddr *ds_addr,
1439 int ds_addrlen, int ds_proto)
1440{
1441 struct nfs_client_initdata cl_init = {
1442 .addr = ds_addr,
1443 .addrlen = ds_addrlen,
1444 .rpc_ops = &nfs_v4_clientops,
1445 .proto = ds_proto,
1446 .minorversion = mds_clp->cl_minorversion,
1447 };
1448 struct rpc_timeout ds_timeout = {
1449 .to_initval = 15 * HZ,
1450 .to_maxval = 15 * HZ,
1451 .to_retries = 1,
1452 .to_exponential = 1,
1453 };
1454 struct nfs_client *clp;
1455
1456 /*
1457 * Set an authflavor equual to the MDS value. Use the MDS nfs_client
1458 * cl_ipaddr so as to use the same EXCHANGE_ID co_ownerid as the MDS
1459 * (section 13.1 RFC 5661).
1460 */
1461 clp = nfs_get_client(&cl_init, &ds_timeout, mds_clp->cl_ipaddr,
1462 mds_clp->cl_rpcclient->cl_auth->au_flavor, 0);
1463
1464 dprintk("<-- %s %p\n", __func__, clp);
1465 return clp;
1466}
1467EXPORT_SYMBOL(nfs4_set_ds_client);
Andy Adamson557134a2009-04-01 09:21:53 -04001468
1469/*
Andy Adamson96b09e02009-04-01 09:22:33 -04001470 * Session has been established, and the client marked ready.
1471 * Set the mount rsize and wsize with negotiated fore channel
1472 * attributes which will be bound checked in nfs_server_set_fsinfo.
1473 */
1474static void nfs4_session_set_rwsize(struct nfs_server *server)
1475{
1476#ifdef CONFIG_NFS_V4_1
Alexandros Batsakis2449ea22009-12-05 13:36:55 -05001477 struct nfs4_session *sess;
1478 u32 server_resp_sz;
1479 u32 server_rqst_sz;
1480
Andy Adamson96b09e02009-04-01 09:22:33 -04001481 if (!nfs4_has_session(server->nfs_client))
1482 return;
Alexandros Batsakis2449ea22009-12-05 13:36:55 -05001483 sess = server->nfs_client->cl_session;
1484 server_resp_sz = sess->fc_attrs.max_resp_sz - nfs41_maxread_overhead;
1485 server_rqst_sz = sess->fc_attrs.max_rqst_sz - nfs41_maxwrite_overhead;
1486
1487 if (server->rsize > server_resp_sz)
1488 server->rsize = server_resp_sz;
1489 if (server->wsize > server_rqst_sz)
1490 server->wsize = server_rqst_sz;
Andy Adamson96b09e02009-04-01 09:22:33 -04001491#endif /* CONFIG_NFS_V4_1 */
1492}
1493
Trond Myklebust44950b62010-06-17 11:45:12 -04001494static int nfs4_server_common_setup(struct nfs_server *server,
1495 struct nfs_fh *mntfh)
1496{
1497 struct nfs_fattr *fattr;
1498 int error;
1499
1500 BUG_ON(!server->nfs_client);
1501 BUG_ON(!server->nfs_client->rpc_ops);
1502 BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
1503
Andy Adamson94de8b22011-03-01 01:34:12 +00001504 /* data servers support only a subset of NFSv4.1 */
1505 if (is_ds_only_client(server->nfs_client))
1506 return -EPROTONOSUPPORT;
1507
Trond Myklebust44950b62010-06-17 11:45:12 -04001508 fattr = nfs_alloc_fattr();
1509 if (fattr == NULL)
1510 return -ENOMEM;
1511
1512 /* We must ensure the session is initialised first */
1513 error = nfs4_init_session(server);
1514 if (error < 0)
1515 goto out;
1516
1517 /* Probe the root fh to retrieve its FSID and filehandle */
1518 error = nfs4_get_rootfh(server, mntfh);
1519 if (error < 0)
1520 goto out;
1521
1522 dprintk("Server FSID: %llx:%llx\n",
1523 (unsigned long long) server->fsid.major,
1524 (unsigned long long) server->fsid.minor);
1525 dprintk("Mount FH: %d\n", mntfh->size);
1526
1527 nfs4_session_set_rwsize(server);
1528
1529 error = nfs_probe_fsinfo(server, mntfh, fattr);
1530 if (error < 0)
1531 goto out;
1532
1533 if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
1534 server->namelen = NFS4_MAXNAMLEN;
1535
Chuck Leverfca52382010-12-24 01:32:32 +00001536 nfs_server_insert_lists(server);
Trond Myklebust44950b62010-06-17 11:45:12 -04001537 server->mount_time = jiffies;
1538out:
1539 nfs_free_fattr(fattr);
1540 return error;
1541}
1542
Andy Adamson96b09e02009-04-01 09:22:33 -04001543/*
David Howells54ceac42006-08-22 20:06:13 -04001544 * Create a version 4 volume record
1545 */
1546static int nfs4_init_server(struct nfs_server *server,
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04001547 const struct nfs_parsed_mount_data *data)
David Howells54ceac42006-08-22 20:06:13 -04001548{
Trond Myklebust33170232007-12-20 16:03:59 -05001549 struct rpc_timeout timeparms;
David Howells54ceac42006-08-22 20:06:13 -04001550 int error;
1551
1552 dprintk("--> nfs4_init_server()\n");
1553
Trond Myklebust33170232007-12-20 16:03:59 -05001554 nfs_init_timeout_values(&timeparms, data->nfs_server.protocol,
1555 data->timeo, data->retrans);
1556
Chuck Lever542fcc32008-12-23 15:21:36 -05001557 /* Initialise the client representation from the mount data */
1558 server->flags = data->flags;
Bryan Schumaker82f2e542010-10-21 16:33:18 -04001559 server->caps |= NFS_CAP_ATOMIC_OPEN|NFS_CAP_CHANGE_ATTR|NFS_CAP_POSIX_LOCK;
1560 if (!(data->flags & NFS_MOUNT_NORDIRPLUS))
1561 server->caps |= NFS_CAP_READDIRPLUS;
David Howellsb797cac2009-04-03 16:42:48 +01001562 server->options = data->options;
Chuck Lever542fcc32008-12-23 15:21:36 -05001563
Trond Myklebust33170232007-12-20 16:03:59 -05001564 /* Get a client record */
1565 error = nfs4_set_client(server,
1566 data->nfs_server.hostname,
1567 (const struct sockaddr *)&data->nfs_server.address,
1568 data->nfs_server.addrlen,
1569 data->client_address,
1570 data->auth_flavors[0],
1571 data->nfs_server.protocol,
Benny Halevy94a417f2009-04-01 09:21:49 -04001572 &timeparms,
1573 data->minorversion);
Trond Myklebust33170232007-12-20 16:03:59 -05001574 if (error < 0)
1575 goto error;
1576
Trond Myklebustb064eca22011-02-22 15:44:32 -08001577 /*
1578 * Don't use NFS uid/gid mapping if we're using AUTH_SYS or lower
1579 * authentication.
1580 */
1581 if (nfs4_disable_idmapping && data->auth_flavors[0] == RPC_AUTH_UNIX)
1582 server->caps |= NFS_CAP_UIDGID_NOMAP;
1583
David Howells54ceac42006-08-22 20:06:13 -04001584 if (data->rsize)
1585 server->rsize = nfs_block_size(data->rsize, NULL);
1586 if (data->wsize)
1587 server->wsize = nfs_block_size(data->wsize, NULL);
1588
1589 server->acregmin = data->acregmin * HZ;
1590 server->acregmax = data->acregmax * HZ;
1591 server->acdirmin = data->acdirmin * HZ;
1592 server->acdirmax = data->acdirmax * HZ;
1593
Chuck Leverf22d6d72008-03-14 14:10:22 -04001594 server->port = data->nfs_server.port;
1595
Trond Myklebust33170232007-12-20 16:03:59 -05001596 error = nfs_init_server_rpcclient(server, &timeparms, data->auth_flavors[0]);
David Howells54ceac42006-08-22 20:06:13 -04001597
Trond Myklebust33170232007-12-20 16:03:59 -05001598error:
David Howells54ceac42006-08-22 20:06:13 -04001599 /* Done */
1600 dprintk("<-- nfs4_init_server() = %d\n", error);
1601 return error;
1602}
1603
1604/*
1605 * Create a version 4 volume record
1606 * - keyed on server and FSID
1607 */
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04001608struct nfs_server *nfs4_create_server(const struct nfs_parsed_mount_data *data,
David Howells54ceac42006-08-22 20:06:13 -04001609 struct nfs_fh *mntfh)
1610{
David Howells54ceac42006-08-22 20:06:13 -04001611 struct nfs_server *server;
1612 int error;
1613
1614 dprintk("--> nfs4_create_server()\n");
1615
1616 server = nfs_alloc_server();
1617 if (!server)
1618 return ERR_PTR(-ENOMEM);
1619
David Howells54ceac42006-08-22 20:06:13 -04001620 /* set up the general RPC client */
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04001621 error = nfs4_init_server(server, data);
David Howells54ceac42006-08-22 20:06:13 -04001622 if (error < 0)
1623 goto error;
1624
Trond Myklebust44950b62010-06-17 11:45:12 -04001625 error = nfs4_server_common_setup(server, mntfh);
Trond Myklebustfccba802009-07-21 16:48:07 -04001626 if (error < 0)
1627 goto error;
Andy Adamson557134a2009-04-01 09:21:53 -04001628
David Howells54ceac42006-08-22 20:06:13 -04001629 dprintk("<-- nfs4_create_server() = %p\n", server);
1630 return server;
1631
1632error:
1633 nfs_free_server(server);
1634 dprintk("<-- nfs4_create_server() = error %d\n", error);
1635 return ERR_PTR(error);
1636}
1637
1638/*
1639 * Create an NFS4 referral server record
1640 */
1641struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
Trond Myklebustf2d0d852007-02-02 14:46:09 -08001642 struct nfs_fh *mntfh)
David Howells54ceac42006-08-22 20:06:13 -04001643{
1644 struct nfs_client *parent_client;
1645 struct nfs_server *server, *parent_server;
David Howells54ceac42006-08-22 20:06:13 -04001646 int error;
1647
1648 dprintk("--> nfs4_create_referral_server()\n");
1649
1650 server = nfs_alloc_server();
1651 if (!server)
1652 return ERR_PTR(-ENOMEM);
1653
1654 parent_server = NFS_SB(data->sb);
1655 parent_client = parent_server->nfs_client;
1656
Chuck Lever542fcc32008-12-23 15:21:36 -05001657 /* Initialise the client representation from the parent server */
1658 nfs_server_copy_userdata(server, parent_server);
Trond Myklebust62ab4602009-08-09 15:06:19 -04001659 server->caps |= NFS_CAP_ATOMIC_OPEN|NFS_CAP_CHANGE_ATTR;
Chuck Lever542fcc32008-12-23 15:21:36 -05001660
David Howells54ceac42006-08-22 20:06:13 -04001661 /* Get a client representation.
1662 * Note: NFSv4 always uses TCP, */
Chuck Leverdcecae02007-12-10 14:58:59 -05001663 error = nfs4_set_client(server, data->hostname,
Chuck Lever6677d092007-12-10 14:59:06 -05001664 data->addr,
1665 data->addrlen,
Chuck Leverdcecae02007-12-10 14:58:59 -05001666 parent_client->cl_ipaddr,
1667 data->authflavor,
1668 parent_server->client->cl_xprt->prot,
Benny Halevy94a417f2009-04-01 09:21:49 -04001669 parent_server->client->cl_timeout,
Trond Myklebust97dc1352010-06-16 09:52:26 -04001670 parent_client->cl_mvops->minor_version);
andros@citi.umich.edu297de4f2006-08-29 12:19:41 -04001671 if (error < 0)
1672 goto error;
David Howells54ceac42006-08-22 20:06:13 -04001673
Trond Myklebust33170232007-12-20 16:03:59 -05001674 error = nfs_init_server_rpcclient(server, parent_server->client->cl_timeout, data->authflavor);
David Howells54ceac42006-08-22 20:06:13 -04001675 if (error < 0)
1676 goto error;
1677
Trond Myklebust44950b62010-06-17 11:45:12 -04001678 error = nfs4_server_common_setup(server, mntfh);
Trond Myklebustf2d0d852007-02-02 14:46:09 -08001679 if (error < 0)
1680 goto error;
1681
David Howells54ceac42006-08-22 20:06:13 -04001682 dprintk("<-- nfs_create_referral_server() = %p\n", server);
1683 return server;
1684
1685error:
1686 nfs_free_server(server);
1687 dprintk("<-- nfs4_create_referral_server() = error %d\n", error);
1688 return ERR_PTR(error);
1689}
1690
1691#endif /* CONFIG_NFS_V4 */
1692
1693/*
1694 * Clone an NFS2, NFS3 or NFS4 server record
1695 */
1696struct nfs_server *nfs_clone_server(struct nfs_server *source,
1697 struct nfs_fh *fh,
1698 struct nfs_fattr *fattr)
1699{
1700 struct nfs_server *server;
Trond Myklebustfbca7792010-04-16 16:22:46 -04001701 struct nfs_fattr *fattr_fsinfo;
David Howells54ceac42006-08-22 20:06:13 -04001702 int error;
1703
1704 dprintk("--> nfs_clone_server(,%llx:%llx,)\n",
David Howells6daabf12006-08-24 15:44:16 -04001705 (unsigned long long) fattr->fsid.major,
1706 (unsigned long long) fattr->fsid.minor);
David Howells54ceac42006-08-22 20:06:13 -04001707
1708 server = nfs_alloc_server();
1709 if (!server)
1710 return ERR_PTR(-ENOMEM);
1711
Trond Myklebustfbca7792010-04-16 16:22:46 -04001712 error = -ENOMEM;
1713 fattr_fsinfo = nfs_alloc_fattr();
1714 if (fattr_fsinfo == NULL)
1715 goto out_free_server;
1716
David Howells54ceac42006-08-22 20:06:13 -04001717 /* Copy data from the source */
1718 server->nfs_client = source->nfs_client;
1719 atomic_inc(&server->nfs_client->cl_count);
1720 nfs_server_copy_userdata(server, source);
1721
1722 server->fsid = fattr->fsid;
1723
Trond Myklebust33170232007-12-20 16:03:59 -05001724 error = nfs_init_server_rpcclient(server,
1725 source->client->cl_timeout,
1726 source->client->cl_auth->au_flavor);
David Howells54ceac42006-08-22 20:06:13 -04001727 if (error < 0)
1728 goto out_free_server;
1729 if (!IS_ERR(source->client_acl))
1730 nfs_init_server_aclclient(server);
1731
1732 /* probe the filesystem info for this server filesystem */
Trond Myklebustfbca7792010-04-16 16:22:46 -04001733 error = nfs_probe_fsinfo(server, fh, fattr_fsinfo);
David Howells54ceac42006-08-22 20:06:13 -04001734 if (error < 0)
1735 goto out_free_server;
1736
Trond Myklebust54af3bb2007-09-28 12:27:41 -04001737 if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
1738 server->namelen = NFS4_MAXNAMLEN;
1739
David Howells54ceac42006-08-22 20:06:13 -04001740 dprintk("Cloned FSID: %llx:%llx\n",
David Howells6daabf12006-08-24 15:44:16 -04001741 (unsigned long long) server->fsid.major,
1742 (unsigned long long) server->fsid.minor);
David Howells54ceac42006-08-22 20:06:13 -04001743
1744 error = nfs_start_lockd(server);
1745 if (error < 0)
1746 goto out_free_server;
1747
Chuck Leverfca52382010-12-24 01:32:32 +00001748 nfs_server_insert_lists(server);
David Howells54ceac42006-08-22 20:06:13 -04001749 server->mount_time = jiffies;
1750
Trond Myklebustfbca7792010-04-16 16:22:46 -04001751 nfs_free_fattr(fattr_fsinfo);
David Howells54ceac42006-08-22 20:06:13 -04001752 dprintk("<-- nfs_clone_server() = %p\n", server);
1753 return server;
1754
1755out_free_server:
Trond Myklebustfbca7792010-04-16 16:22:46 -04001756 nfs_free_fattr(fattr_fsinfo);
David Howells54ceac42006-08-22 20:06:13 -04001757 nfs_free_server(server);
1758 dprintk("<-- nfs_clone_server() = error %d\n", error);
1759 return ERR_PTR(error);
1760}
David Howells6aaca562006-08-22 20:06:13 -04001761
1762#ifdef CONFIG_PROC_FS
1763static struct proc_dir_entry *proc_fs_nfs;
1764
1765static int nfs_server_list_open(struct inode *inode, struct file *file);
1766static void *nfs_server_list_start(struct seq_file *p, loff_t *pos);
1767static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos);
1768static void nfs_server_list_stop(struct seq_file *p, void *v);
1769static int nfs_server_list_show(struct seq_file *m, void *v);
1770
James Morris88e9d342009-09-22 16:43:43 -07001771static const struct seq_operations nfs_server_list_ops = {
David Howells6aaca562006-08-22 20:06:13 -04001772 .start = nfs_server_list_start,
1773 .next = nfs_server_list_next,
1774 .stop = nfs_server_list_stop,
1775 .show = nfs_server_list_show,
1776};
1777
Arjan van de Ven00977a52007-02-12 00:55:34 -08001778static const struct file_operations nfs_server_list_fops = {
David Howells6aaca562006-08-22 20:06:13 -04001779 .open = nfs_server_list_open,
1780 .read = seq_read,
1781 .llseek = seq_lseek,
1782 .release = seq_release,
Denis V. Lunev34b37232008-04-29 01:02:07 -07001783 .owner = THIS_MODULE,
David Howells6aaca562006-08-22 20:06:13 -04001784};
1785
1786static int nfs_volume_list_open(struct inode *inode, struct file *file);
1787static void *nfs_volume_list_start(struct seq_file *p, loff_t *pos);
1788static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos);
1789static void nfs_volume_list_stop(struct seq_file *p, void *v);
1790static int nfs_volume_list_show(struct seq_file *m, void *v);
1791
James Morris88e9d342009-09-22 16:43:43 -07001792static const struct seq_operations nfs_volume_list_ops = {
David Howells6aaca562006-08-22 20:06:13 -04001793 .start = nfs_volume_list_start,
1794 .next = nfs_volume_list_next,
1795 .stop = nfs_volume_list_stop,
1796 .show = nfs_volume_list_show,
1797};
1798
Arjan van de Ven00977a52007-02-12 00:55:34 -08001799static const struct file_operations nfs_volume_list_fops = {
David Howells6aaca562006-08-22 20:06:13 -04001800 .open = nfs_volume_list_open,
1801 .read = seq_read,
1802 .llseek = seq_lseek,
1803 .release = seq_release,
Denis V. Lunev34b37232008-04-29 01:02:07 -07001804 .owner = THIS_MODULE,
David Howells6aaca562006-08-22 20:06:13 -04001805};
1806
1807/*
1808 * open "/proc/fs/nfsfs/servers" which provides a summary of servers with which
1809 * we're dealing
1810 */
1811static int nfs_server_list_open(struct inode *inode, struct file *file)
1812{
1813 struct seq_file *m;
1814 int ret;
1815
1816 ret = seq_open(file, &nfs_server_list_ops);
1817 if (ret < 0)
1818 return ret;
1819
1820 m = file->private_data;
1821 m->private = PDE(inode)->data;
1822
1823 return 0;
1824}
1825
1826/*
1827 * set up the iterator to start reading from the server list and return the first item
1828 */
1829static void *nfs_server_list_start(struct seq_file *m, loff_t *_pos)
1830{
David Howells6aaca562006-08-22 20:06:13 -04001831 /* lock the list against modification */
1832 spin_lock(&nfs_client_lock);
Pavel Emelianov259902e2007-07-15 23:39:56 -07001833 return seq_list_start_head(&nfs_client_list, *_pos);
David Howells6aaca562006-08-22 20:06:13 -04001834}
1835
1836/*
1837 * move to next server
1838 */
1839static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos)
1840{
Pavel Emelianov259902e2007-07-15 23:39:56 -07001841 return seq_list_next(v, &nfs_client_list, pos);
David Howells6aaca562006-08-22 20:06:13 -04001842}
1843
1844/*
1845 * clean up after reading from the transports list
1846 */
1847static void nfs_server_list_stop(struct seq_file *p, void *v)
1848{
1849 spin_unlock(&nfs_client_lock);
1850}
1851
1852/*
1853 * display a header line followed by a load of call lines
1854 */
1855static int nfs_server_list_show(struct seq_file *m, void *v)
1856{
1857 struct nfs_client *clp;
1858
1859 /* display header on line 1 */
Pavel Emelianov259902e2007-07-15 23:39:56 -07001860 if (v == &nfs_client_list) {
David Howells6aaca562006-08-22 20:06:13 -04001861 seq_puts(m, "NV SERVER PORT USE HOSTNAME\n");
1862 return 0;
1863 }
1864
1865 /* display one transport per line on subsequent lines */
1866 clp = list_entry(v, struct nfs_client, cl_share_link);
1867
Chuck Lever5d8515c2007-12-10 14:57:16 -05001868 seq_printf(m, "v%u %s %s %3d %s\n",
Trond Myklebust40c553192007-12-14 14:56:07 -05001869 clp->rpc_ops->version,
Chuck Lever5d8515c2007-12-10 14:57:16 -05001870 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
1871 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
David Howells6aaca562006-08-22 20:06:13 -04001872 atomic_read(&clp->cl_count),
1873 clp->cl_hostname);
1874
1875 return 0;
1876}
1877
1878/*
1879 * open "/proc/fs/nfsfs/volumes" which provides a summary of extant volumes
1880 */
1881static int nfs_volume_list_open(struct inode *inode, struct file *file)
1882{
1883 struct seq_file *m;
1884 int ret;
1885
1886 ret = seq_open(file, &nfs_volume_list_ops);
1887 if (ret < 0)
1888 return ret;
1889
1890 m = file->private_data;
1891 m->private = PDE(inode)->data;
1892
1893 return 0;
1894}
1895
1896/*
1897 * set up the iterator to start reading from the volume list and return the first item
1898 */
1899static void *nfs_volume_list_start(struct seq_file *m, loff_t *_pos)
1900{
David Howells6aaca562006-08-22 20:06:13 -04001901 /* lock the list against modification */
1902 spin_lock(&nfs_client_lock);
Pavel Emelianov259902e2007-07-15 23:39:56 -07001903 return seq_list_start_head(&nfs_volume_list, *_pos);
David Howells6aaca562006-08-22 20:06:13 -04001904}
1905
1906/*
1907 * move to next volume
1908 */
1909static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos)
1910{
Pavel Emelianov259902e2007-07-15 23:39:56 -07001911 return seq_list_next(v, &nfs_volume_list, pos);
David Howells6aaca562006-08-22 20:06:13 -04001912}
1913
1914/*
1915 * clean up after reading from the transports list
1916 */
1917static void nfs_volume_list_stop(struct seq_file *p, void *v)
1918{
1919 spin_unlock(&nfs_client_lock);
1920}
1921
1922/*
1923 * display a header line followed by a load of call lines
1924 */
1925static int nfs_volume_list_show(struct seq_file *m, void *v)
1926{
1927 struct nfs_server *server;
1928 struct nfs_client *clp;
1929 char dev[8], fsid[17];
1930
1931 /* display header on line 1 */
Pavel Emelianov259902e2007-07-15 23:39:56 -07001932 if (v == &nfs_volume_list) {
David Howells5d1acff2009-04-03 16:42:47 +01001933 seq_puts(m, "NV SERVER PORT DEV FSID FSC\n");
David Howells6aaca562006-08-22 20:06:13 -04001934 return 0;
1935 }
1936 /* display one transport per line on subsequent lines */
1937 server = list_entry(v, struct nfs_server, master_link);
1938 clp = server->nfs_client;
1939
1940 snprintf(dev, 8, "%u:%u",
1941 MAJOR(server->s_dev), MINOR(server->s_dev));
1942
1943 snprintf(fsid, 17, "%llx:%llx",
David Howells6daabf12006-08-24 15:44:16 -04001944 (unsigned long long) server->fsid.major,
1945 (unsigned long long) server->fsid.minor);
David Howells6aaca562006-08-22 20:06:13 -04001946
David Howells5d1acff2009-04-03 16:42:47 +01001947 seq_printf(m, "v%u %s %s %-7s %-17s %s\n",
Trond Myklebust40c553192007-12-14 14:56:07 -05001948 clp->rpc_ops->version,
Chuck Lever5d8515c2007-12-10 14:57:16 -05001949 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
1950 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
David Howells6aaca562006-08-22 20:06:13 -04001951 dev,
David Howells5d1acff2009-04-03 16:42:47 +01001952 fsid,
1953 nfs_server_fscache_state(server));
David Howells6aaca562006-08-22 20:06:13 -04001954
1955 return 0;
1956}
1957
1958/*
1959 * initialise the /proc/fs/nfsfs/ directory
1960 */
1961int __init nfs_fs_proc_init(void)
1962{
1963 struct proc_dir_entry *p;
1964
Alexey Dobriyan36a5aeb2008-04-29 01:01:42 -07001965 proc_fs_nfs = proc_mkdir("fs/nfsfs", NULL);
David Howells6aaca562006-08-22 20:06:13 -04001966 if (!proc_fs_nfs)
1967 goto error_0;
1968
David Howells6aaca562006-08-22 20:06:13 -04001969 /* a file of servers with which we're dealing */
Denis V. Lunev34b37232008-04-29 01:02:07 -07001970 p = proc_create("servers", S_IFREG|S_IRUGO,
1971 proc_fs_nfs, &nfs_server_list_fops);
David Howells6aaca562006-08-22 20:06:13 -04001972 if (!p)
1973 goto error_1;
1974
David Howells6aaca562006-08-22 20:06:13 -04001975 /* a file of volumes that we have mounted */
Denis V. Lunev34b37232008-04-29 01:02:07 -07001976 p = proc_create("volumes", S_IFREG|S_IRUGO,
1977 proc_fs_nfs, &nfs_volume_list_fops);
David Howells6aaca562006-08-22 20:06:13 -04001978 if (!p)
1979 goto error_2;
David Howells6aaca562006-08-22 20:06:13 -04001980 return 0;
1981
1982error_2:
1983 remove_proc_entry("servers", proc_fs_nfs);
1984error_1:
Alexey Dobriyan36a5aeb2008-04-29 01:01:42 -07001985 remove_proc_entry("fs/nfsfs", NULL);
David Howells6aaca562006-08-22 20:06:13 -04001986error_0:
1987 return -ENOMEM;
1988}
1989
1990/*
1991 * clean up the /proc/fs/nfsfs/ directory
1992 */
1993void nfs_fs_proc_exit(void)
1994{
1995 remove_proc_entry("volumes", proc_fs_nfs);
1996 remove_proc_entry("servers", proc_fs_nfs);
Alexey Dobriyan36a5aeb2008-04-29 01:01:42 -07001997 remove_proc_entry("fs/nfsfs", NULL);
David Howells6aaca562006-08-22 20:06:13 -04001998}
1999
2000#endif /* CONFIG_PROC_FS */
Trond Myklebustb064eca22011-02-22 15:44:32 -08002001
2002module_param(nfs4_disable_idmapping, bool, 0644);
2003MODULE_PARM_DESC(nfs4_disable_idmapping,
2004 "Turn off NFSv4 idmapping when using 'sec=sys'");