e2fsck: Fix handling of non-zero i_blocks_high field

[tools/e2fsprogs.git] / e2fsck / util.c

diff --git a/e2fsck/util.c b/e2fsck/util.c
index 256100c..56c6b35 100644 (file)
--- a/e2fsck/util.c
+++ b/e2fsck/util.c
@@ -10,9 +10,13 @@
  */
 
 #include <stdlib.h>
+#include <stdio.h>
 #include <unistd.h>
 #include <string.h>
 #include <ctype.h>
+#ifdef __linux__
+#include <sys/utsname.h>
+#endif
 
 #ifdef HAVE_CONIO_H
 #undef HAVE_TERMIOS_H
@@ -22,7 +26,6 @@
 #ifdef HAVE_TERMIOS_H
 #include <termios.h>
 #endif
-#include <stdio.h>
 #endif
 
 #ifdef HAVE_MALLOC_H
@@ -63,7 +66,7 @@ void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size,
        char buf[256];
 
 #ifdef DEBUG_ALLOCATE_MEMORY
-       printf("Allocating %d bytes for %s...\n", size, description);
+       printf("Allocating %u bytes for %s...\n", size, description);
 #endif
        ret = malloc(size);
        if (!ret) {
@@ -257,6 +260,7 @@ void preenhalt(e2fsck_t ctx)
        fprintf(stderr, _("\n\n%s: UNEXPECTED INCONSISTENCY; "
                "RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n"),
               ctx->device_name);
+       ctx->flags |= E2F_FLAG_EXITING;
        if (fs != NULL) {
                fs->super->s_state |= EXT2_ERROR_FS;
                ext2fs_mark_super_dirty(fs);
@@ -309,8 +313,8 @@ static _INLINE_ float timeval_subtract(struct timeval *tv1,
                ((float) (tv1->tv_usec - tv2->tv_usec)) / 1000000);
 }
 
-void print_resource_track(const char *desc, struct resource_track *track,
-                         io_channel channel)
+void print_resource_track(e2fsck_t ctx, const char *desc,
+                         struct resource_track *track, io_channel channel)
 {
 #ifdef HAVE_GETRUSAGE
        struct rusage r;
@@ -320,21 +324,27 @@ void print_resource_track(const char *desc, struct resource_track *track,
 #endif
        struct timeval time_end;
 
+       if ((desc && !(ctx->options & E2F_OPT_TIME2)) ||
+           (!desc && !(ctx->options & E2F_OPT_TIME)))
+               return;
+
+       e2fsck_clear_progbar(ctx);
        gettimeofday(&time_end, 0);
 
        if (desc)
                printf("%s: ", desc);
 
 #ifdef HAVE_MALLINFO
-#define kbytes(x)      (((x) + 1023) / 1024)
+#define kbytes(x)      (((unsigned long)(x) + 1023) / 1024)
 
        malloc_info = mallinfo();
-       printf(_("Memory used: %dk/%dk (%dk/%dk), "),
+       printf(_("Memory used: %luk/%luk (%luk/%luk), "),
               kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd),
               kbytes(malloc_info.uordblks), kbytes(malloc_info.fordblks));
 #else
-       printf(_("Memory used: %d, "),
-              (int) (((char *) sbrk(0)) - ((char *) track->brk_start)));
+       printf(_("Memory used: %lu, "),
+              (unsigned long) (((char *) sbrk(0)) - 
+                               ((char *) track->brk_start)));
 #endif
 #ifdef HAVE_GETRUSAGE
        getrusage(RUSAGE_SELF, &r);
@@ -378,7 +388,7 @@ void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino,
        retval = ext2fs_read_inode(ctx->fs, ino, inode);
        if (retval) {
                com_err("ext2fs_read_inode", retval,
-                       _("while reading inode %ld in %s"), ino, proc);
+                       _("while reading inode %lu in %s"), ino, proc);
                fatal_error(ctx, 0);
        }
 }
@@ -392,7 +402,7 @@ void e2fsck_read_inode_full(e2fsck_t ctx, unsigned long ino,
        retval = ext2fs_read_inode_full(ctx->fs, ino, inode, bufsize);
        if (retval) {
                com_err("ext2fs_read_inode_full", retval,
-                       _("while reading inode %ld in %s"), ino, proc);
+                       _("while reading inode %lu in %s"), ino, proc);
                fatal_error(ctx, 0);
        }
 }
