1/*
2 * util.c --- miscellaneous utilities
3 *
4 * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
5 *
6 * %Begin-Header%
7 * This file may be redistributed under the terms of the GNU Public
8 * License.
9 * %End-Header%
10 */
11
12#include <stdlib.h>
13#include <stdio.h>
14#include <unistd.h>
15#include <string.h>
16#include <ctype.h>
17#ifdef __linux__
18#include <sys/utsname.h>
19#endif
20
21#ifdef HAVE_CONIO_H
22#undef HAVE_TERMIOS_H
23#include <conio.h>
24#define read_a_char()	getch()
25#else
26#ifdef HAVE_TERMIOS_H
27#include <termios.h>
28#endif
29#endif
30
31#ifdef HAVE_MALLOC_H
32#include <malloc.h>
33#endif
34
35#ifdef HAVE_ERRNO_H
36#include <errno.h>
37#endif
38
39#include "e2fsck.h"
40
41extern e2fsck_t e2fsck_global_ctx;   /* Try your very best not to use this! */
42
43#include <stdarg.h>
44#include <time.h>
45#include <sys/time.h>
46#include <sys/resource.h>
47
48void fatal_error(e2fsck_t ctx, const char *msg)
49{
50	ext2_filsys fs = ctx->fs;
51	int exit_value = FSCK_ERROR;
52
53	if (msg)
54		fprintf (stderr, "e2fsck: %s\n", msg);
55	if (!fs)
56		goto out;
57	if (fs->io && fs->super) {
58		ext2fs_mmp_stop(ctx->fs);
59		if (ctx->fs->io->magic == EXT2_ET_MAGIC_IO_CHANNEL)
60			io_channel_flush(ctx->fs->io);
61		else
62			log_err(ctx, "e2fsck: io manager magic bad!\n");
63	}
64	if (ext2fs_test_changed(fs)) {
65		exit_value |= FSCK_NONDESTRUCT;
66		log_out(ctx, _("\n%s: ***** FILE SYSTEM WAS MODIFIED *****\n"),
67			ctx->device_name);
68		if (ctx->mount_flags & EXT2_MF_ISROOT)
69			exit_value |= FSCK_REBOOT;
70	}
71	if (!ext2fs_test_valid(fs)) {
72		log_out(ctx, _("\n%s: ********** WARNING: Filesystem still has "
73			       "errors **********\n\n"), ctx->device_name);
74		exit_value |= FSCK_UNCORRECTED;
75		exit_value &= ~FSCK_NONDESTRUCT;
76	}
77out:
78	ctx->flags |= E2F_FLAG_ABORT;
79	if (ctx->flags & E2F_FLAG_SETJMP_OK)
80		longjmp(ctx->abort_loc, 1);
81	exit(exit_value);
82}
83
84void log_out(e2fsck_t ctx, const char *fmt, ...)
85{
86	va_list pvar;
87
88	va_start(pvar, fmt);
89	vprintf(fmt, pvar);
90	va_end(pvar);
91	if (ctx->logf) {
92		va_start(pvar, fmt);
93		vfprintf(ctx->logf, fmt, pvar);
94		va_end(pvar);
95	}
96}
97
98void log_err(e2fsck_t ctx, const char *fmt, ...)
99{
100	va_list pvar;
101
102	va_start(pvar, fmt);
103	vfprintf(stderr, fmt, pvar);
104	va_end(pvar);
105	if (ctx->logf) {
106		va_start(pvar, fmt);
107		vfprintf(ctx->logf, fmt, pvar);
108		va_end(pvar);
109	}
110}
111
112void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size,
113			     const char *description)
114{
115	void *ret;
116	char buf[256];
117
118#ifdef DEBUG_ALLOCATE_MEMORY
119	printf("Allocating %u bytes for %s...\n", size, description);
120#endif
121	ret = malloc(size);
122	if (!ret) {
123		sprintf(buf, "Can't allocate %u bytes for %s\n",
124			size, description);
125		fatal_error(ctx, buf);
126	}
127	memset(ret, 0, size);
128	return ret;
129}
130
131char *string_copy(e2fsck_t ctx EXT2FS_ATTR((unused)),
132		  const char *str, int len)
133{
134	char	*ret;
135
136	if (!str)
137		return NULL;
138	if (!len)
139		len = strlen(str);
140	ret = malloc(len+1);
141	if (ret) {
142		strncpy(ret, str, len);
143		ret[len] = 0;
144	}
145	return ret;
146}
147
148#ifndef HAVE_STRNLEN
149/*
150 * Incredibly, libc5 doesn't appear to have strnlen.  So we have to
151 * provide our own.
152 */
153int e2fsck_strnlen(const char * s, int count)
154{
155	const char *cp = s;
156
157	while (count-- && *cp)
158		cp++;
159	return cp - s;
160}
161#endif
162
163#ifndef HAVE_CONIO_H
164static int read_a_char(void)
165{
166	char	c;
167	int	r;
168	int	fail = 0;
169
170	while(1) {
171		if (e2fsck_global_ctx &&
172		    (e2fsck_global_ctx->flags & E2F_FLAG_CANCEL)) {
173			return 3;
174		}
175		r = read(0, &c, 1);
176		if (r == 1)
177			return c;
178		if (fail++ > 100)
179			break;
180	}
181	return EOF;
182}
183#endif
184
185int ask_yn(e2fsck_t ctx, const char * string, int def)
186{
187	int		c;
188	const char	*defstr;
189	const char	*short_yes = _("yY");
190	const char	*short_no = _("nN");
191
192#ifdef HAVE_TERMIOS_H
193	struct termios	termios, tmp;
194
195	tcgetattr (0, &termios);
196	tmp = termios;
197	tmp.c_lflag &= ~(ICANON | ECHO);
198	tmp.c_cc[VMIN] = 1;
199	tmp.c_cc[VTIME] = 0;
200	tcsetattr (0, TCSANOW, &tmp);
201#endif
202
203	if (def == 1)
204		defstr = _(_("<y>"));
205	else if (def == 0)
206		defstr = _(_("<n>"));
207	else
208		defstr = _(" (y/n)");
209	log_out(ctx, "%s%s? ", string, defstr);
210	while (1) {
211		fflush (stdout);
212		if ((c = read_a_char()) == EOF)
213			break;
214		if (c == 3) {
215#ifdef HAVE_TERMIOS_H
216			tcsetattr (0, TCSANOW, &termios);
217#endif
218			if (ctx->flags & E2F_FLAG_SETJMP_OK) {
219				log_out(ctx, "\n");
220				longjmp(e2fsck_global_ctx->abort_loc, 1);
221			}
222			log_out(ctx, "%s", _("cancelled!\n"));
223			return 0;
224		}
225		if (strchr(short_yes, (char) c)) {
226			def = 1;
227			break;
228		}
229		else if (strchr(short_no, (char) c)) {
230			def = 0;
231			break;
232		}
233		else if ((c == 27 || c == ' ' || c == '\n') && (def != -1))
234			break;
235	}
236	if (def)
237		log_out(ctx, "%s", _("yes\n"));
238	else
239		log_out(ctx, "%s", _("no\n"));
240#ifdef HAVE_TERMIOS_H
241	tcsetattr (0, TCSANOW, &termios);
242#endif
243	return def;
244}
245
246int ask (e2fsck_t ctx, const char * string, int def)
247{
248	if (ctx->options & E2F_OPT_NO) {
249		log_out(ctx, _("%s? no\n\n"), string);
250		return 0;
251	}
252	if (ctx->options & E2F_OPT_YES) {
253		log_out(ctx, _("%s? yes\n\n"), string);
254		return 1;
255	}
256	if (ctx->options & E2F_OPT_PREEN) {
257		log_out(ctx, "%s? %s\n\n", string, def ? _("yes") : _("no"));
258		return def;
259	}
260	return ask_yn(ctx, string, def);
261}
262
263void e2fsck_read_bitmaps(e2fsck_t ctx)
264{
265	ext2_filsys fs = ctx->fs;
266	errcode_t	retval;
267	const char	*old_op;
268	unsigned int	save_type;
269
270	if (ctx->invalid_bitmaps) {
271		com_err(ctx->program_name, 0,
272		    _("e2fsck_read_bitmaps: illegal bitmap block(s) for %s"),
273			ctx->device_name);
274		fatal_error(ctx, 0);
275	}
276
277	old_op = ehandler_operation(_("reading inode and block bitmaps"));
278	e2fsck_set_bitmap_type(fs, EXT2FS_BMAP64_RBTREE, "fs_bitmaps",
279			       &save_type);
280	retval = ext2fs_read_bitmaps(fs);
281	fs->default_bitmap_type = save_type;
282	ehandler_operation(old_op);
283	if (retval) {
284		com_err(ctx->program_name, retval,
285			_("while retrying to read bitmaps for %s"),
286			ctx->device_name);
287		fatal_error(ctx, 0);
288	}
289}
290
291void e2fsck_write_bitmaps(e2fsck_t ctx)
292{
293	ext2_filsys fs = ctx->fs;
294	errcode_t	retval;
295	const char	*old_op;
296
297	old_op = ehandler_operation(_("writing block and inode bitmaps"));
298	retval = ext2fs_write_bitmaps(fs);
299	ehandler_operation(old_op);
300	if (retval) {
301		com_err(ctx->program_name, retval,
302			_("while rewriting block and inode bitmaps for %s"),
303			ctx->device_name);
304		fatal_error(ctx, 0);
305	}
306}
307
308void preenhalt(e2fsck_t ctx)
309{
310	ext2_filsys fs = ctx->fs;
311
312	if (!(ctx->options & E2F_OPT_PREEN))
313		return;
314	log_err(ctx, _("\n\n%s: UNEXPECTED INCONSISTENCY; "
315		"RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n"),
316	       ctx->device_name);
317	ctx->flags |= E2F_FLAG_EXITING;
318	if (fs != NULL) {
319		fs->super->s_state |= EXT2_ERROR_FS;
320		ext2fs_mark_super_dirty(fs);
321		ext2fs_close(fs);
322	}
323	exit(FSCK_UNCORRECTED);
324}
325
326#ifdef RESOURCE_TRACK
327void init_resource_track(struct resource_track *track, io_channel channel)
328{
329#ifdef HAVE_GETRUSAGE
330	struct rusage r;
331#endif
332	io_stats io_start = 0;
333
334	track->brk_start = sbrk(0);
335	gettimeofday(&track->time_start, 0);
336#ifdef HAVE_GETRUSAGE
337#ifdef sun
338	memset(&r, 0, sizeof(struct rusage));
339#endif
340	getrusage(RUSAGE_SELF, &r);
341	track->user_start = r.ru_utime;
342	track->system_start = r.ru_stime;
343#else
344	track->user_start.tv_sec = track->user_start.tv_usec = 0;
345	track->system_start.tv_sec = track->system_start.tv_usec = 0;
346#endif
347	track->bytes_read = 0;
348	track->bytes_written = 0;
349	if (channel && channel->manager && channel->manager->get_stats)
350		channel->manager->get_stats(channel, &io_start);
351	if (io_start) {
352		track->bytes_read = io_start->bytes_read;
353		track->bytes_written = io_start->bytes_written;
354	}
355}
356
357#ifdef __GNUC__
358#define _INLINE_ __inline__
359#else
360#define _INLINE_
361#endif
362
363static _INLINE_ float timeval_subtract(struct timeval *tv1,
364				       struct timeval *tv2)
365{
366	return ((tv1->tv_sec - tv2->tv_sec) +
367		((float) (tv1->tv_usec - tv2->tv_usec)) / 1000000);
368}
369
370void print_resource_track(e2fsck_t ctx, const char *desc,
371			  struct resource_track *track, io_channel channel)
372{
373#ifdef HAVE_GETRUSAGE
374	struct rusage r;
375#endif
376#ifdef HAVE_MALLINFO
377	struct mallinfo	malloc_info;
378#endif
379	struct timeval time_end;
380
381	if ((desc && !(ctx->options & E2F_OPT_TIME2)) ||
382	    (!desc && !(ctx->options & E2F_OPT_TIME)))
383		return;
384
385	e2fsck_clear_progbar(ctx);
386	gettimeofday(&time_end, 0);
387
388	if (desc)
389		log_out(ctx, "%s: ", desc);
390
391#ifdef HAVE_MALLINFO
392#define kbytes(x)	(((unsigned long)(x) + 1023) / 1024)
393
394	malloc_info = mallinfo();
395	log_out(ctx, _("Memory used: %luk/%luk (%luk/%luk), "),
396		kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd),
397		kbytes(malloc_info.uordblks), kbytes(malloc_info.fordblks));
398#else
399	log_out(ctx, _("Memory used: %lu, "),
400		(unsigned long) (((char *) sbrk(0)) -
401				 ((char *) track->brk_start)));
402#endif
403#ifdef HAVE_GETRUSAGE
404	getrusage(RUSAGE_SELF, &r);
405
406	log_out(ctx, _("time: %5.2f/%5.2f/%5.2f\n"),
407		timeval_subtract(&time_end, &track->time_start),
408		timeval_subtract(&r.ru_utime, &track->user_start),
409		timeval_subtract(&r.ru_stime, &track->system_start));
410#else
411	log_out(ctx, _("elapsed time: %6.3f\n"),
412		timeval_subtract(&time_end, &track->time_start));
413#endif
414#define mbytes(x)	(((x) + 1048575) / 1048576)
415	if (channel && channel->manager && channel->manager->get_stats) {
416		io_stats delta = 0;
417		unsigned long long bytes_read = 0;
418		unsigned long long bytes_written = 0;
419
420		if (desc)
421			log_out(ctx, "%s: ", desc);
422
423		channel->manager->get_stats(channel, &delta);
424		if (delta) {
425			bytes_read = delta->bytes_read - track->bytes_read;
426			bytes_written = delta->bytes_written -
427				track->bytes_written;
428		}
429		log_out(ctx, "I/O read: %lluMB, write: %lluMB, "
430			"rate: %.2fMB/s\n",
431			mbytes(bytes_read), mbytes(bytes_written),
432			(double)mbytes(bytes_read + bytes_written) /
433			timeval_subtract(&time_end, &track->time_start));
434	}
435}
436#endif /* RESOURCE_TRACK */
437
438void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino,
439			      struct ext2_inode * inode, const char *proc)
440{
441	errcode_t retval;
442
443	retval = ext2fs_read_inode(ctx->fs, ino, inode);
444	if (retval) {
445		com_err("ext2fs_read_inode", retval,
446			_("while reading inode %lu in %s"), ino, proc);
447		fatal_error(ctx, 0);
448	}
449}
450
451void e2fsck_read_inode_full(e2fsck_t ctx, unsigned long ino,
452			    struct ext2_inode *inode, int bufsize,
453			    const char *proc)
454{
455	errcode_t retval;
456
457	retval = ext2fs_read_inode_full(ctx->fs, ino, inode, bufsize);
458	if (retval) {
459		com_err("ext2fs_read_inode_full", retval,
460			_("while reading inode %lu in %s"), ino, proc);
461		fatal_error(ctx, 0);
462	}
463}
464
465void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino,
466			     struct ext2_inode * inode, int bufsize,
467			     const char *proc)
468{
469	errcode_t retval;
470
471	retval = ext2fs_write_inode_full(ctx->fs, ino, inode, bufsize);
472	if (retval) {
473		com_err("ext2fs_write_inode", retval,
474			_("while writing inode %lu in %s"), ino, proc);
475		fatal_error(ctx, 0);
476	}
477}
478
479void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino,
480			struct ext2_inode * inode, const char *proc)
481{
482	errcode_t retval;
483
484	retval = ext2fs_write_inode(ctx->fs, ino, inode);
485	if (retval) {
486		com_err("ext2fs_write_inode", retval,
487			_("while writing inode %lu in %s"), ino, proc);
488		fatal_error(ctx, 0);
489	}
490}
491
492#ifdef MTRACE
493void mtrace_print(char *mesg)
494{
495	FILE	*malloc_get_mallstream();
496	FILE	*f = malloc_get_mallstream();
497
498	if (f)
499		fprintf(f, "============= %s\n", mesg);
500}
501#endif
502
503blk64_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs, const char *name,
504		      io_manager manager)
505{
506	struct ext2_super_block *sb;
507	io_channel		io = NULL;
508	void			*buf = NULL;
509	int			blocksize;
510	blk64_t			superblock, ret_sb = 8193;
511
512	if (fs && fs->super) {
513		ret_sb = (fs->super->s_blocks_per_group +
514			  fs->super->s_first_data_block);
515		if (ctx) {
516			ctx->superblock = ret_sb;
517			ctx->blocksize = fs->blocksize;
518		}
519		return ret_sb;
520	}
521
522	if (ctx) {
523		if (ctx->blocksize) {
524			ret_sb = ctx->blocksize * 8;
525			if (ctx->blocksize == 1024)
526				ret_sb++;
527			ctx->superblock = ret_sb;
528			return ret_sb;
529		}
530		ctx->superblock = ret_sb;
531		ctx->blocksize = 1024;
532	}
533
534	if (!name || !manager)
535		goto cleanup;
536
537	if (manager->open(name, 0, &io) != 0)
538		goto cleanup;
539
540	if (ext2fs_get_mem(SUPERBLOCK_SIZE, &buf))
541		goto cleanup;
542	sb = (struct ext2_super_block *) buf;
543
544	for (blocksize = EXT2_MIN_BLOCK_SIZE;
545	     blocksize <= EXT2_MAX_BLOCK_SIZE ; blocksize *= 2) {
546		superblock = blocksize*8;
547		if (blocksize == 1024)
548			superblock++;
549		io_channel_set_blksize(io, blocksize);
550		if (io_channel_read_blk64(io, superblock,
551					-SUPERBLOCK_SIZE, buf))
552			continue;
553#ifdef WORDS_BIGENDIAN
554		if (sb->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
555			ext2fs_swap_super(sb);
556#endif
557		if ((sb->s_magic == EXT2_SUPER_MAGIC) &&
558		    (EXT2_BLOCK_SIZE(sb) == blocksize)) {
559			ret_sb = superblock;
560			if (ctx) {
561				ctx->superblock = superblock;
562				ctx->blocksize = blocksize;
563			}
564			break;
565		}
566	}
567
568cleanup:
569	if (io)
570		io_channel_close(io);
571	if (buf)
572		ext2fs_free_mem(&buf);
573	return (ret_sb);
574}
575
576/*
577 * Given a mode, return the ext2 file type
578 */
579int ext2_file_type(unsigned int mode)
580{
581	if (LINUX_S_ISREG(mode))
582		return EXT2_FT_REG_FILE;
583
584	if (LINUX_S_ISDIR(mode))
585		return EXT2_FT_DIR;
586
587	if (LINUX_S_ISCHR(mode))
588		return EXT2_FT_CHRDEV;
589
590	if (LINUX_S_ISBLK(mode))
591		return EXT2_FT_BLKDEV;
592
593	if (LINUX_S_ISLNK(mode))
594		return EXT2_FT_SYMLINK;
595
596	if (LINUX_S_ISFIFO(mode))
597		return EXT2_FT_FIFO;
598
599	if (LINUX_S_ISSOCK(mode))
600		return EXT2_FT_SOCK;
601
602	return 0;
603}
604
605#define STRIDE_LENGTH 8
606/*
607 * Helper function which zeros out _num_ blocks starting at _blk_.  In
608 * case of an error, the details of the error is returned via _ret_blk_
609 * and _ret_count_ if they are non-NULL pointers.  Returns 0 on
610 * success, and an error code on an error.
611 *
612 * As a special case, if the first argument is NULL, then it will
613 * attempt to free the static zeroizing buffer.  (This is to keep
614 * programs that check for memory leaks happy.)
615 */
616errcode_t e2fsck_zero_blocks(ext2_filsys fs, blk_t blk, int num,
617			     blk_t *ret_blk, int *ret_count)
618{
619	int		j, count;
620	static char	*buf;
621	errcode_t	retval;
622
623	/* If fs is null, clean up the static buffer and return */
624	if (!fs) {
625		if (buf) {
626			free(buf);
627			buf = 0;
628		}
629		return 0;
630	}
631	/* Allocate the zeroizing buffer if necessary */
632	if (!buf) {
633		buf = malloc(fs->blocksize * STRIDE_LENGTH);
634		if (!buf) {
635			com_err("malloc", ENOMEM, "%s",
636				_("while allocating zeroizing buffer"));
637			exit(1);
638		}
639		memset(buf, 0, fs->blocksize * STRIDE_LENGTH);
640	}
641	/* OK, do the write loop */
642	for (j = 0; j < num; j += STRIDE_LENGTH, blk += STRIDE_LENGTH) {
643		count = num - j;
644		if (count > STRIDE_LENGTH)
645			count = STRIDE_LENGTH;
646		retval = io_channel_write_blk64(fs->io, blk, count, buf);
647		if (retval) {
648			if (ret_count)
649				*ret_count = count;
650			if (ret_blk)
651				*ret_blk = blk;
652			return retval;
653		}
654	}
655	return 0;
656}
657
658/*
659 * Check to see if a filesystem is in /proc/filesystems.
660 * Returns 1 if found, 0 if not
661 */
662int fs_proc_check(const char *fs_name)
663{
664	FILE	*f;
665	char	buf[80], *cp, *t;
666
667	f = fopen("/proc/filesystems", "r");
668	if (!f)
669		return (0);
670	while (!feof(f)) {
671		if (!fgets(buf, sizeof(buf), f))
672			break;
673		cp = buf;
674		if (!isspace(*cp)) {
675			while (*cp && !isspace(*cp))
676				cp++;
677		}
678		while (*cp && isspace(*cp))
679			cp++;
680		if ((t = strchr(cp, '\n')) != NULL)
681			*t = 0;
682		if ((t = strchr(cp, '\t')) != NULL)
683			*t = 0;
684		if ((t = strchr(cp, ' ')) != NULL)
685			*t = 0;
686		if (!strcmp(fs_name, cp)) {
687			fclose(f);
688			return (1);
689		}
690	}
691	fclose(f);
692	return (0);
693}
694
695/*
696 * Check to see if a filesystem is available as a module
697 * Returns 1 if found, 0 if not
698 */
699int check_for_modules(const char *fs_name)
700{
701#ifdef __linux__
702	struct utsname	uts;
703	FILE		*f;
704	char		buf[1024], *cp, *t;
705	int		i;
706
707	if (uname(&uts))
708		return (0);
709	snprintf(buf, sizeof(buf), "/lib/modules/%s/modules.dep", uts.release);
710
711	f = fopen(buf, "r");
712	if (!f)
713		return (0);
714	while (!feof(f)) {
715		if (!fgets(buf, sizeof(buf), f))
716			break;
717		if ((cp = strchr(buf, ':')) != NULL)
718			*cp = 0;
719		else
720			continue;
721		if ((cp = strrchr(buf, '/')) != NULL)
722			cp++;
723		else
724			cp = buf;
725		i = strlen(cp);
726		if (i > 3) {
727			t = cp + i - 3;
728			if (!strcmp(t, ".ko"))
729				*t = 0;
730		}
731		if (!strcmp(cp, fs_name)) {
732			fclose(f);
733			return (1);
734		}
735	}
736	fclose(f);
737#endif /* __linux__ */
738	return (0);
739}
740
741/*
742 * Helper function that does the right thing if write returns a
743 * partial write, or an EGAIN/EINTR error.
744 */
745int write_all(int fd, char *buf, size_t count)
746{
747	ssize_t ret;
748	int c = 0;
749
750	while (count > 0) {
751		ret = write(fd, buf, count);
752		if (ret < 0) {
753			if ((errno == EAGAIN) || (errno == EINTR))
754				continue;
755			return -1;
756		}
757		count -= ret;
758		buf += ret;
759		c += ret;
760	}
761	return c;
762}
763
764void dump_mmp_msg(struct mmp_struct *mmp, const char *msg)
765{
766
767	if (msg)
768		printf("MMP check failed: %s\n", msg);
769	if (mmp) {
770		time_t t = mmp->mmp_time;
771
772		printf("MMP error info: last update: %s node: %s device: %s\n",
773		       ctime(&t), mmp->mmp_nodename, mmp->mmp_bdevname);
774	}
775}
776
777errcode_t e2fsck_mmp_update(ext2_filsys fs)
778{
779	errcode_t retval;
780
781	retval = ext2fs_mmp_update(fs);
782	if (retval == EXT2_ET_MMP_CHANGE_ABORT)
783		dump_mmp_msg(fs->mmp_cmp,
784			     _("UNEXPECTED INCONSISTENCY: the filesystem is "
785			       "being modified while fsck is running.\n"));
786
787	return retval;
788}
789
790void e2fsck_set_bitmap_type(ext2_filsys fs, unsigned int default_type,
791			    const char *profile_name, unsigned int *old_type)
792{
793	unsigned type;
794
795	if (old_type)
796		*old_type = fs->default_bitmap_type;
797#ifdef HAVE_SIGNAL_H
798	profile_get_uint(e2fsck_global_ctx->profile, "bitmaps",
799			 profile_name, 0, default_type, &type);
800	profile_get_uint(e2fsck_global_ctx->profile, "bitmaps",
801			 "all", 0, type, &type);
802	fs->default_bitmap_type = type ? type : default_type;
803#else
804	fs->default_bitmap_type = default_type;
805#endif
806}
807
808errcode_t e2fsck_allocate_inode_bitmap(ext2_filsys fs, const char *descr,
809				       int deftype,
810				       const char *name,
811				       ext2fs_inode_bitmap *ret)
812{
813	errcode_t	retval;
814	unsigned int	save_type;
815
816	e2fsck_set_bitmap_type(fs, deftype, name, &save_type);
817	retval = ext2fs_allocate_inode_bitmap(fs, descr, ret);
818	fs->default_bitmap_type = save_type;
819	return retval;
820}
821
822errcode_t e2fsck_allocate_block_bitmap(ext2_filsys fs, const char *descr,
823				       int deftype,
824				       const char *name,
825				       ext2fs_block_bitmap *ret)
826{
827	errcode_t	retval;
828	unsigned int	save_type;
829
830	e2fsck_set_bitmap_type(fs, deftype, name, &save_type);
831	retval = ext2fs_allocate_block_bitmap(fs, descr, ret);
832	fs->default_bitmap_type = save_type;
833	return retval;
834}
835
836errcode_t e2fsck_allocate_subcluster_bitmap(ext2_filsys fs, const char *descr,
837					    int deftype,
838					    const char *name,
839					    ext2fs_block_bitmap *ret)
840{
841	errcode_t	retval;
842	unsigned int	save_type;
843
844	e2fsck_set_bitmap_type(fs, deftype, name, &save_type);
845	retval = ext2fs_allocate_subcluster_bitmap(fs, descr, ret);
846	fs->default_bitmap_type = save_type;
847	return retval;
848}
849