ext4: provide wrappers for transaction reservation calls

Reviewed-by: Zheng Liu <wenqing.lz@taobao.com>
Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

diff --git a/fs/ext4/ext4_jbd2.c b/fs/ext4/ext4_jbd2.c
index bd25e78..72a3600 100644 (file)
--- a/fs/ext4/ext4_jbd2.c
+++ b/fs/ext4/ext4_jbd2.c
@@ -38,31 +38,43 @@ static void ext4_put_nojournal(handle_t *handle)
 /*
  * Wrappers for jbd2_journal_start/end.
  */
-handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line,
-                                 int type, int nblocks)
+static int ext4_journal_check_start(struct super_block *sb)
 {
        journal_t *journal;
 
        might_sleep();
-
-       trace_ext4_journal_start(sb, nblocks, _RET_IP_);
        if (sb->s_flags & MS_RDONLY)
-               return ERR_PTR(-EROFS);
-
+               return -EROFS;
        WARN_ON(sb->s_writers.frozen == SB_FREEZE_COMPLETE);
        journal = EXT4_SB(sb)->s_journal;
-       if (!journal)
-               return ext4_get_nojournal();
        /*
         * Special case here: if the journal has aborted behind our
         * backs (eg. EIO in the commit thread), then we still need to
         * take the FS itself readonly cleanly.
         */
-       if (is_journal_aborted(journal)) {
+       if (journal && is_journal_aborted(journal)) {
                ext4_abort(sb, "Detected aborted journal");
-               return ERR_PTR(-EROFS);
+               return -EROFS;
        }
-       return jbd2__journal_start(journal, nblocks, 0, GFP_NOFS, type, line);
+       return 0;
+}
+
+handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line,
+                                 int type, int blocks, int rsv_blocks)
+{
+       journal_t *journal;
+       int err;
+
+       trace_ext4_journal_start(sb, blocks, rsv_blocks, _RET_IP_);
+       err = ext4_journal_check_start(sb);
+       if (err < 0)
+               return ERR_PTR(err);
+
+       journal = EXT4_SB(sb)->s_journal;
+       if (!journal)
+               return ext4_get_nojournal();
+       return jbd2__journal_start(journal, blocks, rsv_blocks, GFP_NOFS,
+                                  type, line);
 }
 
 int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle)
@@ -86,6 +98,30 @@ int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle)
        return err;
 }
 
+handle_t *__ext4_journal_start_reserved(handle_t *handle, unsigned int line,
+                                       int type)
+{
+       struct super_block *sb;
+       int err;
+
+       if (!ext4_handle_valid(handle))
+               return ext4_get_nojournal();
+
+       sb = handle->h_journal->j_private;
+       trace_ext4_journal_start_reserved(sb, handle->h_buffer_credits,
+                                         _RET_IP_);
+       err = ext4_journal_check_start(sb);
+       if (err < 0) {
+               jbd2_journal_free_reserved(handle);
+               return ERR_PTR(err);
+       }
+
+       err = jbd2_journal_start_reserved(handle, type, line);
+       if (err < 0)
+               return ERR_PTR(err);
+       return handle;
+}
+
 void ext4_journal_abort_handle(const char *caller, unsigned int line,
                               const char *err_fn, struct buffer_head *bh,
                               handle_t *handle, int err)

diff --git a/fs/ext4/ext4_jbd2.h b/fs/ext4/ext4_jbd2.h
index c8c6885..fdd865e 100644 (file)
--- a/fs/ext4/ext4_jbd2.h
+++ b/fs/ext4/ext4_jbd2.h
@@ -265,7 +265,7 @@ int __ext4_handle_dirty_super(const char *where, unsigned int line,
        __ext4_handle_dirty_super(__func__, __LINE__, (handle), (sb))
 
 handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line,
-                                 int type, int nblocks);
+                                 int type, int blocks, int rsv_blocks);
 int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle);
 
 #define EXT4_NOJOURNAL_MAX_REF_COUNT ((unsigned long) 4096)
@@ -300,21 +300,37 @@ static inline int ext4_handle_has_enough_credits(handle_t *handle, int needed)
 }
 
 #define ext4_journal_start_sb(sb, type, nblocks)                       \
-       __ext4_journal_start_sb((sb), __LINE__, (type), (nblocks))
+       __ext4_journal_start_sb((sb), __LINE__, (type), (nblocks), 0)
 
 #define ext4_journal_start(inode, type, nblocks)                       \
