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