fs/ext4/ext4_jbd2.c

   1 /*
   2  * Interface between ext4 and JBD
   3  */
   4
   5 #include "ext4_jbd2.h"
   6
   7 #include <trace/events/ext4.h>
   8
   9 /* Just increment the non-pointer handle value */
  10 static handle_t *ext4_get_nojournal(void)
  11 {
  12         handle_t *handle = current->journal_info;
  13         unsigned long ref_cnt = (unsigned long)handle;
  14
  15         BUG_ON(ref_cnt >= EXT4_NOJOURNAL_MAX_REF_COUNT);
  16
  17         ref_cnt++;
  18         handle = (handle_t *)ref_cnt;
  19
  20         current->journal_info = handle;
  21         return handle;
  22 }
  23
  24
  25 /* Decrement the non-pointer handle value */
  26 static void ext4_put_nojournal(handle_t *handle)
  27 {
  28         unsigned long ref_cnt = (unsigned long)handle;
  29
  30         BUG_ON(ref_cnt == 0);
  31
  32         ref_cnt--;
  33         handle = (handle_t *)ref_cnt;
  34
  35         current->journal_info = handle;
  36 }
  37
  38 /*
  39  * Wrappers for jbd2_journal_start/end.
  40  */
  41 handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line,
  42                                   int type, int nblocks)
  43 {
  44         journal_t *journal;
  45
  46         might_sleep();
  47
  48         trace_ext4_journal_start(sb, nblocks, _RET_IP_);
  49         if (sb->s_flags & MS_RDONLY)
  50                 return ERR_PTR(-EROFS);
  51
  52         WARN_ON(sb->s_writers.frozen == SB_FREEZE_COMPLETE);
  53         journal = EXT4_SB(sb)->s_journal;
  54         if (!journal)
  55                 return ext4_get_nojournal();
  56         /*
  57          * Special case here: if the journal has aborted behind our
  58          * backs (eg. EIO in the commit thread), then we still need to
  59          * take the FS itself readonly cleanly.
  60          */
  61         if (is_journal_aborted(journal)) {
  62                 ext4_abort(sb, "Detected aborted journal");
  63                 return ERR_PTR(-EROFS);
  64         }
  65         return jbd2__journal_start(journal, nblocks, GFP_NOFS, type, line);
  66 }
  67
  68 int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle)
  69 {
  70         struct super_block *sb;
  71         int err;
  72         int rc;
  73
  74         if (!ext4_handle_valid(handle)) {
  75                 ext4_put_nojournal(handle);
  76                 return 0;
  77         }
  78         sb = handle->h_transaction->t_journal->j_private;
  79         err = handle->h_err;
  80         rc = jbd2_journal_stop(handle);
  81
  82         if (!err)
  83                 err = rc;
  84         if (err)
  85                 __ext4_std_error(sb, where, line, err);
  86         return err;
  87 }
  88
  89 void ext4_journal_abort_handle(const char *caller, unsigned int line,
  90                                const char *err_fn, struct buffer_head *bh,
  91                                handle_t *handle, int err)
  92 {
  93         char nbuf[16];
  94         const char *errstr = ext4_decode_error(NULL, err, nbuf);
  95
  96         BUG_ON(!ext4_handle_valid(handle));
  97
  98         if (bh)
  99                 BUFFER_TRACE(bh, "abort");
 100
 101         if (!handle->h_err)
 102                 handle->h_err = err;
 103
 104         if (is_handle_aborted(handle))
 105                 return;
 106
 107         printk(KERN_ERR "EXT4-fs: %s:%d: aborting transaction: %s in %s\n",
 108                caller, line, errstr, err_fn);
 109
 110         jbd2_journal_abort_handle(handle);
 111 }
 112
 113 int __ext4_journal_get_write_access(const char *where, unsigned int line,
 114                                     handle_t *handle, struct buffer_head *bh)
 115 {
 116         int err = 0;
 117
 118         might_sleep();
 119
 120         if (ext4_handle_valid(handle)) {
 121                 err = jbd2_journal_get_write_access(handle, bh);
 122                 if (err)
 123                         ext4_journal_abort_handle(where, line, __func__, bh,
 124                                                   handle, err);
 125         }
 126         return err;
 127 }
 128
 129 /*
 130  * The ext4 forget function must perform a revoke if we are freeing data
 131  * which has been journaled.  Metadata (eg. indirect blocks) must be
 132  * revoked in all cases.
 133  *
 134  * "bh" may be NULL: a metadata block may have been freed from memory
 135  * but there may still be a record of it in the journal, and that record
 136  * still needs to be revoked.
 137  *
 138  * If the handle isn't valid we're not journaling, but we still need to
 139  * call into ext4_journal_revoke() to put the buffer head.
 140  */
 141 int __ext4_forget(const char *where, unsigned int line, handle_t *handle,
 142                   int is_metadata, struct inode *inode,
 143                   struct buffer_head *bh, ext4_fsblk_t blocknr)
 144 {
 145         int err;
 146
 147         might_sleep();
 148
 149         trace_ext4_forget(inode, is_metadata, blocknr);
 150         BUFFER_TRACE(bh, "enter");
 151
 152         jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
 153                   "data mode %x\n",
 154                   bh, is_metadata, inode->i_mode,
 155                   test_opt(inode->i_sb, DATA_FLAGS));
 156
 157         /* In the no journal case, we can just do a bforget and return */
 158         if (!ext4_handle_valid(handle)) {
 159                 bforget(bh);
 160                 return 0;
 161         }
 162
 163         /* Never use the revoke function if we are doing full data
 164          * journaling: there is no need to, and a V1 superblock won't
 165          * support it.  Otherwise, only skip the revoke on un-journaled
 166          * data blocks. */
 167
 168         if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA ||
 169             (!is_metadata && !ext4_should_journal_data(inode))) {
 170                 if (bh) {
 171                         BUFFER_TRACE(bh, "call jbd2_journal_forget");
 172                         err = jbd2_journal_forget(handle, bh);
 173                         if (err)
 174                                 ext4_journal_abort_handle(where, line, __func__,
 175                                                           bh, handle, err);
 176                         return err;
 177                 }
 178                 return 0;
 179         }
 180
 181         /*
 182          * data!=journal && (is_metadata || should_journal_data(inode))
 183          */
 184         BUFFER_TRACE(bh, "call jbd2_journal_revoke");
 185         err = jbd2_journal_revoke(handle, blocknr, bh);
 186         if (err) {
 187                 ext4_journal_abort_handle(where, line, __func__,
 188                                           bh, handle, err);
 189                 __ext4_abort(inode->i_sb, where, line,
 190                            "error %d when attempting revoke", err);
 191         }
 192         BUFFER_TRACE(bh, "exit");
 193         return err;
 194 }
 195
 196 int __ext4_journal_get_create_access(const char *where, unsigned int line,
 197                                 handle_t *handle, struct buffer_head *bh)
 198 {
 199         int err = 0;
 200
 201         if (ext4_handle_valid(handle)) {
 202                 err = jbd2_journal_get_create_access(handle, bh);
 203                 if (err)
 204                         ext4_journal_abort_handle(where, line, __func__,
 205                                                   bh, handle, err);
 206         }
 207         return err;
 208 }
 209
 210 int __ext4_handle_dirty_metadata(const char *where, unsigned int line,
 211                                  handle_t *handle, struct inode *inode,
 212                                  struct buffer_head *bh)
 213 {
 214         int err = 0;
 215
 216         might_sleep();
 217
 218         set_buffer_meta(bh);
 219         set_buffer_prio(bh);
 220         if (ext4_handle_valid(handle)) {
 221                 err = jbd2_journal_dirty_metadata(handle, bh);
 222                 if (err) {
 223                         /* Errors can only happen if there is a bug */
 224                         handle->h_err = err;
 225                         __ext4_journal_stop(where, line, handle);
 226                 }
 227         } else {
 228                 if (inode)
 229                         mark_buffer_dirty_inode(bh, inode);
 230                 else
 231                         mark_buffer_dirty(bh);
 232                 if (inode && inode_needs_sync(inode)) {
 233                         sync_dirty_buffer(bh);
 234                         if (buffer_req(bh) && !buffer_uptodate(bh)) {
 235                                 struct ext4_super_block *es;
 236
 237                                 es = EXT4_SB(inode->i_sb)->s_es;
 238                                 es->s_last_error_block =
 239                                         cpu_to_le64(bh->b_blocknr);
 240                                 ext4_error_inode(inode, where, line,
 241                                                  bh->b_blocknr,
 242                                         "IO error syncing itable block");
 243                                 err = -EIO;
 244                         }
 245                 }
 246         }
 247         return err;
 248 }
 249
 250 int __ext4_handle_dirty_super(const char *where, unsigned int line,
 251                               handle_t *handle, struct super_block *sb)
 252 {
 253         struct buffer_head *bh = EXT4_SB(sb)->s_sbh;
 254         int err = 0;
 255
 256         ext4_superblock_csum_set(sb);
 257         if (ext4_handle_valid(handle)) {
 258                 err = jbd2_journal_dirty_metadata(handle, bh);
 259                 if (err)
 260                         ext4_journal_abort_handle(where, line, __func__,
 261                                                   bh, handle, err);
 262         } else
 263                 mark_buffer_dirty(bh);
 264         return err;
 265 }