2 * util.c --- miscellaneous utilities
4 * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
7 * This file may be redistributed under the terms of the GNU Public
20 #define read_a_char() getch()
34 extern e2fsck_t e2fsck_global_ctx; /* Try your very best not to use this! */
37 #include <sys/resource.h>
39 void fatal_error(e2fsck_t ctx, const char *msg)
42 fprintf (stderr, "e2fsck: %s\n", msg);
43 if (ctx->fs && ctx->fs->io) {
44 if (ctx->fs->io->magic == EXT2_ET_MAGIC_IO_CHANNEL)
45 io_channel_flush(ctx->fs->io);
47 fprintf(stderr, "e2fsck: io manager magic bad!\n");
49 ctx->flags |= E2F_FLAG_ABORT;
50 if (ctx->flags & E2F_FLAG_SETJMP_OK)
51 longjmp(ctx->abort_loc, 1);
55 void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size,
56 const char *description)
61 #ifdef DEBUG_ALLOCATE_MEMORY
62 printf("Allocating %d bytes for %s...\n", size, description);
66 sprintf(buf, "Can't allocate %s\n", description);
67 fatal_error(ctx, buf);
73 char *string_copy(e2fsck_t ctx EXT2FS_ATTR((unused)),
74 const char *str, int len)
84 strncpy(ret, str, len);
92 * Incredibly, libc5 doesn't appear to have strnlen. So we have to
95 int e2fsck_strnlen(const char * s, int count)
99 while (count-- && *cp)
106 static int read_a_char(void)
113 if (e2fsck_global_ctx &&
114 (e2fsck_global_ctx->flags & E2F_FLAG_CANCEL)) {
127 int ask_yn(const char * string, int def)
131 const char *short_yes = _("yY");
132 const char *short_no = _("nN");
134 #ifdef HAVE_TERMIOS_H
135 struct termios termios, tmp;
137 tcgetattr (0, &termios);
139 tmp.c_lflag &= ~(ICANON | ECHO);
142 tcsetattr (0, TCSANOW, &tmp);
146 defstr = _(_("<y>"));
148 defstr = _(_("<n>"));
150 defstr = _(" (y/n)");
151 printf("%s%s? ", string, defstr);
154 if ((c = read_a_char()) == EOF)
157 #ifdef HAVE_TERMIOS_H
158 tcsetattr (0, TCSANOW, &termios);
160 if (e2fsck_global_ctx &&
161 e2fsck_global_ctx->flags & E2F_FLAG_SETJMP_OK) {
163 longjmp(e2fsck_global_ctx->abort_loc, 1);
165 puts(_("cancelled!\n"));
168 if (strchr(short_yes, (char) c)) {
172 else if (strchr(short_no, (char) c)) {
176 else if ((c == ' ' || c == '\n') && (def != -1))
183 #ifdef HAVE_TERMIOS_H
184 tcsetattr (0, TCSANOW, &termios);
189 int ask (e2fsck_t ctx, const char * string, int def)
191 if (ctx->options & E2F_OPT_NO) {
192 printf (_("%s? no\n\n"), string);
195 if (ctx->options & E2F_OPT_YES) {
196 printf (_("%s? yes\n\n"), string);
199 if (ctx->options & E2F_OPT_PREEN) {
200 printf ("%s? %s\n\n", string, def ? _("yes") : _("no"));
203 return ask_yn(string, def);
206 void e2fsck_read_bitmaps(e2fsck_t ctx)
208 ext2_filsys fs = ctx->fs;
212 if (ctx->invalid_bitmaps) {
213 com_err(ctx->program_name, 0,
214 _("e2fsck_read_bitmaps: illegal bitmap block(s) for %s"),
219 old_op = ehandler_operation(_("reading inode and block bitmaps"));
220 retval = ext2fs_read_bitmaps(fs);
221 ehandler_operation(old_op);
223 com_err(ctx->program_name, retval,
224 _("while retrying to read bitmaps for %s"),
230 void e2fsck_write_bitmaps(e2fsck_t ctx)
232 ext2_filsys fs = ctx->fs;
236 if (ext2fs_test_bb_dirty(fs)) {
237 old_op = ehandler_operation(_("writing block bitmaps"));
238 retval = ext2fs_write_block_bitmap(fs);
239 ehandler_operation(old_op);
241 com_err(ctx->program_name, retval,
242 _("while retrying to write block bitmaps for %s"),
248 if (ext2fs_test_ib_dirty(fs)) {
249 old_op = ehandler_operation(_("writing inode bitmaps"));
250 retval = ext2fs_write_inode_bitmap(fs);
251 ehandler_operation(old_op);
253 com_err(ctx->program_name, retval,
254 _("while retrying to write inode bitmaps for %s"),
261 void preenhalt(e2fsck_t ctx)
263 ext2_filsys fs = ctx->fs;
265 if (!(ctx->options & E2F_OPT_PREEN))
267 fprintf(stderr, _("\n\n%s: UNEXPECTED INCONSISTENCY; "
268 "RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n"),
271 fs->super->s_state |= EXT2_ERROR_FS;
272 ext2fs_mark_super_dirty(fs);
275 exit(FSCK_UNCORRECTED);
278 #ifdef RESOURCE_TRACK
279 void init_resource_track(struct resource_track *track)
281 #ifdef HAVE_GETRUSAGE
285 track->brk_start = sbrk(0);
286 gettimeofday(&track->time_start, 0);
287 #ifdef HAVE_GETRUSAGE
289 memset(&r, 0, sizeof(struct rusage));
291 getrusage(RUSAGE_SELF, &r);
292 track->user_start = r.ru_utime;
293 track->system_start = r.ru_stime;
295 track->user_start.tv_sec = track->user_start.tv_usec = 0;
296 track->system_start.tv_sec = track->system_start.tv_usec = 0;
301 #define _INLINE_ __inline__
306 static _INLINE_ float timeval_subtract(struct timeval *tv1,
309 return ((tv1->tv_sec - tv2->tv_sec) +
310 ((float) (tv1->tv_usec - tv2->tv_usec)) / 1000000);
313 void print_resource_track(const char *desc, struct resource_track *track)
315 #ifdef HAVE_GETRUSAGE
319 struct mallinfo malloc_info;
321 struct timeval time_end;
323 gettimeofday(&time_end, 0);
326 printf("%s: ", desc);
329 #define kbytes(x) (((x) + 1023) / 1024)
331 malloc_info = mallinfo();
332 printf(_("Memory used: %dk/%dk (%dk/%dk), "),
333 kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd),
334 kbytes(malloc_info.uordblks), kbytes(malloc_info.fordblks));
336 printf(_("Memory used: %d, "),
337 (int) (((char *) sbrk(0)) - ((char *) track->brk_start)));
339 #ifdef HAVE_GETRUSAGE
340 getrusage(RUSAGE_SELF, &r);
342 printf(_("time: %5.2f/%5.2f/%5.2f\n"),
343 timeval_subtract(&time_end, &track->time_start),
344 timeval_subtract(&r.ru_utime, &track->user_start),
345 timeval_subtract(&r.ru_stime, &track->system_start));
347 printf(_("elapsed time: %6.3f\n"),
348 timeval_subtract(&time_end, &track->time_start));
351 #endif /* RESOURCE_TRACK */
353 void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino,
354 struct ext2_inode * inode, const char *proc)
358 retval = ext2fs_read_inode(ctx->fs, ino, inode);
360 com_err("ext2fs_read_inode", retval,
361 _("while reading inode %ld in %s"), ino, proc);
366 extern void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino,
367 struct ext2_inode * inode, int bufsize,
372 retval = ext2fs_write_inode_full(ctx->fs, ino, inode, bufsize);
374 com_err("ext2fs_write_inode", retval,
375 _("while writing inode %ld in %s"), ino, proc);
380 extern void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino,
381 struct ext2_inode * inode, const char *proc)
385 retval = ext2fs_write_inode(ctx->fs, ino, inode);
387 com_err("ext2fs_write_inode", retval,
388 _("while writing inode %ld in %s"), ino, proc);
394 void mtrace_print(char *mesg)
396 FILE *malloc_get_mallstream();
397 FILE *f = malloc_get_mallstream();
400 fprintf(f, "============= %s\n", mesg);
404 blk_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs, const char *name,
407 struct ext2_super_block *sb;
408 io_channel io = NULL;
411 blk_t superblock, ret_sb = 8193;
413 if (fs && fs->super) {
414 ret_sb = (fs->super->s_blocks_per_group +
415 fs->super->s_first_data_block);
417 ctx->superblock = ret_sb;
418 ctx->blocksize = fs->blocksize;
424 if (ctx->blocksize) {
425 ret_sb = ctx->blocksize * 8;
426 if (ctx->blocksize == 1024)
428 ctx->superblock = ret_sb;
431 ctx->superblock = ret_sb;
432 ctx->blocksize = 1024;
435 if (!name || !manager)
438 if (manager->open(name, 0, &io) != 0)
441 if (ext2fs_get_mem(SUPERBLOCK_SIZE, &buf))
443 sb = (struct ext2_super_block *) buf;
445 for (blocksize = EXT2_MIN_BLOCK_SIZE;
446 blocksize <= EXT2_MAX_BLOCK_SIZE ; blocksize *= 2) {
447 superblock = blocksize*8;
448 if (blocksize == 1024)
450 io_channel_set_blksize(io, blocksize);
451 if (io_channel_read_blk(io, superblock,
452 -SUPERBLOCK_SIZE, buf))
454 #ifdef EXT2FS_ENABLE_SWAPFS
455 if (sb->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
456 ext2fs_swap_super(sb);
458 if ((sb->s_magic == EXT2_SUPER_MAGIC) &&
459 (EXT2_BLOCK_SIZE(sb) == blocksize)) {
462 ctx->superblock = superblock;
463 ctx->blocksize = blocksize;
471 io_channel_close(io);
473 ext2fs_free_mem(&buf);
478 * Given a mode, return the ext2 file type
480 int ext2_file_type(unsigned int mode)
482 if (LINUX_S_ISREG(mode))
483 return EXT2_FT_REG_FILE;
485 if (LINUX_S_ISDIR(mode))
488 if (LINUX_S_ISCHR(mode))
489 return EXT2_FT_CHRDEV;
491 if (LINUX_S_ISBLK(mode))
492 return EXT2_FT_BLKDEV;
494 if (LINUX_S_ISLNK(mode))
495 return EXT2_FT_SYMLINK;
497 if (LINUX_S_ISFIFO(mode))
500 if (LINUX_S_ISSOCK(mode))