ext2fs_vfsops.c revision 1.24.4.3
1 /* $NetBSD: ext2fs_vfsops.c,v 1.24.4.3 1999/08/06 12:55:29 chs Exp $ */ 2 3 /* 4 * Copyright (c) 1997 Manuel Bouyer. 5 * Copyright (c) 1989, 1991, 1993, 1994 6 * The Regents of the University of California. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by the University of 19 * California, Berkeley and its contributors. 20 * 4. Neither the name of the University nor the names of its contributors 21 * may be used to endorse or promote products derived from this software 22 * without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 * 36 * @(#)ffs_vfsops.c 8.14 (Berkeley) 11/28/94 37 * Modified for ext2fs by Manuel Bouyer. 38 */ 39 40 #if defined(_KERNEL) && !defined(_LKM) 41 #include "opt_compat_netbsd.h" 42 #endif 43 44 #include <sys/param.h> 45 #include <sys/systm.h> 46 #include <sys/namei.h> 47 #include <sys/proc.h> 48 #include <sys/kernel.h> 49 #include <sys/vnode.h> 50 #include <sys/socket.h> 51 #include <sys/mount.h> 52 #include <sys/buf.h> 53 #include <sys/device.h> 54 #include <sys/mbuf.h> 55 #include <sys/file.h> 56 #include <sys/disklabel.h> 57 #include <sys/ioctl.h> 58 #include <sys/errno.h> 59 #include <sys/malloc.h> 60 #include <sys/pool.h> 61 #include <sys/lock.h> 62 63 #include <miscfs/specfs/specdev.h> 64 65 #include <ufs/ufs/quota.h> 66 #include <ufs/ufs/ufsmount.h> 67 #include <ufs/ufs/inode.h> 68 #include <ufs/ufs/dir.h> 69 #include <ufs/ufs/ufs_extern.h> 70 71 #include <ufs/ext2fs/ext2fs.h> 72 #include <ufs/ext2fs/ext2fs_extern.h> 73 74 extern struct lock ufs_hashlock; 75 76 int ext2fs_sbupdate __P((struct ufsmount *, int)); 77 78 extern struct vnodeopv_desc ext2fs_vnodeop_opv_desc; 79 extern struct vnodeopv_desc ext2fs_specop_opv_desc; 80 extern struct vnodeopv_desc ext2fs_fifoop_opv_desc; 81 82 struct vnodeopv_desc *ext2fs_vnodeopv_descs[] = { 83 &ext2fs_vnodeop_opv_desc, 84 &ext2fs_specop_opv_desc, 85 &ext2fs_fifoop_opv_desc, 86 NULL, 87 }; 88 89 struct vfsops ext2fs_vfsops = { 90 MOUNT_EXT2FS, 91 ext2fs_mount, 92 ufs_start, 93 ext2fs_unmount, 94 ufs_root, 95 ufs_quotactl, 96 ext2fs_statfs, 97 ext2fs_sync, 98 ext2fs_vget, 99 ext2fs_fhtovp, 100 ext2fs_vptofh, 101 ext2fs_init, 102 ext2fs_sysctl, 103 ext2fs_mountroot, 104 ufs_check_export, 105 ext2fs_vnodeopv_descs, 106 }; 107 108 struct pool ext2fs_inode_pool; 109 110 extern u_long ext2gennumber; 111 112 void 113 ext2fs_init() 114 { 115 ufs_init(); 116 117 /* 118 * XXX Same structure as FFS inodes? Should we share a common pool? 119 */ 120 pool_init(&ext2fs_inode_pool, sizeof(struct inode), 0, 0, 0, 121 "ext2fsinopl", 0, pool_page_alloc_nointr, pool_page_free_nointr, 122 M_EXT2FSNODE); 123 } 124 125 126 /* 127 * Called by main() when ext2fs is going to be mounted as root. 128 * 129 * Name is updated by mount(8) after booting. 130 */ 131 #define ROOTNAME "root_device" 132 133 int 134 ext2fs_mountroot() 135 { 136 extern struct vnode *rootvp; 137 struct m_ext2fs *fs; 138 struct mount *mp; 139 struct proc *p = curproc; /* XXX */ 140 struct ufsmount *ump; 141 int error; 142 143 if (root_device->dv_class != DV_DISK) 144 return (ENODEV); 145 146 /* 147 * Get vnodes for rootdev. 148 */ 149 if (bdevvp(rootdev, &rootvp)) 150 panic("ext2fs_mountroot: can't setup bdevvp's"); 151 152 if ((error = vfs_rootmountalloc(MOUNT_EXT2FS, "root_device", &mp))) { 153 vrele(rootvp); 154 return (error); 155 } 156 157 if ((error = ext2fs_mountfs(rootvp, mp, p)) != 0) { 158 mp->mnt_op->vfs_refcount--; 159 vfs_unbusy(mp); 160 free(mp, M_MOUNT); 161 vrele(rootvp); 162 return (error); 163 } 164 simple_lock(&mountlist_slock); 165 CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list); 166 simple_unlock(&mountlist_slock); 167 ump = VFSTOUFS(mp); 168 fs = ump->um_e2fs; 169 memset(fs->e2fs_fsmnt, 0, sizeof(fs->e2fs_fsmnt)); 170 (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs_fsmnt, 171 MNAMELEN - 1, 0); 172 (void)ext2fs_statfs(mp, &mp->mnt_stat, p); 173 vfs_unbusy(mp); 174 inittodr(fs->e2fs.e2fs_wtime); 175 return (0); 176 } 177 178 /* 179 * VFS Operations. 180 * 181 * mount system call 182 */ 183 int 184 ext2fs_mount(mp, path, data, ndp, p) 185 register struct mount *mp; 186 const char *path; 187 void * data; 188 struct nameidata *ndp; 189 struct proc *p; 190 { 191 struct vnode *devvp; 192 struct ufs_args args; 193 struct ufsmount *ump = NULL; 194 register struct m_ext2fs *fs; 195 size_t size; 196 int error, flags; 197 mode_t accessmode; 198 199 error = copyin(data, (caddr_t)&args, sizeof (struct ufs_args)); 200 if (error) 201 return (error); 202 /* 203 * If updating, check whether changing from read-only to 204 * read/write; if there is no device name, that's all we do. 205 */ 206 if (mp->mnt_flag & MNT_UPDATE) { 207 ump = VFSTOUFS(mp); 208 fs = ump->um_e2fs; 209 if (fs->e2fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) { 210 flags = WRITECLOSE; 211 if (mp->mnt_flag & MNT_FORCE) 212 flags |= FORCECLOSE; 213 error = ext2fs_flushfiles(mp, flags, p); 214 if (error == 0 && 215 ext2fs_cgupdate(ump, MNT_WAIT) == 0 && 216 (fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) { 217 fs->e2fs.e2fs_state = E2FS_ISCLEAN; 218 (void) ext2fs_sbupdate(ump, MNT_WAIT); 219 } 220 if (error) 221 return (error); 222 fs->e2fs_ronly = 1; 223 } 224 if (mp->mnt_flag & MNT_RELOAD) { 225 error = ext2fs_reload(mp, ndp->ni_cnd.cn_cred, p); 226 if (error) 227 return (error); 228 } 229 if (fs->e2fs_ronly && (mp->mnt_flag & MNT_WANTRDWR)) { 230 /* 231 * If upgrade to read-write by non-root, then verify 232 * that user has necessary permissions on the device. 233 */ 234 if (p->p_ucred->cr_uid != 0) { 235 devvp = ump->um_devvp; 236 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 237 error = VOP_ACCESS(devvp, VREAD | VWRITE, 238 p->p_ucred, p); 239 VOP_UNLOCK(devvp, 0); 240 if (error) 241 return (error); 242 } 243 fs->e2fs_ronly = 0; 244 if (fs->e2fs.e2fs_state == E2FS_ISCLEAN) 245 fs->e2fs.e2fs_state = 0; 246 else 247 fs->e2fs.e2fs_state = E2FS_ERRORS; 248 fs->e2fs_fmod = 1; 249 } 250 if (args.fspec == 0) { 251 /* 252 * Process export requests. 253 */ 254 return (vfs_export(mp, &ump->um_export, &args.export)); 255 } 256 } 257 /* 258 * Not an update, or updating the name: look up the name 259 * and verify that it refers to a sensible block device. 260 */ 261 NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p); 262 if ((error = namei(ndp)) != 0) 263 return (error); 264 devvp = ndp->ni_vp; 265 266 if (devvp->v_type != VBLK) { 267 vrele(devvp); 268 return (ENOTBLK); 269 } 270 if (major(devvp->v_rdev) >= nblkdev) { 271 vrele(devvp); 272 return (ENXIO); 273 } 274 /* 275 * If mount by non-root, then verify that user has necessary 276 * permissions on the device. 277 */ 278 if (p->p_ucred->cr_uid != 0) { 279 accessmode = VREAD; 280 if ((mp->mnt_flag & MNT_RDONLY) == 0) 281 accessmode |= VWRITE; 282 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 283 error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p); 284 VOP_UNLOCK(devvp, 0); 285 if (error) { 286 vrele(devvp); 287 return (error); 288 } 289 } 290 if ((mp->mnt_flag & MNT_UPDATE) == 0) 291 error = ext2fs_mountfs(devvp, mp, p); 292 else { 293 if (devvp != ump->um_devvp) 294 error = EINVAL; /* needs translation */ 295 else 296 vrele(devvp); 297 } 298 if (error) { 299 vrele(devvp); 300 return (error); 301 } 302 ump = VFSTOUFS(mp); 303 fs = ump->um_e2fs; 304 (void) copyinstr(path, fs->e2fs_fsmnt, sizeof(fs->e2fs_fsmnt) - 1, &size); 305 memset(fs->e2fs_fsmnt + size, 0, sizeof(fs->e2fs_fsmnt) - size); 306 memcpy(mp->mnt_stat.f_mntonname, fs->e2fs_fsmnt, MNAMELEN); 307 (void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, 308 &size); 309 memset(mp->mnt_stat.f_mntfromname + size, 0, MNAMELEN - size); 310 if (fs->e2fs_fmod != 0) { /* XXX */ 311 fs->e2fs_fmod = 0; 312 if (fs->e2fs.e2fs_state == 0) 313 fs->e2fs.e2fs_wtime = time.tv_sec; 314 else 315 printf("%s: file system not clean; please fsck(8)\n", 316 mp->mnt_stat.f_mntfromname); 317 (void) ext2fs_cgupdate(ump, MNT_WAIT); 318 } 319 return (0); 320 } 321 322 /* 323 * Reload all incore data for a filesystem (used after running fsck on 324 * the root filesystem and finding things to fix). The filesystem must 325 * be mounted read-only. 326 * 327 * Things to do to update the mount: 328 * 1) invalidate all cached meta-data. 329 * 2) re-read superblock from disk. 330 * 3) re-read summary information from disk. 331 * 4) invalidate all inactive vnodes. 332 * 5) invalidate all cached file data. 333 * 6) re-read inode data for all active vnodes. 334 */ 335 int 336 ext2fs_reload(mountp, cred, p) 337 register struct mount *mountp; 338 struct ucred *cred; 339 struct proc *p; 340 { 341 register struct vnode *vp, *nvp, *devvp; 342 struct inode *ip; 343 struct buf *bp; 344 struct m_ext2fs *fs; 345 struct ext2fs *newfs; 346 struct partinfo dpart; 347 int i, size, error; 348 caddr_t cp; 349 350 if ((mountp->mnt_flag & MNT_RDONLY) == 0) 351 return (EINVAL); 352 /* 353 * Step 1: invalidate all cached meta-data. 354 */ 355 devvp = VFSTOUFS(mountp)->um_devvp; 356 if (vinvalbuf(devvp, 0, cred, p, 0, 0)) 357 panic("ext2fs_reload: dirty1"); 358 /* 359 * Step 2: re-read superblock from disk. 360 */ 361 if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, p) != 0) 362 size = DEV_BSIZE; 363 else 364 size = dpart.disklab->d_secsize; 365 error = bread(devvp, (ufs_daddr_t)(SBOFF / size), SBSIZE, NOCRED, &bp); 366 if (error) { 367 brelse(bp); 368 return (error); 369 } 370 newfs = (struct ext2fs *)bp->b_data; 371 if (fs2h16(newfs->e2fs_magic) != E2FS_MAGIC) { 372 brelse(bp); 373 return (EIO); /* XXX needs translation */ 374 } 375 if (fs2h32(newfs->e2fs_rev) != E2FS_REV) { 376 #ifdef DIAGNOSTIC 377 printf("Ext2 fs: unsupported revision number: %x (expected %x)\n", 378 fs2h32(newfs->e2fs_rev), E2FS_REV); 379 #endif 380 brelse(bp); 381 return (EIO); /* XXX needs translation */ 382 } 383 if (fs2h32(newfs->e2fs_log_bsize) > 2) { /* block size = 1024|2048|4096 */ 384 #ifdef DIAGNOSTIC 385 printf("Ext2 fs: bad block size: %d (expected <=2 for ext2 fs)\n", 386 fs2h32(newfs->e2fs_log_bsize)); 387 #endif 388 brelse(bp); 389 return (EIO); /* XXX needs translation */ 390 } 391 392 393 fs = VFSTOUFS(mountp)->um_e2fs; 394 /* 395 * copy in new superblock, and compute in-memory values 396 */ 397 e2fs_sbload(newfs, &fs->e2fs); 398 fs->e2fs_ncg = 399 howmany(fs->e2fs.e2fs_bcount - fs->e2fs.e2fs_first_dblock, 400 fs->e2fs.e2fs_bpg); 401 /* XXX assume hw bsize = 512 */ 402 fs->e2fs_fsbtodb = fs->e2fs.e2fs_log_bsize + 1; 403 fs->e2fs_bsize = 1024 << fs->e2fs.e2fs_log_bsize; 404 fs->e2fs_bshift = LOG_MINBSIZE + fs->e2fs.e2fs_log_bsize; 405 fs->e2fs_qbmask = fs->e2fs_bsize - 1; 406 fs->e2fs_bmask = ~fs->e2fs_qbmask; 407 fs->e2fs_ngdb = howmany(fs->e2fs_ncg, 408 fs->e2fs_bsize / sizeof(struct ext2_gd)); 409 fs->e2fs_ipb = fs->e2fs_bsize / EXT2_DINODE_SIZE; 410 fs->e2fs_itpg = fs->e2fs.e2fs_ipg/fs->e2fs_ipb; 411 412 /* 413 * Step 3: re-read summary information from disk. 414 */ 415 416 for (i=0; i < fs->e2fs_ngdb; i++) { 417 error = bread(devvp , 418 fsbtodb(fs, ((fs->e2fs_bsize>1024)? 0 : 1) + i + 1), 419 fs->e2fs_bsize, NOCRED, &bp); 420 if (error) { 421 brelse(bp); 422 return (error); 423 } 424 e2fs_cgload((struct ext2_gd*)bp->b_data, 425 &fs->e2fs_gd[i* fs->e2fs_bsize / sizeof(struct ext2_gd)], 426 fs->e2fs_bsize); 427 brelse(bp); 428 } 429 430 loop: 431 simple_lock(&mntvnode_slock); 432 for (vp = mountp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) { 433 if (vp->v_mount != mountp) { 434 simple_unlock(&mntvnode_slock); 435 goto loop; 436 } 437 nvp = vp->v_mntvnodes.le_next; 438 /* 439 * Step 4: invalidate all inactive vnodes. 440 */ 441 if (vrecycle(vp, &mntvnode_slock, p)) 442 goto loop; 443 /* 444 * Step 5: invalidate all cached file data. 445 */ 446 simple_lock(&vp->v_interlock); 447 simple_unlock(&mntvnode_slock); 448 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK)) 449 goto loop; 450 if (vinvalbuf(vp, 0, cred, p, 0, 0)) 451 panic("ext2fs_reload: dirty2"); 452 /* 453 * Step 6: re-read inode data for all active vnodes. 454 */ 455 ip = VTOI(vp); 456 error = bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)), 457 (int)fs->e2fs_bsize, NOCRED, &bp); 458 if (error) { 459 vput(vp); 460 return (error); 461 } 462 cp = (caddr_t)bp->b_data + 463 (ino_to_fsbo(fs, ip->i_number) * EXT2_DINODE_SIZE); 464 e2fs_iload((struct ext2fs_dinode *)cp, &ip->i_din.e2fs_din); 465 brelse(bp); 466 vput(vp); 467 simple_lock(&mntvnode_slock); 468 } 469 simple_unlock(&mntvnode_slock); 470 return (0); 471 } 472 473 /* 474 * Common code for mount and mountroot 475 */ 476 int 477 ext2fs_mountfs(devvp, mp, p) 478 register struct vnode *devvp; 479 struct mount *mp; 480 struct proc *p; 481 { 482 register struct ufsmount *ump; 483 struct buf *bp; 484 register struct ext2fs *fs; 485 register struct m_ext2fs *m_fs; 486 dev_t dev; 487 struct partinfo dpart; 488 int error, i, size, ronly; 489 struct ucred *cred; 490 extern struct vnode *rootvp; 491 492 dev = devvp->v_rdev; 493 cred = p ? p->p_ucred : NOCRED; 494 /* 495 * Disallow multiple mounts of the same device. 496 * Disallow mounting of a device that is currently in use 497 * (except for root, which might share swap device for miniroot). 498 * Flush out any old buffers remaining from a previous use. 499 */ 500 if ((error = vfs_mountedon(devvp)) != 0) 501 return (error); 502 if (vcount(devvp) > 1 && devvp != rootvp) 503 return (EBUSY); 504 if ((error = vinvalbuf(devvp, V_SAVE, cred, p, 0, 0)) != 0) 505 return (error); 506 507 ronly = (mp->mnt_flag & MNT_RDONLY) != 0; 508 error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p); 509 if (error) 510 return (error); 511 if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, cred, p) != 0) 512 size = DEV_BSIZE; 513 else 514 size = dpart.disklab->d_secsize; 515 516 bp = NULL; 517 ump = NULL; 518 519 #ifdef DEBUG_EXT2 520 printf("sb size: %d ino size %d\n", sizeof(struct ext2fs), 521 EXT2_DINODE_SIZE); 522 #endif 523 error = bread(devvp, (SBOFF / DEV_BSIZE), SBSIZE, cred, &bp); 524 if (error) 525 goto out; 526 fs = (struct ext2fs *)bp->b_data; 527 if (fs2h16(fs->e2fs_magic) != E2FS_MAGIC) { 528 error = EINVAL; /* XXX needs translation */ 529 goto out; 530 } 531 if (fs2h32(fs->e2fs_rev) != E2FS_REV) { 532 #ifdef DIAGNOSTIC 533 printf("Ext2 fs: unsupported revision number: %x (expected %x)\n", 534 fs2h32(fs->e2fs_rev), E2FS_REV); 535 #endif 536 error = EINVAL; /* XXX needs translation */ 537 goto out; 538 } 539 if (fs2h32(fs->e2fs_log_bsize) > 2) { /* block size = 1024|2048|4096 */ 540 #ifdef DIAGNOSTIC 541 printf("Ext2 fs: bad block size: %d (expected <=2 for ext2 fs)\n", 542 fs2h32(fs->e2fs_log_bsize)); 543 #endif 544 error = EINVAL; /* XXX needs translation */ 545 goto out; 546 } 547 548 ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK); 549 memset((caddr_t)ump, 0, sizeof *ump); 550 ump->um_e2fs = malloc(sizeof(struct m_ext2fs), M_UFSMNT, M_WAITOK); 551 memset((caddr_t)ump->um_e2fs, 0, sizeof(struct m_ext2fs)); 552 e2fs_sbload((struct ext2fs*)bp->b_data, &ump->um_e2fs->e2fs); 553 brelse(bp); 554 bp = NULL; 555 m_fs = ump->um_e2fs; 556 m_fs->e2fs_ronly = ronly; 557 if (ronly == 0) { 558 if (m_fs->e2fs.e2fs_state == E2FS_ISCLEAN) 559 m_fs->e2fs.e2fs_state = 0; 560 else 561 m_fs->e2fs.e2fs_state = E2FS_ERRORS; 562 m_fs->e2fs_fmod = 1; 563 } 564 565 /* compute dynamic sb infos */ 566 m_fs->e2fs_ncg = 567 howmany(m_fs->e2fs.e2fs_bcount - m_fs->e2fs.e2fs_first_dblock, 568 m_fs->e2fs.e2fs_bpg); 569 /* XXX assume hw bsize = 512 */ 570 m_fs->e2fs_fsbtodb = m_fs->e2fs.e2fs_log_bsize + 1; 571 m_fs->e2fs_bsize = 1024 << m_fs->e2fs.e2fs_log_bsize; 572 m_fs->e2fs_bshift = LOG_MINBSIZE + m_fs->e2fs.e2fs_log_bsize; 573 m_fs->e2fs_qbmask = m_fs->e2fs_bsize - 1; 574 m_fs->e2fs_bmask = ~m_fs->e2fs_qbmask; 575 m_fs->e2fs_ngdb = howmany(m_fs->e2fs_ncg, 576 m_fs->e2fs_bsize / sizeof(struct ext2_gd)); 577 m_fs->e2fs_ipb = m_fs->e2fs_bsize / EXT2_DINODE_SIZE; 578 m_fs->e2fs_itpg = m_fs->e2fs.e2fs_ipg/m_fs->e2fs_ipb; 579 580 m_fs->e2fs_gd = malloc(m_fs->e2fs_ngdb * m_fs->e2fs_bsize, 581 M_UFSMNT, M_WAITOK); 582 for (i=0; i < m_fs->e2fs_ngdb; i++) { 583 error = bread(devvp , 584 fsbtodb(m_fs, ((m_fs->e2fs_bsize>1024)? 0 : 1) + i + 1), 585 m_fs->e2fs_bsize, NOCRED, &bp); 586 if (error) { 587 free(m_fs->e2fs_gd, M_UFSMNT); 588 goto out; 589 } 590 e2fs_cgload((struct ext2_gd*)bp->b_data, 591 &m_fs->e2fs_gd[ 592 i * m_fs->e2fs_bsize / sizeof(struct ext2_gd)], 593 m_fs->e2fs_bsize); 594 brelse(bp); 595 bp = NULL; 596 } 597 598 mp->mnt_data = (qaddr_t)ump; 599 mp->mnt_stat.f_fsid.val[0] = (long)dev; 600 mp->mnt_stat.f_fsid.val[1] = makefstype(MOUNT_EXT2FS); 601 mp->mnt_maxsymlinklen = EXT2_MAXSYMLINKLEN; 602 mp->mnt_flag |= MNT_LOCAL; 603 mp->mnt_dev_bshift = DEV_BSHIFT; /* XXX */ 604 mp->mnt_fs_bshift = m_fs->e2fs_bshift; 605 ump->um_flags = 0; 606 ump->um_mountp = mp; 607 ump->um_dev = dev; 608 ump->um_devvp = devvp; 609 ump->um_nindir = NINDIR(m_fs); 610 ump->um_bptrtodb = m_fs->e2fs_fsbtodb; 611 ump->um_seqinc = 1; /* no frags */ 612 devvp->v_specflags |= SI_MOUNTEDON; 613 return (0); 614 615 out: 616 if (bp) 617 brelse(bp); 618 (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, p); 619 if (ump) { 620 free(ump->um_e2fs, M_UFSMNT); 621 free(ump, M_UFSMNT); 622 mp->mnt_data = (qaddr_t)0; 623 } 624 return (error); 625 } 626 627 /* 628 * unmount system call 629 */ 630 int 631 ext2fs_unmount(mp, mntflags, p) 632 struct mount *mp; 633 int mntflags; 634 struct proc *p; 635 { 636 register struct ufsmount *ump; 637 register struct m_ext2fs *fs; 638 int error, flags; 639 640 flags = 0; 641 if (mntflags & MNT_FORCE) 642 flags |= FORCECLOSE; 643 if ((error = ext2fs_flushfiles(mp, flags, p)) != 0) 644 return (error); 645 ump = VFSTOUFS(mp); 646 fs = ump->um_e2fs; 647 if (fs->e2fs_ronly == 0 && 648 ext2fs_cgupdate(ump, MNT_WAIT) == 0 && 649 (fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) { 650 fs->e2fs.e2fs_state = E2FS_ISCLEAN; 651 (void) ext2fs_sbupdate(ump, MNT_WAIT); 652 } 653 ump->um_devvp->v_specflags &= ~SI_MOUNTEDON; 654 error = VOP_CLOSE(ump->um_devvp, fs->e2fs_ronly ? FREAD : FREAD|FWRITE, 655 NOCRED, p); 656 vrele(ump->um_devvp); 657 free(fs->e2fs_gd, M_UFSMNT); 658 free(fs, M_UFSMNT); 659 free(ump, M_UFSMNT); 660 mp->mnt_data = (qaddr_t)0; 661 mp->mnt_flag &= ~MNT_LOCAL; 662 return (error); 663 } 664 665 /* 666 * Flush out all the files in a filesystem. 667 */ 668 int 669 ext2fs_flushfiles(mp, flags, p) 670 register struct mount *mp; 671 int flags; 672 struct proc *p; 673 { 674 extern int doforce; 675 register struct ufsmount *ump; 676 int error; 677 678 if (!doforce) 679 flags &= ~FORCECLOSE; 680 ump = VFSTOUFS(mp); 681 error = vflush(mp, NULLVP, flags); 682 return (error); 683 } 684 685 /* 686 * Get file system statistics. 687 */ 688 int 689 ext2fs_statfs(mp, sbp, p) 690 struct mount *mp; 691 register struct statfs *sbp; 692 struct proc *p; 693 { 694 register struct ufsmount *ump; 695 register struct m_ext2fs *fs; 696 u_int32_t overhead, overhead_per_group; 697 698 ump = VFSTOUFS(mp); 699 fs = ump->um_e2fs; 700 if (fs->e2fs.e2fs_magic != E2FS_MAGIC) 701 panic("ext2fs_statfs"); 702 703 #ifdef COMPAT_09 704 sbp->f_type = 1; 705 #else 706 sbp->f_type = 0; 707 #endif 708 709 /* 710 * Compute the overhead (FS structures) 711 */ 712 overhead_per_group = 1 /* super block */ + 713 fs->e2fs_ngdb + 714 1 /* block bitmap */ + 715 1 /* inode bitmap */ + 716 fs->e2fs_itpg; 717 overhead = fs->e2fs.e2fs_first_dblock + 718 fs->e2fs_ncg * overhead_per_group; 719 720 721 sbp->f_bsize = fs->e2fs_bsize; 722 sbp->f_iosize = fs->e2fs_bsize; 723 sbp->f_blocks = fs->e2fs.e2fs_bcount - overhead; 724 sbp->f_bfree = fs->e2fs.e2fs_fbcount; 725 sbp->f_bavail = sbp->f_bfree - fs->e2fs.e2fs_rbcount; 726 sbp->f_files = fs->e2fs.e2fs_icount; 727 sbp->f_ffree = fs->e2fs.e2fs_ficount; 728 if (sbp != &mp->mnt_stat) { 729 memcpy(sbp->f_mntonname, mp->mnt_stat.f_mntonname, MNAMELEN); 730 memcpy(sbp->f_mntfromname, mp->mnt_stat.f_mntfromname, MNAMELEN); 731 } 732 strncpy(sbp->f_fstypename, mp->mnt_op->vfs_name, MFSNAMELEN); 733 return (0); 734 } 735 736 /* 737 * Go through the disk queues to initiate sandbagged IO; 738 * go through the inodes to write those that have been modified; 739 * initiate the writing of the super block if it has been modified. 740 * 741 * Note: we are always called with the filesystem marked `MPBUSY'. 742 */ 743 int 744 ext2fs_sync(mp, waitfor, cred, p) 745 struct mount *mp; 746 int waitfor; 747 struct ucred *cred; 748 struct proc *p; 749 { 750 struct vnode *vp, *nvp; 751 struct inode *ip; 752 struct ufsmount *ump = VFSTOUFS(mp); 753 struct m_ext2fs *fs; 754 int error, allerror = 0; 755 756 fs = ump->um_e2fs; 757 if (fs->e2fs_ronly != 0) { /* XXX */ 758 printf("fs = %s\n", fs->e2fs_fsmnt); 759 panic("update: rofs mod"); 760 } 761 762 /* 763 * Write back each (modified) inode. 764 */ 765 simple_lock(&mntvnode_slock); 766 loop: 767 for (vp = mp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) { 768 /* 769 * If the vnode that we are about to sync is no longer 770 * associated with this mount point, start over. 771 */ 772 if (vp->v_mount != mp) 773 goto loop; 774 simple_lock(&vp->v_interlock); 775 nvp = vp->v_mntvnodes.le_next; 776 ip = VTOI(vp); 777 if ((ip->i_flag & 778 (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 && 779 vp->v_dirtyblkhd.lh_first == NULL) { 780 simple_unlock(&vp->v_interlock); 781 continue; 782 } 783 simple_unlock(&mntvnode_slock); 784 error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK); 785 if (error) { 786 simple_lock(&mntvnode_slock); 787 if (error == ENOENT) 788 goto loop; 789 continue; 790 } 791 if ((error = VOP_FSYNC(vp, cred, 792 waitfor == MNT_WAIT ? FSYNC_WAIT : 0, p)) != 0) 793 allerror = error; 794 vput(vp); 795 simple_lock(&mntvnode_slock); 796 } 797 simple_unlock(&mntvnode_slock); 798 /* 799 * Force stale file system control information to be flushed. 800 */ 801 if ((error = VOP_FSYNC(ump->um_devvp, cred, 802 waitfor == MNT_WAIT ? FSYNC_WAIT : 0, p)) != 0) 803 allerror = error; 804 /* 805 * Write back modified superblock. 806 */ 807 if (fs->e2fs_fmod != 0) { 808 fs->e2fs_fmod = 0; 809 fs->e2fs.e2fs_wtime = time.tv_sec; 810 if ((error = ext2fs_cgupdate(ump, waitfor))) 811 allerror = error; 812 } 813 return (allerror); 814 } 815 816 /* 817 * Look up a EXT2FS dinode number to find its incore vnode, otherwise read it 818 * in from disk. If it is in core, wait for the lock bit to clear, then 819 * return the inode locked. Detection and handling of mount points must be 820 * done by the calling routine. 821 */ 822 int 823 ext2fs_vget(mp, ino, vpp) 824 struct mount *mp; 825 ino_t ino; 826 struct vnode **vpp; 827 { 828 struct m_ext2fs *fs; 829 struct inode *ip; 830 struct ufsmount *ump; 831 struct buf *bp; 832 struct vnode *vp; 833 dev_t dev; 834 int error; 835 caddr_t cp; 836 837 ump = VFSTOUFS(mp); 838 dev = ump->um_dev; 839 do { 840 if ((*vpp = ufs_ihashget(dev, ino)) != NULL) 841 return (0); 842 } while (lockmgr(&ufs_hashlock, LK_EXCLUSIVE|LK_SLEEPFAIL, 0)); 843 844 /* Allocate a new vnode/inode. */ 845 if ((error = getnewvnode(VT_EXT2FS, mp, ext2fs_vnodeop_p, &vp)) != 0) { 846 *vpp = NULL; 847 lockmgr(&ufs_hashlock, LK_RELEASE, 0); 848 return (error); 849 } 850 ip = pool_get(&ext2fs_inode_pool, PR_WAITOK); 851 memset((caddr_t)ip, 0, sizeof(struct inode)); 852 vp->v_data = ip; 853 ip->i_vnode = vp; 854 ip->i_e2fs = fs = ump->um_e2fs; 855 ip->i_dev = dev; 856 ip->i_number = ino; 857 ip->i_e2fs_last_lblk = 0; 858 ip->i_e2fs_last_blk = 0; 859 860 /* 861 * Put it onto its hash chain and lock it so that other requests for 862 * this inode will block if they arrive while we are sleeping waiting 863 * for old data structures to be purged or for the contents of the 864 * disk portion of this inode to be read. 865 */ 866 ufs_ihashins(ip); 867 lockmgr(&ufs_hashlock, LK_RELEASE, 0); 868 869 /* Read in the disk contents for the inode, copy into the inode. */ 870 error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)), 871 (int)fs->e2fs_bsize, NOCRED, &bp); 872 if (error) { 873 /* 874 * The inode does not contain anything useful, so it would 875 * be misleading to leave it on its hash chain. With mode 876 * still zero, it will be unlinked and returned to the free 877 * list by vput(). 878 */ 879 vput(vp); 880 brelse(bp); 881 *vpp = NULL; 882 return (error); 883 } 884 cp = (caddr_t)bp->b_data + 885 (ino_to_fsbo(fs, ino) * EXT2_DINODE_SIZE); 886 e2fs_iload((struct ext2fs_dinode *)cp, &ip->i_din.e2fs_din); 887 brelse(bp); 888 889 /* If the inode was deleted, reset all fields */ 890 if (ip->i_e2fs_dtime != 0) { 891 ip->i_e2fs_mode = ip->i_e2fs_size = ip->i_e2fs_nblock = 0; 892 memset(ip->i_e2fs_blocks, 0, sizeof(ip->i_e2fs_blocks)); 893 } 894 895 /* 896 * Initialize the vnode from the inode, check for aliases. 897 * Note that the underlying vnode may have changed. 898 */ 899 error = ext2fs_vinit(mp, ext2fs_specop_p, ext2fs_fifoop_p, &vp); 900 if (error) { 901 vput(vp); 902 *vpp = NULL; 903 return (error); 904 } 905 /* 906 * Finish inode initialization now that aliasing has been resolved. 907 */ 908 ip->i_devvp = ump->um_devvp; 909 VREF(ip->i_devvp); 910 /* 911 * Set up a generation number for this inode if it does not 912 * already have one. This should only happen on old filesystems. 913 */ 914 if (ip->i_e2fs_gen == 0) { 915 if (++ext2gennumber < (u_long)time.tv_sec) 916 ext2gennumber = time.tv_sec; 917 ip->i_e2fs_gen = ext2gennumber; 918 if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) 919 ip->i_flag |= IN_MODIFIED; 920 } 921 922 vp->v_uvm.u_size = ip->i_e2fs_size; 923 *vpp = vp; 924 return (0); 925 } 926 927 /* 928 * File handle to vnode 929 * 930 * Have to be really careful about stale file handles: 931 * - check that the inode number is valid 932 * - call ext2fs_vget() to get the locked inode 933 * - check for an unallocated inode (i_mode == 0) 934 */ 935 int 936 ext2fs_fhtovp(mp, fhp, vpp) 937 register struct mount *mp; 938 struct fid *fhp; 939 struct vnode **vpp; 940 { 941 register struct inode *ip; 942 struct vnode *nvp; 943 int error; 944 register struct ufid *ufhp; 945 struct m_ext2fs *fs; 946 947 ufhp = (struct ufid *)fhp; 948 fs = VFSTOUFS(mp)->um_e2fs; 949 if ((ufhp->ufid_ino < EXT2_FIRSTINO && ufhp->ufid_ino != EXT2_ROOTINO) || 950 ufhp->ufid_ino >= fs->e2fs_ncg * fs->e2fs.e2fs_ipg) 951 return (ESTALE); 952 953 if ((error = VFS_VGET(mp, ufhp->ufid_ino, &nvp)) != 0) { 954 *vpp = NULLVP; 955 return (error); 956 } 957 ip = VTOI(nvp); 958 if (ip->i_e2fs_mode == 0 || ip->i_e2fs_dtime != 0 || 959 ip->i_e2fs_gen != ufhp->ufid_gen) { 960 vput(nvp); 961 *vpp = NULLVP; 962 return (ESTALE); 963 } 964 *vpp = nvp; 965 return (0); 966 } 967 968 /* 969 * Vnode pointer to File handle 970 */ 971 /* ARGSUSED */ 972 int 973 ext2fs_vptofh(vp, fhp) 974 struct vnode *vp; 975 struct fid *fhp; 976 { 977 register struct inode *ip; 978 register struct ufid *ufhp; 979 980 ip = VTOI(vp); 981 ufhp = (struct ufid *)fhp; 982 ufhp->ufid_len = sizeof(struct ufid); 983 ufhp->ufid_ino = ip->i_number; 984 ufhp->ufid_gen = ip->i_e2fs_gen; 985 return (0); 986 } 987 988 int 989 ext2fs_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) 990 int *name; 991 u_int namelen; 992 void *oldp; 993 size_t *oldlenp; 994 void *newp; 995 size_t newlen; 996 struct proc *p; 997 { 998 return (EOPNOTSUPP); 999 } 1000 1001 /* 1002 * Write a superblock and associated information back to disk. 1003 */ 1004 int 1005 ext2fs_sbupdate(mp, waitfor) 1006 struct ufsmount *mp; 1007 int waitfor; 1008 { 1009 register struct m_ext2fs *fs = mp->um_e2fs; 1010 register struct buf *bp; 1011 int error = 0; 1012 1013 bp = getblk(mp->um_devvp, SBLOCK, SBSIZE, 0, 0); 1014 e2fs_sbsave(&fs->e2fs, (struct ext2fs*)bp->b_data); 1015 if (waitfor == MNT_WAIT) 1016 error = bwrite(bp); 1017 else 1018 bawrite(bp); 1019 return (error); 1020 } 1021 1022 int 1023 ext2fs_cgupdate(mp, waitfor) 1024 struct ufsmount *mp; 1025 int waitfor; 1026 { 1027 register struct m_ext2fs *fs = mp->um_e2fs; 1028 register struct buf *bp; 1029 int i, error = 0, allerror = 0; 1030 1031 allerror = ext2fs_sbupdate(mp, waitfor); 1032 for (i = 0; i < fs->e2fs_ngdb; i++) { 1033 bp = getblk(mp->um_devvp, fsbtodb(fs, ((fs->e2fs_bsize>1024)?0:1)+i+1), 1034 fs->e2fs_bsize, 0, 0); 1035 e2fs_cgsave(&fs->e2fs_gd[i* fs->e2fs_bsize / sizeof(struct ext2_gd)], 1036 (struct ext2_gd*)bp->b_data, fs->e2fs_bsize); 1037 if (waitfor == MNT_WAIT) 1038 error = bwrite(bp); 1039 else 1040 bawrite(bp); 1041 } 1042 1043 if (!allerror && error) 1044 allerror = error; 1045 return (allerror); 1046 } 1047
Indexes created Sun Oct 12 22:09:51 GMT 2025