inode.c revision 1.36
1 /* $NetBSD: inode.c,v 1.36 2013/06/23 07:28:36 dholland Exp $ */ 2 3 /* 4 * Copyright (c) 1980, 1986, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 /* 33 * Copyright (c) 1997 Manuel Bouyer. 34 * 35 * Redistribution and use in source and binary forms, with or without 36 * modification, are permitted provided that the following conditions 37 * are met: 38 * 1. Redistributions of source code must retain the above copyright 39 * notice, this list of conditions and the following disclaimer. 40 * 2. Redistributions in binary form must reproduce the above copyright 41 * notice, this list of conditions and the following disclaimer in the 42 * documentation and/or other materials provided with the distribution. 43 * 44 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 45 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 46 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 47 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 48 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 49 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 50 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 51 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 52 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 53 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 54 */ 55 56 #include <sys/cdefs.h> 57 #ifndef lint 58 #if 0 59 static char sccsid[] = "@(#)inode.c 8.5 (Berkeley) 2/8/95"; 60 #else 61 __RCSID("$NetBSD: inode.c,v 1.36 2013/06/23 07:28:36 dholland Exp $"); 62 #endif 63 #endif /* not lint */ 64 65 #include <sys/param.h> 66 #include <sys/time.h> 67 #include <ufs/ext2fs/ext2fs_dinode.h> 68 #include <ufs/ext2fs/ext2fs_dir.h> 69 #include <ufs/ext2fs/ext2fs.h> 70 71 #include <ufs/ufs/dinode.h> /* for IFMT & friends */ 72 #ifndef SMALL 73 #include <pwd.h> 74 #endif 75 #include <stdio.h> 76 #include <stdlib.h> 77 #include <string.h> 78 #include <time.h> 79 80 #include "fsck.h" 81 #include "fsutil.h" 82 #include "extern.h" 83 84 /* 85 * CG is stored in fs byte order in memory, so we can't use ino_to_fsba 86 * here. 87 */ 88 89 #define fsck_ino_to_fsba(fs, x) \ 90 (fs2h32((fs)->e2fs_gd[ino_to_cg(fs, x)].ext2bgd_i_tables) + \ 91 (((x)-1) % (fs)->e2fs.e2fs_ipg)/(fs)->e2fs_ipb) 92 93 94 static ino_t startinum; 95 96 static int iblock(struct inodesc *, long, u_int64_t); 97 98 static int setlarge(void); 99 100 static int sethuge(void); 101 102 static int 103 setlarge(void) 104 { 105 if (sblock.e2fs.e2fs_rev < E2FS_REV1) { 106 pfatal("LARGE FILES UNSUPPORTED ON REVISION 0 FILESYSTEMS"); 107 return 0; 108 } 109 if (!(sblock.e2fs.e2fs_features_rocompat & EXT2F_ROCOMPAT_LARGEFILE)) { 110 if (preen) 111 pwarn("SETTING LARGE FILE INDICATOR\n"); 112 else if (!reply("SET LARGE FILE INDICATOR")) 113 return 0; 114 sblock.e2fs.e2fs_features_rocompat |= EXT2F_ROCOMPAT_LARGEFILE; 115 sbdirty(); 116 } 117 return 1; 118 } 119 120 static int 121 sethuge(void) 122 { 123 if (sblock.e2fs.e2fs_rev < E2FS_REV1) { 124 pfatal("HUGE FILES UNSUPPORTED ON REVISION 0 FILESYSTEMS"); 125 return 0; 126 } 127 if (!(sblock.e2fs.e2fs_features_rocompat & EXT2F_ROCOMPAT_HUGE_FILE)) { 128 if (preen) 129 pwarn("SETTING HUGE FILE FEATURE\n"); 130 else if (!reply("SET HUGE FILE FEATURE")) 131 return 0; 132 sblock.e2fs.e2fs_features_rocompat |= EXT2F_ROCOMPAT_HUGE_FILE; 133 sbdirty(); 134 } 135 return 1; 136 } 137 138 u_int64_t 139 inosize(struct ext2fs_dinode *dp) 140 { 141 u_int64_t size = fs2h32(dp->e2di_size); 142 143 if ((fs2h16(dp->e2di_mode) & IFMT) == IFREG) 144 size |= (u_int64_t)fs2h32(dp->e2di_dacl) << 32; 145 if (size > INT32_MAX) 146 (void)setlarge(); 147 return size; 148 } 149 150 void 151 inossize(struct ext2fs_dinode *dp, u_int64_t size) 152 { 153 if ((fs2h16(dp->e2di_mode) & IFMT) == IFREG) { 154 dp->e2di_dacl = h2fs32(size >> 32); 155 if (size > INT32_MAX) 156 if (!setlarge()) 157 return; 158 } else if (size > INT32_MAX) { 159 pfatal("TRYING TO SET FILESIZE TO %llu ON MODE %x FILE\n", 160 (unsigned long long)size, fs2h16(dp->e2di_mode) & IFMT); 161 return; 162 } 163 dp->e2di_size = h2fs32(size); 164 } 165 166 int 167 ckinode(struct ext2fs_dinode *dp, struct inodesc *idesc) 168 { 169 u_int32_t *ap; 170 long ret, n, ndb; 171 struct ext2fs_dinode dino; 172 u_int64_t remsize, sizepb; 173 mode_t mode; 174 char pathbuf[MAXPATHLEN + 1]; 175 176 if (idesc->id_fix != IGNORE) 177 idesc->id_fix = DONTKNOW; 178 idesc->id_entryno = 0; 179 idesc->id_filesize = inosize(dp); 180 mode = fs2h16(dp->e2di_mode) & IFMT; 181 if (mode == IFBLK || mode == IFCHR || mode == IFIFO || 182 (mode == IFLNK && (inosize(dp) < EXT2_MAXSYMLINKLEN))) 183 return (KEEPON); 184 dino = *dp; 185 ndb = howmany(inosize(&dino), sblock.e2fs_bsize); 186 for (ap = &dino.e2di_blocks[0]; ap < &dino.e2di_blocks[EXT2FS_NDADDR]; 187 ap++,ndb--) { 188 idesc->id_numfrags = 1; 189 if (*ap == 0) { 190 if (idesc->id_type == DATA && ndb > 0) { 191 /* An empty block in a directory XXX */ 192 getpathname(pathbuf, sizeof(pathbuf), 193 idesc->id_number, idesc->id_number); 194 pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS", 195 pathbuf); 196 if (reply("ADJUST LENGTH") == 1) { 197 dp = ginode(idesc->id_number); 198 inossize(dp, 199 (ap - &dino.e2di_blocks[0]) * 200 sblock.e2fs_bsize); 201 printf( 202 "YOU MUST RERUN FSCK AFTERWARDS\n"); 203 rerun = 1; 204 inodirty(); 205 } 206 } 207 continue; 208 } 209 idesc->id_blkno = fs2h32(*ap); 210 if (idesc->id_type == ADDR) 211 ret = (*idesc->id_func)(idesc); 212 else 213 ret = dirscan(idesc); 214 if (ret & STOP) 215 return (ret); 216 } 217 idesc->id_numfrags = 1; 218 remsize = inosize(&dino) - sblock.e2fs_bsize * EXT2FS_NDADDR; 219 sizepb = sblock.e2fs_bsize; 220 for (ap = &dino.e2di_blocks[EXT2FS_NDADDR], n = 1; n <= EXT2FS_NIADDR; ap++, n++) { 221 if (*ap) { 222 idesc->id_blkno = fs2h32(*ap); 223 ret = iblock(idesc, n, remsize); 224 if (ret & STOP) 225 return (ret); 226 } else { 227 if (idesc->id_type == DATA && remsize > 0) { 228 /* An empty block in a directory XXX */ 229 getpathname(pathbuf, sizeof(pathbuf), 230 idesc->id_number, idesc->id_number); 231 pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS", 232 pathbuf); 233 if (reply("ADJUST LENGTH") == 1) { 234 dp = ginode(idesc->id_number); 235 inossize(dp, inosize(dp) - remsize); 236 remsize = 0; 237 printf( 238 "YOU MUST RERUN FSCK AFTERWARDS\n"); 239 rerun = 1; 240 inodirty(); 241 break; 242 } 243 } 244 } 245 sizepb *= EXT2_NINDIR(&sblock); 246 remsize -= sizepb; 247 } 248 return (KEEPON); 249 } 250 251 static int 252 iblock(struct inodesc *idesc, long ilevel, u_int64_t isize) 253 { 254 /* XXX ondisk32 */ 255 int32_t *ap; 256 int32_t *aplim; 257 struct bufarea *bp; 258 int i, n, (*func)(struct inodesc *); 259 size_t nif; 260 u_int64_t sizepb; 261 char buf[BUFSIZ]; 262 char pathbuf[MAXPATHLEN + 1]; 263 struct ext2fs_dinode *dp; 264 265 if (idesc->id_type == ADDR) { 266 func = idesc->id_func; 267 if (((n = (*func)(idesc)) & KEEPON) == 0) 268 return (n); 269 } else 270 func = dirscan; 271 if (chkrange(idesc->id_blkno, idesc->id_numfrags)) 272 return (SKIP); 273 bp = getdatablk(idesc->id_blkno, sblock.e2fs_bsize); 274 ilevel--; 275 for (sizepb = sblock.e2fs_bsize, i = 0; i < ilevel; i++) 276 sizepb *= EXT2_NINDIR(&sblock); 277 if (isize > sizepb * EXT2_NINDIR(&sblock)) 278 nif = EXT2_NINDIR(&sblock); 279 else 280 nif = howmany(isize, sizepb); 281 if (idesc->id_func == pass1check && 282 nif < EXT2_NINDIR(&sblock)) { 283 aplim = &bp->b_un.b_indir[EXT2_NINDIR(&sblock)]; 284 for (ap = &bp->b_un.b_indir[nif]; ap < aplim; ap++) { 285 if (*ap == 0) 286 continue; 287 (void)snprintf(buf, sizeof(buf), 288 "PARTIALLY TRUNCATED INODE I=%llu", 289 (unsigned long long)idesc->id_number); 290 if (dofix(idesc, buf)) { 291 *ap = 0; 292 dirty(bp); 293 } 294 } 295 flush(fswritefd, bp); 296 } 297 aplim = &bp->b_un.b_indir[nif]; 298 for (ap = bp->b_un.b_indir; ap < aplim; ap++) { 299 if (*ap) { 300 idesc->id_blkno = fs2h32(*ap); 301 if (ilevel == 0) 302 n = (*func)(idesc); 303 else 304 n = iblock(idesc, ilevel, isize); 305 if (n & STOP) { 306 bp->b_flags &= ~B_INUSE; 307 return (n); 308 } 309 } else { 310 if (idesc->id_type == DATA && isize > 0) { 311 /* An empty block in a directory XXX */ 312 getpathname(pathbuf, sizeof(pathbuf), 313 idesc->id_number, idesc->id_number); 314 pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS", 315 pathbuf); 316 if (reply("ADJUST LENGTH") == 1) { 317 dp = ginode(idesc->id_number); 318 inossize(dp, inosize(dp) - isize); 319 isize = 0; 320 printf( 321 "YOU MUST RERUN FSCK AFTERWARDS\n"); 322 rerun = 1; 323 inodirty(); 324 bp->b_flags &= ~B_INUSE; 325 return(STOP); 326 } 327 } 328 } 329 isize -= sizepb; 330 } 331 bp->b_flags &= ~B_INUSE; 332 return (KEEPON); 333 } 334 335 /* 336 * Check that a block in a legal block number. 337 * Return 0 if in range, 1 if out of range. 338 */ 339 int 340 chkrange(daddr_t blk, int cnt) 341 { 342 int c, overh; 343 344 if ((unsigned int)(blk + cnt) > maxfsblock) 345 return (1); 346 c = dtog(&sblock, blk); 347 overh = cgoverhead(c); 348 if (blk < sblock.e2fs.e2fs_bpg * c + overh + 349 sblock.e2fs.e2fs_first_dblock) { 350 if ((blk + cnt) > sblock.e2fs.e2fs_bpg * c + overh + 351 sblock.e2fs.e2fs_first_dblock) { 352 if (debug) { 353 printf("blk %lld < cgdmin %d;", 354 (long long)blk, 355 sblock.e2fs.e2fs_bpg * c + overh + 356 sblock.e2fs.e2fs_first_dblock); 357 printf(" blk + cnt %lld > cgsbase %d\n", 358 (long long)(blk + cnt), 359 sblock.e2fs.e2fs_bpg * c + 360 overh + sblock.e2fs.e2fs_first_dblock); 361 } 362 return (1); 363 } 364 } else { 365 if ((blk + cnt) > sblock.e2fs.e2fs_bpg * (c + 1) + overh + 366 sblock.e2fs.e2fs_first_dblock) { 367 if (debug) { 368 printf("blk %lld >= cgdmin %d;", 369 (long long)blk, 370 sblock.e2fs.e2fs_bpg * c + overh + 371 sblock.e2fs.e2fs_first_dblock); 372 printf(" blk + cnt %lld > cgdmax %d\n", 373 (long long)(blk+cnt), 374 sblock.e2fs.e2fs_bpg * (c + 1) + 375 overh + sblock.e2fs.e2fs_first_dblock); 376 } 377 return (1); 378 } 379 } 380 return (0); 381 } 382 383 /* 384 * General purpose interface for reading inodes. 385 */ 386 struct ext2fs_dinode * 387 ginode(ino_t inumber) 388 { 389 daddr_t iblk; 390 struct ext2fs_dinode *dp; 391 392 if ((inumber < EXT2_FIRSTINO && 393 inumber != EXT2_ROOTINO && 394 !(inumber == EXT2_RESIZEINO && 395 (sblock.e2fs.e2fs_features_compat & EXT2F_COMPAT_RESIZE) != 0)) 396 || inumber > maxino) 397 errexit("bad inode number %llu to ginode", 398 (unsigned long long)inumber); 399 if (startinum == 0 || 400 inumber < startinum || inumber >= startinum + sblock.e2fs_ipb) { 401 iblk = fsck_ino_to_fsba(&sblock, inumber); 402 if (pbp != 0) 403 pbp->b_flags &= ~B_INUSE; 404 pbp = getdatablk(iblk, sblock.e2fs_bsize); 405 startinum = 406 ((inumber - 1) / sblock.e2fs_ipb) * sblock.e2fs_ipb + 1; 407 } 408 dp = (struct ext2fs_dinode *)(pbp->b_un.b_buf + 409 EXT2_DINODE_SIZE(&sblock) * ino_to_fsbo(&sblock, inumber)); 410 411 return dp; 412 } 413 414 /* 415 * Special purpose version of ginode used to optimize first pass 416 * over all the inodes in numerical order. 417 */ 418 ino_t nextino, lastinum; 419 long readcnt, readpercg, fullcnt, inobufsize, partialcnt, partialsize; 420 char *inodebuf; 421 422 struct ext2fs_dinode * 423 getnextinode(ino_t inumber) 424 { 425 long size; 426 daddr_t dblk; 427 struct ext2fs_dinode *dp; 428 static char *bp; 429 430 if (inumber != nextino++ || inumber > maxino) 431 errexit("bad inode number %llu to nextinode", 432 (unsigned long long)inumber); 433 if (inumber >= lastinum) { 434 readcnt++; 435 dblk = EXT2_FSBTODB(&sblock, fsck_ino_to_fsba(&sblock, lastinum)); 436 if (readcnt % readpercg == 0) { 437 size = partialsize; 438 lastinum += partialcnt; 439 } else { 440 size = inobufsize; 441 lastinum += fullcnt; 442 } 443 (void)bread(fsreadfd, inodebuf, dblk, size); 444 bp = inodebuf; 445 } 446 dp = (struct ext2fs_dinode *)bp; 447 bp += EXT2_DINODE_SIZE(&sblock); 448 449 return dp; 450 } 451 452 void 453 resetinodebuf(void) 454 { 455 456 startinum = 0; 457 nextino = 1; 458 lastinum = 1; 459 readcnt = 0; 460 inobufsize = ext2_blkroundup(&sblock, INOBUFSIZE); 461 fullcnt = inobufsize / EXT2_DINODE_SIZE(&sblock); 462 readpercg = sblock.e2fs.e2fs_ipg / fullcnt; 463 partialcnt = sblock.e2fs.e2fs_ipg % fullcnt; 464 partialsize = partialcnt * EXT2_DINODE_SIZE(&sblock); 465 if (partialcnt != 0) { 466 readpercg++; 467 } else { 468 partialcnt = fullcnt; 469 partialsize = inobufsize; 470 } 471 if (inodebuf == NULL && 472 (inodebuf = malloc((unsigned int)inobufsize)) == NULL) 473 errexit("Cannot allocate space for inode buffer"); 474 while (nextino < EXT2_ROOTINO) 475 (void)getnextinode(nextino); 476 } 477 478 void 479 freeinodebuf(void) 480 { 481 482 if (inodebuf != NULL) 483 free(inodebuf); 484 inodebuf = NULL; 485 } 486 487 /* 488 * Routines to maintain information about directory inodes. 489 * This is built during the first pass and used during the 490 * second and third passes. 491 * 492 * Enter inodes into the cache. 493 */ 494 void 495 cacheino(struct ext2fs_dinode *dp, ino_t inumber) 496 { 497 struct inoinfo *inp; 498 struct inoinfo **inpp; 499 unsigned int blks; 500 501 blks = howmany(inosize(dp), sblock.e2fs_bsize); 502 if (blks > EXT2FS_NDADDR) 503 blks = EXT2FS_NDADDR + EXT2FS_NIADDR; 504 /* XXX ondisk32 */ 505 inp = malloc(sizeof(*inp) + (blks - 1) * sizeof(int32_t)); 506 if (inp == NULL) 507 return; 508 inpp = &inphead[inumber % numdirs]; 509 inp->i_nexthash = *inpp; 510 *inpp = inp; 511 inp->i_child = inp->i_sibling = inp->i_parentp = 0; 512 if (inumber == EXT2_ROOTINO) 513 inp->i_parent = EXT2_ROOTINO; 514 else 515 inp->i_parent = (ino_t)0; 516 inp->i_dotdot = (ino_t)0; 517 inp->i_number = inumber; 518 inp->i_isize = inosize(dp); 519 /* XXX ondisk32 */ 520 inp->i_numblks = blks * sizeof(int32_t); 521 memcpy(&inp->i_blks[0], &dp->e2di_blocks[0], (size_t)inp->i_numblks); 522 if (inplast == listmax) { 523 listmax += 100; 524 inpsort = (struct inoinfo **)realloc((char *)inpsort, 525 (unsigned int)listmax * sizeof(struct inoinfo *)); 526 if (inpsort == NULL) 527 errexit("cannot increase directory list"); 528 } 529 inpsort[inplast++] = inp; 530 } 531 532 /* 533 * Look up an inode cache structure. 534 */ 535 struct inoinfo * 536 getinoinfo(ino_t inumber) 537 { 538 struct inoinfo *inp; 539 540 for (inp = inphead[inumber % numdirs]; inp; inp = inp->i_nexthash) { 541 if (inp->i_number != inumber) 542 continue; 543 return (inp); 544 } 545 errexit("cannot find inode %llu", (unsigned long long)inumber); 546 return ((struct inoinfo *)0); 547 } 548 549 /* 550 * Clean up all the inode cache structure. 551 */ 552 void 553 inocleanup(void) 554 { 555 struct inoinfo **inpp; 556 557 if (inphead == NULL) 558 return; 559 for (inpp = &inpsort[inplast - 1]; inpp >= inpsort; inpp--) 560 free(*inpp); 561 free(inphead); 562 free(inpsort); 563 inphead = inpsort = NULL; 564 } 565 566 void 567 inodirty(void) 568 { 569 570 dirty(pbp); 571 } 572 573 void 574 clri(struct inodesc *idesc, const char *type, int flag) 575 { 576 struct ext2fs_dinode *dp; 577 578 dp = ginode(idesc->id_number); 579 if (flag == 1) { 580 pwarn("%s %s", type, 581 (fs2h16(dp->e2di_mode) & IFMT) == IFDIR ? "DIR" : "FILE"); 582 pinode(idesc->id_number); 583 } 584 if (preen || reply("CLEAR") == 1) { 585 if (preen) 586 printf(" (CLEARED)\n"); 587 n_files--; 588 (void)ckinode(dp, idesc); 589 clearinode(dp); 590 statemap[idesc->id_number] = USTATE; 591 inodirty(); 592 } 593 } 594 595 int 596 findname(struct inodesc *idesc) 597 { 598 struct ext2fs_direct *dirp = idesc->id_dirp; 599 u_int16_t namlen = dirp->e2d_namlen; 600 /* from utilities.c namebuf[] variable */ 601 char *buf = __UNCONST(idesc->id_name); 602 if (namlen > MAXPATHLEN) { 603 /* XXX: Prevent overflow but don't fix */ 604 namlen = MAXPATHLEN; 605 } 606 607 if (fs2h32(dirp->e2d_ino) != idesc->id_parent) 608 return (KEEPON); 609 (void)memcpy(buf, dirp->e2d_name, (size_t)namlen); 610 buf[namlen] = '\0'; 611 return (STOP|FOUND); 612 } 613 614 int 615 findino(struct inodesc *idesc) 616 { 617 struct ext2fs_direct *dirp = idesc->id_dirp; 618 u_int32_t ino = fs2h32(dirp->e2d_ino); 619 620 if (ino == 0) 621 return (KEEPON); 622 if (strcmp(dirp->e2d_name, idesc->id_name) == 0 && 623 (ino == EXT2_ROOTINO || ino >= EXT2_FIRSTINO) 624 && ino <= maxino) { 625 idesc->id_parent = ino; 626 return (STOP|FOUND); 627 } 628 return (KEEPON); 629 } 630 631 void 632 pinode(ino_t ino) 633 { 634 struct ext2fs_dinode *dp; 635 struct passwd *pw; 636 uid_t uid; 637 638 printf(" I=%llu ", (unsigned long long)ino); 639 if ((ino < EXT2_FIRSTINO && ino != EXT2_ROOTINO) || ino > maxino) 640 return; 641 dp = ginode(ino); 642 uid = fs2h16(dp->e2di_uid); 643 if (sblock.e2fs.e2fs_rev > E2FS_REV0) 644 uid |= fs2h16(dp->e2di_uid_high) << 16; 645 printf(" OWNER="); 646 #ifndef SMALL 647 if (Uflag && (pw = getpwuid(uid)) != 0) 648 printf("%s ", pw->pw_name); 649 else 650 #endif 651 printf("%u ", (unsigned int)uid); 652 printf("MODE=%o\n", fs2h16(dp->e2di_mode)); 653 if (preen) 654 printf("%s: ", cdevname()); 655 printf("SIZE=%llu ", (long long)inosize(dp)); 656 printf("MTIME=%s ", print_mtime(fs2h32(dp->e2di_mtime))); 657 } 658 659 void 660 blkerror(ino_t ino, const char *type, daddr_t blk) 661 { 662 663 pfatal("%lld %s I=%llu", (long long)blk, type, (unsigned long long)ino); 664 printf("\n"); 665 switch (statemap[ino]) { 666 667 case FSTATE: 668 statemap[ino] = FCLEAR; 669 return; 670 671 case DSTATE: 672 statemap[ino] = DCLEAR; 673 return; 674 675 case FCLEAR: 676 case DCLEAR: 677 return; 678 679 default: 680 errexit("BAD STATE %d TO BLKERR", statemap[ino]); 681 /* NOTREACHED */ 682 } 683 } 684 685 /* 686 * allocate an unused inode 687 */ 688 ino_t 689 allocino(ino_t request, int type) 690 { 691 ino_t ino; 692 struct ext2fs_dinode *dp; 693 time_t t; 694 695 if (request == 0) 696 request = EXT2_ROOTINO; 697 else if (statemap[request] != USTATE) 698 return (0); 699 for (ino = request; ino < maxino; ino++) { 700 if ((ino > EXT2_ROOTINO) && (ino < EXT2_FIRSTINO)) 701 continue; 702 if (statemap[ino] == USTATE) 703 break; 704 } 705 if (ino == maxino) 706 return (0); 707 switch (type & IFMT) { 708 case IFDIR: 709 statemap[ino] = DSTATE; 710 break; 711 case IFREG: 712 case IFLNK: 713 statemap[ino] = FSTATE; 714 break; 715 default: 716 return (0); 717 } 718 dp = ginode(ino); 719 dp->e2di_blocks[0] = h2fs32(allocblk()); 720 if (dp->e2di_blocks[0] == 0) { 721 statemap[ino] = USTATE; 722 return (0); 723 } 724 dp->e2di_mode = h2fs16(type); 725 (void)time(&t); 726 dp->e2di_atime = h2fs32(t); 727 dp->e2di_mtime = dp->e2di_ctime = dp->e2di_atime; 728 dp->e2di_dtime = 0; 729 inossize(dp, sblock.e2fs_bsize); 730 inosnblock(dp, btodb(sblock.e2fs_bsize)); 731 n_files++; 732 inodirty(); 733 typemap[ino] = E2IFTODT(type); 734 return (ino); 735 } 736 737 /* 738 * deallocate an inode 739 */ 740 void 741 freeino(ino_t ino) 742 { 743 struct inodesc idesc; 744 struct ext2fs_dinode *dp; 745 746 memset(&idesc, 0, sizeof(struct inodesc)); 747 idesc.id_type = ADDR; 748 idesc.id_func = pass4check; 749 idesc.id_number = ino; 750 dp = ginode(ino); 751 (void)ckinode(dp, &idesc); 752 clearinode(dp); 753 inodirty(); 754 statemap[ino] = USTATE; 755 n_files--; 756 } 757 758 uint64_t 759 inonblock(struct ext2fs_dinode *dp) 760 { 761 uint64_t nblock; 762 763 /* XXX check for EXT2_HUGE_FILE without EXT2F_ROCOMPAT_HUGE_FILE? */ 764 765 nblock = fs2h32(dp->e2di_nblock); 766 767 if ((sblock.e2fs.e2fs_features_rocompat & EXT2F_ROCOMPAT_HUGE_FILE)) { 768 nblock |= (uint64_t)fs2h16(dp->e2di_nblock_high) << 32; 769 if (fs2h32(dp->e2di_flags) & EXT2_HUGE_FILE) { 770 nblock = EXT2_FSBTODB(&sblock, nblock); 771 } 772 } 773 774 return nblock; 775 } 776 777 void 778 inosnblock(struct ext2fs_dinode *dp, uint64_t nblock) 779 { 780 uint32_t flags; 781 782 flags = fs2h32(dp->e2di_flags); 783 784 if (nblock <= 0xffffffffULL) { 785 flags &= ~EXT2_HUGE_FILE; 786 dp->e2di_flags = h2fs32(flags); 787 dp->e2di_nblock = h2fs32(nblock); 788 return; 789 } 790 791 sethuge(); 792 793 if (nblock <= 0xffffffffffffULL) { 794 flags &= ~EXT2_HUGE_FILE; 795 dp->e2di_flags = h2fs32(flags); 796 dp->e2di_nblock = h2fs32(nblock); 797 dp->e2di_nblock_high = h2fs16((nblock >> 32)); 798 return; 799 } 800 801 if (EXT2_DBTOFSB(&sblock, nblock) <= 0xffffffffffffULL) { 802 flags |= EXT2_HUGE_FILE; 803 dp->e2di_flags = h2fs32(flags); 804 dp->e2di_nblock = h2fs32(EXT2_DBTOFSB(&sblock, nblock)); 805 dp->e2di_nblock_high = h2fs16((EXT2_DBTOFSB(&sblock, nblock) >> 32)); 806 return; 807 } 808 809 pfatal("trying to set nblocks higher than representable"); 810 811 return; 812 } 813
Indexes created Sun Sep 21 20:09:37 GMT 2025