ext2fs.c revision 1.9
1 /* $NetBSD: ext2fs.c,v 1.9 2013/06/23 02:06:06 dholland Exp $ */ 2 3 /* 4 * Copyright (c) 1997 Manuel Bouyer. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 /*- 28 * Copyright (c) 2002 The NetBSD Foundation, Inc. 29 * All rights reserved. 30 * 31 * This code is derived from software contributed to The NetBSD Foundation 32 * by Matt Fredette. 33 * 34 * Redistribution and use in source and binary forms, with or without 35 * modification, are permitted provided that the following conditions 36 * are met: 37 * 1. Redistributions of source code must retain the above copyright 38 * notice, this list of conditions and the following disclaimer. 39 * 2. Redistributions in binary form must reproduce the above copyright 40 * notice, this list of conditions and the following disclaimer in the 41 * documentation and/or other materials provided with the distribution. 42 * 43 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 44 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 45 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 46 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 47 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 48 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 49 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 50 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 51 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 52 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 53 * POSSIBILITY OF SUCH DAMAGE. 54 */ 55 56 #if HAVE_NBTOOL_CONFIG_H 57 #include "nbtool_config.h" 58 #endif 59 60 #include <sys/cdefs.h> 61 #if !defined(__lint) 62 __RCSID("$NetBSD: ext2fs.c,v 1.9 2013/06/23 02:06:06 dholland Exp $"); 63 #endif /* !__lint */ 64 65 #include <sys/param.h> 66 67 #if !HAVE_NBTOOL_CONFIG_H 68 #include <sys/mount.h> 69 #endif 70 71 #include <assert.h> 72 #include <err.h> 73 #include <errno.h> 74 #include <fcntl.h> 75 #include <stdarg.h> 76 #include <stdio.h> 77 #include <stdlib.h> 78 #include <string.h> 79 #include <unistd.h> 80 81 #include "installboot.h" 82 83 #include <ufs/ext2fs/ext2fs_dinode.h> 84 #include <ufs/ext2fs/ext2fs_dir.h> 85 #include <ufs/ext2fs/ext2fs.h> 86 87 static int ext2fs_read_disk_block(ib_params *, uint64_t, int, uint8_t []); 88 static int ext2fs_read_sblock(ib_params *, struct m_ext2fs *fs); 89 static int ext2fs_read_gdblock(ib_params *, struct m_ext2fs *fs); 90 static int ext2fs_find_disk_blocks(ib_params *, ino_t, 91 int (*)(ib_params *, void *, uint64_t, uint32_t), void *); 92 static int ext2fs_findstage2_ino(ib_params *, void *, uint64_t, uint32_t); 93 static int ext2fs_findstage2_blocks(ib_params *, void *, uint64_t, 94 uint32_t); 95 96 97 /* This reads a disk block from the file system. */ 98 /* XXX: should be shared with ffs.c? */ 99 static int 100 ext2fs_read_disk_block(ib_params *params, uint64_t blkno, int size, 101 uint8_t blk[]) 102 { 103 int rv; 104 105 assert(params != NULL); 106 assert(params->filesystem != NULL); 107 assert(params->fsfd != -1); 108 assert(size > 0); 109 assert(blk != NULL); 110 111 rv = pread(params->fsfd, blk, size, blkno * params->sectorsize); 112 if (rv == -1) { 113 warn("Reading block %llu in `%s'", 114 (unsigned long long)blkno, params->filesystem); 115 return 0; 116 } else if (rv != size) { 117 warnx("Reading block %llu in `%s': short read", 118 (unsigned long long)blkno, params->filesystem); 119 return 0; 120 } 121 122 return 1; 123 } 124 125 static int 126 ext2fs_read_sblock(ib_params *params, struct m_ext2fs *fs) 127 { 128 uint8_t sbbuf[SBSIZE]; 129 130 if (ext2fs_read_disk_block(params, SBOFF / params->sectorsize, SBSIZE, 131 sbbuf) == 0) 132 133 e2fs_sbload((void *)sbbuf, &fs->e2fs); 134 135 if (fs->e2fs.e2fs_magic != E2FS_MAGIC) 136 return 0; 137 138 if (fs->e2fs.e2fs_rev > E2FS_REV1 || 139 (fs->e2fs.e2fs_rev == E2FS_REV1 && 140 (fs->e2fs.e2fs_first_ino != EXT2_FIRSTINO || 141 fs->e2fs.e2fs_inode_size != EXT2_DINODE_SIZE || 142 (fs->e2fs.e2fs_features_incompat & ~EXT2F_INCOMPAT_SUPP) != 0))) 143 return 0; 144 145 fs->e2fs_ncg = 146 howmany(fs->e2fs.e2fs_bcount - fs->e2fs.e2fs_first_dblock, 147 fs->e2fs.e2fs_bpg); 148 /* XXX assume hw bsize = 512 */ 149 fs->e2fs_fsbtodb = fs->e2fs.e2fs_log_bsize + 1; 150 fs->e2fs_bsize = MINBSIZE << fs->e2fs.e2fs_log_bsize; 151 fs->e2fs_bshift = LOG_MINBSIZE + fs->e2fs.e2fs_log_bsize; 152 fs->e2fs_qbmask = fs->e2fs_bsize - 1; 153 fs->e2fs_bmask = ~fs->e2fs_qbmask; 154 fs->e2fs_ngdb = 155 howmany(fs->e2fs_ncg, fs->e2fs_bsize / sizeof(struct ext2_gd)); 156 fs->e2fs_ipb = fs->e2fs_bsize / EXT2_DINODE_SIZE; 157 fs->e2fs_itpg = fs->e2fs.e2fs_ipg / fs->e2fs_ipb; 158 159 return 1; 160 } 161 162 static int 163 ext2fs_read_gdblock(ib_params *params, struct m_ext2fs *fs) 164 { 165 uint8_t gdbuf[MAXBSIZE]; 166 uint32_t gdpb; 167 int i; 168 169 gdpb = fs->e2fs_bsize / sizeof(struct ext2_gd); 170 171 for (i = 0; i < fs->e2fs_ngdb; i++) { 172 if (ext2fs_read_disk_block(params, EXT2_FSBTODB(fs, 173 fs->e2fs.e2fs_first_dblock + 1 /* superblock */ + i), 174 SBSIZE, gdbuf) == 0) 175 return 0; 176 177 e2fs_cgload((struct ext2_gd *)gdbuf, &fs->e2fs_gd[gdpb * i], 178 (i == (fs->e2fs_ngdb - 1)) ? 179 (fs->e2fs_ncg - gdpb * i) * sizeof(struct ext2_gd): 180 fs->e2fs_bsize); 181 } 182 183 return 1; 184 } 185 186 /* 187 * This iterates over the data blocks belonging to an inode, 188 * making a callback each iteration with the disk block number 189 * and the size. 190 */ 191 static int 192 ext2fs_find_disk_blocks(ib_params *params, ino_t ino, 193 int (*callback)(ib_params *, void *, uint64_t, uint32_t), 194 void *state) 195 { 196 uint8_t sbbuf[sizeof(struct m_ext2fs)]; 197 struct m_ext2fs *fs; 198 uint8_t inodebuf[MAXBSIZE]; 199 struct ext2fs_dinode inode_store, *inode; 200 int level_i; 201 int32_t blk, lblk, nblk; 202 int rv; 203 #define LEVELS 4 204 struct { 205 uint32_t *blknums; 206 unsigned long blkcount; 207 uint8_t diskbuf[MAXBSIZE]; 208 } level[LEVELS]; 209 210 assert(params != NULL); 211 assert(params->fstype != NULL); 212 assert(callback != NULL); 213 assert(state != NULL); 214 215 /* Read the superblock. */ 216 fs = (void *)sbbuf; 217 if (ext2fs_read_sblock(params, fs) == 0) 218 return 0; 219 220 fs->e2fs_gd = malloc(sizeof(struct ext2_gd) * fs->e2fs_ncg); 221 if (fs->e2fs_gd == NULL) { 222 warnx("Can't allocate memofy for group descriptors"); 223 return 0; 224 } 225 226 if (ext2fs_read_gdblock(params, fs) == 0) { 227 warnx("Can't read group descriptors"); 228 return 0; 229 } 230 231 if (fs->e2fs_ipb <= 0) { 232 warnx("Bad ipb %d in superblock in `%s'", 233 fs->e2fs_ipb, params->filesystem); 234 return 0; 235 } 236 237 /* Read the inode. */ 238 if (ext2fs_read_disk_block(params, 239 EXT2_FSBTODB(fs, ino_to_fsba(fs, ino)) + params->fstype->offset, 240 fs->e2fs_bsize, inodebuf)) 241 return 0; 242 inode = (void *)inodebuf; 243 e2fs_iload(&inode[ino_to_fsbo(fs, ino)], &inode_store); 244 inode = &inode_store; 245 246 /* Get the block count and initialize for our block walk. */ 247 nblk = howmany(inode->e2di_size, fs->e2fs_bsize); 248 lblk = 0; 249 level_i = 0; 250 level[0].blknums = &inode->e2di_blocks[0]; 251 level[0].blkcount = UFS_NDADDR; 252 level[1].blknums = &inode->e2di_blocks[UFS_NDADDR + 0]; 253 level[1].blkcount = 1; 254 level[2].blknums = &inode->e2di_blocks[UFS_NDADDR + 1]; 255 level[2].blkcount = 1; 256 level[3].blknums = &inode->e2di_blocks[UFS_NDADDR + 2]; 257 level[3].blkcount = 1; 258 259 /* Walk the data blocks. */ 260 while (nblk > 0) { 261 262 /* 263 * If there are no more blocks at this indirection 264 * level, move up one indirection level and loop. 265 */ 266 if (level[level_i].blkcount == 0) { 267 if (++level_i == LEVELS) 268 break; 269 continue; 270 } 271 272 /* Get the next block at this level. */ 273 blk = fs2h32(*(level[level_i].blknums++)); 274 level[level_i].blkcount--; 275 276 #if 0 277 fprintf(stderr, "ino %lu blk %lu level %d\n", ino, blk, 278 level_i); 279 #endif 280 281 /* 282 * If we're not at the direct level, descend one 283 * level, read in that level's new block list, 284 * and loop. 285 */ 286 if (level_i > 0) { 287 level_i--; 288 if (blk == 0) 289 memset(level[level_i].diskbuf, 0, MAXBSIZE); 290 else if (ext2fs_read_disk_block(params, 291 EXT2_FSBTODB(fs, blk) + params->fstype->offset, 292 fs->e2fs_bsize, level[level_i].diskbuf) == 0) 293 return 0; 294 /* XXX ondisk32 */ 295 level[level_i].blknums = 296 (uint32_t *)level[level_i].diskbuf; 297 level[level_i].blkcount = EXT2_NINDIR(fs); 298 continue; 299 } 300 301 /* blk is the next direct level block. */ 302 #if 0 303 fprintf(stderr, "ino %lu db %lu blksize %lu\n", ino, 304 EXT2_FSBTODB(fs, blk), ext2_sblksize(fs, inode->di_size, lblk)); 305 #endif 306 rv = (*callback)(params, state, 307 EXT2_FSBTODB(fs, blk) + params->fstype->offset, fs->e2fs_bsize); 308 lblk++; 309 nblk--; 310 if (rv != 1) 311 return rv; 312 } 313 314 if (nblk != 0) { 315 warnx("Inode %llu in `%s' ran out of blocks?", 316 (unsigned long long)ino, params->filesystem); 317 return 0; 318 } 319 320 return 1; 321 } 322 323 /* 324 * This callback reads a block of the root directory, 325 * searches for an entry for the secondary bootstrap, 326 * and saves the inode number if one is found. 327 */ 328 static int 329 ext2fs_findstage2_ino(ib_params *params, void *_ino, 330 uint64_t blk, uint32_t blksize) 331 { 332 uint8_t dirbuf[MAXBSIZE]; 333 struct ext2fs_direct *de, *ede; 334 uint32_t ino; 335 336 assert(params != NULL); 337 assert(params->fstype != NULL); 338 assert(params->stage2 != NULL); 339 assert(_ino != NULL); 340 341 /* Skip directory holes. */ 342 if (blk == 0) 343 return 1; 344 345 /* Read the directory block. */ 346 if (ext2fs_read_disk_block(params, blk, blksize, dirbuf) == 0) 347 return 0; 348 349 /* Loop over the directory entries. */ 350 de = (struct ext2fs_direct *)&dirbuf[0]; 351 ede = (struct ext2fs_direct *)&dirbuf[blksize]; 352 while (de < ede) { 353 ino = fs2h32(de->e2d_ino); 354 if (ino != 0 && strcmp(de->e2d_name, params->stage2) == 0) { 355 *((uint32_t *)_ino) = ino; 356 return (2); 357 } 358 if (fs2h16(de->e2d_reclen) == 0) 359 break; 360 de = (struct ext2fs_direct *)((char *)de + 361 fs2h16(de->e2d_reclen)); 362 } 363 364 return 1; 365 } 366 367 struct findblks_state { 368 uint32_t maxblk; 369 uint32_t nblk; 370 ib_block *blocks; 371 }; 372 373 /* This callback records the blocks of the secondary bootstrap. */ 374 static int 375 ext2fs_findstage2_blocks(ib_params *params, void *_state, 376 uint64_t blk, uint32_t blksize) 377 { 378 struct findblks_state *state = _state; 379 380 assert(params != NULL); 381 assert(params->stage2 != NULL); 382 assert(_state != NULL); 383 384 if (state->nblk == state->maxblk) { 385 warnx("Secondary bootstrap `%s' has too many blocks (max %d)", 386 params->stage2, state->maxblk); 387 return (0); 388 } 389 state->blocks[state->nblk].block = blk; 390 state->blocks[state->nblk].blocksize = blksize; 391 state->nblk++; 392 return 1; 393 } 394 395 /* 396 * publicly visible functions 397 */ 398 399 int 400 ext2fs_match(ib_params *params) 401 { 402 uint8_t sbbuf[sizeof(struct m_ext2fs)]; 403 struct m_ext2fs *fs; 404 405 assert(params != NULL); 406 assert(params->fstype != NULL); 407 408 /* Read the superblock. */ 409 fs = (void *)sbbuf; 410 if (ext2fs_read_sblock(params, fs) == 0) 411 return 0; 412 413 params->fstype->needswap = 0; 414 params->fstype->blocksize = fs->e2fs_bsize; 415 params->fstype->offset = 0; 416 417 return 1; 418 } 419 420 int 421 ext2fs_findstage2(ib_params *params, uint32_t *maxblk, ib_block *blocks) 422 { 423 int rv; 424 uint32_t ino; 425 struct findblks_state state; 426 427 assert(params != NULL); 428 assert(params->stage2 != NULL); 429 assert(maxblk != NULL); 430 assert(blocks != NULL); 431 432 if (params->flags & IB_STAGE2START) 433 return hardcode_stage2(params, maxblk, blocks); 434 435 /* The secondary bootstrap must be clearly in /. */ 436 if (params->stage2[0] == '/') 437 params->stage2++; 438 if (strchr(params->stage2, '/') != NULL) { 439 warnx("The secondary bootstrap `%s' must be in /", 440 params->stage2); 441 warnx("(Path must be relative to the file system in `%s')", 442 params->filesystem); 443 return 0; 444 } 445 446 /* Get the inode number of the secondary bootstrap. */ 447 rv = ext2fs_find_disk_blocks(params, EXT2_ROOTINO, 448 ext2fs_findstage2_ino, &ino); 449 if (rv != 2) { 450 warnx("Could not find secondary bootstrap `%s' in `%s'", 451 params->stage2, params->filesystem); 452 warnx("(Path must be relative to the file system in `%s')", 453 params->filesystem); 454 return 0; 455 } 456 457 /* Record the disk blocks of the secondary bootstrap. */ 458 state.maxblk = *maxblk; 459 state.nblk = 0; 460 state.blocks = blocks; 461 rv = ext2fs_find_disk_blocks(params, ino, 462 ext2fs_findstage2_blocks, &state); 463 if (rv == 0) 464 return 0; 465 466 *maxblk = state.nblk; 467 return 1; 468 } 469
Indexes created Sun Sep 21 20:09:37 GMT 2025