1 /* $NetBSD: vfs_mount.c,v 1.37 2015/08/19 08:40:02 hannken Exp $ */ 2 3 /*- 4 * Copyright (c) 1997-2011 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, by Charles M. Hannum, and by Andrew Doran. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /* 34 * Copyright (c) 1989, 1993 35 * The Regents of the University of California. All rights reserved. 36 * (c) UNIX System Laboratories, Inc. 37 * All or some portions of this file are derived from material licensed 38 * to the University of California by American Telephone and Telegraph 39 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 40 * the permission of UNIX System Laboratories, Inc. 41 * 42 * Redistribution and use in source and binary forms, with or without 43 * modification, are permitted provided that the following conditions 44 * are met: 45 * 1. Redistributions of source code must retain the above copyright 46 * notice, this list of conditions and the following disclaimer. 47 * 2. Redistributions in binary form must reproduce the above copyright 48 * notice, this list of conditions and the following disclaimer in the 49 * documentation and/or other materials provided with the distribution. 50 * 3. Neither the name of the University nor the names of its contributors 51 * may be used to endorse or promote products derived from this software 52 * without specific prior written permission. 53 * 54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 64 * SUCH DAMAGE. 65 * 66 * @(#)vfs_subr.c 8.13 (Berkeley) 4/18/94 67 */ 68 69 #include <sys/cdefs.h> 70 __KERNEL_RCSID(0, "$NetBSD: vfs_mount.c,v 1.37 2015/08/19 08:40:02 hannken Exp $"); 71 72 #define _VFS_VNODE_PRIVATE 73 74 #include <sys/param.h> 75 #include <sys/kernel.h> 76 77 #include <sys/atomic.h> 78 #include <sys/buf.h> 79 #include <sys/conf.h> 80 #include <sys/fcntl.h> 81 #include <sys/filedesc.h> 82 #include <sys/device.h> 83 #include <sys/kauth.h> 84 #include <sys/kmem.h> 85 #include <sys/module.h> 86 #include <sys/mount.h> 87 #include <sys/namei.h> 88 #include <sys/extattr.h> 89 #include <sys/syscallargs.h> 90 #include <sys/sysctl.h> 91 #include <sys/systm.h> 92 #include <sys/vfs_syscalls.h> 93 #include <sys/vnode.h> 94 95 #include <miscfs/genfs/genfs.h> 96 #include <miscfs/specfs/specdev.h> 97 98 /* Root filesystem. */ 99 vnode_t * rootvnode; 100 101 /* Mounted filesystem list. */ 102 struct mntlist mountlist; 103 kmutex_t mountlist_lock; 104 105 kmutex_t mntvnode_lock; 106 kmutex_t vfs_list_lock; 107 108 static specificdata_domain_t mount_specificdata_domain; 109 static kmutex_t mntid_lock; 110 111 static kmutex_t mountgen_lock; 112 static uint64_t mountgen; 113 114 void 115 vfs_mount_sysinit(void) 116 { 117 118 TAILQ_INIT(&mountlist); 119 mutex_init(&mountlist_lock, MUTEX_DEFAULT, IPL_NONE); 120 mutex_init(&mntvnode_lock, MUTEX_DEFAULT, IPL_NONE); 121 mutex_init(&vfs_list_lock, MUTEX_DEFAULT, IPL_NONE); 122 123 mount_specificdata_domain = specificdata_domain_create(); 124 mutex_init(&mntid_lock, MUTEX_DEFAULT, IPL_NONE); 125 mutex_init(&mountgen_lock, MUTEX_DEFAULT, IPL_NONE); 126 mountgen = 0; 127 } 128 129 struct mount * 130 vfs_mountalloc(struct vfsops *vfsops, vnode_t *vp) 131 { 132 struct mount *mp; 133 int error __diagused; 134 135 mp = kmem_zalloc(sizeof(*mp), KM_SLEEP); 136 if (mp == NULL) 137 return NULL; 138 139 mp->mnt_op = vfsops; 140 mp->mnt_refcnt = 1; 141 TAILQ_INIT(&mp->mnt_vnodelist); 142 mutex_init(&mp->mnt_unmounting, MUTEX_DEFAULT, IPL_NONE); 143 mutex_init(&mp->mnt_renamelock, MUTEX_DEFAULT, IPL_NONE); 144 mutex_init(&mp->mnt_updating, MUTEX_DEFAULT, IPL_NONE); 145 error = vfs_busy(mp, NULL); 146 KASSERT(error == 0); 147 mp->mnt_vnodecovered = vp; 148 mount_initspecific(mp); 149 150 mutex_enter(&mountgen_lock); 151 mp->mnt_gen = mountgen++; 152 mutex_exit(&mountgen_lock); 153 154 return mp; 155 } 156 157 /* 158 * vfs_rootmountalloc: lookup a filesystem type, and if found allocate and 159 * initialize a mount structure for it. 160 * 161 * Devname is usually updated by mount(8) after booting. 162 */ 163 int 164 vfs_rootmountalloc(const char *fstypename, const char *devname, 165 struct mount **mpp) 166 { 167 struct vfsops *vfsp = NULL; 168 struct mount *mp; 169 170 mutex_enter(&vfs_list_lock); 171 LIST_FOREACH(vfsp, &vfs_list, vfs_list) 172 if (!strncmp(vfsp->vfs_name, fstypename, 173 sizeof(mp->mnt_stat.f_fstypename))) 174 break; 175 if (vfsp == NULL) { 176 mutex_exit(&vfs_list_lock); 177 return (ENODEV); 178 } 179 vfsp->vfs_refcount++; 180 mutex_exit(&vfs_list_lock); 181 182 if ((mp = vfs_mountalloc(vfsp, NULL)) == NULL) 183 return ENOMEM; 184 mp->mnt_flag = MNT_RDONLY; 185 (void)strlcpy(mp->mnt_stat.f_fstypename, vfsp->vfs_name, 186 sizeof(mp->mnt_stat.f_fstypename)); 187 mp->mnt_stat.f_mntonname[0] = '/'; 188 mp->mnt_stat.f_mntonname[1] = '\0'; 189 mp->mnt_stat.f_mntfromname[sizeof(mp->mnt_stat.f_mntfromname) - 1] = 190 '\0'; 191 (void)copystr(devname, mp->mnt_stat.f_mntfromname, 192 sizeof(mp->mnt_stat.f_mntfromname) - 1, 0); 193 *mpp = mp; 194 return 0; 195 } 196 197 /* 198 * vfs_getnewfsid: get a new unique fsid. 199 */ 200 void 201 vfs_getnewfsid(struct mount *mp) 202 { 203 static u_short xxxfs_mntid; 204 fsid_t tfsid; 205 int mtype; 206 207 mutex_enter(&mntid_lock); 208 mtype = makefstype(mp->mnt_op->vfs_name); 209 mp->mnt_stat.f_fsidx.__fsid_val[0] = makedev(mtype, 0); 210 mp->mnt_stat.f_fsidx.__fsid_val[1] = mtype; 211 mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0]; 212 if (xxxfs_mntid == 0) 213 ++xxxfs_mntid; 214 tfsid.__fsid_val[0] = makedev(mtype & 0xff, xxxfs_mntid); 215 tfsid.__fsid_val[1] = mtype; 216 if (!TAILQ_EMPTY(&mountlist)) { 217 while (vfs_getvfs(&tfsid)) { 218 tfsid.__fsid_val[0]++; 219 xxxfs_mntid++; 220 } 221 } 222 mp->mnt_stat.f_fsidx.__fsid_val[0] = tfsid.__fsid_val[0]; 223 mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0]; 224 mutex_exit(&mntid_lock); 225 } 226 227 /* 228 * Lookup a mount point by filesystem identifier. 229 * 230 * XXX Needs to add a reference to the mount point. 231 */ 232 struct mount * 233 vfs_getvfs(fsid_t *fsid) 234 { 235 struct mount *mp; 236 237 mutex_enter(&mountlist_lock); 238 TAILQ_FOREACH(mp, &mountlist, mnt_list) { 239 if (mp->mnt_stat.f_fsidx.__fsid_val[0] == fsid->__fsid_val[0] && 240 mp->mnt_stat.f_fsidx.__fsid_val[1] == fsid->__fsid_val[1]) { 241 mutex_exit(&mountlist_lock); 242 return (mp); 243 } 244 } 245 mutex_exit(&mountlist_lock); 246 return NULL; 247 } 248 249 /* 250 * Drop a reference to a mount structure, freeing if the last reference. 251 */ 252 void 253 vfs_destroy(struct mount *mp) 254 { 255 256 if (__predict_true((int)atomic_dec_uint_nv(&mp->mnt_refcnt) > 0)) { 257 return; 258 } 259 260 /* 261 * Nothing else has visibility of the mount: we can now 262 * free the data structures. 263 */ 264 KASSERT(mp->mnt_refcnt == 0); 265 specificdata_fini(mount_specificdata_domain, &mp->mnt_specdataref); 266 mutex_destroy(&mp->mnt_unmounting); 267 mutex_destroy(&mp->mnt_updating); 268 mutex_destroy(&mp->mnt_renamelock); 269 if (mp->mnt_op != NULL) { 270 vfs_delref(mp->mnt_op); 271 } 272 kmem_free(mp, sizeof(*mp)); 273 } 274 275 /* 276 * Mark a mount point as busy, and gain a new reference to it. Used to 277 * prevent the file system from being unmounted during critical sections. 278 * 279 * vfs_busy can be called multiple times and by multiple threads 280 * and must be accompanied by the same number of vfs_unbusy calls. 281 * 282 * => The caller must hold a pre-existing reference to the mount. 283 * => Will fail if the file system is being unmounted, or is unmounted. 284 */ 285 int 286 vfs_busy(struct mount *mp, struct mount **nextp) 287 { 288 289 KASSERT(mp->mnt_refcnt > 0); 290 291 mutex_enter(&mp->mnt_unmounting); 292 if (__predict_false((mp->mnt_iflag & IMNT_GONE) != 0)) { 293 mutex_exit(&mp->mnt_unmounting); 294 if (nextp != NULL) { 295 KASSERT(mutex_owned(&mountlist_lock)); 296 *nextp = TAILQ_NEXT(mp, mnt_list); 297 } 298 return ENOENT; 299 } 300 ++mp->mnt_busynest; 301 KASSERT(mp->mnt_busynest != 0); 302 mutex_exit(&mp->mnt_unmounting); 303 if (nextp != NULL) { 304 mutex_exit(&mountlist_lock); 305 } 306 atomic_inc_uint(&mp->mnt_refcnt); 307 return 0; 308 } 309 310 /* 311 * Unbusy a busy filesystem. 312 * 313 * Every successful vfs_busy() call must be undone by a vfs_unbusy() call. 314 * 315 * => If keepref is true, preserve reference added by vfs_busy(). 316 * => If nextp != NULL, acquire mountlist_lock. 317 */ 318 void 319 vfs_unbusy(struct mount *mp, bool keepref, struct mount **nextp) 320 { 321 322 KASSERT(mp->mnt_refcnt > 0); 323 324 if (nextp != NULL) { 325 mutex_enter(&mountlist_lock); 326 } 327 mutex_enter(&mp->mnt_unmounting); 328 KASSERT(mp->mnt_busynest != 0); 329 mp->mnt_busynest--; 330 mutex_exit(&mp->mnt_unmounting); 331 if (!keepref) { 332 vfs_destroy(mp); 333 } 334 if (nextp != NULL) { 335 KASSERT(mutex_owned(&mountlist_lock)); 336 *nextp = TAILQ_NEXT(mp, mnt_list); 337 } 338 } 339 340 struct vnode_iterator { 341 struct vnode vi_vnode; 342 }; 343 344 void 345 vfs_vnode_iterator_init(struct mount *mp, struct vnode_iterator **vip) 346 { 347 struct vnode *vp; 348 349 vp = vnalloc(mp); 350 351 mutex_enter(&mntvnode_lock); 352 TAILQ_INSERT_HEAD(&mp->mnt_vnodelist, vp, v_mntvnodes); 353 vp->v_usecount = 1; 354 mutex_exit(&mntvnode_lock); 355 356 *vip = (struct vnode_iterator *)vp; 357 } 358 359 void 360 vfs_vnode_iterator_destroy(struct vnode_iterator *vi) 361 { 362 struct vnode *mvp = &vi->vi_vnode; 363 364 mutex_enter(&mntvnode_lock); 365 KASSERT(ISSET(mvp->v_iflag, VI_MARKER)); 366 if (mvp->v_usecount != 0) { 367 TAILQ_REMOVE(&mvp->v_mount->mnt_vnodelist, mvp, v_mntvnodes); 368 mvp->v_usecount = 0; 369 } 370 mutex_exit(&mntvnode_lock); 371 vnfree(mvp); 372 } 373 374 struct vnode * 375 vfs_vnode_iterator_next(struct vnode_iterator *vi, 376 bool (*f)(void *, struct vnode *), void *cl) 377 { 378 struct vnode *mvp = &vi->vi_vnode; 379 struct mount *mp = mvp->v_mount; 380 struct vnode *vp; 381 int error; 382 383 KASSERT(ISSET(mvp->v_iflag, VI_MARKER)); 384 385 do { 386 mutex_enter(&mntvnode_lock); 387 vp = TAILQ_NEXT(mvp, v_mntvnodes); 388 TAILQ_REMOVE(&mp->mnt_vnodelist, mvp, v_mntvnodes); 389 mvp->v_usecount = 0; 390 again: 391 if (vp == NULL) { 392 mutex_exit(&mntvnode_lock); 393 return NULL; 394 } 395 mutex_enter(vp->v_interlock); 396 if (ISSET(vp->v_iflag, VI_MARKER) || 397 ISSET(vp->v_iflag, VI_XLOCK) || 398 (f && !(*f)(cl, vp))) { 399 mutex_exit(vp->v_interlock); 400 vp = TAILQ_NEXT(vp, v_mntvnodes); 401 goto again; 402 } 403 404 TAILQ_INSERT_AFTER(&mp->mnt_vnodelist, vp, mvp, v_mntvnodes); 405 mvp->v_usecount = 1; 406 mutex_exit(&mntvnode_lock); 407 error = vget(vp, 0, true /* wait */); 408 KASSERT(error == 0 || error == ENOENT); 409 } while (error != 0); 410 411 return vp; 412 } 413 414 /* 415 * Move a vnode from one mount queue to another. 416 */ 417 void 418 vfs_insmntque(vnode_t *vp, struct mount *mp) 419 { 420 struct mount *omp; 421 422 KASSERT(mp == NULL || (mp->mnt_iflag & IMNT_UNMOUNT) == 0 || 423 vp->v_tag == VT_VFS); 424 425 mutex_enter(&mntvnode_lock); 426 /* 427 * Delete from old mount point vnode list, if on one. 428 */ 429 if ((omp = vp->v_mount) != NULL) 430 TAILQ_REMOVE(&vp->v_mount->mnt_vnodelist, vp, v_mntvnodes); 431 /* 432 * Insert into list of vnodes for the new mount point, if 433 * available. The caller must take a reference on the mount 434 * structure and donate to the vnode. 435 */ 436 if ((vp->v_mount = mp) != NULL) 437 TAILQ_INSERT_TAIL(&mp->mnt_vnodelist, vp, v_mntvnodes); 438 mutex_exit(&mntvnode_lock); 439 440 if (omp != NULL) { 441 /* Release reference to old mount. */ 442 vfs_destroy(omp); 443 } 444 } 445 446 /* 447 * Remove any vnodes in the vnode table belonging to mount point mp. 448 * 449 * If FORCECLOSE is not specified, there should not be any active ones, 450 * return error if any are found (nb: this is a user error, not a 451 * system error). If FORCECLOSE is specified, detach any active vnodes 452 * that are found. 453 * 454 * If WRITECLOSE is set, only flush out regular file vnodes open for 455 * writing. 456 * 457 * SKIPSYSTEM causes any vnodes marked VV_SYSTEM to be skipped. 458 */ 459 #ifdef DEBUG 460 int busyprt = 0; /* print out busy vnodes */ 461 struct ctldebug debug1 = { "busyprt", &busyprt }; 462 #endif 463 464 struct vflush_ctx { 465 const struct vnode *skipvp; 466 int flags; 467 }; 468 469 static bool 470 vflush_selector(void *cl, struct vnode *vp) 471 { 472 struct vflush_ctx *c = cl; 473 /* 474 * Skip over a selected vnode. 475 */ 476 if (vp == c->skipvp) 477 return false; 478 /* 479 * Skip over a vnodes marked VSYSTEM. 480 */ 481 if ((c->flags & SKIPSYSTEM) && (vp->v_vflag & VV_SYSTEM)) 482 return false; 483 484 /* 485 * If WRITECLOSE is set, only flush out regular file 486 * vnodes open for writing. 487 */ 488 if ((c->flags & WRITECLOSE) && vp->v_type == VREG) { 489 if (vp->v_writecount == 0) 490 return false; 491 } 492 return true; 493 } 494 495 static vnode_t * 496 vflushnext(struct vnode_iterator *marker, void *ctx, int *when) 497 { 498 if (hardclock_ticks > *when) { 499 yield(); 500 *when = hardclock_ticks + hz / 10; 501 } 502 return vfs_vnode_iterator_next(marker, vflush_selector, ctx); 503 } 504 505 506 int 507 vflush(struct mount *mp, vnode_t *skipvp, int flags) 508 { 509 vnode_t *vp; 510 struct vnode_iterator *marker; 511 int error, busy = 0, when = 0; 512 struct vflush_ctx ctx; 513 514 /* First, flush out any vnode references from vrele_list. */ 515 vrele_flush(); 516 517 vfs_vnode_iterator_init(mp, &marker); 518 519 ctx.skipvp = skipvp; 520 ctx.flags = flags; 521 while ((vp = vflushnext(marker, &ctx, &when)) != NULL) { 522 /* 523 * First try to recycle the vnode. 524 */ 525 if (vrecycle(vp)) 526 continue; 527 /* 528 * If FORCECLOSE is set, forcibly close the vnode. 529 */ 530 if (flags & FORCECLOSE) { 531 vgone(vp); 532 continue; 533 } 534 #ifdef DEBUG 535 if (busyprt) 536 vprint("vflush: busy vnode", vp); 537 #endif 538 vrele(vp); 539 busy++; 540 } 541 vfs_vnode_iterator_destroy(marker); 542 if (busy) 543 return (EBUSY); 544 545 /* Wait for all vnodes to be reclaimed. */ 546 for (;;) { 547 mutex_enter(&mntvnode_lock); 548 TAILQ_FOREACH(vp, &mp->mnt_vnodelist, v_mntvnodes) { 549 if (vp == skipvp) 550 continue; 551 if ((flags & SKIPSYSTEM) && (vp->v_vflag & VV_SYSTEM)) 552 continue; 553 break; 554 } 555 if (vp != NULL) { 556 mutex_enter(vp->v_interlock); 557 mutex_exit(&mntvnode_lock); 558 error = vget(vp, 0, true /* wait */); 559 if (error == ENOENT) 560 continue; 561 else if (error == 0) 562 vrele(vp); 563 return EBUSY; 564 } else { 565 mutex_exit(&mntvnode_lock); 566 return 0; 567 } 568 } 569 } 570 571 /* 572 * Mount a file system. 573 */ 574 575 /* 576 * Scan all active processes to see if any of them have a current or root 577 * directory onto which the new filesystem has just been mounted. If so, 578 * replace them with the new mount point. 579 */ 580 static void 581 mount_checkdirs(vnode_t *olddp) 582 { 583 vnode_t *newdp, *rele1, *rele2; 584 struct cwdinfo *cwdi; 585 struct proc *p; 586 bool retry; 587 588 if (olddp->v_usecount == 1) { 589 return; 590 } 591 if (VFS_ROOT(olddp->v_mountedhere, &newdp)) 592 panic("mount: lost mount"); 593 594 do { 595 retry = false; 596 mutex_enter(proc_lock); 597 PROCLIST_FOREACH(p, &allproc) { 598 if ((cwdi = p->p_cwdi) == NULL) 599 continue; 600 /* 601 * Cannot change to the old directory any more, 602 * so even if we see a stale value it is not a 603 * problem. 604 */ 605 if (cwdi->cwdi_cdir != olddp && 606 cwdi->cwdi_rdir != olddp) 607 continue; 608 retry = true; 609 rele1 = NULL; 610 rele2 = NULL; 611 atomic_inc_uint(&cwdi->cwdi_refcnt); 612 mutex_exit(proc_lock); 613 rw_enter(&cwdi->cwdi_lock, RW_WRITER); 614 if (cwdi->cwdi_cdir == olddp) { 615 rele1 = cwdi->cwdi_cdir; 616 vref(newdp); 617 cwdi->cwdi_cdir = newdp; 618 } 619 if (cwdi->cwdi_rdir == olddp) { 620 rele2 = cwdi->cwdi_rdir; 621 vref(newdp); 622 cwdi->cwdi_rdir = newdp; 623 } 624 rw_exit(&cwdi->cwdi_lock); 625 cwdfree(cwdi); 626 if (rele1 != NULL) 627 vrele(rele1); 628 if (rele2 != NULL) 629 vrele(rele2); 630 mutex_enter(proc_lock); 631 break; 632 } 633 mutex_exit(proc_lock); 634 } while (retry); 635 636 if (rootvnode == olddp) { 637 vrele(rootvnode); 638 vref(newdp); 639 rootvnode = newdp; 640 } 641 vput(newdp); 642 } 643 644 /* 645 * Start extended attributes 646 */ 647 static int 648 start_extattr(struct mount *mp) 649 { 650 int error; 651 652 error = VFS_EXTATTRCTL(mp, EXTATTR_CMD_START, NULL, 0, NULL); 653 if (error) 654 printf("%s: failed to start extattr: error = %d\n", 655 mp->mnt_stat.f_mntonname, error); 656 657 return error; 658 } 659 660 int 661 mount_domount(struct lwp *l, vnode_t **vpp, struct vfsops *vfsops, 662 const char *path, int flags, void *data, size_t *data_len) 663 { 664 vnode_t *vp = *vpp; 665 struct mount *mp; 666 struct pathbuf *pb; 667 struct nameidata nd; 668 int error; 669 670 error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_MOUNT, 671 KAUTH_REQ_SYSTEM_MOUNT_NEW, vp, KAUTH_ARG(flags), data); 672 if (error) { 673 vfs_delref(vfsops); 674 return error; 675 } 676 677 /* Cannot make a non-dir a mount-point (from here anyway). */ 678 if (vp->v_type != VDIR) { 679 vfs_delref(vfsops); 680 return ENOTDIR; 681 } 682 683 if (flags & MNT_EXPORTED) { 684 vfs_delref(vfsops); 685 return EINVAL; 686 } 687 688 if ((mp = vfs_mountalloc(vfsops, vp)) == NULL) { 689 vfs_delref(vfsops); 690 return ENOMEM; 691 } 692 693 mp->mnt_stat.f_owner = kauth_cred_geteuid(l->l_cred); 694 695 /* 696 * The underlying file system may refuse the mount for 697 * various reasons. Allow the user to force it to happen. 698 * 699 * Set the mount level flags. 700 */ 701 mp->mnt_flag = flags & (MNT_BASIC_FLAGS | MNT_FORCE | MNT_IGNORE); 702 703 mutex_enter(&mp->mnt_updating); 704 error = VFS_MOUNT(mp, path, data, data_len); 705 mp->mnt_flag &= ~MNT_OP_FLAGS; 706 707 if (error != 0) 708 goto err_unmounted; 709 710 /* 711 * Validate and prepare the mount point. 712 */ 713 error = pathbuf_copyin(path, &pb); 714 if (error != 0) { 715 goto err_mounted; 716 } 717 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | TRYEMULROOT, pb); 718 error = namei(&nd); 719 pathbuf_destroy(pb); 720 if (error != 0) { 721 goto err_mounted; 722 } 723 if (nd.ni_vp != vp) { 724 vput(nd.ni_vp); 725 error = EINVAL; 726 goto err_mounted; 727 } 728 if (vp->v_mountedhere != NULL) { 729 vput(nd.ni_vp); 730 error = EBUSY; 731 goto err_mounted; 732 } 733 error = vinvalbuf(vp, V_SAVE, l->l_cred, l, 0, 0); 734 if (error != 0) { 735 vput(nd.ni_vp); 736 goto err_mounted; 737 } 738 739 /* 740 * Put the new filesystem on the mount list after root. 741 */ 742 cache_purge(vp); 743 mp->mnt_iflag &= ~IMNT_WANTRDWR; 744 745 mutex_enter(&mountlist_lock); 746 TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list); 747 mutex_exit(&mountlist_lock); 748 if ((mp->mnt_flag & (MNT_RDONLY | MNT_ASYNC)) == 0) 749 vfs_syncer_add_to_worklist(mp); 750 vp->v_mountedhere = mp; 751 vput(nd.ni_vp); 752 753 mount_checkdirs(vp); 754 mutex_exit(&mp->mnt_updating); 755 756 /* Hold an additional reference to the mount across VFS_START(). */ 757 vfs_unbusy(mp, true, NULL); 758 (void) VFS_STATVFS(mp, &mp->mnt_stat); 759 error = VFS_START(mp, 0); 760 if (error) { 761 vrele(vp); 762 } else if (flags & MNT_EXTATTR) { 763 (void)start_extattr(mp); 764 } 765 /* Drop reference held for VFS_START(). */ 766 vfs_destroy(mp); 767 *vpp = NULL; 768 return error; 769 770 err_mounted: 771 if (VFS_UNMOUNT(mp, MNT_FORCE) != 0) 772 panic("Unmounting fresh file system failed"); 773 774 err_unmounted: 775 vp->v_mountedhere = NULL; 776 mutex_exit(&mp->mnt_updating); 777 vfs_unbusy(mp, false, NULL); 778 vfs_destroy(mp); 779 780 return error; 781 } 782 783 /* 784 * Do the actual file system unmount. File system is assumed to have 785 * been locked by the caller. 786 * 787 * => Caller hold reference to the mount, explicitly for dounmount(). 788 */ 789 int 790 dounmount(struct mount *mp, int flags, struct lwp *l) 791 { 792 vnode_t *coveredvp; 793 int error, async, used_syncer, used_extattr; 794 795 #if NVERIEXEC > 0 796 error = veriexec_unmountchk(mp); 797 if (error) 798 return (error); 799 #endif /* NVERIEXEC > 0 */ 800 801 /* 802 * XXX Freeze syncer. Must do this before locking the 803 * mount point. See dounmount() for details. 804 */ 805 mutex_enter(&syncer_mutex); 806 807 /* 808 * Abort unmount attempt when the filesystem is in use 809 */ 810 mutex_enter(&mp->mnt_unmounting); 811 if (mp->mnt_busynest != 0) { 812 mutex_exit(&mp->mnt_unmounting); 813 mutex_exit(&syncer_mutex); 814 return EBUSY; 815 } 816 817 /* 818 * Abort unmount attempt when the filesystem is not mounted 819 */ 820 if ((mp->mnt_iflag & IMNT_GONE) != 0) { 821 mutex_exit(&mp->mnt_unmounting); 822 mutex_exit(&syncer_mutex); 823 return ENOENT; 824 } 825 826 used_syncer = (mp->mnt_iflag & IMNT_ONWORKLIST) != 0; 827 used_extattr = mp->mnt_flag & MNT_EXTATTR; 828 829 /* 830 * XXX Syncer must be frozen when we get here. This should really 831 * be done on a per-mountpoint basis, but the syncer doesn't work 832 * like that. 833 * 834 * The caller of dounmount() must acquire syncer_mutex because 835 * the syncer itself acquires locks in syncer_mutex -> vfs_busy 836 * order, and we must preserve that order to avoid deadlock. 837 * 838 * So, if the file system did not use the syncer, now is 839 * the time to release the syncer_mutex. 840 */ 841 if (used_syncer == 0) { 842 mutex_exit(&syncer_mutex); 843 } 844 mp->mnt_iflag |= IMNT_UNMOUNT; 845 mutex_enter(&mp->mnt_updating); 846 async = mp->mnt_flag & MNT_ASYNC; 847 mp->mnt_flag &= ~MNT_ASYNC; 848 cache_purgevfs(mp); /* remove cache entries for this file sys */ 849 if (used_syncer) 850 vfs_syncer_remove_from_worklist(mp); 851 error = 0; 852 if (((mp->mnt_flag & MNT_RDONLY) == 0) && ((flags & MNT_FORCE) == 0)) { 853 error = VFS_SYNC(mp, MNT_WAIT, l->l_cred); 854 } 855 if (error == 0 || (flags & MNT_FORCE)) { 856 error = VFS_UNMOUNT(mp, flags); 857 } 858 if (error) { 859 mp->mnt_iflag &= ~IMNT_UNMOUNT; 860 mutex_exit(&mp->mnt_unmounting); 861 if ((mp->mnt_flag & (MNT_RDONLY | MNT_ASYNC)) == 0) 862 vfs_syncer_add_to_worklist(mp); 863 mp->mnt_flag |= async; 864 mutex_exit(&mp->mnt_updating); 865 if (used_syncer) 866 mutex_exit(&syncer_mutex); 867 if (used_extattr) { 868 if (start_extattr(mp) != 0) 869 mp->mnt_flag &= ~MNT_EXTATTR; 870 else 871 mp->mnt_flag |= MNT_EXTATTR; 872 } 873 return (error); 874 } 875 mutex_exit(&mp->mnt_updating); 876 877 /* 878 * release mnt_umounting lock here, because other code calls 879 * vfs_busy() while holding the mountlist_lock. 880 * 881 * mark filesystem as gone to prevent further umounts 882 * after mnt_umounting lock is gone, this also prevents 883 * vfs_busy() from succeeding. 884 */ 885 mp->mnt_iflag |= IMNT_GONE; 886 mutex_exit(&mp->mnt_unmounting); 887 888 if ((coveredvp = mp->mnt_vnodecovered) != NULLVP) { 889 vn_lock(coveredvp, LK_EXCLUSIVE | LK_RETRY); 890 coveredvp->v_mountedhere = NULL; 891 VOP_UNLOCK(coveredvp); 892 } 893 mutex_enter(&mountlist_lock); 894 TAILQ_REMOVE(&mountlist, mp, mnt_list); 895 mutex_exit(&mountlist_lock); 896 if (TAILQ_FIRST(&mp->mnt_vnodelist) != NULL) 897 panic("unmount: dangling vnode"); 898 if (used_syncer) 899 mutex_exit(&syncer_mutex); 900 vfs_hooks_unmount(mp); 901 902 vfs_destroy(mp); /* reference from mount() */ 903 if (coveredvp != NULLVP) { 904 vrele(coveredvp); 905 } 906 return (0); 907 } 908 909 /* 910 * Unmount all file systems. 911 * We traverse the list in reverse order under the assumption that doing so 912 * will avoid needing to worry about dependencies. 913 */ 914 bool 915 vfs_unmountall(struct lwp *l) 916 { 917 918 printf("unmounting file systems...\n"); 919 return vfs_unmountall1(l, true, true); 920 } 921 922 static void 923 vfs_unmount_print(struct mount *mp, const char *pfx) 924 { 925 926 aprint_verbose("%sunmounted %s on %s type %s\n", pfx, 927 mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname, 928 mp->mnt_stat.f_fstypename); 929 } 930 931 bool 932 vfs_unmount_forceone(struct lwp *l) 933 { 934 struct mount *mp, *nmp; 935 int error; 936 937 nmp = NULL; 938 939 TAILQ_FOREACH_REVERSE(mp, &mountlist, mntlist, mnt_list) { 940 if (nmp == NULL || mp->mnt_gen > nmp->mnt_gen) { 941 nmp = mp; 942 } 943 } 944 if (nmp == NULL) { 945 return false; 946 } 947 948 #ifdef DEBUG 949 printf("forcefully unmounting %s (%s)...\n", 950 nmp->mnt_stat.f_mntonname, nmp->mnt_stat.f_mntfromname); 951 #endif 952 atomic_inc_uint(&nmp->mnt_refcnt); 953 if ((error = dounmount(nmp, MNT_FORCE, l)) == 0) { 954 vfs_unmount_print(nmp, "forcefully "); 955 return true; 956 } else { 957 vfs_destroy(nmp); 958 } 959 960 #ifdef DEBUG 961 printf("forceful unmount of %s failed with error %d\n", 962 nmp->mnt_stat.f_mntonname, error); 963 #endif 964 965 return false; 966 } 967 968 bool 969 vfs_unmountall1(struct lwp *l, bool force, bool verbose) 970 { 971 struct mount *mp, *nmp; 972 bool any_error = false, progress = false; 973 int error; 974 975 TAILQ_FOREACH_REVERSE_SAFE(mp, &mountlist, mntlist, mnt_list, nmp) { 976 #ifdef DEBUG 977 printf("unmounting %p %s (%s)...\n", 978 (void *)mp, mp->mnt_stat.f_mntonname, 979 mp->mnt_stat.f_mntfromname); 980 #endif 981 atomic_inc_uint(&mp->mnt_refcnt); 982 if ((error = dounmount(mp, force ? MNT_FORCE : 0, l)) == 0) { 983 vfs_unmount_print(mp, ""); 984 progress = true; 985 } else { 986 vfs_destroy(mp); 987 if (verbose) { 988 printf("unmount of %s failed with error %d\n", 989 mp->mnt_stat.f_mntonname, error); 990 } 991 any_error = true; 992 } 993 } 994 if (verbose) { 995 printf("unmounting done\n"); 996 } 997 if (any_error && verbose) { 998 printf("WARNING: some file systems would not unmount\n"); 999 } 1000 return progress; 1001 } 1002 1003 void 1004 vfs_sync_all(struct lwp *l) 1005 { 1006 printf("syncing disks... "); 1007 1008 /* remove user processes from run queue */ 1009 suspendsched(); 1010 (void)spl0(); 1011 1012 /* avoid coming back this way again if we panic. */ 1013 doing_shutdown = 1; 1014 1015 do_sys_sync(l); 1016 1017 /* Wait for sync to finish. */ 1018 if (buf_syncwait() != 0) { 1019 #if defined(DDB) && defined(DEBUG_HALT_BUSY) 1020 Debugger(); 1021 #endif 1022 printf("giving up\n"); 1023 return; 1024 } else 1025 printf("done\n"); 1026 } 1027 1028 /* 1029 * Sync and unmount file systems before shutting down. 1030 */ 1031 void 1032 vfs_shutdown(void) 1033 { 1034 lwp_t *l = curlwp; 1035 1036 vfs_sync_all(l); 1037 1038 /* 1039 * If we have paniced - do not make the situation potentially 1040 * worse by unmounting the file systems. 1041 */ 1042 if (panicstr != NULL) { 1043 return; 1044 } 1045 1046 /* Unmount file systems. */ 1047 vfs_unmountall(l); 1048 } 1049 1050 /* 1051 * Print a list of supported file system types (used by vfs_mountroot) 1052 */ 1053 static void 1054 vfs_print_fstypes(void) 1055 { 1056 struct vfsops *v; 1057 int cnt = 0; 1058 1059 mutex_enter(&vfs_list_lock); 1060 LIST_FOREACH(v, &vfs_list, vfs_list) 1061 ++cnt; 1062 mutex_exit(&vfs_list_lock); 1063 1064 if (cnt == 0) { 1065 printf("WARNING: No file system modules have been loaded.\n"); 1066 return; 1067 } 1068 1069 printf("Supported file systems:"); 1070 mutex_enter(&vfs_list_lock); 1071 LIST_FOREACH(v, &vfs_list, vfs_list) { 1072 printf(" %s", v->vfs_name); 1073 } 1074 mutex_exit(&vfs_list_lock); 1075 printf("\n"); 1076 } 1077 1078 /* 1079 * Mount the root file system. If the operator didn't specify a 1080 * file system to use, try all possible file systems until one 1081 * succeeds. 1082 */ 1083 int 1084 vfs_mountroot(void) 1085 { 1086 struct vfsops *v; 1087 int error = ENODEV; 1088 1089 if (root_device == NULL) 1090 panic("vfs_mountroot: root device unknown"); 1091 1092 switch (device_class(root_device)) { 1093 case DV_IFNET: 1094 if (rootdev != NODEV) 1095 panic("vfs_mountroot: rootdev set for DV_IFNET " 1096 "(0x%llx -> %llu,%llu)", 1097 (unsigned long long)rootdev, 1098 (unsigned long long)major(rootdev), 1099 (unsigned long long)minor(rootdev)); 1100 break; 1101 1102 case DV_DISK: 1103 if (rootdev == NODEV) 1104 panic("vfs_mountroot: rootdev not set for DV_DISK"); 1105 if (bdevvp(rootdev, &rootvp)) 1106 panic("vfs_mountroot: can't get vnode for rootdev"); 1107 error = VOP_OPEN(rootvp, FREAD, FSCRED); 1108 if (error) { 1109 printf("vfs_mountroot: can't open root device\n"); 1110 return (error); 1111 } 1112 break; 1113 1114 case DV_VIRTUAL: 1115 break; 1116 1117 default: 1118 printf("%s: inappropriate for root file system\n", 1119 device_xname(root_device)); 1120 return (ENODEV); 1121 } 1122 1123 /* 1124 * If user specified a root fs type, use it. Make sure the 1125 * specified type exists and has a mount_root() 1126 */ 1127 if (strcmp(rootfstype, ROOT_FSTYPE_ANY) != 0) { 1128 v = vfs_getopsbyname(rootfstype); 1129 error = EFTYPE; 1130 if (v != NULL) { 1131 if (v->vfs_mountroot != NULL) { 1132 error = (v->vfs_mountroot)(); 1133 } 1134 v->vfs_refcount--; 1135 } 1136 goto done; 1137 } 1138 1139 /* 1140 * Try each file system currently configured into the kernel. 1141 */ 1142 mutex_enter(&vfs_list_lock); 1143 LIST_FOREACH(v, &vfs_list, vfs_list) { 1144 if (v->vfs_mountroot == NULL) 1145 continue; 1146 #ifdef DEBUG 1147 aprint_normal("mountroot: trying %s...\n", v->vfs_name); 1148 #endif 1149 v->vfs_refcount++; 1150 mutex_exit(&vfs_list_lock); 1151 error = (*v->vfs_mountroot)(); 1152 mutex_enter(&vfs_list_lock); 1153 v->vfs_refcount--; 1154 if (!error) { 1155 aprint_normal("root file system type: %s\n", 1156 v->vfs_name); 1157 break; 1158 } 1159 } 1160 mutex_exit(&vfs_list_lock); 1161 1162 if (v == NULL) { 1163 vfs_print_fstypes(); 1164 printf("no file system for %s", device_xname(root_device)); 1165 if (device_class(root_device) == DV_DISK) 1166 printf(" (dev 0x%llx)", (unsigned long long)rootdev); 1167 printf("\n"); 1168 error = EFTYPE; 1169 } 1170 1171 done: 1172 if (error && device_class(root_device) == DV_DISK) { 1173 VOP_CLOSE(rootvp, FREAD, FSCRED); 1174 vrele(rootvp); 1175 } 1176 if (error == 0) { 1177 struct mount *mp; 1178 extern struct cwdinfo cwdi0; 1179 1180 mp = TAILQ_FIRST(&mountlist); 1181 mp->mnt_flag |= MNT_ROOTFS; 1182 mp->mnt_op->vfs_refcount++; 1183 1184 /* 1185 * Get the vnode for '/'. Set cwdi0.cwdi_cdir to 1186 * reference it. 1187 */ 1188 error = VFS_ROOT(mp, &rootvnode); 1189 if (error) 1190 panic("cannot find root vnode, error=%d", error); 1191 cwdi0.cwdi_cdir = rootvnode; 1192 vref(cwdi0.cwdi_cdir); 1193 VOP_UNLOCK(rootvnode); 1194 cwdi0.cwdi_rdir = NULL; 1195 1196 /* 1197 * Now that root is mounted, we can fixup initproc's CWD 1198 * info. All other processes are kthreads, which merely 1199 * share proc0's CWD info. 1200 */ 1201 initproc->p_cwdi->cwdi_cdir = rootvnode; 1202 vref(initproc->p_cwdi->cwdi_cdir); 1203 initproc->p_cwdi->cwdi_rdir = NULL; 1204 /* 1205 * Enable loading of modules from the filesystem 1206 */ 1207 module_load_vfs_init(); 1208 1209 } 1210 return (error); 1211 } 1212 1213 /* 1214 * mount_specific_key_create -- 1215 * Create a key for subsystem mount-specific data. 1216 */ 1217 int 1218 mount_specific_key_create(specificdata_key_t *keyp, specificdata_dtor_t dtor) 1219 { 1220 1221 return specificdata_key_create(mount_specificdata_domain, keyp, dtor); 1222 } 1223 1224 /* 1225 * mount_specific_key_delete -- 1226 * Delete a key for subsystem mount-specific data. 1227 */ 1228 void 1229 mount_specific_key_delete(specificdata_key_t key) 1230 { 1231 1232 specificdata_key_delete(mount_specificdata_domain, key); 1233 } 1234 1235 /* 1236 * mount_initspecific -- 1237 * Initialize a mount's specificdata container. 1238 */ 1239 void 1240 mount_initspecific(struct mount *mp) 1241 { 1242 int error __diagused; 1243 1244 error = specificdata_init(mount_specificdata_domain, 1245 &mp->mnt_specdataref); 1246 KASSERT(error == 0); 1247 } 1248 1249 /* 1250 * mount_finispecific -- 1251 * Finalize a mount's specificdata container. 1252 */ 1253 void 1254 mount_finispecific(struct mount *mp) 1255 { 1256 1257 specificdata_fini(mount_specificdata_domain, &mp->mnt_specdataref); 1258 } 1259 1260 /* 1261 * mount_getspecific -- 1262 * Return mount-specific data corresponding to the specified key. 1263 */ 1264 void * 1265 mount_getspecific(struct mount *mp, specificdata_key_t key) 1266 { 1267 1268 return specificdata_getspecific(mount_specificdata_domain, 1269 &mp->mnt_specdataref, key); 1270 } 1271 1272 /* 1273 * mount_setspecific -- 1274 * Set mount-specific data corresponding to the specified key. 1275 */ 1276 void 1277 mount_setspecific(struct mount *mp, specificdata_key_t key, void *data) 1278 { 1279 1280 specificdata_setspecific(mount_specificdata_domain, 1281 &mp->mnt_specdataref, key, data); 1282 } 1283 1284 /* 1285 * Check to see if a filesystem is mounted on a block device. 1286 */ 1287 int 1288 vfs_mountedon(vnode_t *vp) 1289 { 1290 vnode_t *vq; 1291 int error = 0; 1292 1293 if (vp->v_type != VBLK) 1294 return ENOTBLK; 1295 if (spec_node_getmountedfs(vp) != NULL) 1296 return EBUSY; 1297 if (spec_node_lookup_by_dev(vp->v_type, vp->v_rdev, &vq) == 0) { 1298 if (spec_node_getmountedfs(vq) != NULL) 1299 error = EBUSY; 1300 vrele(vq); 1301 } 1302 1303 return error; 1304 } 1305 1306 /* 1307 * Check if a device pointed to by vp is mounted. 1308 * 1309 * Returns: 1310 * EINVAL if it's not a disk 1311 * EBUSY if it's a disk and mounted 1312 * 0 if it's a disk and not mounted 1313 */ 1314 int 1315 rawdev_mounted(vnode_t *vp, vnode_t **bvpp) 1316 { 1317 vnode_t *bvp; 1318 dev_t dev; 1319 int d_type; 1320 1321 bvp = NULL; 1322 d_type = D_OTHER; 1323 1324 if (iskmemvp(vp)) 1325 return EINVAL; 1326 1327 switch (vp->v_type) { 1328 case VCHR: { 1329 const struct cdevsw *cdev; 1330 1331 dev = vp->v_rdev; 1332 cdev = cdevsw_lookup(dev); 1333 if (cdev != NULL) { 1334 dev_t blkdev; 1335 1336 blkdev = devsw_chr2blk(dev); 1337 if (blkdev != NODEV) { 1338 if (vfinddev(blkdev, VBLK, &bvp) != 0) { 1339 d_type = (cdev->d_flag & D_TYPEMASK); 1340 /* XXX: what if bvp disappears? */ 1341 vrele(bvp); 1342 } 1343 } 1344 } 1345 1346 break; 1347 } 1348 1349 case VBLK: { 1350 const struct bdevsw *bdev; 1351 1352 dev = vp->v_rdev; 1353 bdev = bdevsw_lookup(dev); 1354 if (bdev != NULL) 1355 d_type = (bdev->d_flag & D_TYPEMASK); 1356 1357 bvp = vp; 1358 1359 break; 1360 } 1361 1362 default: 1363 break; 1364 } 1365 1366 if (d_type != D_DISK) 1367 return EINVAL; 1368 1369 if (bvpp != NULL) 1370 *bvpp = bvp; 1371 1372 /* 1373 * XXX: This is bogus. We should be failing the request 1374 * XXX: not only if this specific slice is mounted, but 1375 * XXX: if it's on a disk with any other mounted slice. 1376 */ 1377 if (vfs_mountedon(bvp)) 1378 return EBUSY; 1379 1380 return 0; 1381 } 1382 1383 /* 1384 * Make a 'unique' number from a mount type name. 1385 */ 1386 long 1387 makefstype(const char *type) 1388 { 1389 long rv; 1390 1391 for (rv = 0; *type; type++) { 1392 rv <<= 2; 1393 rv ^= *type; 1394 } 1395 return rv; 1396 } 1397 1398 void 1399 mountlist_append(struct mount *mp) 1400 { 1401 mutex_enter(&mountlist_lock); 1402 TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list); 1403 mutex_exit(&mountlist_lock); 1404 } 1405