Initial checkin of the filefrag program, which reports on how

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

diff --git a/misc/util.c b/misc/util.c
index c4a8c2b..b5e6f94 100644 (file)
--- a/misc/util.c
+++ b/misc/util.c
@@ -9,21 +9,27 @@
  * %End-Header%
  */
 
+#define _LARGEFILE_SOURCE
+#define _LARGEFILE64_SOURCE
+
 #include <stdio.h>
 #include <string.h>
 #ifdef HAVE_ERRNO_H
 #include <errno.h>
 #endif
-#include <linux/ext2_fs.h>
 #ifdef HAVE_LINUX_MAJOR_H
 #include <linux/major.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #endif
 
 #include "et/com_err.h"
 #include "e2p/e2p.h"
+#include "ext2fs/ext2_fs.h"
 #include "ext2fs/ext2fs.h"
 #include "nls-enable.h"
+#include "blkid/blkid.h"
 #include "util.h"
 
 #ifndef HAVE_STRCASECMP
@@ -42,6 +48,20 @@ int strcasecmp (char *s1, char *s2)
 }
 #endif
 
+/*
+ * Given argv[0], return the program name.
+ */
+char *get_progname(char *argv_zero)
+{
+       char    *cp;
+
+       cp = strrchr(argv_zero, '/');
+       if (!cp )
+               return argv_zero;
+       else
+               return cp+1;
+}
+
 void proceed_question(void)
 {
        char buf[256];
@@ -49,7 +69,7 @@ void proceed_question(void)
 
        fflush(stdout);
        fflush(stderr);
-       printf(_("Proceed anyway? (y,n) "));
+       fputs(_("Proceed anyway? (y,n) "), stdout);
        buf[0] = 0;
        fgets(buf, sizeof(buf), stdin);
        if (strchr(short_yes, buf[0]) == 0)
@@ -59,16 +79,22 @@ void proceed_question(void)
 void check_plausibility(const char *device)
 {
        int val;
+#ifdef HAVE_OPEN64
+       struct stat64 s;
+       
+       val = stat64(device, &s);
+#else
        struct stat s;
        
        val = stat(device, &s);
+#endif
        
        if(val == -1) {
                fprintf(stderr, _("Could not stat %s --- %s\n"),
                        device, error_message(errno));
                if (errno == ENOENT)
-                       fprintf(stderr, _("\nThe device apparently does "
-                              "not exist; did you specify it correctly?\n"));
+                       fputs(_("\nThe device apparently does not exist; "
+                               "did you specify it correctly?\n"), stderr);
                exit(1);
        }
        if (!S_ISBLK(s.st_mode)) {
@@ -83,8 +109,20 @@ void check_plausibility(const char *device)
 #define MINOR(dev)     ((dev) & 0xff)
 #endif
 #ifndef SCSI_BLK_MAJOR
+#ifdef SCSI_DISK0_MAJOR
+#ifdef SCSI_DISK8_MAJOR
+#define SCSI_DISK_MAJOR(M) ((M) == SCSI_DISK0_MAJOR || \
+  ((M) >= SCSI_DISK1_MAJOR && (M) <= SCSI_DISK7_MAJOR) || \
+  ((M) >= SCSI_DISK8_MAJOR && (M) <= SCSI_DISK15_MAJOR))
+#else
+#define SCSI_DISK_MAJOR(M) ((M) == SCSI_DISK0_MAJOR || \
+  ((M) >= SCSI_DISK1_MAJOR && (M) <= SCSI_DISK7_MAJOR))
+#endif /* defined(SCSI_DISK8_MAJOR) */
+#define SCSI_BLK_MAJOR(M) (SCSI_DISK_MAJOR((M)) || (M) == SCSI_CDROM_MAJOR)
+#else
 #define SCSI_BLK_MAJOR(M)  ((M) == SCSI_DISK_MAJOR || (M) == SCSI_CDROM_MAJOR)
-#endif
+#endif /* defined(SCSI_DISK0_MAJOR) */
+#endif /* defined(SCSI_BLK_MAJOR) */
        if (((MAJOR(s.st_rdev) == HD_MAJOR &&
              MINOR(s.st_rdev)%64 == 0) ||
             (SCSI_BLK_MAJOR(MAJOR(s.st_rdev)) &&
@@ -113,8 +151,8 @@ void check_mount(const char *device, int force, const char *type)
 
        fprintf(stderr, _("%s is mounted; "), device);
        if (force) {
-               fprintf(stderr, _("mke2fs forced anyway.  "
-                       "Hope /etc/mtab is incorrect.\n"));
+               fputs(_("mke2fs forced anyway.  Hope /etc/mtab is "
+                       "incorrect.\n"), stderr);
        } else {
                fprintf(stderr, _("will not make a %s here!\n"), type);
                exit(1);
@@ -130,8 +168,8 @@ void parse_journal_opts(const char *opts)
        len = strlen(opts);
        buf = malloc(len+1);
        if (!buf) {
-               fprintf(stderr, _("Couldn't allocate memory to parse "
-                       "journal options!\n"));
+               fputs(_("Couldn't allocate memory to parse journal "
+                       "options!\n"), stderr);
                exit(1);
        }
        strcpy(buf, opts);
@@ -152,11 +190,11 @@ void parse_journal_opts(const char *opts)
                       arg ? arg : "NONE");
 #endif
                if (strcmp(token, "device") == 0) {
-                       if (!arg) {
+                       journal_device = blkid_get_devname(NULL, arg, NULL);
+                       if (!journal_device) {
                                journal_usage++;
                                continue;
                        }
-                       journal_device = arg;
                } else if (strcmp(token, "size") == 0) {
                        if (!arg) {
                                journal_usage++;
@@ -172,15 +210,15 @@ void parse_journal_opts(const char *opts)
                        journal_usage++;
        }
        if (journal_usage) {
-               fprintf(stderr, _("\nBad journal options specified.\n\n"
+               fputs(_("\nBad journal options specified.\n\n"
                        "Journal options are separated by commas, "
                        "and may take an argument which\n"
                        "\tis set off by an equals ('=') sign.\n\n"
-                       "Valid raid options are:\n"
+                       "Valid journal options are:\n"
                        "\tsize=<journal size in megabytes>\n"
                        "\tdevice=<journal device>\n\n"
                        "The journal size must be between "
-                       "1024 and 102400 filesystem blocks.\n\n" ));
+                       "1024 and 102400 filesystem blocks.\n\n"), stderr);
                exit(1);
        }
 }      
@@ -194,18 +232,17 @@ void parse_journal_opts(const char *opts)
  * in the filesystem.  For very small filesystems, it is not reasonable to
  * have a journal that fills more than half of the filesystem.
  */
-int figure_journal_size(int journal_size, ext2_filsys fs)
+int figure_journal_size(int size, ext2_filsys fs)
 {
        blk_t j_blocks;
 
        if (fs->super->s_blocks_count < 2048) {
-               fprintf(stderr, _("\nFilesystem too small for a journal\n"));
+               fputs(_("\nFilesystem too small for a journal\n"), stderr);
                return 0;
        }
        
-       if (journal_size >= 0) {
-               j_blocks = journal_size * 1024 /
-                       (fs->blocksize  / 1024);
+       if (size >= 0) {
+               j_blocks = size * 1024 / (fs->blocksize / 1024);
                if (j_blocks < 1024 || j_blocks > 102400) {
                        fprintf(stderr, _("\nThe requested journal "
                                "size is %d blocks; it must be\n"
@@ -215,8 +252,8 @@ int figure_journal_size(int journal_size, ext2_filsys fs)
                        exit(1);
                }
                if (j_blocks > fs->super->s_free_blocks_count) {
-                       fprintf(stderr, _("\nJournal size too big "
-                                         "for filesystem.\n"));
+                       fputs(_("\nJournal size too big for filesystem.\n"),
+                             stderr);
                        exit(1);
                }
                return j_blocks;
@@ -232,3 +269,12 @@ int figure_journal_size(int journal_size, ext2_filsys fs)
        return j_blocks;
 }
 
+void print_check_message(ext2_filsys fs)
+{
+       printf(_("This filesystem will be automatically "
+                "checked every %d mounts or\n"
+                "%g days, whichever comes first.  "
+                "Use tune2fs -c or -i to override.\n"),
+              fs->super->s_max_mnt_count,
+              (double)fs->super->s_checkinterval / (3600 * 24));
+}