mke2fs: skip zeroing journal blocks

Add the ability to skip zeroing journal blocks on disk.  This can
significantly speed up mke2fs with large journals.  At worst the
uninitialized journal is only a very short-term risk (if at all),
because the journal will be overwritten on any new filesystem as
soon as any significant amount of data is written to disk, and
the new journal TID would need to match the offset/TID of an old
commit block still left on disk.

Signed-off-by: Andreas Dilger <adilger@whamcloud.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>

diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h
index c4d262f0f61e3af30f3167939e1392423d69f975..ee7e3c2667b147370be3ccf6e24898315e703619 100644 (file)
--- a/lib/ext2fs/ext2fs.h
+++ b/lib/ext2fs/ext2fs.h
@@ -204,10 +204,9 @@ typedef struct ext2_file *ext2_file_t;
 
 /*
  * Flags for mkjournal
- *
- * EXT2_MKJOURNAL_V1_SUPER     Make a (deprecated) V1 journal superblock
  */
-#define EXT2_MKJOURNAL_V1_SUPER        0x0000001
+#define EXT2_MKJOURNAL_V1_SUPER        0x0000001 /* create V1 superblock (deprecated) */
+#define EXT2_MKJOURNAL_LAZYINIT        0x0000002 /* don't zero journal inode before use*/
 
 struct opaque_ext2_group_desc;
 

