1/* 2 * tune2fs.c - Change the file system parameters on an ext2 file system 3 * 4 * Copyright (C) 1992, 1993, 1994 Remy Card <card@masi.ibp.fr> 5 * Laboratoire MASI, Institut Blaise Pascal 6 * Universite Pierre et Marie Curie (Paris VI) 7 * 8 * Copyright 1995, 1996, 1997, 1998, 1999, 2000 by Theodore Ts'o. 9 * 10 * %Begin-Header% 11 * This file may be redistributed under the terms of the GNU Public 12 * License. 13 * %End-Header% 14 */ 15 16/* 17 * History: 18 * 93/06/01 - Creation 19 * 93/10/31 - Added the -c option to change the maximal mount counts 20 * 93/12/14 - Added -l flag to list contents of superblock 21 * M.J.E. Mol (marcel@duteca.et.tudelft.nl) 22 * F.W. ten Wolde (franky@duteca.et.tudelft.nl) 23 * 93/12/29 - Added the -e option to change errors behavior 24 * 94/02/27 - Ported to use the ext2fs library 25 * 94/03/06 - Added the checks interval from Uwe Ohse (uwe@tirka.gun.de) 26 */ 27 28#define _XOPEN_SOURCE 600 /* for inclusion of strptime() */ 29#define _BSD_SOURCE /* for inclusion of strcasecmp() */ 30#include <fcntl.h> 31#include <grp.h> 32#ifdef HAVE_GETOPT_H 33#include <getopt.h> 34#else 35extern char *optarg; 36extern int optind; 37#endif 38#include <pwd.h> 39#include <stdio.h> 40#ifdef HAVE_STDLIB_H 41#include <stdlib.h> 42#endif 43#include <string.h> 44#include <time.h> 45#include <unistd.h> 46#include <sys/types.h> 47#include <libgen.h> 48#include <limits.h> 49 50#include "ext2fs/ext2_fs.h" 51#include "ext2fs/ext2fs.h" 52#include "et/com_err.h" 53#include "uuid/uuid.h" 54#include "e2p/e2p.h" 55#include "jfs_user.h" 56#include "util.h" 57#include "blkid/blkid.h" 58 59#include "../version.h" 60#include "nls-enable.h" 61 62const char *program_name = "tune2fs"; 63char *device_name; 64char *new_label, *new_last_mounted, *new_UUID; 65char *io_options; 66static int c_flag, C_flag, e_flag, f_flag, g_flag, i_flag, l_flag, L_flag; 67static int m_flag, M_flag, r_flag, s_flag = -1, u_flag, U_flag, T_flag; 68static int I_flag; 69static time_t last_check_time; 70static int print_label; 71static int max_mount_count, mount_count, mount_flags; 72static unsigned long interval, reserved_blocks; 73static double reserved_ratio; 74static unsigned long resgid, resuid; 75static unsigned short errors; 76static int open_flag; 77static char *features_cmd; 78static char *mntopts_cmd; 79static int stride, stripe_width; 80static int stride_set, stripe_width_set; 81static char *extended_cmd; 82static unsigned long new_inode_size; 83 84int journal_size, journal_flags; 85char *journal_device; 86 87static struct list_head blk_move_list; 88 89struct blk_move { 90 struct list_head list; 91 blk_t old_loc; 92 blk_t new_loc; 93}; 94 95 96static const char *please_fsck = N_("Please run e2fsck on the filesystem.\n"); 97 98#ifdef CONFIG_BUILD_FINDFS 99void do_findfs(int argc, char **argv); 100#endif 101 102static void usage(void) 103{ 104 fprintf(stderr, 105 _("Usage: %s [-c max_mounts_count] [-e errors_behavior] " 106 "[-g group]\n" 107 "\t[-i interval[d|m|w]] [-j] [-J journal_options] [-l]\n" 108 "\t[-m reserved_blocks_percent] " 109 "[-o [^]mount_options[,...]] \n" 110 "\t[-r reserved_blocks_count] [-u user] [-C mount_count] " 111 "[-L volume_label]\n" 112 "\t[-M last_mounted_dir] [-O [^]feature[,...]]\n" 113 "\t[-E extended-option[,...]] [-T last_check_time] " 114 "[-U UUID]\n\t[ -I new_inode_size ] device\n"), program_name); 115 exit(1); 116} 117 118static __u32 ok_features[3] = { 119 /* Compat */ 120 EXT3_FEATURE_COMPAT_HAS_JOURNAL | 121 EXT2_FEATURE_COMPAT_DIR_INDEX, 122 /* Incompat */ 123 EXT2_FEATURE_INCOMPAT_FILETYPE | 124 EXT3_FEATURE_INCOMPAT_EXTENTS | 125 EXT4_FEATURE_INCOMPAT_FLEX_BG, 126 /* R/O compat */ 127 EXT2_FEATURE_RO_COMPAT_LARGE_FILE | 128 EXT4_FEATURE_RO_COMPAT_HUGE_FILE| 129 EXT4_FEATURE_RO_COMPAT_DIR_NLINK| 130 EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE| 131 EXT4_FEATURE_RO_COMPAT_GDT_CSUM | 132 EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER 133}; 134 135static __u32 clear_ok_features[3] = { 136 /* Compat */ 137 EXT3_FEATURE_COMPAT_HAS_JOURNAL | 138 EXT2_FEATURE_COMPAT_RESIZE_INODE | 139 EXT2_FEATURE_COMPAT_DIR_INDEX, 140 /* Incompat */ 141 EXT2_FEATURE_INCOMPAT_FILETYPE | 142 EXT4_FEATURE_INCOMPAT_FLEX_BG, 143 /* R/O compat */ 144 EXT2_FEATURE_RO_COMPAT_LARGE_FILE | 145 EXT4_FEATURE_RO_COMPAT_HUGE_FILE| 146 EXT4_FEATURE_RO_COMPAT_DIR_NLINK| 147 EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE| 148 EXT4_FEATURE_RO_COMPAT_GDT_CSUM 149}; 150 151/* 152 * Remove an external journal from the filesystem 153 */ 154static void remove_journal_device(ext2_filsys fs) 155{ 156 char *journal_path; 157 ext2_filsys jfs; 158 char buf[1024]; 159 journal_superblock_t *jsb; 160 int i, nr_users; 161 errcode_t retval; 162 int commit_remove_journal = 0; 163 io_manager io_ptr; 164 165 if (f_flag) 166 commit_remove_journal = 1; /* force removal even if error */ 167 168 uuid_unparse(fs->super->s_journal_uuid, buf); 169 journal_path = blkid_get_devname(NULL, "UUID", buf); 170 171 if (!journal_path) { 172 journal_path = 173 ext2fs_find_block_device(fs->super->s_journal_dev); 174 if (!journal_path) 175 return; 176 } 177 178#ifdef CONFIG_TESTIO_DEBUG 179 if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) { 180 io_ptr = test_io_manager; 181 test_io_backing_manager = unix_io_manager; 182 } else 183#endif 184 io_ptr = unix_io_manager; 185 retval = ext2fs_open(journal_path, EXT2_FLAG_RW| 186 EXT2_FLAG_JOURNAL_DEV_OK, 0, 187 fs->blocksize, io_ptr, &jfs); 188 if (retval) { 189 com_err(program_name, retval, 190 _("while trying to open external journal")); 191 goto no_valid_journal; 192 } 193 if (!(jfs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) { 194 fprintf(stderr, _("%s is not a journal device.\n"), 195 journal_path); 196 goto no_valid_journal; 197 } 198 199 /* Get the journal superblock */ 200 if ((retval = io_channel_read_blk(jfs->io, 1, -1024, buf))) { 201 com_err(program_name, retval, 202 _("while reading journal superblock")); 203 goto no_valid_journal; 204 } 205 206 jsb = (journal_superblock_t *) buf; 207 if ((jsb->s_header.h_magic != (unsigned) ntohl(JFS_MAGIC_NUMBER)) || 208 (jsb->s_header.h_blocktype != (unsigned) ntohl(JFS_SUPERBLOCK_V2))) { 209 fputs(_("Journal superblock not found!\n"), stderr); 210 goto no_valid_journal; 211 } 212 213 /* Find the filesystem UUID */ 214 nr_users = ntohl(jsb->s_nr_users); 215 for (i = 0; i < nr_users; i++) { 216 if (memcmp(fs->super->s_uuid, 217 &jsb->s_users[i*16], 16) == 0) 218 break; 219 } 220 if (i >= nr_users) { 221 fputs(_("Filesystem's UUID not found on journal device.\n"), 222 stderr); 223 commit_remove_journal = 1; 224 goto no_valid_journal; 225 } 226 nr_users--; 227 for (i = 0; i < nr_users; i++) 228 memcpy(&jsb->s_users[i*16], &jsb->s_users[(i+1)*16], 16); 229 jsb->s_nr_users = htonl(nr_users); 230 231 /* Write back the journal superblock */ 232 if ((retval = io_channel_write_blk(jfs->io, 1, -1024, buf))) { 233 com_err(program_name, retval, 234 "while writing journal superblock."); 235 goto no_valid_journal; 236 } 237 238 commit_remove_journal = 1; 239 240no_valid_journal: 241 if (commit_remove_journal == 0) { 242 fputs(_("Journal NOT removed\n"), stderr); 243 exit(1); 244 } 245 fs->super->s_journal_dev = 0; 246 uuid_clear(fs->super->s_journal_uuid); 247 ext2fs_mark_super_dirty(fs); 248 fputs(_("Journal removed\n"), stdout); 249 free(journal_path); 250} 251 252/* Helper function for remove_journal_inode */ 253static int release_blocks_proc(ext2_filsys fs, blk_t *blocknr, 254 int blockcnt EXT2FS_ATTR((unused)), 255 void *private EXT2FS_ATTR((unused))) 256{ 257 blk_t block; 258 int group; 259 260 block = *blocknr; 261 ext2fs_unmark_block_bitmap(fs->block_map, block); 262 group = ext2fs_group_of_blk(fs, block); 263 fs->group_desc[group].bg_free_blocks_count++; 264 ext2fs_group_desc_csum_set(fs, group); 265 fs->super->s_free_blocks_count++; 266 return 0; 267} 268 269/* 270 * Remove the journal inode from the filesystem 271 */ 272static void remove_journal_inode(ext2_filsys fs) 273{ 274 struct ext2_inode inode; 275 errcode_t retval; 276 ino_t ino = fs->super->s_journal_inum; 277 278 retval = ext2fs_read_inode(fs, ino, &inode); 279 if (retval) { 280 com_err(program_name, retval, 281 _("while reading journal inode")); 282 exit(1); 283 } 284 if (ino == EXT2_JOURNAL_INO) { 285 retval = ext2fs_read_bitmaps(fs); 286 if (retval) { 287 com_err(program_name, retval, 288 _("while reading bitmaps")); 289 exit(1); 290 } 291 retval = ext2fs_block_iterate(fs, ino, 292 BLOCK_FLAG_READ_ONLY, NULL, 293 release_blocks_proc, NULL); 294 if (retval) { 295 com_err(program_name, retval, 296 _("while clearing journal inode")); 297 exit(1); 298 } 299 memset(&inode, 0, sizeof(inode)); 300 ext2fs_mark_bb_dirty(fs); 301 fs->flags &= ~EXT2_FLAG_SUPER_ONLY; 302 } else 303 inode.i_flags &= ~EXT2_IMMUTABLE_FL; 304 retval = ext2fs_write_inode(fs, ino, &inode); 305 if (retval) { 306 com_err(program_name, retval, 307 _("while writing journal inode")); 308 exit(1); 309 } 310 fs->super->s_journal_inum = 0; 311 ext2fs_mark_super_dirty(fs); 312} 313 314/* 315 * Update the default mount options 316 */ 317static void update_mntopts(ext2_filsys fs, char *mntopts) 318{ 319 struct ext2_super_block *sb = fs->super; 320 321 if (e2p_edit_mntopts(mntopts, &sb->s_default_mount_opts, ~0)) { 322 fprintf(stderr, _("Invalid mount option set: %s\n"), 323 mntopts); 324 exit(1); 325 } 326 ext2fs_mark_super_dirty(fs); 327} 328 329/* 330 * Update the feature set as provided by the user. 331 */ 332static void update_feature_set(ext2_filsys fs, char *features) 333{ 334 struct ext2_super_block *sb = fs->super; 335 __u32 old_features[3]; 336 int type_err; 337 unsigned int mask_err; 338 339#define FEATURE_ON(type, mask) (!(old_features[(type)] & (mask)) && \ 340 ((&sb->s_feature_compat)[(type)] & (mask))) 341#define FEATURE_OFF(type, mask) ((old_features[(type)] & (mask)) && \ 342 !((&sb->s_feature_compat)[(type)] & (mask))) 343#define FEATURE_CHANGED(type, mask) ((mask) & \ 344 (old_features[(type)] ^ (&sb->s_feature_compat)[(type)])) 345 346 old_features[E2P_FEATURE_COMPAT] = sb->s_feature_compat; 347 old_features[E2P_FEATURE_INCOMPAT] = sb->s_feature_incompat; 348 old_features[E2P_FEATURE_RO_INCOMPAT] = sb->s_feature_ro_compat; 349 350 if (e2p_edit_feature2(features, &sb->s_feature_compat, 351 ok_features, clear_ok_features, 352 &type_err, &mask_err)) { 353 if (!mask_err) 354 fprintf(stderr, 355 _("Invalid filesystem option set: %s\n"), 356 features); 357 else if (type_err & E2P_FEATURE_NEGATE_FLAG) 358 fprintf(stderr, _("Clearing filesystem feature '%s' " 359 "not supported.\n"), 360 e2p_feature2string(type_err & 361 E2P_FEATURE_TYPE_MASK, 362 mask_err)); 363 else 364 fprintf(stderr, _("Setting filesystem feature '%s' " 365 "not supported.\n"), 366 e2p_feature2string(type_err, mask_err)); 367 exit(1); 368 } 369 370 if (FEATURE_OFF(E2P_FEATURE_COMPAT, EXT3_FEATURE_COMPAT_HAS_JOURNAL)) { 371 if ((mount_flags & EXT2_MF_MOUNTED) && 372 !(mount_flags & EXT2_MF_READONLY)) { 373 fputs(_("The has_journal feature may only be " 374 "cleared when the filesystem is\n" 375 "unmounted or mounted " 376 "read-only.\n"), stderr); 377 exit(1); 378 } 379 if (sb->s_feature_incompat & 380 EXT3_FEATURE_INCOMPAT_RECOVER) { 381 fputs(_("The needs_recovery flag is set. " 382 "Please run e2fsck before clearing\n" 383 "the has_journal flag.\n"), stderr); 384 exit(1); 385 } 386 if (sb->s_journal_inum) { 387 remove_journal_inode(fs); 388 } 389 if (sb->s_journal_dev) { 390 remove_journal_device(fs); 391 } 392 } 393 394 if (FEATURE_ON(E2P_FEATURE_COMPAT, EXT3_FEATURE_COMPAT_HAS_JOURNAL)) { 395 /* 396 * If adding a journal flag, let the create journal 397 * code below handle setting the flag and creating the 398 * journal. We supply a default size if necessary. 399 */ 400 if (!journal_size) 401 journal_size = -1; 402 sb->s_feature_compat &= ~EXT3_FEATURE_COMPAT_HAS_JOURNAL; 403 } 404 405 if (FEATURE_ON(E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_DIR_INDEX)) { 406 if (!sb->s_def_hash_version) 407 sb->s_def_hash_version = EXT2_HASH_HALF_MD4; 408 if (uuid_is_null((unsigned char *) sb->s_hash_seed)) 409 uuid_generate((unsigned char *) sb->s_hash_seed); 410 } 411 412 if (FEATURE_OFF(E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_FLEX_BG)) { 413 if (ext2fs_check_desc(fs)) { 414 fputs(_("Clearing the flex_bg flag would " 415 "cause the the filesystem to be\n" 416 "inconsistent.\n"), stderr); 417 exit(1); 418 } 419 } 420 421 if (FEATURE_OFF(E2P_FEATURE_RO_INCOMPAT, 422 EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) { 423 if ((mount_flags & EXT2_MF_MOUNTED) && 424 !(mount_flags & EXT2_MF_READONLY)) { 425 fputs(_("The huge_file feature may only be " 426 "cleared when the filesystem is\n" 427 "unmounted or mounted " 428 "read-only.\n"), stderr); 429 exit(1); 430 } 431 } 432 433 if (sb->s_rev_level == EXT2_GOOD_OLD_REV && 434 (sb->s_feature_compat || sb->s_feature_ro_compat || 435 sb->s_feature_incompat)) 436 ext2fs_update_dynamic_rev(fs); 437 438 if (FEATURE_CHANGED(E2P_FEATURE_RO_INCOMPAT, 439 EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER) || 440 FEATURE_CHANGED(E2P_FEATURE_RO_INCOMPAT, 441 EXT4_FEATURE_RO_COMPAT_GDT_CSUM) || 442 FEATURE_OFF(E2P_FEATURE_RO_INCOMPAT, 443 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) || 444 FEATURE_CHANGED(E2P_FEATURE_INCOMPAT, 445 EXT2_FEATURE_INCOMPAT_FILETYPE) || 446 FEATURE_CHANGED(E2P_FEATURE_COMPAT, 447 EXT2_FEATURE_COMPAT_RESIZE_INODE) || 448 FEATURE_OFF(E2P_FEATURE_RO_INCOMPAT, 449 EXT2_FEATURE_RO_COMPAT_LARGE_FILE)) { 450 sb->s_state &= ~EXT2_VALID_FS; 451 printf("\n%s\n", _(please_fsck)); 452 if (mount_flags & EXT2_MF_READONLY) 453 printf(_("(and reboot afterwards!)\n")); 454 } 455 456 if ((old_features[E2P_FEATURE_COMPAT] != sb->s_feature_compat) || 457 (old_features[E2P_FEATURE_INCOMPAT] != sb->s_feature_incompat) || 458 (old_features[E2P_FEATURE_RO_INCOMPAT] != sb->s_feature_ro_compat)) 459 ext2fs_mark_super_dirty(fs); 460} 461 462/* 463 * Add a journal to the filesystem. 464 */ 465static void add_journal(ext2_filsys fs) 466{ 467 unsigned long journal_blocks; 468 errcode_t retval; 469 ext2_filsys jfs; 470 io_manager io_ptr; 471 472 if (fs->super->s_feature_compat & 473 EXT3_FEATURE_COMPAT_HAS_JOURNAL) { 474 fputs(_("The filesystem already has a journal.\n"), stderr); 475 goto err; 476 } 477 if (journal_device) { 478 check_plausibility(journal_device); 479 check_mount(journal_device, 0, _("journal")); 480#ifdef CONFIG_TESTIO_DEBUG 481 if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) { 482 io_ptr = test_io_manager; 483 test_io_backing_manager = unix_io_manager; 484 } else 485#endif 486 io_ptr = unix_io_manager; 487 retval = ext2fs_open(journal_device, EXT2_FLAG_RW| 488 EXT2_FLAG_JOURNAL_DEV_OK, 0, 489 fs->blocksize, io_ptr, &jfs); 490 if (retval) { 491 com_err(program_name, retval, 492 _("\n\twhile trying to open journal on %s\n"), 493 journal_device); 494 goto err; 495 } 496 printf(_("Creating journal on device %s: "), 497 journal_device); 498 fflush(stdout); 499 500 retval = ext2fs_add_journal_device(fs, jfs); 501 ext2fs_close(jfs); 502 if (retval) { 503 com_err(program_name, retval, 504 _("while adding filesystem to journal on %s"), 505 journal_device); 506 goto err; 507 } 508 fputs(_("done\n"), stdout); 509 } else if (journal_size) { 510 fputs(_("Creating journal inode: "), stdout); 511 fflush(stdout); 512 journal_blocks = figure_journal_size(journal_size, fs); 513 514 retval = ext2fs_add_journal_inode(fs, journal_blocks, 515 journal_flags); 516 if (retval) { 517 fprintf(stderr, "\n"); 518 com_err(program_name, retval, 519 _("\n\twhile trying to create journal file")); 520 exit(1); 521 } else 522 fputs(_("done\n"), stdout); 523 /* 524 * If the filesystem wasn't mounted, we need to force 525 * the block group descriptors out. 526 */ 527 if ((mount_flags & EXT2_MF_MOUNTED) == 0) 528 fs->flags &= ~EXT2_FLAG_SUPER_ONLY; 529 } 530 print_check_message(fs); 531 return; 532 533err: 534 free(journal_device); 535 exit(1); 536} 537 538 539static void parse_e2label_options(int argc, char ** argv) 540{ 541 if ((argc < 2) || (argc > 3)) { 542 fputs(_("Usage: e2label device [newlabel]\n"), stderr); 543 exit(1); 544 } 545 io_options = strchr(argv[1], '?'); 546 if (io_options) 547 *io_options++ = 0; 548 device_name = blkid_get_devname(NULL, argv[1], NULL); 549 if (!device_name) { 550 com_err("e2label", 0, _("Unable to resolve '%s'"), 551 argv[1]); 552 exit(1); 553 } 554 open_flag = EXT2_FLAG_JOURNAL_DEV_OK; 555 if (argc == 3) { 556 open_flag |= EXT2_FLAG_RW; 557 L_flag = 1; 558 new_label = argv[2]; 559 } else 560 print_label++; 561} 562 563static time_t parse_time(char *str) 564{ 565 struct tm ts; 566 567 if (strcmp(str, "now") == 0) { 568 return (time(0)); 569 } 570 memset(&ts, 0, sizeof(ts)); 571#ifdef HAVE_STRPTIME 572 strptime(str, "%Y%m%d%H%M%S", &ts); 573#else 574 sscanf(str, "%4d%2d%2d%2d%2d%2d", &ts.tm_year, &ts.tm_mon, 575 &ts.tm_mday, &ts.tm_hour, &ts.tm_min, &ts.tm_sec); 576 ts.tm_year -= 1900; 577 ts.tm_mon -= 1; 578 if (ts.tm_year < 0 || ts.tm_mon < 0 || ts.tm_mon > 11 || 579 ts.tm_mday < 0 || ts.tm_mday > 31 || ts.tm_hour > 23 || 580 ts.tm_min > 59 || ts.tm_sec > 61) 581 ts.tm_mday = 0; 582#endif 583 if (ts.tm_mday == 0) { 584 com_err(program_name, 0, 585 _("Couldn't parse date/time specifier: %s"), 586 str); 587 usage(); 588 } 589 ts.tm_isdst = -1; 590 return (mktime(&ts)); 591} 592 593static void parse_tune2fs_options(int argc, char **argv) 594{ 595 int c; 596 char *tmp; 597 struct group *gr; 598 struct passwd *pw; 599 600 open_flag = 0; 601 602 printf("tune2fs %s (%s)\n", E2FSPROGS_VERSION, E2FSPROGS_DATE); 603 while ((c = getopt(argc, argv, "c:e:fg:i:jlm:o:r:s:u:C:E:I:J:L:M:O:T:U:")) != EOF) 604 switch (c) { 605 case 'c': 606 max_mount_count = strtol(optarg, &tmp, 0); 607 if (*tmp || max_mount_count > 16000) { 608 com_err(program_name, 0, 609 _("bad mounts count - %s"), 610 optarg); 611 usage(); 612 } 613 if (max_mount_count == 0) 614 max_mount_count = -1; 615 c_flag = 1; 616 open_flag = EXT2_FLAG_RW; 617 break; 618 case 'C': 619 mount_count = strtoul(optarg, &tmp, 0); 620 if (*tmp || mount_count > 16000) { 621 com_err(program_name, 0, 622 _("bad mounts count - %s"), 623 optarg); 624 usage(); 625 } 626 C_flag = 1; 627 open_flag = EXT2_FLAG_RW; 628 break; 629 case 'e': 630 if (strcmp(optarg, "continue") == 0) 631 errors = EXT2_ERRORS_CONTINUE; 632 else if (strcmp(optarg, "remount-ro") == 0) 633 errors = EXT2_ERRORS_RO; 634 else if (strcmp(optarg, "panic") == 0) 635 errors = EXT2_ERRORS_PANIC; 636 else { 637 com_err(program_name, 0, 638 _("bad error behavior - %s"), 639 optarg); 640 usage(); 641 } 642 e_flag = 1; 643 open_flag = EXT2_FLAG_RW; 644 break; 645 case 'E': 646 extended_cmd = optarg; 647 open_flag |= EXT2_FLAG_RW; 648 break; 649 case 'f': /* Force */ 650 f_flag = 1; 651 break; 652 case 'g': 653 resgid = strtoul(optarg, &tmp, 0); 654 if (*tmp) { 655 gr = getgrnam(optarg); 656 if (gr == NULL) 657 tmp = optarg; 658 else { 659 resgid = gr->gr_gid; 660 *tmp = 0; 661 } 662 } 663 if (*tmp) { 664 com_err(program_name, 0, 665 _("bad gid/group name - %s"), 666 optarg); 667 usage(); 668 } 669 g_flag = 1; 670 open_flag = EXT2_FLAG_RW; 671 break; 672 case 'i': 673 interval = strtoul(optarg, &tmp, 0); 674 switch (*tmp) { 675 case 's': 676 tmp++; 677 break; 678 case '\0': 679 case 'd': 680 case 'D': /* days */ 681 interval *= 86400; 682 if (*tmp != '\0') 683 tmp++; 684 break; 685 case 'm': 686 case 'M': /* months! */ 687 interval *= 86400 * 30; 688 tmp++; 689 break; 690 case 'w': 691 case 'W': /* weeks */ 692 interval *= 86400 * 7; 693 tmp++; 694 break; 695 } 696 if (*tmp) { 697 com_err(program_name, 0, 698 _("bad interval - %s"), optarg); 699 usage(); 700 } 701 i_flag = 1; 702 open_flag = EXT2_FLAG_RW; 703 break; 704 case 'j': 705 if (!journal_size) 706 journal_size = -1; 707 open_flag = EXT2_FLAG_RW; 708 break; 709 case 'J': 710 parse_journal_opts(optarg); 711 open_flag = EXT2_FLAG_RW; 712 break; 713 case 'l': 714 l_flag = 1; 715 break; 716 case 'L': 717 new_label = optarg; 718 L_flag = 1; 719 open_flag |= EXT2_FLAG_RW | 720 EXT2_FLAG_JOURNAL_DEV_OK; 721 break; 722 case 'm': 723 reserved_ratio = strtod(optarg, &tmp); 724 if (*tmp || reserved_ratio > 50 || 725 reserved_ratio < 0) { 726 com_err(program_name, 0, 727 _("bad reserved block ratio - %s"), 728 optarg); 729 usage(); 730 } 731 m_flag = 1; 732 open_flag = EXT2_FLAG_RW; 733 break; 734 case 'M': 735 new_last_mounted = optarg; 736 M_flag = 1; 737 open_flag = EXT2_FLAG_RW; 738 break; 739 case 'o': 740 if (mntopts_cmd) { 741 com_err(program_name, 0, 742 _("-o may only be specified once")); 743 usage(); 744 } 745 mntopts_cmd = optarg; 746 open_flag = EXT2_FLAG_RW; 747 break; 748 749 case 'O': 750 if (features_cmd) { 751 com_err(program_name, 0, 752 _("-O may only be specified once")); 753 usage(); 754 } 755 features_cmd = optarg; 756 open_flag = EXT2_FLAG_RW; 757 break; 758 case 'r': 759 reserved_blocks = strtoul(optarg, &tmp, 0); 760 if (*tmp) { 761 com_err(program_name, 0, 762 _("bad reserved blocks count - %s"), 763 optarg); 764 usage(); 765 } 766 r_flag = 1; 767 open_flag = EXT2_FLAG_RW; 768 break; 769 case 's': /* Deprecated */ 770 s_flag = atoi(optarg); 771 open_flag = EXT2_FLAG_RW; 772 break; 773 case 'T': 774 T_flag = 1; 775 last_check_time = parse_time(optarg); 776 open_flag = EXT2_FLAG_RW; 777 break; 778 case 'u': 779 resuid = strtoul(optarg, &tmp, 0); 780 if (*tmp) { 781 pw = getpwnam(optarg); 782 if (pw == NULL) 783 tmp = optarg; 784 else { 785 resuid = pw->pw_uid; 786 *tmp = 0; 787 } 788 } 789 if (*tmp) { 790 com_err(program_name, 0, 791 _("bad uid/user name - %s"), 792 optarg); 793 usage(); 794 } 795 u_flag = 1; 796 open_flag = EXT2_FLAG_RW; 797 break; 798 case 'U': 799 new_UUID = optarg; 800 U_flag = 1; 801 open_flag = EXT2_FLAG_RW | 802 EXT2_FLAG_JOURNAL_DEV_OK; 803 break; 804 case 'I': 805 new_inode_size = strtoul(optarg, &tmp, 0); 806 if (*tmp) { 807 com_err(program_name, 0, 808 _("bad inode size - %s"), 809 optarg); 810 usage(); 811 } 812 if (!((new_inode_size & 813 (new_inode_size - 1)) == 0)) { 814 com_err(program_name, 0, 815 _("Inode size must be a " 816 "power of two- %s"), 817 optarg); 818 usage(); 819 } 820 open_flag = EXT2_FLAG_RW; 821 I_flag = 1; 822 break; 823 default: 824 usage(); 825 } 826 if (optind < argc - 1 || optind == argc) 827 usage(); 828 if (!open_flag && !l_flag) 829 usage(); 830 io_options = strchr(argv[optind], '?'); 831 if (io_options) 832 *io_options++ = 0; 833 device_name = blkid_get_devname(NULL, argv[optind], NULL); 834 if (!device_name) { 835 com_err("tune2fs", 0, _("Unable to resolve '%s'"), 836 argv[optind]); 837 exit(1); 838 } 839} 840 841#ifdef CONFIG_BUILD_FINDFS 842void do_findfs(int argc, char **argv) 843{ 844 char *dev; 845 846 if ((argc != 2) || 847 (strncmp(argv[1], "LABEL=", 6) && strncmp(argv[1], "UUID=", 5))) { 848 fprintf(stderr, "Usage: findfs LABEL=<label>|UUID=<uuid>\n"); 849 exit(2); 850 } 851 dev = blkid_get_devname(NULL, argv[1], NULL); 852 if (!dev) { 853 com_err("findfs", 0, _("Unable to resolve '%s'"), 854 argv[1]); 855 exit(1); 856 } 857 puts(dev); 858 exit(0); 859} 860#endif 861 862static void parse_extended_opts(ext2_filsys fs, const char *opts) 863{ 864 char *buf, *token, *next, *p, *arg; 865 int len, hash_alg; 866 int r_usage = 0; 867 868 len = strlen(opts); 869 buf = malloc(len+1); 870 if (!buf) { 871 fprintf(stderr, 872 _("Couldn't allocate memory to parse options!\n")); 873 exit(1); 874 } 875 strcpy(buf, opts); 876 for (token = buf; token && *token; token = next) { 877 p = strchr(token, ','); 878 next = 0; 879 if (p) { 880 *p = 0; 881 next = p+1; 882 } 883 arg = strchr(token, '='); 884 if (arg) { 885 *arg = 0; 886 arg++; 887 } 888 if (!strcmp(token, "test_fs")) { 889 fs->super->s_flags |= EXT2_FLAGS_TEST_FILESYS; 890 printf("Setting test filesystem flag\n"); 891 ext2fs_mark_super_dirty(fs); 892 } else if (!strcmp(token, "^test_fs")) { 893 fs->super->s_flags &= ~EXT2_FLAGS_TEST_FILESYS; 894 printf("Clearing test filesystem flag\n"); 895 ext2fs_mark_super_dirty(fs); 896 } else if (strcmp(token, "stride") == 0) { 897 if (!arg) { 898 r_usage++; 899 continue; 900 } 901 stride = strtoul(arg, &p, 0); 902 if (*p || (stride == 0)) { 903 fprintf(stderr, 904 _("Invalid RAID stride: %s\n"), 905 arg); 906 r_usage++; 907 continue; 908 } 909 stride_set = 1; 910 } else if (strcmp(token, "stripe-width") == 0 || 911 strcmp(token, "stripe_width") == 0) { 912 if (!arg) { 913 r_usage++; 914 continue; 915 } 916 stripe_width = strtoul(arg, &p, 0); 917 if (*p || (stripe_width == 0)) { 918 fprintf(stderr, 919 _("Invalid RAID stripe-width: %s\n"), 920 arg); 921 r_usage++; 922 continue; 923 } 924 stripe_width_set = 1; 925 } else if (strcmp(token, "hash_alg") == 0 || 926 strcmp(token, "hash-alg") == 0) { 927 if (!arg) { 928 r_usage++; 929 continue; 930 } 931 hash_alg = e2p_string2hash(arg); 932 if (hash_alg < 0) { 933 fprintf(stderr, 934 _("Invalid hash algorithm: %s\n"), 935 arg); 936 r_usage++; 937 continue; 938 } 939 fs->super->s_def_hash_version = hash_alg; 940 printf(_("Setting default hash algorithm " 941 "to %s (%d)\n"), 942 arg, hash_alg); 943 ext2fs_mark_super_dirty(fs); 944 } else 945 r_usage++; 946 } 947 if (r_usage) { 948 fprintf(stderr, _("\nBad options specified.\n\n" 949 "Extended options are separated by commas, " 950 "and may take an argument which\n" 951 "\tis set off by an equals ('=') sign.\n\n" 952 "Valid extended options are:\n" 953 "\tstride=<RAID per-disk chunk size in blocks>\n" 954 "\tstripe_width=<RAID stride*data disks in blocks>\n" 955 "\thash_alg=<hash algorithm>\n" 956 "\ttest_fs\n" 957 "\t^test_fs\n")); 958 free(buf); 959 exit(1); 960 } 961 free(buf); 962} 963 964/* 965 * Fill in the block bitmap bmap with the information regarding the 966 * blocks to be moved 967 */ 968static int get_move_bitmaps(ext2_filsys fs, int new_ino_blks_per_grp, 969 ext2fs_block_bitmap bmap) 970{ 971 dgrp_t i; 972 int retval; 973 ext2_badblocks_list bb_list = 0; 974 blk_t j, needed_blocks = 0; 975 blk_t start_blk, end_blk; 976 977 retval = ext2fs_read_bb_inode(fs, &bb_list); 978 if (retval) 979 return retval; 980 981 for (i = 0; i < fs->group_desc_count; i++) { 982 start_blk = fs->group_desc[i].bg_inode_table + 983 fs->inode_blocks_per_group; 984 985 end_blk = fs->group_desc[i].bg_inode_table + 986 new_ino_blks_per_grp; 987 988 for (j = start_blk; j < end_blk; j++) { 989 if (ext2fs_test_block_bitmap(fs->block_map, j)) { 990 /* 991 * IF the block is a bad block we fail 992 */ 993 if (ext2fs_badblocks_list_test(bb_list, j)) { 994 ext2fs_badblocks_list_free(bb_list); 995 return ENOSPC; 996 } 997 998 ext2fs_mark_block_bitmap(bmap, j); 999 } else { 1000 /* 1001 * We are going to use this block for 1002 * inode table. So mark them used. 1003 */ 1004 ext2fs_mark_block_bitmap(fs->block_map, j); 1005 } 1006 } 1007 needed_blocks += end_blk - start_blk; 1008 } 1009 1010 ext2fs_badblocks_list_free(bb_list); 1011 if (needed_blocks > fs->super->s_free_blocks_count) 1012 return ENOSPC; 1013 1014 return 0; 1015} 1016 1017static int ext2fs_is_meta_block(ext2_filsys fs, blk_t blk) 1018{ 1019 dgrp_t group; 1020 group = ext2fs_group_of_blk(fs, blk); 1021 if (fs->group_desc[group].bg_block_bitmap == blk) 1022 return 1; 1023 if (fs->group_desc[group].bg_inode_bitmap == blk) 1024 return 1; 1025 return 0; 1026} 1027 1028static int ext2fs_is_block_in_group(ext2_filsys fs, dgrp_t group, blk_t blk) 1029{ 1030 blk_t start_blk, end_blk; 1031 start_blk = fs->super->s_first_data_block + 1032 EXT2_BLOCKS_PER_GROUP(fs->super) * group; 1033 /* 1034 * We cannot get new block beyond end_blk for for the last block group 1035 * so we can check with EXT2_BLOCKS_PER_GROUP even for last block group 1036 */ 1037 end_blk = start_blk + EXT2_BLOCKS_PER_GROUP(fs->super); 1038 if (blk >= start_blk && blk <= end_blk) 1039 return 1; 1040 return 0; 1041} 1042 1043static int move_block(ext2_filsys fs, ext2fs_block_bitmap bmap) 1044{ 1045 1046 char *buf; 1047 dgrp_t group; 1048 errcode_t retval; 1049 int meta_data = 0; 1050 blk_t blk, new_blk, goal; 1051 struct blk_move *bmv; 1052 1053 retval = ext2fs_get_mem(fs->blocksize, &buf); 1054 if (retval) 1055 return retval; 1056 1057 for (new_blk = blk = fs->super->s_first_data_block; 1058 blk < fs->super->s_blocks_count; blk++) { 1059 if (!ext2fs_test_block_bitmap(bmap, blk)) 1060 continue; 1061 1062 if (ext2fs_is_meta_block(fs, blk)) { 1063 /* 1064 * If the block is mapping a fs meta data block 1065 * like group desc/block bitmap/inode bitmap. We 1066 * should find a block in the same group and fix 1067 * the respective fs metadata pointers. Otherwise 1068 * fail 1069 */ 1070 group = ext2fs_group_of_blk(fs, blk); 1071 goal = ext2fs_group_first_block(fs, group); 1072 meta_data = 1; 1073 1074 } else { 1075 goal = new_blk; 1076 } 1077 retval = ext2fs_new_block(fs, goal, NULL, &new_blk); 1078 if (retval) 1079 goto err_out; 1080 1081 /* new fs meta data block should be in the same group */ 1082 if (meta_data && !ext2fs_is_block_in_group(fs, group, new_blk)) { 1083 retval = ENOSPC; 1084 goto err_out; 1085 } 1086 1087 /* Mark this block as allocated */ 1088 ext2fs_mark_block_bitmap(fs->block_map, new_blk); 1089 1090 /* Add it to block move list */ 1091 retval = ext2fs_get_mem(sizeof(struct blk_move), &bmv); 1092 if (retval) 1093 goto err_out; 1094 1095 bmv->old_loc = blk; 1096 bmv->new_loc = new_blk; 1097 1098 list_add(&(bmv->list), &blk_move_list); 1099 1100 retval = io_channel_read_blk(fs->io, blk, 1, buf); 1101 if (retval) 1102 goto err_out; 1103 1104 retval = io_channel_write_blk(fs->io, new_blk, 1, buf); 1105 if (retval) 1106 goto err_out; 1107 } 1108 1109err_out: 1110 ext2fs_free_mem(&buf); 1111 return retval; 1112} 1113 1114static blk_t translate_block(blk_t blk) 1115{ 1116 struct list_head *entry; 1117 struct blk_move *bmv; 1118 1119 list_for_each(entry, &blk_move_list) { 1120 bmv = list_entry(entry, struct blk_move, list); 1121 if (bmv->old_loc == blk) 1122 return bmv->new_loc; 1123 } 1124 1125 return 0; 1126} 1127 1128static int process_block(ext2_filsys fs EXT2FS_ATTR((unused)), 1129 blk_t *block_nr, 1130 e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)), 1131 blk_t ref_block EXT2FS_ATTR((unused)), 1132 int ref_offset EXT2FS_ATTR((unused)), 1133 void *priv_data) 1134{ 1135 int ret = 0; 1136 blk_t new_blk; 1137 ext2fs_block_bitmap bmap = (ext2fs_block_bitmap) priv_data; 1138 1139 if (!ext2fs_test_block_bitmap(bmap, *block_nr)) 1140 return 0; 1141 new_blk = translate_block(*block_nr); 1142 if (new_blk) { 1143 *block_nr = new_blk; 1144 /* 1145 * This will force the ext2fs_write_inode in the iterator 1146 */ 1147 ret |= BLOCK_CHANGED; 1148 } 1149 1150 return ret; 1151} 1152 1153static int inode_scan_and_fix(ext2_filsys fs, ext2fs_block_bitmap bmap) 1154{ 1155 errcode_t retval = 0; 1156 ext2_ino_t ino; 1157 blk_t blk; 1158 char *block_buf = 0; 1159 struct ext2_inode inode; 1160 ext2_inode_scan scan = NULL; 1161 1162 retval = ext2fs_get_mem(fs->blocksize * 3, &block_buf); 1163 if (retval) 1164 return retval; 1165 1166 retval = ext2fs_open_inode_scan(fs, 0, &scan); 1167 if (retval) 1168 goto err_out; 1169 1170 while (1) { 1171 retval = ext2fs_get_next_inode(scan, &ino, &inode); 1172 if (retval) 1173 goto err_out; 1174 1175 if (!ino) 1176 break; 1177 1178 if (inode.i_links_count == 0) 1179 continue; /* inode not in use */ 1180 1181 /* FIXME!! 1182 * If we end up modifying the journal inode 1183 * the sb->s_jnl_blocks will differ. But a 1184 * subsequent e2fsck fixes that. 1185 * Do we need to fix this ?? 1186 */ 1187 1188 if (inode.i_file_acl && 1189 ext2fs_test_block_bitmap(bmap, inode.i_file_acl)) { 1190 blk = translate_block(inode.i_file_acl); 1191 if (!blk) 1192 continue; 1193 1194 inode.i_file_acl = blk; 1195 1196 /* 1197 * Write the inode to disk so that inode table 1198 * resizing can work 1199 */ 1200 retval = ext2fs_write_inode(fs, ino, &inode); 1201 if (retval) 1202 goto err_out; 1203 } 1204 1205 if (!ext2fs_inode_has_valid_blocks(&inode)) 1206 continue; 1207 1208 retval = ext2fs_block_iterate2(fs, ino, 0, block_buf, 1209 process_block, bmap); 1210 if (retval) 1211 goto err_out; 1212 1213 } 1214 1215err_out: 1216 ext2fs_free_mem(&block_buf); 1217 1218 return retval; 1219} 1220 1221/* 1222 * We need to scan for inode and block bitmaps that may need to be 1223 * moved. This can take place if the filesystem was formatted for 1224 * RAID arrays using the mke2fs's extended option "stride". 1225 */ 1226static int group_desc_scan_and_fix(ext2_filsys fs, ext2fs_block_bitmap bmap) 1227{ 1228 dgrp_t i; 1229 blk_t blk, new_blk; 1230 1231 for (i = 0; i < fs->group_desc_count; i++) { 1232 blk = fs->group_desc[i].bg_block_bitmap; 1233 if (ext2fs_test_block_bitmap(bmap, blk)) { 1234 new_blk = translate_block(blk); 1235 if (!new_blk) 1236 continue; 1237 fs->group_desc[i].bg_block_bitmap = new_blk; 1238 } 1239 1240 blk = fs->group_desc[i].bg_inode_bitmap; 1241 if (ext2fs_test_block_bitmap(bmap, blk)) { 1242 new_blk = translate_block(blk); 1243 if (!new_blk) 1244 continue; 1245 fs->group_desc[i].bg_inode_bitmap = new_blk; 1246 } 1247 } 1248 return 0; 1249} 1250 1251static int expand_inode_table(ext2_filsys fs, unsigned long new_ino_size) 1252{ 1253 dgrp_t i; 1254 blk_t blk; 1255 errcode_t retval; 1256 int new_ino_blks_per_grp; 1257 unsigned int j; 1258 char *old_itable = NULL, *new_itable = NULL; 1259 char *tmp_old_itable = NULL, *tmp_new_itable = NULL; 1260 unsigned long old_ino_size; 1261 int old_itable_size, new_itable_size; 1262 1263 old_itable_size = fs->inode_blocks_per_group * fs->blocksize; 1264 old_ino_size = EXT2_INODE_SIZE(fs->super); 1265 1266 new_ino_blks_per_grp = ext2fs_div_ceil( 1267 EXT2_INODES_PER_GROUP(fs->super) * 1268 new_ino_size, 1269 fs->blocksize); 1270 1271 new_itable_size = new_ino_blks_per_grp * fs->blocksize; 1272 1273 retval = ext2fs_get_mem(old_itable_size, &old_itable); 1274 if (retval) 1275 return retval; 1276 1277 retval = ext2fs_get_mem(new_itable_size, &new_itable); 1278 if (retval) 1279 goto err_out; 1280 1281 tmp_old_itable = old_itable; 1282 tmp_new_itable = new_itable; 1283 1284 for (i = 0; i < fs->group_desc_count; i++) { 1285 blk = fs->group_desc[i].bg_inode_table; 1286 retval = io_channel_read_blk(fs->io, blk, 1287 fs->inode_blocks_per_group, old_itable); 1288 if (retval) 1289 goto err_out; 1290 1291 for (j = 0; j < EXT2_INODES_PER_GROUP(fs->super); j++) { 1292 memcpy(new_itable, old_itable, old_ino_size); 1293 1294 memset(new_itable+old_ino_size, 0, 1295 new_ino_size - old_ino_size); 1296 1297 new_itable += new_ino_size; 1298 old_itable += old_ino_size; 1299 } 1300 1301 /* reset the pointer */ 1302 old_itable = tmp_old_itable; 1303 new_itable = tmp_new_itable; 1304 1305 retval = io_channel_write_blk(fs->io, blk, 1306 new_ino_blks_per_grp, new_itable); 1307 if (retval) 1308 goto err_out; 1309 } 1310 1311 /* Update the meta data */ 1312 fs->inode_blocks_per_group = new_ino_blks_per_grp; 1313 fs->super->s_inode_size = new_ino_size; 1314 1315err_out: 1316 if (old_itable) 1317 ext2fs_free_mem(&old_itable); 1318 1319 if (new_itable) 1320 ext2fs_free_mem(&new_itable); 1321 1322 return retval; 1323} 1324 1325static errcode_t ext2fs_calculate_summary_stats(ext2_filsys fs) 1326{ 1327 blk_t blk; 1328 ext2_ino_t ino; 1329 unsigned int group = 0; 1330 unsigned int count = 0; 1331 int total_free = 0; 1332 int group_free = 0; 1333 1334 /* 1335 * First calculate the block statistics 1336 */ 1337 for (blk = fs->super->s_first_data_block; 1338 blk < fs->super->s_blocks_count; blk++) { 1339 if (!ext2fs_fast_test_block_bitmap(fs->block_map, blk)) { 1340 group_free++; 1341 total_free++; 1342 } 1343 count++; 1344 if ((count == fs->super->s_blocks_per_group) || 1345 (blk == fs->super->s_blocks_count-1)) { 1346 fs->group_desc[group++].bg_free_blocks_count = 1347 group_free; 1348 count = 0; 1349 group_free = 0; 1350 } 1351 } 1352 fs->super->s_free_blocks_count = total_free; 1353 1354 /* 1355 * Next, calculate the inode statistics 1356 */ 1357 group_free = 0; 1358 total_free = 0; 1359 count = 0; 1360 group = 0; 1361 1362 /* Protect loop from wrap-around if s_inodes_count maxed */ 1363 for (ino = 1; ino <= fs->super->s_inodes_count && ino > 0; ino++) { 1364 if (!ext2fs_fast_test_inode_bitmap(fs->inode_map, ino)) { 1365 group_free++; 1366 total_free++; 1367 } 1368 count++; 1369 if ((count == fs->super->s_inodes_per_group) || 1370 (ino == fs->super->s_inodes_count)) { 1371 fs->group_desc[group++].bg_free_inodes_count = 1372 group_free; 1373 count = 0; 1374 group_free = 0; 1375 } 1376 } 1377 fs->super->s_free_inodes_count = total_free; 1378 ext2fs_mark_super_dirty(fs); 1379 return 0; 1380} 1381 1382#define list_for_each_safe(pos, pnext, head) \ 1383 for (pos = (head)->next, pnext = pos->next; pos != (head); \ 1384 pos = pnext, pnext = pos->next) 1385 1386static void free_blk_move_list(void) 1387{ 1388 struct list_head *entry, *tmp; 1389 struct blk_move *bmv; 1390 1391 list_for_each_safe(entry, tmp, &blk_move_list) { 1392 bmv = list_entry(entry, struct blk_move, list); 1393 list_del(entry); 1394 ext2fs_free_mem(&bmv); 1395 } 1396 return; 1397} 1398 1399static int resize_inode(ext2_filsys fs, unsigned long new_size) 1400{ 1401 errcode_t retval; 1402 int new_ino_blks_per_grp; 1403 ext2fs_block_bitmap bmap; 1404 1405 ext2fs_read_inode_bitmap(fs); 1406 ext2fs_read_block_bitmap(fs); 1407 INIT_LIST_HEAD(&blk_move_list); 1408 1409 1410 new_ino_blks_per_grp = ext2fs_div_ceil( 1411 EXT2_INODES_PER_GROUP(fs->super)* 1412 new_size, 1413 fs->blocksize); 1414 1415 /* We may change the file system. 1416 * Mark the file system as invalid so that 1417 * the user is prompted to run fsck. 1418 */ 1419 fs->super->s_state &= ~EXT2_VALID_FS; 1420 1421 retval = ext2fs_allocate_block_bitmap(fs, _("blocks to be moved"), 1422 &bmap); 1423 if (retval) { 1424 fputs(_("Failed to allocate block bitmap when " 1425 "increasing inode size\n"), stderr); 1426 return retval; 1427 } 1428 retval = get_move_bitmaps(fs, new_ino_blks_per_grp, bmap); 1429 if (retval) { 1430 fputs(_("Not enough space to increase inode size \n"), stderr); 1431 goto err_out; 1432 } 1433 retval = move_block(fs, bmap); 1434 if (retval) { 1435 fputs(_("Failed to relocate blocks during inode resize \n"), 1436 stderr); 1437 goto err_out; 1438 } 1439 retval = inode_scan_and_fix(fs, bmap); 1440 if (retval) 1441 goto err_out_undo; 1442 1443 retval = group_desc_scan_and_fix(fs, bmap); 1444 if (retval) 1445 goto err_out_undo; 1446 1447 retval = expand_inode_table(fs, new_size); 1448 if (retval) 1449 goto err_out_undo; 1450 1451 ext2fs_calculate_summary_stats(fs); 1452 1453 fs->super->s_state |= EXT2_VALID_FS; 1454 /* mark super block and block bitmap as dirty */ 1455 ext2fs_mark_super_dirty(fs); 1456 ext2fs_mark_bb_dirty(fs); 1457 1458err_out: 1459 free_blk_move_list(); 1460 ext2fs_free_block_bitmap(bmap); 1461 1462 return retval; 1463 1464err_out_undo: 1465 free_blk_move_list(); 1466 ext2fs_free_block_bitmap(bmap); 1467 fputs(_("Error in resizing the inode size.\n" 1468 "Run e2undo to undo the " 1469 "file system changes. \n"), stderr); 1470 1471 return retval; 1472} 1473 1474static int tune2fs_setup_tdb(const char *name, io_manager *io_ptr) 1475{ 1476 errcode_t retval = 0; 1477 const char *tdb_dir; 1478 char *tdb_file; 1479 char *dev_name, *tmp_name; 1480 1481#if 0 /* FIXME!! */ 1482 /* 1483 * Configuration via a conf file would be 1484 * nice 1485 */ 1486 profile_get_string(profile, "scratch_files", 1487 "directory", 0, 0, 1488 &tdb_dir); 1489#endif 1490 tmp_name = strdup(name); 1491 if (!tmp_name) { 1492 alloc_fn_fail: 1493 com_err(program_name, ENOMEM, 1494 _("Couldn't allocate memory for tdb filename\n")); 1495 return ENOMEM; 1496 } 1497 dev_name = basename(tmp_name); 1498 1499 tdb_dir = getenv("E2FSPROGS_UNDO_DIR"); 1500 if (!tdb_dir) 1501 tdb_dir = "/var/lib/e2fsprogs"; 1502 1503 if (!strcmp(tdb_dir, "none") || (tdb_dir[0] == 0) || 1504 access(tdb_dir, W_OK)) 1505 return 0; 1506 1507 tdb_file = malloc(strlen(tdb_dir) + 9 + strlen(dev_name) + 7 + 1); 1508 if (!tdb_file) 1509 goto alloc_fn_fail; 1510 sprintf(tdb_file, "%s/tune2fs-%s.e2undo", tdb_dir, dev_name); 1511 1512 if (!access(tdb_file, F_OK)) { 1513 if (unlink(tdb_file) < 0) { 1514 retval = errno; 1515 com_err(program_name, retval, 1516 _("while trying to delete %s"), 1517 tdb_file); 1518 free(tdb_file); 1519 return retval; 1520 } 1521 } 1522 1523 set_undo_io_backing_manager(*io_ptr); 1524 *io_ptr = undo_io_manager; 1525 set_undo_io_backup_file(tdb_file); 1526 printf(_("To undo the tune2fs operation please run " 1527 "the command\n e2undo %s %s\n\n"), 1528 tdb_file, name); 1529 free(tdb_file); 1530 free(tmp_name); 1531 return retval; 1532} 1533 1534int main(int argc, char **argv) 1535{ 1536 errcode_t retval; 1537 ext2_filsys fs; 1538 struct ext2_super_block *sb; 1539 io_manager io_ptr, io_ptr_orig = NULL; 1540 1541#ifdef ENABLE_NLS 1542 setlocale(LC_MESSAGES, ""); 1543 setlocale(LC_CTYPE, ""); 1544 bindtextdomain(NLS_CAT_NAME, LOCALEDIR); 1545 textdomain(NLS_CAT_NAME); 1546#endif 1547 if (argc && *argv) 1548 program_name = *argv; 1549 add_error_table(&et_ext2_error_table); 1550 1551#ifdef CONFIG_BUILD_FINDFS 1552 if (strcmp(get_progname(argv[0]), "findfs") == 0) 1553 do_findfs(argc, argv); 1554#endif 1555 if (strcmp(get_progname(argv[0]), "e2label") == 0) 1556 parse_e2label_options(argc, argv); 1557 else 1558 parse_tune2fs_options(argc, argv); 1559 1560#ifdef CONFIG_TESTIO_DEBUG 1561 if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_DEBUG")) { 1562 io_ptr = test_io_manager; 1563 test_io_backing_manager = unix_io_manager; 1564 } else 1565#endif 1566 io_ptr = unix_io_manager; 1567 1568retry_open: 1569 retval = ext2fs_open2(device_name, io_options, open_flag, 1570 0, 0, io_ptr, &fs); 1571 if (retval) { 1572 com_err(program_name, retval, 1573 _("while trying to open %s"), 1574 device_name); 1575 fprintf(stderr, 1576 _("Couldn't find valid filesystem superblock.\n")); 1577 exit(1); 1578 } 1579 1580 if (I_flag && !io_ptr_orig) { 1581 /* 1582 * Check the inode size is right so we can issue an 1583 * error message and bail before setting up the tdb 1584 * file. 1585 */ 1586 if (new_inode_size == EXT2_INODE_SIZE(fs->super)) { 1587 fprintf(stderr, _("The inode size is already %lu\n"), 1588 new_inode_size); 1589 exit(1); 1590 } 1591 if (new_inode_size < EXT2_INODE_SIZE(fs->super)) { 1592 fprintf(stderr, _("Shrinking the inode size is " 1593 "not supported\n")); 1594 exit(1); 1595 } 1596 1597 /* 1598 * If inode resize is requested use the 1599 * Undo I/O manager 1600 */ 1601 io_ptr_orig = io_ptr; 1602 retval = tune2fs_setup_tdb(device_name, &io_ptr); 1603 if (retval) 1604 exit(1); 1605 if (io_ptr != io_ptr_orig) { 1606 ext2fs_close(fs); 1607 goto retry_open; 1608 } 1609 } 1610 1611 sb = fs->super; 1612 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; 1613 1614 if (print_label) { 1615 /* For e2label emulation */ 1616 printf("%.*s\n", (int) sizeof(sb->s_volume_name), 1617 sb->s_volume_name); 1618 remove_error_table(&et_ext2_error_table); 1619 exit(0); 1620 } 1621 1622 retval = ext2fs_check_if_mounted(device_name, &mount_flags); 1623 if (retval) { 1624 com_err("ext2fs_check_if_mount", retval, 1625 _("while determining whether %s is mounted."), 1626 device_name); 1627 exit(1); 1628 } 1629 /* Normally we only need to write out the superblock */ 1630 fs->flags |= EXT2_FLAG_SUPER_ONLY; 1631 1632 if (c_flag) { 1633 sb->s_max_mnt_count = max_mount_count; 1634 ext2fs_mark_super_dirty(fs); 1635 printf(_("Setting maximal mount count to %d\n"), 1636 max_mount_count); 1637 } 1638 if (C_flag) { 1639 sb->s_mnt_count = mount_count; 1640 ext2fs_mark_super_dirty(fs); 1641 printf(_("Setting current mount count to %d\n"), mount_count); 1642 } 1643 if (e_flag) { 1644 sb->s_errors = errors; 1645 ext2fs_mark_super_dirty(fs); 1646 printf(_("Setting error behavior to %d\n"), errors); 1647 } 1648 if (g_flag) { 1649 sb->s_def_resgid = resgid; 1650 ext2fs_mark_super_dirty(fs); 1651 printf(_("Setting reserved blocks gid to %lu\n"), resgid); 1652 } 1653 if (i_flag) { 1654 sb->s_checkinterval = interval; 1655 ext2fs_mark_super_dirty(fs); 1656 printf(_("Setting interval between checks to %lu seconds\n"), 1657 interval); 1658 } 1659 if (m_flag) { 1660 sb->s_r_blocks_count = (unsigned int) (reserved_ratio * 1661 sb->s_blocks_count / 100.0); 1662 ext2fs_mark_super_dirty(fs); 1663 printf(_("Setting reserved blocks percentage to %g%% " 1664 "(%u blocks)\n"), 1665 reserved_ratio, sb->s_r_blocks_count); 1666 } 1667 if (r_flag) { 1668 if (reserved_blocks >= sb->s_blocks_count/2) { 1669 com_err(program_name, 0, 1670 _("reserved blocks count is too big (%lu)"), 1671 reserved_blocks); 1672 exit(1); 1673 } 1674 sb->s_r_blocks_count = reserved_blocks; 1675 ext2fs_mark_super_dirty(fs); 1676 printf(_("Setting reserved blocks count to %lu\n"), 1677 reserved_blocks); 1678 } 1679 if (s_flag == 1) { 1680 if (sb->s_feature_ro_compat & 1681 EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER) 1682 fputs(_("\nThe filesystem already has sparse " 1683 "superblocks.\n"), stderr); 1684 else { 1685 sb->s_feature_ro_compat |= 1686 EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER; 1687 sb->s_state &= ~EXT2_VALID_FS; 1688 ext2fs_mark_super_dirty(fs); 1689 printf(_("\nSparse superblock flag set. %s"), 1690 _(please_fsck)); 1691 } 1692 } 1693 if (s_flag == 0) { 1694 fputs(_("\nClearing the sparse superflag not supported.\n"), 1695 stderr); 1696 exit(1); 1697 } 1698 if (T_flag) { 1699 sb->s_lastcheck = last_check_time; 1700 ext2fs_mark_super_dirty(fs); 1701 printf(_("Setting time filesystem last checked to %s\n"), 1702 ctime(&last_check_time)); 1703 } 1704 if (u_flag) { 1705 sb->s_def_resuid = resuid; 1706 ext2fs_mark_super_dirty(fs); 1707 printf(_("Setting reserved blocks uid to %lu\n"), resuid); 1708 } 1709 if (L_flag) { 1710 if (strlen(new_label) > sizeof(sb->s_volume_name)) 1711 fputs(_("Warning: label too long, truncating.\n"), 1712 stderr); 1713 memset(sb->s_volume_name, 0, sizeof(sb->s_volume_name)); 1714 strncpy(sb->s_volume_name, new_label, 1715 sizeof(sb->s_volume_name)); 1716 ext2fs_mark_super_dirty(fs); 1717 } 1718 if (M_flag) { 1719 memset(sb->s_last_mounted, 0, sizeof(sb->s_last_mounted)); 1720 strncpy(sb->s_last_mounted, new_last_mounted, 1721 sizeof(sb->s_last_mounted)); 1722 ext2fs_mark_super_dirty(fs); 1723 } 1724 if (mntopts_cmd) 1725 update_mntopts(fs, mntopts_cmd); 1726 if (features_cmd) 1727 update_feature_set(fs, features_cmd); 1728 if (extended_cmd) 1729 parse_extended_opts(fs, extended_cmd); 1730 if (journal_size || journal_device) 1731 add_journal(fs); 1732 1733 if (U_flag) { 1734 int set_csum = 0; 1735 dgrp_t i; 1736 1737 if (sb->s_feature_ro_compat & 1738 EXT4_FEATURE_RO_COMPAT_GDT_CSUM) { 1739 /* 1740 * Determine if the block group checksums are 1741 * correct so we know whether or not to set 1742 * them later on. 1743 */ 1744 for (i = 0; i < fs->group_desc_count; i++) 1745 if (!ext2fs_group_desc_csum_verify(fs, i)) 1746 break; 1747 if (i >= fs->group_desc_count) 1748 set_csum = 1; 1749 } 1750 if ((strcasecmp(new_UUID, "null") == 0) || 1751 (strcasecmp(new_UUID, "clear") == 0)) { 1752 uuid_clear(sb->s_uuid); 1753 } else if (strcasecmp(new_UUID, "time") == 0) { 1754 uuid_generate_time(sb->s_uuid); 1755 } else if (strcasecmp(new_UUID, "random") == 0) { 1756 uuid_generate(sb->s_uuid); 1757 } else if (uuid_parse(new_UUID, sb->s_uuid)) { 1758 com_err(program_name, 0, _("Invalid UUID format\n")); 1759 exit(1); 1760 } 1761 if (set_csum) { 1762 for (i = 0; i < fs->group_desc_count; i++) 1763 ext2fs_group_desc_csum_set(fs, i); 1764 fs->flags &= ~EXT2_FLAG_SUPER_ONLY; 1765 } 1766 ext2fs_mark_super_dirty(fs); 1767 } 1768 if (I_flag) { 1769 if (mount_flags & EXT2_MF_MOUNTED) { 1770 fputs(_("The inode size may only be " 1771 "changed when the filesystem is " 1772 "unmounted.\n"), stderr); 1773 exit(1); 1774 } 1775 if (fs->super->s_feature_incompat & 1776 EXT4_FEATURE_INCOMPAT_FLEX_BG) { 1777 fputs(_("Changing the inode size not supported for " 1778 "filesystems with the flex_bg\n" 1779 "feature enabled.\n"), 1780 stderr); 1781 exit(1); 1782 } 1783 /* 1784 * We want to update group descriptor also 1785 * with the new free inode count 1786 */ 1787 fs->flags &= ~EXT2_FLAG_SUPER_ONLY; 1788 if (resize_inode(fs, new_inode_size) == 0) { 1789 printf(_("Setting inode size %lu\n"), 1790 new_inode_size); 1791 } 1792 } 1793 1794 if (l_flag) 1795 list_super(sb); 1796 if (stride_set) { 1797 sb->s_raid_stride = stride; 1798 ext2fs_mark_super_dirty(fs); 1799 printf(_("Setting stride size to %d\n"), stride); 1800 } 1801 if (stripe_width_set) { 1802 sb->s_raid_stripe_width = stripe_width; 1803 ext2fs_mark_super_dirty(fs); 1804 printf(_("Setting stripe width to %d\n"), stripe_width); 1805 } 1806 free(device_name); 1807 remove_error_table(&et_ext2_error_table); 1808 return (ext2fs_close(fs) ? 1 : 0); 1809} 1810