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 21 extern char *optarg; 22 extern 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 38 char *program_name, *device_name, *io_options; 39 40 static 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 48 static 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 100 static 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 149 int 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 blk_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 printf(_("Estimated minimum size of the filesystem: %u\n"), 349 min_size); 350 exit(0); 351 } 352 353 /* Determine the system page size if possible */ 354 #ifdef HAVE_SYSCONF 355 #if (!defined(_SC_PAGESIZE) && defined(_SC_PAGE_SIZE)) 356 #define _SC_PAGESIZE _SC_PAGE_SIZE 357 #endif 358 #ifdef _SC_PAGESIZE 359 sysval = sysconf(_SC_PAGESIZE); 360 if (sysval > 0) 361 sys_page_size = sysval; 362 #endif /* _SC_PAGESIZE */ 363 #endif /* HAVE_SYSCONF */ 364 365 /* 366 * Get the size of the containing partition, and use this for 367 * defaults and for making sure the new filesystem doesn't 368 * exceed the partition size. 369 */ 370 retval = ext2fs_get_device_size(device_name, fs->blocksize, 371 &max_size); 372 if (retval) { 373 com_err(program_name, retval, 374 _("while trying to determine filesystem size")); 375 exit(1); 376 } 377 if (force_min_size) 378 new_size = min_size; 379 else if (new_size_str) { 380 new_size = parse_num_blocks(new_size_str, 381 fs->super->s_log_block_size); 382 if (new_size == 0) { 383 com_err(program_name, 0, 384 _("Invalid new size: %s\n"), new_size_str); 385 exit(1); 386 } 387 } else { 388 new_size = max_size; 389 /* Round down to an even multiple of a pagesize */ 390 if (sys_page_size > fs->blocksize) 391 new_size &= ~((sys_page_size / fs->blocksize)-1); 392 } 393 394 if (!force && new_size < min_size) { 395 com_err(program_name, 0, 396 _("New size smaller than minimum (%u)\n"), min_size); 397 exit(1); 398 } 399 if (use_stride >= 0) { 400 if (use_stride >= (int) fs->super->s_blocks_per_group) { 401 com_err(program_name, 0, 402 _("Invalid stride length")); 403 exit(1); 404 } 405 fs->stride = fs->super->s_raid_stride = use_stride; 406 ext2fs_mark_super_dirty(fs); 407 } else 408 determine_fs_stride(fs); 409 410 /* 411 * If we are resizing a plain file, and it's not big enough, 412 * automatically extend it in a sparse fashion by writing the 413 * last requested block. 414 */ 415 new_file_size = ((__u64) new_size) * fs->blocksize; 416 if ((__u64) new_file_size > 417 (((__u64) 1) << (sizeof(st_buf.st_size)*8 - 1)) - 1) 418 fd = -1; 419 if ((new_file_size > st_buf.st_size) && 420 (fd > 0)) { 421 if ((ext2fs_llseek(fd, new_file_size-1, SEEK_SET) >= 0) && 422 (write(fd, "0", 1) == 1)) 423 max_size = new_size; 424 } 425 if (!force && (new_size > max_size)) { 426 fprintf(stderr, _("The containing partition (or device)" 427 " is only %u (%dk) blocks.\nYou requested a new size" 428 " of %u blocks.\n\n"), max_size, 429 fs->blocksize / 1024, new_size); 430 exit(1); 431 } 432 if (new_size == fs->super->s_blocks_count) { 433 fprintf(stderr, _("The filesystem is already %u blocks " 434 "long. Nothing to do!\n\n"), new_size); 435 exit(0); 436 } 437 if (mount_flags & EXT2_MF_MOUNTED) { 438 retval = online_resize_fs(fs, mtpt, &new_size, flags); 439 } else { 440 if (!force && ((fs->super->s_lastcheck < fs->super->s_mtime) || 441 (fs->super->s_state & EXT2_ERROR_FS) || 442 ((fs->super->s_state & EXT2_VALID_FS) == 0))) { 443 fprintf(stderr, 444 _("Please run 'e2fsck -f %s' first.\n\n"), 445 device_name); 446 exit(1); 447 } 448 printf(_("Resizing the filesystem on " 449 "%s to %u (%dk) blocks.\n"), 450 device_name, new_size, fs->blocksize / 1024); 451 retval = resize_fs(fs, &new_size, flags, 452 ((flags & RESIZE_PERCENT_COMPLETE) ? 453 resize_progress_func : 0)); 454 } 455 free(mtpt); 456 if (retval) { 457 com_err(program_name, retval, _("while trying to resize %s"), 458 device_name); 459 fprintf(stderr, 460 _("Please run 'e2fsck -fy %s' to fix the filesystem\n" 461 "after the aborted resize operation.\n"), 462 device_name); 463 ext2fs_close(fs); 464 exit(1); 465 } 466 printf(_("The filesystem on %s is now %u blocks long.\n\n"), 467 device_name, new_size); 468 469 if ((st_buf.st_size > new_file_size) && 470 (fd > 0)) { 471 #ifdef HAVE_FTRUNCATE64 472 retval = ftruncate64(fd, new_file_size); 473 #else 474 retval = 0; 475 /* Only truncate if new_file_size doesn't overflow off_t */ 476 if (((off_t) new_file_size) == new_file_size) 477 retval = ftruncate(fd, (off_t) new_file_size); 478 #endif 479 if (retval) 480 com_err(program_name, retval, 481 _("while trying to truncate %s"), 482 device_name); 483 } 484 if (fd > 0) 485 close(fd); 486 remove_error_table(&et_ext2_error_table); 487 return (0); 488 } 489
