main.c revision f404167dda29a59d2be2882328aeb074b9899669
1/* 2 * main.c --- ext2 resizer main program 3 * 4 * Copyright (C) 1997, 1998 by Theodore Ts'o and 5 * PowerQuest, Inc. 6 * 7 * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 by Theodore Ts'o 8 * 9 * %Begin-Header% 10 * This file may be redistributed under the terms of the GNU Public 11 * License. 12 * %End-Header% 13 */ 14 15#define _LARGEFILE_SOURCE 16#define _LARGEFILE64_SOURCE 17 18#include "config.h" 19#ifdef HAVE_GETOPT_H 20#include <getopt.h> 21#else 22extern char *optarg; 23extern int optind; 24#endif 25#include <unistd.h> 26#ifdef HAVE_STDLIB_H 27#include <stdlib.h> 28#endif 29#include <sys/types.h> 30#include <sys/stat.h> 31#include <fcntl.h> 32 33#include "e2p/e2p.h" 34 35#include "resize2fs.h" 36 37#include "../version.h" 38 39char *program_name; 40static char *device_name, *io_options; 41 42static void usage (char *prog) 43{ 44 fprintf (stderr, _("Usage: %s [-d debug_flags] [-f] [-F] [-M] [-P] " 45 "[-p] device [new_size]\n\n"), prog); 46 47 exit (1); 48} 49 50static errcode_t resize_progress_func(ext2_resize_t rfs, int pass, 51 unsigned long cur, unsigned long max) 52{ 53 ext2_sim_progmeter progress; 54 const char *label; 55 errcode_t retval; 56 57 progress = (ext2_sim_progmeter) rfs->prog_data; 58 if (max == 0) 59 return 0; 60 if (cur == 0) { 61 if (progress) 62 ext2fs_progress_close(progress); 63 progress = 0; 64 switch (pass) { 65 case E2_RSZ_EXTEND_ITABLE_PASS: 66 label = _("Extending the inode table"); 67 break; 68 case E2_RSZ_BLOCK_RELOC_PASS: 69 label = _("Relocating blocks"); 70 break; 71 case E2_RSZ_INODE_SCAN_PASS: 72 label = _("Scanning inode table"); 73 break; 74 case E2_RSZ_INODE_REF_UPD_PASS: 75 label = _("Updating inode references"); 76 break; 77 case E2_RSZ_MOVE_ITABLE_PASS: 78 label = _("Moving inode table"); 79 break; 80 default: 81 label = _("Unknown pass?!?"); 82 break; 83 } 84 printf(_("Begin pass %d (max = %lu)\n"), pass, max); 85 retval = ext2fs_progress_init(&progress, label, 30, 86 40, max, 0); 87 if (retval) 88 progress = 0; 89 rfs->prog_data = (void *) progress; 90 } 91 if (progress) 92 ext2fs_progress_update(progress, cur); 93 if (cur >= max) { 94 if (progress) 95 ext2fs_progress_close(progress); 96 progress = 0; 97 rfs->prog_data = 0; 98 } 99 return 0; 100} 101 102static void determine_fs_stride(ext2_filsys fs) 103{ 104 unsigned int group; 105 unsigned long long sum; 106 unsigned int has_sb, prev_has_sb = 0, num; 107 int i_stride, b_stride; 108 109 if (fs->stride) 110 return; 111 num = 0; sum = 0; 112 for (group = 0; group < fs->group_desc_count; group++) { 113 has_sb = ext2fs_bg_has_super(fs, group); 114 if (group == 0 || has_sb != prev_has_sb) 115 goto next; 116 b_stride = ext2fs_block_bitmap_loc(fs, group) - 117 ext2fs_block_bitmap_loc(fs, group - 1) - 118 fs->super->s_blocks_per_group; 119 i_stride = ext2fs_inode_bitmap_loc(fs, group) - 120 ext2fs_inode_bitmap_loc(fs, group - 1) - 121 fs->super->s_blocks_per_group; 122 if (b_stride != i_stride || 123 b_stride < 0) 124 goto next; 125 126 /* printf("group %d has stride %d\n", group, b_stride); */ 127 sum += b_stride; 128 num++; 129 130 next: 131 prev_has_sb = has_sb; 132 } 133 134 if (fs->group_desc_count > 12 && num < 3) 135 sum = 0; 136 137 if (num) 138 fs->stride = sum / num; 139 else 140 fs->stride = 0; 141 142 fs->super->s_raid_stride = fs->stride; 143 ext2fs_mark_super_dirty(fs); 144 145#if 0 146 if (fs->stride) 147 printf("Using RAID stride of %d\n", fs->stride); 148#endif 149} 150 151static void bigalloc_check(ext2_filsys fs, int force) 152{ 153 if (!force && EXT2_HAS_RO_COMPAT_FEATURE(fs->super, 154 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) { 155 fprintf(stderr, "%s", _("\nResizing bigalloc file systems has " 156 "not been fully tested. Proceed at\n" 157 "your own risk! Use the force option " 158 "if you want to go ahead anyway.\n\n")); 159 exit(1); 160 } 161} 162 163int main (int argc, char ** argv) 164{ 165 errcode_t retval; 166 ext2_filsys fs; 167 int c; 168 int flags = 0; 169 int flush = 0; 170 int force = 0; 171 int io_flags = 0; 172 int force_min_size = 0; 173 int print_min_size = 0; 174 int fd, ret; 175 blk64_t new_size = 0; 176 blk64_t max_size = 0; 177 blk64_t min_size = 0; 178 io_manager io_ptr; 179 char *new_size_str = 0; 180 int use_stride = -1; 181 ext2fs_struct_stat st_buf; 182 __s64 new_file_size; 183 unsigned int sys_page_size = 4096; 184 long sysval; 185 int len, mount_flags; 186 char *mtpt; 187 188#ifdef ENABLE_NLS 189 setlocale(LC_MESSAGES, ""); 190 setlocale(LC_CTYPE, ""); 191 bindtextdomain(NLS_CAT_NAME, LOCALEDIR); 192 textdomain(NLS_CAT_NAME); 193 set_com_err_gettext(gettext); 194#endif 195 196 add_error_table(&et_ext2_error_table); 197 198 fprintf (stderr, "resize2fs %s (%s)\n", 199 E2FSPROGS_VERSION, E2FSPROGS_DATE); 200 if (argc && *argv) 201 program_name = *argv; 202 203 while ((c = getopt (argc, argv, "d:fFhMPpS:")) != EOF) { 204 switch (c) { 205 case 'h': 206 usage(program_name); 207 break; 208 case 'f': 209 force = 1; 210 break; 211 case 'F': 212 flush = 1; 213 break; 214 case 'M': 215 force_min_size = 1; 216 break; 217 case 'P': 218 print_min_size = 1; 219 break; 220 case 'd': 221 flags |= atoi(optarg); 222 break; 223 case 'p': 224 flags |= RESIZE_PERCENT_COMPLETE; 225 break; 226 case 'S': 227 use_stride = atoi(optarg); 228 break; 229 default: 230 usage(program_name); 231 } 232 } 233 if (optind == argc) 234 usage(program_name); 235 236 device_name = argv[optind++]; 237 if (optind < argc) 238 new_size_str = argv[optind++]; 239 if (optind < argc) 240 usage(program_name); 241 242 io_options = strchr(device_name, '?'); 243 if (io_options) 244 *io_options++ = 0; 245 246 /* 247 * Figure out whether or not the device is mounted, and if it is 248 * where it is mounted. 249 */ 250 len=80; 251 while (1) { 252 mtpt = malloc(len); 253 if (!mtpt) 254 return ENOMEM; 255 mtpt[len-1] = 0; 256 retval = ext2fs_check_mount_point(device_name, &mount_flags, 257 mtpt, len); 258 if (retval) { 259 com_err("ext2fs_check_mount_point", retval, 260 _("while determining whether %s is mounted."), 261 device_name); 262 exit(1); 263 } 264 if (!(mount_flags & EXT2_MF_MOUNTED) || (mtpt[len-1] == 0)) 265 break; 266 free(mtpt); 267 len = 2 * len; 268 } 269 270 fd = ext2fs_open_file(device_name, O_RDWR, 0); 271 if (fd < 0) { 272 com_err("open", errno, _("while opening %s"), 273 device_name); 274 exit(1); 275 } 276 277 ret = ext2fs_fstat(fd, &st_buf); 278 if (ret < 0) { 279 com_err("open", errno, 280 _("while getting stat information for %s"), 281 device_name); 282 exit(1); 283 } 284 285 if (flush) { 286 retval = ext2fs_sync_device(fd, 1); 287 if (retval) { 288 com_err(argv[0], retval, 289 _("while trying to flush %s"), 290 device_name); 291 exit(1); 292 } 293 } 294 295 if (!S_ISREG(st_buf.st_mode )) { 296 close(fd); 297 fd = -1; 298 } 299 300#ifdef CONFIG_TESTIO_DEBUG 301 if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) { 302 io_ptr = test_io_manager; 303 test_io_backing_manager = unix_io_manager; 304 } else 305#endif 306 io_ptr = unix_io_manager; 307 308 if (!(mount_flags & EXT2_MF_MOUNTED)) 309 io_flags = EXT2_FLAG_RW | EXT2_FLAG_EXCLUSIVE; 310 311 io_flags |= EXT2_FLAG_64BITS; 312 313 retval = ext2fs_open2(device_name, io_options, io_flags, 314 0, 0, io_ptr, &fs); 315 if (retval) { 316 com_err(program_name, retval, _("while trying to open %s"), 317 device_name); 318 printf("%s", _("Couldn't find valid filesystem superblock.\n")); 319 exit (1); 320 } 321 322 /* 323 * Check for compatibility with the feature sets. We need to 324 * be more stringent than ext2fs_open(). 325 */ 326 if (fs->super->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP) { 327 com_err(program_name, EXT2_ET_UNSUPP_FEATURE, 328 "(%s)", device_name); 329 exit(1); 330 } 331 332 min_size = calculate_minimum_resize_size(fs, flags); 333 334 if (print_min_size) { 335 if (!force && ((fs->super->s_state & EXT2_ERROR_FS) || 336 ((fs->super->s_state & EXT2_VALID_FS) == 0))) { 337 fprintf(stderr, 338 _("Please run 'e2fsck -f %s' first.\n\n"), 339 device_name); 340 exit(1); 341 } 342 printf(_("Estimated minimum size of the filesystem: %llu\n"), 343 min_size); 344 exit(0); 345 } 346 347 /* Determine the system page size if possible */ 348#ifdef HAVE_SYSCONF 349#if (!defined(_SC_PAGESIZE) && defined(_SC_PAGE_SIZE)) 350#define _SC_PAGESIZE _SC_PAGE_SIZE 351#endif 352#ifdef _SC_PAGESIZE 353 sysval = sysconf(_SC_PAGESIZE); 354 if (sysval > 0) 355 sys_page_size = sysval; 356#endif /* _SC_PAGESIZE */ 357#endif /* HAVE_SYSCONF */ 358 359 /* 360 * Get the size of the containing partition, and use this for 361 * defaults and for making sure the new filesystem doesn't 362 * exceed the partition size. 363 */ 364 retval = ext2fs_get_device_size2(device_name, fs->blocksize, 365 &max_size); 366 if (retval) { 367 com_err(program_name, retval, "%s", 368 _("while trying to determine filesystem size")); 369 exit(1); 370 } 371 if (force_min_size) 372 new_size = min_size; 373 else if (new_size_str) { 374 new_size = parse_num_blocks2(new_size_str, 375 fs->super->s_log_block_size); 376 if (new_size == 0) { 377 com_err(program_name, 0, 378 _("Invalid new size: %s\n"), new_size_str); 379 exit(1); 380 } 381 } else { 382 new_size = max_size; 383 /* Round down to an even multiple of a pagesize */ 384 if (sys_page_size > fs->blocksize) 385 new_size &= ~((sys_page_size / fs->blocksize)-1); 386 } 387 if (!EXT2_HAS_INCOMPAT_FEATURE(fs->super, 388 EXT4_FEATURE_INCOMPAT_64BIT)) { 389 /* Take 16T down to 2^32-1 blocks */ 390 if (new_size == (1ULL << 32)) 391 new_size--; 392 else if (new_size > (1ULL << 32)) { 393 com_err(program_name, 0, "%s", 394 _("New size too large to be " 395 "expressed in 32 bits\n")); 396 exit(1); 397 } 398 } 399 400 if (!force && new_size < min_size) { 401 com_err(program_name, 0, 402 _("New size smaller than minimum (%llu)\n"), min_size); 403 exit(1); 404 } 405 if (use_stride >= 0) { 406 if (use_stride >= (int) fs->super->s_blocks_per_group) { 407 com_err(program_name, 0, "%s", 408 _("Invalid stride length")); 409 exit(1); 410 } 411 fs->stride = fs->super->s_raid_stride = use_stride; 412 ext2fs_mark_super_dirty(fs); 413 } else 414 determine_fs_stride(fs); 415 416 /* 417 * If we are resizing a plain file, and it's not big enough, 418 * automatically extend it in a sparse fashion by writing the 419 * last requested block. 420 */ 421 new_file_size = ((__u64) new_size) * fs->blocksize; 422 if ((__u64) new_file_size > 423 (((__u64) 1) << (sizeof(st_buf.st_size)*8 - 1)) - 1) 424 fd = -1; 425 if ((new_file_size > st_buf.st_size) && 426 (fd > 0)) { 427 if ((ext2fs_llseek(fd, new_file_size-1, SEEK_SET) >= 0) && 428 (write(fd, "0", 1) == 1)) 429 max_size = new_size; 430 } 431 if (!force && (new_size > max_size)) { 432 fprintf(stderr, _("The containing partition (or device)" 433 " is only %llu (%dk) blocks.\nYou requested a new size" 434 " of %llu blocks.\n\n"), max_size, 435 fs->blocksize / 1024, new_size); 436 exit(1); 437 } 438 if (new_size == ext2fs_blocks_count(fs->super)) { 439 fprintf(stderr, _("The filesystem is already %llu blocks " 440 "long. Nothing to do!\n\n"), new_size); 441 exit(0); 442 } 443 if (mount_flags & EXT2_MF_MOUNTED) { 444 bigalloc_check(fs, force); 445 retval = online_resize_fs(fs, mtpt, &new_size, flags); 446 } else { 447 if (!force && ((fs->super->s_lastcheck < fs->super->s_mtime) || 448 (fs->super->s_state & EXT2_ERROR_FS) || 449 ((fs->super->s_state & EXT2_VALID_FS) == 0))) { 450 fprintf(stderr, 451 _("Please run 'e2fsck -f %s' first.\n\n"), 452 device_name); 453 exit(1); 454 } 455 bigalloc_check(fs, force); 456 printf(_("Resizing the filesystem on " 457 "%s to %llu (%dk) blocks.\n"), 458 device_name, new_size, fs->blocksize / 1024); 459 retval = resize_fs(fs, &new_size, flags, 460 ((flags & RESIZE_PERCENT_COMPLETE) ? 461 resize_progress_func : 0)); 462 } 463 free(mtpt); 464 if (retval) { 465 com_err(program_name, retval, _("while trying to resize %s"), 466 device_name); 467 fprintf(stderr, 468 _("Please run 'e2fsck -fy %s' to fix the filesystem\n" 469 "after the aborted resize operation.\n"), 470 device_name); 471 ext2fs_close(fs); 472 exit(1); 473 } 474 printf(_("The filesystem on %s is now %llu blocks long.\n\n"), 475 device_name, new_size); 476 477 if ((st_buf.st_size > new_file_size) && 478 (fd > 0)) { 479#ifdef HAVE_FTRUNCATE64 480 retval = ftruncate64(fd, new_file_size); 481#else 482 retval = 0; 483 /* Only truncate if new_file_size doesn't overflow off_t */ 484 if (((off_t) new_file_size) == new_file_size) 485 retval = ftruncate(fd, (off_t) new_file_size); 486#endif 487 if (retval) 488 com_err(program_name, retval, 489 _("while trying to truncate %s"), 490 device_name); 491 } 492 if (fd > 0) 493 close(fd); 494 remove_error_table(&et_ext2_error_table); 495 return (0); 496} 497