fs/ext4/ext4_jbd2.c

   1 /*
   2  * Interface between ext4 and JBD
   3  */
   4
   5 #include "ext4_jbd2.h"
   6
   7 int __ext4_journal_get_undo_access(const char *where, handle_t *handle,
   8                                 struct buffer_head *bh)
   9 {
  10         int err = 0;
  11
  12         if (ext4_handle_valid(handle)) {
  13                 err = jbd2_journal_get_undo_access(handle, bh);
  14                 if (err)
  15                         ext4_journal_abort_handle(where, __func__, bh,
  16                                                   handle, err);
  17         }
  18         return err;
  19 }
  20
  21 int __ext4_journal_get_write_access(const char *where, handle_t *handle,
  22                                 struct buffer_head *bh)
  23 {
  24         int err = 0;
  25
  26         if (ext4_handle_valid(handle)) {
  27                 err = jbd2_journal_get_write_access(handle, bh);
  28                 if (err)
  29                         ext4_journal_abort_handle(where, __func__, bh,
  30                                                   handle, err);
  31         }
  32         return err;
  33 }
  34
  35 int __ext4_journal_forget(const char *where, handle_t *handle,
  36                                 struct buffer_head *bh)
  37 {
  38         int err = 0;
  39
  40         if (ext4_handle_valid(handle)) {
  41                 err = jbd2_journal_forget(handle, bh);
  42                 if (err)
  43                         ext4_journal_abort_handle(where, __func__, bh,
  44                                                   handle, err);
  45         }
  46         return err;
  47 }
  48
  49 int __ext4_journal_revoke(const char *where, handle_t *handle,
  50                                 ext4_fsblk_t blocknr, struct buffer_head *bh)
  51 {
  52         int err = 0;
  53
  54         if (ext4_handle_valid(handle)) {
  55                 err = jbd2_journal_revoke(handle, blocknr, bh);
  56                 if (err)
  57                         ext4_journal_abort_handle(where, __func__, bh,
  58                                                   handle, err);
  59         }
  60         return err;
  61 }
  62
  63 int __ext4_journal_get_create_access(const char *where,
  64                                 handle_t *handle, struct buffer_head *bh)
  65 {
  66         int err = 0;
  67
  68         if (ext4_handle_valid(handle)) {
  69                 err = jbd2_journal_get_create_access(handle, bh);
  70                 if (err)
  71                         ext4_journal_abort_handle(where, __func__, bh,
  72                                                   handle, err);
  73         }
  74         return err;
  75 }
  76
  77 int __ext4_handle_dirty_metadata(const char *where, handle_t *handle,
  78                                  struct inode *inode, struct buffer_head *bh)
  79 {
  80         int err = 0;
  81
  82         if (ext4_handle_valid(handle)) {
  83                 err = jbd2_journal_dirty_metadata(handle, bh);
  84                 if (err)
  85                         ext4_journal_abort_handle(where, __func__, bh,
  86                                                   handle, err);
  87         } else {
  88                 mark_buffer_dirty(bh);
  89                 if (inode && inode_needs_sync(inode)) {
  90                         sync_dirty_buffer(bh);
  91                         if (buffer_req(bh) && !buffer_uptodate(bh)) {
  92                                 ext4_error(inode->i_sb, __func__,
  93                                            "IO error syncing inode, "
  94                                            "inode=%lu, block=%llu",
  95                                            inode->i_ino,
  96                                            (unsigned long long) bh->b_blocknr);
  97                                 err = -EIO;
  98                         }
  99                 }
 100         }
 101         return err;
 102 }