-       __ext4_journal_start((inode), __LINE__, (type), (nblocks))
+       __ext4_journal_start((inode), __LINE__, (type), (nblocks), 0)
+
+#define ext4_journal_start_with_reserve(inode, type, blocks, rsv_blocks) \
+       __ext4_journal_start((inode), __LINE__, (type), (blocks), (rsv_blocks))
 
 static inline handle_t *__ext4_journal_start(struct inode *inode,
                                             unsigned int line, int type,
-                                            int nblocks)
+                                            int blocks, int rsv_blocks)
 {
-       return __ext4_journal_start_sb(inode->i_sb, line, type, nblocks);
+       return __ext4_journal_start_sb(inode->i_sb, line, type, blocks,
+                                      rsv_blocks);
 }
 
 #define ext4_journal_stop(handle) \
        __ext4_journal_stop(__func__, __LINE__, (handle))
 
+#define ext4_journal_start_reserve(handle, type) \
+       __ext4_journal_start_reserved((handle), __LINE__, (type))
+
+handle_t *__ext4_journal_start_reserved(handle_t *handle, unsigned int line,
+                                       int type);
+
+static inline void ext4_journal_free_reserved(handle_t *handle)
+{
+       if (ext4_handle_valid(handle))
+               jbd2_journal_free_reserved(handle);
+}
+
 static inline handle_t *ext4_journal_current_handle(void)
 {
        return journal_current_handle();

diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 00a818d..f03598c 100644 (file)
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -747,7 +747,8 @@ repeat_in_this_group:
                if (!handle) {
                        BUG_ON(nblocks <= 0);
                        handle = __ext4_journal_start_sb(dir->i_sb, line_no,
-                                                        handle_type, nblocks);
+                                                        handle_type, nblocks,
+                                                        0);
                        if (IS_ERR(handle)) {
                                err = PTR_ERR(handle);
                                ext4_std_error(sb, err);

diff --git a/include/trace/events/ext4.h b/include/trace/events/ext4.h
index e23b218..1f2ea71 100644 (file)
--- a/include/trace/events/ext4.h
+++ b/include/trace/events/ext4.h
@@ -1640,25 +1640,50 @@ TRACE_EVENT(ext4_load_inode,
 );
 
 TRACE_EVENT(ext4_journal_start,
-       TP_PROTO(struct super_block *sb, int nblocks, unsigned long IP),
+       TP_PROTO(struct super_block *sb, int blocks, int rsv_blocks,
+                unsigned long IP),
 
-       TP_ARGS(sb, nblocks, IP),
+       TP_ARGS(sb, blocks, rsv_blocks, IP),
 
        TP_STRUCT__entry(
                __field(        dev_t,  dev                     )
                __field(unsigned long,  ip                      )
-               __field(        int,    nblocks                 )
+               __field(          int,  blocks                  )
+               __field(          int,  rsv_blocks              )
        ),
 
        TP_fast_assign(
-               __entry->dev     = sb->s_dev;
-               __entry->ip      = IP;
-               __entry->nblocks = nblocks;
+               __entry->dev             = sb->s_dev;
+               __entry->ip              = IP;
+               __entry->blocks          = blocks;
+               __entry->rsv_blocks      = rsv_blocks;
        ),
 
-       TP_printk("dev %d,%d nblocks %d caller %pF",
+       TP_printk("dev %d,%d blocks, %d rsv_blocks, %d caller %pF",
                  MAJOR(__entry->dev), MINOR(__entry->dev),
-                 __entry->nblocks, (void *)__entry->ip)
+                 __entry->blocks, __entry->rsv_blocks, (void *)__entry->ip)
+);
+
+TRACE_EVENT(ext4_journal_start_reserved,
+       TP_PROTO(struct super_block *sb, int blocks, unsigned long IP),
+
+       TP_ARGS(sb, blocks, IP),
+
+       TP_STRUCT__entry(
+               __field(        dev_t,  dev                     )
+               __field(unsigned long,  ip                      )
+               __field(          int,  blocks                  )
+       ),
+
+       TP_fast_assign(
+               __entry->dev             = sb->s_dev;
+               __entry->ip              = IP;
+               __entry->blocks          = blocks;
+       ),
+
+       TP_printk("dev %d,%d blocks, %d caller %pF",
+                 MAJOR(__entry->dev), MINOR(__entry->dev),
+                 __entry->blocks, (void *)__entry->ip)
 );
 
 DECLARE_EVENT_CLASS(ext4__trim,