1 /* 2 * Copyright (c) 1989, 1991, 1993, 1994 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by the University of 16 * California, Berkeley and its contributors. 17 * 4. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * @(#)ffs_vfsops.c 8.31 (Berkeley) 5/20/95 34 * $FreeBSD: src/sys/ufs/ffs/ffs_vfsops.c,v 1.117.2.10 2002/06/23 22:34:52 iedowse Exp $ 35 * $DragonFly: src/sys/vfs/ufs/ffs_vfsops.c,v 1.46 2006/07/28 02:17:41 dillon Exp $ 36 */ 37 38 #include "opt_quota.h" 39 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/proc.h> 43 #include <sys/nlookup.h> 44 #include <sys/kernel.h> 45 #include <sys/vnode.h> 46 #include <sys/mount.h> 47 #include <sys/buf.h> 48 #include <sys/conf.h> 49 #include <sys/fcntl.h> 50 #include <sys/disklabel.h> 51 #include <sys/malloc.h> 52 53 #include "quota.h" 54 #include "ufsmount.h" 55 #include "inode.h" 56 #include "ufs_extern.h" 57 58 #include "fs.h" 59 #include "ffs_extern.h" 60 61 #include <vm/vm.h> 62 #include <vm/vm_page.h> 63 #include <vm/vm_zone.h> 64 65 static MALLOC_DEFINE(M_FFSNODE, "FFS node", "FFS vnode private part"); 66 67 static int ffs_sbupdate (struct ufsmount *, int); 68 static int ffs_reload (struct mount *, struct ucred *); 69 static int ffs_oldfscompat (struct fs *); 70 static int ffs_mount (struct mount *, char *, caddr_t, struct ucred *); 71 static int ffs_init (struct vfsconf *); 72 73 static struct vfsops ufs_vfsops = { 74 .vfs_mount = ffs_mount, 75 .vfs_unmount = ffs_unmount, 76 .vfs_root = ufs_root, 77 .vfs_quotactl = ufs_quotactl, 78 .vfs_statfs = ffs_statfs, 79 .vfs_sync = ffs_sync, 80 .vfs_vget = ffs_vget, 81 .vfs_fhtovp = ffs_fhtovp, 82 .vfs_checkexp = ufs_check_export, 83 .vfs_vptofh = ffs_vptofh, 84 .vfs_init = ffs_init, 85 .vfs_uninit = ufs_uninit 86 }; 87 88 VFS_SET(ufs_vfsops, ufs, 0); 89 90 extern struct vop_ops ffs_vnode_vops; 91 extern struct vop_ops ffs_spec_vops; 92 extern struct vop_ops ffs_fifo_vops; 93 94 /* 95 * ffs_mount 96 * 97 * Called when mounting local physical media 98 * 99 * PARAMETERS: 100 * mountroot 101 * mp mount point structure 102 * path NULL (flag for root mount!!!) 103 * data <unused> 104 * p process (user credentials check [statfs]) 105 * 106 * mount 107 * mp mount point structure 108 * path path to mount point 109 * data pointer to argument struct in user space 110 * p process (user credentials check) 111 * 112 * RETURNS: 0 Success 113 * !0 error number (errno.h) 114 * 115 * LOCK STATE: 116 * 117 * ENTRY 118 * mount point is locked 119 * EXIT 120 * mount point is locked 121 * 122 * NOTES: 123 * A NULL path can be used for a flag since the mount 124 * system call will fail with EFAULT in copyinstr in 125 * nlookup() if it is a genuine NULL from the user. 126 */ 127 static int 128 ffs_mount(struct mount *mp, /* mount struct pointer */ 129 char *path, /* path to mount point */ 130 caddr_t data, /* arguments to FS specific mount */ 131 struct ucred *cred) /* process requesting mount */ 132 { 133 size_t size; 134 int error; 135 struct vnode *devvp; 136 137 struct ufs_args args; 138 struct ufsmount *ump = 0; 139 struct fs *fs; 140 int flags, ronly = 0; 141 mode_t accessmode; 142 struct nlookupdata nd; 143 struct vnode *rootvp; 144 145 devvp = NULL; 146 error = 0; 147 148 /* 149 * Use NULL path to flag a root mount 150 */ 151 if (path == NULL) { 152 /* 153 *** 154 * Mounting root filesystem 155 *** 156 */ 157 158 if ((error = bdevvp(rootdev, &rootvp))) { 159 printf("ffs_mountroot: can't find rootvp\n"); 160 return (error); 161 } 162 163 if( ( error = ffs_mountfs(rootvp, mp, M_FFSNODE)) != 0) { 164 /* fs specific cleanup (if any)*/ 165 goto error_1; 166 } 167 devvp = rootvp; 168 169 goto dostatfs; /* success*/ 170 171 } 172 173 /* 174 *** 175 * Mounting non-root filesystem or updating a filesystem 176 *** 177 */ 178 179 /* copy in user arguments*/ 180 error = copyin(data, (caddr_t)&args, sizeof (struct ufs_args)); 181 if (error) 182 goto error_1; /* can't get arguments*/ 183 184 /* 185 * If updating, check whether changing from read-only to 186 * read/write; if there is no device name, that's all we do. 187 */ 188 if (mp->mnt_flag & MNT_UPDATE) { 189 ump = VFSTOUFS(mp); 190 fs = ump->um_fs; 191 devvp = ump->um_devvp; 192 error = 0; 193 ronly = fs->fs_ronly; /* MNT_RELOAD might change this */ 194 if (ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) { 195 /* 196 * Flush any dirty data. 197 */ 198 VFS_SYNC(mp, MNT_WAIT); 199 /* 200 * Check for and optionally get rid of files open 201 * for writing. 202 */ 203 flags = WRITECLOSE; 204 if (mp->mnt_flag & MNT_FORCE) 205 flags |= FORCECLOSE; 206 if (mp->mnt_flag & MNT_SOFTDEP) { 207 error = softdep_flushfiles(mp, flags); 208 } else { 209 error = ffs_flushfiles(mp, flags); 210 } 211 ronly = 1; 212 } 213 if (!error && (mp->mnt_flag & MNT_RELOAD)) { 214 error = ffs_reload(mp, NULL); 215 } 216 if (error) { 217 goto error_1; 218 } 219 if (ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) { 220 /* 221 * If upgrade to read-write by non-root, then verify 222 * that user has necessary permissions on the device. 223 */ 224 if (cred->cr_uid != 0) { 225 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 226 if ((error = VOP_ACCESS(devvp, VREAD | VWRITE, 227 cred)) != 0) { 228 VOP_UNLOCK(devvp, 0); 229 return (error); 230 } 231 VOP_UNLOCK(devvp, 0); 232 } 233 234 fs->fs_flags &= ~FS_UNCLEAN; 235 if (fs->fs_clean == 0) { 236 fs->fs_flags |= FS_UNCLEAN; 237 if (mp->mnt_flag & MNT_FORCE) { 238 printf( 239 "WARNING: %s was not properly dismounted\n", 240 fs->fs_fsmnt); 241 } else { 242 printf( 243 "WARNING: R/W mount of %s denied. Filesystem is not clean - run fsck\n", 244 fs->fs_fsmnt); 245 error = EPERM; 246 goto error_1; 247 } 248 } 249 250 /* check to see if we need to start softdep */ 251 if (fs->fs_flags & FS_DOSOFTDEP) { 252 error = softdep_mount(devvp, mp, fs); 253 if (error) 254 goto error_1; 255 } 256 ronly = 0; 257 } 258 /* 259 * Soft updates is incompatible with "async", 260 * so if we are doing softupdates stop the user 261 * from setting the async flag in an update. 262 * Softdep_mount() clears it in an initial mount 263 * or ro->rw remount. 264 */ 265 if (mp->mnt_flag & MNT_SOFTDEP) { 266 mp->mnt_flag &= ~MNT_ASYNC; 267 } 268 /* if not updating name...*/ 269 if (args.fspec == 0) { 270 /* 271 * Process export requests. Jumping to "success" 272 * will return the vfs_export() error code. 273 */ 274 error = vfs_export(mp, &ump->um_export, &args.export); 275 goto success; 276 } 277 } 278 279 /* 280 * Not an update, or updating the name: look up the name 281 * and verify that it refers to a sensible block device. 282 */ 283 devvp = NULL; 284 error = nlookup_init(&nd, args.fspec, UIO_USERSPACE, NLC_FOLLOW); 285 if (error == 0) 286 error = nlookup(&nd); 287 if (error == 0) 288 error = cache_vref(nd.nl_ncp, nd.nl_cred, &devvp); 289 nlookup_done(&nd); 290 if (error) 291 goto error_1; 292 293 if (!vn_isdisk(devvp, &error)) 294 goto error_2; 295 296 /* 297 * If mount by non-root, then verify that user has necessary 298 * permissions on the device. 299 */ 300 if (cred->cr_uid != 0) { 301 accessmode = VREAD; 302 if ((mp->mnt_flag & MNT_RDONLY) == 0) 303 accessmode |= VWRITE; 304 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 305 if ((error = VOP_ACCESS(devvp, accessmode, cred)) != 0) { 306 vput(devvp); 307 return (error); 308 } 309 VOP_UNLOCK(devvp, 0); 310 } 311 312 if (mp->mnt_flag & MNT_UPDATE) { 313 /* 314 * UPDATE - make sure the resolved vnode represents the same 315 * device. Note that devvp->v_rdev may be NULL since we 316 * haven't opened it, so compare udev instead. 317 * 318 * Our current open/writecount state is associated with 319 * um_devvp, so continue using um_devvp and throw away devvp. 320 */ 321 if (devvp != ump->um_devvp) { 322 if (devvp->v_udev == ump->um_devvp->v_udev) { 323 vrele(devvp); 324 devvp = ump->um_devvp; 325 } else { 326 printf("cannot update mount, udev does" 327 " not match %08x vs %08x\n", 328 devvp->v_udev, ump->um_devvp->v_udev); 329 error = EINVAL; /* needs translation */ 330 } 331 } else { 332 vrele(devvp); 333 } 334 /* 335 * Update device name only on success 336 */ 337 if (!error) { 338 /* Save "mounted from" info for mount point (NULL pad)*/ 339 copyinstr( args.fspec, 340 mp->mnt_stat.f_mntfromname, 341 MNAMELEN - 1, 342 &size); 343 bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); 344 } 345 } else { 346 /* 347 ******************** 348 * NEW MOUNT 349 ******************** 350 */ 351 352 /* Save "mounted from" info for mount point (NULL pad)*/ 353 copyinstr( args.fspec, /* device name*/ 354 mp->mnt_stat.f_mntfromname, /* save area*/ 355 MNAMELEN - 1, /* max size*/ 356 &size); /* real size*/ 357 bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); 358 359 error = ffs_mountfs(devvp, mp, M_FFSNODE); 360 } 361 if (error) { 362 goto error_2; 363 } 364 365 dostatfs: 366 /* 367 * Initialize FS stat information in mount struct; uses 368 * mp->mnt_stat.f_mntfromname. 369 * 370 * This code is common to root and non-root mounts 371 */ 372 (void)VFS_STATFS(mp, &mp->mnt_stat, cred); 373 374 goto success; 375 376 377 error_2: /* error with devvp held*/ 378 379 /* release devvp before failing*/ 380 vrele(devvp); 381 382 error_1: /* no state to back out*/ 383 384 success: 385 if (!error && path && (mp->mnt_flag & MNT_UPDATE)) { 386 /* Update clean flag after changing read-onlyness. */ 387 fs = ump->um_fs; 388 if (ronly != fs->fs_ronly) { 389 fs->fs_ronly = ronly; 390 fs->fs_clean = ronly && 391 (fs->fs_flags & FS_UNCLEAN) == 0 ? 1 : 0; 392 393 /* 394 * The device must be re-opened as appropriate or 395 * the device close at unmount time will panic. 396 */ 397 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 398 if (ronly) { 399 VOP_OPEN(devvp, FREAD, FSCRED, NULL); 400 VOP_CLOSE(devvp, FREAD|FWRITE); 401 } else { 402 VOP_OPEN(devvp, FREAD|FWRITE, FSCRED, NULL); 403 VOP_CLOSE(devvp, FREAD); 404 } 405 VOP_UNLOCK(devvp, 0); 406 ffs_sbupdate(ump, MNT_WAIT); 407 } 408 } 409 return (error); 410 } 411 412 /* 413 * Reload all incore data for a filesystem (used after running fsck on 414 * the root filesystem and finding things to fix). The filesystem must 415 * be mounted read-only. 416 * 417 * Things to do to update the mount: 418 * 1) invalidate all cached meta-data. 419 * 2) re-read superblock from disk. 420 * 3) re-read summary information from disk. 421 * 4) invalidate all inactive vnodes. 422 * 5) invalidate all cached file data. 423 * 6) re-read inode data for all active vnodes. 424 */ 425 426 static int ffs_reload_scan2(struct mount *mp, struct vnode *vp, void *data); 427 428 struct scaninfo { 429 int rescan; 430 struct fs *fs; 431 struct vnode *devvp; 432 int waitfor; 433 int allerror; 434 }; 435 436 static int 437 ffs_reload(struct mount *mp, struct ucred *cred) 438 { 439 struct vnode *devvp; 440 void *space; 441 struct buf *bp; 442 struct fs *fs, *newfs; 443 struct partinfo dpart; 444 dev_t dev; 445 int i, blks, size, error; 446 struct scaninfo scaninfo; 447 int32_t *lp; 448 449 if ((mp->mnt_flag & MNT_RDONLY) == 0) 450 return (EINVAL); 451 /* 452 * Step 1: invalidate all cached meta-data. 453 */ 454 devvp = VFSTOUFS(mp)->um_devvp; 455 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 456 error = vinvalbuf(devvp, 0, 0, 0); 457 VOP_UNLOCK(devvp, 0); 458 if (error) 459 panic("ffs_reload: dirty1"); 460 461 dev = devvp->v_rdev; 462 463 /* 464 * The backing device must be VMIO-capable because we use getblk(). 465 * NOTE: the MFS driver now returns a VMIO-enabled descriptor. 466 */ 467 if (devvp->v_object == NULL) 468 panic("ffs_reload: devvp has no VM object!"); 469 470 /* 471 * Step 2: re-read superblock from disk. 472 */ 473 if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, cred) != 0) 474 size = DEV_BSIZE; 475 else 476 size = dpart.disklab->d_secsize; 477 if ((error = bread(devvp, SBOFF, SBSIZE, &bp)) != 0) { 478 brelse(bp); 479 return (error); 480 } 481 newfs = (struct fs *)bp->b_data; 482 if (newfs->fs_magic != FS_MAGIC || newfs->fs_bsize > MAXBSIZE || 483 newfs->fs_bsize < sizeof(struct fs)) { 484 brelse(bp); 485 return (EIO); /* XXX needs translation */ 486 } 487 fs = VFSTOUFS(mp)->um_fs; 488 /* 489 * Copy pointer fields back into superblock before copying in XXX 490 * new superblock. These should really be in the ufsmount. XXX 491 * Note that important parameters (eg fs_ncg) are unchanged. 492 */ 493 newfs->fs_csp = fs->fs_csp; 494 newfs->fs_maxcluster = fs->fs_maxcluster; 495 newfs->fs_contigdirs = fs->fs_contigdirs; 496 /* The filesystem is still read-only. */ 497 newfs->fs_ronly = 1; 498 bcopy(newfs, fs, (uint)fs->fs_sbsize); 499 if (fs->fs_sbsize < SBSIZE) 500 bp->b_flags |= B_INVAL; 501 brelse(bp); 502 mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen; 503 ffs_oldfscompat(fs); 504 /* An old fsck may have zeroed these fields, so recheck them. */ 505 if (fs->fs_avgfilesize <= 0) /* XXX */ 506 fs->fs_avgfilesize = AVFILESIZ; /* XXX */ 507 if (fs->fs_avgfpdir <= 0) /* XXX */ 508 fs->fs_avgfpdir = AFPDIR; /* XXX */ 509 510 /* 511 * Step 3: re-read summary information from disk. 512 */ 513 blks = howmany(fs->fs_cssize, fs->fs_fsize); 514 space = fs->fs_csp; 515 for (i = 0; i < blks; i += fs->fs_frag) { 516 size = fs->fs_bsize; 517 if (i + fs->fs_frag > blks) 518 size = (blks - i) * fs->fs_fsize; 519 error = bread(devvp, fsbtodoff(fs, fs->fs_csaddr + i), size, &bp); 520 if (error) { 521 brelse(bp); 522 return (error); 523 } 524 bcopy(bp->b_data, space, (uint)size); 525 space = (char *)space + size; 526 brelse(bp); 527 } 528 /* 529 * We no longer know anything about clusters per cylinder group. 530 */ 531 if (fs->fs_contigsumsize > 0) { 532 lp = fs->fs_maxcluster; 533 for (i = 0; i < fs->fs_ncg; i++) 534 *lp++ = fs->fs_contigsumsize; 535 } 536 537 scaninfo.rescan = 0; 538 scaninfo.fs = fs; 539 scaninfo.devvp = devvp; 540 while (error == 0 && scaninfo.rescan) { 541 scaninfo.rescan = 0; 542 error = vmntvnodescan(mp, VMSC_GETVX, 543 NULL, ffs_reload_scan2, &scaninfo); 544 } 545 return(error); 546 } 547 548 static int 549 ffs_reload_scan2(struct mount *mp, struct vnode *vp, void *data) 550 { 551 struct scaninfo *info = data; 552 struct inode *ip; 553 struct buf *bp; 554 int error; 555 556 /* 557 * Try to recycle 558 */ 559 if (vrecycle(vp)) 560 return(0); 561 562 if (vinvalbuf(vp, 0, 0, 0)) 563 panic("ffs_reload: dirty2"); 564 /* 565 * Step 6: re-read inode data for all active vnodes. 566 */ 567 ip = VTOI(vp); 568 error = bread(info->devvp, 569 fsbtodoff(info->fs, ino_to_fsba(info->fs, ip->i_number)), 570 (int)info->fs->fs_bsize, &bp); 571 if (error) { 572 brelse(bp); 573 return (error); 574 } 575 ip->i_din = *((struct ufs1_dinode *)bp->b_data + 576 ino_to_fsbo(info->fs, ip->i_number)); 577 ip->i_effnlink = ip->i_nlink; 578 brelse(bp); 579 return(0); 580 } 581 582 /* 583 * Common code for mount and mountroot 584 */ 585 int 586 ffs_mountfs(struct vnode *devvp, struct mount *mp, struct malloc_type *mtype) 587 { 588 struct ufsmount *ump; 589 struct buf *bp; 590 struct fs *fs; 591 dev_t dev; 592 struct partinfo dpart; 593 void *space; 594 int error, i, blks, size, ronly; 595 int32_t *lp; 596 uint64_t maxfilesize; /* XXX */ 597 598 /* 599 * Disallow multiple mounts of the same device. 600 * Disallow mounting of a device that is currently in use 601 * Flush out any old buffers remaining from a previous use. 602 */ 603 error = vfs_mountedon(devvp); 604 if (error) 605 return (error); 606 if (count_udev(devvp->v_udev) > 0) 607 return (EBUSY); 608 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 609 error = vinvalbuf(devvp, V_SAVE, 0, 0); 610 VOP_UNLOCK(devvp, 0); 611 if (error) 612 return (error); 613 614 ronly = (mp->mnt_flag & MNT_RDONLY) != 0; 615 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 616 error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, NULL); 617 VOP_UNLOCK(devvp, 0); 618 if (error) 619 return (error); 620 dev = devvp->v_rdev; 621 if (dev->si_iosize_max != 0) 622 mp->mnt_iosize_max = dev->si_iosize_max; 623 if (mp->mnt_iosize_max > MAXPHYS) 624 mp->mnt_iosize_max = MAXPHYS; 625 626 /* 627 * Filesystem supports native FSMIDs 628 */ 629 mp->mnt_kern_flag |= MNTK_FSMID; 630 631 /* 632 * The backing device must be VMIO-capable because we use getblk(). 633 * NOTE: the MFS driver now returns a VMIO-enabled descriptor. 634 * The VOP_OPEN() call above should have associated a VM object 635 * with devvp. 636 */ 637 if (devvp->v_object == NULL) 638 panic("ffs_reload: devvp has no VM object!"); 639 640 if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, proc0.p_ucred) != 0) 641 size = DEV_BSIZE; 642 else 643 size = dpart.disklab->d_secsize; 644 645 bp = NULL; 646 ump = NULL; 647 if ((error = bread(devvp, SBOFF, SBSIZE, &bp)) != 0) 648 goto out; 649 fs = (struct fs *)bp->b_data; 650 if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE || 651 fs->fs_bsize < sizeof(struct fs)) { 652 error = EINVAL; /* XXX needs translation */ 653 goto out; 654 } 655 fs->fs_fmod = 0; 656 fs->fs_flags &= ~FS_UNCLEAN; 657 if (fs->fs_clean == 0) { 658 fs->fs_flags |= FS_UNCLEAN; 659 if (ronly || (mp->mnt_flag & MNT_FORCE)) { 660 printf( 661 "WARNING: %s was not properly dismounted\n", 662 fs->fs_fsmnt); 663 } else { 664 printf( 665 "WARNING: R/W mount of %s denied. Filesystem is not clean - run fsck\n", 666 fs->fs_fsmnt); 667 error = EPERM; 668 goto out; 669 } 670 } 671 /* XXX updating 4.2 FFS superblocks trashes rotational layout tables */ 672 if (fs->fs_postblformat == FS_42POSTBLFMT && !ronly) { 673 error = EROFS; /* needs translation */ 674 goto out; 675 } 676 ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK); 677 bzero((caddr_t)ump, sizeof *ump); 678 ump->um_malloctype = mtype; 679 ump->um_i_effnlink_valid = 1; 680 ump->um_fs = malloc((u_long)fs->fs_sbsize, M_UFSMNT, 681 M_WAITOK); 682 bcopy(bp->b_data, ump->um_fs, (uint)fs->fs_sbsize); 683 if (fs->fs_sbsize < SBSIZE) 684 bp->b_flags |= B_INVAL; 685 brelse(bp); 686 bp = NULL; 687 fs = ump->um_fs; 688 fs->fs_ronly = ronly; 689 size = fs->fs_cssize; 690 blks = howmany(size, fs->fs_fsize); 691 if (fs->fs_contigsumsize > 0) 692 size += fs->fs_ncg * sizeof(int32_t); 693 size += fs->fs_ncg * sizeof(uint8_t); 694 space = malloc((u_long)size, M_UFSMNT, M_WAITOK); 695 fs->fs_csp = space; 696 for (i = 0; i < blks; i += fs->fs_frag) { 697 size = fs->fs_bsize; 698 if (i + fs->fs_frag > blks) 699 size = (blks - i) * fs->fs_fsize; 700 if ((error = bread(devvp, fsbtodoff(fs, fs->fs_csaddr + i), 701 size, &bp)) != 0) { 702 free(fs->fs_csp, M_UFSMNT); 703 goto out; 704 } 705 bcopy(bp->b_data, space, (uint)size); 706 space = (char *)space + size; 707 brelse(bp); 708 bp = NULL; 709 } 710 if (fs->fs_contigsumsize > 0) { 711 fs->fs_maxcluster = lp = space; 712 for (i = 0; i < fs->fs_ncg; i++) 713 *lp++ = fs->fs_contigsumsize; 714 space = lp; 715 } 716 size = fs->fs_ncg * sizeof(uint8_t); 717 fs->fs_contigdirs = (uint8_t *)space; 718 bzero(fs->fs_contigdirs, size); 719 /* Compatibility for old filesystems XXX */ 720 if (fs->fs_avgfilesize <= 0) /* XXX */ 721 fs->fs_avgfilesize = AVFILESIZ; /* XXX */ 722 if (fs->fs_avgfpdir <= 0) /* XXX */ 723 fs->fs_avgfpdir = AFPDIR; /* XXX */ 724 mp->mnt_data = (qaddr_t)ump; 725 mp->mnt_stat.f_fsid.val[0] = fs->fs_id[0]; 726 mp->mnt_stat.f_fsid.val[1] = fs->fs_id[1]; 727 if (fs->fs_id[0] == 0 || fs->fs_id[1] == 0 || 728 vfs_getvfs(&mp->mnt_stat.f_fsid)) 729 vfs_getnewfsid(mp); 730 mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen; 731 mp->mnt_flag |= MNT_LOCAL; 732 ump->um_mountp = mp; 733 ump->um_dev = dev; 734 ump->um_devvp = devvp; 735 ump->um_nindir = fs->fs_nindir; 736 ump->um_bptrtodb = fs->fs_fsbtodb; 737 ump->um_seqinc = fs->fs_frag; 738 for (i = 0; i < MAXQUOTAS; i++) 739 ump->um_quotas[i] = NULLVP; 740 dev->si_mountpoint = mp; 741 ffs_oldfscompat(fs); 742 743 if( mp->mnt_flag & MNT_ROOTFS) { 744 /* 745 * Root mount; update timestamp in mount structure. 746 * this will be used by the common root mount code 747 * to update the system clock. 748 */ 749 mp->mnt_time = fs->fs_time; 750 } 751 752 ump->um_savedmaxfilesize = fs->fs_maxfilesize; /* XXX */ 753 maxfilesize = (uint64_t)0x40000000 * fs->fs_bsize - 1; /* XXX */ 754 /* Enforce limit caused by vm object backing (32 bits vm_pindex_t). */ 755 if (maxfilesize > (uint64_t)0x80000000u * PAGE_SIZE - 1) 756 maxfilesize = (uint64_t)0x80000000u * PAGE_SIZE - 1; 757 if (fs->fs_maxfilesize > maxfilesize) /* XXX */ 758 fs->fs_maxfilesize = maxfilesize; /* XXX */ 759 if (ronly == 0) { 760 if ((fs->fs_flags & FS_DOSOFTDEP) && 761 (error = softdep_mount(devvp, mp, fs)) != 0) { 762 free(fs->fs_csp, M_UFSMNT); 763 goto out; 764 } 765 fs->fs_fmod = 1; 766 fs->fs_clean = 0; 767 (void) ffs_sbupdate(ump, MNT_WAIT); 768 } 769 vfs_add_vnodeops(mp, &ffs_vnode_vops, &mp->mnt_vn_norm_ops); 770 vfs_add_vnodeops(mp, &ffs_spec_vops, &mp->mnt_vn_spec_ops); 771 vfs_add_vnodeops(mp, &ffs_fifo_vops, &mp->mnt_vn_fifo_ops); 772 773 return (0); 774 out: 775 dev->si_mountpoint = NULL; 776 if (bp) 777 brelse(bp); 778 VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE); 779 if (ump) { 780 free(ump->um_fs, M_UFSMNT); 781 free(ump, M_UFSMNT); 782 mp->mnt_data = (qaddr_t)0; 783 } 784 return (error); 785 } 786 787 /* 788 * Sanity checks for old filesystems. 789 * 790 * XXX - goes away some day. 791 */ 792 static int 793 ffs_oldfscompat(struct fs *fs) 794 { 795 fs->fs_npsect = max(fs->fs_npsect, fs->fs_nsect); /* XXX */ 796 fs->fs_interleave = max(fs->fs_interleave, 1); /* XXX */ 797 if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */ 798 fs->fs_nrpos = 8; /* XXX */ 799 if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */ 800 #if 0 801 int i; /* XXX */ 802 uint64_t sizepb = fs->fs_bsize; /* XXX */ 803 /* XXX */ 804 fs->fs_maxfilesize = fs->fs_bsize * NDADDR - 1; /* XXX */ 805 for (i = 0; i < NIADDR; i++) { /* XXX */ 806 sizepb *= NINDIR(fs); /* XXX */ 807 fs->fs_maxfilesize += sizepb; /* XXX */ 808 } /* XXX */ 809 #endif 810 fs->fs_maxfilesize = (u_quad_t) 1LL << 39; 811 fs->fs_qbmask = ~fs->fs_bmask; /* XXX */ 812 fs->fs_qfmask = ~fs->fs_fmask; /* XXX */ 813 } /* XXX */ 814 return (0); 815 } 816 817 /* 818 * unmount system call 819 */ 820 int 821 ffs_unmount(struct mount *mp, int mntflags) 822 { 823 struct ufsmount *ump; 824 struct fs *fs; 825 int error, flags; 826 827 flags = 0; 828 if (mntflags & MNT_FORCE) { 829 flags |= FORCECLOSE; 830 } 831 if (mp->mnt_flag & MNT_SOFTDEP) { 832 if ((error = softdep_flushfiles(mp, flags)) != 0) 833 return (error); 834 } else { 835 if ((error = ffs_flushfiles(mp, flags)) != 0) 836 return (error); 837 } 838 ump = VFSTOUFS(mp); 839 fs = ump->um_fs; 840 if (fs->fs_ronly == 0) { 841 fs->fs_clean = fs->fs_flags & FS_UNCLEAN ? 0 : 1; 842 error = ffs_sbupdate(ump, MNT_WAIT); 843 if (error) { 844 fs->fs_clean = 0; 845 return (error); 846 } 847 } 848 ump->um_devvp->v_rdev->si_mountpoint = NULL; 849 850 vinvalbuf(ump->um_devvp, V_SAVE, 0, 0); 851 error = VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD|FWRITE); 852 853 vrele(ump->um_devvp); 854 855 free(fs->fs_csp, M_UFSMNT); 856 free(fs, M_UFSMNT); 857 free(ump, M_UFSMNT); 858 mp->mnt_data = (qaddr_t)0; 859 mp->mnt_flag &= ~MNT_LOCAL; 860 return (error); 861 } 862 863 /* 864 * Flush out all the files in a filesystem. 865 */ 866 int 867 ffs_flushfiles(struct mount *mp, int flags) 868 { 869 struct ufsmount *ump; 870 int error; 871 872 ump = VFSTOUFS(mp); 873 #ifdef QUOTA 874 if (mp->mnt_flag & MNT_QUOTA) { 875 int i; 876 error = vflush(mp, 0, SKIPSYSTEM|flags); 877 if (error) 878 return (error); 879 /* Find out how many quota files we have open. */ 880 for (i = 0; i < MAXQUOTAS; i++) { 881 if (ump->um_quotas[i] == NULLVP) 882 continue; 883 ufs_quotaoff(mp, i); 884 } 885 /* 886 * Here we fall through to vflush again to ensure 887 * that we have gotten rid of all the system vnodes. 888 */ 889 } 890 #endif 891 /* 892 * Flush all the files. 893 */ 894 if ((error = vflush(mp, 0, flags)) != 0) 895 return (error); 896 /* 897 * Flush filesystem metadata. 898 */ 899 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY); 900 error = VOP_FSYNC(ump->um_devvp, MNT_WAIT); 901 VOP_UNLOCK(ump->um_devvp, 0); 902 return (error); 903 } 904 905 /* 906 * Get filesystem statistics. 907 */ 908 int 909 ffs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred) 910 { 911 struct ufsmount *ump; 912 struct fs *fs; 913 914 ump = VFSTOUFS(mp); 915 fs = ump->um_fs; 916 if (fs->fs_magic != FS_MAGIC) 917 panic("ffs_statfs"); 918 sbp->f_bsize = fs->fs_fsize; 919 sbp->f_iosize = fs->fs_bsize; 920 sbp->f_blocks = fs->fs_dsize; 921 sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag + 922 fs->fs_cstotal.cs_nffree; 923 sbp->f_bavail = freespace(fs, fs->fs_minfree); 924 sbp->f_files = fs->fs_ncg * fs->fs_ipg - ROOTINO; 925 sbp->f_ffree = fs->fs_cstotal.cs_nifree; 926 if (sbp != &mp->mnt_stat) { 927 sbp->f_type = mp->mnt_vfc->vfc_typenum; 928 bcopy((caddr_t)mp->mnt_stat.f_mntfromname, 929 (caddr_t)&sbp->f_mntfromname[0], MNAMELEN); 930 } 931 return (0); 932 } 933 934 /* 935 * Go through the disk queues to initiate sandbagged IO; 936 * go through the inodes to write those that have been modified; 937 * initiate the writing of the super block if it has been modified. 938 * 939 * Note: we are always called with the filesystem marked `MPBUSY'. 940 */ 941 942 943 static int ffs_sync_scan1(struct mount *mp, struct vnode *vp, void *data); 944 static int ffs_sync_scan2(struct mount *mp, struct vnode *vp, void *data); 945 946 int 947 ffs_sync(struct mount *mp, int waitfor) 948 { 949 struct ufsmount *ump = VFSTOUFS(mp); 950 struct fs *fs; 951 int error; 952 struct scaninfo scaninfo; 953 954 fs = ump->um_fs; 955 if (fs->fs_fmod != 0 && fs->fs_ronly != 0) { /* XXX */ 956 printf("fs = %s\n", fs->fs_fsmnt); 957 panic("ffs_sync: rofs mod"); 958 } 959 960 /* 961 * Write back each (modified) inode. 962 */ 963 scaninfo.allerror = 0; 964 scaninfo.rescan = 1; 965 scaninfo.waitfor = waitfor; 966 while (scaninfo.rescan) { 967 scaninfo.rescan = 0; 968 vmntvnodescan(mp, VMSC_GETVP|VMSC_NOWAIT, 969 ffs_sync_scan1, ffs_sync_scan2, &scaninfo); 970 } 971 972 /* 973 * Force stale filesystem control information to be flushed. 974 */ 975 if (waitfor != MNT_LAZY) { 976 if (ump->um_mountp->mnt_flag & MNT_SOFTDEP) 977 waitfor = MNT_NOWAIT; 978 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY); 979 if ((error = VOP_FSYNC(ump->um_devvp, waitfor)) != 0) 980 scaninfo.allerror = error; 981 VOP_UNLOCK(ump->um_devvp, 0); 982 } 983 #ifdef QUOTA 984 ufs_qsync(mp); 985 #endif 986 /* 987 * Write back modified superblock. 988 */ 989 if (fs->fs_fmod != 0 && (error = ffs_sbupdate(ump, waitfor)) != 0) 990 scaninfo.allerror = error; 991 return (scaninfo.allerror); 992 } 993 994 static int 995 ffs_sync_scan1(struct mount *mp, struct vnode *vp, void *data) 996 { 997 struct inode *ip; 998 999 /* 1000 * Depend on the mount list's vnode lock to keep things stable 1001 * enough for a quick test. Since there might be hundreds of 1002 * thousands of vnodes, we cannot afford even a subroutine 1003 * call unless there's a good chance that we have work to do. 1004 */ 1005 ip = VTOI(vp); 1006 /* Restart out whole search if this guy is locked 1007 * or is being reclaimed. 1008 */ 1009 if (vp->v_type == VNON || ((ip->i_flag & 1010 (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 && 1011 RB_EMPTY(&vp->v_rbdirty_tree))) { 1012 return(-1); 1013 } 1014 return(0); 1015 } 1016 1017 static int 1018 ffs_sync_scan2(struct mount *mp, struct vnode *vp, void *data) 1019 { 1020 struct scaninfo *info = data; 1021 struct inode *ip; 1022 int error; 1023 1024 /* 1025 * We have to recheck after having obtained the vnode interlock. 1026 */ 1027 ip = VTOI(vp); 1028 if (vp->v_type == VNON || ((ip->i_flag & 1029 (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 && 1030 RB_EMPTY(&vp->v_rbdirty_tree))) { 1031 return(0); 1032 } 1033 if (vp->v_type != VCHR) { 1034 if ((error = VOP_FSYNC(vp, info->waitfor)) != 0) 1035 info->allerror = error; 1036 } else { 1037 /* 1038 * We must reference the vp to prevent it from 1039 * getting ripped out from under ffs_update, since 1040 * we are not holding a vnode lock. 1041 */ 1042 /* ffs_update(vp, waitfor == MNT_WAIT); */ 1043 ffs_update(vp, 0); 1044 } 1045 return(0); 1046 } 1047 1048 /* 1049 * Look up a FFS dinode number to find its incore vnode, otherwise read it 1050 * in from disk. If it is in core, wait for the lock bit to clear, then 1051 * return the inode locked. Detection and handling of mount points must be 1052 * done by the calling routine. 1053 */ 1054 1055 int 1056 ffs_vget(struct mount *mp, ino_t ino, struct vnode **vpp) 1057 { 1058 struct fs *fs; 1059 struct inode *ip; 1060 struct ufsmount *ump; 1061 struct buf *bp; 1062 struct vnode *vp; 1063 dev_t dev; 1064 int error; 1065 1066 ump = VFSTOUFS(mp); 1067 dev = ump->um_dev; 1068 restart: 1069 if ((*vpp = ufs_ihashget(dev, ino)) != NULL) { 1070 return (0); 1071 } 1072 1073 /* 1074 * If this MALLOC() is performed after the getnewvnode() 1075 * it might block, leaving a vnode with a NULL v_data to be 1076 * found by ffs_sync() if a sync happens to fire right then, 1077 * which will cause a panic because ffs_sync() blindly 1078 * dereferences vp->v_data (as well it should). 1079 * 1080 * XXX this may no longer be true since getnewvnode returns a 1081 * VX locked vnode now. 1082 */ 1083 MALLOC(ip, struct inode *, sizeof(struct inode), 1084 ump->um_malloctype, M_WAITOK); 1085 1086 /* Allocate a new vnode/inode. */ 1087 error = getnewvnode(VT_UFS, mp, &vp, VLKTIMEOUT, LK_CANRECURSE); 1088 if (error) { 1089 *vpp = NULL; 1090 free(ip, ump->um_malloctype); 1091 return (error); 1092 } 1093 bzero((caddr_t)ip, sizeof(struct inode)); 1094 ip->i_vnode = vp; 1095 ip->i_fs = fs = ump->um_fs; 1096 ip->i_dev = dev; 1097 ip->i_number = ino; 1098 #ifdef QUOTA 1099 { 1100 int i; 1101 for (i = 0; i < MAXQUOTAS; i++) 1102 ip->i_dquot[i] = NODQUOT; 1103 } 1104 #endif 1105 1106 /* 1107 * Insert it into the inode hash table and check for a collision. 1108 * If a collision occurs, throw away the vnode and try again. 1109 */ 1110 if (ufs_ihashins(ip) != 0) { 1111 printf("debug: ufs ihashins collision, retrying inode %ld\n", 1112 (long)ip->i_number); 1113 vx_put(vp); 1114 free(ip, ump->um_malloctype); 1115 goto restart; 1116 } 1117 vp->v_data = ip; 1118 1119 /* Read in the disk contents for the inode, copy into the inode. */ 1120 error = bread(ump->um_devvp, fsbtodoff(fs, ino_to_fsba(fs, ino)), 1121 (int)fs->fs_bsize, &bp); 1122 if (error) { 1123 /* 1124 * The inode does not contain anything useful, so it would 1125 * be misleading to leave it on its hash chain. With mode 1126 * still zero, it will be unlinked and returned to the free 1127 * list by vput(). 1128 */ 1129 brelse(bp); 1130 vx_put(vp); 1131 *vpp = NULL; 1132 return (error); 1133 } 1134 ip->i_din = *((struct ufs1_dinode *)bp->b_data + ino_to_fsbo(fs, ino)); 1135 if (DOINGSOFTDEP(vp)) 1136 softdep_load_inodeblock(ip); 1137 else 1138 ip->i_effnlink = ip->i_nlink; 1139 bqrelse(bp); 1140 1141 /* 1142 * Initialize the vnode from the inode, check for aliases. 1143 * Note that the underlying vnode may have changed. 1144 */ 1145 error = ufs_vinit(mp, &vp); 1146 if (error) { 1147 vx_put(vp); 1148 *vpp = NULL; 1149 return (error); 1150 } 1151 /* 1152 * Finish inode initialization now that aliasing has been resolved. 1153 */ 1154 ip->i_devvp = ump->um_devvp; 1155 vref(ip->i_devvp); 1156 /* 1157 * Set up a generation number for this inode if it does not 1158 * already have one. This should only happen on old filesystems. 1159 */ 1160 if (ip->i_gen == 0) { 1161 ip->i_gen = random() / 2 + 1; 1162 if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) 1163 ip->i_flag |= IN_MODIFIED; 1164 } 1165 /* 1166 * Ensure that uid and gid are correct. This is a temporary 1167 * fix until fsck has been changed to do the update. 1168 */ 1169 if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */ 1170 ip->i_uid = ip->i_din.di_ouid; /* XXX */ 1171 ip->i_gid = ip->i_din.di_ogid; /* XXX */ 1172 } /* XXX */ 1173 1174 /* 1175 * return a VX locked and refd vnode (VX == same as normal vget() 1176 * vnode so we are ok) 1177 */ 1178 *vpp = vp; 1179 return (0); 1180 } 1181 1182 /* 1183 * File handle to vnode 1184 * 1185 * Have to be really careful about stale file handles: 1186 * - check that the inode number is valid 1187 * - call ffs_vget() to get the locked inode 1188 * - check for an unallocated inode (i_mode == 0) 1189 * - check that the given client host has export rights and return 1190 * those rights via. exflagsp and credanonp 1191 */ 1192 int 1193 ffs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp) 1194 { 1195 struct ufid *ufhp; 1196 struct fs *fs; 1197 1198 ufhp = (struct ufid *)fhp; 1199 fs = VFSTOUFS(mp)->um_fs; 1200 if (ufhp->ufid_ino < ROOTINO || 1201 ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg) 1202 return (ESTALE); 1203 return (ufs_fhtovp(mp, ufhp, vpp)); 1204 } 1205 1206 /* 1207 * Vnode pointer to File handle 1208 */ 1209 /* ARGSUSED */ 1210 int 1211 ffs_vptofh(struct vnode *vp, struct fid *fhp) 1212 { 1213 struct inode *ip; 1214 struct ufid *ufhp; 1215 1216 ip = VTOI(vp); 1217 ufhp = (struct ufid *)fhp; 1218 ufhp->ufid_len = sizeof(struct ufid); 1219 ufhp->ufid_ino = ip->i_number; 1220 ufhp->ufid_gen = ip->i_gen; 1221 return (0); 1222 } 1223 1224 /* 1225 * Initialize the filesystem; just use ufs_init. 1226 */ 1227 static int 1228 ffs_init(struct vfsconf *vfsp) 1229 { 1230 softdep_initialize(); 1231 return (ufs_init(vfsp)); 1232 } 1233 1234 /* 1235 * Write a superblock and associated information back to disk. 1236 */ 1237 static int 1238 ffs_sbupdate(struct ufsmount *mp, int waitfor) 1239 { 1240 struct fs *dfs, *fs = mp->um_fs; 1241 struct buf *bp; 1242 int blks; 1243 void *space; 1244 int i, size, error, allerror = 0; 1245 1246 /* 1247 * First write back the summary information. 1248 * 1249 * NOTE: the getblk is relative to the device vnode so bio1 1250 * contains the device block number. 1251 */ 1252 blks = howmany(fs->fs_cssize, fs->fs_fsize); 1253 space = fs->fs_csp; 1254 for (i = 0; i < blks; i += fs->fs_frag) { 1255 size = fs->fs_bsize; 1256 if (i + fs->fs_frag > blks) 1257 size = (blks - i) * fs->fs_fsize; 1258 bp = getblk(mp->um_devvp, fsbtodoff(fs, fs->fs_csaddr + i), 1259 size, 0, 0); 1260 bcopy(space, bp->b_data, (uint)size); 1261 space = (char *)space + size; 1262 if (waitfor != MNT_WAIT) 1263 bawrite(bp); 1264 else if ((error = bwrite(bp)) != 0) 1265 allerror = error; 1266 } 1267 /* 1268 * Now write back the superblock itself. If any errors occurred 1269 * up to this point, then fail so that the superblock avoids 1270 * being written out as clean. 1271 */ 1272 if (allerror) 1273 return (allerror); 1274 bp = getblk(mp->um_devvp, SBOFF, (int)fs->fs_sbsize, 0, 0); 1275 fs->fs_fmod = 0; 1276 fs->fs_time = time_second; 1277 bcopy((caddr_t)fs, bp->b_data, (uint)fs->fs_sbsize); 1278 /* Restore compatibility to old filesystems. XXX */ 1279 dfs = (struct fs *)bp->b_data; /* XXX */ 1280 if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */ 1281 dfs->fs_nrpos = -1; /* XXX */ 1282 if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */ 1283 int32_t *lp, tmp; /* XXX */ 1284 /* XXX */ 1285 lp = (int32_t *)&dfs->fs_qbmask; /* XXX */ 1286 tmp = lp[4]; /* XXX */ 1287 for (i = 4; i > 0; i--) /* XXX */ 1288 lp[i] = lp[i-1]; /* XXX */ 1289 lp[0] = tmp; /* XXX */ 1290 } /* XXX */ 1291 dfs->fs_maxfilesize = mp->um_savedmaxfilesize; /* XXX */ 1292 if (waitfor != MNT_WAIT) 1293 bawrite(bp); 1294 else if ((error = bwrite(bp)) != 0) 1295 allerror = error; 1296 return (allerror); 1297 } 1298