util.c revision 18a1444b4f1e6a0948fd38fa0de382d86cfe04de
1/* 2 * util.c --- miscellaneous utilities 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 12#include <stdlib.h> 13#include <stdio.h> 14#include <unistd.h> 15#include <string.h> 16#include <ctype.h> 17#ifdef __linux__ 18#include <sys/utsname.h> 19#endif 20 21#ifdef HAVE_CONIO_H 22#undef HAVE_TERMIOS_H 23#include <conio.h> 24#define read_a_char() getch() 25#else 26#ifdef HAVE_TERMIOS_H 27#include <termios.h> 28#endif 29#endif 30 31#ifdef HAVE_MALLOC_H 32#include <malloc.h> 33#endif 34 35#ifdef HAVE_ERRNO_H 36#include <errno.h> 37#endif 38 39#include "e2fsck.h" 40 41extern e2fsck_t e2fsck_global_ctx; /* Try your very best not to use this! */ 42 43#include <stdarg.h> 44#include <time.h> 45#include <sys/time.h> 46#include <sys/resource.h> 47 48void fatal_error(e2fsck_t ctx, const char *msg) 49{ 50 ext2_filsys fs = ctx->fs; 51 int exit_value = FSCK_ERROR; 52 53 if (msg) 54 fprintf (stderr, "e2fsck: %s\n", msg); 55 if (!fs) 56 goto out; 57 if (fs->io && fs->super) { 58 ext2fs_mmp_stop(ctx->fs); 59 if (ctx->fs->io->magic == EXT2_ET_MAGIC_IO_CHANNEL) 60 io_channel_flush(ctx->fs->io); 61 else 62 log_err(ctx, "e2fsck: io manager magic bad!\n"); 63 } 64 if (ext2fs_test_changed(fs)) { 65 exit_value |= FSCK_NONDESTRUCT; 66 log_out(ctx, _("\n%s: ***** FILE SYSTEM WAS MODIFIED *****\n"), 67 ctx->device_name); 68 if (ctx->mount_flags & EXT2_MF_ISROOT) 69 exit_value |= FSCK_REBOOT; 70 } 71 if (!ext2fs_test_valid(fs)) { 72 log_out(ctx, _("\n%s: ********** WARNING: Filesystem still has " 73 "errors **********\n\n"), ctx->device_name); 74 exit_value |= FSCK_UNCORRECTED; 75 exit_value &= ~FSCK_NONDESTRUCT; 76 } 77out: 78 ctx->flags |= E2F_FLAG_ABORT; 79 if (ctx->flags & E2F_FLAG_SETJMP_OK) 80 longjmp(ctx->abort_loc, 1); 81 exit(exit_value); 82} 83 84void log_out(e2fsck_t ctx, const char *fmt, ...) 85{ 86 va_list pvar; 87 88 va_start(pvar, fmt); 89 vprintf(fmt, pvar); 90 va_end(pvar); 91 if (ctx->logf) { 92 va_start(pvar, fmt); 93 vfprintf(ctx->logf, fmt, pvar); 94 va_end(pvar); 95 } 96} 97 98void log_err(e2fsck_t ctx, const char *fmt, ...) 99{ 100 va_list pvar; 101 102 va_start(pvar, fmt); 103 vfprintf(stderr, fmt, pvar); 104 va_end(pvar); 105 if (ctx->logf) { 106 va_start(pvar, fmt); 107 vfprintf(ctx->logf, fmt, pvar); 108 va_end(pvar); 109 } 110} 111 112void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size, 113 const char *description) 114{ 115 void *ret; 116 char buf[256]; 117 118#ifdef DEBUG_ALLOCATE_MEMORY 119 printf("Allocating %u bytes for %s...\n", size, description); 120#endif 121 ret = malloc(size); 122 if (!ret) { 123 sprintf(buf, "Can't allocate %u bytes for %s\n", 124 size, description); 125 fatal_error(ctx, buf); 126 } 127 memset(ret, 0, size); 128 return ret; 129} 130 131char *string_copy(e2fsck_t ctx EXT2FS_ATTR((unused)), 132 const char *str, int len) 133{ 134 char *ret; 135 136 if (!str) 137 return NULL; 138 if (!len) 139 len = strlen(str); 140 ret = malloc(len+1); 141 if (ret) { 142 strncpy(ret, str, len); 143 ret[len] = 0; 144 } 145 return ret; 146} 147 148#ifndef HAVE_STRNLEN 149/* 150 * Incredibly, libc5 doesn't appear to have strnlen. So we have to 151 * provide our own. 152 */ 153int e2fsck_strnlen(const char * s, int count) 154{ 155 const char *cp = s; 156 157 while (count-- && *cp) 158 cp++; 159 return cp - s; 160} 161#endif 162 163#ifndef HAVE_CONIO_H 164static int read_a_char(void) 165{ 166 char c; 167 int r; 168 int fail = 0; 169 170 while(1) { 171 if (e2fsck_global_ctx && 172 (e2fsck_global_ctx->flags & E2F_FLAG_CANCEL)) { 173 return 3; 174 } 175 r = read(0, &c, 1); 176 if (r == 1) 177 return c; 178 if (fail++ > 100) 179 break; 180 } 181 return EOF; 182} 183#endif 184 185int ask_yn(e2fsck_t ctx, const char * string, int def) 186{ 187 int c; 188 const char *defstr; 189 const char *short_yes = _("yY"); 190 const char *short_no = _("nN"); 191 192#ifdef HAVE_TERMIOS_H 193 struct termios termios, tmp; 194 195 tcgetattr (0, &termios); 196 tmp = termios; 197 tmp.c_lflag &= ~(ICANON | ECHO); 198 tmp.c_cc[VMIN] = 1; 199 tmp.c_cc[VTIME] = 0; 200 tcsetattr (0, TCSANOW, &tmp); 201#endif 202 203 if (def == 1) 204 defstr = _(_("<y>")); 205 else if (def == 0) 206 defstr = _(_("<n>")); 207 else 208 defstr = _(" (y/n)"); 209 log_out(ctx, "%s%s? ", string, defstr); 210 while (1) { 211 fflush (stdout); 212 if ((c = read_a_char()) == EOF) 213 break; 214 if (c == 3) { 215#ifdef HAVE_TERMIOS_H 216 tcsetattr (0, TCSANOW, &termios); 217#endif 218 if (ctx->flags & E2F_FLAG_SETJMP_OK) { 219 log_out(ctx, "\n"); 220 longjmp(e2fsck_global_ctx->abort_loc, 1); 221 } 222 log_out(ctx, "%s", _("cancelled!\n")); 223 return 0; 224 } 225 if (strchr(short_yes, (char) c)) { 226 def = 1; 227 break; 228 } 229 else if (strchr(short_no, (char) c)) { 230 def = 0; 231 break; 232 } 233 else if ((c == 27 || c == ' ' || c == '\n') && (def != -1)) 234 break; 235 } 236 if (def) 237 log_out(ctx, "%s", _("yes\n")); 238 else 239 log_out(ctx, "%s", _("no\n")); 240#ifdef HAVE_TERMIOS_H 241 tcsetattr (0, TCSANOW, &termios); 242#endif 243 return def; 244} 245 246int ask (e2fsck_t ctx, const char * string, int def) 247{ 248 if (ctx->options & E2F_OPT_NO) { 249 log_out(ctx, _("%s? no\n\n"), string); 250 return 0; 251 } 252 if (ctx->options & E2F_OPT_YES) { 253 log_out(ctx, _("%s? yes\n\n"), string); 254 return 1; 255 } 256 if (ctx->options & E2F_OPT_PREEN) { 257 log_out(ctx, "%s? %s\n\n", string, def ? _("yes") : _("no")); 258 return def; 259 } 260 return ask_yn(ctx, string, def); 261} 262 263void e2fsck_read_bitmaps(e2fsck_t ctx) 264{ 265 ext2_filsys fs = ctx->fs; 266 errcode_t retval; 267 const char *old_op; 268 unsigned int save_type; 269 270 if (ctx->invalid_bitmaps) { 271 com_err(ctx->program_name, 0, 272 _("e2fsck_read_bitmaps: illegal bitmap block(s) for %s"), 273 ctx->device_name); 274 fatal_error(ctx, 0); 275 } 276 277 old_op = ehandler_operation(_("reading inode and block bitmaps")); 278 e2fsck_set_bitmap_type(fs, EXT2FS_BMAP64_RBTREE, "fs_bitmaps", 279 &save_type); 280 retval = ext2fs_read_bitmaps(fs); 281 fs->default_bitmap_type = save_type; 282 ehandler_operation(old_op); 283 if (retval) { 284 com_err(ctx->program_name, retval, 285 _("while retrying to read bitmaps for %s"), 286 ctx->device_name); 287 fatal_error(ctx, 0); 288 } 289} 290 291void e2fsck_write_bitmaps(e2fsck_t ctx) 292{ 293 ext2_filsys fs = ctx->fs; 294 errcode_t retval; 295 const char *old_op; 296 297 old_op = ehandler_operation(_("writing block and inode bitmaps")); 298 retval = ext2fs_write_bitmaps(fs); 299 ehandler_operation(old_op); 300 if (retval) { 301 com_err(ctx->program_name, retval, 302 _("while rewriting block and inode bitmaps for %s"), 303 ctx->device_name); 304 fatal_error(ctx, 0); 305 } 306} 307 308void preenhalt(e2fsck_t ctx) 309{ 310 ext2_filsys fs = ctx->fs; 311 312 if (!(ctx->options & E2F_OPT_PREEN)) 313 return; 314 log_err(ctx, _("\n\n%s: UNEXPECTED INCONSISTENCY; " 315 "RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n"), 316 ctx->device_name); 317 ctx->flags |= E2F_FLAG_EXITING; 318 if (fs != NULL) { 319 fs->super->s_state |= EXT2_ERROR_FS; 320 ext2fs_mark_super_dirty(fs); 321 ext2fs_close(fs); 322 } 323 exit(FSCK_UNCORRECTED); 324} 325 326#ifdef RESOURCE_TRACK 327void init_resource_track(struct resource_track *track, io_channel channel) 328{ 329#ifdef HAVE_GETRUSAGE 330 struct rusage r; 331#endif 332 io_stats io_start = 0; 333 334 track->brk_start = sbrk(0); 335 gettimeofday(&track->time_start, 0); 336#ifdef HAVE_GETRUSAGE 337#ifdef sun 338 memset(&r, 0, sizeof(struct rusage)); 339#endif 340 getrusage(RUSAGE_SELF, &r); 341 track->user_start = r.ru_utime; 342 track->system_start = r.ru_stime; 343#else 344 track->user_start.tv_sec = track->user_start.tv_usec = 0; 345 track->system_start.tv_sec = track->system_start.tv_usec = 0; 346#endif 347 track->bytes_read = 0; 348 track->bytes_written = 0; 349 if (channel && channel->manager && channel->manager->get_stats) 350 channel->manager->get_stats(channel, &io_start); 351 if (io_start) { 352 track->bytes_read = io_start->bytes_read; 353 track->bytes_written = io_start->bytes_written; 354 } 355} 356 357#ifdef __GNUC__ 358#define _INLINE_ __inline__ 359#else 360#define _INLINE_ 361#endif 362 363static _INLINE_ float timeval_subtract(struct timeval *tv1, 364 struct timeval *tv2) 365{ 366 return ((tv1->tv_sec - tv2->tv_sec) + 367 ((float) (tv1->tv_usec - tv2->tv_usec)) / 1000000); 368} 369 370void print_resource_track(e2fsck_t ctx, const char *desc, 371 struct resource_track *track, io_channel channel) 372{ 373#ifdef HAVE_GETRUSAGE 374 struct rusage r; 375#endif 376#ifdef HAVE_MALLINFO 377 struct mallinfo malloc_info; 378#endif 379 struct timeval time_end; 380 381 if ((desc && !(ctx->options & E2F_OPT_TIME2)) || 382 (!desc && !(ctx->options & E2F_OPT_TIME))) 383 return; 384 385 e2fsck_clear_progbar(ctx); 386 gettimeofday(&time_end, 0); 387 388 if (desc) 389 log_out(ctx, "%s: ", desc); 390 391#ifdef HAVE_MALLINFO 392#define kbytes(x) (((unsigned long)(x) + 1023) / 1024) 393 394 malloc_info = mallinfo(); 395 log_out(ctx, _("Memory used: %luk/%luk (%luk/%luk), "), 396 kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd), 397 kbytes(malloc_info.uordblks), kbytes(malloc_info.fordblks)); 398#else 399 log_out(ctx, _("Memory used: %lu, "), 400 (unsigned long) (((char *) sbrk(0)) - 401 ((char *) track->brk_start))); 402#endif 403#ifdef HAVE_GETRUSAGE 404 getrusage(RUSAGE_SELF, &r); 405 406 log_out(ctx, _("time: %5.2f/%5.2f/%5.2f\n"), 407 timeval_subtract(&time_end, &track->time_start), 408 timeval_subtract(&r.ru_utime, &track->user_start), 409 timeval_subtract(&r.ru_stime, &track->system_start)); 410#else 411 log_out(ctx, _("elapsed time: %6.3f\n"), 412 timeval_subtract(&time_end, &track->time_start)); 413#endif 414#define mbytes(x) (((x) + 1048575) / 1048576) 415 if (channel && channel->manager && channel->manager->get_stats) { 416 io_stats delta = 0; 417 unsigned long long bytes_read = 0; 418 unsigned long long bytes_written = 0; 419 420 if (desc) 421 log_out(ctx, "%s: ", desc); 422 423 channel->manager->get_stats(channel, &delta); 424 if (delta) { 425 bytes_read = delta->bytes_read - track->bytes_read; 426 bytes_written = delta->bytes_written - 427 track->bytes_written; 428 } 429 log_out(ctx, "I/O read: %lluMB, write: %lluMB, " 430 "rate: %.2fMB/s\n", 431 mbytes(bytes_read), mbytes(bytes_written), 432 (double)mbytes(bytes_read + bytes_written) / 433 timeval_subtract(&time_end, &track->time_start)); 434 } 435} 436#endif /* RESOURCE_TRACK */ 437 438void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino, 439 struct ext2_inode * inode, const char *proc) 440{ 441 errcode_t retval; 442 443 retval = ext2fs_read_inode(ctx->fs, ino, inode); 444 if (retval) { 445 com_err("ext2fs_read_inode", retval, 446 _("while reading inode %lu in %s"), ino, proc); 447 fatal_error(ctx, 0); 448 } 449} 450 451void e2fsck_read_inode_full(e2fsck_t ctx, unsigned long ino, 452 struct ext2_inode *inode, int bufsize, 453 const char *proc) 454{ 455 errcode_t retval; 456 457 retval = ext2fs_read_inode_full(ctx->fs, ino, inode, bufsize); 458 if (retval) { 459 com_err("ext2fs_read_inode_full", retval, 460 _("while reading inode %lu in %s"), ino, proc); 461 fatal_error(ctx, 0); 462 } 463} 464 465void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino, 466 struct ext2_inode * inode, int bufsize, 467 const char *proc) 468{ 469 errcode_t retval; 470 471 retval = ext2fs_write_inode_full(ctx->fs, ino, inode, bufsize); 472 if (retval) { 473 com_err("ext2fs_write_inode", retval, 474 _("while writing inode %lu in %s"), ino, proc); 475 fatal_error(ctx, 0); 476 } 477} 478 479void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino, 480 struct ext2_inode * inode, const char *proc) 481{ 482 errcode_t retval; 483 484 retval = ext2fs_write_inode(ctx->fs, ino, inode); 485 if (retval) { 486 com_err("ext2fs_write_inode", retval, 487 _("while writing inode %lu in %s"), ino, proc); 488 fatal_error(ctx, 0); 489 } 490} 491 492#ifdef MTRACE 493void mtrace_print(char *mesg) 494{ 495 FILE *malloc_get_mallstream(); 496 FILE *f = malloc_get_mallstream(); 497 498 if (f) 499 fprintf(f, "============= %s\n", mesg); 500} 501#endif 502 503blk64_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs, const char *name, 504 io_manager manager) 505{ 506 struct ext2_super_block *sb; 507 io_channel io = NULL; 508 void *buf = NULL; 509 int blocksize; 510 blk64_t superblock, ret_sb = 8193; 511 512 if (fs && fs->super) { 513 ret_sb = (fs->super->s_blocks_per_group + 514 fs->super->s_first_data_block); 515 if (ctx) { 516 ctx->superblock = ret_sb; 517 ctx->blocksize = fs->blocksize; 518 } 519 return ret_sb; 520 } 521 522 if (ctx) { 523 if (ctx->blocksize) { 524 ret_sb = ctx->blocksize * 8; 525 if (ctx->blocksize == 1024) 526 ret_sb++; 527 ctx->superblock = ret_sb; 528 return ret_sb; 529 } 530 ctx->superblock = ret_sb; 531 ctx->blocksize = 1024; 532 } 533 534 if (!name || !manager) 535 goto cleanup; 536 537 if (manager->open(name, 0, &io) != 0) 538 goto cleanup; 539 540 if (ext2fs_get_mem(SUPERBLOCK_SIZE, &buf)) 541 goto cleanup; 542 sb = (struct ext2_super_block *) buf; 543 544 for (blocksize = EXT2_MIN_BLOCK_SIZE; 545 blocksize <= EXT2_MAX_BLOCK_SIZE ; blocksize *= 2) { 546 superblock = blocksize*8; 547 if (blocksize == 1024) 548 superblock++; 549 io_channel_set_blksize(io, blocksize); 550 if (io_channel_read_blk64(io, superblock, 551 -SUPERBLOCK_SIZE, buf)) 552 continue; 553#ifdef WORDS_BIGENDIAN 554 if (sb->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC)) 555 ext2fs_swap_super(sb); 556#endif 557 if ((sb->s_magic == EXT2_SUPER_MAGIC) && 558 (EXT2_BLOCK_SIZE(sb) == blocksize)) { 559 ret_sb = superblock; 560 if (ctx) { 561 ctx->superblock = superblock; 562 ctx->blocksize = blocksize; 563 } 564 break; 565 } 566 } 567 568cleanup: 569 if (io) 570 io_channel_close(io); 571 if (buf) 572 ext2fs_free_mem(&buf); 573 return (ret_sb); 574} 575 576/* 577 * Given a mode, return the ext2 file type 578 */ 579int ext2_file_type(unsigned int mode) 580{ 581 if (LINUX_S_ISREG(mode)) 582 return EXT2_FT_REG_FILE; 583 584 if (LINUX_S_ISDIR(mode)) 585 return EXT2_FT_DIR; 586 587 if (LINUX_S_ISCHR(mode)) 588 return EXT2_FT_CHRDEV; 589 590 if (LINUX_S_ISBLK(mode)) 591 return EXT2_FT_BLKDEV; 592 593 if (LINUX_S_ISLNK(mode)) 594 return EXT2_FT_SYMLINK; 595 596 if (LINUX_S_ISFIFO(mode)) 597 return EXT2_FT_FIFO; 598 599 if (LINUX_S_ISSOCK(mode)) 600 return EXT2_FT_SOCK; 601 602 return 0; 603} 604 605#define STRIDE_LENGTH 8 606/* 607 * Helper function which zeros out _num_ blocks starting at _blk_. In 608 * case of an error, the details of the error is returned via _ret_blk_ 609 * and _ret_count_ if they are non-NULL pointers. Returns 0 on 610 * success, and an error code on an error. 611 * 612 * As a special case, if the first argument is NULL, then it will 613 * attempt to free the static zeroizing buffer. (This is to keep 614 * programs that check for memory leaks happy.) 615 */ 616errcode_t e2fsck_zero_blocks(ext2_filsys fs, blk_t blk, int num, 617 blk_t *ret_blk, int *ret_count) 618{ 619 int j, count; 620 static char *buf; 621 errcode_t retval; 622 623 /* If fs is null, clean up the static buffer and return */ 624 if (!fs) { 625 if (buf) { 626 free(buf); 627 buf = 0; 628 } 629 return 0; 630 } 631 /* Allocate the zeroizing buffer if necessary */ 632 if (!buf) { 633 buf = malloc(fs->blocksize * STRIDE_LENGTH); 634 if (!buf) { 635 com_err("malloc", ENOMEM, "%s", 636 _("while allocating zeroizing buffer")); 637 exit(1); 638 } 639 memset(buf, 0, fs->blocksize * STRIDE_LENGTH); 640 } 641 /* OK, do the write loop */ 642 for (j = 0; j < num; j += STRIDE_LENGTH, blk += STRIDE_LENGTH) { 643 count = num - j; 644 if (count > STRIDE_LENGTH) 645 count = STRIDE_LENGTH; 646 retval = io_channel_write_blk64(fs->io, blk, count, buf); 647 if (retval) { 648 if (ret_count) 649 *ret_count = count; 650 if (ret_blk) 651 *ret_blk = blk; 652 return retval; 653 } 654 } 655 return 0; 656} 657 658/* 659 * Check to see if a filesystem is in /proc/filesystems. 660 * Returns 1 if found, 0 if not 661 */ 662int fs_proc_check(const char *fs_name) 663{ 664 FILE *f; 665 char buf[80], *cp, *t; 666 667 f = fopen("/proc/filesystems", "r"); 668 if (!f) 669 return (0); 670 while (!feof(f)) { 671 if (!fgets(buf, sizeof(buf), f)) 672 break; 673 cp = buf; 674 if (!isspace(*cp)) { 675 while (*cp && !isspace(*cp)) 676 cp++; 677 } 678 while (*cp && isspace(*cp)) 679 cp++; 680 if ((t = strchr(cp, '\n')) != NULL) 681 *t = 0; 682 if ((t = strchr(cp, '\t')) != NULL) 683 *t = 0; 684 if ((t = strchr(cp, ' ')) != NULL) 685 *t = 0; 686 if (!strcmp(fs_name, cp)) { 687 fclose(f); 688 return (1); 689 } 690 } 691 fclose(f); 692 return (0); 693} 694 695/* 696 * Check to see if a filesystem is available as a module 697 * Returns 1 if found, 0 if not 698 */ 699int check_for_modules(const char *fs_name) 700{ 701#ifdef __linux__ 702 struct utsname uts; 703 FILE *f; 704 char buf[1024], *cp, *t; 705 int i; 706 707 if (uname(&uts)) 708 return (0); 709 snprintf(buf, sizeof(buf), "/lib/modules/%s/modules.dep", uts.release); 710 711 f = fopen(buf, "r"); 712 if (!f) 713 return (0); 714 while (!feof(f)) { 715 if (!fgets(buf, sizeof(buf), f)) 716 break; 717 if ((cp = strchr(buf, ':')) != NULL) 718 *cp = 0; 719 else 720 continue; 721 if ((cp = strrchr(buf, '/')) != NULL) 722 cp++; 723 else 724 cp = buf; 725 i = strlen(cp); 726 if (i > 3) { 727 t = cp + i - 3; 728 if (!strcmp(t, ".ko")) 729 *t = 0; 730 } 731 if (!strcmp(cp, fs_name)) { 732 fclose(f); 733 return (1); 734 } 735 } 736 fclose(f); 737#endif /* __linux__ */ 738 return (0); 739} 740 741/* 742 * Helper function that does the right thing if write returns a 743 * partial write, or an EGAIN/EINTR error. 744 */ 745int write_all(int fd, char *buf, size_t count) 746{ 747 ssize_t ret; 748 int c = 0; 749 750 while (count > 0) { 751 ret = write(fd, buf, count); 752 if (ret < 0) { 753 if ((errno == EAGAIN) || (errno == EINTR)) 754 continue; 755 return -1; 756 } 757 count -= ret; 758 buf += ret; 759 c += ret; 760 } 761 return c; 762} 763 764void dump_mmp_msg(struct mmp_struct *mmp, const char *msg) 765{ 766 767 if (msg) 768 printf("MMP check failed: %s\n", msg); 769 if (mmp) { 770 time_t t = mmp->mmp_time; 771 772 printf("MMP error info: last update: %s node: %s device: %s\n", 773 ctime(&t), mmp->mmp_nodename, mmp->mmp_bdevname); 774 } 775} 776 777errcode_t e2fsck_mmp_update(ext2_filsys fs) 778{ 779 errcode_t retval; 780 781 retval = ext2fs_mmp_update(fs); 782 if (retval == EXT2_ET_MMP_CHANGE_ABORT) 783 dump_mmp_msg(fs->mmp_cmp, 784 _("UNEXPECTED INCONSISTENCY: the filesystem is " 785 "being modified while fsck is running.\n")); 786 787 return retval; 788} 789 790void e2fsck_set_bitmap_type(ext2_filsys fs, unsigned int default_type, 791 const char *profile_name, unsigned int *old_type) 792{ 793 unsigned type; 794 795 if (old_type) 796 *old_type = fs->default_bitmap_type; 797 profile_get_uint(e2fsck_global_ctx->profile, "bitmaps", 798 profile_name, 0, default_type, &type); 799 profile_get_uint(e2fsck_global_ctx->profile, "bitmaps", 800 "all", 0, type, &type); 801 fs->default_bitmap_type = type ? type : default_type; 802} 803 804errcode_t e2fsck_allocate_inode_bitmap(ext2_filsys fs, const char *descr, 805 int deftype, 806 const char *name, 807 ext2fs_inode_bitmap *ret) 808{ 809 errcode_t retval; 810 unsigned int save_type; 811 812 e2fsck_set_bitmap_type(fs, deftype, name, &save_type); 813 retval = ext2fs_allocate_inode_bitmap(fs, descr, ret); 814 fs->default_bitmap_type = save_type; 815 return retval; 816} 817 818errcode_t e2fsck_allocate_block_bitmap(ext2_filsys fs, const char *descr, 819 int deftype, 820 const char *name, 821 ext2fs_block_bitmap *ret) 822{ 823 errcode_t retval; 824 unsigned int save_type; 825 826 e2fsck_set_bitmap_type(fs, deftype, name, &save_type); 827 retval = ext2fs_allocate_block_bitmap(fs, descr, ret); 828 fs->default_bitmap_type = save_type; 829 return retval; 830} 831 832errcode_t e2fsck_allocate_subcluster_bitmap(ext2_filsys fs, const char *descr, 833 int deftype, 834 const char *name, 835 ext2fs_block_bitmap *ret) 836{ 837 errcode_t retval; 838 unsigned int save_type; 839 840 e2fsck_set_bitmap_type(fs, deftype, name, &save_type); 841 retval = ext2fs_allocate_subcluster_bitmap(fs, descr, ret); 842 fs->default_bitmap_type = save_type; 843 return retval; 844} 845