ext2fs_vfsops.c revision 1.24
1 /* $NetBSD: ext2fs_vfsops.c,v 1.24 1999/02/26 23:44:49 wrstuden 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 e2fs_sbload((struct ext2fs*)bp->b_data, &ump->um_e2fs->e2fs); 549 brelse(bp); 550 bp = NULL; 551 m_fs = ump->um_e2fs; 552 m_fs->e2fs_ronly = ronly; 553 if (ronly == 0) { 554 if (m_fs->e2fs.e2fs_state == E2FS_ISCLEAN) 555 m_fs->e2fs.e2fs_state = 0; 556 else 557 m_fs->e2fs.e2fs_state = E2FS_ERRORS; 558 m_fs->e2fs_fmod = 1; 559 } 560 561 /* compute dynamic sb infos */ 562 m_fs->e2fs_ncg = 563 howmany(m_fs->e2fs.e2fs_bcount - m_fs->e2fs.e2fs_first_dblock, 564 m_fs->e2fs.e2fs_bpg); 565 /* XXX assume hw bsize = 512 */ 566 m_fs->e2fs_fsbtodb = m_fs->e2fs.e2fs_log_bsize + 1; 567 m_fs->e2fs_bsize = 1024 << m_fs->e2fs.e2fs_log_bsize; 568 m_fs->e2fs_bshift = LOG_MINBSIZE + m_fs->e2fs.e2fs_log_bsize; 569 m_fs->e2fs_qbmask = m_fs->e2fs_bsize - 1; 570 m_fs->e2fs_bmask = ~m_fs->e2fs_qbmask; 571 m_fs->e2fs_ngdb = howmany(m_fs->e2fs_ncg, 572 m_fs->e2fs_bsize / sizeof(struct ext2_gd)); 573 m_fs->e2fs_ipb = m_fs->e2fs_bsize / EXT2_DINODE_SIZE; 574 m_fs->e2fs_itpg = m_fs->e2fs.e2fs_ipg/m_fs->e2fs_ipb; 575 576 m_fs->e2fs_gd = malloc(m_fs->e2fs_ngdb * m_fs->e2fs_bsize, 577 M_UFSMNT, M_WAITOK); 578 for (i=0; i < m_fs->e2fs_ngdb; i++) { 579 error = bread(devvp , 580 fsbtodb(m_fs, ((m_fs->e2fs_bsize>1024)? 0 : 1) + i + 1), 581 m_fs->e2fs_bsize, NOCRED, &bp); 582 if (error) { 583 free(m_fs->e2fs_gd, M_UFSMNT); 584 goto out; 585 } 586 e2fs_cgload((struct ext2_gd*)bp->b_data, 587 &m_fs->e2fs_gd[ 588 i * m_fs->e2fs_bsize / sizeof(struct ext2_gd)], 589 m_fs->e2fs_bsize); 590 brelse(bp); 591 bp = NULL; 592 } 593 594 mp->mnt_data = (qaddr_t)ump; 595 mp->mnt_stat.f_fsid.val[0] = (long)dev; 596 mp->mnt_stat.f_fsid.val[1] = makefstype(MOUNT_EXT2FS); 597 mp->mnt_maxsymlinklen = EXT2_MAXSYMLINKLEN; 598 mp->mnt_flag |= MNT_LOCAL; 599 ump->um_flags = 0; 600 ump->um_mountp = mp; 601 ump->um_dev = dev; 602 ump->um_devvp = devvp; 603 ump->um_nindir = NINDIR(m_fs); 604 ump->um_bptrtodb = m_fs->e2fs_fsbtodb; 605 ump->um_seqinc = 1; /* no frags */ 606 devvp->v_specflags |= SI_MOUNTEDON; 607 return (0); 608 out: 609 if (bp) 610 brelse(bp); 611 (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, p); 612 if (ump) { 613 free(ump->um_e2fs, M_UFSMNT); 614 free(ump, M_UFSMNT); 615 mp->mnt_data = (qaddr_t)0; 616 } 617 return (error); 618 } 619 620 /* 621 * unmount system call 622 */ 623 int 624 ext2fs_unmount(mp, mntflags, p) 625 struct mount *mp; 626 int mntflags; 627 struct proc *p; 628 { 629 register struct ufsmount *ump; 630 register struct m_ext2fs *fs; 631 int error, flags; 632 633 flags = 0; 634 if (mntflags & MNT_FORCE) 635 flags |= FORCECLOSE; 636 if ((error = ext2fs_flushfiles(mp, flags, p)) != 0) 637 return (error); 638 ump = VFSTOUFS(mp); 639 fs = ump->um_e2fs; 640 if (fs->e2fs_ronly == 0 && 641 ext2fs_cgupdate(ump, MNT_WAIT) == 0 && 642 (fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) { 643 fs->e2fs.e2fs_state = E2FS_ISCLEAN; 644 (void) ext2fs_sbupdate(ump, MNT_WAIT); 645 } 646 ump->um_devvp->v_specflags &= ~SI_MOUNTEDON; 647 error = VOP_CLOSE(ump->um_devvp, fs->e2fs_ronly ? FREAD : FREAD|FWRITE, 648 NOCRED, p); 649 vrele(ump->um_devvp); 650 free(fs->e2fs_gd, M_UFSMNT); 651 free(fs, M_UFSMNT); 652 free(ump, M_UFSMNT); 653 mp->mnt_data = (qaddr_t)0; 654 mp->mnt_flag &= ~MNT_LOCAL; 655 return (error); 656 } 657 658 /* 659 * Flush out all the files in a filesystem. 660 */ 661 int 662 ext2fs_flushfiles(mp, flags, p) 663 register struct mount *mp; 664 int flags; 665 struct proc *p; 666 { 667 extern int doforce; 668 register struct ufsmount *ump; 669 int error; 670 671 if (!doforce) 672 flags &= ~FORCECLOSE; 673 ump = VFSTOUFS(mp); 674 error = vflush(mp, NULLVP, flags); 675 return (error); 676 } 677 678 /* 679 * Get file system statistics. 680 */ 681 int 682 ext2fs_statfs(mp, sbp, p) 683 struct mount *mp; 684 register struct statfs *sbp; 685 struct proc *p; 686 { 687 register struct ufsmount *ump; 688 register struct m_ext2fs *fs; 689 u_int32_t overhead, overhead_per_group; 690 691 ump = VFSTOUFS(mp); 692 fs = ump->um_e2fs; 693 if (fs->e2fs.e2fs_magic != E2FS_MAGIC) 694 panic("ext2fs_statfs"); 695 696 #ifdef COMPAT_09 697 sbp->f_type = 1; 698 #else 699 sbp->f_type = 0; 700 #endif 701 702 /* 703 * Compute the overhead (FS structures) 704 */ 705 overhead_per_group = 1 /* super block */ + 706 fs->e2fs_ngdb + 707 1 /* block bitmap */ + 708 1 /* inode bitmap */ + 709 fs->e2fs_itpg; 710 overhead = fs->e2fs.e2fs_first_dblock + 711 fs->e2fs_ncg * overhead_per_group; 712 713 714 sbp->f_bsize = fs->e2fs_bsize; 715 sbp->f_iosize = fs->e2fs_bsize; 716 sbp->f_blocks = fs->e2fs.e2fs_bcount - overhead; 717 sbp->f_bfree = fs->e2fs.e2fs_fbcount; 718 sbp->f_bavail = sbp->f_bfree - fs->e2fs.e2fs_rbcount; 719 sbp->f_files = fs->e2fs.e2fs_icount; 720 sbp->f_ffree = fs->e2fs.e2fs_ficount; 721 if (sbp != &mp->mnt_stat) { 722 memcpy(sbp->f_mntonname, mp->mnt_stat.f_mntonname, MNAMELEN); 723 memcpy(sbp->f_mntfromname, mp->mnt_stat.f_mntfromname, MNAMELEN); 724 } 725 strncpy(sbp->f_fstypename, mp->mnt_op->vfs_name, MFSNAMELEN); 726 return (0); 727 } 728 729 /* 730 * Go through the disk queues to initiate sandbagged IO; 731 * go through the inodes to write those that have been modified; 732 * initiate the writing of the super block if it has been modified. 733 * 734 * Note: we are always called with the filesystem marked `MPBUSY'. 735 */ 736 int 737 ext2fs_sync(mp, waitfor, cred, p) 738 struct mount *mp; 739 int waitfor; 740 struct ucred *cred; 741 struct proc *p; 742 { 743 struct vnode *vp, *nvp; 744 struct inode *ip; 745 struct ufsmount *ump = VFSTOUFS(mp); 746 struct m_ext2fs *fs; 747 int error, allerror = 0; 748 749 fs = ump->um_e2fs; 750 if (fs->e2fs_ronly != 0) { /* XXX */ 751 printf("fs = %s\n", fs->e2fs_fsmnt); 752 panic("update: rofs mod"); 753 } 754 755 /* 756 * Write back each (modified) inode. 757 */ 758 simple_lock(&mntvnode_slock); 759 loop: 760 for (vp = mp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) { 761 /* 762 * If the vnode that we are about to sync is no longer 763 * associated with this mount point, start over. 764 */ 765 if (vp->v_mount != mp) 766 goto loop; 767 simple_lock(&vp->v_interlock); 768 nvp = vp->v_mntvnodes.le_next; 769 ip = VTOI(vp); 770 if ((ip->i_flag & 771 (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 && 772 vp->v_dirtyblkhd.lh_first == NULL) { 773 simple_unlock(&vp->v_interlock); 774 continue; 775 } 776 simple_unlock(&mntvnode_slock); 777 error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK); 778 if (error) { 779 simple_lock(&mntvnode_slock); 780 if (error == ENOENT) 781 goto loop; 782 continue; 783 } 784 if ((error = VOP_FSYNC(vp, cred, 785 waitfor == MNT_WAIT ? FSYNC_WAIT : 0, p)) != 0) 786 allerror = error; 787 vput(vp); 788 simple_lock(&mntvnode_slock); 789 } 790 simple_unlock(&mntvnode_slock); 791 /* 792 * Force stale file system control information to be flushed. 793 */ 794 if ((error = VOP_FSYNC(ump->um_devvp, cred, 795 waitfor == MNT_WAIT ? FSYNC_WAIT : 0, p)) != 0) 796 allerror = error; 797 /* 798 * Write back modified superblock. 799 */ 800 if (fs->e2fs_fmod != 0) { 801 fs->e2fs_fmod = 0; 802 fs->e2fs.e2fs_wtime = time.tv_sec; 803 if ((error = ext2fs_cgupdate(ump, waitfor))) 804 allerror = error; 805 } 806 return (allerror); 807 } 808 809 /* 810 * Look up a EXT2FS dinode number to find its incore vnode, otherwise read it 811 * in from disk. If it is in core, wait for the lock bit to clear, then 812 * return the inode locked. Detection and handling of mount points must be 813 * done by the calling routine. 814 */ 815 int 816 ext2fs_vget(mp, ino, vpp) 817 struct mount *mp; 818 ino_t ino; 819 struct vnode **vpp; 820 { 821 struct m_ext2fs *fs; 822 struct inode *ip; 823 struct ufsmount *ump; 824 struct buf *bp; 825 struct vnode *vp; 826 dev_t dev; 827 int error; 828 caddr_t cp; 829 830 ump = VFSTOUFS(mp); 831 dev = ump->um_dev; 832 do { 833 if ((*vpp = ufs_ihashget(dev, ino)) != NULL) 834 return (0); 835 } while (lockmgr(&ufs_hashlock, LK_EXCLUSIVE|LK_SLEEPFAIL, 0)); 836 837 /* Allocate a new vnode/inode. */ 838 if ((error = getnewvnode(VT_EXT2FS, mp, ext2fs_vnodeop_p, &vp)) != 0) { 839 *vpp = NULL; 840 lockmgr(&ufs_hashlock, LK_RELEASE, 0); 841 return (error); 842 } 843 ip = pool_get(&ext2fs_inode_pool, PR_WAITOK); 844 memset((caddr_t)ip, 0, sizeof(struct inode)); 845 lockinit(&ip->i_lock, PINOD, "inode", 0, 0); 846 vp->v_data = ip; 847 ip->i_vnode = vp; 848 ip->i_e2fs = fs = ump->um_e2fs; 849 ip->i_dev = dev; 850 ip->i_number = ino; 851 ip->i_e2fs_last_lblk = 0; 852 ip->i_e2fs_last_blk = 0; 853 854 /* 855 * Put it onto its hash chain and lock it so that other requests for 856 * this inode will block if they arrive while we are sleeping waiting 857 * for old data structures to be purged or for the contents of the 858 * disk portion of this inode to be read. 859 */ 860 ufs_ihashins(ip); 861 lockmgr(&ufs_hashlock, LK_RELEASE, 0); 862 863 /* Read in the disk contents for the inode, copy into the inode. */ 864 error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)), 865 (int)fs->e2fs_bsize, NOCRED, &bp); 866 if (error) { 867 /* 868 * The inode does not contain anything useful, so it would 869 * be misleading to leave it on its hash chain. With mode 870 * still zero, it will be unlinked and returned to the free 871 * list by vput(). 872 */ 873 vput(vp); 874 brelse(bp); 875 *vpp = NULL; 876 return (error); 877 } 878 cp = (caddr_t)bp->b_data + 879 (ino_to_fsbo(fs, ino) * EXT2_DINODE_SIZE); 880 e2fs_iload((struct ext2fs_dinode *)cp, &ip->i_din.e2fs_din); 881 brelse(bp); 882 883 /* If the inode was deleted, reset all fields */ 884 if (ip->i_e2fs_dtime != 0) { 885 ip->i_e2fs_mode = ip->i_e2fs_size = ip->i_e2fs_nblock = 0; 886 memset(ip->i_e2fs_blocks, 0, sizeof(ip->i_e2fs_blocks)); 887 } 888 889 /* 890 * Initialize the vnode from the inode, check for aliases. 891 * Note that the underlying vnode may have changed. 892 */ 893 error = ext2fs_vinit(mp, ext2fs_specop_p, ext2fs_fifoop_p, &vp); 894 if (error) { 895 vput(vp); 896 *vpp = NULL; 897 return (error); 898 } 899 /* 900 * Finish inode initialization now that aliasing has been resolved. 901 */ 902 ip->i_devvp = ump->um_devvp; 903 VREF(ip->i_devvp); 904 /* 905 * Set up a generation number for this inode if it does not 906 * already have one. This should only happen on old filesystems. 907 */ 908 if (ip->i_e2fs_gen == 0) { 909 if (++ext2gennumber < (u_long)time.tv_sec) 910 ext2gennumber = time.tv_sec; 911 ip->i_e2fs_gen = ext2gennumber; 912 if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) 913 ip->i_flag |= IN_MODIFIED; 914 } 915 916 *vpp = vp; 917 return (0); 918 } 919 920 /* 921 * File handle to vnode 922 * 923 * Have to be really careful about stale file handles: 924 * - check that the inode number is valid 925 * - call ext2fs_vget() to get the locked inode 926 * - check for an unallocated inode (i_mode == 0) 927 */ 928 int 929 ext2fs_fhtovp(mp, fhp, vpp) 930 register struct mount *mp; 931 struct fid *fhp; 932 struct vnode **vpp; 933 { 934 register struct inode *ip; 935 struct vnode *nvp; 936 int error; 937 register struct ufid *ufhp; 938 struct m_ext2fs *fs; 939 940 ufhp = (struct ufid *)fhp; 941 fs = VFSTOUFS(mp)->um_e2fs; 942 if ((ufhp->ufid_ino < EXT2_FIRSTINO && ufhp->ufid_ino != EXT2_ROOTINO) || 943 ufhp->ufid_ino >= fs->e2fs_ncg * fs->e2fs.e2fs_ipg) 944 return (ESTALE); 945 946 if ((error = VFS_VGET(mp, ufhp->ufid_ino, &nvp)) != 0) { 947 *vpp = NULLVP; 948 return (error); 949 } 950 ip = VTOI(nvp); 951 if (ip->i_e2fs_mode == 0 || ip->i_e2fs_dtime != 0 || 952 ip->i_e2fs_gen != ufhp->ufid_gen) { 953 vput(nvp); 954 *vpp = NULLVP; 955 return (ESTALE); 956 } 957 *vpp = nvp; 958 return (0); 959 } 960 961 /* 962 * Vnode pointer to File handle 963 */ 964 /* ARGSUSED */ 965 int 966 ext2fs_vptofh(vp, fhp) 967 struct vnode *vp; 968 struct fid *fhp; 969 { 970 register struct inode *ip; 971 register struct ufid *ufhp; 972 973 ip = VTOI(vp); 974 ufhp = (struct ufid *)fhp; 975 ufhp->ufid_len = sizeof(struct ufid); 976 ufhp->ufid_ino = ip->i_number; 977 ufhp->ufid_gen = ip->i_e2fs_gen; 978 return (0); 979 } 980 981 int 982 ext2fs_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) 983 int *name; 984 u_int namelen; 985 void *oldp; 986 size_t *oldlenp; 987 void *newp; 988 size_t newlen; 989 struct proc *p; 990 { 991 return (EOPNOTSUPP); 992 } 993 994 /* 995 * Write a superblock and associated information back to disk. 996 */ 997 int 998 ext2fs_sbupdate(mp, waitfor) 999 struct ufsmount *mp; 1000 int waitfor; 1001 { 1002 register struct m_ext2fs *fs = mp->um_e2fs; 1003 register struct buf *bp; 1004 int error = 0; 1005 1006 bp = getblk(mp->um_devvp, SBLOCK, SBSIZE, 0, 0); 1007 e2fs_sbsave(&fs->e2fs, (struct ext2fs*)bp->b_data); 1008 if (waitfor == MNT_WAIT) 1009 error = bwrite(bp); 1010 else 1011 bawrite(bp); 1012 return (error); 1013 } 1014 1015 int 1016 ext2fs_cgupdate(mp, waitfor) 1017 struct ufsmount *mp; 1018 int waitfor; 1019 { 1020 register struct m_ext2fs *fs = mp->um_e2fs; 1021 register struct buf *bp; 1022 int i, error = 0, allerror = 0; 1023 1024 allerror = ext2fs_sbupdate(mp, waitfor); 1025 for (i = 0; i < fs->e2fs_ngdb; i++) { 1026 bp = getblk(mp->um_devvp, fsbtodb(fs, ((fs->e2fs_bsize>1024)?0:1)+i+1), 1027 fs->e2fs_bsize, 0, 0); 1028 e2fs_cgsave(&fs->e2fs_gd[i* fs->e2fs_bsize / sizeof(struct ext2_gd)], 1029 (struct ext2_gd*)bp->b_data, fs->e2fs_bsize); 1030 if (waitfor == MNT_WAIT) 1031 error = bwrite(bp); 1032 else 1033 bawrite(bp); 1034 } 1035 1036 if (!allerror && error) 1037 allerror = error; 1038 return (allerror); 1039 } 1040
Indexes created Thu Sep 25 02:09:54 GMT 2025