diff --git a/lib/ext2fs/mkjournal.c b/lib/ext2fs/mkjournal.c
index e5060f40fa1504339f1e74ee308275163a7890e6..5113ced843ceffce0b023b98640f6629928b82f7 100644 (file)
--- a/lib/ext2fs/mkjournal.c
+++ b/lib/ext2fs/mkjournal.c
@@ -104,7 +104,7 @@ static errcode_t write_journal_file(ext2_filsys fs, char *filename,
        /* Open the device or journal file */
        if ((fd = open(filename, O_WRONLY)) < 0) {
                retval = errno;
-               goto errout;
+               goto errfree;
        }
 
        /* Write the superblock out */
@@ -118,6 +118,9 @@ static errcode_t write_journal_file(ext2_filsys fs, char *filename,
                goto errout;
        memset(buf, 0, fs->blocksize);
 
+       if (flags & EXT2_MKJOURNAL_LAZYINIT)
+               goto success;
+
        for (i = 1; i < num_blocks; i++) {
                ret_size = write(fd, buf, fs->blocksize);
                if (ret_size < 0) {
@@ -127,10 +130,12 @@ static errcode_t write_journal_file(ext2_filsys fs, char *filename,
                if (ret_size != (int) fs->blocksize)
                        goto errout;
        }
-       close(fd);
 
+success:
        retval = 0;
 errout:
+       close(fd);
+errfree:
        ext2fs_free_mem(&buf);
        return retval;
 }
@@ -214,6 +219,7 @@ struct mkjournal_struct {
        blk64_t         goal;
        blk64_t         blk_to_zero;
        int             zero_count;
+       int             flags;
        char            *buf;
        errcode_t       err;
 };
@@ -251,7 +257,7 @@ static int mkjournal_proc(ext2_filsys       fs,
        retval = 0;
        if (blockcnt <= 0)
                retval = io_channel_write_blk64(fs->io, new_blk, 1, es->buf);
-       else {
+       else if (!(es->flags & EXT2_MKJOURNAL_LAZYINIT)) {
                if (es->zero_count) {
                        if ((es->blk_to_zero + es->zero_count == new_blk) &&
                            (es->zero_count < 1024))
@@ -317,6 +323,7 @@ static errcode_t write_journal_inode(ext2_filsys fs, ext2_ino_t journal_ino,
        es.newblocks = 0;
        es.buf = buf;
        es.err = 0;
+       es.flags = flags;
        es.zero_count = 0;
 
        if (fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS) {
@@ -519,6 +526,13 @@ errcode_t ext2fs_add_journal_inode(ext2_filsys fs, blk_t num_blocks, int flags)
                if ((fd = open(jfile, O_CREAT|O_WRONLY, 0600)) < 0)
                        return errno;
 
+               /* Note that we can't do lazy journal initialization for mounted
+                * filesystems, since the zero writing is also allocating the
+                * journal blocks.  We could use fallocate, but not all kernels
+                * support that, and creating a journal on a mounted ext2
+                * filesystems is extremely rare these days...  Ignore it. */
+               flags &= ~EXT2_MKJOURNAL_LAZYINIT;
+
                if ((retval = write_journal_file(fs, jfile, num_blocks, flags)))
                        goto errout;
 

diff --git a/misc/mke2fs.8.in b/misc/mke2fs.8.in
index 4a3b0c38089dfd5b94ff5ccdd46bafc8beefcfe9..0d4b046a160bed7755ae54a3134a0c5680b694c9 100644 (file)
--- a/misc/mke2fs.8.in
+++ b/misc/mke2fs.8.in
@@ -232,7 +232,15 @@ This speeds up filesystem
 initialization noticeably, but it requires the kernel to finish
 initializing the filesystem in the background when the filesystem is
 first mounted.  If the option value is omitted, it defaults to 1 to
-enable lazy inode table initialization.
+enable lazy inode table zeroing.
+.TP
+.B lazy_journal_init\fR[\fB= \fI<0 to disable, 1 to enable>\fR]
+If enabled, the journal inode will not be fully zeroed out by
+.BR mke2fs .
+This speeds up filesystem initialization noticeably, but carries some
+small risk if the system crashes before the journal has been overwritten
+entirely one time.  If the option value is omitted, it defaults to 1 to
+enable lazy journal inode zeroing.
 .TP
 .B test_fs
 Set a flag in the filesystem superblock indicating that it may be

diff --git a/misc/mke2fs.c b/misc/mke2fs.c
index a246ec18cce6152f8e102e82c2380d13c73d1e98..5ff3f9fe5fa395a08358c7373e8be522e77b2d94 100644 (file)
--- a/misc/mke2fs.c
+++ b/misc/mke2fs.c
@@ -503,6 +503,10 @@ static void create_journal_dev(ext2_filsys fs)
                        _("while initializing journal superblock"));
                exit(1);
        }
+
+       if (journal_flags & EXT2_MKJOURNAL_LAZYINIT)
+               goto write_superblock;
+
        ext2fs_numeric_progress_init(fs, &progress,
                                     _("Zeroing journal device: "),
                                     ext2fs_blocks_count(fs->super));
@@ -527,6 +531,8 @@ static void create_journal_dev(ext2_filsys fs)
        }
        ext2fs_zero_blocks2(0, 0, 0, 0, 0);
 
+       ext2fs_numeric_progress_close(fs, &progress, NULL);
+write_superblock:
        retval = io_channel_write_blk64(fs->io,
                                        fs->super->s_first_data_block+1,
                                        1, buf);
@@ -535,7 +541,6 @@ static void create_journal_dev(ext2_filsys fs)
                        _("while writing journal superblock"));
                exit(1);
        }
-       ext2fs_numeric_progress_close(fs, &progress, NULL);
 }
 
 static void show_stats(ext2_filsys fs)
@@ -762,6 +767,12 @@ static void parse_extended_opts(struct ext2_super_block *param,
                                lazy_itable_init = strtoul(arg, &p, 0);
                        else
                                lazy_itable_init = 1;
+               } else if (!strcmp(token, "lazy_journal_init")) {
+                       if (arg)
+                               journal_flags |= strtoul(arg, &p, 0) ?
+                                               EXT2_MKJOURNAL_LAZYINIT : 0;
+                       else
+                               journal_flags |= EXT2_MKJOURNAL_LAZYINIT;
                } else if (!strcmp(token, "discard")) {
                        discard = 1;
                } else if (!strcmp(token, "nodiscard")) {
@@ -781,6 +792,7 @@ static void parse_extended_opts(struct ext2_super_block *param,
                        "\tstripe-width=<RAID stride * data disks in blocks>\n"
                        "\tresize=<resize maximum size in blocks>\n"
                        "\tlazy_itable_init=<0 to disable, 1 to enable>\n"
+                       "\tlazy_journal_init=<0 to disable, 1 to enable>\n"
                        "\ttest_fs\n"
                        "\tdiscard\n"
                        "\tnodiscard\n\n"),
@@ -1821,6 +1833,9 @@ profile_error:
                                                 "lazy_itable_init",
                                                 lazy_itable_init);
        discard = get_bool_from_profile(fs_types, "discard" , discard);
+       journal_flags |= get_bool_from_profile(fs_types,
+                                              "lazy_journal_init", 0) ?
+                                              EXT2_MKJOURNAL_LAZYINIT : 0;
 
        /* Get options from profile */
        for (cpp = fs_types; *cpp; cpp++) {