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/malloc.h>
19 #include <linux/stat.h>
20 #include <linux/in.h>
21
22 #include <linux/sunrpc/svc.h>
23 #include <linux/nfsd/nfsd.h>
24 #include <linux/nfsd/nfsfh.h>
25 #include <linux/nfsd/syscall.h>
26 #include <linux/lockd/bind.h>
27
28 #define NFSDDBG_FACILITY NFSDDBG_EXPORT
29 #define NFSD_PARANOIA 1
30
31 typedef struct svc_client svc_client;
32 typedef struct svc_export svc_export;
33
34 static svc_export * exp_find(svc_client *clp, kdev_t dev);
35 static svc_export * exp_parent(svc_client *clp, kdev_t dev,
36 struct dentry *dentry);
37 static svc_export * exp_child(svc_client *clp, kdev_t dev,
38 struct dentry *dentry);
39 static void exp_unexport_all(svc_client *clp);
40 static void exp_do_unexport(svc_export *unexp);
41 static svc_client * exp_getclientbyname(char *name);
42 static void exp_freeclient(svc_client *clp);
43 static void exp_unhashclient(svc_client *clp);
44 static int exp_verify_string(char *cp, int max);
45
46 #define CLIENT_HASHBITS 6
47 #define CLIENT_HASHMAX (1 << CLIENT_HASHBITS)
48 #define CLIENT_HASHMASK (CLIENT_HASHMAX - 1)
49 #define CLIENT_HASH(a) \
50 ((((a)>>24) ^ ((a)>>16) ^ ((a)>>8) ^(a)) & CLIENT_HASHMASK)
51 /* XXX: is this adequate for 32bit kdev_t ? */
52 #define EXPORT_HASH(dev) ((dev) & (NFSCLNT_EXPMAX - 1))
53
54 struct svc_clnthash {
55 struct svc_clnthash * h_next;
56 struct in_addr h_addr;
57 struct svc_client * h_client;
58 };
59 static struct svc_clnthash * clnt_hash[CLIENT_HASHMAX];
60 static svc_client * clients;
61 static int initialized;
62
63 static int hash_lock;
64 static int want_lock;
65 static int hash_count;
66 static DECLARE_WAIT_QUEUE_HEAD( hash_wait );
67
68
69 /*
70 * Find a client's export for a device.
71 */
72 static inline svc_export *
73 exp_find(svc_client *clp, kdev_t dev)
74 {
75 svc_export * exp;
76
77 exp = clp->cl_export[EXPORT_HASH(dev)];
78 while (exp && exp->ex_dev != dev)
79 exp = exp->ex_next;
80 return exp;
81 }
82
83 /*
84 * Find the client's export entry matching xdev/xino.
85 */
86 svc_export *
87 exp_get(svc_client *clp, kdev_t dev, ino_t ino)
88 {
89 svc_export * exp;
90
91 if (!clp)
92 return NULL;
93
94 exp = clp->cl_export[EXPORT_HASH(dev)];
95 if (exp)
96 do {
97 if (exp->ex_ino == ino && exp->ex_dev == dev)
98 goto out;
99 } while (NULL != (exp = exp->ex_next));
100 exp = NULL;
101 out:
102 return exp;
103 }
104
105 /*
106 * Find the export entry for a given dentry. <gam3@acm.org>
107 */
108 static svc_export *
109 exp_parent(svc_client *clp, kdev_t dev, struct dentry *dentry)
110 {
111 svc_export *exp;
112
113 if (clp == NULL)
114 return NULL;
115
116 for (exp = clp->cl_export[EXPORT_HASH(dev)]; exp; exp = exp->ex_next)
117 if (is_subdir(dentry, exp->ex_dentry))
118 break;
119 return exp;
120 }
121
122 /*
123 * Find the child export entry for a given fs. This function is used
124 * only by the export syscall to keep the export tree consistent.
125 * <gam3@acm.org>
126 */
127 static svc_export *
128 exp_child(svc_client *clp, kdev_t dev, struct dentry *dentry)
129 {
130 svc_export *exp;
131
132 if (clp == NULL)
133 return NULL;
134
135 for (exp = clp->cl_export[EXPORT_HASH(dev)]; exp; exp = exp->ex_next) {
136 struct dentry *ndentry = exp->ex_dentry;
137 if (ndentry && is_subdir(ndentry->d_parent, dentry))
138 break;
139 }
140 return exp;
141 }
142
143 /*
144 * Export a file system.
145 */
146 int
147 exp_export(struct nfsctl_export *nxp)
148 {
149 svc_client *clp;
150 svc_export *exp, *parent;
151 svc_export **head;
152 struct nameidata nd;
153 struct inode *inode = NULL;
154 int i, err;
155 kdev_t dev;
156 ino_t ino;
157
158 /* Consistency check */
159 err = -EINVAL;
160 if (!exp_verify_string(nxp->ex_path, NFS_MAXPATHLEN) ||
161 !exp_verify_string(nxp->ex_client, NFSCLNT_IDMAX))
162 goto out;
163
164 dprintk("exp_export called for %s:%s (%x/%ld fl %x).\n",
165 nxp->ex_client, nxp->ex_path,
166 nxp->ex_dev, (long) nxp->ex_ino, nxp->ex_flags);
167 dev = to_kdev_t(nxp->ex_dev);
168 ino = nxp->ex_ino;
169
170 /* Try to lock the export table for update */
171 if ((err = exp_writelock()) < 0)
172 goto out;
173
174 /* Look up client info */
175 err = -EINVAL;
176 if (!(clp = exp_getclientbyname(nxp->ex_client)))
177 goto out_unlock;
178
179 /*
180 * If there's already an export for this file, assume this
181 * is just a flag update.
182 */
183 if ((exp = exp_get(clp, dev, ino)) != NULL) {
184 exp->ex_flags = nxp->ex_flags;
185 exp->ex_anon_uid = nxp->ex_anon_uid;
186 exp->ex_anon_gid = nxp->ex_anon_gid;
187 err = 0;
188 goto out_unlock;
189 }
190
191 /* Look up the dentry */
192 err = 0;
193 if (path_init(nxp->ex_path, LOOKUP_POSITIVE, &nd))
194 err = path_walk(nxp->ex_path, &nd);
195 if (err)
196 goto out_unlock;
197
198 inode = nd.dentry->d_inode;
199 err = -EINVAL;
200 if (inode->i_dev != dev || inode->i_ino != nxp->ex_ino) {
201 printk(KERN_DEBUG "exp_export: i_dev = %x, dev = %x\n",
202 inode->i_dev, dev);
203 /* I'm just being paranoid... */
204 goto finish;
205 }
206
207 /* We currently export only dirs and regular files.
208 * This is what umountd does.
209 */
210 err = -ENOTDIR;
211 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode))
212 goto finish;
213
214 err = -EINVAL;
215 if (!(inode->i_sb->s_type->fs_flags & FS_REQUIRES_DEV) ||
216 inode->i_sb->s_op->read_inode == NULL) {
217 dprintk("exp_export: export of invalid fs type.\n");
218 goto finish;
219 }
220
221 if ((parent = exp_child(clp, dev, nd.dentry)) != NULL) {
222 dprintk("exp_export: export not valid (Rule 3).\n");
223 goto finish;
224 }
225 /* Is this is a sub-export, must be a proper subset of FS */
226 if ((parent = exp_parent(clp, dev, nd.dentry)) != NULL) {
227 dprintk("exp_export: sub-export not valid (Rule 2).\n");
228 goto finish;
229 }
230
231 err = -ENOMEM;
232 if (!(exp = kmalloc(sizeof(*exp), GFP_USER)))
233 goto finish;
234 dprintk("nfsd: created export entry %p for client %p\n", exp, clp);
235
236 strcpy(exp->ex_path, nxp->ex_path);
237 exp->ex_client = clp;
238 exp->ex_parent = parent;
239 exp->ex_dentry = nd.dentry;
240 exp->ex_mnt = nd.mnt;
241 exp->ex_flags = nxp->ex_flags;
242 exp->ex_dev = dev;
243 exp->ex_ino = ino;
244 exp->ex_anon_uid = nxp->ex_anon_uid;
245 exp->ex_anon_gid = nxp->ex_anon_gid;
246
247 /* Update parent pointers of all exports */
248 if (parent) {
249 for (i = 0; i < NFSCLNT_EXPMAX; i++) {
250 svc_export *temp = clp->cl_export[i];
251
252 while (temp) {
253 if (temp->ex_parent == parent)
254 temp->ex_parent = exp;
255 temp = temp->ex_next;
256 }
257 }
258 }
259
260 head = clp->cl_export + EXPORT_HASH(dev);
261 exp->ex_next = *head;
262 *head = exp;
263
264 err = 0;
265
266 /* Unlock hashtable */
267 out_unlock:
268 exp_unlock();
269 out:
270 return err;
271
272 /* Release the dentry */
273 finish:
274 path_release(&nd);
275 goto out_unlock;
276 }
277
278 /*
279 * Unexport a file system. The export entry has already
280 * been removed from the client's list of exported fs's.
281 */
282 static void
283 exp_do_unexport(svc_export *unexp)
284 {
285 svc_export *exp;
286 svc_client *clp;
287 struct dentry *dentry;
288 struct vfsmount *mnt;
289 struct inode *inode;
290 int i;
291
292 /* Update parent pointers. */
293 clp = unexp->ex_client;
294 for (i = 0; i < NFSCLNT_EXPMAX; i++) {
295 for (exp = clp->cl_export[i]; exp; exp = exp->ex_next)
296 if (exp->ex_parent == unexp)
297 exp->ex_parent = unexp->ex_parent;
298 }
299
300 dentry = unexp->ex_dentry;
301 mnt = unexp->ex_mnt;
302 inode = dentry->d_inode;
303 if (unexp->ex_dev != inode->i_dev || unexp->ex_ino != inode->i_ino)
304 printk(KERN_WARNING "nfsd: bad dentry in unexport!\n");
305 dput(dentry);
306 mntput(mnt);
307
308 kfree(unexp);
309 }
310
311 /*
312 * Revoke all exports for a given client.
313 * This may look very awkward, but we have to do it this way in order
314 * to avoid race conditions (aka mind the parent pointer).
315 */
316 static void
317 exp_unexport_all(svc_client *clp)
318 {
319 svc_export *exp;
320 int i;
321
322 dprintk("unexporting all fs's for clnt %p\n", clp);
323 for (i = 0; i < NFSCLNT_EXPMAX; i++) {
324 exp = clp->cl_export[i];
325 clp->cl_export[i] = NULL;
326 while (exp) {
327 svc_export *next = exp->ex_next;
328 exp_do_unexport(exp);
329 exp = next;
330 }
331 }
332 }
333
334 /*
335 * unexport syscall.
336 */
337 int
338 exp_unexport(struct nfsctl_export *nxp)
339 {
340 svc_client *clp;
341 svc_export **expp, *exp = NULL;
342 int err;
343
344 /* Consistency check */
345 if (!exp_verify_string(nxp->ex_client, NFSCLNT_IDMAX))
346 return -EINVAL;
347
348 if ((err = exp_writelock()) < 0)
349 goto out;
350
351 err = -EINVAL;
352 clp = exp_getclientbyname(nxp->ex_client);
353 if (clp) {
354 expp = clp->cl_export + EXPORT_HASH(nxp->ex_dev);
355 while ((exp = *expp) != NULL) {
356 if (exp->ex_dev == nxp->ex_dev) {
357 if (exp->ex_ino == nxp->ex_ino) {
358 *expp = exp->ex_next;
359 exp_do_unexport(exp);
360 err = 0;
361 break;
362 }
363 }
364 expp = &(exp->ex_next);
365 }
366 }
367
368 exp_unlock();
369 out:
370 return err;
371 }
372
373 /*
374 * Obtain the root fh on behalf of a client.
375 * This could be done in user space, but I feel that it adds some safety
376 * since its harder to fool a kernel module than a user space program.
377 */
378 int
379 exp_rootfh(struct svc_client *clp, kdev_t dev, ino_t ino,
380 char *path, struct knfsd_fh *f, int maxsize)
381 {
382 struct svc_export *exp;
383 struct nameidata nd;
384 struct inode *inode;
385 struct svc_fh fh;
386 int err;
387
388 err = -EPERM;
389 if (path) {
390 if (path_init(path, LOOKUP_POSITIVE, &nd) &&
391 path_walk(path, &nd)) {
392 printk("nfsd: exp_rootfh path not found %s", path);
393 return err;
394 }
395 dev = nd.dentry->d_inode->i_dev;
396 ino = nd.dentry->d_inode->i_ino;
397
398 dprintk("nfsd: exp_rootfh(%s [%p] %s:%x/%ld)\n",
399 path, nd.dentry, clp->cl_ident, dev, (long) ino);
400 exp = exp_parent(clp, dev, nd.dentry);
401 } else {
402 dprintk("nfsd: exp_rootfh(%s:%x/%ld)\n",
403 clp->cl_ident, dev, (long) ino);
404 if ((exp = exp_get(clp, dev, ino))) {
405 nd.mnt = mntget(exp->ex_mnt);
406 nd.dentry = dget(exp->ex_dentry);
407 }
408 }
409 if (!exp) {
410 dprintk("nfsd: exp_rootfh export not found.\n");
411 goto out;
412 }
413
414 inode = nd.dentry->d_inode;
415 if (!inode) {
416 printk("exp_rootfh: Aieee, NULL d_inode\n");
417 goto out;
418 }
419 if (inode->i_dev != dev || inode->i_ino != ino) {
420 printk("exp_rootfh: Aieee, ino/dev mismatch\n");
421 printk("exp_rootfh: arg[dev(%x):ino(%ld)]"
422 " inode[dev(%x):ino(%ld)]\n",
423 dev, (long) ino, inode->i_dev, (long) inode->i_ino);
424 }
425
426 /*
427 * fh must be initialized before calling fh_compose
428 */
429 fh_init(&fh, maxsize);
430 if (fh_compose(&fh, exp, dget(nd.dentry)))
431 err = -EINVAL;
432 else
433 err = 0;
434 memcpy(f, &fh.fh_handle, sizeof(struct knfsd_fh));
435 fh_put(&fh);
436
437 out:
438 if (path)
439 path_release(&nd);
440 return err;
441 }
442
443 /*
444 * Hashtable locking. Write locks are placed only by user processes
445 * wanting to modify export information.
446 */
447 void
448 exp_readlock(void)
449 {
450 while (hash_lock || want_lock)
451 sleep_on(&hash_wait);
452 hash_count++;
453 }
454
455 int
456 exp_writelock(void)
457 {
458 /* fast track */
459 if (!hash_count && !hash_lock) {
460 lock_it:
461 hash_lock = 1;
462 return 0;
463 }
464
465 current->sigpending = 0;
466 want_lock++;
467 while (hash_count || hash_lock) {
468 interruptible_sleep_on(&hash_wait);
469 if (signal_pending(current))
470 break;
471 }
472 want_lock--;
473
474 /* restore the task's signals */
475 spin_lock_irq(¤t->sigmask_lock);
476 recalc_sigpending(current);
477 spin_unlock_irq(¤t->sigmask_lock);
478
479 if (!hash_count && !hash_lock)
480 goto lock_it;
481 return -EINTR;
482 }
483
484 void
485 exp_unlock(void)
486 {
487 if (!hash_count && !hash_lock)
488 printk(KERN_WARNING "exp_unlock: not locked!\n");
489 if (hash_count)
490 hash_count--;
491 else
492 hash_lock = 0;
493 wake_up(&hash_wait);
494 }
495
496 /*
497 * Find a valid client given an inet address. We always move the most
498 * recently used client to the front of the hash chain to speed up
499 * future lookups.
500 * Locking against other processes is the responsibility of the caller.
501 */
502 struct svc_client *
503 exp_getclient(struct sockaddr_in *sin)
504 {
505 struct svc_clnthash **hp, **head, *tmp;
506 unsigned long addr = sin->sin_addr.s_addr;
507
508 if (!initialized)
509 return NULL;
510
511 head = &clnt_hash[CLIENT_HASH(addr)];
512
513 for (hp = head; (tmp = *hp) != NULL; hp = &(tmp->h_next)) {
514 if (tmp->h_addr.s_addr == addr) {
515 /* Move client to the front */
516 if (head != hp) {
517 *hp = tmp->h_next;
518 tmp->h_next = *head;
519 *head = tmp;
520 }
521
522 return tmp->h_client;
523 }
524 }
525
526 return NULL;
527 }
528
529 /*
530 * Find a client given its identifier.
531 */
532 static svc_client *
533 exp_getclientbyname(char *ident)
534 {
535 svc_client * clp;
536
537 for (clp = clients; clp; clp = clp->cl_next) {
538 if (!strcmp(clp->cl_ident, ident))
539 return clp;
540 }
541 return NULL;
542 }
543
544 struct flags {
545 int flag;
546 char *name[2];
547 } expflags[] = {
548 { NFSEXP_READONLY, {"ro", "rw"}},
549 { NFSEXP_INSECURE_PORT, {"insecure", ""}},
550 { NFSEXP_ROOTSQUASH, {"root_squash", "no_root_squash"}},
551 { NFSEXP_ALLSQUASH, {"all_squash", ""}},
552 { NFSEXP_ASYNC, {"async", ""}},
553 { NFSEXP_GATHERED_WRITES, {"wdelay", ""}},
554 { NFSEXP_UIDMAP, {"uidmap", ""}},
555 { NFSEXP_KERBEROS, { "kerberos", ""}},
556 { NFSEXP_SUNSECURE, { "sunsecure", ""}},
557 { NFSEXP_CROSSMNT, {"nohide", ""}},
558 { NFSEXP_NOSUBTREECHECK, {"no_subtree_check", ""}},
559 { NFSEXP_NOAUTHNLM, {"insecure_locks", ""}},
560 #ifdef NSMFS
561 { NFSEXP_MSNFS, {"msnfs", ""}},
562 #endif
563 { 0, {"", ""}}
564 };
565
566 static int
567 exp_flags(char *buffer, int flag)
568 {
569 int len = 0, first = 0;
570 struct flags *flg = expflags;
571
572 for (;flg->flag;flg++) {
573 int state = (flg->flag & flag)?0:1;
574 if (!flg->flag)
575 break;
576 if (*flg->name[state]) {
577 len += sprintf(buffer + len, "%s%s",
578 first++?",":"", flg->name[state]);
579 }
580 }
581 return len;
582 }
583
584 int
585 exp_procfs_exports(char *buffer, char **start, off_t offset,
586 int length, int *eof, void *data)
587 {
588 struct svc_clnthash **hp, **head, *tmp;
589 struct svc_client *clp;
590 svc_export *exp;
591 off_t pos = 0;
592 off_t begin = 0;
593 int len = 0;
594 int i,j;
595
596 len += sprintf(buffer, "# Version 1.0\n");
597 len += sprintf(buffer+len, "# Path Client(Flags) # IPs\n");
598
599 for (clp = clients; clp; clp = clp->cl_next) {
600 for (i = 0; i < NFSCLNT_EXPMAX; i++) {
601 exp = clp->cl_export[i];
602 while (exp) {
603 int first = 0;
604 len += sprintf(buffer+len, "%s\t", exp->ex_path);
605 len += sprintf(buffer+len, "%s", clp->cl_ident);
606 len += sprintf(buffer+len, "(");
607
608 len += exp_flags(buffer+len, exp->ex_flags);
609 len += sprintf(buffer+len, ") # ");
610 for (j = 0; j < clp->cl_naddr; j++) {
611 struct in_addr addr = clp->cl_addr[j];
612
613 head = &clnt_hash[CLIENT_HASH(addr.s_addr)];
614 for (hp = head; (tmp = *hp) != NULL; hp = &(tmp->h_next)) {
615 if (tmp->h_addr.s_addr == addr.s_addr) {
616 if (first++) len += sprintf(buffer+len, "%s", " ");
617 if (tmp->h_client != clp)
618 len += sprintf(buffer+len, "(");
619 len += sprintf(buffer+len, "%d.%d.%d.%d",
620 htonl(addr.s_addr) >> 24 & 0xff,
621 htonl(addr.s_addr) >> 16 & 0xff,
622 htonl(addr.s_addr) >> 8 & 0xff,
623 htonl(addr.s_addr) >> 0 & 0xff);
624 if (tmp->h_client != clp)
625 len += sprintf(buffer+len, ")");
626 break;
627 }
628 }
629 }
630 exp = exp->ex_next;
631
632 buffer[len++]='\n';
633
634 pos=begin+len;
635 if(pos<offset) {
636 len=0;
637 begin=pos;
638 }
639 if (pos > offset + length)
640 goto done;
641 }
642 }
643 }
644
645 *eof = 1;
646
647 done:
648 *start = buffer + (offset - begin);
649 len -= (offset - begin);
650 if ( len > length )
651 len = length;
652 return len;
653 }
654
655 /*
656 * Add or modify a client.
657 * Change requests may involve the list of host addresses. The list of
658 * exports and possibly existing uid maps are left untouched.
659 */
660 int
661 exp_addclient(struct nfsctl_client *ncp)
662 {
663 struct svc_clnthash * ch[NFSCLNT_ADDRMAX];
664 svc_client * clp;
665 int i, err, change = 0, ilen;
666
667 /* First, consistency check. */
668 err = -EINVAL;
669 if (!(ilen = exp_verify_string(ncp->cl_ident, NFSCLNT_IDMAX)))
670 goto out;
671 if (ncp->cl_naddr > NFSCLNT_ADDRMAX)
672 goto out;
673
674 /* Lock the hashtable */
675 if ((err = exp_writelock()) < 0)
676 goto out;
677
678 /* First check if this is a change request for a client. */
679 for (clp = clients; clp; clp = clp->cl_next)
680 if (!strcmp(clp->cl_ident, ncp->cl_ident))
681 break;
682
683 err = -ENOMEM;
684 if (clp) {
685 change = 1;
686 } else {
687 if (!(clp = kmalloc(sizeof(*clp), GFP_KERNEL)))
688 goto out_unlock;
689 memset(clp, 0, sizeof(*clp));
690
691 dprintk("created client %s (%p)\n", ncp->cl_ident, clp);
692
693 strcpy(clp->cl_ident, ncp->cl_ident);
694 clp->cl_idlen = ilen;
695 }
696
697 /* Allocate hash buckets */
698 for (i = 0; i < ncp->cl_naddr; i++) {
699 ch[i] = kmalloc(sizeof(struct svc_clnthash), GFP_KERNEL);
700 if (!ch[i]) {
701 while (i--)
702 kfree(ch[i]);
703 if (!change)
704 kfree(clp);
705 goto out_unlock;
706 }
707 }
708
709 /* Copy addresses. */
710 for (i = 0; i < ncp->cl_naddr; i++) {
711 clp->cl_addr[i] = ncp->cl_addrlist[i];
712 }
713 clp->cl_naddr = ncp->cl_naddr;
714
715 /* Remove old client hash entries. */
716 if (change)
717 exp_unhashclient(clp);
718
719 /* Insert client into hashtable. */
720 for (i = 0; i < ncp->cl_naddr; i++) {
721 struct in_addr addr = clp->cl_addr[i];
722 int hash;
723
724 hash = CLIENT_HASH(addr.s_addr);
725 ch[i]->h_client = clp;
726 ch[i]->h_addr = addr;
727 ch[i]->h_next = clnt_hash[hash];
728 clnt_hash[hash] = ch[i];
729 }
730
731 if (!change) {
732 clp->cl_next = clients;
733 clients = clp;
734 }
735 err = 0;
736
737 out_unlock:
738 exp_unlock();
739 out:
740 return err;
741 }
742
743 /*
744 * Delete a client given an identifier.
745 */
746 int
747 exp_delclient(struct nfsctl_client *ncp)
748 {
749 svc_client **clpp, *clp;
750 int err;
751
752 err = -EINVAL;
753 if (!exp_verify_string(ncp->cl_ident, NFSCLNT_IDMAX))
754 goto out;
755
756 /* Lock the hashtable */
757 if ((err = exp_writelock()) < 0)
758 goto out;
759
760 err = -EINVAL;
761 for (clpp = &clients; (clp = *clpp); clpp = &(clp->cl_next))
762 if (!strcmp(ncp->cl_ident, clp->cl_ident))
763 break;
764
765 if (clp) {
766 *clpp = clp->cl_next;
767 exp_freeclient(clp);
768 err = 0;
769 }
770
771 exp_unlock();
772 out:
773 return err;
774 }
775
776 /*
777 * Free a client. The caller has already removed it from the client list.
778 */
779 static void
780 exp_freeclient(svc_client *clp)
781 {
782 exp_unhashclient(clp);
783
784 /* umap_free(&(clp->cl_umap)); */
785 exp_unexport_all(clp);
786 nfsd_lockd_unexport(clp);
787 kfree (clp);
788 }
789
790 /*
791 * Remove client from hashtable. We first collect all hashtable
792 * entries and free them in one go.
793 * The hash table must be writelocked by the caller.
794 */
795 static void
796 exp_unhashclient(svc_client *clp)
797 {
798 struct svc_clnthash **hpp, *hp, *ch[NFSCLNT_ADDRMAX];
799 int i, count, err;
800
801 again:
802 err = 0;
803 for (i = 0, count = 0; i < CLIENT_HASHMAX && !err; i++) {
804 hpp = clnt_hash + i;
805 while ((hp = *hpp) && !err) {
806 if (hp->h_client == clp) {
807 *hpp = hp->h_next;
808 ch[count++] = hp;
809 err = (count >= NFSCLNT_ADDRMAX);
810 } else {
811 hpp = &(hp->h_next);
812 }
813 }
814 }
815 if (count != clp->cl_naddr)
816 printk(KERN_WARNING "nfsd: bad address count in freeclient!\n");
817 if (err)
818 goto again;
819 for (i = 0; i < count; i++)
820 kfree (ch[i]);
821 }
822
823 /*
824 * Lockd is shutting down and tells us to unregister all clients
825 */
826 void
827 exp_nlmdetach(void)
828 {
829 struct svc_client *clp;
830
831 for (clp = clients; clp; clp = clp->cl_next)
832 nfsd_lockd_unexport(clp);
833 }
834
835 /*
836 * Verify that string is non-empty and does not exceed max length.
837 */
838 static int
839 exp_verify_string(char *cp, int max)
840 {
841 int i;
842
843 for (i = 0; i < max; i++)
844 if (!cp[i])
845 return i;
846 cp[i] = 0;
847 printk(KERN_NOTICE "nfsd: couldn't validate string %s\n", cp);
848 return 0;
849 }
850
851 /*
852 * Initialize the exports module.
853 */
854 void
855 nfsd_export_init(void)
856 {
857 int i;
858
859 dprintk("nfsd: initializing export module.\n");
860 if (initialized)
861 return;
862 for (i = 0; i < CLIENT_HASHMAX; i++)
863 clnt_hash[i] = NULL;
864 clients = NULL;
865
866 initialized = 1;
867 }
868
869 /*
870 * Shutdown the exports module.
871 */
872 void
873 nfsd_export_shutdown(void)
874 {
875 int i;
876
877 dprintk("nfsd: shutting down export module.\n");
878 if (!initialized)
879 return;
880 if (exp_writelock() < 0) {
881 printk(KERN_WARNING "Weird: hashtable locked in exp_shutdown");
882 return;
883 }
884 for (i = 0; i < CLIENT_HASHMAX; i++) {
885 while (clnt_hash[i])
886 exp_freeclient(clnt_hash[i]->h_client);
887 }
888 clients = NULL; /* we may be restarted before the module unloads */
889
890 exp_unlock();
891 dprintk("nfsd: export shutdown complete.\n");
892 }
893
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.