1// SPDX-License-Identifier: GPL-2.0 2/* 3 * NFS exporting and validation. 4 * 5 * We maintain a list of clients, each of which has a list of 6 * exports. To export an fs to a given client, you first have 7 * to create the client entry with NFSCTL_ADDCLIENT, which 8 * creates a client control block and adds it to the hash 9 * table. Then, you call NFSCTL_EXPORT for each fs. 10 * 11 * 12 * Copyright (C) 1995, 1996 Olaf Kirch, <okir@monad.swb.de> 13 */ 14 15#include <linux/slab.h> 16#include <linux/namei.h> 17#include <linux/module.h> 18#include <linux/exportfs.h> 19#include <linux/sunrpc/svc_xprt.h> 20 21#include "nfsd.h" 22#include "nfsfh.h" 23#include "netns.h" 24#include "pnfs.h" 25#include "filecache.h" 26#include "trace.h" 27 28#define NFSDDBG_FACILITY NFSDDBG_EXPORT 29 30/* 31 * We have two caches. 32 * One maps client+vfsmnt+dentry to export options - the export map 33 * The other maps client+filehandle-fragment to export options. - the expkey map 34 * 35 * The export options are actually stored in the first map, and the 36 * second map contains a reference to the entry in the first map. 37 */ 38 39#define EXPKEY_HASHBITS 8 40#define EXPKEY_HASHMAX (1 << EXPKEY_HASHBITS) 41#define EXPKEY_HASHMASK (EXPKEY_HASHMAX -1) 42 43static void expkey_put(struct kref *ref) 44{ 45 struct svc_expkey *key = container_of(ref, struct svc_expkey, h.ref); 46 47 if (test_bit(CACHE_VALID, &key->h.flags) && 48 !test_bit(CACHE_NEGATIVE, &key->h.flags)) 49 path_put(&key->ek_path); 50 auth_domain_put(key->ek_client); 51 kfree_rcu(key, ek_rcu); 52} 53 54static int expkey_upcall(struct cache_detail *cd, struct cache_head *h) 55{ 56 return sunrpc_cache_pipe_upcall(cd, h); 57} 58 59static void expkey_request(struct cache_detail *cd, 60 struct cache_head *h, 61 char **bpp, int *blen) 62{ 63 /* client fsidtype \xfsid */ 64 struct svc_expkey *ek = container_of(h, struct svc_expkey, h); 65 char type[5]; 66 67 qword_add(bpp, blen, ek->ek_client->name); 68 snprintf(type, 5, "%d", ek->ek_fsidtype); 69 qword_add(bpp, blen, type); 70 qword_addhex(bpp, blen, (char*)ek->ek_fsid, key_len(ek->ek_fsidtype)); 71 (*bpp)[-1] = '\n'; 72} 73 74static struct svc_expkey *svc_expkey_update(struct cache_detail *cd, struct svc_expkey *new, 75 struct svc_expkey *old); 76static struct svc_expkey *svc_expkey_lookup(struct cache_detail *cd, struct svc_expkey *); 77 78static int expkey_parse(struct cache_detail *cd, char *mesg, int mlen) 79{ 80 /* client fsidtype fsid expiry [path] */ 81 char *buf; 82 int len; 83 struct auth_domain *dom = NULL; 84 int err; 85 int fsidtype; 86 char *ep; 87 struct svc_expkey key; 88 struct svc_expkey *ek = NULL; 89 90 if (mesg[mlen - 1] != '\n') 91 return -EINVAL; 92 mesg[mlen-1] = 0; 93 94 buf = kmalloc(PAGE_SIZE, GFP_KERNEL); 95 err = -ENOMEM; 96 if (!buf) 97 goto out; 98 99 err = -EINVAL; 100 if (qword_get(&mesg, buf, PAGE_SIZE) <= 0) 101 goto out; 102 103 err = -ENOENT; 104 dom = auth_domain_find(buf); 105 if (!dom) 106 goto out; 107 dprintk("found domain %s\n", buf); 108 109 err = -EINVAL; 110 if (qword_get(&mesg, buf, PAGE_SIZE) <= 0) 111 goto out; 112 fsidtype = simple_strtoul(buf, &ep, 10); 113 if (*ep) 114 goto out; 115 dprintk("found fsidtype %d\n", fsidtype); 116 if (key_len(fsidtype)==0) /* invalid type */ 117 goto out; 118 if ((len=qword_get(&mesg, buf, PAGE_SIZE)) <= 0) 119 goto out; 120 dprintk("found fsid length %d\n", len); 121 if (len != key_len(fsidtype)) 122 goto out; 123 124 /* OK, we seem to have a valid key */ 125 key.h.flags = 0; 126 err = get_expiry(&mesg, &key.h.expiry_time); 127 if (err) 128 goto out; 129 130 key.ek_client = dom; 131 key.ek_fsidtype = fsidtype; 132 memcpy(key.ek_fsid, buf, len); 133 134 ek = svc_expkey_lookup(cd, &key); 135 err = -ENOMEM; 136 if (!ek) 137 goto out; 138 139 /* now we want a pathname, or empty meaning NEGATIVE */ 140 err = -EINVAL; 141 len = qword_get(&mesg, buf, PAGE_SIZE); 142 if (len < 0) 143 goto out; 144 dprintk("Path seems to be <%s>\n", buf); 145 err = 0; 146 if (len == 0) { 147 set_bit(CACHE_NEGATIVE, &key.h.flags); 148 ek = svc_expkey_update(cd, &key, ek); 149 if (ek) 150 trace_nfsd_expkey_update(ek, NULL); 151 else 152 err = -ENOMEM; 153 } else { 154 err = kern_path(buf, 0, &key.ek_path); 155 if (err) 156 goto out; 157 158 dprintk("Found the path %s\n", buf); 159 160 ek = svc_expkey_update(cd, &key, ek); 161 if (ek) 162 trace_nfsd_expkey_update(ek, buf); 163 else 164 err = -ENOMEM; 165 path_put(&key.ek_path); 166 } 167 cache_flush(); 168 out: 169 if (ek) 170 cache_put(&ek->h, cd); 171 if (dom) 172 auth_domain_put(dom); 173 kfree(buf); 174 return err; 175} 176 177static int expkey_show(struct seq_file *m, 178 struct cache_detail *cd, 179 struct cache_head *h) 180{ 181 struct svc_expkey *ek ; 182 int i; 183 184 if (h ==NULL) { 185 seq_puts(m, "#domain fsidtype fsid [path]\n"); 186 return 0; 187 } 188 ek = container_of(h, struct svc_expkey, h); 189 seq_printf(m, "%s %d 0x", ek->ek_client->name, 190 ek->ek_fsidtype); 191 for (i=0; i < key_len(ek->ek_fsidtype)/4; i++) 192 seq_printf(m, "%08x", ek->ek_fsid[i]); 193 if (test_bit(CACHE_VALID, &h->flags) && 194 !test_bit(CACHE_NEGATIVE, &h->flags)) { 195 seq_printf(m, " "); 196 seq_path(m, &ek->ek_path, "\\ \t\n"); 197 } 198 seq_printf(m, "\n"); 199 return 0; 200} 201 202static inline int expkey_match (struct cache_head *a, struct cache_head *b) 203{ 204 struct svc_expkey *orig = container_of(a, struct svc_expkey, h); 205 struct svc_expkey *new = container_of(b, struct svc_expkey, h); 206 207 if (orig->ek_fsidtype != new->ek_fsidtype || 208 orig->ek_client != new->ek_client || 209 memcmp(orig->ek_fsid, new->ek_fsid, key_len(orig->ek_fsidtype)) != 0) 210 return 0; 211 return 1; 212} 213 214static inline void expkey_init(struct cache_head *cnew, 215 struct cache_head *citem) 216{ 217 struct svc_expkey *new = container_of(cnew, struct svc_expkey, h); 218 struct svc_expkey *item = container_of(citem, struct svc_expkey, h); 219 220 kref_get(&item->ek_client->ref); 221 new->ek_client = item->ek_client; 222 new->ek_fsidtype = item->ek_fsidtype; 223 224 memcpy(new->ek_fsid, item->ek_fsid, sizeof(new->ek_fsid)); 225} 226 227static inline void expkey_update(struct cache_head *cnew, 228 struct cache_head *citem) 229{ 230 struct svc_expkey *new = container_of(cnew, struct svc_expkey, h); 231 struct svc_expkey *item = container_of(citem, struct svc_expkey, h); 232 233 new->ek_path = item->ek_path; 234 path_get(&item->ek_path); 235} 236 237static struct cache_head *expkey_alloc(void) 238{ 239 struct svc_expkey *i = kmalloc(sizeof(*i), GFP_KERNEL); 240 if (i) 241 return &i->h; 242 else 243 return NULL; 244} 245 246static void expkey_flush(void) 247{ 248 /* 249 * Take the nfsd_mutex here to ensure that the file cache is not 250 * destroyed while we're in the middle of flushing. 251 */ 252 mutex_lock(&nfsd_mutex); 253 nfsd_file_cache_purge(current->nsproxy->net_ns); 254 mutex_unlock(&nfsd_mutex); 255} 256 257static const struct cache_detail svc_expkey_cache_template = { 258 .owner = THIS_MODULE, 259 .hash_size = EXPKEY_HASHMAX, 260 .name = "nfsd.fh", 261 .cache_put = expkey_put, 262 .cache_upcall = expkey_upcall, 263 .cache_request = expkey_request, 264 .cache_parse = expkey_parse, 265 .cache_show = expkey_show, 266 .match = expkey_match, 267 .init = expkey_init, 268 .update = expkey_update, 269 .alloc = expkey_alloc, 270 .flush = expkey_flush, 271}; 272 273static int 274svc_expkey_hash(struct svc_expkey *item) 275{ 276 int hash = item->ek_fsidtype; 277 char * cp = (char*)item->ek_fsid; 278 int len = key_len(item->ek_fsidtype); 279 280 hash ^= hash_mem(cp, len, EXPKEY_HASHBITS); 281 hash ^= hash_ptr(item->ek_client, EXPKEY_HASHBITS); 282 hash &= EXPKEY_HASHMASK; 283 return hash; 284} 285 286static struct svc_expkey * 287svc_expkey_lookup(struct cache_detail *cd, struct svc_expkey *item) 288{ 289 struct cache_head *ch; 290 int hash = svc_expkey_hash(item); 291 292 ch = sunrpc_cache_lookup_rcu(cd, &item->h, hash); 293 if (ch) 294 return container_of(ch, struct svc_expkey, h); 295 else 296 return NULL; 297} 298 299static struct svc_expkey * 300svc_expkey_update(struct cache_detail *cd, struct svc_expkey *new, 301 struct svc_expkey *old) 302{ 303 struct cache_head *ch; 304 int hash = svc_expkey_hash(new); 305 306 ch = sunrpc_cache_update(cd, &new->h, &old->h, hash); 307 if (ch) 308 return container_of(ch, struct svc_expkey, h); 309 else 310 return NULL; 311} 312 313 314#define EXPORT_HASHBITS 8 315#define EXPORT_HASHMAX (1<< EXPORT_HASHBITS) 316 317static void nfsd4_fslocs_free(struct nfsd4_fs_locations *fsloc) 318{ 319 struct nfsd4_fs_location *locations = fsloc->locations; 320 int i; 321 322 if (!locations) 323 return; 324 325 for (i = 0; i < fsloc->locations_count; i++) { 326 kfree(locations[i].path); 327 kfree(locations[i].hosts); 328 } 329 330 kfree(locations); 331 fsloc->locations = NULL; 332} 333 334static int export_stats_init(struct export_stats *stats) 335{ 336 stats->start_time = ktime_get_seconds(); 337 return nfsd_percpu_counters_init(stats->counter, EXP_STATS_COUNTERS_NUM); 338} 339 340static void export_stats_reset(struct export_stats *stats) 341{ 342 if (stats) 343 nfsd_percpu_counters_reset(stats->counter, 344 EXP_STATS_COUNTERS_NUM); 345} 346 347static void export_stats_destroy(struct export_stats *stats) 348{ 349 if (stats) 350 nfsd_percpu_counters_destroy(stats->counter, 351 EXP_STATS_COUNTERS_NUM); 352} 353 354static void svc_export_put(struct kref *ref) 355{ 356 struct svc_export *exp = container_of(ref, struct svc_export, h.ref); 357 path_put(&exp->ex_path); 358 auth_domain_put(exp->ex_client); 359 nfsd4_fslocs_free(&exp->ex_fslocs); 360 export_stats_destroy(exp->ex_stats); 361 kfree(exp->ex_stats); 362 kfree(exp->ex_uuid); 363 kfree_rcu(exp, ex_rcu); 364} 365 366static int svc_export_upcall(struct cache_detail *cd, struct cache_head *h) 367{ 368 return sunrpc_cache_pipe_upcall(cd, h); 369} 370 371static void svc_export_request(struct cache_detail *cd, 372 struct cache_head *h, 373 char **bpp, int *blen) 374{ 375 /* client path */ 376 struct svc_export *exp = container_of(h, struct svc_export, h); 377 char *pth; 378 379 qword_add(bpp, blen, exp->ex_client->name); 380 pth = d_path(&exp->ex_path, *bpp, *blen); 381 if (IS_ERR(pth)) { 382 /* is this correct? */ 383 (*bpp)[0] = '\n'; 384 return; 385 } 386 qword_add(bpp, blen, pth); 387 (*bpp)[-1] = '\n'; 388} 389 390static struct svc_export *svc_export_update(struct svc_export *new, 391 struct svc_export *old); 392static struct svc_export *svc_export_lookup(struct svc_export *); 393 394static int check_export(struct path *path, int *flags, unsigned char *uuid) 395{ 396 struct inode *inode = d_inode(path->dentry); 397 398 /* 399 * We currently export only dirs, regular files, and (for v4 400 * pseudoroot) symlinks. 401 */ 402 if (!S_ISDIR(inode->i_mode) && 403 !S_ISLNK(inode->i_mode) && 404 !S_ISREG(inode->i_mode)) 405 return -ENOTDIR; 406 407 /* 408 * Mountd should never pass down a writeable V4ROOT export, but, 409 * just to make sure: 410 */ 411 if (*flags & NFSEXP_V4ROOT) 412 *flags |= NFSEXP_READONLY; 413 414 /* There are two requirements on a filesystem to be exportable. 415 * 1: We must be able to identify the filesystem from a number. 416 * either a device number (so FS_REQUIRES_DEV needed) 417 * or an FSID number (so NFSEXP_FSID or ->uuid is needed). 418 * 2: We must be able to find an inode from a filehandle. 419 * This means that s_export_op must be set. 420 * 3: We must not currently be on an idmapped mount. 421 */ 422 if (!(inode->i_sb->s_type->fs_flags & FS_REQUIRES_DEV) && 423 !(*flags & NFSEXP_FSID) && 424 uuid == NULL) { 425 dprintk("exp_export: export of non-dev fs without fsid\n"); 426 return -EINVAL; 427 } 428 429 if (!exportfs_can_decode_fh(inode->i_sb->s_export_op)) { 430 dprintk("exp_export: export of invalid fs type.\n"); 431 return -EINVAL; 432 } 433 434 if (is_idmapped_mnt(path->mnt)) { 435 dprintk("exp_export: export of idmapped mounts not yet supported.\n"); 436 return -EINVAL; 437 } 438 439 if (inode->i_sb->s_export_op->flags & EXPORT_OP_NOSUBTREECHK && 440 !(*flags & NFSEXP_NOSUBTREECHECK)) { 441 dprintk("%s: %s does not support subtree checking!\n", 442 __func__, inode->i_sb->s_type->name); 443 return -EINVAL; 444 } 445 return 0; 446} 447 448#ifdef CONFIG_NFSD_V4 449 450static int 451fsloc_parse(char **mesg, char *buf, struct nfsd4_fs_locations *fsloc) 452{ 453 int len; 454 int migrated, i, err; 455 456 /* more than one fsloc */ 457 if (fsloc->locations) 458 return -EINVAL; 459 460 /* listsize */ 461 err = get_uint(mesg, &fsloc->locations_count); 462 if (err) 463 return err; 464 if (fsloc->locations_count > MAX_FS_LOCATIONS) 465 return -EINVAL; 466 if (fsloc->locations_count == 0) 467 return 0; 468 469 fsloc->locations = kcalloc(fsloc->locations_count, 470 sizeof(struct nfsd4_fs_location), 471 GFP_KERNEL); 472 if (!fsloc->locations) 473 return -ENOMEM; 474 for (i=0; i < fsloc->locations_count; i++) { 475 /* colon separated host list */ 476 err = -EINVAL; 477 len = qword_get(mesg, buf, PAGE_SIZE); 478 if (len <= 0) 479 goto out_free_all; 480 err = -ENOMEM; 481 fsloc->locations[i].hosts = kstrdup(buf, GFP_KERNEL); 482 if (!fsloc->locations[i].hosts) 483 goto out_free_all; 484 err = -EINVAL; 485 /* slash separated path component list */ 486 len = qword_get(mesg, buf, PAGE_SIZE); 487 if (len <= 0) 488 goto out_free_all; 489 err = -ENOMEM; 490 fsloc->locations[i].path = kstrdup(buf, GFP_KERNEL); 491 if (!fsloc->locations[i].path) 492 goto out_free_all; 493 } 494 /* migrated */ 495 err = get_int(mesg, &migrated); 496 if (err) 497 goto out_free_all; 498 err = -EINVAL; 499 if (migrated < 0 || migrated > 1) 500 goto out_free_all; 501 fsloc->migrated = migrated; 502 return 0; 503out_free_all: 504 nfsd4_fslocs_free(fsloc); 505 return err; 506} 507 508static int secinfo_parse(char **mesg, char *buf, struct svc_export *exp) 509{ 510 struct exp_flavor_info *f; 511 u32 listsize; 512 int err; 513 514 /* more than one secinfo */ 515 if (exp->ex_nflavors) 516 return -EINVAL; 517 518 err = get_uint(mesg, &listsize); 519 if (err) 520 return err; 521 if (listsize > MAX_SECINFO_LIST) 522 return -EINVAL; 523 524 for (f = exp->ex_flavors; f < exp->ex_flavors + listsize; f++) { 525 err = get_uint(mesg, &f->pseudoflavor); 526 if (err) 527 return err; 528 /* 529 * XXX: It would be nice to also check whether this 530 * pseudoflavor is supported, so we can discover the 531 * problem at export time instead of when a client fails 532 * to authenticate. 533 */ 534 err = get_uint(mesg, &f->flags); 535 if (err) 536 return err; 537 /* Only some flags are allowed to differ between flavors: */ 538 if (~NFSEXP_SECINFO_FLAGS & (f->flags ^ exp->ex_flags)) 539 return -EINVAL; 540 } 541 exp->ex_nflavors = listsize; 542 return 0; 543} 544 545#else /* CONFIG_NFSD_V4 */ 546static inline int 547fsloc_parse(char **mesg, char *buf, struct nfsd4_fs_locations *fsloc){return 0;} 548static inline int 549secinfo_parse(char **mesg, char *buf, struct svc_export *exp) { return 0; } 550#endif 551 552static int xprtsec_parse(char **mesg, char *buf, struct svc_export *exp) 553{ 554 unsigned int i, mode, listsize; 555 int err; 556 557 err = get_uint(mesg, &listsize); 558 if (err) 559 return err; 560 if (listsize > NFSEXP_XPRTSEC_NUM) 561 return -EINVAL; 562 563 exp->ex_xprtsec_modes = 0; 564 for (i = 0; i < listsize; i++) { 565 err = get_uint(mesg, &mode); 566 if (err) 567 return err; 568 if (mode > NFSEXP_XPRTSEC_MTLS) 569 return -EINVAL; 570 exp->ex_xprtsec_modes |= mode; 571 } 572 return 0; 573} 574 575static inline int 576nfsd_uuid_parse(char **mesg, char *buf, unsigned char **puuid) 577{ 578 int len; 579 580 /* more than one uuid */ 581 if (*puuid) 582 return -EINVAL; 583 584 /* expect a 16 byte uuid encoded as \xXXXX... */ 585 len = qword_get(mesg, buf, PAGE_SIZE); 586 if (len != EX_UUID_LEN) 587 return -EINVAL; 588 589 *puuid = kmemdup(buf, EX_UUID_LEN, GFP_KERNEL); 590 if (*puuid == NULL) 591 return -ENOMEM; 592 593 return 0; 594} 595 596static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen) 597{ 598 /* client path expiry [flags anonuid anongid fsid] */ 599 char *buf; 600 int err; 601 struct auth_domain *dom = NULL; 602 struct svc_export exp = {}, *expp; 603 int an_int; 604 605 if (mesg[mlen-1] != '\n') 606 return -EINVAL; 607 mesg[mlen-1] = 0; 608 609 buf = kmalloc(PAGE_SIZE, GFP_KERNEL); 610 if (!buf) 611 return -ENOMEM; 612 613 /* client */ 614 err = -EINVAL; 615 if (qword_get(&mesg, buf, PAGE_SIZE) <= 0) 616 goto out; 617 618 err = -ENOENT; 619 dom = auth_domain_find(buf); 620 if (!dom) 621 goto out; 622 623 /* path */ 624 err = -EINVAL; 625 if (qword_get(&mesg, buf, PAGE_SIZE) <= 0) 626 goto out1; 627 628 err = kern_path(buf, 0, &exp.ex_path); 629 if (err) 630 goto out1; 631 632 exp.ex_client = dom; 633 exp.cd = cd; 634 exp.ex_devid_map = NULL; 635 exp.ex_xprtsec_modes = NFSEXP_XPRTSEC_ALL; 636 637 /* expiry */ 638 err = get_expiry(&mesg, &exp.h.expiry_time); 639 if (err) 640 goto out3; 641 642 /* flags */ 643 err = get_int(&mesg, &an_int); 644 if (err == -ENOENT) { 645 err = 0; 646 set_bit(CACHE_NEGATIVE, &exp.h.flags); 647 } else { 648 if (err || an_int < 0) 649 goto out3; 650 exp.ex_flags= an_int; 651 652 /* anon uid */ 653 err = get_int(&mesg, &an_int); 654 if (err) 655 goto out3; 656 exp.ex_anon_uid= make_kuid(current_user_ns(), an_int); 657 658 /* anon gid */ 659 err = get_int(&mesg, &an_int); 660 if (err) 661 goto out3; 662 exp.ex_anon_gid= make_kgid(current_user_ns(), an_int); 663 664 /* fsid */ 665 err = get_int(&mesg, &an_int); 666 if (err) 667 goto out3; 668 exp.ex_fsid = an_int; 669 670 while (qword_get(&mesg, buf, PAGE_SIZE) > 0) { 671 if (strcmp(buf, "fsloc") == 0) 672 err = fsloc_parse(&mesg, buf, &exp.ex_fslocs); 673 else if (strcmp(buf, "uuid") == 0) 674 err = nfsd_uuid_parse(&mesg, buf, &exp.ex_uuid); 675 else if (strcmp(buf, "secinfo") == 0) 676 err = secinfo_parse(&mesg, buf, &exp); 677 else if (strcmp(buf, "xprtsec") == 0) 678 err = xprtsec_parse(&mesg, buf, &exp); 679 else 680 /* quietly ignore unknown words and anything 681 * following. Newer user-space can try to set 682 * new values, then see what the result was. 683 */ 684 break; 685 if (err) 686 goto out4; 687 } 688 689 err = check_export(&exp.ex_path, &exp.ex_flags, exp.ex_uuid); 690 if (err) 691 goto out4; 692 693 /* 694 * No point caching this if it would immediately expire. 695 * Also, this protects exportfs's dummy export from the 696 * anon_uid/anon_gid checks: 697 */ 698 if (exp.h.expiry_time < seconds_since_boot()) 699 goto out4; 700 /* 701 * For some reason exportfs has been passing down an 702 * invalid (-1) uid & gid on the "dummy" export which it 703 * uses to test export support. To make sure exportfs 704 * sees errors from check_export we therefore need to 705 * delay these checks till after check_export: 706 */ 707 err = -EINVAL; 708 if (!uid_valid(exp.ex_anon_uid)) 709 goto out4; 710 if (!gid_valid(exp.ex_anon_gid)) 711 goto out4; 712 err = 0; 713 714 nfsd4_setup_layout_type(&exp); 715 } 716 717 expp = svc_export_lookup(&exp); 718 if (!expp) { 719 err = -ENOMEM; 720 goto out4; 721 } 722 expp = svc_export_update(&exp, expp); 723 if (expp) { 724 trace_nfsd_export_update(expp); 725 cache_flush(); 726 exp_put(expp); 727 } else 728 err = -ENOMEM; 729out4: 730 nfsd4_fslocs_free(&exp.ex_fslocs); 731 kfree(exp.ex_uuid); 732out3: 733 path_put(&exp.ex_path); 734out1: 735 auth_domain_put(dom); 736out: 737 kfree(buf); 738 return err; 739} 740 741static void exp_flags(struct seq_file *m, int flag, int fsid, 742 kuid_t anonu, kgid_t anong, struct nfsd4_fs_locations *fslocs); 743static void show_secinfo(struct seq_file *m, struct svc_export *exp); 744 745static int is_export_stats_file(struct seq_file *m) 746{ 747 /* 748 * The export_stats file uses the same ops as the exports file. 749 * We use the file's name to determine the reported info per export. 750 * There is no rename in nsfdfs, so d_name.name is stable. 751 */ 752 return !strcmp(m->file->f_path.dentry->d_name.name, "export_stats"); 753} 754 755static int svc_export_show(struct seq_file *m, 756 struct cache_detail *cd, 757 struct cache_head *h) 758{ 759 struct svc_export *exp; 760 bool export_stats = is_export_stats_file(m); 761 762 if (h == NULL) { 763 if (export_stats) 764 seq_puts(m, "#path domain start-time\n#\tstats\n"); 765 else 766 seq_puts(m, "#path domain(flags)\n"); 767 return 0; 768 } 769 exp = container_of(h, struct svc_export, h); 770 seq_path(m, &exp->ex_path, " \t\n\\"); 771 seq_putc(m, '\t'); 772 seq_escape(m, exp->ex_client->name, " \t\n\\"); 773 if (export_stats) { 774 struct percpu_counter *counter = exp->ex_stats->counter; 775 776 seq_printf(m, "\t%lld\n", exp->ex_stats->start_time); 777 seq_printf(m, "\tfh_stale: %lld\n", 778 percpu_counter_sum_positive(&counter[EXP_STATS_FH_STALE])); 779 seq_printf(m, "\tio_read: %lld\n", 780 percpu_counter_sum_positive(&counter[EXP_STATS_IO_READ])); 781 seq_printf(m, "\tio_write: %lld\n", 782 percpu_counter_sum_positive(&counter[EXP_STATS_IO_WRITE])); 783 seq_putc(m, '\n'); 784 return 0; 785 } 786 seq_putc(m, '('); 787 if (test_bit(CACHE_VALID, &h->flags) && 788 !test_bit(CACHE_NEGATIVE, &h->flags)) { 789 exp_flags(m, exp->ex_flags, exp->ex_fsid, 790 exp->ex_anon_uid, exp->ex_anon_gid, &exp->ex_fslocs); 791 if (exp->ex_uuid) { 792 int i; 793 seq_puts(m, ",uuid="); 794 for (i = 0; i < EX_UUID_LEN; i++) { 795 if ((i&3) == 0 && i) 796 seq_putc(m, ':'); 797 seq_printf(m, "%02x", exp->ex_uuid[i]); 798 } 799 } 800 show_secinfo(m, exp); 801 } 802 seq_puts(m, ")\n"); 803 return 0; 804} 805static int svc_export_match(struct cache_head *a, struct cache_head *b) 806{ 807 struct svc_export *orig = container_of(a, struct svc_export, h); 808 struct svc_export *new = container_of(b, struct svc_export, h); 809 return orig->ex_client == new->ex_client && 810 path_equal(&orig->ex_path, &new->ex_path); 811} 812 813static void svc_export_init(struct cache_head *cnew, struct cache_head *citem) 814{ 815 struct svc_export *new = container_of(cnew, struct svc_export, h); 816 struct svc_export *item = container_of(citem, struct svc_export, h); 817 818 kref_get(&item->ex_client->ref); 819 new->ex_client = item->ex_client; 820 new->ex_path = item->ex_path; 821 path_get(&item->ex_path); 822 new->ex_fslocs.locations = NULL; 823 new->ex_fslocs.locations_count = 0; 824 new->ex_fslocs.migrated = 0; 825 new->ex_layout_types = 0; 826 new->ex_uuid = NULL; 827 new->cd = item->cd; 828 export_stats_reset(new->ex_stats); 829} 830 831static void export_update(struct cache_head *cnew, struct cache_head *citem) 832{ 833 struct svc_export *new = container_of(cnew, struct svc_export, h); 834 struct svc_export *item = container_of(citem, struct svc_export, h); 835 int i; 836 837 new->ex_flags = item->ex_flags; 838 new->ex_anon_uid = item->ex_anon_uid; 839 new->ex_anon_gid = item->ex_anon_gid; 840 new->ex_fsid = item->ex_fsid; 841 new->ex_devid_map = item->ex_devid_map; 842 item->ex_devid_map = NULL; 843 new->ex_uuid = item->ex_uuid; 844 item->ex_uuid = NULL; 845 new->ex_fslocs.locations = item->ex_fslocs.locations; 846 item->ex_fslocs.locations = NULL; 847 new->ex_fslocs.locations_count = item->ex_fslocs.locations_count; 848 item->ex_fslocs.locations_count = 0; 849 new->ex_fslocs.migrated = item->ex_fslocs.migrated; 850 item->ex_fslocs.migrated = 0; 851 new->ex_layout_types = item->ex_layout_types; 852 new->ex_nflavors = item->ex_nflavors; 853 for (i = 0; i < MAX_SECINFO_LIST; i++) { 854 new->ex_flavors[i] = item->ex_flavors[i]; 855 } 856 new->ex_xprtsec_modes = item->ex_xprtsec_modes; 857} 858 859static struct cache_head *svc_export_alloc(void) 860{ 861 struct svc_export *i = kmalloc(sizeof(*i), GFP_KERNEL); 862 if (!i) 863 return NULL; 864 865 i->ex_stats = kmalloc(sizeof(*(i->ex_stats)), GFP_KERNEL); 866 if (!i->ex_stats) { 867 kfree(i); 868 return NULL; 869 } 870 871 if (export_stats_init(i->ex_stats)) { 872 kfree(i->ex_stats); 873 kfree(i); 874 return NULL; 875 } 876 877 return &i->h; 878} 879 880static const struct cache_detail svc_export_cache_template = { 881 .owner = THIS_MODULE, 882 .hash_size = EXPORT_HASHMAX, 883 .name = "nfsd.export", 884 .cache_put = svc_export_put, 885 .cache_upcall = svc_export_upcall, 886 .cache_request = svc_export_request, 887 .cache_parse = svc_export_parse, 888 .cache_show = svc_export_show, 889 .match = svc_export_match, 890 .init = svc_export_init, 891 .update = export_update, 892 .alloc = svc_export_alloc, 893}; 894 895static int 896svc_export_hash(struct svc_export *exp) 897{ 898 int hash; 899 900 hash = hash_ptr(exp->ex_client, EXPORT_HASHBITS); 901 hash ^= hash_ptr(exp->ex_path.dentry, EXPORT_HASHBITS); 902 hash ^= hash_ptr(exp->ex_path.mnt, EXPORT_HASHBITS); 903 return hash; 904} 905 906static struct svc_export * 907svc_export_lookup(struct svc_export *exp) 908{ 909 struct cache_head *ch; 910 int hash = svc_export_hash(exp); 911 912 ch = sunrpc_cache_lookup_rcu(exp->cd, &exp->h, hash); 913 if (ch) 914 return container_of(ch, struct svc_export, h); 915 else 916 return NULL; 917} 918 919static struct svc_export * 920svc_export_update(struct svc_export *new, struct svc_export *old) 921{ 922 struct cache_head *ch; 923 int hash = svc_export_hash(old); 924 925 ch = sunrpc_cache_update(old->cd, &new->h, &old->h, hash); 926 if (ch) 927 return container_of(ch, struct svc_export, h); 928 else 929 return NULL; 930} 931 932 933static struct svc_expkey * 934exp_find_key(struct cache_detail *cd, struct auth_domain *clp, int fsid_type, 935 u32 *fsidv, struct cache_req *reqp) 936{ 937 struct svc_expkey key, *ek; 938 int err; 939 940 if (!clp) 941 return ERR_PTR(-ENOENT); 942 943 key.ek_client = clp; 944 key.ek_fsidtype = fsid_type; 945 memcpy(key.ek_fsid, fsidv, key_len(fsid_type)); 946 947 ek = svc_expkey_lookup(cd, &key); 948 if (ek == NULL) 949 return ERR_PTR(-ENOMEM); 950 err = cache_check(cd, &ek->h, reqp); 951 if (err) { 952 trace_nfsd_exp_find_key(&key, err); 953 return ERR_PTR(err); 954 } 955 return ek; 956} 957 958static struct svc_export * 959exp_get_by_name(struct cache_detail *cd, struct auth_domain *clp, 960 const struct path *path, struct cache_req *reqp) 961{ 962 struct svc_export *exp, key; 963 int err; 964 965 if (!clp) 966 return ERR_PTR(-ENOENT); 967 968 key.ex_client = clp; 969 key.ex_path = *path; 970 key.cd = cd; 971 972 exp = svc_export_lookup(&key); 973 if (exp == NULL) 974 return ERR_PTR(-ENOMEM); 975 err = cache_check(cd, &exp->h, reqp); 976 if (err) { 977 trace_nfsd_exp_get_by_name(&key, err); 978 return ERR_PTR(err); 979 } 980 return exp; 981} 982 983/* 984 * Find the export entry for a given dentry. 985 */ 986static struct svc_export * 987exp_parent(struct cache_detail *cd, struct auth_domain *clp, struct path *path) 988{ 989 struct dentry *saved = dget(path->dentry); 990 struct svc_export *exp = exp_get_by_name(cd, clp, path, NULL); 991 992 while (PTR_ERR(exp) == -ENOENT && !IS_ROOT(path->dentry)) { 993 struct dentry *parent = dget_parent(path->dentry); 994 dput(path->dentry); 995 path->dentry = parent; 996 exp = exp_get_by_name(cd, clp, path, NULL); 997 } 998 dput(path->dentry); 999 path->dentry = saved; 1000 return exp; 1001} 1002 1003 1004 1005/* 1006 * Obtain the root fh on behalf of a client. 1007 * This could be done in user space, but I feel that it adds some safety 1008 * since its harder to fool a kernel module than a user space program. 1009 */ 1010int 1011exp_rootfh(struct net *net, struct auth_domain *clp, char *name, 1012 struct knfsd_fh *f, int maxsize) 1013{ 1014 struct svc_export *exp; 1015 struct path path; 1016 struct inode *inode; 1017 struct svc_fh fh; 1018 int err; 1019 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1020 struct cache_detail *cd = nn->svc_export_cache; 1021 1022 err = -EPERM; 1023 /* NB: we probably ought to check that it's NUL-terminated */ 1024 if (kern_path(name, 0, &path)) { 1025 printk("nfsd: exp_rootfh path not found %s", name); 1026 return err; 1027 } 1028 inode = d_inode(path.dentry); 1029 1030 dprintk("nfsd: exp_rootfh(%s [%p] %s:%s/%ld)\n", 1031 name, path.dentry, clp->name, 1032 inode->i_sb->s_id, inode->i_ino); 1033 exp = exp_parent(cd, clp, &path); 1034 if (IS_ERR(exp)) { 1035 err = PTR_ERR(exp); 1036 goto out; 1037 } 1038 1039 /* 1040 * fh must be initialized before calling fh_compose 1041 */ 1042 fh_init(&fh, maxsize); 1043 if (fh_compose(&fh, exp, path.dentry, NULL)) 1044 err = -EINVAL; 1045 else 1046 err = 0; 1047 memcpy(f, &fh.fh_handle, sizeof(struct knfsd_fh)); 1048 fh_put(&fh); 1049 exp_put(exp); 1050out: 1051 path_put(&path); 1052 return err; 1053} 1054 1055static struct svc_export *exp_find(struct cache_detail *cd, 1056 struct auth_domain *clp, int fsid_type, 1057 u32 *fsidv, struct cache_req *reqp) 1058{ 1059 struct svc_export *exp; 1060 struct nfsd_net *nn = net_generic(cd->net, nfsd_net_id); 1061 struct svc_expkey *ek = exp_find_key(nn->svc_expkey_cache, clp, fsid_type, fsidv, reqp); 1062 if (IS_ERR(ek)) 1063 return ERR_CAST(ek); 1064 1065 exp = exp_get_by_name(cd, clp, &ek->ek_path, reqp); 1066 cache_put(&ek->h, nn->svc_expkey_cache); 1067 1068 if (IS_ERR(exp)) 1069 return ERR_CAST(exp); 1070 return exp; 1071} 1072 1073__be32 check_nfsd_access(struct svc_export *exp, struct svc_rqst *rqstp) 1074{ 1075 struct exp_flavor_info *f, *end = exp->ex_flavors + exp->ex_nflavors; 1076 struct svc_xprt *xprt = rqstp->rq_xprt; 1077 1078 if (exp->ex_xprtsec_modes & NFSEXP_XPRTSEC_NONE) { 1079 if (!test_bit(XPT_TLS_SESSION, &xprt->xpt_flags)) 1080 goto ok; 1081 } 1082 if (exp->ex_xprtsec_modes & NFSEXP_XPRTSEC_TLS) { 1083 if (test_bit(XPT_TLS_SESSION, &xprt->xpt_flags) && 1084 !test_bit(XPT_PEER_AUTH, &xprt->xpt_flags)) 1085 goto ok; 1086 } 1087 if (exp->ex_xprtsec_modes & NFSEXP_XPRTSEC_MTLS) { 1088 if (test_bit(XPT_TLS_SESSION, &xprt->xpt_flags) && 1089 test_bit(XPT_PEER_AUTH, &xprt->xpt_flags)) 1090 goto ok; 1091 } 1092 goto denied; 1093 1094ok: 1095 /* legacy gss-only clients are always OK: */ 1096 if (exp->ex_client == rqstp->rq_gssclient) 1097 return 0; 1098 /* ip-address based client; check sec= export option: */ 1099 for (f = exp->ex_flavors; f < end; f++) { 1100 if (f->pseudoflavor == rqstp->rq_cred.cr_flavor) 1101 return 0; 1102 } 1103 /* defaults in absence of sec= options: */ 1104 if (exp->ex_nflavors == 0) { 1105 if (rqstp->rq_cred.cr_flavor == RPC_AUTH_NULL || 1106 rqstp->rq_cred.cr_flavor == RPC_AUTH_UNIX) 1107 return 0; 1108 } 1109 1110 /* If the compound op contains a spo_must_allowed op, 1111 * it will be sent with integrity/protection which 1112 * will have to be expressly allowed on mounts that 1113 * don't support it 1114 */ 1115 1116 if (nfsd4_spo_must_allow(rqstp)) 1117 return 0; 1118 1119denied: 1120 return rqstp->rq_vers < 4 ? nfserr_acces : nfserr_wrongsec; 1121} 1122 1123/* 1124 * Uses rq_client and rq_gssclient to find an export; uses rq_client (an 1125 * auth_unix client) if it's available and has secinfo information; 1126 * otherwise, will try to use rq_gssclient. 1127 * 1128 * Called from functions that handle requests; functions that do work on 1129 * behalf of mountd are passed a single client name to use, and should 1130 * use exp_get_by_name() or exp_find(). 1131 */ 1132struct svc_export * 1133rqst_exp_get_by_name(struct svc_rqst *rqstp, struct path *path) 1134{ 1135 struct svc_export *gssexp, *exp = ERR_PTR(-ENOENT); 1136 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 1137 struct cache_detail *cd = nn->svc_export_cache; 1138 1139 if (rqstp->rq_client == NULL) 1140 goto gss; 1141 1142 /* First try the auth_unix client: */ 1143 exp = exp_get_by_name(cd, rqstp->rq_client, path, &rqstp->rq_chandle); 1144 if (PTR_ERR(exp) == -ENOENT) 1145 goto gss; 1146 if (IS_ERR(exp)) 1147 return exp; 1148 /* If it has secinfo, assume there are no gss/... clients */ 1149 if (exp->ex_nflavors > 0) 1150 return exp; 1151gss: 1152 /* Otherwise, try falling back on gss client */ 1153 if (rqstp->rq_gssclient == NULL) 1154 return exp; 1155 gssexp = exp_get_by_name(cd, rqstp->rq_gssclient, path, &rqstp->rq_chandle); 1156 if (PTR_ERR(gssexp) == -ENOENT) 1157 return exp; 1158 if (!IS_ERR(exp)) 1159 exp_put(exp); 1160 return gssexp; 1161} 1162 1163struct svc_export * 1164rqst_exp_find(struct svc_rqst *rqstp, int fsid_type, u32 *fsidv) 1165{ 1166 struct svc_export *gssexp, *exp = ERR_PTR(-ENOENT); 1167 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 1168 struct cache_detail *cd = nn->svc_export_cache; 1169 1170 if (rqstp->rq_client == NULL) 1171 goto gss; 1172 1173 /* First try the auth_unix client: */ 1174 exp = exp_find(cd, rqstp->rq_client, fsid_type, 1175 fsidv, &rqstp->rq_chandle); 1176 if (PTR_ERR(exp) == -ENOENT) 1177 goto gss; 1178 if (IS_ERR(exp)) 1179 return exp; 1180 /* If it has secinfo, assume there are no gss/... clients */ 1181 if (exp->ex_nflavors > 0) 1182 return exp; 1183gss: 1184 /* Otherwise, try falling back on gss client */ 1185 if (rqstp->rq_gssclient == NULL) 1186 return exp; 1187 gssexp = exp_find(cd, rqstp->rq_gssclient, fsid_type, fsidv, 1188 &rqstp->rq_chandle); 1189 if (PTR_ERR(gssexp) == -ENOENT) 1190 return exp; 1191 if (!IS_ERR(exp)) 1192 exp_put(exp); 1193 return gssexp; 1194} 1195 1196struct svc_export * 1197rqst_exp_parent(struct svc_rqst *rqstp, struct path *path) 1198{ 1199 struct dentry *saved = dget(path->dentry); 1200 struct svc_export *exp = rqst_exp_get_by_name(rqstp, path); 1201 1202 while (PTR_ERR(exp) == -ENOENT && !IS_ROOT(path->dentry)) { 1203 struct dentry *parent = dget_parent(path->dentry); 1204 dput(path->dentry); 1205 path->dentry = parent; 1206 exp = rqst_exp_get_by_name(rqstp, path); 1207 } 1208 dput(path->dentry); 1209 path->dentry = saved; 1210 return exp; 1211} 1212 1213struct svc_export *rqst_find_fsidzero_export(struct svc_rqst *rqstp) 1214{ 1215 u32 fsidv[2]; 1216 1217 mk_fsid(FSID_NUM, fsidv, 0, 0, 0, NULL); 1218 1219 return rqst_exp_find(rqstp, FSID_NUM, fsidv); 1220} 1221 1222/* 1223 * Called when we need the filehandle for the root of the pseudofs, 1224 * for a given NFSv4 client. The root is defined to be the 1225 * export point with fsid==0 1226 */ 1227__be32 1228exp_pseudoroot(struct svc_rqst *rqstp, struct svc_fh *fhp) 1229{ 1230 struct svc_export *exp; 1231 __be32 rv; 1232 1233 exp = rqst_find_fsidzero_export(rqstp); 1234 if (IS_ERR(exp)) 1235 return nfserrno(PTR_ERR(exp)); 1236 rv = fh_compose(fhp, exp, exp->ex_path.dentry, NULL); 1237 exp_put(exp); 1238 return rv; 1239} 1240 1241static struct flags { 1242 int flag; 1243 char *name[2]; 1244} expflags[] = { 1245 { NFSEXP_READONLY, {"ro", "rw"}}, 1246 { NFSEXP_INSECURE_PORT, {"insecure", ""}}, 1247 { NFSEXP_ROOTSQUASH, {"root_squash", "no_root_squash"}}, 1248 { NFSEXP_ALLSQUASH, {"all_squash", ""}}, 1249 { NFSEXP_ASYNC, {"async", "sync"}}, 1250 { NFSEXP_GATHERED_WRITES, {"wdelay", "no_wdelay"}}, 1251 { NFSEXP_NOREADDIRPLUS, {"nordirplus", ""}}, 1252 { NFSEXP_NOHIDE, {"nohide", ""}}, 1253 { NFSEXP_CROSSMOUNT, {"crossmnt", ""}}, 1254 { NFSEXP_NOSUBTREECHECK, {"no_subtree_check", ""}}, 1255 { NFSEXP_NOAUTHNLM, {"insecure_locks", ""}}, 1256 { NFSEXP_V4ROOT, {"v4root", ""}}, 1257 { NFSEXP_PNFS, {"pnfs", ""}}, 1258 { NFSEXP_SECURITY_LABEL, {"security_label", ""}}, 1259 { 0, {"", ""}} 1260}; 1261 1262static void show_expflags(struct seq_file *m, int flags, int mask) 1263{ 1264 struct flags *flg; 1265 int state, first = 0; 1266 1267 for (flg = expflags; flg->flag; flg++) { 1268 if (flg->flag & ~mask) 1269 continue; 1270 state = (flg->flag & flags) ? 0 : 1; 1271 if (*flg->name[state]) 1272 seq_printf(m, "%s%s", first++?",":"", flg->name[state]); 1273 } 1274} 1275 1276static void show_secinfo_flags(struct seq_file *m, int flags) 1277{ 1278 seq_printf(m, ","); 1279 show_expflags(m, flags, NFSEXP_SECINFO_FLAGS); 1280} 1281 1282static bool secinfo_flags_equal(int f, int g) 1283{ 1284 f &= NFSEXP_SECINFO_FLAGS; 1285 g &= NFSEXP_SECINFO_FLAGS; 1286 return f == g; 1287} 1288 1289static int show_secinfo_run(struct seq_file *m, struct exp_flavor_info **fp, struct exp_flavor_info *end) 1290{ 1291 int flags; 1292 1293 flags = (*fp)->flags; 1294 seq_printf(m, ",sec=%d", (*fp)->pseudoflavor); 1295 (*fp)++; 1296 while (*fp != end && secinfo_flags_equal(flags, (*fp)->flags)) { 1297 seq_printf(m, ":%d", (*fp)->pseudoflavor); 1298 (*fp)++; 1299 } 1300 return flags; 1301} 1302 1303static void show_secinfo(struct seq_file *m, struct svc_export *exp) 1304{ 1305 struct exp_flavor_info *f; 1306 struct exp_flavor_info *end = exp->ex_flavors + exp->ex_nflavors; 1307 int flags; 1308 1309 if (exp->ex_nflavors == 0) 1310 return; 1311 f = exp->ex_flavors; 1312 flags = show_secinfo_run(m, &f, end); 1313 if (!secinfo_flags_equal(flags, exp->ex_flags)) 1314 show_secinfo_flags(m, flags); 1315 while (f != end) { 1316 flags = show_secinfo_run(m, &f, end); 1317 show_secinfo_flags(m, flags); 1318 } 1319} 1320 1321static void exp_flags(struct seq_file *m, int flag, int fsid, 1322 kuid_t anonu, kgid_t anong, struct nfsd4_fs_locations *fsloc) 1323{ 1324 struct user_namespace *userns = m->file->f_cred->user_ns; 1325 1326 show_expflags(m, flag, NFSEXP_ALLFLAGS); 1327 if (flag & NFSEXP_FSID) 1328 seq_printf(m, ",fsid=%d", fsid); 1329 if (!uid_eq(anonu, make_kuid(userns, (uid_t)-2)) && 1330 !uid_eq(anonu, make_kuid(userns, 0x10000-2))) 1331 seq_printf(m, ",anonuid=%u", from_kuid_munged(userns, anonu)); 1332 if (!gid_eq(anong, make_kgid(userns, (gid_t)-2)) && 1333 !gid_eq(anong, make_kgid(userns, 0x10000-2))) 1334 seq_printf(m, ",anongid=%u", from_kgid_munged(userns, anong)); 1335 if (fsloc && fsloc->locations_count > 0) { 1336 char *loctype = (fsloc->migrated) ? "refer" : "replicas"; 1337 int i; 1338 1339 seq_printf(m, ",%s=", loctype); 1340 seq_escape(m, fsloc->locations[0].path, ",;@ \t\n\\"); 1341 seq_putc(m, '@'); 1342 seq_escape(m, fsloc->locations[0].hosts, ",;@ \t\n\\"); 1343 for (i = 1; i < fsloc->locations_count; i++) { 1344 seq_putc(m, ';'); 1345 seq_escape(m, fsloc->locations[i].path, ",;@ \t\n\\"); 1346 seq_putc(m, '@'); 1347 seq_escape(m, fsloc->locations[i].hosts, ",;@ \t\n\\"); 1348 } 1349 } 1350} 1351 1352static int e_show(struct seq_file *m, void *p) 1353{ 1354 struct cache_head *cp = p; 1355 struct svc_export *exp = container_of(cp, struct svc_export, h); 1356 struct cache_detail *cd = m->private; 1357 bool export_stats = is_export_stats_file(m); 1358 1359 if (p == SEQ_START_TOKEN) { 1360 seq_puts(m, "# Version 1.1\n"); 1361 if (export_stats) 1362 seq_puts(m, "# Path Client Start-time\n#\tStats\n"); 1363 else 1364 seq_puts(m, "# Path Client(Flags) # IPs\n"); 1365 return 0; 1366 } 1367 1368 exp_get(exp); 1369 if (cache_check(cd, &exp->h, NULL)) 1370 return 0; 1371 exp_put(exp); 1372 return svc_export_show(m, cd, cp); 1373} 1374 1375const struct seq_operations nfs_exports_op = { 1376 .start = cache_seq_start_rcu, 1377 .next = cache_seq_next_rcu, 1378 .stop = cache_seq_stop_rcu, 1379 .show = e_show, 1380}; 1381 1382/* 1383 * Initialize the exports module. 1384 */ 1385int 1386nfsd_export_init(struct net *net) 1387{ 1388 int rv; 1389 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1390 1391 dprintk("nfsd: initializing export module (net: %x).\n", net->ns.inum); 1392 1393 nn->svc_export_cache = cache_create_net(&svc_export_cache_template, net); 1394 if (IS_ERR(nn->svc_export_cache)) 1395 return PTR_ERR(nn->svc_export_cache); 1396 rv = cache_register_net(nn->svc_export_cache, net); 1397 if (rv) 1398 goto destroy_export_cache; 1399 1400 nn->svc_expkey_cache = cache_create_net(&svc_expkey_cache_template, net); 1401 if (IS_ERR(nn->svc_expkey_cache)) { 1402 rv = PTR_ERR(nn->svc_expkey_cache); 1403 goto unregister_export_cache; 1404 } 1405 rv = cache_register_net(nn->svc_expkey_cache, net); 1406 if (rv) 1407 goto destroy_expkey_cache; 1408 return 0; 1409 1410destroy_expkey_cache: 1411 cache_destroy_net(nn->svc_expkey_cache, net); 1412unregister_export_cache: 1413 cache_unregister_net(nn->svc_export_cache, net); 1414destroy_export_cache: 1415 cache_destroy_net(nn->svc_export_cache, net); 1416 return rv; 1417} 1418 1419/* 1420 * Flush exports table - called when last nfsd thread is killed 1421 */ 1422void 1423nfsd_export_flush(struct net *net) 1424{ 1425 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1426 1427 cache_purge(nn->svc_expkey_cache); 1428 cache_purge(nn->svc_export_cache); 1429} 1430 1431/* 1432 * Shutdown the exports module. 1433 */ 1434void 1435nfsd_export_shutdown(struct net *net) 1436{ 1437 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1438 1439 dprintk("nfsd: shutting down export module (net: %x).\n", net->ns.inum); 1440 1441 cache_unregister_net(nn->svc_expkey_cache, net); 1442 cache_unregister_net(nn->svc_export_cache, net); 1443 cache_destroy_net(nn->svc_expkey_cache, net); 1444 cache_destroy_net(nn->svc_export_cache, net); 1445 svcauth_unix_purge(net); 1446 1447 dprintk("nfsd: export shutdown complete (net: %x).\n", net->ns.inum); 1448} 1449