ext4: Allow ext4 to run without a journal

A few weeks ago I posted a patch for discussion that allowed ext4 to run
without a journal.  Since that time I've integrated the excellent
comments from Andreas and fixed several serious bugs.  We're currently
running with this patch and generating some performance numbers against
both ext2 (with backported reservations code) and ext4 with and without
a journal.  It just so happens that running without a journal is
slightly faster for most everything.

We did
	iozone -T -t 4 s 2g -r 256k -T -I -i0 -i1 -i2

which creates 4 threads, each of which create and do reads and writes on
a 2G file, with a buffer size of 256K, using O_DIRECT for all file opens
to bypass the page cache.  Results:

                     ext2        ext4, default   ext4, no journal
  initial writes   13.0 MB/s        15.4 MB/s          15.7 MB/s
  rewrites         13.1 MB/s        15.6 MB/s          15.9 MB/s
  reads            15.2 MB/s        16.9 MB/s          17.2 MB/s
  re-reads         15.3 MB/s        16.9 MB/s          17.2 MB/s
  random readers    5.6 MB/s         5.6 MB/s           5.7 MB/s
  random writers    5.1 MB/s         5.3 MB/s           5.4 MB/s 

So it seems that, so far, this was a useful exercise.

Signed-off-by: Frank Mayhar <fmayhar@google.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

1 files changed, 68 insertions, 15 deletions

diff --git a/fs/ext4/ext4_jbd2.h b/fs/ext4/ext4_jbd2.h
index b455c685a98b..663197adae56 100644
--- a/fs/ext4/ext4_jbd2.h
+++ b/fs/ext4/ext4_jbd2.h
@@ -122,12 +122,6 @@ int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode);
  * been done yet.
  */
 
-static inline void ext4_journal_release_buffer(handle_t *handle,
-                                                struct buffer_head *bh)
-{
-        jbd2_journal_release_buffer(handle, bh);
-}
-
 void ext4_journal_abort_handle(const char *caller, const char *err_fn,
                 struct buffer_head *bh, handle_t *handle, int err);
 
@@ -146,8 +140,8 @@ int __ext4_journal_revoke(const char *where, handle_t *handle,
 int __ext4_journal_get_create_access(const char *where,
                                 handle_t *handle, struct buffer_head *bh);
 
-int __ext4_journal_dirty_metadata(const char *where,
-                                handle_t *handle, struct buffer_head *bh);
+int __ext4_handle_dirty_metadata(const char *where, handle_t *handle,
+                                 struct inode *inode, struct buffer_head *bh);
 
 #define ext4_journal_get_undo_access(handle, bh) \
         __ext4_journal_get_undo_access(__func__, (handle), (bh))
@@ -157,14 +151,57 @@ int __ext4_journal_dirty_metadata(const char *where,
         __ext4_journal_revoke(__func__, (handle), (blocknr), (bh))
 #define ext4_journal_get_create_access(handle, bh) \
         __ext4_journal_get_create_access(__func__, (handle), (bh))
-#define ext4_journal_dirty_metadata(handle, bh) \
-        __ext4_journal_dirty_metadata(__func__, (handle), (bh))
 #define ext4_journal_forget(handle, bh) \
         __ext4_journal_forget(__func__, (handle), (bh))
+#define ext4_handle_dirty_metadata(handle, inode, bh) \
+        __ext4_handle_dirty_metadata(__func__, (handle), (inode), (bh))
 
 handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks);
 int __ext4_journal_stop(const char *where, handle_t *handle);
 
+#define EXT4_NOJOURNAL_HANDLE   ((handle_t *) 0x1)
+
+static inline int ext4_handle_valid(handle_t *handle)
+{
+        if (handle == EXT4_NOJOURNAL_HANDLE)
+                return 0;
+        return 1;
+}
+
+static inline void ext4_handle_sync(handle_t *handle)
+{
+        if (ext4_handle_valid(handle))
+                handle->h_sync = 1;
+}
+
+static inline void ext4_handle_release_buffer(handle_t *handle,
+                                                struct buffer_head *bh)
+{
+        if (ext4_handle_valid(handle))
+                jbd2_journal_release_buffer(handle, bh);
+}
+
+static inline int ext4_handle_is_aborted(handle_t *handle)
+{
+        if (ext4_handle_valid(handle))
+                return is_handle_aborted(handle);
+        return 0;
+}
+
+static inline int ext4_handle_has_enough_credits(handle_t *handle, int needed)
+{
+        if (ext4_handle_valid(handle) && handle->h_buffer_credits < needed)
+                return 0;
+        return 1;
+}
+
+static inline void ext4_journal_release_buffer(handle_t *handle,
+                                                struct buffer_head *bh)
+{
+        if (ext4_handle_valid(handle))
+                jbd2_journal_release_buffer(handle, bh);
+}
+
 static inline handle_t *ext4_journal_start(struct inode *inode, int nblocks)
 {
         return ext4_journal_start_sb(inode->i_sb, nblocks);
@@ -180,27 +217,37 @@ static inline handle_t *ext4_journal_current_handle(void)
 
 static inline int ext4_journal_extend(handle_t *handle, int nblocks)
 {
-        return jbd2_journal_extend(handle, nblocks);
+        if (ext4_handle_valid(handle))
+                return jbd2_journal_extend(handle, nblocks);
+        return 0;
 }
 
 static inline int ext4_journal_restart(handle_t *handle, int nblocks)
 {
-        return jbd2_journal_restart(handle, nblocks);
+        if (ext4_handle_valid(handle))
+                return jbd2_journal_restart(handle, nblocks);
+        return 0;
 }
 
 static inline int ext4_journal_blocks_per_page(struct inode *inode)
 {
-        return jbd2_journal_blocks_per_page(inode);
+        if (EXT4_JOURNAL(inode) != NULL)
+                return jbd2_journal_blocks_per_page(inode);
+        return 0;
 }
 
 static inline int ext4_journal_force_commit(journal_t *journal)
 {
-        return jbd2_journal_force_commit(journal);
+        if (journal)
+                return jbd2_journal_force_commit(journal);
+        return 0;
 }
 
 static inline int ext4_jbd2_file_inode(handle_t *handle, struct inode *inode)
 {
-        return jbd2_journal_file_inode(handle, &EXT4_I(inode)->jinode);
+        if (ext4_handle_valid(handle))
+                return jbd2_journal_file_inode(handle, &EXT4_I(inode)->jinode);
+        return 0;
 }
 
 /* super.c */
@@ -208,6 +255,8 @@ int ext4_force_commit(struct super_block *sb);
 
 static inline int ext4_should_journal_data(struct inode *inode)
 {
+        if (EXT4_JOURNAL(inode) == NULL)
+                return 0;
         if (!S_ISREG(inode->i_mode))
                 return 1;
         if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
@@ -219,6 +268,8 @@ static inline int ext4_should_journal_data(struct inode *inode)
 
 static inline int ext4_should_order_data(struct inode *inode)
 {
+        if (EXT4_JOURNAL(inode) == NULL)
+                return 0;
         if (!S_ISREG(inode->i_mode))
                 return 0;
         if (EXT4_I(inode)->i_flags & EXT4_JOURNAL_DATA_FL)
@@ -230,6 +281,8 @@ static inline int ext4_should_order_data(struct inode *inode)
 
 static inline int ext4_should_writeback_data(struct inode *inode)
 {
+        if (EXT4_JOURNAL(inode) == NULL)
+                return 0;
         if (!S_ISREG(inode->i_mode))
                 return 0;
         if (EXT4_I(inode)->i_flags & EXT4_JOURNAL_DATA_FL)