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 nfsd_percpu_counters_reset(stats->counter, EXP_STATS_COUNTERS_NUM); 343} 344 345static void export_stats_destroy(struct export_stats *stats) 346{ 347 nfsd_percpu_counters_destroy(stats->counter, EXP_STATS_COUNTERS_NUM); 348} 349 350static void svc_export_put(struct kref *ref) 351{ 352 struct svc_export *exp = container_of(ref, struct svc_export, h.ref); 353 path_put(&exp->ex_path); 354 auth_domain_put(exp->ex_client); 355 nfsd4_fslocs_free(&exp->ex_fslocs); 356 export_stats_destroy(&exp->ex_stats); 357 kfree(exp->ex_uuid); 358 kfree_rcu(exp, ex_rcu); 359} 360 361static int svc_export_upcall(struct cache_detail *cd, struct cache_head *h) 362{ 363 return sunrpc_cache_pipe_upcall(cd, h); 364} 365 366static void svc_export_request(struct cache_detail *cd, 367 struct cache_head *h, 368 char **bpp, int *blen) 369{ 370 /* client path */ 371 struct svc_export *exp = container_of(h, struct svc_export, h); 372 char *pth; 373 374 qword_add(bpp, blen, exp->ex_client->name); 375 pth = d_path(&exp->ex_path, *bpp, *blen); 376 if (IS_ERR(pth)) { 377 /* is this correct? */ 378 (*bpp)[0] = '\n'; 379 return; 380 } 381 qword_add(bpp, blen, pth); 382 (*bpp)[-1] = '\n'; 383} 384 385static struct svc_export *svc_export_update(struct svc_export *new, 386 struct svc_export *old); 387static struct svc_export *svc_export_lookup(struct svc_export *); 388 389static int check_export(struct path *path, int *flags, unsigned char *uuid) 390{ 391 struct inode *inode = d_inode(path->dentry); 392 393 /* 394 * We currently export only dirs, regular files, and (for v4 395 * pseudoroot) symlinks. 396 */ 397 if (!S_ISDIR(inode->i_mode) && 398 !S_ISLNK(inode->i_mode) && 399 !S_ISREG(inode->i_mode)) 400 return -ENOTDIR; 401 402 /* 403 * Mountd should never pass down a writeable V4ROOT export, but, 404 * just to make sure: 405 */ 406 if (*flags & NFSEXP_V4ROOT) 407 *flags |= NFSEXP_READONLY; 408 409 /* There are two requirements on a filesystem to be exportable. 410 * 1: We must be able to identify the filesystem from a number. 411 * either a device number (so FS_REQUIRES_DEV needed) 412 * or an FSID number (so NFSEXP_FSID or ->uuid is needed). 413 * 2: We must be able to find an inode from a filehandle. 414 * This means that s_export_op must be set. 415 * 3: We must not currently be on an idmapped mount. 416 */ 417 if (!(inode->i_sb->s_type->fs_flags & FS_REQUIRES_DEV) && 418 !(*flags & NFSEXP_FSID) && 419 uuid == NULL) { 420 dprintk("exp_export: export of non-dev fs without fsid\n"); 421 return -EINVAL; 422 } 423 424 if (!inode->i_sb->s_export_op || 425 !inode->i_sb->s_export_op->fh_to_dentry) { 426 dprintk("exp_export: export of invalid fs type.\n"); 427 return -EINVAL; 428 } 429 430 if (is_idmapped_mnt(path->mnt)) { 431 dprintk("exp_export: export of idmapped mounts not yet supported.\n"); 432 return -EINVAL; 433 } 434 435 if (inode->i_sb->s_export_op->flags & EXPORT_OP_NOSUBTREECHK && 436 !(*flags & NFSEXP_NOSUBTREECHECK)) { 437 dprintk("%s: %s does not support subtree checking!\n", 438 __func__, inode->i_sb->s_type->name); 439 return -EINVAL; 440 } 441 return 0; 442} 443 444#ifdef CONFIG_NFSD_V4 445 446static int 447fsloc_parse(char **mesg, char *buf, struct nfsd4_fs_locations *fsloc) 448{ 449 int len; 450 int migrated, i, err; 451 452 /* more than one fsloc */ 453 if (fsloc->locations) 454 return -EINVAL; 455 456 /* listsize */ 457 err = get_uint(mesg, &fsloc->locations_count); 458 if (err) 459 return err; 460 if (fsloc->locations_count > MAX_FS_LOCATIONS) 461 return -EINVAL; 462 if (fsloc->locations_count == 0) 463 return 0; 464 465 fsloc->locations = kcalloc(fsloc->locations_count, 466 sizeof(struct nfsd4_fs_location), 467 GFP_KERNEL); 468 if (!fsloc->locations) 469 return -ENOMEM; 470 for (i=0; i < fsloc->locations_count; i++) { 471 /* colon separated host list */ 472 err = -EINVAL; 473 len = qword_get(mesg, buf, PAGE_SIZE); 474 if (len <= 0) 475 goto out_free_all; 476 err = -ENOMEM; 477 fsloc->locations[i].hosts = kstrdup(buf, GFP_KERNEL); 478 if (!fsloc->locations[i].hosts) 479 goto out_free_all; 480 err = -EINVAL; 481 /* slash separated path component list */ 482 len = qword_get(mesg, buf, PAGE_SIZE); 483 if (len <= 0) 484 goto out_free_all; 485 err = -ENOMEM; 486 fsloc->locations[i].path = kstrdup(buf, GFP_KERNEL); 487 if (!fsloc->locations[i].path) 488 goto out_free_all; 489 } 490 /* migrated */ 491 err = get_int(mesg, &migrated); 492 if (err) 493 goto out_free_all; 494 err = -EINVAL; 495 if (migrated < 0 || migrated > 1) 496 goto out_free_all; 497 fsloc->migrated = migrated; 498 return 0; 499out_free_all: 500 nfsd4_fslocs_free(fsloc); 501 return err; 502} 503 504static int secinfo_parse(char **mesg, char *buf, struct svc_export *exp) 505{ 506 struct exp_flavor_info *f; 507 u32 listsize; 508 int err; 509 510 /* more than one secinfo */ 511 if (exp->ex_nflavors) 512 return -EINVAL; 513 514 err = get_uint(mesg, &listsize); 515 if (err) 516 return err; 517 if (listsize > MAX_SECINFO_LIST) 518 return -EINVAL; 519 520 for (f = exp->ex_flavors; f < exp->ex_flavors + listsize; f++) { 521 err = get_uint(mesg, &f->pseudoflavor); 522 if (err) 523 return err; 524 /* 525 * XXX: It would be nice to also check whether this 526 * pseudoflavor is supported, so we can discover the 527 * problem at export time instead of when a client fails 528 * to authenticate. 529 */ 530 err = get_uint(mesg, &f->flags); 531 if (err) 532 return err; 533 /* Only some flags are allowed to differ between flavors: */ 534 if (~NFSEXP_SECINFO_FLAGS & (f->flags ^ exp->ex_flags)) 535 return -EINVAL; 536 } 537 exp->ex_nflavors = listsize; 538 return 0; 539} 540 541#else /* CONFIG_NFSD_V4 */ 542static inline int 543fsloc_parse(char **mesg, char *buf, struct nfsd4_fs_locations *fsloc){return 0;} 544static inline int 545secinfo_parse(char **mesg, char *buf, struct svc_export *exp) { return 0; } 546#endif 547 548static int xprtsec_parse(char **mesg, char *buf, struct svc_export *exp) 549{ 550 unsigned int i, mode, listsize; 551 int err; 552 553 err = get_uint(mesg, &listsize); 554 if (err) 555 return err; 556 if (listsize > NFSEXP_XPRTSEC_NUM) 557 return -EINVAL; 558 559 exp->ex_xprtsec_modes = 0; 560 for (i = 0; i < listsize; i++) { 561 err = get_uint(mesg, &mode); 562 if (err) 563 return err; 564 if (mode > NFSEXP_XPRTSEC_MTLS) 565 return -EINVAL; 566 exp->ex_xprtsec_modes |= mode; 567 } 568 return 0; 569} 570 571static inline int 572nfsd_uuid_parse(char **mesg, char *buf, unsigned char **puuid) 573{ 574 int len; 575 576 /* more than one uuid */ 577 if (*puuid) 578 return -EINVAL; 579 580 /* expect a 16 byte uuid encoded as \xXXXX... */ 581 len = qword_get(mesg, buf, PAGE_SIZE); 582 if (len != EX_UUID_LEN) 583 return -EINVAL; 584 585 *puuid = kmemdup(buf, EX_UUID_LEN, GFP_KERNEL); 586 if (*puuid == NULL) 587 return -ENOMEM; 588 589 return 0; 590} 591 592static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen) 593{ 594 /* client path expiry [flags anonuid anongid fsid] */ 595 char *buf; 596 int err; 597 struct auth_domain *dom = NULL; 598 struct svc_export exp = {}, *expp; 599 int an_int; 600 601 if (mesg[mlen-1] != '\n') 602 return -EINVAL; 603 mesg[mlen-1] = 0; 604 605 buf = kmalloc(PAGE_SIZE, GFP_KERNEL); 606 if (!buf) 607 return -ENOMEM; 608 609 /* client */ 610 err = -EINVAL; 611 if (qword_get(&mesg, buf, PAGE_SIZE) <= 0) 612 goto out; 613 614 err = -ENOENT; 615 dom = auth_domain_find(buf); 616 if (!dom) 617 goto out; 618 619 /* path */ 620 err = -EINVAL; 621 if (qword_get(&mesg, buf, PAGE_SIZE) <= 0) 622 goto out1; 623 624 err = kern_path(buf, 0, &exp.ex_path); 625 if (err) 626 goto out1; 627 628 exp.ex_client = dom; 629 exp.cd = cd; 630 exp.ex_devid_map = NULL; 631 exp.ex_xprtsec_modes = NFSEXP_XPRTSEC_ALL; 632 633 /* expiry */ 634 err = get_expiry(&mesg, &exp.h.expiry_time); 635 if (err) 636 goto out3; 637 638 /* flags */ 639 err = get_int(&mesg, &an_int); 640 if (err == -ENOENT) { 641 err = 0; 642 set_bit(CACHE_NEGATIVE, &exp.h.flags); 643 } else { 644 if (err || an_int < 0) 645 goto out3; 646 exp.ex_flags= an_int; 647 648 /* anon uid */ 649 err = get_int(&mesg, &an_int); 650 if (err) 651 goto out3; 652 exp.ex_anon_uid= make_kuid(current_user_ns(), an_int); 653 654 /* anon gid */ 655 err = get_int(&mesg, &an_int); 656 if (err) 657 goto out3; 658 exp.ex_anon_gid= make_kgid(current_user_ns(), an_int); 659 660 /* fsid */ 661 err = get_int(&mesg, &an_int); 662 if (err) 663 goto out3; 664 exp.ex_fsid = an_int; 665 666 while (qword_get(&mesg, buf, PAGE_SIZE) > 0) { 667 if (strcmp(buf, "fsloc") == 0) 668 err = fsloc_parse(&mesg, buf, &exp.ex_fslocs); 669 else if (strcmp(buf, "uuid") == 0) 670 err = nfsd_uuid_parse(&mesg, buf, &exp.ex_uuid); 671 else if (strcmp(buf, "secinfo") == 0) 672 err = secinfo_parse(&mesg, buf, &exp); 673 else if (strcmp(buf, "xprtsec") == 0) 674 err = xprtsec_parse(&mesg, buf, &exp); 675 else 676 /* quietly ignore unknown words and anything 677 * following. Newer user-space can try to set 678 * new values, then see what the result was. 679 */ 680 break; 681 if (err) 682 goto out4; 683 } 684 685 err = check_export(&exp.ex_path, &exp.ex_flags, exp.ex_uuid); 686 if (err) 687 goto out4; 688 689 /* 690 * No point caching this if it would immediately expire. 691 * Also, this protects exportfs's dummy export from the 692 * anon_uid/anon_gid checks: 693 */ 694 if (exp.h.expiry_time < seconds_since_boot()) 695 goto out4; 696 /* 697 * For some reason exportfs has been passing down an 698 * invalid (-1) uid & gid on the "dummy" export which it 699 * uses to test export support. To make sure exportfs 700 * sees errors from check_export we therefore need to 701 * delay these checks till after check_export: 702 */ 703 err = -EINVAL; 704 if (!uid_valid(exp.ex_anon_uid)) 705 goto out4; 706 if (!gid_valid(exp.ex_anon_gid)) 707 goto out4; 708 err = 0; 709 710 nfsd4_setup_layout_type(&exp); 711 } 712 713 expp = svc_export_lookup(&exp); 714 if (!expp) { 715 err = -ENOMEM; 716 goto out4; 717 } 718 expp = svc_export_update(&exp, expp); 719 if (expp) { 720 trace_nfsd_export_update(expp); 721 cache_flush(); 722 exp_put(expp); 723 } else 724 err = -ENOMEM; 725out4: 726 nfsd4_fslocs_free(&exp.ex_fslocs); 727 kfree(exp.ex_uuid); 728out3: 729 path_put(&exp.ex_path); 730out1: 731 auth_domain_put(dom); 732out: 733 kfree(buf); 734 return err; 735} 736 737static void exp_flags(struct seq_file *m, int flag, int fsid, 738 kuid_t anonu, kgid_t anong, struct nfsd4_fs_locations *fslocs); 739static void show_secinfo(struct seq_file *m, struct svc_export *exp); 740 741static int is_export_stats_file(struct seq_file *m) 742{ 743 /* 744 * The export_stats file uses the same ops as the exports file. 745 * We use the file's name to determine the reported info per export. 746 * There is no rename in nsfdfs, so d_name.name is stable. 747 */ 748 return !strcmp(m->file->f_path.dentry->d_name.name, "export_stats"); 749} 750 751static int svc_export_show(struct seq_file *m, 752 struct cache_detail *cd, 753 struct cache_head *h) 754{ 755 struct svc_export *exp; 756 bool export_stats = is_export_stats_file(m); 757 758 if (h == NULL) { 759 if (export_stats) 760 seq_puts(m, "#path domain start-time\n#\tstats\n"); 761 else 762 seq_puts(m, "#path domain(flags)\n"); 763 return 0; 764 } 765 exp = container_of(h, struct svc_export, h); 766 seq_path(m, &exp->ex_path, " \t\n\\"); 767 seq_putc(m, '\t'); 768 seq_escape(m, exp->ex_client->name, " \t\n\\"); 769 if (export_stats) { 770 seq_printf(m, "\t%lld\n", exp->ex_stats.start_time); 771 seq_printf(m, "\tfh_stale: %lld\n", 772 percpu_counter_sum_positive(&exp->ex_stats.counter[EXP_STATS_FH_STALE])); 773 seq_printf(m, "\tio_read: %lld\n", 774 percpu_counter_sum_positive(&exp->ex_stats.counter[EXP_STATS_IO_READ])); 775 seq_printf(m, "\tio_write: %lld\n", 776 percpu_counter_sum_positive(&exp->ex_stats.counter[EXP_STATS_IO_WRITE])); 777 seq_putc(m, '\n'); 778 return 0; 779 } 780 seq_putc(m, '('); 781 if (test_bit(CACHE_VALID, &h->flags) && 782 !test_bit(CACHE_NEGATIVE, &h->flags)) { 783 exp_flags(m, exp->ex_flags, exp->ex_fsid, 784 exp->ex_anon_uid, exp->ex_anon_gid, &exp->ex_fslocs); 785 if (exp->ex_uuid) { 786 int i; 787 seq_puts(m, ",uuid="); 788 for (i = 0; i < EX_UUID_LEN; i++) { 789 if ((i&3) == 0 && i) 790 seq_putc(m, ':'); 791 seq_printf(m, "%02x", exp->ex_uuid[i]); 792 } 793 } 794 show_secinfo(m, exp); 795 } 796 seq_puts(m, ")\n"); 797 return 0; 798} 799static int svc_export_match(struct cache_head *a, struct cache_head *b) 800{ 801 struct svc_export *orig = container_of(a, struct svc_export, h); 802 struct svc_export *new = container_of(b, struct svc_export, h); 803 return orig->ex_client == new->ex_client && 804 path_equal(&orig->ex_path, &new->ex_path); 805} 806 807static void svc_export_init(struct cache_head *cnew, struct cache_head *citem) 808{ 809 struct svc_export *new = container_of(cnew, struct svc_export, h); 810 struct svc_export *item = container_of(citem, struct svc_export, h); 811 812 kref_get(&item->ex_client->ref); 813 new->ex_client = item->ex_client; 814 new->ex_path = item->ex_path; 815 path_get(&item->ex_path); 816 new->ex_fslocs.locations = NULL; 817 new->ex_fslocs.locations_count = 0; 818 new->ex_fslocs.migrated = 0; 819 new->ex_layout_types = 0; 820 new->ex_uuid = NULL; 821 new->cd = item->cd; 822 export_stats_reset(&new->ex_stats); 823} 824 825static void export_update(struct cache_head *cnew, struct cache_head *citem) 826{ 827 struct svc_export *new = container_of(cnew, struct svc_export, h); 828 struct svc_export *item = container_of(citem, struct svc_export, h); 829 int i; 830 831 new->ex_flags = item->ex_flags; 832 new->ex_anon_uid = item->ex_anon_uid; 833 new->ex_anon_gid = item->ex_anon_gid; 834 new->ex_fsid = item->ex_fsid; 835 new->ex_devid_map = item->ex_devid_map; 836 item->ex_devid_map = NULL; 837 new->ex_uuid = item->ex_uuid; 838 item->ex_uuid = NULL; 839 new->ex_fslocs.locations = item->ex_fslocs.locations; 840 item->ex_fslocs.locations = NULL; 841 new->ex_fslocs.locations_count = item->ex_fslocs.locations_count; 842 item->ex_fslocs.locations_count = 0; 843 new->ex_fslocs.migrated = item->ex_fslocs.migrated; 844 item->ex_fslocs.migrated = 0; 845 new->ex_layout_types = item->ex_layout_types; 846 new->ex_nflavors = item->ex_nflavors; 847 for (i = 0; i < MAX_SECINFO_LIST; i++) { 848 new->ex_flavors[i] = item->ex_flavors[i]; 849 } 850 new->ex_xprtsec_modes = item->ex_xprtsec_modes; 851} 852 853static struct cache_head *svc_export_alloc(void) 854{ 855 struct svc_export *i = kmalloc(sizeof(*i), GFP_KERNEL); 856 if (!i) 857 return NULL; 858 859 if (export_stats_init(&i->ex_stats)) { 860 kfree(i); 861 return NULL; 862 } 863 864 return &i->h; 865} 866 867static const struct cache_detail svc_export_cache_template = { 868 .owner = THIS_MODULE, 869 .hash_size = EXPORT_HASHMAX, 870 .name = "nfsd.export", 871 .cache_put = svc_export_put, 872 .cache_upcall = svc_export_upcall, 873 .cache_request = svc_export_request, 874 .cache_parse = svc_export_parse, 875 .cache_show = svc_export_show, 876 .match = svc_export_match, 877 .init = svc_export_init, 878 .update = export_update, 879 .alloc = svc_export_alloc, 880}; 881 882static int 883svc_export_hash(struct svc_export *exp) 884{ 885 int hash; 886 887 hash = hash_ptr(exp->ex_client, EXPORT_HASHBITS); 888 hash ^= hash_ptr(exp->ex_path.dentry, EXPORT_HASHBITS); 889 hash ^= hash_ptr(exp->ex_path.mnt, EXPORT_HASHBITS); 890 return hash; 891} 892 893static struct svc_export * 894svc_export_lookup(struct svc_export *exp) 895{ 896 struct cache_head *ch; 897 int hash = svc_export_hash(exp); 898 899 ch = sunrpc_cache_lookup_rcu(exp->cd, &exp->h, hash); 900 if (ch) 901 return container_of(ch, struct svc_export, h); 902 else 903 return NULL; 904} 905 906static struct svc_export * 907svc_export_update(struct svc_export *new, struct svc_export *old) 908{ 909 struct cache_head *ch; 910 int hash = svc_export_hash(old); 911 912 ch = sunrpc_cache_update(old->cd, &new->h, &old->h, hash); 913 if (ch) 914 return container_of(ch, struct svc_export, h); 915 else 916 return NULL; 917} 918 919 920static struct svc_expkey * 921exp_find_key(struct cache_detail *cd, struct auth_domain *clp, int fsid_type, 922 u32 *fsidv, struct cache_req *reqp) 923{ 924 struct svc_expkey key, *ek; 925 int err; 926 927 if (!clp) 928 return ERR_PTR(-ENOENT); 929 930 key.ek_client = clp; 931 key.ek_fsidtype = fsid_type; 932 memcpy(key.ek_fsid, fsidv, key_len(fsid_type)); 933 934 ek = svc_expkey_lookup(cd, &key); 935 if (ek == NULL) 936 return ERR_PTR(-ENOMEM); 937 err = cache_check(cd, &ek->h, reqp); 938 if (err) { 939 trace_nfsd_exp_find_key(&key, err); 940 return ERR_PTR(err); 941 } 942 return ek; 943} 944 945static struct svc_export * 946exp_get_by_name(struct cache_detail *cd, struct auth_domain *clp, 947 const struct path *path, struct cache_req *reqp) 948{ 949 struct svc_export *exp, key; 950 int err; 951 952 if (!clp) 953 return ERR_PTR(-ENOENT); 954 955 key.ex_client = clp; 956 key.ex_path = *path; 957 key.cd = cd; 958 959 exp = svc_export_lookup(&key); 960 if (exp == NULL) 961 return ERR_PTR(-ENOMEM); 962 err = cache_check(cd, &exp->h, reqp); 963 if (err) { 964 trace_nfsd_exp_get_by_name(&key, err); 965 return ERR_PTR(err); 966 } 967 return exp; 968} 969 970/* 971 * Find the export entry for a given dentry. 972 */ 973static struct svc_export * 974exp_parent(struct cache_detail *cd, struct auth_domain *clp, struct path *path) 975{ 976 struct dentry *saved = dget(path->dentry); 977 struct svc_export *exp = exp_get_by_name(cd, clp, path, NULL); 978 979 while (PTR_ERR(exp) == -ENOENT && !IS_ROOT(path->dentry)) { 980 struct dentry *parent = dget_parent(path->dentry); 981 dput(path->dentry); 982 path->dentry = parent; 983 exp = exp_get_by_name(cd, clp, path, NULL); 984 } 985 dput(path->dentry); 986 path->dentry = saved; 987 return exp; 988} 989 990 991 992/* 993 * Obtain the root fh on behalf of a client. 994 * This could be done in user space, but I feel that it adds some safety 995 * since its harder to fool a kernel module than a user space program. 996 */ 997int 998exp_rootfh(struct net *net, struct auth_domain *clp, char *name, 999 struct knfsd_fh *f, int maxsize) 1000{ 1001 struct svc_export *exp; 1002 struct path path; 1003 struct inode *inode; 1004 struct svc_fh fh; 1005 int err; 1006 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1007 struct cache_detail *cd = nn->svc_export_cache; 1008 1009 err = -EPERM; 1010 /* NB: we probably ought to check that it's NUL-terminated */ 1011 if (kern_path(name, 0, &path)) { 1012 printk("nfsd: exp_rootfh path not found %s", name); 1013 return err; 1014 } 1015 inode = d_inode(path.dentry); 1016 1017 dprintk("nfsd: exp_rootfh(%s [%p] %s:%s/%ld)\n", 1018 name, path.dentry, clp->name, 1019 inode->i_sb->s_id, inode->i_ino); 1020 exp = exp_parent(cd, clp, &path); 1021 if (IS_ERR(exp)) { 1022 err = PTR_ERR(exp); 1023 goto out; 1024 } 1025 1026 /* 1027 * fh must be initialized before calling fh_compose 1028 */ 1029 fh_init(&fh, maxsize); 1030 if (fh_compose(&fh, exp, path.dentry, NULL)) 1031 err = -EINVAL; 1032 else 1033 err = 0; 1034 memcpy(f, &fh.fh_handle, sizeof(struct knfsd_fh)); 1035 fh_put(&fh); 1036 exp_put(exp); 1037out: 1038 path_put(&path); 1039 return err; 1040} 1041 1042static struct svc_export *exp_find(struct cache_detail *cd, 1043 struct auth_domain *clp, int fsid_type, 1044 u32 *fsidv, struct cache_req *reqp) 1045{ 1046 struct svc_export *exp; 1047 struct nfsd_net *nn = net_generic(cd->net, nfsd_net_id); 1048 struct svc_expkey *ek = exp_find_key(nn->svc_expkey_cache, clp, fsid_type, fsidv, reqp); 1049 if (IS_ERR(ek)) 1050 return ERR_CAST(ek); 1051 1052 exp = exp_get_by_name(cd, clp, &ek->ek_path, reqp); 1053 cache_put(&ek->h, nn->svc_expkey_cache); 1054 1055 if (IS_ERR(exp)) 1056 return ERR_CAST(exp); 1057 return exp; 1058} 1059 1060__be32 check_nfsd_access(struct svc_export *exp, struct svc_rqst *rqstp) 1061{ 1062 struct exp_flavor_info *f, *end = exp->ex_flavors + exp->ex_nflavors; 1063 struct svc_xprt *xprt = rqstp->rq_xprt; 1064 1065 if (exp->ex_xprtsec_modes & NFSEXP_XPRTSEC_NONE) { 1066 if (!test_bit(XPT_TLS_SESSION, &xprt->xpt_flags)) 1067 goto ok; 1068 } 1069 if (exp->ex_xprtsec_modes & NFSEXP_XPRTSEC_TLS) { 1070 if (test_bit(XPT_TLS_SESSION, &xprt->xpt_flags) && 1071 !test_bit(XPT_PEER_AUTH, &xprt->xpt_flags)) 1072 goto ok; 1073 } 1074 if (exp->ex_xprtsec_modes & NFSEXP_XPRTSEC_MTLS) { 1075 if (test_bit(XPT_TLS_SESSION, &xprt->xpt_flags) && 1076 test_bit(XPT_PEER_AUTH, &xprt->xpt_flags)) 1077 goto ok; 1078 } 1079 goto denied; 1080 1081ok: 1082 /* legacy gss-only clients are always OK: */ 1083 if (exp->ex_client == rqstp->rq_gssclient) 1084 return 0; 1085 /* ip-address based client; check sec= export option: */ 1086 for (f = exp->ex_flavors; f < end; f++) { 1087 if (f->pseudoflavor == rqstp->rq_cred.cr_flavor) 1088 return 0; 1089 } 1090 /* defaults in absence of sec= options: */ 1091 if (exp->ex_nflavors == 0) { 1092 if (rqstp->rq_cred.cr_flavor == RPC_AUTH_NULL || 1093 rqstp->rq_cred.cr_flavor == RPC_AUTH_UNIX) 1094 return 0; 1095 } 1096 1097 /* If the compound op contains a spo_must_allowed op, 1098 * it will be sent with integrity/protection which 1099 * will have to be expressly allowed on mounts that 1100 * don't support it 1101 */ 1102 1103 if (nfsd4_spo_must_allow(rqstp)) 1104 return 0; 1105 1106denied: 1107 return rqstp->rq_vers < 4 ? nfserr_acces : nfserr_wrongsec; 1108} 1109 1110/* 1111 * Uses rq_client and rq_gssclient to find an export; uses rq_client (an 1112 * auth_unix client) if it's available and has secinfo information; 1113 * otherwise, will try to use rq_gssclient. 1114 * 1115 * Called from functions that handle requests; functions that do work on 1116 * behalf of mountd are passed a single client name to use, and should 1117 * use exp_get_by_name() or exp_find(). 1118 */ 1119struct svc_export * 1120rqst_exp_get_by_name(struct svc_rqst *rqstp, struct path *path) 1121{ 1122 struct svc_export *gssexp, *exp = ERR_PTR(-ENOENT); 1123 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 1124 struct cache_detail *cd = nn->svc_export_cache; 1125 1126 if (rqstp->rq_client == NULL) 1127 goto gss; 1128 1129 /* First try the auth_unix client: */ 1130 exp = exp_get_by_name(cd, rqstp->rq_client, path, &rqstp->rq_chandle); 1131 if (PTR_ERR(exp) == -ENOENT) 1132 goto gss; 1133 if (IS_ERR(exp)) 1134 return exp; 1135 /* If it has secinfo, assume there are no gss/... clients */ 1136 if (exp->ex_nflavors > 0) 1137 return exp; 1138gss: 1139 /* Otherwise, try falling back on gss client */ 1140 if (rqstp->rq_gssclient == NULL) 1141 return exp; 1142 gssexp = exp_get_by_name(cd, rqstp->rq_gssclient, path, &rqstp->rq_chandle); 1143 if (PTR_ERR(gssexp) == -ENOENT) 1144 return exp; 1145 if (!IS_ERR(exp)) 1146 exp_put(exp); 1147 return gssexp; 1148} 1149 1150struct svc_export * 1151rqst_exp_find(struct svc_rqst *rqstp, int fsid_type, u32 *fsidv) 1152{ 1153 struct svc_export *gssexp, *exp = ERR_PTR(-ENOENT); 1154 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 1155 struct cache_detail *cd = nn->svc_export_cache; 1156 1157 if (rqstp->rq_client == NULL) 1158 goto gss; 1159 1160 /* First try the auth_unix client: */ 1161 exp = exp_find(cd, rqstp->rq_client, fsid_type, 1162 fsidv, &rqstp->rq_chandle); 1163 if (PTR_ERR(exp) == -ENOENT) 1164 goto gss; 1165 if (IS_ERR(exp)) 1166 return exp; 1167 /* If it has secinfo, assume there are no gss/... clients */ 1168 if (exp->ex_nflavors > 0) 1169 return exp; 1170gss: 1171 /* Otherwise, try falling back on gss client */ 1172 if (rqstp->rq_gssclient == NULL) 1173 return exp; 1174 gssexp = exp_find(cd, rqstp->rq_gssclient, fsid_type, fsidv, 1175 &rqstp->rq_chandle); 1176 if (PTR_ERR(gssexp) == -ENOENT) 1177 return exp; 1178 if (!IS_ERR(exp)) 1179 exp_put(exp); 1180 return gssexp; 1181} 1182 1183struct svc_export * 1184rqst_exp_parent(struct svc_rqst *rqstp, struct path *path) 1185{ 1186 struct dentry *saved = dget(path->dentry); 1187 struct svc_export *exp = rqst_exp_get_by_name(rqstp, path); 1188 1189 while (PTR_ERR(exp) == -ENOENT && !IS_ROOT(path->dentry)) { 1190 struct dentry *parent = dget_parent(path->dentry); 1191 dput(path->dentry); 1192 path->dentry = parent; 1193 exp = rqst_exp_get_by_name(rqstp, path); 1194 } 1195 dput(path->dentry); 1196 path->dentry = saved; 1197 return exp; 1198} 1199 1200struct svc_export *rqst_find_fsidzero_export(struct svc_rqst *rqstp) 1201{ 1202 u32 fsidv[2]; 1203 1204 mk_fsid(FSID_NUM, fsidv, 0, 0, 0, NULL); 1205 1206 return rqst_exp_find(rqstp, FSID_NUM, fsidv); 1207} 1208 1209/* 1210 * Called when we need the filehandle for the root of the pseudofs, 1211 * for a given NFSv4 client. The root is defined to be the 1212 * export point with fsid==0 1213 */ 1214__be32 1215exp_pseudoroot(struct svc_rqst *rqstp, struct svc_fh *fhp) 1216{ 1217 struct svc_export *exp; 1218 __be32 rv; 1219 1220 exp = rqst_find_fsidzero_export(rqstp); 1221 if (IS_ERR(exp)) 1222 return nfserrno(PTR_ERR(exp)); 1223 rv = fh_compose(fhp, exp, exp->ex_path.dentry, NULL); 1224 exp_put(exp); 1225 return rv; 1226} 1227 1228static struct flags { 1229 int flag; 1230 char *name[2]; 1231} expflags[] = { 1232 { NFSEXP_READONLY, {"ro", "rw"}}, 1233 { NFSEXP_INSECURE_PORT, {"insecure", ""}}, 1234 { NFSEXP_ROOTSQUASH, {"root_squash", "no_root_squash"}}, 1235 { NFSEXP_ALLSQUASH, {"all_squash", ""}}, 1236 { NFSEXP_ASYNC, {"async", "sync"}}, 1237 { NFSEXP_GATHERED_WRITES, {"wdelay", "no_wdelay"}}, 1238 { NFSEXP_NOREADDIRPLUS, {"nordirplus", ""}}, 1239 { NFSEXP_NOHIDE, {"nohide", ""}}, 1240 { NFSEXP_CROSSMOUNT, {"crossmnt", ""}}, 1241 { NFSEXP_NOSUBTREECHECK, {"no_subtree_check", ""}}, 1242 { NFSEXP_NOAUTHNLM, {"insecure_locks", ""}}, 1243 { NFSEXP_V4ROOT, {"v4root", ""}}, 1244 { NFSEXP_PNFS, {"pnfs", ""}}, 1245 { NFSEXP_SECURITY_LABEL, {"security_label", ""}}, 1246 { 0, {"", ""}} 1247}; 1248 1249static void show_expflags(struct seq_file *m, int flags, int mask) 1250{ 1251 struct flags *flg; 1252 int state, first = 0; 1253 1254 for (flg = expflags; flg->flag; flg++) { 1255 if (flg->flag & ~mask) 1256 continue; 1257 state = (flg->flag & flags) ? 0 : 1; 1258 if (*flg->name[state]) 1259 seq_printf(m, "%s%s", first++?",":"", flg->name[state]); 1260 } 1261} 1262 1263static void show_secinfo_flags(struct seq_file *m, int flags) 1264{ 1265 seq_printf(m, ","); 1266 show_expflags(m, flags, NFSEXP_SECINFO_FLAGS); 1267} 1268 1269static bool secinfo_flags_equal(int f, int g) 1270{ 1271 f &= NFSEXP_SECINFO_FLAGS; 1272 g &= NFSEXP_SECINFO_FLAGS; 1273 return f == g; 1274} 1275 1276static int show_secinfo_run(struct seq_file *m, struct exp_flavor_info **fp, struct exp_flavor_info *end) 1277{ 1278 int flags; 1279 1280 flags = (*fp)->flags; 1281 seq_printf(m, ",sec=%d", (*fp)->pseudoflavor); 1282 (*fp)++; 1283 while (*fp != end && secinfo_flags_equal(flags, (*fp)->flags)) { 1284 seq_printf(m, ":%d", (*fp)->pseudoflavor); 1285 (*fp)++; 1286 } 1287 return flags; 1288} 1289 1290static void show_secinfo(struct seq_file *m, struct svc_export *exp) 1291{ 1292 struct exp_flavor_info *f; 1293 struct exp_flavor_info *end = exp->ex_flavors + exp->ex_nflavors; 1294 int flags; 1295 1296 if (exp->ex_nflavors == 0) 1297 return; 1298 f = exp->ex_flavors; 1299 flags = show_secinfo_run(m, &f, end); 1300 if (!secinfo_flags_equal(flags, exp->ex_flags)) 1301 show_secinfo_flags(m, flags); 1302 while (f != end) { 1303 flags = show_secinfo_run(m, &f, end); 1304 show_secinfo_flags(m, flags); 1305 } 1306} 1307 1308static void exp_flags(struct seq_file *m, int flag, int fsid, 1309 kuid_t anonu, kgid_t anong, struct nfsd4_fs_locations *fsloc) 1310{ 1311 struct user_namespace *userns = m->file->f_cred->user_ns; 1312 1313 show_expflags(m, flag, NFSEXP_ALLFLAGS); 1314 if (flag & NFSEXP_FSID) 1315 seq_printf(m, ",fsid=%d", fsid); 1316 if (!uid_eq(anonu, make_kuid(userns, (uid_t)-2)) && 1317 !uid_eq(anonu, make_kuid(userns, 0x10000-2))) 1318 seq_printf(m, ",anonuid=%u", from_kuid_munged(userns, anonu)); 1319 if (!gid_eq(anong, make_kgid(userns, (gid_t)-2)) && 1320 !gid_eq(anong, make_kgid(userns, 0x10000-2))) 1321 seq_printf(m, ",anongid=%u", from_kgid_munged(userns, anong)); 1322 if (fsloc && fsloc->locations_count > 0) { 1323 char *loctype = (fsloc->migrated) ? "refer" : "replicas"; 1324 int i; 1325 1326 seq_printf(m, ",%s=", loctype); 1327 seq_escape(m, fsloc->locations[0].path, ",;@ \t\n\\"); 1328 seq_putc(m, '@'); 1329 seq_escape(m, fsloc->locations[0].hosts, ",;@ \t\n\\"); 1330 for (i = 1; i < fsloc->locations_count; i++) { 1331 seq_putc(m, ';'); 1332 seq_escape(m, fsloc->locations[i].path, ",;@ \t\n\\"); 1333 seq_putc(m, '@'); 1334 seq_escape(m, fsloc->locations[i].hosts, ",;@ \t\n\\"); 1335 } 1336 } 1337} 1338 1339static int e_show(struct seq_file *m, void *p) 1340{ 1341 struct cache_head *cp = p; 1342 struct svc_export *exp = container_of(cp, struct svc_export, h); 1343 struct cache_detail *cd = m->private; 1344 bool export_stats = is_export_stats_file(m); 1345 1346 if (p == SEQ_START_TOKEN) { 1347 seq_puts(m, "# Version 1.1\n"); 1348 if (export_stats) 1349 seq_puts(m, "# Path Client Start-time\n#\tStats\n"); 1350 else 1351 seq_puts(m, "# Path Client(Flags) # IPs\n"); 1352 return 0; 1353 } 1354 1355 exp_get(exp); 1356 if (cache_check(cd, &exp->h, NULL)) 1357 return 0; 1358 exp_put(exp); 1359 return svc_export_show(m, cd, cp); 1360} 1361 1362const struct seq_operations nfs_exports_op = { 1363 .start = cache_seq_start_rcu, 1364 .next = cache_seq_next_rcu, 1365 .stop = cache_seq_stop_rcu, 1366 .show = e_show, 1367}; 1368 1369/* 1370 * Initialize the exports module. 1371 */ 1372int 1373nfsd_export_init(struct net *net) 1374{ 1375 int rv; 1376 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1377 1378 dprintk("nfsd: initializing export module (net: %x).\n", net->ns.inum); 1379 1380 nn->svc_export_cache = cache_create_net(&svc_export_cache_template, net); 1381 if (IS_ERR(nn->svc_export_cache)) 1382 return PTR_ERR(nn->svc_export_cache); 1383 rv = cache_register_net(nn->svc_export_cache, net); 1384 if (rv) 1385 goto destroy_export_cache; 1386 1387 nn->svc_expkey_cache = cache_create_net(&svc_expkey_cache_template, net); 1388 if (IS_ERR(nn->svc_expkey_cache)) { 1389 rv = PTR_ERR(nn->svc_expkey_cache); 1390 goto unregister_export_cache; 1391 } 1392 rv = cache_register_net(nn->svc_expkey_cache, net); 1393 if (rv) 1394 goto destroy_expkey_cache; 1395 return 0; 1396 1397destroy_expkey_cache: 1398 cache_destroy_net(nn->svc_expkey_cache, net); 1399unregister_export_cache: 1400 cache_unregister_net(nn->svc_export_cache, net); 1401destroy_export_cache: 1402 cache_destroy_net(nn->svc_export_cache, net); 1403 return rv; 1404} 1405 1406/* 1407 * Flush exports table - called when last nfsd thread is killed 1408 */ 1409void 1410nfsd_export_flush(struct net *net) 1411{ 1412 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1413 1414 cache_purge(nn->svc_expkey_cache); 1415 cache_purge(nn->svc_export_cache); 1416} 1417 1418/* 1419 * Shutdown the exports module. 1420 */ 1421void 1422nfsd_export_shutdown(struct net *net) 1423{ 1424 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1425 1426 dprintk("nfsd: shutting down export module (net: %x).\n", net->ns.inum); 1427 1428 cache_unregister_net(nn->svc_expkey_cache, net); 1429 cache_unregister_net(nn->svc_export_cache, net); 1430 cache_destroy_net(nn->svc_expkey_cache, net); 1431 cache_destroy_net(nn->svc_export_cache, net); 1432 svcauth_unix_purge(net); 1433 1434 dprintk("nfsd: export shutdown complete (net: %x).\n", net->ns.inum); 1435} 1436