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