xref: /openbmc/linux/fs/nfsd/export.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
1 #define MSNFS	/* HACK HACK */
2 /*
3  * linux/fs/nfsd/export.c
4  *
5  * NFS exporting and validation.
6  *
7  * We maintain a list of clients, each of which has a list of
8  * exports. To export an fs to a given client, you first have
9  * to create the client entry with NFSCTL_ADDCLIENT, which
10  * creates a client control block and adds it to the hash
11  * table. Then, you call NFSCTL_EXPORT for each fs.
12  *
13  *
14  * Copyright (C) 1995, 1996 Olaf Kirch, <okir@monad.swb.de>
15  */
16 
17 #include <linux/unistd.h>
18 #include <linux/slab.h>
19 #include <linux/stat.h>
20 #include <linux/in.h>
21 #include <linux/seq_file.h>
22 #include <linux/syscalls.h>
23 #include <linux/rwsem.h>
24 #include <linux/dcache.h>
25 #include <linux/namei.h>
26 #include <linux/mount.h>
27 #include <linux/hash.h>
28 #include <linux/module.h>
29 
30 #include <linux/sunrpc/svc.h>
31 #include <linux/nfsd/nfsd.h>
32 #include <linux/nfsd/nfsfh.h>
33 #include <linux/nfsd/syscall.h>
34 #include <linux/lockd/bind.h>
35 
36 #define NFSDDBG_FACILITY	NFSDDBG_EXPORT
37 
38 typedef struct auth_domain	svc_client;
39 typedef struct svc_export	svc_export;
40 
41 static void		exp_do_unexport(svc_export *unexp);
42 static int		exp_verify_string(char *cp, int max);
43 
44 /*
45  * We have two caches.
46  * One maps client+vfsmnt+dentry to export options - the export map
47  * The other maps client+filehandle-fragment to export options. - the expkey map
48  *
49  * The export options are actually stored in the first map, and the
50  * second map contains a reference to the entry in the first map.
51  */
52 
53 #define	EXPKEY_HASHBITS		8
54 #define	EXPKEY_HASHMAX		(1 << EXPKEY_HASHBITS)
55 #define	EXPKEY_HASHMASK		(EXPKEY_HASHMAX -1)
56 static struct cache_head *expkey_table[EXPKEY_HASHMAX];
57 
58 static void expkey_put(struct kref *ref)
59 {
60 	struct svc_expkey *key = container_of(ref, struct svc_expkey, h.ref);
61 
62 	if (test_bit(CACHE_VALID, &key->h.flags) &&
63 	    !test_bit(CACHE_NEGATIVE, &key->h.flags)) {
64 		dput(key->ek_dentry);
65 		mntput(key->ek_mnt);
66 	}
67 	auth_domain_put(key->ek_client);
68 	kfree(key);
69 }
70 
71 static void expkey_request(struct cache_detail *cd,
72 			   struct cache_head *h,
73 			   char **bpp, int *blen)
74 {
75 	/* client fsidtype \xfsid */
76 	struct svc_expkey *ek = container_of(h, struct svc_expkey, h);
77 	char type[5];
78 
79 	qword_add(bpp, blen, ek->ek_client->name);
80 	snprintf(type, 5, "%d", ek->ek_fsidtype);
81 	qword_add(bpp, blen, type);
82 	qword_addhex(bpp, blen, (char*)ek->ek_fsid, key_len(ek->ek_fsidtype));
83 	(*bpp)[-1] = '\n';
84 }
85 
86 static struct svc_expkey *svc_expkey_update(struct svc_expkey *new, struct svc_expkey *old);
87 static struct svc_expkey *svc_expkey_lookup(struct svc_expkey *);
88 static struct cache_detail svc_expkey_cache;
89 
90 static int expkey_parse(struct cache_detail *cd, char *mesg, int mlen)
91 {
92 	/* client fsidtype fsid [path] */
93 	char *buf;
94 	int len;
95 	struct auth_domain *dom = NULL;
96 	int err;
97 	int fsidtype;
98 	char *ep;
99 	struct svc_expkey key;
100 	struct svc_expkey *ek;
101 
102 	if (mesg[mlen-1] != '\n')
103 		return -EINVAL;
104 	mesg[mlen-1] = 0;
105 
106 	buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
107 	err = -ENOMEM;
108 	if (!buf) goto out;
109 
110 	err = -EINVAL;
111 	if ((len=qword_get(&mesg, buf, PAGE_SIZE)) <= 0)
112 		goto out;
113 
114 	err = -ENOENT;
115 	dom = auth_domain_find(buf);
116 	if (!dom)
117 		goto out;
118 	dprintk("found domain %s\n", buf);
119 
120 	err = -EINVAL;
121 	if ((len=qword_get(&mesg, buf, PAGE_SIZE)) <= 0)
122 		goto out;
123 	fsidtype = simple_strtoul(buf, &ep, 10);
124 	if (*ep)
125 		goto out;
126 	dprintk("found fsidtype %d\n", fsidtype);
127 	if (key_len(fsidtype)==0) /* invalid type */
128 		goto out;
129 	if ((len=qword_get(&mesg, buf, PAGE_SIZE)) <= 0)
130 		goto out;
131 	dprintk("found fsid length %d\n", len);
132 	if (len != key_len(fsidtype))
133 		goto out;
134 
135 	/* OK, we seem to have a valid key */
136 	key.h.flags = 0;
137 	key.h.expiry_time = get_expiry(&mesg);
138 	if (key.h.expiry_time == 0)
139 		goto out;
140 
141 	key.ek_client = dom;
142 	key.ek_fsidtype = fsidtype;
143 	memcpy(key.ek_fsid, buf, len);
144 
145 	ek = svc_expkey_lookup(&key);
146 	err = -ENOMEM;
147 	if (!ek)
148 		goto out;
149 
150 	/* now we want a pathname, or empty meaning NEGATIVE  */
151 	err = -EINVAL;
152 	if ((len=qword_get(&mesg, buf, PAGE_SIZE)) < 0)
153 		goto out;
154 	dprintk("Path seems to be <%s>\n", buf);
155 	err = 0;
156 	if (len == 0) {
157 		set_bit(CACHE_NEGATIVE, &key.h.flags);
158 		ek = svc_expkey_update(&key, ek);
159 		if (ek)
160 			cache_put(&ek->h, &svc_expkey_cache);
161 		else err = -ENOMEM;
162 	} else {
163 		struct nameidata nd;
164 		err = path_lookup(buf, 0, &nd);
165 		if (err)
166 			goto out;
167 
168 		dprintk("Found the path %s\n", buf);
169 		key.ek_mnt = nd.mnt;
170 		key.ek_dentry = nd.dentry;
171 
172 		ek = svc_expkey_update(&key, ek);
173 		if (ek)
174 			cache_put(&ek->h, &svc_expkey_cache);
175 		else
176 			err = -ENOMEM;
177 		path_release(&nd);
178 	}
179 	cache_flush();
180  out:
181 	if (dom)
182 		auth_domain_put(dom);
183 	kfree(buf);
184 	return err;
185 }
186 
187 static int expkey_show(struct seq_file *m,
188 		       struct cache_detail *cd,
189 		       struct cache_head *h)
190 {
191 	struct svc_expkey *ek ;
192 	int i;
193 
194 	if (h ==NULL) {
195 		seq_puts(m, "#domain fsidtype fsid [path]\n");
196 		return 0;
197 	}
198 	ek = container_of(h, struct svc_expkey, h);
199 	seq_printf(m, "%s %d 0x", ek->ek_client->name,
200 		   ek->ek_fsidtype);
201 	for (i=0; i < key_len(ek->ek_fsidtype)/4; i++)
202 		seq_printf(m, "%08x", ek->ek_fsid[i]);
203 	if (test_bit(CACHE_VALID, &h->flags) &&
204 	    !test_bit(CACHE_NEGATIVE, &h->flags)) {
205 		seq_printf(m, " ");
206 		seq_path(m, ek->ek_mnt, ek->ek_dentry, "\\ \t\n");
207 	}
208 	seq_printf(m, "\n");
209 	return 0;
210 }
211 
212 static inline int expkey_match (struct cache_head *a, struct cache_head *b)
213 {
214 	struct svc_expkey *orig = container_of(a, struct svc_expkey, h);
215 	struct svc_expkey *new = container_of(b, struct svc_expkey, h);
216 
217 	if (orig->ek_fsidtype != new->ek_fsidtype ||
218 	    orig->ek_client != new->ek_client ||
219 	    memcmp(orig->ek_fsid, new->ek_fsid, key_len(orig->ek_fsidtype)) != 0)
220 		return 0;
221 	return 1;
222 }
223 
224 static inline void expkey_init(struct cache_head *cnew,
225 				   struct cache_head *citem)
226 {
227 	struct svc_expkey *new = container_of(cnew, struct svc_expkey, h);
228 	struct svc_expkey *item = container_of(citem, struct svc_expkey, h);
229 
230 	kref_get(&item->ek_client->ref);
231 	new->ek_client = item->ek_client;
232 	new->ek_fsidtype = item->ek_fsidtype;
233 
234 	memcpy(new->ek_fsid, item->ek_fsid, sizeof(new->ek_fsid));
235 }
236 
237 static inline void expkey_update(struct cache_head *cnew,
238 				   struct cache_head *citem)
239 {
240 	struct svc_expkey *new = container_of(cnew, struct svc_expkey, h);
241 	struct svc_expkey *item = container_of(citem, struct svc_expkey, h);
242 
243 	new->ek_mnt = mntget(item->ek_mnt);
244 	new->ek_dentry = dget(item->ek_dentry);
245 }
246 
247 static struct cache_head *expkey_alloc(void)
248 {
249 	struct svc_expkey *i = kmalloc(sizeof(*i), GFP_KERNEL);
250 	if (i)
251 		return &i->h;
252 	else
253 		return NULL;
254 }
255 
256 static struct cache_detail svc_expkey_cache = {
257 	.owner		= THIS_MODULE,
258 	.hash_size	= EXPKEY_HASHMAX,
259 	.hash_table	= expkey_table,
260 	.name		= "nfsd.fh",
261 	.cache_put	= expkey_put,
262 	.cache_request	= expkey_request,
263 	.cache_parse	= expkey_parse,
264 	.cache_show	= expkey_show,
265 	.match		= expkey_match,
266 	.init		= expkey_init,
267 	.update       	= expkey_update,
268 	.alloc		= expkey_alloc,
269 };
270 
271 static struct svc_expkey *
272 svc_expkey_lookup(struct svc_expkey *item)
273 {
274 	struct cache_head *ch;
275 	int hash = item->ek_fsidtype;
276 	char * cp = (char*)item->ek_fsid;
277 	int len = key_len(item->ek_fsidtype);
278 
279 	hash ^= hash_mem(cp, len, EXPKEY_HASHBITS);
280 	hash ^= hash_ptr(item->ek_client, EXPKEY_HASHBITS);
281 	hash &= EXPKEY_HASHMASK;
282 
283 	ch = sunrpc_cache_lookup(&svc_expkey_cache, &item->h,
284 				 hash);
285 	if (ch)
286 		return container_of(ch, struct svc_expkey, h);
287 	else
288 		return NULL;
289 }
290 
291 static struct svc_expkey *
292 svc_expkey_update(struct svc_expkey *new, struct svc_expkey *old)
293 {
294 	struct cache_head *ch;
295 	int hash = new->ek_fsidtype;
296 	char * cp = (char*)new->ek_fsid;
297 	int len = key_len(new->ek_fsidtype);
298 
299 	hash ^= hash_mem(cp, len, EXPKEY_HASHBITS);
300 	hash ^= hash_ptr(new->ek_client, EXPKEY_HASHBITS);
301 	hash &= EXPKEY_HASHMASK;
302 
303 	ch = sunrpc_cache_update(&svc_expkey_cache, &new->h,
304 				 &old->h, hash);
305 	if (ch)
306 		return container_of(ch, struct svc_expkey, h);
307 	else
308 		return NULL;
309 }
310 
311 
312 #define	EXPORT_HASHBITS		8
313 #define	EXPORT_HASHMAX		(1<< EXPORT_HASHBITS)
314 #define	EXPORT_HASHMASK		(EXPORT_HASHMAX -1)
315 
316 static struct cache_head *export_table[EXPORT_HASHMAX];
317 
318 static void nfsd4_fslocs_free(struct nfsd4_fs_locations *fsloc)
319 {
320 	int i;
321 
322 	for (i = 0; i < fsloc->locations_count; i++) {
323 		kfree(fsloc->locations[i].path);
324 		kfree(fsloc->locations[i].hosts);
325 	}
326 	kfree(fsloc->locations);
327 }
328 
329 static void svc_export_put(struct kref *ref)
330 {
331 	struct svc_export *exp = container_of(ref, struct svc_export, h.ref);
332 	dput(exp->ex_dentry);
333 	mntput(exp->ex_mnt);
334 	auth_domain_put(exp->ex_client);
335 	kfree(exp->ex_path);
336 	nfsd4_fslocs_free(&exp->ex_fslocs);
337 	kfree(exp);
338 }
339 
340 static void svc_export_request(struct cache_detail *cd,
341 			       struct cache_head *h,
342 			       char **bpp, int *blen)
343 {
344 	/*  client path */
345 	struct svc_export *exp = container_of(h, struct svc_export, h);
346 	char *pth;
347 
348 	qword_add(bpp, blen, exp->ex_client->name);
349 	pth = d_path(exp->ex_dentry, exp->ex_mnt, *bpp, *blen);
350 	if (IS_ERR(pth)) {
351 		/* is this correct? */
352 		(*bpp)[0] = '\n';
353 		return;
354 	}
355 	qword_add(bpp, blen, pth);
356 	(*bpp)[-1] = '\n';
357 }
358 
359 static struct svc_export *svc_export_update(struct svc_export *new,
360 					    struct svc_export *old);
361 static struct svc_export *svc_export_lookup(struct svc_export *);
362 
363 static int check_export(struct inode *inode, int flags, unsigned char *uuid)
364 {
365 
366 	/* We currently export only dirs and regular files.
367 	 * This is what umountd does.
368 	 */
369 	if (!S_ISDIR(inode->i_mode) &&
370 	    !S_ISREG(inode->i_mode))
371 		return -ENOTDIR;
372 
373 	/* There are two requirements on a filesystem to be exportable.
374 	 * 1:  We must be able to identify the filesystem from a number.
375 	 *       either a device number (so FS_REQUIRES_DEV needed)
376 	 *       or an FSID number (so NFSEXP_FSID or ->uuid is needed).
377 	 * 2:  We must be able to find an inode from a filehandle.
378 	 *       This means that s_export_op must be set.
379 	 */
380 	if (!(inode->i_sb->s_type->fs_flags & FS_REQUIRES_DEV) &&
381 	    !(flags & NFSEXP_FSID) &&
382 	    uuid == NULL) {
383 		dprintk("exp_export: export of non-dev fs without fsid\n");
384 		return -EINVAL;
385 	}
386 	if (!inode->i_sb->s_export_op) {
387 		dprintk("exp_export: export of invalid fs type.\n");
388 		return -EINVAL;
389 	}
390 
391 	/* Ok, we can export it */;
392 	if (!inode->i_sb->s_export_op->find_exported_dentry)
393 		inode->i_sb->s_export_op->find_exported_dentry =
394 			find_exported_dentry;
395 	return 0;
396 
397 }
398 
399 #ifdef CONFIG_NFSD_V4
400 
401 static int
402 fsloc_parse(char **mesg, char *buf, struct nfsd4_fs_locations *fsloc)
403 {
404 	int len;
405 	int migrated, i, err;
406 
407 	/* listsize */
408 	err = get_int(mesg, &fsloc->locations_count);
409 	if (err)
410 		return err;
411 	if (fsloc->locations_count > MAX_FS_LOCATIONS)
412 		return -EINVAL;
413 	if (fsloc->locations_count == 0)
414 		return 0;
415 
416 	fsloc->locations = kzalloc(fsloc->locations_count
417 			* sizeof(struct nfsd4_fs_location), GFP_KERNEL);
418 	if (!fsloc->locations)
419 		return -ENOMEM;
420 	for (i=0; i < fsloc->locations_count; i++) {
421 		/* colon separated host list */
422 		err = -EINVAL;
423 		len = qword_get(mesg, buf, PAGE_SIZE);
424 		if (len <= 0)
425 			goto out_free_all;
426 		err = -ENOMEM;
427 		fsloc->locations[i].hosts = kstrdup(buf, GFP_KERNEL);
428 		if (!fsloc->locations[i].hosts)
429 			goto out_free_all;
430 		err = -EINVAL;
431 		/* slash separated path component list */
432 		len = qword_get(mesg, buf, PAGE_SIZE);
433 		if (len <= 0)
434 			goto out_free_all;
435 		err = -ENOMEM;
436 		fsloc->locations[i].path = kstrdup(buf, GFP_KERNEL);
437 		if (!fsloc->locations[i].path)
438 			goto out_free_all;
439 	}
440 	/* migrated */
441 	err = get_int(mesg, &migrated);
442 	if (err)
443 		goto out_free_all;
444 	err = -EINVAL;
445 	if (migrated < 0 || migrated > 1)
446 		goto out_free_all;
447 	fsloc->migrated = migrated;
448 	return 0;
449 out_free_all:
450 	nfsd4_fslocs_free(fsloc);
451 	return err;
452 }
453 
454 #else /* CONFIG_NFSD_V4 */
455 static inline int fsloc_parse(char **mesg, char *buf, struct nfsd4_fs_locations *fsloc) { return 0; }
456 #endif
457 
458 static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
459 {
460 	/* client path expiry [flags anonuid anongid fsid] */
461 	char *buf;
462 	int len;
463 	int err;
464 	struct auth_domain *dom = NULL;
465 	struct nameidata nd;
466 	struct svc_export exp, *expp;
467 	int an_int;
468 
469 	nd.dentry = NULL;
470 	exp.ex_path = NULL;
471 
472 	/* fs locations */
473 	exp.ex_fslocs.locations = NULL;
474 	exp.ex_fslocs.locations_count = 0;
475 	exp.ex_fslocs.migrated = 0;
476 
477 	exp.ex_uuid = NULL;
478 
479 	if (mesg[mlen-1] != '\n')
480 		return -EINVAL;
481 	mesg[mlen-1] = 0;
482 
483 	buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
484 	err = -ENOMEM;
485 	if (!buf) goto out;
486 
487 	/* client */
488 	len = qword_get(&mesg, buf, PAGE_SIZE);
489 	err = -EINVAL;
490 	if (len <= 0) goto out;
491 
492 	err = -ENOENT;
493 	dom = auth_domain_find(buf);
494 	if (!dom)
495 		goto out;
496 
497 	/* path */
498 	err = -EINVAL;
499 	if ((len=qword_get(&mesg, buf, PAGE_SIZE)) <= 0)
500 		goto out;
501 	err = path_lookup(buf, 0, &nd);
502 	if (err) goto out_no_path;
503 
504 	exp.h.flags = 0;
505 	exp.ex_client = dom;
506 	exp.ex_mnt = nd.mnt;
507 	exp.ex_dentry = nd.dentry;
508 	exp.ex_path = kstrdup(buf, GFP_KERNEL);
509 	err = -ENOMEM;
510 	if (!exp.ex_path)
511 		goto out;
512 
513 	/* expiry */
514 	err = -EINVAL;
515 	exp.h.expiry_time = get_expiry(&mesg);
516 	if (exp.h.expiry_time == 0)
517 		goto out;
518 
519 	/* flags */
520 	err = get_int(&mesg, &an_int);
521 	if (err == -ENOENT)
522 		set_bit(CACHE_NEGATIVE, &exp.h.flags);
523 	else {
524 		if (err || an_int < 0) goto out;
525 		exp.ex_flags= an_int;
526 
527 		/* anon uid */
528 		err = get_int(&mesg, &an_int);
529 		if (err) goto out;
530 		exp.ex_anon_uid= an_int;
531 
532 		/* anon gid */
533 		err = get_int(&mesg, &an_int);
534 		if (err) goto out;
535 		exp.ex_anon_gid= an_int;
536 
537 		/* fsid */
538 		err = get_int(&mesg, &an_int);
539 		if (err) goto out;
540 		exp.ex_fsid = an_int;
541 
542 		while ((len = qword_get(&mesg, buf, PAGE_SIZE)) > 0) {
543 			if (strcmp(buf, "fsloc") == 0)
544 				err = fsloc_parse(&mesg, buf, &exp.ex_fslocs);
545 			else if (strcmp(buf, "uuid") == 0) {
546 				/* expect a 16 byte uuid encoded as \xXXXX... */
547 				len = qword_get(&mesg, buf, PAGE_SIZE);
548 				if (len != 16)
549 					err  = -EINVAL;
550 				else {
551 					exp.ex_uuid =
552 						kmemdup(buf, 16, GFP_KERNEL);
553 					if (exp.ex_uuid == NULL)
554 						err = -ENOMEM;
555 				}
556 			} else
557 				/* quietly ignore unknown words and anything
558 				 * following. Newer user-space can try to set
559 				 * new values, then see what the result was.
560 				 */
561 				break;
562 			if (err)
563 				goto out;
564 		}
565 
566 		err = check_export(nd.dentry->d_inode, exp.ex_flags,
567 				   exp.ex_uuid);
568 		if (err) goto out;
569 	}
570 
571 	expp = svc_export_lookup(&exp);
572 	if (expp)
573 		expp = svc_export_update(&exp, expp);
574 	else
575 		err = -ENOMEM;
576 	cache_flush();
577 	if (expp == NULL)
578 		err = -ENOMEM;
579 	else
580 		exp_put(expp);
581  out:
582 	nfsd4_fslocs_free(&exp.ex_fslocs);
583 	kfree(exp.ex_uuid);
584  	kfree(exp.ex_path);
585 	if (nd.dentry)
586 		path_release(&nd);
587  out_no_path:
588 	if (dom)
589 		auth_domain_put(dom);
590 	kfree(buf);
591 	return err;
592 }
593 
594 static void exp_flags(struct seq_file *m, int flag, int fsid,
595 		uid_t anonu, uid_t anong, struct nfsd4_fs_locations *fslocs);
596 
597 static int svc_export_show(struct seq_file *m,
598 			   struct cache_detail *cd,
599 			   struct cache_head *h)
600 {
601 	struct svc_export *exp ;
602 
603 	if (h ==NULL) {
604 		seq_puts(m, "#path domain(flags)\n");
605 		return 0;
606 	}
607 	exp = container_of(h, struct svc_export, h);
608 	seq_path(m, exp->ex_mnt, exp->ex_dentry, " \t\n\\");
609 	seq_putc(m, '\t');
610 	seq_escape(m, exp->ex_client->name, " \t\n\\");
611 	seq_putc(m, '(');
612 	if (test_bit(CACHE_VALID, &h->flags) &&
613 	    !test_bit(CACHE_NEGATIVE, &h->flags)) {
614 		exp_flags(m, exp->ex_flags, exp->ex_fsid,
615 			  exp->ex_anon_uid, exp->ex_anon_gid, &exp->ex_fslocs);
616 		if (exp->ex_uuid) {
617 			int i;
618 			seq_puts(m, ",uuid=");
619 			for (i=0; i<16; i++) {
620 				if ((i&3) == 0 && i)
621 					seq_putc(m, ':');
622 				seq_printf(m, "%02x", exp->ex_uuid[i]);
623 			}
624 		}
625 	}
626 	seq_puts(m, ")\n");
627 	return 0;
628 }
629 static int svc_export_match(struct cache_head *a, struct cache_head *b)
630 {
631 	struct svc_export *orig = container_of(a, struct svc_export, h);
632 	struct svc_export *new = container_of(b, struct svc_export, h);
633 	return orig->ex_client == new->ex_client &&
634 		orig->ex_dentry == new->ex_dentry &&
635 		orig->ex_mnt == new->ex_mnt;
636 }
637 
638 static void svc_export_init(struct cache_head *cnew, struct cache_head *citem)
639 {
640 	struct svc_export *new = container_of(cnew, struct svc_export, h);
641 	struct svc_export *item = container_of(citem, struct svc_export, h);
642 
643 	kref_get(&item->ex_client->ref);
644 	new->ex_client = item->ex_client;
645 	new->ex_dentry = dget(item->ex_dentry);
646 	new->ex_mnt = mntget(item->ex_mnt);
647 	new->ex_path = NULL;
648 	new->ex_fslocs.locations = NULL;
649 	new->ex_fslocs.locations_count = 0;
650 	new->ex_fslocs.migrated = 0;
651 }
652 
653 static void export_update(struct cache_head *cnew, struct cache_head *citem)
654 {
655 	struct svc_export *new = container_of(cnew, struct svc_export, h);
656 	struct svc_export *item = container_of(citem, struct svc_export, h);
657 
658 	new->ex_flags = item->ex_flags;
659 	new->ex_anon_uid = item->ex_anon_uid;
660 	new->ex_anon_gid = item->ex_anon_gid;
661 	new->ex_fsid = item->ex_fsid;
662 	new->ex_uuid = item->ex_uuid;
663 	item->ex_uuid = NULL;
664 	new->ex_path = item->ex_path;
665 	item->ex_path = NULL;
666 	new->ex_fslocs.locations = item->ex_fslocs.locations;
667 	item->ex_fslocs.locations = NULL;
668 	new->ex_fslocs.locations_count = item->ex_fslocs.locations_count;
669 	item->ex_fslocs.locations_count = 0;
670 	new->ex_fslocs.migrated = item->ex_fslocs.migrated;
671 	item->ex_fslocs.migrated = 0;
672 }
673 
674 static struct cache_head *svc_export_alloc(void)
675 {
676 	struct svc_export *i = kmalloc(sizeof(*i), GFP_KERNEL);
677 	if (i)
678 		return &i->h;
679 	else
680 		return NULL;
681 }
682 
683 struct cache_detail svc_export_cache = {
684 	.owner		= THIS_MODULE,
685 	.hash_size	= EXPORT_HASHMAX,
686 	.hash_table	= export_table,
687 	.name		= "nfsd.export",
688 	.cache_put	= svc_export_put,
689 	.cache_request	= svc_export_request,
690 	.cache_parse	= svc_export_parse,
691 	.cache_show	= svc_export_show,
692 	.match		= svc_export_match,
693 	.init		= svc_export_init,
694 	.update		= export_update,
695 	.alloc		= svc_export_alloc,
696 };
697 
698 static struct svc_export *
699 svc_export_lookup(struct svc_export *exp)
700 {
701 	struct cache_head *ch;
702 	int hash;
703 	hash = hash_ptr(exp->ex_client, EXPORT_HASHBITS);
704 	hash ^= hash_ptr(exp->ex_dentry, EXPORT_HASHBITS);
705 	hash ^= hash_ptr(exp->ex_mnt, EXPORT_HASHBITS);
706 
707 	ch = sunrpc_cache_lookup(&svc_export_cache, &exp->h,
708 				 hash);
709 	if (ch)
710 		return container_of(ch, struct svc_export, h);
711 	else
712 		return NULL;
713 }
714 
715 static struct svc_export *
716 svc_export_update(struct svc_export *new, struct svc_export *old)
717 {
718 	struct cache_head *ch;
719 	int hash;
720 	hash = hash_ptr(old->ex_client, EXPORT_HASHBITS);
721 	hash ^= hash_ptr(old->ex_dentry, EXPORT_HASHBITS);
722 	hash ^= hash_ptr(old->ex_mnt, EXPORT_HASHBITS);
723 
724 	ch = sunrpc_cache_update(&svc_export_cache, &new->h,
725 				 &old->h,
726 				 hash);
727 	if (ch)
728 		return container_of(ch, struct svc_export, h);
729 	else
730 		return NULL;
731 }
732 
733 
734 static struct svc_expkey *
735 exp_find_key(svc_client *clp, int fsid_type, u32 *fsidv, struct cache_req *reqp)
736 {
737 	struct svc_expkey key, *ek;
738 	int err;
739 
740 	if (!clp)
741 		return NULL;
742 
743 	key.ek_client = clp;
744 	key.ek_fsidtype = fsid_type;
745 	memcpy(key.ek_fsid, fsidv, key_len(fsid_type));
746 
747 	ek = svc_expkey_lookup(&key);
748 	if (ek != NULL)
749 		if ((err = cache_check(&svc_expkey_cache, &ek->h, reqp)))
750 			ek = ERR_PTR(err);
751 	return ek;
752 }
753 
754 static int exp_set_key(svc_client *clp, int fsid_type, u32 *fsidv,
755 		       struct svc_export *exp)
756 {
757 	struct svc_expkey key, *ek;
758 
759 	key.ek_client = clp;
760 	key.ek_fsidtype = fsid_type;
761 	memcpy(key.ek_fsid, fsidv, key_len(fsid_type));
762 	key.ek_mnt = exp->ex_mnt;
763 	key.ek_dentry = exp->ex_dentry;
764 	key.h.expiry_time = NEVER;
765 	key.h.flags = 0;
766 
767 	ek = svc_expkey_lookup(&key);
768 	if (ek)
769 		ek = svc_expkey_update(&key,ek);
770 	if (ek) {
771 		cache_put(&ek->h, &svc_expkey_cache);
772 		return 0;
773 	}
774 	return -ENOMEM;
775 }
776 
777 /*
778  * Find the client's export entry matching xdev/xino.
779  */
780 static inline struct svc_expkey *
781 exp_get_key(svc_client *clp, dev_t dev, ino_t ino)
782 {
783 	u32 fsidv[3];
784 
785 	if (old_valid_dev(dev)) {
786 		mk_fsid(FSID_DEV, fsidv, dev, ino, 0, NULL);
787 		return exp_find_key(clp, FSID_DEV, fsidv, NULL);
788 	}
789 	mk_fsid(FSID_ENCODE_DEV, fsidv, dev, ino, 0, NULL);
790 	return exp_find_key(clp, FSID_ENCODE_DEV, fsidv, NULL);
791 }
792 
793 /*
794  * Find the client's export entry matching fsid
795  */
796 static inline struct svc_expkey *
797 exp_get_fsid_key(svc_client *clp, int fsid)
798 {
799 	u32 fsidv[2];
800 
801 	mk_fsid(FSID_NUM, fsidv, 0, 0, fsid, NULL);
802 
803 	return exp_find_key(clp, FSID_NUM, fsidv, NULL);
804 }
805 
806 svc_export *
807 exp_get_by_name(svc_client *clp, struct vfsmount *mnt, struct dentry *dentry,
808 		struct cache_req *reqp)
809 {
810 	struct svc_export *exp, key;
811 
812 	if (!clp)
813 		return NULL;
814 
815 	key.ex_client = clp;
816 	key.ex_mnt = mnt;
817 	key.ex_dentry = dentry;
818 
819 	exp = svc_export_lookup(&key);
820 	if (exp != NULL)  {
821 		int err;
822 
823 		err = cache_check(&svc_export_cache, &exp->h, reqp);
824 		switch (err) {
825 		case 0: break;
826 		case -EAGAIN:
827 		case -ETIMEDOUT:
828 			exp = ERR_PTR(err);
829 			break;
830 		default:
831 			exp = NULL;
832 		}
833 	}
834 
835 	return exp;
836 }
837 
838 /*
839  * Find the export entry for a given dentry.
840  */
841 struct svc_export *
842 exp_parent(svc_client *clp, struct vfsmount *mnt, struct dentry *dentry,
843 	   struct cache_req *reqp)
844 {
845 	svc_export *exp;
846 
847 	dget(dentry);
848 	exp = exp_get_by_name(clp, mnt, dentry, reqp);
849 
850 	while (exp == NULL && !IS_ROOT(dentry)) {
851 		struct dentry *parent;
852 
853 		parent = dget_parent(dentry);
854 		dput(dentry);
855 		dentry = parent;
856 		exp = exp_get_by_name(clp, mnt, dentry, reqp);
857 	}
858 	dput(dentry);
859 	return exp;
860 }
861 
862 /*
863  * Hashtable locking. Write locks are placed only by user processes
864  * wanting to modify export information.
865  * Write locking only done in this file.  Read locking
866  * needed externally.
867  */
868 
869 static DECLARE_RWSEM(hash_sem);
870 
871 void
872 exp_readlock(void)
873 {
874 	down_read(&hash_sem);
875 }
876 
877 static inline void
878 exp_writelock(void)
879 {
880 	down_write(&hash_sem);
881 }
882 
883 void
884 exp_readunlock(void)
885 {
886 	up_read(&hash_sem);
887 }
888 
889 static inline void
890 exp_writeunlock(void)
891 {
892 	up_write(&hash_sem);
893 }
894 
895 static void exp_fsid_unhash(struct svc_export *exp)
896 {
897 	struct svc_expkey *ek;
898 
899 	if ((exp->ex_flags & NFSEXP_FSID) == 0)
900 		return;
901 
902 	ek = exp_get_fsid_key(exp->ex_client, exp->ex_fsid);
903 	if (ek && !IS_ERR(ek)) {
904 		ek->h.expiry_time = get_seconds()-1;
905 		cache_put(&ek->h, &svc_expkey_cache);
906 	}
907 	svc_expkey_cache.nextcheck = get_seconds();
908 }
909 
910 static int exp_fsid_hash(svc_client *clp, struct svc_export *exp)
911 {
912 	u32 fsid[2];
913 
914 	if ((exp->ex_flags & NFSEXP_FSID) == 0)
915 		return 0;
916 
917 	mk_fsid(FSID_NUM, fsid, 0, 0, exp->ex_fsid, NULL);
918 	return exp_set_key(clp, FSID_NUM, fsid, exp);
919 }
920 
921 static int exp_hash(struct auth_domain *clp, struct svc_export *exp)
922 {
923 	u32 fsid[2];
924 	struct inode *inode = exp->ex_dentry->d_inode;
925 	dev_t dev = inode->i_sb->s_dev;
926 
927 	if (old_valid_dev(dev)) {
928 		mk_fsid(FSID_DEV, fsid, dev, inode->i_ino, 0, NULL);
929 		return exp_set_key(clp, FSID_DEV, fsid, exp);
930 	}
931 	mk_fsid(FSID_ENCODE_DEV, fsid, dev, inode->i_ino, 0, NULL);
932 	return exp_set_key(clp, FSID_ENCODE_DEV, fsid, exp);
933 }
934 
935 static void exp_unhash(struct svc_export *exp)
936 {
937 	struct svc_expkey *ek;
938 	struct inode *inode = exp->ex_dentry->d_inode;
939 
940 	ek = exp_get_key(exp->ex_client, inode->i_sb->s_dev, inode->i_ino);
941 	if (ek && !IS_ERR(ek)) {
942 		ek->h.expiry_time = get_seconds()-1;
943 		cache_put(&ek->h, &svc_expkey_cache);
944 	}
945 	svc_expkey_cache.nextcheck = get_seconds();
946 }
947 
948 /*
949  * Export a file system.
950  */
951 int
952 exp_export(struct nfsctl_export *nxp)
953 {
954 	svc_client	*clp;
955 	struct svc_export	*exp = NULL;
956 	struct svc_export	new;
957 	struct svc_expkey	*fsid_key = NULL;
958 	struct nameidata nd;
959 	int		err;
960 
961 	/* Consistency check */
962 	err = -EINVAL;
963 	if (!exp_verify_string(nxp->ex_path, NFS_MAXPATHLEN) ||
964 	    !exp_verify_string(nxp->ex_client, NFSCLNT_IDMAX))
965 		goto out;
966 
967 	dprintk("exp_export called for %s:%s (%x/%ld fl %x).\n",
968 			nxp->ex_client, nxp->ex_path,
969 			(unsigned)nxp->ex_dev, (long)nxp->ex_ino,
970 			nxp->ex_flags);
971 
972 	/* Try to lock the export table for update */
973 	exp_writelock();
974 
975 	/* Look up client info */
976 	if (!(clp = auth_domain_find(nxp->ex_client)))
977 		goto out_unlock;
978 
979 
980 	/* Look up the dentry */
981 	err = path_lookup(nxp->ex_path, 0, &nd);
982 	if (err)
983 		goto out_unlock;
984 	err = -EINVAL;
985 
986 	exp = exp_get_by_name(clp, nd.mnt, nd.dentry, NULL);
987 
988 	memset(&new, 0, sizeof(new));
989 
990 	/* must make sure there won't be an ex_fsid clash */
991 	if ((nxp->ex_flags & NFSEXP_FSID) &&
992 	    (fsid_key = exp_get_fsid_key(clp, nxp->ex_dev)) &&
993 	    !IS_ERR(fsid_key) &&
994 	    fsid_key->ek_mnt &&
995 	    (fsid_key->ek_mnt != nd.mnt || fsid_key->ek_dentry != nd.dentry) )
996 		goto finish;
997 
998 	if (exp) {
999 		/* just a flags/id/fsid update */
1000 
1001 		exp_fsid_unhash(exp);
1002 		exp->ex_flags    = nxp->ex_flags;
1003 		exp->ex_anon_uid = nxp->ex_anon_uid;
1004 		exp->ex_anon_gid = nxp->ex_anon_gid;
1005 		exp->ex_fsid     = nxp->ex_dev;
1006 
1007 		err = exp_fsid_hash(clp, exp);
1008 		goto finish;
1009 	}
1010 
1011 	err = check_export(nd.dentry->d_inode, nxp->ex_flags, NULL);
1012 	if (err) goto finish;
1013 
1014 	err = -ENOMEM;
1015 
1016 	dprintk("nfsd: creating export entry %p for client %p\n", exp, clp);
1017 
1018 	new.h.expiry_time = NEVER;
1019 	new.h.flags = 0;
1020 	new.ex_path = kstrdup(nxp->ex_path, GFP_KERNEL);
1021 	if (!new.ex_path)
1022 		goto finish;
1023 	new.ex_client = clp;
1024 	new.ex_mnt = nd.mnt;
1025 	new.ex_dentry = nd.dentry;
1026 	new.ex_flags = nxp->ex_flags;
1027 	new.ex_anon_uid = nxp->ex_anon_uid;
1028 	new.ex_anon_gid = nxp->ex_anon_gid;
1029 	new.ex_fsid = nxp->ex_dev;
1030 
1031 	exp = svc_export_lookup(&new);
1032 	if (exp)
1033 		exp = svc_export_update(&new, exp);
1034 
1035 	if (!exp)
1036 		goto finish;
1037 
1038 	if (exp_hash(clp, exp) ||
1039 	    exp_fsid_hash(clp, exp)) {
1040 		/* failed to create at least one index */
1041 		exp_do_unexport(exp);
1042 		cache_flush();
1043 	} else
1044 		err = 0;
1045 finish:
1046 	if (new.ex_path)
1047 		kfree(new.ex_path);
1048 	if (exp)
1049 		exp_put(exp);
1050 	if (fsid_key && !IS_ERR(fsid_key))
1051 		cache_put(&fsid_key->h, &svc_expkey_cache);
1052 	if (clp)
1053 		auth_domain_put(clp);
1054 	path_release(&nd);
1055 out_unlock:
1056 	exp_writeunlock();
1057 out:
1058 	return err;
1059 }
1060 
1061 /*
1062  * Unexport a file system. The export entry has already
1063  * been removed from the client's list of exported fs's.
1064  */
1065 static void
1066 exp_do_unexport(svc_export *unexp)
1067 {
1068 	unexp->h.expiry_time = get_seconds()-1;
1069 	svc_export_cache.nextcheck = get_seconds();
1070 	exp_unhash(unexp);
1071 	exp_fsid_unhash(unexp);
1072 }
1073 
1074 
1075 /*
1076  * unexport syscall.
1077  */
1078 int
1079 exp_unexport(struct nfsctl_export *nxp)
1080 {
1081 	struct auth_domain *dom;
1082 	svc_export *exp;
1083 	struct nameidata nd;
1084 	int		err;
1085 
1086 	/* Consistency check */
1087 	if (!exp_verify_string(nxp->ex_path, NFS_MAXPATHLEN) ||
1088 	    !exp_verify_string(nxp->ex_client, NFSCLNT_IDMAX))
1089 		return -EINVAL;
1090 
1091 	exp_writelock();
1092 
1093 	err = -EINVAL;
1094 	dom = auth_domain_find(nxp->ex_client);
1095 	if (!dom) {
1096 		dprintk("nfsd: unexport couldn't find %s\n", nxp->ex_client);
1097 		goto out_unlock;
1098 	}
1099 
1100 	err = path_lookup(nxp->ex_path, 0, &nd);
1101 	if (err)
1102 		goto out_domain;
1103 
1104 	err = -EINVAL;
1105 	exp = exp_get_by_name(dom, nd.mnt, nd.dentry, NULL);
1106 	path_release(&nd);
1107 	if (!exp)
1108 		goto out_domain;
1109 
1110 	exp_do_unexport(exp);
1111 	exp_put(exp);
1112 	err = 0;
1113 
1114 out_domain:
1115 	auth_domain_put(dom);
1116 	cache_flush();
1117 out_unlock:
1118 	exp_writeunlock();
1119 	return err;
1120 }
1121 
1122 /*
1123  * Obtain the root fh on behalf of a client.
1124  * This could be done in user space, but I feel that it adds some safety
1125  * since its harder to fool a kernel module than a user space program.
1126  */
1127 int
1128 exp_rootfh(svc_client *clp, char *path, struct knfsd_fh *f, int maxsize)
1129 {
1130 	struct svc_export	*exp;
1131 	struct nameidata	nd;
1132 	struct inode		*inode;
1133 	struct svc_fh		fh;
1134 	int			err;
1135 
1136 	err = -EPERM;
1137 	/* NB: we probably ought to check that it's NUL-terminated */
1138 	if (path_lookup(path, 0, &nd)) {
1139 		printk("nfsd: exp_rootfh path not found %s", path);
1140 		return err;
1141 	}
1142 	inode = nd.dentry->d_inode;
1143 
1144 	dprintk("nfsd: exp_rootfh(%s [%p] %s:%s/%ld)\n",
1145 		 path, nd.dentry, clp->name,
1146 		 inode->i_sb->s_id, inode->i_ino);
1147 	exp = exp_parent(clp, nd.mnt, nd.dentry, NULL);
1148 	if (IS_ERR(exp)) {
1149 		err = PTR_ERR(exp);
1150 		goto out;
1151 	}
1152 	if (!exp) {
1153 		dprintk("nfsd: exp_rootfh export not found.\n");
1154 		goto out;
1155 	}
1156 
1157 	/*
1158 	 * fh must be initialized before calling fh_compose
1159 	 */
1160 	fh_init(&fh, maxsize);
1161 	if (fh_compose(&fh, exp, nd.dentry, NULL))
1162 		err = -EINVAL;
1163 	else
1164 		err = 0;
1165 	memcpy(f, &fh.fh_handle, sizeof(struct knfsd_fh));
1166 	fh_put(&fh);
1167 	exp_put(exp);
1168 out:
1169 	path_release(&nd);
1170 	return err;
1171 }
1172 
1173 struct svc_export *
1174 exp_find(struct auth_domain *clp, int fsid_type, u32 *fsidv,
1175 	 struct cache_req *reqp)
1176 {
1177 	struct svc_export *exp;
1178 	struct svc_expkey *ek = exp_find_key(clp, fsid_type, fsidv, reqp);
1179 	if (!ek || IS_ERR(ek))
1180 		return ERR_PTR(PTR_ERR(ek));
1181 
1182 	exp = exp_get_by_name(clp, ek->ek_mnt, ek->ek_dentry, reqp);
1183 	cache_put(&ek->h, &svc_expkey_cache);
1184 
1185 	if (!exp || IS_ERR(exp))
1186 		return ERR_PTR(PTR_ERR(exp));
1187 	return exp;
1188 }
1189 
1190 
1191 /*
1192  * Called when we need the filehandle for the root of the pseudofs,
1193  * for a given NFSv4 client.   The root is defined to be the
1194  * export point with fsid==0
1195  */
1196 __be32
1197 exp_pseudoroot(struct auth_domain *clp, struct svc_fh *fhp,
1198 	       struct cache_req *creq)
1199 {
1200 	struct svc_export *exp;
1201 	__be32 rv;
1202 	u32 fsidv[2];
1203 
1204 	mk_fsid(FSID_NUM, fsidv, 0, 0, 0, NULL);
1205 
1206 	exp = exp_find(clp, FSID_NUM, fsidv, creq);
1207 	if (IS_ERR(exp))
1208 		return nfserrno(PTR_ERR(exp));
1209 	if (exp == NULL)
1210 		return nfserr_perm;
1211 	rv = fh_compose(fhp, exp, exp->ex_dentry, NULL);
1212 	exp_put(exp);
1213 	return rv;
1214 }
1215 
1216 /* Iterator */
1217 
1218 static void *e_start(struct seq_file *m, loff_t *pos)
1219 	__acquires(svc_export_cache.hash_lock)
1220 {
1221 	loff_t n = *pos;
1222 	unsigned hash, export;
1223 	struct cache_head *ch;
1224 
1225 	exp_readlock();
1226 	read_lock(&svc_export_cache.hash_lock);
1227 	if (!n--)
1228 		return SEQ_START_TOKEN;
1229 	hash = n >> 32;
1230 	export = n & ((1LL<<32) - 1);
1231 
1232 
1233 	for (ch=export_table[hash]; ch; ch=ch->next)
1234 		if (!export--)
1235 			return ch;
1236 	n &= ~((1LL<<32) - 1);
1237 	do {
1238 		hash++;
1239 		n += 1LL<<32;
1240 	} while(hash < EXPORT_HASHMAX && export_table[hash]==NULL);
1241 	if (hash >= EXPORT_HASHMAX)
1242 		return NULL;
1243 	*pos = n+1;
1244 	return export_table[hash];
1245 }
1246 
1247 static void *e_next(struct seq_file *m, void *p, loff_t *pos)
1248 {
1249 	struct cache_head *ch = p;
1250 	int hash = (*pos >> 32);
1251 
1252 	if (p == SEQ_START_TOKEN)
1253 		hash = 0;
1254 	else if (ch->next == NULL) {
1255 		hash++;
1256 		*pos += 1LL<<32;
1257 	} else {
1258 		++*pos;
1259 		return ch->next;
1260 	}
1261 	*pos &= ~((1LL<<32) - 1);
1262 	while (hash < EXPORT_HASHMAX && export_table[hash] == NULL) {
1263 		hash++;
1264 		*pos += 1LL<<32;
1265 	}
1266 	if (hash >= EXPORT_HASHMAX)
1267 		return NULL;
1268 	++*pos;
1269 	return export_table[hash];
1270 }
1271 
1272 static void e_stop(struct seq_file *m, void *p)
1273 	__releases(svc_export_cache.hash_lock)
1274 {
1275 	read_unlock(&svc_export_cache.hash_lock);
1276 	exp_readunlock();
1277 }
1278 
1279 static struct flags {
1280 	int flag;
1281 	char *name[2];
1282 } expflags[] = {
1283 	{ NFSEXP_READONLY, {"ro", "rw"}},
1284 	{ NFSEXP_INSECURE_PORT, {"insecure", ""}},
1285 	{ NFSEXP_ROOTSQUASH, {"root_squash", "no_root_squash"}},
1286 	{ NFSEXP_ALLSQUASH, {"all_squash", ""}},
1287 	{ NFSEXP_ASYNC, {"async", "sync"}},
1288 	{ NFSEXP_GATHERED_WRITES, {"wdelay", "no_wdelay"}},
1289 	{ NFSEXP_NOHIDE, {"nohide", ""}},
1290 	{ NFSEXP_CROSSMOUNT, {"crossmnt", ""}},
1291 	{ NFSEXP_NOSUBTREECHECK, {"no_subtree_check", ""}},
1292 	{ NFSEXP_NOAUTHNLM, {"insecure_locks", ""}},
1293 #ifdef MSNFS
1294 	{ NFSEXP_MSNFS, {"msnfs", ""}},
1295 #endif
1296 	{ 0, {"", ""}}
1297 };
1298 
1299 static void exp_flags(struct seq_file *m, int flag, int fsid,
1300 		uid_t anonu, uid_t anong, struct nfsd4_fs_locations *fsloc)
1301 {
1302 	int first = 0;
1303 	struct flags *flg;
1304 
1305 	for (flg = expflags; flg->flag; flg++) {
1306 		int state = (flg->flag & flag)?0:1;
1307 		if (*flg->name[state])
1308 			seq_printf(m, "%s%s", first++?",":"", flg->name[state]);
1309 	}
1310 	if (flag & NFSEXP_FSID)
1311 		seq_printf(m, "%sfsid=%d", first++?",":"", fsid);
1312 	if (anonu != (uid_t)-2 && anonu != (0x10000-2))
1313 		seq_printf(m, "%sanonuid=%d", first++?",":"", anonu);
1314 	if (anong != (gid_t)-2 && anong != (0x10000-2))
1315 		seq_printf(m, "%sanongid=%d", first++?",":"", anong);
1316 	if (fsloc && fsloc->locations_count > 0) {
1317 		char *loctype = (fsloc->migrated) ? "refer" : "replicas";
1318 		int i;
1319 
1320 		seq_printf(m, "%s%s=", first++?",":"", loctype);
1321 		seq_escape(m, fsloc->locations[0].path, ",;@ \t\n\\");
1322 		seq_putc(m, '@');
1323 		seq_escape(m, fsloc->locations[0].hosts, ",;@ \t\n\\");
1324 		for (i = 1; i < fsloc->locations_count; i++) {
1325 			seq_putc(m, ';');
1326 			seq_escape(m, fsloc->locations[i].path, ",;@ \t\n\\");
1327 			seq_putc(m, '@');
1328 			seq_escape(m, fsloc->locations[i].hosts, ",;@ \t\n\\");
1329 		}
1330 	}
1331 }
1332 
1333 static int e_show(struct seq_file *m, void *p)
1334 {
1335 	struct cache_head *cp = p;
1336 	struct svc_export *exp = container_of(cp, struct svc_export, h);
1337 
1338 	if (p == SEQ_START_TOKEN) {
1339 		seq_puts(m, "# Version 1.1\n");
1340 		seq_puts(m, "# Path Client(Flags) # IPs\n");
1341 		return 0;
1342 	}
1343 
1344 	cache_get(&exp->h);
1345 	if (cache_check(&svc_export_cache, &exp->h, NULL))
1346 		return 0;
1347 	cache_put(&exp->h, &svc_export_cache);
1348 	return svc_export_show(m, &svc_export_cache, cp);
1349 }
1350 
1351 struct seq_operations nfs_exports_op = {
1352 	.start	= e_start,
1353 	.next	= e_next,
1354 	.stop	= e_stop,
1355 	.show	= e_show,
1356 };
1357 
1358 /*
1359  * Add or modify a client.
1360  * Change requests may involve the list of host addresses. The list of
1361  * exports and possibly existing uid maps are left untouched.
1362  */
1363 int
1364 exp_addclient(struct nfsctl_client *ncp)
1365 {
1366 	struct auth_domain	*dom;
1367 	int			i, err;
1368 
1369 	/* First, consistency check. */
1370 	err = -EINVAL;
1371 	if (! exp_verify_string(ncp->cl_ident, NFSCLNT_IDMAX))
1372 		goto out;
1373 	if (ncp->cl_naddr > NFSCLNT_ADDRMAX)
1374 		goto out;
1375 
1376 	/* Lock the hashtable */
1377 	exp_writelock();
1378 
1379 	dom = unix_domain_find(ncp->cl_ident);
1380 
1381 	err = -ENOMEM;
1382 	if (!dom)
1383 		goto out_unlock;
1384 
1385 	/* Insert client into hashtable. */
1386 	for (i = 0; i < ncp->cl_naddr; i++)
1387 		auth_unix_add_addr(ncp->cl_addrlist[i], dom);
1388 
1389 	auth_unix_forget_old(dom);
1390 	auth_domain_put(dom);
1391 
1392 	err = 0;
1393 
1394 out_unlock:
1395 	exp_writeunlock();
1396 out:
1397 	return err;
1398 }
1399 
1400 /*
1401  * Delete a client given an identifier.
1402  */
1403 int
1404 exp_delclient(struct nfsctl_client *ncp)
1405 {
1406 	int		err;
1407 	struct auth_domain *dom;
1408 
1409 	err = -EINVAL;
1410 	if (!exp_verify_string(ncp->cl_ident, NFSCLNT_IDMAX))
1411 		goto out;
1412 
1413 	/* Lock the hashtable */
1414 	exp_writelock();
1415 
1416 	dom = auth_domain_find(ncp->cl_ident);
1417 	/* just make sure that no addresses work
1418 	 * and that it will expire soon
1419 	 */
1420 	if (dom) {
1421 		err = auth_unix_forget_old(dom);
1422 		auth_domain_put(dom);
1423 	}
1424 
1425 	exp_writeunlock();
1426 out:
1427 	return err;
1428 }
1429 
1430 /*
1431  * Verify that string is non-empty and does not exceed max length.
1432  */
1433 static int
1434 exp_verify_string(char *cp, int max)
1435 {
1436 	int	i;
1437 
1438 	for (i = 0; i < max; i++)
1439 		if (!cp[i])
1440 			return i;
1441 	cp[i] = 0;
1442 	printk(KERN_NOTICE "nfsd: couldn't validate string %s\n", cp);
1443 	return 0;
1444 }
1445 
1446 /*
1447  * Initialize the exports module.
1448  */
1449 void
1450 nfsd_export_init(void)
1451 {
1452 	dprintk("nfsd: initializing export module.\n");
1453 
1454 	cache_register(&svc_export_cache);
1455 	cache_register(&svc_expkey_cache);
1456 
1457 }
1458 
1459 /*
1460  * Flush exports table - called when last nfsd thread is killed
1461  */
1462 void
1463 nfsd_export_flush(void)
1464 {
1465 	exp_writelock();
1466 	cache_purge(&svc_expkey_cache);
1467 	cache_purge(&svc_export_cache);
1468 	exp_writeunlock();
1469 }
1470 
1471 /*
1472  * Shutdown the exports module.
1473  */
1474 void
1475 nfsd_export_shutdown(void)
1476 {
1477 
1478 	dprintk("nfsd: shutting down export module.\n");
1479 
1480 	exp_writelock();
1481 
1482 	if (cache_unregister(&svc_expkey_cache))
1483 		printk(KERN_ERR "nfsd: failed to unregister expkey cache\n");
1484 	if (cache_unregister(&svc_export_cache))
1485 		printk(KERN_ERR "nfsd: failed to unregister export cache\n");
1486 	svcauth_unix_purge();
1487 
1488 	exp_writeunlock();
1489 	dprintk("nfsd: export shutdown complete.\n");
1490 }
1491