e2fsck/pass2.c

   1 /*
   2  * pass2.c --- check directory structure
   3  *
   4  * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o
   5  *
   6  * %Begin-Header%
   7  * This file may be redistributed under the terms of the GNU Public
   8  * License.
   9  * %End-Header%
  10  *
  11  * Pass 2 of e2fsck iterates through all active directory inodes, and
  12  * applies to following tests to each directory entry in the directory
  13  * blocks in the inodes:
  14  *
  15  *      - The length of the directory entry (rec_len) should be at
  16  *              least 8 bytes, and no more than the remaining space
  17  *              left in the directory block.
  18  *      - The length of the name in the directory entry (name_len)
  19  *              should be less than (rec_len - 8).
  20  *      - The inode number in the directory entry should be within
  21  *              legal bounds.
  22  *      - The inode number should refer to a in-use inode.
  23  *      - The first entry should be '.', and its inode should be
  24  *              the inode of the directory.
  25  *      - The second entry should be '..'.
  26  *
  27  * To minimize disk seek time, the directory blocks are processed in
  28  * sorted order of block numbers.
  29  *
  30  * Pass 2 also collects the following information:
  31  *      - The inode numbers of the subdirectories for each directory.
  32  *
  33  * Pass 2 relies on the following information from previous passes:
  34  *      - The directory information collected in pass 1.
  35  *      - The inode_used_map bitmap
  36  *      - The inode_bad_map bitmap
  37  *      - The inode_dir_map bitmap
  38  *
  39  * Pass 2 frees the following data structures
  40  *      - The inode_bad_map bitmap
  41  */
  42
  43 #include "e2fsck.h"
  44 #include "problem.h"
  45
  46 /*
  47  * Keeps track of how many times an inode is referenced.
  48  */
  49 static void deallocate_inode(e2fsck_t ctx, ino_t ino,
  50                              char* block_buf);
  51 static int process_bad_inode(e2fsck_t ctx, ino_t dir, ino_t ino);
  52 static int check_dir_block(ext2_filsys fs,
  53                            struct ext2_db_entry *dir_blocks_info,
  54                            void *private);
  55 static int allocate_dir_block(e2fsck_t ctx,
  56                               struct ext2_db_entry *dir_blocks_info,
  57                               char *buf, struct problem_context *pctx);
  58 static int update_dir_block(ext2_filsys fs,
  59                             blk_t       *block_nr,
  60                             int blockcnt,
  61                             void *private);
  62
  63 struct check_dir_struct {
  64         char *buf;
  65         struct problem_context  pctx;
  66         e2fsck_t ctx;
  67 };
  68
  69 void e2fsck_pass2(e2fsck_t ctx)
  70 {
  71         ext2_filsys     fs = ctx->fs;
  72         char    *buf;
  73 #ifdef RESOURCE_TRACK
  74         struct resource_track   rtrack;
  75 #endif
  76         struct dir_info *dir;
  77         struct check_dir_struct cd;
  78
  79 #ifdef RESOURCE_TRACK
  80         init_resource_track(&rtrack);
  81 #endif
  82
  83         clear_problem_context(&cd.pctx);
  84
  85 #ifdef MTRACE
  86         mtrace_print("Pass 2");
  87 #endif
  88
  89         if (!(ctx->options & E2F_OPT_PREEN))
  90                 fix_problem(ctx, PR_2_PASS_HEADER, &cd.pctx);
  91
  92         cd.pctx.errcode = ext2fs_create_icount2(fs, EXT2_ICOUNT_OPT_INCREMENT,
  93                                                 0, ctx->inode_link_info,
  94                                                 &ctx->inode_count);
  95         if (cd.pctx.errcode) {
  96                 fix_problem(ctx, PR_2_ALLOCATE_ICOUNT, &cd.pctx);
  97                 ctx->flags |= E2F_FLAG_ABORT;
  98                 return;
  99         }
 100         buf = allocate_memory(fs->blocksize, "directory scan buffer");
 101
 102         /*
 103          * Set up the parent pointer for the root directory, if
 104          * present.  (If the root directory is not present, we will
 105          * create it in pass 3.)
 106          */
 107         dir = e2fsck_get_dir_info(ctx, EXT2_ROOT_INO);
 108         if (dir)
 109                 dir->parent = EXT2_ROOT_INO;
 110
 111         cd.buf = buf;
 112         cd.ctx = ctx;
 113
 114         cd.pctx.errcode = ext2fs_dblist_iterate(fs->dblist, check_dir_block,
 115                                                 &cd);
 116         if (ctx->flags & E2F_FLAG_ABORT)
 117                 return;
 118         if (cd.pctx.errcode) {
 119                 fix_problem(ctx, PR_2_DBLIST_ITERATE, &cd.pctx);
 120                 ctx->flags |= E2F_FLAG_ABORT;
 121                 return;
 122         }
 123
 124         ext2fs_free_mem((void **) &buf);
 125         ext2fs_free_dblist(fs->dblist);
 126
 127         if (ctx->inode_bad_map) {
 128                 ext2fs_free_inode_bitmap(ctx->inode_bad_map);
 129                 ctx->inode_bad_map = 0;
 130         }
 131 #ifdef RESOURCE_TRACK
 132         if (ctx->options & E2F_OPT_TIME2)
 133                 print_resource_track("Pass 2", &rtrack);
 134 #endif
 135 }
 136
 137 /*
 138  * Make sure the first entry in the directory is '.', and that the
 139  * directory entry is sane.
 140  */
 141 static int check_dot(e2fsck_t ctx,
 142                      struct ext2_dir_entry *dirent,
 143                      ino_t ino, struct problem_context *pctx)
 144 {
 145         struct ext2_dir_entry *nextdir;
 146         int     status = 0;
 147         int     created = 0;
 148         int     new_len;
 149         int     problem = 0;
 150
 151         if (!dirent->inode)
 152                 problem = PR_2_MISSING_DOT;
 153         else if ((dirent->name_len != 1) ||
 154                  (dirent->name[0] != '.'))
 155                 problem = PR_2_1ST_NOT_DOT;
 156         else if (dirent->name[1] != '\0')
 157                 problem = PR_2_DOT_NULL_TERM;
 158
 159         if (problem) {
 160                 if (fix_problem(ctx, problem, pctx)) {
 161                         if (dirent->rec_len < 12)
 162                                 dirent->rec_len = 12;
 163                         dirent->inode = ino;
 164                         dirent->name_len = 1;
 165                         dirent->name[0] = '.';
 166                         dirent->name[1] = '\0';
 167                         status = 1;
 168                         created = 1;
 169                 }
 170         }
 171         if (dirent->inode != ino) {
 172                 if (fix_problem(ctx, PR_2_BAD_INODE_DOT, pctx)) {
 173                         dirent->inode = ino;
 174                         status = 1;
 175                 }
 176         }
 177         if (dirent->rec_len > 12) {
 178                 new_len = dirent->rec_len - 12;
 179                 if (new_len > 12) {
 180                         preenhalt(ctx);
 181                         if (created ||
 182                             ask(ctx, "Directory entry for '.' is big.  Split", 1)) {
 183                                 nextdir = (struct ext2_dir_entry *)
 184                                         ((char *) dirent + 12);
 185                                 dirent->rec_len = 12;
 186                                 nextdir->rec_len = new_len;
 187                                 nextdir->inode = 0;
 188                                 nextdir->name_len = 0;
 189                                 status = 1;
 190                         }
 191                 }
 192         }
 193         return status;
 194 }
 195
 196 /*
 197  * Make sure the second entry in the directory is '..', and that the
 198  * directory entry is sane.  We do not check the inode number of '..'
 199  * here; this gets done in pass 3.
 200  */
 201 static int check_dotdot(e2fsck_t ctx,
 202                         struct ext2_dir_entry *dirent,
 203                         struct dir_info *dir, struct problem_context *pctx)
 204 {
 205         int             problem = 0;
 206
 207         if (!dirent->inode)
 208                 problem = PR_2_MISSING_DOT_DOT;
 209         else if ((dirent->name_len != 2) ||
 210                  (dirent->name[0] != '.') ||
 211                  (dirent->name[1] != '.'))
 212                 problem = PR_2_2ND_NOT_DOT_DOT;
 213         else if (dirent->name[2] != '\0')
 214                 problem = PR_2_DOT_DOT_NULL_TERM;
 215
 216         if (problem) {
 217                 if (fix_problem(ctx, problem, pctx)) {
 218                         if (dirent->rec_len < 12)
 219                                 dirent->rec_len = 12;
 220                         /*
 221                          * Note: we don't have the parent inode just
 222                          * yet, so we will fill it in with the root
 223                          * inode.  This will get fixed in pass 3.
 224                          */
 225                         dirent->inode = EXT2_ROOT_INO;
 226                         dirent->name_len = 2;
 227                         dirent->name[0] = '.';
 228                         dirent->name[1] = '.';
 229                         dirent->name[2] = '\0';
 230                         return 1;
 231                 }
 232                 return 0;
 233         }
 234         dir->dotdot = dirent->inode;
 235         return 0;
 236 }
 237
 238 /*
 239  * Check to make sure a directory entry doesn't contain any illegal
 240  * characters.
 241  */
 242 static int check_name(e2fsck_t ctx,
 243                       struct ext2_dir_entry *dirent,
 244                       ino_t dir_ino, struct problem_context *pctx)
 245 {
 246         int     i;
 247         int     fixup = -1;
 248         int     ret = 0;
 249
 250         for ( i = 0; i < dirent->name_len; i++) {
 251                 if (dirent->name[i] == '/' || dirent->name[i] == '\0') {
 252                         if (fixup < 0) {
 253                                 fixup = fix_problem(ctx, PR_2_BAD_NAME, pctx);
 254                         }
 255                         if (fixup) {
 256                                 dirent->name[i] = '.';
 257                                 ret = 1;
 258                         }
 259                 }
 260         }
 261         return ret;
 262 }
 263
 264 static int check_dir_block(ext2_filsys fs,
 265                            struct ext2_db_entry *db,
 266                            void *private)
 267 {
 268         struct dir_info         *subdir, *dir;
 269         struct ext2_dir_entry   *dirent;
 270         int                     offset = 0;
 271         int                     dir_modified = 0;
 272         int                     dot_state;
 273         blk_t                   block_nr = db->blk;
 274         ino_t                   ino = db->ino;
 275         __u16                   links;
 276         struct check_dir_struct *cd = private;
 277         char                    *buf;
 278         e2fsck_t                ctx;
 279         int                     problem;
 280
 281         buf = cd->buf;
 282         ctx = cd->ctx;
 283
 284         /*
 285          * Make sure the inode is still in use (could have been
 286          * deleted in the duplicate/bad blocks pass.
 287          */
 288         if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, ino)))
 289                 return 0;
 290
 291         cd->pctx.ino = ino;
 292         cd->pctx.blk = block_nr;
 293         cd->pctx.blkcount = db->blockcnt;
 294         cd->pctx.ino2 = 0;
 295         cd->pctx.dirent = 0;
 296         cd->pctx.num = 0;
 297
 298         if (db->blk == 0) {
 299                 if (allocate_dir_block(ctx, db, buf, &cd->pctx))
 300                         return 0;
 301                 block_nr = db->blk;
 302         }
 303
 304         if (db->blockcnt)
 305                 dot_state = 2;
 306         else
 307                 dot_state = 0;
 308
 309 #if 0
 310         printf("In process_dir_block block %lu, #%d, inode %lu\n", block_nr,
 311                db->blockcnt, ino);
 312 #endif
 313
 314         cd->pctx.errcode = ext2fs_read_dir_block(fs, block_nr, buf);
 315         if (cd->pctx.errcode) {
 316                 if (!fix_problem(ctx, PR_2_READ_DIRBLOCK, &cd->pctx)) {
 317                         ctx->flags |= E2F_FLAG_ABORT;
 318                         return DIRENT_ABORT;
 319                 }
 320                 memset(buf, 0, fs->blocksize);
 321         }
 322
 323         do {
 324                 dot_state++;
 325                 problem = 0;
 326                 dirent = (struct ext2_dir_entry *) (buf + offset);
 327                 cd->pctx.dirent = dirent;
 328                 cd->pctx.num = offset;
 329                 if (((offset + dirent->rec_len) > fs->blocksize) ||
 330                     (dirent->rec_len < 8) ||
 331                     ((dirent->rec_len % 4) != 0) ||
 332                     ((dirent->name_len+8) > dirent->rec_len)) {
 333                         if (fix_problem(ctx, PR_2_DIR_CORRUPTED, &cd->pctx)) {
 334                                 dirent->rec_len = fs->blocksize - offset;
 335                                 dirent->name_len = 0;
 336                                 dirent->inode = 0;
 337                                 dir_modified++;
 338                         } else
 339                                 return DIRENT_ABORT;
 340                 }
 341                 if (dirent->name_len > EXT2_NAME_LEN) {
 342                         if (fix_problem(ctx, PR_2_FILENAME_LONG, &cd->pctx)) {
 343                                 dirent->name_len = EXT2_NAME_LEN;
 344                                 dir_modified++;
 345                         }
 346                 }
 347
 348                 if (dot_state == 1) {
 349                         if (check_dot(ctx, dirent, ino, &cd->pctx))
 350                                 dir_modified++;
 351                 } else if (dot_state == 2) {
 352                         dir = e2fsck_get_dir_info(ctx, ino);
 353                         if (!dir) {
 354                                 fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx);
 355                                 ctx->flags |= E2F_FLAG_ABORT;
 356                                 return DIRENT_ABORT;
 357                         }
 358                         if (check_dotdot(ctx, dirent, dir, &cd->pctx))
 359                                 dir_modified++;
 360                 } else if (dirent->inode == ino) {
 361                         problem = PR_2_LINK_DOT;
 362                         if (fix_problem(ctx, PR_2_LINK_DOT, &cd->pctx)) {
 363                                 dirent->inode = 0;
 364                                 dir_modified++;
 365                                 goto next;
 366                         }
 367                 }
 368                 if (!dirent->inode)
 369                         goto next;
 370
 371                 /*
 372                  * Make sure the inode listed is a legal one.
 373                  */
 374                 if (((dirent->inode != EXT2_ROOT_INO) &&
 375                      (dirent->inode < EXT2_FIRST_INODE(fs->super))) ||
 376                     (dirent->inode > fs->super->s_inodes_count)) {
 377                         problem = PR_2_BAD_INO;
 378                 } else if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map,
 379                                                dirent->inode))) {
 380                         /*
 381                          * If the inode is unused, offer to clear it.
 382                          */
 383                         problem = PR_2_UNUSED_INODE;
 384                 } else if (ctx->inode_bb_map &&
 385                            (ext2fs_test_inode_bitmap(ctx->inode_bb_map,
 386                                                      dirent->inode))) {
 387                         /*
 388                          * If the inode is in a bad block, offer to
 389                          * clear it.
 390                          */
 391                         problem = PR_2_BB_INODE;
 392                 } else if ((dot_state > 2) &&
 393                            (dirent->name_len == 1) &&
 394                            (dirent->name[0] == '.')) {
 395                         /*
 396                          * If there's a '.' entry in anything other
 397                          * than the first directory entry, it's a
 398                          * duplicate entry that should be removed.
 399                          */
 400                         problem = PR_2_DUP_DOT;
 401                 } else if ((dot_state > 2) &&
 402                            (dirent->name_len == 2) &&
 403                            (dirent->name[0] == '.') &&
 404                            (dirent->name[1] == '.')) {
 405                         /*
 406                          * If there's a '..' entry in anything other
 407                          * than the second directory entry, it's a
 408                          * duplicate entry that should be removed.
 409                          */
 410                         problem = PR_2_DUP_DOT_DOT;
 411                 } else if ((dot_state > 2) &&
 412                            (dirent->inode == EXT2_ROOT_INO)) {
 413                         /*
 414                          * Don't allow links to the root directory.
 415                          * We check this specially to make sure we
 416                          * catch this error case even if the root
 417                          * directory hasn't been created yet.
 418                          */
 419                         problem = PR_2_LINK_ROOT;
 420                 }
 421
 422                 if (problem) {
 423                         if (fix_problem(ctx, problem, &cd->pctx)) {
 424                                 dirent->inode = 0;
 425                                 dir_modified++;
 426                                 goto next;
 427                         } else {
 428                                 ext2fs_unmark_valid(fs);
 429                                 if (problem == PR_2_BAD_INO)
 430                                         goto next;
 431                         }
 432                 }
 433
 434                 /*
 435                  * If the inode was marked as having bad fields in
 436                  * pass1, process it and offer to fix/clear it.
 437                  * (We wait until now so that we can display the
 438                  * pathname to the user.)
 439                  */
 440                 if (ctx->inode_bad_map &&
 441                     ext2fs_test_inode_bitmap(ctx->inode_bad_map,
 442                                              dirent->inode)) {
 443                         if (process_bad_inode(ctx, ino, dirent->inode)) {
 444                                 dirent->inode = 0;
 445                                 dir_modified++;
 446                                 goto next;
 447                         }
 448                         if (ctx->flags & E2F_FLAG_ABORT)
 449                                 return DIRENT_ABORT;
 450                 }
 451
 452                 if (check_name(ctx, dirent, ino, &cd->pctx))
 453                         dir_modified++;
 454
 455                 /*
 456                  * If this is a directory, then mark its parent in its
 457                  * dir_info structure.  If the parent field is already
 458                  * filled in, then this directory has more than one
 459                  * hard link.  We assume the first link is correct,
 460                  * and ask the user if he/she wants to clear this one.
 461                  */
 462                 if ((dot_state > 2) &&
 463                     (ext2fs_test_inode_bitmap(ctx->inode_dir_map,
 464                                               dirent->inode))) {
 465                         subdir = e2fsck_get_dir_info(ctx, dirent->inode);
 466                         if (!subdir) {
 467                                 cd->pctx.ino = dirent->inode;
 468                                 fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx);
 469                                 ctx->flags |= E2F_FLAG_ABORT;
 470                                 return DIRENT_ABORT;
 471                         }
 472                         if (subdir->parent) {
 473                                 cd->pctx.ino2 = subdir->parent;
 474                                 if (fix_problem(ctx, PR_2_LINK_DIR,
 475                                                 &cd->pctx)) {
 476                                         dirent->inode = 0;
 477                                         dir_modified++;
 478                                         goto next;
 479                                 }
 480                                 cd->pctx.ino2 = 0;
 481                         } else
 482                                 subdir->parent = ino;
 483                 }
 484
 485                 ext2fs_icount_increment(ctx->inode_count, dirent->inode,
 486                                         &links);
 487                 if (links > 1)
 488                         ctx->fs_links_count++;
 489                 ctx->fs_total_count++;
 490         next:
 491                 offset += dirent->rec_len;
 492         } while (offset < fs->blocksize);
 493 #if 0
 494         printf("\n");
 495 #endif
 496         if (offset != fs->blocksize) {
 497                 cd->pctx.num = dirent->rec_len - fs->blocksize + offset;
 498                 if (fix_problem(ctx, PR_2_FINAL_RECLEN, &cd->pctx)) {
 499                         dirent->rec_len = cd->pctx.num;
 500                         dir_modified++;
 501                 }
 502         }
 503         if (dir_modified) {
 504                 cd->pctx.errcode = ext2fs_write_dir_block(fs, block_nr, buf);
 505                 if (cd->pctx.errcode) {
 506                         if (!fix_problem(ctx, PR_2_WRITE_DIRBLOCK,
 507                                          &cd->pctx)) {
 508                                 ctx->flags |= E2F_FLAG_ABORT;
 509                                 return DIRENT_ABORT;
 510                         }
 511                 }
 512                 ext2fs_mark_changed(fs);
 513         }
 514         return 0;
 515 }
 516
 517 /*
 518  * This function is called to deallocate a block, and is an interator
 519  * functioned called by deallocate inode via ext2fs_iterate_block().
 520  */
 521 static int deallocate_inode_block(ext2_filsys fs,
 522                              blk_t      *block_nr,
 523                              int blockcnt,
 524                              void *private)
 525 {
 526         e2fsck_t        ctx = (e2fsck_t) private;
 527
 528         if (!*block_nr)
 529                 return 0;
 530         ext2fs_unmark_block_bitmap(ctx->block_found_map, *block_nr);
 531         ext2fs_unmark_block_bitmap(fs->block_map, *block_nr);
 532         return 0;
 533 }
 534
 535 /*
 536  * This fuction deallocates an inode
 537  */
 538 static void deallocate_inode(e2fsck_t ctx, ino_t ino,
 539                              char* block_buf)
 540 {
 541         ext2_filsys fs = ctx->fs;
 542         struct ext2_inode       inode;
 543         struct problem_context  pctx;
 544
 545         ext2fs_icount_store(ctx->inode_link_info, ino, 0);
 546         e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode");
 547         inode.i_links_count = 0;
 548         inode.i_dtime = time(0);
 549         e2fsck_write_inode(ctx, ino, &inode, "deallocate_inode");
 550         clear_problem_context(&pctx);
 551         pctx.ino = ino;
 552
 553         /*
 554          * Fix up the bitmaps...
 555          */
 556         read_bitmaps(ctx);
 557         ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino);
 558         ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
 559         if (ctx->inode_bad_map)
 560                 ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino);
 561         ext2fs_unmark_inode_bitmap(fs->inode_map, ino);
 562         ext2fs_mark_ib_dirty(fs);
 563
 564         if (!ext2fs_inode_has_valid_blocks(&inode))
 565                 return;
 566
 567         ext2fs_mark_bb_dirty(fs);
 568         pctx.errcode = ext2fs_block_iterate(fs, ino, 0, block_buf,
 569                                             deallocate_inode_block, ctx);
 570         if (pctx.errcode) {
 571                 fix_problem(ctx, PR_2_DEALLOC_INODE, &pctx);
 572                 ctx->flags |= E2F_FLAG_ABORT;
 573                 return;
 574         }
 575 }
 576
 577 static int process_bad_inode(e2fsck_t ctx, ino_t dir, ino_t ino)
 578 {
 579         ext2_filsys fs = ctx->fs;
 580         struct ext2_inode       inode;
 581         int                     inode_modified = 0;
 582         unsigned char           *frag, *fsize;
 583         struct problem_context  pctx;
 584         int     problem = 0;
 585
 586         e2fsck_read_inode(ctx, ino, &inode, "process_bad_inode");
 587
 588         clear_problem_context(&pctx);
 589         pctx.ino = ino;
 590         pctx.dir = dir;
 591         pctx.inode = &inode;
 592
 593         if (!LINUX_S_ISDIR(inode.i_mode) && !LINUX_S_ISREG(inode.i_mode) &&
 594             !LINUX_S_ISCHR(inode.i_mode) && !LINUX_S_ISBLK(inode.i_mode) &&
 595             !LINUX_S_ISLNK(inode.i_mode) && !LINUX_S_ISFIFO(inode.i_mode) &&
 596             !(LINUX_S_ISSOCK(inode.i_mode)))
 597                 problem = PR_2_BAD_MODE;
 598
 599         if (LINUX_S_ISCHR(inode.i_mode)
 600             && !e2fsck_pass1_check_device_inode(&inode))
 601                 problem = PR_2_BAD_CHAR_DEV;
 602
 603         if (LINUX_S_ISBLK(inode.i_mode)
 604             && !e2fsck_pass1_check_device_inode(&inode))
 605                 problem = PR_2_BAD_BLOCK_DEV;
 606
 607         if (problem) {
 608                 if (fix_problem(ctx, problem, &pctx)) {
 609                         deallocate_inode(ctx, ino, 0);
 610                         if (ctx->flags & E2F_FLAG_ABORT)
 611                                 return 0;
 612                         return 1;
 613                 }
 614                 problem = 0;
 615         }
 616
 617         if (inode.i_faddr &&
 618             fix_problem(ctx, PR_2_FADDR_ZERO, &pctx)) {
 619                 inode.i_faddr = 0;
 620                 inode_modified++;
 621         }
 622
 623         switch (fs->super->s_creator_os) {
 624             case EXT2_OS_LINUX:
 625                 frag = &inode.osd2.linux2.l_i_frag;
 626                 fsize = &inode.osd2.linux2.l_i_fsize;
 627                 break;
 628             case EXT2_OS_HURD:
 629                 frag = &inode.osd2.hurd2.h_i_frag;
 630                 fsize = &inode.osd2.hurd2.h_i_fsize;
 631                 break;
 632             case EXT2_OS_MASIX:
 633                 frag = &inode.osd2.masix2.m_i_frag;
 634                 fsize = &inode.osd2.masix2.m_i_fsize;
 635                 break;
 636             default:
 637                 frag = fsize = 0;
 638         }
 639         if (frag && *frag) {
 640                 pctx.num = *frag;
 641                 if (fix_problem(ctx, PR_2_FRAG_ZERO, &pctx)) {
 642                         *frag = 0;
 643                         inode_modified++;
 644                 }
 645                 pctx.num = 0;
 646         }
 647         if (fsize && *fsize) {
 648                 pctx.num = *fsize;
 649                 if (fix_problem(ctx, PR_2_FSIZE_ZERO, &pctx)) {
 650                         *fsize = 0;
 651                         inode_modified++;
 652                 }
 653                 pctx.num = 0;
 654         }
 655
 656         if (inode.i_file_acl &&
 657             fix_problem(ctx, PR_2_FILE_ACL_ZERO, &pctx)) {
 658                 inode.i_file_acl = 0;
 659                 inode_modified++;
 660         }
 661         if (inode.i_dir_acl &&
 662             fix_problem(ctx, PR_2_DIR_ACL_ZERO, &pctx)) {
 663                 inode.i_dir_acl = 0;
 664                 inode_modified++;
 665         }
 666         if (inode_modified)
 667                 e2fsck_write_inode(ctx, ino, &inode, "process_bad_inode");
 668         return 0;
 669 }
 670
 671
 672 /*
 673  * allocate_dir_block --- this function allocates a new directory
 674  *      block for a particular inode; this is done if a directory has
 675  *      a "hole" in it, or if a directory has a illegal block number
 676  *      that was zeroed out and now needs to be replaced.
 677  */
 678 static int allocate_dir_block(e2fsck_t ctx,
 679                               struct ext2_db_entry *db,
 680                               char *buf, struct problem_context *pctx)
 681 {
 682         ext2_filsys fs = ctx->fs;
 683         blk_t                   blk;
 684         char                    *block;
 685         struct ext2_inode       inode;
 686
 687         if (fix_problem(ctx, PR_2_DIRECTORY_HOLE, pctx) == 0)
 688                 return 1;
 689
 690         /*
 691          * Read the inode and block bitmaps in; we'll be messing with
 692          * them.
 693          */
 694         read_bitmaps(ctx);
 695
 696         /*
 697          * First, find a free block
 698          */
 699         pctx->errcode = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk);
 700         if (pctx->errcode) {
 701                 pctx->str = "ext2fs_new_block";
 702                 fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
 703                 return 1;
 704         }
 705         ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
 706         ext2fs_mark_block_bitmap(fs->block_map, blk);
 707         ext2fs_mark_bb_dirty(fs);
 708
 709         /*
 710          * Now let's create the actual data block for the inode
 711          */
 712         if (db->blockcnt)
 713                 pctx->errcode = ext2fs_new_dir_block(fs, 0, 0, &block);
 714         else
 715                 pctx->errcode = ext2fs_new_dir_block(fs, db->ino,
 716                                                      EXT2_ROOT_INO, &block);
 717
 718         if (pctx->errcode) {
 719                 pctx->str = "ext2fs_new_dir_block";
 720                 fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
 721                 return 1;
 722         }
 723
 724         pctx->errcode = ext2fs_write_dir_block(fs, blk, block);
 725         ext2fs_free_mem((void **) &block);
 726         if (pctx->errcode) {
 727                 pctx->str = "ext2fs_write_dir_block";
 728                 fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
 729                 return 1;
 730         }
 731
 732         /*
 733          * Update the inode block count
 734          */
 735         e2fsck_read_inode(ctx, db->ino, &inode, "allocate_dir_block");
 736         inode.i_blocks += fs->blocksize / 512;
 737         if (inode.i_size < (db->blockcnt+1) * fs->blocksize)
 738                 inode.i_size = (db->blockcnt+1) * fs->blocksize;
 739         e2fsck_write_inode(ctx, db->ino, &inode, "allocate_dir_block");
 740
 741         /*
 742          * Finally, update the block pointers for the inode
 743          */
 744         db->blk = blk;
 745         pctx->errcode = ext2fs_block_iterate(fs, db->ino, BLOCK_FLAG_HOLE,
 746                                       0, update_dir_block, db);
 747         if (pctx->errcode) {
 748                 pctx->str = "ext2fs_block_iterate";
 749                 fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
 750                 return 1;
 751         }
 752
 753         return 0;
 754 }
 755
 756 /*
 757  * This is a helper function for allocate_dir_block().
 758  */
 759 static int update_dir_block(ext2_filsys fs,
 760                             blk_t       *block_nr,
 761                             int blockcnt,
 762                             void *private)
 763 {
 764         struct ext2_db_entry *db = private;
 765
 766         if (db->blockcnt == blockcnt) {
 767                 *block_nr = db->blk;
 768                 return BLOCK_CHANGED;
 769         }
 770         return 0;
 771 }
 772