@@ -406,7 +416,7 @@ extern void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino,
        retval = ext2fs_write_inode_full(ctx->fs, ino, inode, bufsize);
        if (retval) {
                com_err("ext2fs_write_inode", retval,
-                       _("while writing inode %ld in %s"), ino, proc);
+                       _("while writing inode %lu in %s"), ino, proc);
                fatal_error(ctx, 0);
        }
 }
@@ -419,7 +429,7 @@ extern void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino,
        retval = ext2fs_write_inode(ctx->fs, ino, inode);
        if (retval) {
                com_err("ext2fs_write_inode", retval,
-                       _("while writing inode %ld in %s"), ino, proc);
+                       _("while writing inode %lu in %s"), ino, proc);
                fatal_error(ctx, 0);
        }
 }
@@ -593,3 +603,109 @@ errcode_t e2fsck_zero_blocks(ext2_filsys fs, blk_t blk, int num,
        }
        return 0;
 }
+
+/*
+ * Check to see if a filesystem is in /proc/filesystems.
+ * Returns 1 if found, 0 if not
+ */
+int fs_proc_check(const char *fs_name)
+{
+       FILE    *f;
+       char    buf[80], *cp, *t;
+
+       f = fopen("/proc/filesystems", "r");
+       if (!f)
+               return (0);
+       while (!feof(f)) {
+               if (!fgets(buf, sizeof(buf), f))
+                       break;
+               cp = buf;
+               if (!isspace(*cp)) {
+                       while (*cp && !isspace(*cp))
+                               cp++;
+               }
+               while (*cp && isspace(*cp))
+                       cp++;
+               if ((t = strchr(cp, '\n')) != NULL)
+                       *t = 0;
+               if ((t = strchr(cp, '\t')) != NULL)
+                       *t = 0;
+               if ((t = strchr(cp, ' ')) != NULL)
+                       *t = 0;
+               if (!strcmp(fs_name, cp)) {
+                       fclose(f);
+                       return (1);
+               }
+       }
+       fclose(f);
+       return (0);
+}
+
+/*
+ * Check to see if a filesystem is available as a module
+ * Returns 1 if found, 0 if not
+ */
+int check_for_modules(const char *fs_name)
+{
+#ifdef __linux__
+       struct utsname  uts;
+       FILE            *f;
+       char            buf[1024], *cp, *t;
+       int             i;
+
+       if (uname(&uts))
+               return (0);
+       snprintf(buf, sizeof(buf), "/lib/modules/%s/modules.dep", uts.release);
+
+       f = fopen(buf, "r");
+       if (!f)
+               return (0);
+       while (!feof(f)) {
+               if (!fgets(buf, sizeof(buf), f))
+                       break;
+               if ((cp = strchr(buf, ':')) != NULL)
+                       *cp = 0;
+               else
+                       continue;
+               if ((cp = strrchr(buf, '/')) != NULL)
+                       cp++;
+               else
+                       cp = buf;
+               i = strlen(cp);
+               if (i > 3) {
+                       t = cp + i - 3;
+                       if (!strcmp(t, ".ko"))
+                               *t = 0;
+               }
+               if (!strcmp(cp, fs_name)) {
+                       fclose(f);
+                       return (1);
+               }
+       }
+       fclose(f);
+#endif /* __linux__ */
+       return (0);
+}
+
+/*
+ * Helper function that does the right thing if write returns a
+ * partial write, or an EGAIN/EINTR error.
+ */
+int write_all(int fd, char *buf, size_t count)
+{
+       ssize_t ret;
+       int c = 0;
+
+       while (count > 0) {
+               ret = write(fd, buf, count);
+               if (ret < 0) {
+                       if ((errno == EAGAIN) || (errno == EINTR))
+                               continue;
+                       return -1;
+               }
+               count -= ret;
+               buf += ret;
+               c += ret;
+       }
+       return c;
+}