nfs_export.c revision 1.10
1 /* $NetBSD: nfs_export.c,v 1.10 2006/03/27 20:20:46 martin Exp $ */ 2 3 /*- 4 * Copyright (c) 1997, 1998, 2004, 2005 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility, 9 * NASA Ames Research Center. 10 * This code is derived from software contributed to The NetBSD Foundation 11 * by Charles M. Hannum. 12 * This code is derived from software contributed to The NetBSD Foundation 13 * by Julio M. Merino Vidal. 14 * 15 * Redistribution and use in source and binary forms, with or without 16 * modification, are permitted provided that the following conditions 17 * are met: 18 * 1. Redistributions of source code must retain the above copyright 19 * notice, this list of conditions and the following disclaimer. 20 * 2. Redistributions in binary form must reproduce the above copyright 21 * notice, this list of conditions and the following disclaimer in the 22 * documentation and/or other materials provided with the distribution. 23 * 3. All advertising materials mentioning features or use of this software 24 * must display the following acknowledgement: 25 * This product includes software developed by the NetBSD 26 * Foundation, Inc. and its contributors. 27 * 4. Neither the name of The NetBSD Foundation nor the names of its 28 * contributors may be used to endorse or promote products derived 29 * from this software without specific prior written permission. 30 * 31 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 32 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 33 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 34 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 35 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 36 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 37 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 38 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 39 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 40 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGE. 42 */ 43 44 /* 45 * Copyright (c) 1989, 1993 46 * The Regents of the University of California. All rights reserved. 47 * (c) UNIX System Laboratories, Inc. 48 * All or some portions of this file are derived from material licensed 49 * to the University of California by American Telephone and Telegraph 50 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 51 * the permission of UNIX System Laboratories, Inc. 52 * 53 * Redistribution and use in source and binary forms, with or without 54 * modification, are permitted provided that the following conditions 55 * are met: 56 * 1. Redistributions of source code must retain the above copyright 57 * notice, this list of conditions and the following disclaimer. 58 * 2. Redistributions in binary form must reproduce the above copyright 59 * notice, this list of conditions and the following disclaimer in the 60 * documentation and/or other materials provided with the distribution. 61 * 3. Neither the name of the University nor the names of its contributors 62 * may be used to endorse or promote products derived from this software 63 * without specific prior written permission. 64 * 65 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 66 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 67 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 68 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 69 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 70 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 71 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 72 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 73 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 74 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 75 * SUCH DAMAGE. 76 * 77 * @(#)vfs_subr.c 8.13 (Berkeley) 4/18/94 78 */ 79 80 /* 81 * VFS exports list management. 82 */ 83 84 #include <sys/cdefs.h> 85 __KERNEL_RCSID(0, "$NetBSD: nfs_export.c,v 1.10 2006/03/27 20:20:46 martin Exp $"); 86 87 #include "opt_compat_netbsd.h" 88 #include "opt_inet.h" 89 90 #include <sys/param.h> 91 #include <sys/systm.h> 92 #include <sys/queue.h> 93 #include <sys/proc.h> 94 #include <sys/mount.h> 95 #include <sys/vnode.h> 96 #include <sys/namei.h> 97 #include <sys/errno.h> 98 #include <sys/malloc.h> 99 #include <sys/domain.h> 100 #include <sys/mbuf.h> 101 #include <sys/dirent.h> 102 #include <sys/socket.h> /* XXX for AF_MAX */ 103 104 #include <net/radix.h> 105 106 #include <netinet/in.h> 107 108 #include <nfs/rpcv2.h> 109 #include <nfs/nfsproto.h> 110 #include <nfs/nfs.h> 111 #include <nfs/nfs_var.h> 112 113 /* 114 * Network address lookup element. 115 */ 116 struct netcred { 117 struct radix_node netc_rnodes[2]; 118 int netc_refcnt; 119 int netc_exflags; 120 struct ucred netc_anon; 121 }; 122 123 /* 124 * Network export information. 125 */ 126 struct netexport { 127 CIRCLEQ_ENTRY(netexport) ne_list; 128 struct mount *ne_mount; 129 struct netcred ne_defexported; /* Default export */ 130 struct radix_node_head *ne_rtable[AF_MAX+1]; /* Individual exports */ 131 }; 132 CIRCLEQ_HEAD(, netexport) netexport_list = 133 CIRCLEQ_HEAD_INITIALIZER(netexport_list); 134 135 /* Malloc type used by the mount<->netexport map. */ 136 MALLOC_DEFINE(M_NFS_EXPORT, "nfs_export", "NFS export data"); 137 138 /* Publicly exported file system. */ 139 struct nfs_public nfs_pub; 140 141 /* 142 * Local prototypes. 143 */ 144 static int init_exports(struct mount *, struct netexport **); 145 static int hang_addrlist(struct mount *, struct netexport *, 146 const struct export_args *); 147 static int sacheck(struct sockaddr *); 148 static int free_netcred(struct radix_node *, void *); 149 static void clear_exports(struct netexport *); 150 static int export(struct netexport *, const struct export_args *); 151 static int setpublicfs(struct mount *, struct netexport *, 152 const struct export_args *); 153 static struct netcred *netcred_lookup(struct netexport *, struct mbuf *); 154 static struct netexport *netexport_lookup(const struct mount *); 155 static struct netexport *netexport_lookup_byfsid(const fsid_t *); 156 static void netexport_insert(struct netexport *); 157 static void netexport_remove(struct netexport *); 158 static void netexport_wrlock(void); 159 static void netexport_wrunlock(void); 160 161 /* 162 * PUBLIC INTERFACE 163 */ 164 165 /* 166 * Declare and initialize the file system export hooks. 167 */ 168 static void nfs_export_unmount(struct mount *); 169 170 struct vfs_hooks nfs_export_hooks = { 171 nfs_export_unmount 172 }; 173 VFS_HOOKS_ATTACH(nfs_export_hooks); 174 175 /* 176 * VFS unmount hook for NFS exports. 177 * 178 * Releases NFS exports list resources if the given mount point has some. 179 * As allocation happens lazily, it may be that it doesn't has this 180 * information, although it theorically should. 181 */ 182 static void 183 nfs_export_unmount(struct mount *mp) 184 { 185 struct netexport *ne; 186 187 KASSERT(mp != NULL); 188 189 netexport_wrlock(); 190 ne = netexport_lookup(mp); 191 if (ne == NULL) { 192 netexport_wrunlock(); 193 return; 194 } 195 196 KASSERT(mp->mnt_op->vfs_vptofh != NULL && 197 mp->mnt_op->vfs_fhtovp != NULL); 198 199 if (mp->mnt_flag & MNT_EXPUBLIC) { 200 setpublicfs(NULL, NULL, NULL); 201 } 202 203 netexport_remove(ne); 204 netexport_wrunlock(); 205 free(ne, M_NFS_EXPORT); 206 } 207 208 /* 209 * Atomically set the NFS exports list of the given file system, replacing 210 * it with a new list of entries. 211 * 212 * Returns zero on success or an appropriate error code otherwise. 213 * 214 * Helper function for the nfssvc(2) system call (NFSSVC_SETEXPORTSLIST 215 * command). 216 */ 217 int 218 mountd_set_exports_list(const struct mountd_exports_list *mel, struct lwp *l) 219 { 220 int error; 221 #ifdef notyet 222 /* XXX: See below to see the reason why this is disabled. */ 223 size_t i; 224 #endif 225 struct mount *mp; 226 struct netexport *ne; 227 struct nameidata nd; 228 struct vnode *vp; 229 struct fid fid; 230 231 if (suser(l->l_proc->p_ucred, &l->l_proc->p_acflag) != 0) 232 return EPERM; 233 234 /* Lookup the file system path. */ 235 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, mel->mel_path, l); 236 error = namei(&nd); 237 if (error != 0) 238 return error; 239 vp = nd.ni_vp; 240 mp = vp->v_mount; 241 242 /* The selected file system may not support NFS exports, so ensure 243 * it does. */ 244 if (mp->mnt_op->vfs_vptofh == NULL || mp->mnt_op->vfs_fhtovp == NULL || 245 VFS_VPTOFH(vp, &fid) != 0) { 246 error = EOPNOTSUPP; 247 goto out_locked; 248 } 249 KASSERT(fid.fid_len <= _VFS_MAXFIDSZ); 250 KASSERT(mp->mnt_op->vfs_vptofh != NULL && 251 mp->mnt_op->vfs_fhtovp != NULL); 252 253 /* Mark the file system busy. */ 254 error = vfs_busy(mp, LK_NOWAIT, NULL); 255 if (error != 0) 256 goto out_locked; 257 258 netexport_wrlock(); 259 ne = netexport_lookup(mp); 260 if (ne == NULL) { 261 error = init_exports(mp, &ne); 262 if (error != 0) { 263 goto out_locked2; 264 } 265 } 266 267 KASSERT(ne != NULL); 268 KASSERT(ne->ne_mount == mp); 269 270 /* 271 * XXX: The part marked as 'notyet' works fine from the kernel's 272 * point of view, in the sense that it is able to atomically update 273 * the complete exports list for a file system. However, supporting 274 * this in mountd(8) requires a lot of work; so, for now, keep the 275 * old behavior of updating a single entry per call. 276 * 277 * When mountd(8) is fixed, just remove the second branch of this 278 * preprocessor conditional and enable the first one. 279 */ 280 #ifdef notyet 281 clear_exports(ne); 282 for (i = 0; error == 0 && i < mel->mel_nexports; i++) 283 error = export(ne, &mel->mel_exports[i]); 284 #else 285 if (mel->mel_nexports == 0) 286 clear_exports(ne); 287 else if (mel->mel_nexports == 1) 288 error = export(ne, &mel->mel_exports[0]); 289 else { 290 printf("mountd_set_exports_list: Cannot set more than one " 291 "entry at once (unimplemented)\n"); 292 error = EOPNOTSUPP; 293 } 294 #endif 295 296 out_locked2: 297 netexport_wrunlock(); 298 vfs_unbusy(mp); 299 300 out_locked: 301 vput(vp); 302 303 return error; 304 } 305 306 static void 307 netexport_insert(struct netexport *ne) 308 { 309 310 CIRCLEQ_INSERT_HEAD(&netexport_list, ne, ne_list); 311 } 312 313 static void 314 netexport_remove(struct netexport *ne) 315 { 316 317 CIRCLEQ_REMOVE(&netexport_list, ne, ne_list); 318 } 319 320 static struct netexport * 321 netexport_lookup(const struct mount *mp) 322 { 323 struct netexport *ne; 324 325 CIRCLEQ_FOREACH(ne, &netexport_list, ne_list) { 326 if (ne->ne_mount == mp) { 327 goto done; 328 } 329 } 330 ne = NULL; 331 done: 332 return ne; 333 } 334 335 static struct netexport * 336 netexport_lookup_byfsid(const fsid_t *fsid) 337 { 338 struct netexport *ne; 339 340 CIRCLEQ_FOREACH(ne, &netexport_list, ne_list) { 341 const struct mount *mp = ne->ne_mount; 342 343 if (mp->mnt_stat.f_fsidx.__fsid_val[0] == fsid->__fsid_val[0] && 344 mp->mnt_stat.f_fsidx.__fsid_val[1] == fsid->__fsid_val[1]) { 345 goto done; 346 } 347 } 348 ne = NULL; 349 done: 350 351 return ne; 352 } 353 354 /* 355 * Check if the file system specified by the 'mp' mount structure is 356 * exported to a client with 'anon' anonymous credentials. The 'mb' 357 * argument is an mbuf containing the network address of the client. 358 * The return parameters for the export flags for the client are returned 359 * in the address specified by 'wh'. 360 * 361 * This function is used exclusively by the NFS server. It is generally 362 * invoked before VFS_FHTOVP to validate that client has access to the 363 * file system. 364 */ 365 366 int 367 netexport_check(const fsid_t *fsid, struct mbuf *mb, struct mount **mpp, 368 int *wh, struct ucred **anon) 369 { 370 struct netexport *ne; 371 struct netcred *np; 372 373 ne = netexport_lookup_byfsid(fsid); 374 if (ne == NULL) { 375 return EACCES; 376 } 377 np = netcred_lookup(ne, mb); 378 if (np == NULL) { 379 return EACCES; 380 } 381 382 *mpp = ne->ne_mount; 383 *wh = np->netc_exflags; 384 *anon = &np->netc_anon; 385 386 return 0; 387 } 388 389 #ifdef COMPAT_30 390 /* 391 * Handles legacy export requests. In this case, the export information 392 * is hardcoded in a specific place of the mount arguments structure (given 393 * in data); the request for an update is given through the fspec field 394 * (also in a known location), which must be a null pointer. 395 * 396 * Returns EJUSTRETURN if the given command was not a export request. 397 * Otherwise, returns 0 on success or an appropriate error code otherwise. 398 */ 399 int 400 nfs_update_exports_30(struct mount *mp, const char *path, void *data, 401 struct lwp *l) 402 { 403 int error; 404 struct { 405 const char *fspec; 406 struct export_args30 eargs; 407 } args; 408 struct mountd_exports_list mel; 409 410 mel.mel_path = path; 411 412 error = copyin(data, &args, sizeof(args)); 413 if (error != 0) 414 return EJUSTRETURN; 415 416 if (args.fspec != NULL) 417 return EJUSTRETURN; 418 419 if (args.eargs.ex_flags & 0x00020000) { 420 /* Request to delete exports. The mask above holds the 421 * value that used to be in MNT_DELEXPORT. */ 422 mel.mel_nexports = 0; 423 } else { 424 struct export_args eargs; 425 426 /* The following assumes export_args has not changed since 427 * export_args30. */ 428 memcpy(&eargs, &args.eargs, sizeof(struct export_args)); 429 430 mel.mel_nexports = 1; 431 mel.mel_exports = &eargs; 432 } 433 434 return mountd_set_exports_list(&mel, l); 435 } 436 #endif 437 438 /* 439 * INTERNAL FUNCTIONS 440 */ 441 442 /* 443 * Initializes NFS exports for the file system given in 'mp' if it supports 444 * file handles; this is determined by checking whether mp's vfs_vptofh and 445 * vfs_fhtovp operations are NULL or not. 446 * 447 * If successful, returns 0 and sets *mnpp to the address of the new 448 * mount_netexport_pair item; otherwise returns and appropriate error code 449 * and *mnpp remains unmodified. 450 */ 451 static int 452 init_exports(struct mount *mp, struct netexport **nep) 453 { 454 int error; 455 struct export_args ea; 456 struct netexport *ne; 457 458 KASSERT(mp != NULL); 459 KASSERT(mp->mnt_op->vfs_vptofh != NULL && 460 mp->mnt_op->vfs_fhtovp != NULL); 461 462 /* Ensure that we do not already have this mount point. */ 463 KASSERT(netexport_lookup(mp) == NULL); 464 465 ne = malloc(sizeof(*ne), M_NFS_EXPORT, M_WAITOK | M_ZERO); 466 ne->ne_mount = mp; 467 468 /* Set the default export entry. Handled internally by export upon 469 * first call. */ 470 memset(&ea, 0, sizeof(ea)); 471 ea.ex_root = -2; 472 if (mp->mnt_flag & MNT_RDONLY) 473 ea.ex_flags |= MNT_EXRDONLY; 474 error = export(ne, &ea); 475 if (error != 0) { 476 free(ne, M_NFS_EXPORT); 477 } else { 478 netexport_insert(ne); 479 *nep = ne; 480 } 481 482 return error; 483 } 484 485 /* 486 * Build hash lists of net addresses and hang them off the mount point. 487 * Called by export() to set up a new entry in the lists of export 488 * addresses. 489 */ 490 static int 491 hang_addrlist(struct mount *mp, struct netexport *nep, 492 const struct export_args *argp) 493 { 494 int error, i; 495 struct netcred *np, *enp; 496 struct radix_node_head *rnh; 497 struct sockaddr *saddr, *smask; 498 struct domain *dom; 499 500 smask = NULL; 501 502 if (argp->ex_addrlen == 0) { 503 if (mp->mnt_flag & MNT_DEFEXPORTED) 504 return EPERM; 505 np = &nep->ne_defexported; 506 np->netc_exflags = argp->ex_flags; 507 crcvt(&np->netc_anon, &argp->ex_anon); 508 np->netc_anon.cr_ref = 1; 509 mp->mnt_flag |= MNT_DEFEXPORTED; 510 return 0; 511 } 512 513 if (argp->ex_addrlen > MLEN || argp->ex_masklen > MLEN) 514 return EINVAL; 515 516 i = sizeof(struct netcred) + argp->ex_addrlen + argp->ex_masklen; 517 np = malloc(i, M_NETADDR, M_WAITOK | M_ZERO); 518 saddr = (struct sockaddr *)(np + 1); 519 error = copyin(argp->ex_addr, saddr, argp->ex_addrlen); 520 if (error) 521 goto out; 522 if (saddr->sa_len > argp->ex_addrlen) 523 saddr->sa_len = argp->ex_addrlen; 524 if (sacheck(saddr) == -1) 525 return EINVAL; 526 if (argp->ex_masklen) { 527 smask = (struct sockaddr *)((caddr_t)saddr + argp->ex_addrlen); 528 error = copyin(argp->ex_mask, smask, argp->ex_masklen); 529 if (error) 530 goto out; 531 if (smask->sa_len > argp->ex_masklen) 532 smask->sa_len = argp->ex_masklen; 533 if (smask->sa_family != saddr->sa_family) 534 return EINVAL; 535 if (sacheck(smask) == -1) 536 return EINVAL; 537 } 538 i = saddr->sa_family; 539 if ((rnh = nep->ne_rtable[i]) == 0) { 540 /* 541 * Seems silly to initialize every AF when most are not 542 * used, do so on demand here 543 */ 544 DOMAIN_FOREACH(dom) { 545 if (dom->dom_family == i && dom->dom_rtattach) { 546 dom->dom_rtattach((void **)&nep->ne_rtable[i], 547 dom->dom_rtoffset); 548 break; 549 } 550 } 551 if ((rnh = nep->ne_rtable[i]) == 0) { 552 error = ENOBUFS; 553 goto out; 554 } 555 } 556 557 enp = (struct netcred *)(*rnh->rnh_addaddr)(saddr, smask, rnh, 558 np->netc_rnodes); 559 if (enp != np) { 560 if (enp == NULL) { 561 enp = (struct netcred *)(*rnh->rnh_lookup)(saddr, 562 smask, rnh); 563 if (enp == NULL) { 564 error = EPERM; 565 goto out; 566 } 567 } else 568 enp->netc_refcnt++; 569 570 goto check; 571 } else 572 enp->netc_refcnt = 1; 573 574 np->netc_exflags = argp->ex_flags; 575 crcvt(&np->netc_anon, &argp->ex_anon); 576 np->netc_anon.cr_ref = 1; 577 return 0; 578 check: 579 if (enp->netc_exflags != argp->ex_flags || 580 crcmp(&enp->netc_anon, &argp->ex_anon) != 0) 581 error = EPERM; 582 else 583 error = 0; 584 out: 585 free(np, M_NETADDR); 586 return error; 587 } 588 589 /* 590 * Ensure that the address stored in 'sa' is valid. 591 * Returns zero on success, otherwise -1. 592 */ 593 static int 594 sacheck(struct sockaddr *sa) 595 { 596 597 switch (sa->sa_family) { 598 #ifdef INET 599 case AF_INET: { 600 struct sockaddr_in *sin = (struct sockaddr_in *)sa; 601 char *p = (char *)sin->sin_zero; 602 size_t i; 603 604 if (sin->sin_len != sizeof(*sin)) 605 return -1; 606 if (sin->sin_port != 0) 607 return -1; 608 for (i = 0; i < sizeof(sin->sin_zero); i++) 609 if (*p++ != '\0') 610 return -1; 611 return 0; 612 } 613 #endif 614 #ifdef INET6 615 case AF_INET6: { 616 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa; 617 618 if (sin6->sin6_len != sizeof(*sin6)) 619 return -1; 620 if (sin6->sin6_port != 0) 621 return -1; 622 return 0; 623 } 624 #endif 625 default: 626 return -1; 627 } 628 } 629 630 /* 631 * Free the netcred object pointed to by the 'rn' radix node. 632 * 'w' holds a pointer to the radix tree head. 633 */ 634 static int 635 free_netcred(struct radix_node *rn, void *w) 636 { 637 struct radix_node_head *rnh = (struct radix_node_head *)w; 638 struct netcred *np = (struct netcred *)(void *)rn; 639 640 (*rnh->rnh_deladdr)(rn->rn_key, rn->rn_mask, rnh); 641 if (--(np->netc_refcnt) <= 0) 642 free(np, M_NETADDR); 643 return 0; 644 } 645 646 /* 647 * Clears the exports list for a given file system. 648 */ 649 static void 650 clear_exports(struct netexport *ne) 651 { 652 struct radix_node_head *rnh; 653 struct mount *mp = ne->ne_mount; 654 int i; 655 656 if (mp->mnt_flag & MNT_EXPUBLIC) { 657 setpublicfs(NULL, NULL, NULL); 658 mp->mnt_flag &= ~MNT_EXPUBLIC; 659 } 660 661 for (i = 0; i <= AF_MAX; i++) { 662 if ((rnh = ne->ne_rtable[i]) != NULL) { 663 (*rnh->rnh_walktree)(rnh, free_netcred, rnh); 664 free(rnh, M_RTABLE); 665 ne->ne_rtable[i] = NULL; 666 } 667 } 668 669 mp->mnt_flag &= ~(MNT_EXPORTED | MNT_DEFEXPORTED); 670 } 671 672 /* 673 * Add a new export entry (described by an export_args structure) to the 674 * given file system. 675 */ 676 static int 677 export(struct netexport *nep, const struct export_args *argp) 678 { 679 struct mount *mp = nep->ne_mount; 680 int error; 681 682 if (argp->ex_flags & MNT_EXPORTED) { 683 if (argp->ex_flags & MNT_EXPUBLIC) { 684 if ((error = setpublicfs(mp, nep, argp)) != 0) 685 return error; 686 mp->mnt_flag |= MNT_EXPUBLIC; 687 } 688 if ((error = hang_addrlist(mp, nep, argp)) != 0) 689 return error; 690 mp->mnt_flag |= MNT_EXPORTED; 691 } 692 return 0; 693 } 694 695 /* 696 * Set the publicly exported filesystem (WebNFS). Currently, only 697 * one public filesystem is possible in the spec (RFC 2054 and 2055) 698 */ 699 static int 700 setpublicfs(struct mount *mp, struct netexport *nep, 701 const struct export_args *argp) 702 { 703 char *cp; 704 int error; 705 struct vnode *rvp; 706 707 /* 708 * mp == NULL -> invalidate the current info, the FS is 709 * no longer exported. May be called from either export 710 * or unmount, so check if it hasn't already been done. 711 */ 712 if (mp == NULL) { 713 if (nfs_pub.np_valid) { 714 nfs_pub.np_valid = 0; 715 if (nfs_pub.np_index != NULL) { 716 FREE(nfs_pub.np_index, M_TEMP); 717 nfs_pub.np_index = NULL; 718 } 719 } 720 return 0; 721 } 722 723 /* 724 * Only one allowed at a time. 725 */ 726 if (nfs_pub.np_valid != 0 && mp != nfs_pub.np_mount) 727 return EBUSY; 728 729 /* 730 * Get real filehandle for root of exported FS. 731 */ 732 memset((caddr_t)&nfs_pub.np_handle, 0, sizeof(nfs_pub.np_handle)); 733 nfs_pub.np_handle.fh_fsid = mp->mnt_stat.f_fsidx; 734 735 if ((error = VFS_ROOT(mp, &rvp))) 736 return error; 737 738 if ((error = VFS_VPTOFH(rvp, &nfs_pub.np_handle.fh_fid))) 739 return error; 740 741 vput(rvp); 742 KASSERT(nfs_pub.np_handle.fh_fid.fid_len <= _VFS_MAXFIDSZ); 743 744 /* 745 * If an indexfile was specified, pull it in. 746 */ 747 if (argp->ex_indexfile != NULL) { 748 MALLOC(nfs_pub.np_index, char *, MAXNAMLEN + 1, M_TEMP, 749 M_WAITOK); 750 error = copyinstr(argp->ex_indexfile, nfs_pub.np_index, 751 MAXNAMLEN, (size_t *)0); 752 if (!error) { 753 /* 754 * Check for illegal filenames. 755 */ 756 for (cp = nfs_pub.np_index; *cp; cp++) { 757 if (*cp == '/') { 758 error = EINVAL; 759 break; 760 } 761 } 762 } 763 if (error) { 764 FREE(nfs_pub.np_index, M_TEMP); 765 return error; 766 } 767 } 768 769 nfs_pub.np_mount = mp; 770 nfs_pub.np_valid = 1; 771 return 0; 772 } 773 774 /* 775 * Lookup an export entry in the exports list that matches the address 776 * stored in 'nam'. If no entry is found, the default one is used instead 777 * (if available). 778 */ 779 static struct netcred * 780 netcred_lookup(struct netexport *ne, struct mbuf *nam) 781 { 782 struct netcred *np; 783 struct radix_node_head *rnh; 784 struct sockaddr *saddr; 785 786 if ((ne->ne_mount->mnt_flag & MNT_EXPORTED) == 0) { 787 return NULL; 788 } 789 790 /* 791 * Lookup in the export list first. 792 */ 793 np = NULL; 794 if (nam != NULL) { 795 saddr = mtod(nam, struct sockaddr *); 796 rnh = ne->ne_rtable[saddr->sa_family]; 797 if (rnh != NULL) { 798 np = (struct netcred *) 799 (*rnh->rnh_matchaddr)((caddr_t)saddr, 800 rnh); 801 if (np && np->netc_rnodes->rn_flags & RNF_ROOT) 802 np = NULL; 803 } 804 } 805 /* 806 * If no address match, use the default if it exists. 807 */ 808 if (np == NULL && ne->ne_mount->mnt_flag & MNT_DEFEXPORTED) 809 np = &ne->ne_defexported; 810 811 return np; 812 } 813 814 static struct lock netexport_lock = LOCK_INITIALIZER(PVFS, "netexp", 0, 0); 815 816 void 817 netexport_rdlock(void) 818 { 819 820 lockmgr(&netexport_lock, LK_SHARED, NULL); 821 } 822 823 void 824 netexport_rdunlock(void) 825 { 826 827 lockmgr(&netexport_lock, LK_RELEASE, NULL); 828 } 829 830 static void 831 netexport_wrlock(void) 832 { 833 834 lockmgr(&netexport_lock, LK_EXCLUSIVE, NULL); 835 } 836 837 static void 838 netexport_wrunlock(void) 839 { 840 841 lockmgr(&netexport_lock, LK_RELEASE, NULL); 842 } 843
Indexes created Wed Sep 24 05:09:52 GMT 2025