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