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         else
  47                 brelse(bh);
  48         return err;
  49 }
  50
  51 int __ext4_journal_revoke(const char *where, handle_t *handle,
  52                                 ext4_fsblk_t blocknr, struct buffer_head *bh)
  53 {
  54         int err = 0;
  55
  56         if (ext4_handle_valid(handle)) {
  57                 err = jbd2_journal_revoke(handle, blocknr, bh);
  58                 if (err)
  59                         ext4_journal_abort_handle(where, __func__, bh,
  60                                                   handle, err);
  61         }
  62         else
  63                 brelse(bh);
  64         return err;
  65 }
  66
  67 int __ext4_journal_get_create_access(const char *where,
  68                                 handle_t *handle, struct buffer_head *bh)
  69 {
  70         int err = 0;
  71
  72         if (ext4_handle_valid(handle)) {
  73                 err = jbd2_journal_get_create_access(handle, bh);
  74                 if (err)
  75                         ext4_journal_abort_handle(where, __func__, bh,
  76                                                   handle, err);
  77         }
  78         return err;
  79 }
  80
  81 int __ext4_handle_dirty_metadata(const char *where, handle_t *handle,
  82                                  struct inode *inode, struct buffer_head *bh)
  83 {
  84         int err = 0;
  85
  86         if (ext4_handle_valid(handle)) {
  87                 err = jbd2_journal_dirty_metadata(handle, bh);
  88                 if (err)
  89                         ext4_journal_abort_handle(where, __func__, bh,
  90                                                   handle, err);
  91         } else {
  92                 mark_buffer_dirty(bh);
  93                 if (inode && inode_needs_sync(inode)) {
  94                         sync_dirty_buffer(bh);
  95                         if (buffer_req(bh) && !buffer_uptodate(bh)) {
  96                                 ext4_error(inode->i_sb, __func__,
  97                                            "IO error syncing inode, "
  98                                            "inode=%lu, block=%llu",
  99                                            inode->i_ino,
 100                                            (unsigned long long) bh->b_blocknr);
 101                                 err = -EIO;
 102                         }
 103                 }
 104         }
 105         return err;
 106 }