lfs_vfsops.c revision 1.59
1 /* $NetBSD: lfs_vfsops.c,v 1.59 2000/11/14 00:42:55 perseant Exp $ */ 2 3 /*- 4 * Copyright (c) 1999, 2000 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Konrad E. Schroder <perseant (at) hhhh.org>. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 /*- 39 * Copyright (c) 1989, 1991, 1993, 1994 40 * The Regents of the University of California. All rights reserved. 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. All advertising materials mentioning features or use of this software 51 * must display the following acknowledgement: 52 * This product includes software developed by the University of 53 * California, Berkeley and its contributors. 54 * 4. Neither the name of the University nor the names of its contributors 55 * may be used to endorse or promote products derived from this software 56 * without specific prior written permission. 57 * 58 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 59 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 60 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 61 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 62 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 63 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 64 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 65 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 66 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 67 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 68 * SUCH DAMAGE. 69 * 70 * @(#)lfs_vfsops.c 8.20 (Berkeley) 6/10/95 71 */ 72 73 #if defined(_KERNEL) && !defined(_LKM) 74 #include "opt_quota.h" 75 #endif 76 77 #include <sys/param.h> 78 #include <sys/systm.h> 79 #include <sys/namei.h> 80 #include <sys/proc.h> 81 #include <sys/kernel.h> 82 #include <sys/vnode.h> 83 #include <sys/mount.h> 84 #include <sys/buf.h> 85 #include <sys/device.h> 86 #include <sys/mbuf.h> 87 #include <sys/file.h> 88 #include <sys/disklabel.h> 89 #include <sys/ioctl.h> 90 #include <sys/errno.h> 91 #include <sys/malloc.h> 92 #include <sys/pool.h> 93 #include <sys/socket.h> 94 #include <uvm/uvm_extern.h> 95 #include <sys/sysctl.h> 96 97 #include <miscfs/specfs/specdev.h> 98 99 #include <ufs/ufs/quota.h> 100 #include <ufs/ufs/inode.h> 101 #include <ufs/ufs/ufsmount.h> 102 #include <ufs/ufs/ufs_extern.h> 103 104 #include <ufs/lfs/lfs.h> 105 #include <ufs/lfs/lfs_extern.h> 106 107 int lfs_mountfs __P((struct vnode *, struct mount *, struct proc *)); 108 109 extern struct vnodeopv_desc lfs_vnodeop_opv_desc; 110 extern struct vnodeopv_desc lfs_specop_opv_desc; 111 extern struct vnodeopv_desc lfs_fifoop_opv_desc; 112 113 struct vnodeopv_desc *lfs_vnodeopv_descs[] = { 114 &lfs_vnodeop_opv_desc, 115 &lfs_specop_opv_desc, 116 &lfs_fifoop_opv_desc, 117 NULL, 118 }; 119 120 struct vfsops lfs_vfsops = { 121 MOUNT_LFS, 122 lfs_mount, 123 ufs_start, 124 lfs_unmount, 125 ufs_root, 126 ufs_quotactl, 127 lfs_statfs, 128 lfs_sync, 129 lfs_vget, 130 lfs_fhtovp, 131 lfs_vptofh, 132 lfs_init, 133 lfs_done, 134 lfs_sysctl, 135 lfs_mountroot, 136 ufs_check_export, 137 lfs_vnodeopv_descs, 138 }; 139 140 struct pool lfs_inode_pool; 141 142 /* 143 * Initialize the filesystem, most work done by ufs_init. 144 */ 145 void 146 lfs_init() 147 { 148 ufs_init(); 149 150 /* 151 * XXX Same structure as FFS inodes? Should we share a common pool? 152 */ 153 pool_init(&lfs_inode_pool, sizeof(struct inode), 0, 0, 0, 154 "lfsinopl", 0, pool_page_alloc_nointr, pool_page_free_nointr, 155 M_LFSNODE); 156 } 157 158 void 159 lfs_done() 160 { 161 ufs_done(); 162 pool_destroy(&lfs_inode_pool); 163 } 164 165 /* 166 * Called by main() when ufs is going to be mounted as root. 167 */ 168 int 169 lfs_mountroot() 170 { 171 extern struct vnode *rootvp; 172 struct mount *mp; 173 struct proc *p = curproc; /* XXX */ 174 int error; 175 176 if (root_device->dv_class != DV_DISK) 177 return (ENODEV); 178 179 if (rootdev == NODEV) 180 return (ENODEV); 181 /* 182 * Get vnodes for swapdev and rootdev. 183 */ 184 if ((error = bdevvp(rootdev, &rootvp))) { 185 printf("lfs_mountroot: can't setup bdevvp's"); 186 return (error); 187 } 188 if ((error = vfs_rootmountalloc(MOUNT_LFS, "root_device", &mp))) { 189 vrele(rootvp); 190 return (error); 191 } 192 if ((error = lfs_mountfs(rootvp, mp, p))) { 193 mp->mnt_op->vfs_refcount--; 194 vfs_unbusy(mp); 195 free(mp, M_MOUNT); 196 vrele(rootvp); 197 return (error); 198 } 199 simple_lock(&mountlist_slock); 200 CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list); 201 simple_unlock(&mountlist_slock); 202 (void)lfs_statfs(mp, &mp->mnt_stat, p); 203 vfs_unbusy(mp); 204 return (0); 205 } 206 207 /* 208 * VFS Operations. 209 * 210 * mount system call 211 */ 212 int 213 lfs_mount(mp, path, data, ndp, p) 214 struct mount *mp; 215 const char *path; 216 void *data; 217 struct nameidata *ndp; 218 struct proc *p; 219 { 220 struct vnode *devvp; 221 struct ufs_args args; 222 struct ufsmount *ump = NULL; 223 struct lfs *fs = NULL; /* LFS */ 224 size_t size; 225 int error; 226 mode_t accessmode; 227 228 error = copyin(data, (caddr_t)&args, sizeof (struct ufs_args)); 229 if (error) 230 return (error); 231 232 #if 0 233 /* Until LFS can do NFS right. XXX */ 234 if (args.export.ex_flags & MNT_EXPORTED) 235 return (EINVAL); 236 #endif 237 238 /* 239 * If updating, check whether changing from read-only to 240 * read/write; if there is no device name, that's all we do. 241 */ 242 if (mp->mnt_flag & MNT_UPDATE) { 243 ump = VFSTOUFS(mp); 244 fs = ump->um_lfs; 245 if (fs->lfs_ronly && (mp->mnt_flag & MNT_WANTRDWR)) { 246 /* 247 * If upgrade to read-write by non-root, then verify 248 * that user has necessary permissions on the device. 249 */ 250 if (p->p_ucred->cr_uid != 0) { 251 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY); 252 error = VOP_ACCESS(ump->um_devvp, VREAD|VWRITE, 253 p->p_ucred, p); 254 VOP_UNLOCK(ump->um_devvp, 0); 255 if (error) 256 return (error); 257 } 258 fs->lfs_ronly = 0; 259 } 260 if (args.fspec == 0) { 261 /* 262 * Process export requests. 263 */ 264 return (vfs_export(mp, &ump->um_export, &args.export)); 265 } 266 } 267 /* 268 * Not an update, or updating the name: look up the name 269 * and verify that it refers to a sensible block device. 270 */ 271 NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p); 272 if ((error = namei(ndp)) != 0) 273 return (error); 274 devvp = ndp->ni_vp; 275 if (devvp->v_type != VBLK) { 276 vrele(devvp); 277 return (ENOTBLK); 278 } 279 if (major(devvp->v_rdev) >= nblkdev) { 280 vrele(devvp); 281 return (ENXIO); 282 } 283 /* 284 * If mount by non-root, then verify that user has necessary 285 * permissions on the device. 286 */ 287 if (p->p_ucred->cr_uid != 0) { 288 accessmode = VREAD; 289 if ((mp->mnt_flag & MNT_RDONLY) == 0) 290 accessmode |= VWRITE; 291 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 292 error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p); 293 if (error) { 294 vput(devvp); 295 return (error); 296 } 297 VOP_UNLOCK(devvp, 0); 298 } 299 if ((mp->mnt_flag & MNT_UPDATE) == 0) 300 error = lfs_mountfs(devvp, mp, p); /* LFS */ 301 else { 302 if (devvp != ump->um_devvp) 303 error = EINVAL; /* needs translation */ 304 else 305 vrele(devvp); 306 } 307 if (error) { 308 vrele(devvp); 309 return (error); 310 } 311 ump = VFSTOUFS(mp); 312 fs = ump->um_lfs; /* LFS */ 313 (void)copyinstr(path, fs->lfs_fsmnt, sizeof(fs->lfs_fsmnt) - 1, &size); 314 bzero(fs->lfs_fsmnt + size, sizeof(fs->lfs_fsmnt) - size); 315 bcopy(fs->lfs_fsmnt, mp->mnt_stat.f_mntonname, MNAMELEN); 316 (void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, 317 &size); 318 bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); 319 return (0); 320 } 321 322 /* 323 * Common code for mount and mountroot 324 * LFS specific 325 */ 326 int 327 lfs_mountfs(devvp, mp, p) 328 struct vnode *devvp; 329 struct mount *mp; 330 struct proc *p; 331 { 332 extern struct vnode *rootvp; 333 struct dlfs *dfs, *adfs; 334 struct lfs *fs; 335 struct ufsmount *ump; 336 struct vnode *vp; 337 struct buf *bp, *abp; 338 struct partinfo dpart; 339 dev_t dev; 340 int error, i, ronly, size; 341 struct ucred *cred; 342 CLEANERINFO *cip; 343 SEGUSE *sup; 344 345 cred = p ? p->p_ucred : NOCRED; 346 /* 347 * Disallow multiple mounts of the same device. 348 * Disallow mounting of a device that is currently in use 349 * (except for root, which might share swap device for miniroot). 350 * Flush out any old buffers remaining from a previous use. 351 */ 352 if ((error = vfs_mountedon(devvp)) != 0) 353 return (error); 354 if (vcount(devvp) > 1 && devvp != rootvp) 355 return (EBUSY); 356 if ((error = vinvalbuf(devvp, V_SAVE, cred, p, 0, 0)) != 0) 357 return (error); 358 359 ronly = (mp->mnt_flag & MNT_RDONLY) != 0; 360 error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p); 361 if (error) 362 return (error); 363 if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, cred, p) != 0) 364 size = DEV_BSIZE; 365 else 366 size = dpart.disklab->d_secsize; 367 368 /* Don't free random space on error. */ 369 bp = NULL; 370 abp = NULL; 371 ump = NULL; 372 373 /* Read in the superblock. */ 374 error = bread(devvp, LFS_LABELPAD / size, LFS_SBPAD, cred, &bp); 375 if (error) 376 goto out; 377 dfs = (struct dlfs *)bp->b_data; 378 379 /* Check the basics. */ 380 if (dfs->dlfs_magic != LFS_MAGIC || dfs->dlfs_bsize > MAXBSIZE || 381 dfs->dlfs_version > LFS_VERSION || 382 dfs->dlfs_bsize < sizeof(struct dlfs)) { 383 error = EINVAL; /* XXX needs translation */ 384 goto out; 385 } 386 387 /* 388 * Check the second superblock to see which is newer; then mount 389 * using the older of the two. This is necessary to ensure that 390 * the filesystem is valid if it was not unmounted cleanly. 391 */ 392 if (dfs->dlfs_sboffs[1] && 393 dfs->dlfs_sboffs[1]-(LFS_LABELPAD/size) > LFS_SBPAD/size) 394 { 395 error = bread(devvp, dfs->dlfs_sboffs[1], LFS_SBPAD, cred, &abp); 396 if (error) 397 goto out; 398 adfs = (struct dlfs *)abp->b_data; 399 400 if (adfs->dlfs_tstamp < dfs->dlfs_tstamp) /* XXX 1s? */ 401 dfs = adfs; 402 } else { 403 printf("lfs_mountfs: invalid alt superblock daddr=0x%x\n", 404 dfs->dlfs_sboffs[1]); 405 error = EINVAL; 406 goto out; 407 } 408 409 /* Allocate the mount structure, copy the superblock into it. */ 410 fs = malloc(sizeof(struct lfs), M_UFSMNT, M_WAITOK); 411 memcpy(&fs->lfs_dlfs, dfs, sizeof(struct dlfs)); 412 ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK); 413 memset((caddr_t)ump, 0, sizeof *ump); 414 ump->um_lfs = fs; 415 if (sizeof(struct lfs) < LFS_SBPAD) /* XXX why? */ 416 bp->b_flags |= B_INVAL; 417 brelse(bp); 418 bp = NULL; 419 brelse(abp); 420 abp = NULL; 421 422 /* Set up the I/O information */ 423 fs->lfs_iocount = 0; 424 fs->lfs_diropwait = 0; 425 fs->lfs_activesb = 0; 426 fs->lfs_uinodes = 0; 427 fs->lfs_ravail = 0; 428 #ifdef LFS_CANNOT_ROLLFW 429 fs->lfs_sbactive = 0; 430 #endif 431 #ifdef LFS_TRACK_IOS 432 for (i=0;i<LFS_THROTTLE;i++) 433 fs->lfs_pending[i] = LFS_UNUSED_DADDR; 434 #endif 435 436 /* Set up the ifile and lock aflags */ 437 fs->lfs_doifile = 0; 438 fs->lfs_writer = 0; 439 fs->lfs_dirops = 0; 440 fs->lfs_nadirop = 0; 441 fs->lfs_seglock = 0; 442 lockinit(&fs->lfs_freelock, PINOD, "lfs_freelock", 0, 0); 443 444 /* Set the file system readonly/modify bits. */ 445 fs->lfs_ronly = ronly; 446 if (ronly == 0) 447 fs->lfs_fmod = 1; 448 449 /* Initialize the mount structure. */ 450 dev = devvp->v_rdev; 451 mp->mnt_data = (qaddr_t)ump; 452 mp->mnt_stat.f_fsid.val[0] = (long)dev; 453 mp->mnt_stat.f_fsid.val[1] = makefstype(MOUNT_LFS); 454 mp->mnt_stat.f_iosize = fs->lfs_bsize; 455 mp->mnt_maxsymlinklen = fs->lfs_maxsymlinklen; 456 mp->mnt_flag |= MNT_LOCAL; 457 ump->um_flags = 0; 458 ump->um_mountp = mp; 459 ump->um_dev = dev; 460 ump->um_devvp = devvp; 461 ump->um_bptrtodb = 0; 462 ump->um_seqinc = 1 << fs->lfs_fsbtodb; 463 ump->um_nindir = fs->lfs_nindir; 464 for (i = 0; i < MAXQUOTAS; i++) 465 ump->um_quotas[i] = NULLVP; 466 devvp->v_specmountpoint = mp; 467 468 /* 469 * We use the ifile vnode for almost every operation. Instead of 470 * retrieving it from the hash table each time we retrieve it here, 471 * artificially increment the reference count and keep a pointer 472 * to it in the incore copy of the superblock. 473 */ 474 if ((error = VFS_VGET(mp, LFS_IFILE_INUM, &vp)) != 0) 475 goto out; 476 fs->lfs_ivnode = vp; 477 VREF(vp); 478 vput(vp); 479 480 /* 481 * Initialize the ifile cleaner info with information from 482 * the superblock. 483 */ 484 LFS_CLEANERINFO(cip, fs, bp); 485 cip->clean = fs->lfs_nclean; 486 cip->dirty = fs->lfs_nseg - fs->lfs_nclean; 487 cip->avail = fs->lfs_avail; 488 cip->bfree = fs->lfs_bfree; 489 (void) VOP_BWRITE(bp); /* Ifile */ 490 491 /* 492 * Mark the current segment as ACTIVE, since we're going to 493 * be writing to it. 494 */ 495 LFS_SEGENTRY(sup, fs, datosn(fs, fs->lfs_offset), bp); 496 sup->su_flags |= SEGUSE_DIRTY | SEGUSE_ACTIVE; 497 (void) VOP_BWRITE(bp); /* Ifile */ 498 499 return (0); 500 out: 501 if (bp) 502 brelse(bp); 503 if (abp) 504 brelse(abp); 505 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 506 (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, p); 507 VOP_UNLOCK(devvp, 0); 508 if (ump) { 509 free(ump->um_lfs, M_UFSMNT); 510 free(ump, M_UFSMNT); 511 mp->mnt_data = (qaddr_t)0; 512 } 513 return (error); 514 } 515 516 /* 517 * unmount system call 518 */ 519 int 520 lfs_unmount(mp, mntflags, p) 521 struct mount *mp; 522 int mntflags; 523 struct proc *p; 524 { 525 struct ufsmount *ump; 526 struct lfs *fs; 527 int error, flags, ronly; 528 extern int lfs_allclean_wakeup; 529 530 flags = 0; 531 if (mntflags & MNT_FORCE) 532 flags |= FORCECLOSE; 533 534 ump = VFSTOUFS(mp); 535 fs = ump->um_lfs; 536 #ifdef QUOTA 537 if (mp->mnt_flag & MNT_QUOTA) { 538 int i; 539 error = vflush(mp, fs->lfs_ivnode, SKIPSYSTEM|flags); 540 if (error) 541 return (error); 542 for (i = 0; i < MAXQUOTAS; i++) { 543 if (ump->um_quotas[i] == NULLVP) 544 continue; 545 quotaoff(p, mp, i); 546 } 547 /* 548 * Here we fall through to vflush again to ensure 549 * that we have gotten rid of all the system vnodes. 550 */ 551 } 552 #endif 553 if ((error = vflush(mp, fs->lfs_ivnode, flags)) != 0) 554 return (error); 555 fs->lfs_clean = 1; 556 if ((error = VFS_SYNC(mp, 1, p->p_ucred, p)) != 0) 557 return (error); 558 if (fs->lfs_ivnode->v_dirtyblkhd.lh_first) 559 panic("lfs_unmount: still dirty blocks on ifile vnode\n"); 560 vrele(fs->lfs_ivnode); 561 vgone(fs->lfs_ivnode); 562 563 ronly = !fs->lfs_ronly; 564 if (ump->um_devvp->v_type != VBAD) 565 ump->um_devvp->v_specmountpoint = NULL; 566 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY); 567 error = VOP_CLOSE(ump->um_devvp, 568 ronly ? FREAD : FREAD|FWRITE, NOCRED, p); 569 vput(ump->um_devvp); 570 571 /* XXX KS - wake up the cleaner so it can die */ 572 wakeup(&fs->lfs_nextseg); 573 wakeup(&lfs_allclean_wakeup); 574 575 free(fs, M_UFSMNT); 576 free(ump, M_UFSMNT); 577 mp->mnt_data = (qaddr_t)0; 578 mp->mnt_flag &= ~MNT_LOCAL; 579 return (error); 580 } 581 582 /* 583 * Get file system statistics. 584 */ 585 int 586 lfs_statfs(mp, sbp, p) 587 struct mount *mp; 588 struct statfs *sbp; 589 struct proc *p; 590 { 591 struct lfs *fs; 592 struct ufsmount *ump; 593 594 ump = VFSTOUFS(mp); 595 fs = ump->um_lfs; 596 if (fs->lfs_magic != LFS_MAGIC) 597 panic("lfs_statfs: magic"); 598 599 sbp->f_type = 0; 600 sbp->f_bsize = fs->lfs_fsize; 601 sbp->f_iosize = fs->lfs_bsize; 602 sbp->f_blocks = dbtofrags(fs, LFS_EST_NONMETA(fs)); 603 sbp->f_bfree = dbtofrags(fs, LFS_EST_BFREE(fs)); 604 sbp->f_bavail = dbtofrags(fs, (long)LFS_EST_BFREE(fs) - 605 (long)LFS_EST_RSVD(fs)); 606 sbp->f_files = dbtofsb(fs,fs->lfs_bfree) * INOPB(fs); 607 sbp->f_ffree = sbp->f_files - fs->lfs_nfiles; 608 if (sbp != &mp->mnt_stat) { 609 bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN); 610 bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN); 611 } 612 strncpy(sbp->f_fstypename, mp->mnt_op->vfs_name, MFSNAMELEN); 613 return (0); 614 } 615 616 /* 617 * Go through the disk queues to initiate sandbagged IO; 618 * go through the inodes to write those that have been modified; 619 * initiate the writing of the super block if it has been modified. 620 * 621 * Note: we are always called with the filesystem marked `MPBUSY'. 622 */ 623 int 624 lfs_sync(mp, waitfor, cred, p) 625 struct mount *mp; 626 int waitfor; 627 struct ucred *cred; 628 struct proc *p; 629 { 630 int error; 631 struct lfs *fs; 632 633 fs = ((struct ufsmount *)mp->mnt_data)->ufsmount_u.lfs; 634 if (fs->lfs_ronly) 635 return 0; 636 while(fs->lfs_dirops) 637 error = tsleep(&fs->lfs_dirops, PRIBIO + 1, "lfs_dirops", 0); 638 fs->lfs_writer++; 639 640 /* All syncs must be checkpoints until roll-forward is implemented. */ 641 error = lfs_segwrite(mp, SEGM_CKP | (waitfor ? SEGM_SYNC : 0)); 642 if(--fs->lfs_writer==0) 643 wakeup(&fs->lfs_dirops); 644 #ifdef QUOTA 645 qsync(mp); 646 #endif 647 return (error); 648 } 649 650 extern struct lock ufs_hashlock; 651 652 /* 653 * Look up an LFS dinode number to find its incore vnode. If not already 654 * in core, read it in from the specified device. Return the inode locked. 655 * Detection and handling of mount points must be done by the calling routine. 656 */ 657 int 658 lfs_vget(mp, ino, vpp) 659 struct mount *mp; 660 ino_t ino; 661 struct vnode **vpp; 662 { 663 struct lfs *fs; 664 struct inode *ip; 665 struct buf *bp; 666 struct ifile *ifp; 667 struct vnode *vp; 668 struct ufsmount *ump; 669 ufs_daddr_t daddr; 670 dev_t dev; 671 int error; 672 #ifdef LFS_ATIME_IFILE 673 struct timespec ts; 674 #endif 675 676 ump = VFSTOUFS(mp); 677 dev = ump->um_dev; 678 679 if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL) 680 return (0); 681 682 if ((error = getnewvnode(VT_LFS, mp, lfs_vnodeop_p, &vp)) != 0) { 683 *vpp = NULL; 684 return (error); 685 } 686 687 do { 688 if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL) { 689 ungetnewvnode(vp); 690 return (0); 691 } 692 } while (lockmgr(&ufs_hashlock, LK_EXCLUSIVE|LK_SLEEPFAIL, 0)); 693 694 /* Translate the inode number to a disk address. */ 695 fs = ump->um_lfs; 696 if (ino == LFS_IFILE_INUM) 697 daddr = fs->lfs_idaddr; 698 else { 699 LFS_IENTRY(ifp, fs, ino, bp); 700 daddr = ifp->if_daddr; 701 #ifdef LFS_ATIME_IFILE 702 ts = ifp->if_atime; /* structure copy */ 703 #endif 704 brelse(bp); 705 if (daddr == LFS_UNUSED_DADDR) { 706 lockmgr(&ufs_hashlock, LK_RELEASE, 0); 707 return (ENOENT); 708 } 709 } 710 711 /* Allocate/init new vnode/inode. */ 712 lfs_vcreate(mp, ino, vp); 713 714 /* 715 * Put it onto its hash chain and lock it so that other requests for 716 * this inode will block if they arrive while we are sleeping waiting 717 * for old data structures to be purged or for the contents of the 718 * disk portion of this inode to be read. 719 */ 720 ip = VTOI(vp); 721 ufs_ihashins(ip); 722 lockmgr(&ufs_hashlock, LK_RELEASE, 0); 723 724 /* 725 * XXX 726 * This may not need to be here, logically it should go down with 727 * the i_devvp initialization. 728 * Ask Kirk. 729 */ 730 ip->i_lfs = ump->um_lfs; 731 732 /* Read in the disk contents for the inode, copy into the inode. */ 733 error = bread(ump->um_devvp, daddr, (int)fs->lfs_bsize, NOCRED, &bp); 734 if (error) { 735 /* 736 * The inode does not contain anything useful, so it would 737 * be misleading to leave it on its hash chain. With mode 738 * still zero, it will be unlinked and returned to the free 739 * list by vput(). 740 */ 741 vput(vp); 742 brelse(bp); 743 *vpp = NULL; 744 return (error); 745 } 746 ip->i_din.ffs_din = *lfs_ifind(fs, ino, bp); 747 ip->i_ffs_effnlink = ip->i_ffs_nlink; 748 ip->i_lfs_effnblks = ip->i_ffs_blocks; 749 #ifdef LFS_ATIME_IFILE 750 ip->i_ffs_atime = ts.tv_sec; 751 ip->i_ffs_atimensec = ts.tv_nsec; 752 #endif 753 brelse(bp); 754 755 /* 756 * Initialize the vnode from the inode, check for aliases. In all 757 * cases re-init ip, the underlying vnode/inode may have changed. 758 */ 759 error = ufs_vinit(mp, lfs_specop_p, lfs_fifoop_p, &vp); 760 if (error) { 761 vput(vp); 762 *vpp = NULL; 763 return (error); 764 } 765 #ifdef DIAGNOSTIC 766 if(vp->v_type == VNON) { 767 panic("lfs_vget: ino %d is type VNON! (ifmt %o)\n", 768 ip->i_number, (ip->i_ffs_mode & IFMT) >> 12); 769 } 770 #endif 771 /* 772 * Finish inode initialization now that aliasing has been resolved. 773 */ 774 ip->i_devvp = ump->um_devvp; 775 VREF(ip->i_devvp); 776 *vpp = vp; 777 778 return (0); 779 } 780 781 /* 782 * File handle to vnode 783 * 784 * Have to be really careful about stale file handles: 785 * - check that the inode number is valid 786 * - call lfs_vget() to get the locked inode 787 * - check for an unallocated inode (i_mode == 0) 788 * 789 * XXX 790 * use ifile to see if inode is allocated instead of reading off disk 791 * what is the relationship between my generational number and the NFS 792 * generational number. 793 */ 794 int 795 lfs_fhtovp(mp, fhp, vpp) 796 struct mount *mp; 797 struct fid *fhp; 798 struct vnode **vpp; 799 { 800 struct ufid *ufhp; 801 802 ufhp = (struct ufid *)fhp; 803 if (ufhp->ufid_ino < ROOTINO) 804 return (ESTALE); 805 return (ufs_fhtovp(mp, ufhp, vpp)); 806 } 807 808 /* 809 * Vnode pointer to File handle 810 */ 811 /* ARGSUSED */ 812 int 813 lfs_vptofh(vp, fhp) 814 struct vnode *vp; 815 struct fid *fhp; 816 { 817 struct inode *ip; 818 struct ufid *ufhp; 819 820 ip = VTOI(vp); 821 ufhp = (struct ufid *)fhp; 822 ufhp->ufid_len = sizeof(struct ufid); 823 ufhp->ufid_ino = ip->i_number; 824 ufhp->ufid_gen = ip->i_ffs_gen; 825 return (0); 826 } 827 828 int 829 lfs_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) 830 int *name; 831 u_int namelen; 832 void *oldp; 833 size_t *oldlenp; 834 void *newp; 835 size_t newlen; 836 struct proc *p; 837 { 838 extern int lfs_writeindir, lfs_dostats, lfs_clean_vnhead; 839 extern struct lfs_stats lfs_stats; 840 int error; 841 842 /* all sysctl names at this level are terminal */ 843 if (namelen != 1) 844 return (ENOTDIR); 845 846 switch (name[0]) { 847 case LFS_WRITEINDIR: 848 return (sysctl_int(oldp, oldlenp, newp, newlen, 849 &lfs_writeindir)); 850 case LFS_CLEAN_VNHEAD: 851 return (sysctl_int(oldp, oldlenp, newp, newlen, 852 &lfs_clean_vnhead)); 853 case LFS_DOSTATS: 854 if((error = sysctl_int(oldp, oldlenp, newp, newlen, 855 &lfs_dostats))) 856 return error; 857 if(lfs_dostats == 0) 858 memset(&lfs_stats,0,sizeof(lfs_stats)); 859 return 0; 860 case LFS_STATS: 861 return (sysctl_rdstruct(oldp, oldlenp, newp, 862 &lfs_stats, sizeof(lfs_stats))); 863 default: 864 return (EOPNOTSUPP); 865 } 866 /* NOTREACHED */ 867 } 868
Indexes created Tue Sep 30 20:09:53 GMT 2025