Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 1 | /* |
Christoph Hellwig | 3dcf545 | 2008-04-29 18:13:32 -0400 | [diff] [blame] | 2 | * ext4_jbd2.h |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 3 | * |
| 4 | * Written by Stephen C. Tweedie <sct@redhat.com>, 1999 |
| 5 | * |
| 6 | * Copyright 1998--1999 Red Hat corp --- All Rights Reserved |
| 7 | * |
| 8 | * This file is part of the Linux kernel and is made available under |
| 9 | * the terms of the GNU General Public License, version 2, or at your |
| 10 | * option, any later version, incorporated herein by reference. |
| 11 | * |
| 12 | * Ext4-specific journaling extensions. |
| 13 | */ |
| 14 | |
Christoph Hellwig | 3dcf545 | 2008-04-29 18:13:32 -0400 | [diff] [blame] | 15 | #ifndef _EXT4_JBD2_H |
| 16 | #define _EXT4_JBD2_H |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 17 | |
| 18 | #include <linux/fs.h> |
Mingming Cao | f7f4bcc | 2006-10-11 01:20:59 -0700 | [diff] [blame] | 19 | #include <linux/jbd2.h> |
Christoph Hellwig | 3dcf545 | 2008-04-29 18:13:32 -0400 | [diff] [blame] | 20 | #include "ext4.h" |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 21 | |
| 22 | #define EXT4_JOURNAL(inode) (EXT4_SB((inode)->i_sb)->s_journal) |
| 23 | |
| 24 | /* Define the number of blocks we need to account to a transaction to |
| 25 | * modify one block of data. |
| 26 | * |
| 27 | * We may have to touch one inode, one bitmap buffer, up to three |
| 28 | * indirection blocks, the group and superblock summaries, and the data |
Alex Tomas | a86c618 | 2006-10-11 01:21:03 -0700 | [diff] [blame] | 29 | * block to complete the transaction. |
| 30 | * |
Randy Dunlap | d0d856e | 2006-10-11 01:21:07 -0700 | [diff] [blame] | 31 | * For extents-enabled fs we may have to allocate and modify up to |
Jan Kara | f45a5ef | 2013-04-09 12:39:26 -0400 | [diff] [blame] | 32 | * 5 levels of tree, data block (for each of these we need bitmap + group |
| 33 | * summaries), root which is stored in the inode, sb |
| 34 | */ |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 35 | |
Alex Tomas | a86c618 | 2006-10-11 01:21:03 -0700 | [diff] [blame] | 36 | #define EXT4_SINGLEDATA_TRANS_BLOCKS(sb) \ |
Darrick J. Wong | e2b911c | 2015-10-17 16:18:43 -0400 | [diff] [blame] | 37 | (ext4_has_feature_extents(sb) ? 20U : 8U) |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 38 | |
| 39 | /* Extended attribute operations touch at most two data buffers, |
| 40 | * two bitmap buffers, and two group summaries, in addition to the inode |
| 41 | * and the superblock, which are already accounted for. */ |
| 42 | |
| 43 | #define EXT4_XATTR_TRANS_BLOCKS 6U |
| 44 | |
| 45 | /* Define the minimum size for a transaction which modifies data. This |
| 46 | * needs to take into account the fact that we may end up modifying two |
| 47 | * quota files too (one for the group, one for the user quota). The |
| 48 | * superblock only gets updated once, of course, so don't bother |
| 49 | * counting that again for the quota updates. */ |
| 50 | |
Alex Tomas | a86c618 | 2006-10-11 01:21:03 -0700 | [diff] [blame] | 51 | #define EXT4_DATA_TRANS_BLOCKS(sb) (EXT4_SINGLEDATA_TRANS_BLOCKS(sb) + \ |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 52 | EXT4_XATTR_TRANS_BLOCKS - 2 + \ |
Dmitry Monakhov | 5aca07e | 2009-12-08 22:42:15 -0500 | [diff] [blame] | 53 | EXT4_MAXQUOTAS_TRANS_BLOCKS(sb)) |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 54 | |
Mingming Cao | a02908f | 2008-08-19 22:16:07 -0400 | [diff] [blame] | 55 | /* |
| 56 | * Define the number of metadata blocks we need to account to modify data. |
| 57 | * |
| 58 | * This include super block, inode block, quota blocks and xattr blocks |
| 59 | */ |
| 60 | #define EXT4_META_TRANS_BLOCKS(sb) (EXT4_XATTR_TRANS_BLOCKS + \ |
Dmitry Monakhov | 5aca07e | 2009-12-08 22:42:15 -0500 | [diff] [blame] | 61 | EXT4_MAXQUOTAS_TRANS_BLOCKS(sb)) |
Mingming Cao | a02908f | 2008-08-19 22:16:07 -0400 | [diff] [blame] | 62 | |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 63 | /* Define an arbitrary limit for the amount of data we will anticipate |
| 64 | * writing to any given transaction. For unbounded transactions such as |
| 65 | * write(2) and truncate(2) we can write more than this, but we always |
| 66 | * start off at the maximum transaction size and grow the transaction |
| 67 | * optimistically as we go. */ |
| 68 | |
| 69 | #define EXT4_MAX_TRANS_DATA 64U |
| 70 | |
| 71 | /* We break up a large truncate or write transaction once the handle's |
| 72 | * buffer credits gets this low, we need either to extend the |
| 73 | * transaction or to start a new one. Reserve enough space here for |
| 74 | * inode, bitmap, superblock, group and indirection updates for at least |
| 75 | * one block, plus two quota updates. Quota allocations are not |
| 76 | * needed. */ |
| 77 | |
| 78 | #define EXT4_RESERVE_TRANS_BLOCKS 12U |
| 79 | |
| 80 | #define EXT4_INDEX_EXTRA_TRANS_BLOCKS 8 |
| 81 | |
| 82 | #ifdef CONFIG_QUOTA |
| 83 | /* Amount of blocks needed for quota update - we know that the structure was |
Jan Kara | 21f9769 | 2011-04-04 15:33:39 -0400 | [diff] [blame] | 84 | * allocated so we need to update only data block */ |
Aditya Kali | 7c319d3 | 2012-07-22 20:21:31 -0400 | [diff] [blame] | 85 | #define EXT4_QUOTA_TRANS_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\ |
Darrick J. Wong | e2b911c | 2015-10-17 16:18:43 -0400 | [diff] [blame] | 86 | ext4_has_feature_quota(sb)) ? 1 : 0) |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 87 | /* Amount of blocks needed for quota insert/delete - we do some block writes |
| 88 | * but inode, sb and group updates are done only once */ |
Aditya Kali | 7c319d3 | 2012-07-22 20:21:31 -0400 | [diff] [blame] | 89 | #define EXT4_QUOTA_INIT_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\ |
Darrick J. Wong | e2b911c | 2015-10-17 16:18:43 -0400 | [diff] [blame] | 90 | ext4_has_feature_quota(sb)) ?\ |
Aditya Kali | 7c319d3 | 2012-07-22 20:21:31 -0400 | [diff] [blame] | 91 | (DQUOT_INIT_ALLOC*(EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)\ |
| 92 | +3+DQUOT_INIT_REWRITE) : 0) |
Dmitry Monakhov | 5aca07e | 2009-12-08 22:42:15 -0500 | [diff] [blame] | 93 | |
Aditya Kali | 7c319d3 | 2012-07-22 20:21:31 -0400 | [diff] [blame] | 94 | #define EXT4_QUOTA_DEL_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\ |
Darrick J. Wong | e2b911c | 2015-10-17 16:18:43 -0400 | [diff] [blame] | 95 | ext4_has_feature_quota(sb)) ?\ |
Aditya Kali | 7c319d3 | 2012-07-22 20:21:31 -0400 | [diff] [blame] | 96 | (DQUOT_DEL_ALLOC*(EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)\ |
| 97 | +3+DQUOT_DEL_REWRITE) : 0) |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 98 | #else |
| 99 | #define EXT4_QUOTA_TRANS_BLOCKS(sb) 0 |
| 100 | #define EXT4_QUOTA_INIT_BLOCKS(sb) 0 |
| 101 | #define EXT4_QUOTA_DEL_BLOCKS(sb) 0 |
| 102 | #endif |
Jan Kara | a2d4a64 | 2014-09-11 11:15:15 -0400 | [diff] [blame] | 103 | #define EXT4_MAXQUOTAS_TRANS_BLOCKS(sb) (EXT4_MAXQUOTAS*EXT4_QUOTA_TRANS_BLOCKS(sb)) |
| 104 | #define EXT4_MAXQUOTAS_INIT_BLOCKS(sb) (EXT4_MAXQUOTAS*EXT4_QUOTA_INIT_BLOCKS(sb)) |
| 105 | #define EXT4_MAXQUOTAS_DEL_BLOCKS(sb) (EXT4_MAXQUOTAS*EXT4_QUOTA_DEL_BLOCKS(sb)) |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 106 | |
Theodore Ts'o | 95eaefb | 2013-02-09 15:23:03 -0500 | [diff] [blame] | 107 | static inline int ext4_jbd2_credits_xattr(struct inode *inode) |
| 108 | { |
| 109 | int credits = EXT4_DATA_TRANS_BLOCKS(inode->i_sb); |
| 110 | |
| 111 | /* |
| 112 | * In case of inline data, we may push out the data to a block, |
| 113 | * so we need to reserve credits for this eventuality |
| 114 | */ |
| 115 | if (ext4_has_inline_data(inode)) |
| 116 | credits += ext4_writepage_trans_blocks(inode) + 1; |
| 117 | return credits; |
| 118 | } |
| 119 | |
| 120 | |
Theodore Ts'o | 9924a92 | 2013-02-08 21:59:22 -0500 | [diff] [blame] | 121 | /* |
| 122 | * Ext4 handle operation types -- for logging purposes |
| 123 | */ |
| 124 | #define EXT4_HT_MISC 0 |
| 125 | #define EXT4_HT_INODE 1 |
| 126 | #define EXT4_HT_WRITE_PAGE 2 |
| 127 | #define EXT4_HT_MAP_BLOCKS 3 |
| 128 | #define EXT4_HT_DIR 4 |
| 129 | #define EXT4_HT_TRUNCATE 5 |
| 130 | #define EXT4_HT_QUOTA 6 |
| 131 | #define EXT4_HT_RESIZE 7 |
| 132 | #define EXT4_HT_MIGRATE 8 |
| 133 | #define EXT4_HT_MOVE_EXTENTS 9 |
| 134 | #define EXT4_HT_XATTR 10 |
Jan Kara | 6b523df | 2013-06-04 13:21:11 -0400 | [diff] [blame] | 135 | #define EXT4_HT_EXT_CONVERT 11 |
| 136 | #define EXT4_HT_MAX 12 |
Theodore Ts'o | 9924a92 | 2013-02-08 21:59:22 -0500 | [diff] [blame] | 137 | |
Bobi Jam | 18aadd4 | 2012-02-20 17:53:02 -0500 | [diff] [blame] | 138 | /** |
| 139 | * struct ext4_journal_cb_entry - Base structure for callback information. |
| 140 | * |
| 141 | * This struct is a 'seed' structure for a using with your own callback |
| 142 | * structs. If you are using callbacks you must allocate one of these |
| 143 | * or another struct of your own definition which has this struct |
| 144 | * as it's first element and pass it to ext4_journal_callback_add(). |
| 145 | */ |
| 146 | struct ext4_journal_cb_entry { |
| 147 | /* list information for other callbacks attached to the same handle */ |
| 148 | struct list_head jce_list; |
| 149 | |
| 150 | /* Function to call with this callback structure */ |
| 151 | void (*jce_func)(struct super_block *sb, |
| 152 | struct ext4_journal_cb_entry *jce, int error); |
| 153 | |
| 154 | /* user data goes here */ |
| 155 | }; |
| 156 | |
| 157 | /** |
| 158 | * ext4_journal_callback_add: add a function to call after transaction commit |
| 159 | * @handle: active journal transaction handle to register callback on |
| 160 | * @func: callback function to call after the transaction has committed: |
| 161 | * @sb: superblock of current filesystem for transaction |
| 162 | * @jce: returned journal callback data |
| 163 | * @rc: journal state at commit (0 = transaction committed properly) |
| 164 | * @jce: journal callback data (internal and function private data struct) |
| 165 | * |
| 166 | * The registered function will be called in the context of the journal thread |
| 167 | * after the transaction for which the handle was created has completed. |
| 168 | * |
| 169 | * No locks are held when the callback function is called, so it is safe to |
| 170 | * call blocking functions from within the callback, but the callback should |
| 171 | * not block or run for too long, or the filesystem will be blocked waiting for |
| 172 | * the next transaction to commit. No journaling functions can be used, or |
| 173 | * there is a risk of deadlock. |
| 174 | * |
| 175 | * There is no guaranteed calling order of multiple registered callbacks on |
| 176 | * the same transaction. |
| 177 | */ |
Theodore Ts'o | d08854f | 2016-06-26 18:24:01 -0400 | [diff] [blame] | 178 | static inline void _ext4_journal_callback_add(handle_t *handle, |
| 179 | struct ext4_journal_cb_entry *jce) |
| 180 | { |
| 181 | /* Add the jce to transaction's private list */ |
| 182 | list_add_tail(&jce->jce_list, &handle->h_transaction->t_private_list); |
| 183 | } |
| 184 | |
Bobi Jam | 18aadd4 | 2012-02-20 17:53:02 -0500 | [diff] [blame] | 185 | static inline void ext4_journal_callback_add(handle_t *handle, |
| 186 | void (*func)(struct super_block *sb, |
| 187 | struct ext4_journal_cb_entry *jce, |
| 188 | int rc), |
| 189 | struct ext4_journal_cb_entry *jce) |
| 190 | { |
| 191 | struct ext4_sb_info *sbi = |
| 192 | EXT4_SB(handle->h_transaction->t_journal->j_private); |
| 193 | |
| 194 | /* Add the jce to transaction's private list */ |
| 195 | jce->jce_func = func; |
| 196 | spin_lock(&sbi->s_md_lock); |
Theodore Ts'o | d08854f | 2016-06-26 18:24:01 -0400 | [diff] [blame] | 197 | _ext4_journal_callback_add(handle, jce); |
Bobi Jam | 18aadd4 | 2012-02-20 17:53:02 -0500 | [diff] [blame] | 198 | spin_unlock(&sbi->s_md_lock); |
| 199 | } |
| 200 | |
Theodore Ts'o | d08854f | 2016-06-26 18:24:01 -0400 | [diff] [blame] | 201 | |
Bobi Jam | 18aadd4 | 2012-02-20 17:53:02 -0500 | [diff] [blame] | 202 | /** |
| 203 | * ext4_journal_callback_del: delete a registered callback |
| 204 | * @handle: active journal transaction handle on which callback was registered |
| 205 | * @jce: registered journal callback entry to unregister |
Anatol Pomozov | 70261f5 | 2013-08-28 14:40:12 -0400 | [diff] [blame] | 206 | * Return true if object was successfully removed |
Bobi Jam | 18aadd4 | 2012-02-20 17:53:02 -0500 | [diff] [blame] | 207 | */ |
Dmitry Monakhov | 5d3ee20 | 2013-04-03 22:08:52 -0400 | [diff] [blame] | 208 | static inline bool ext4_journal_callback_try_del(handle_t *handle, |
Bobi Jam | 18aadd4 | 2012-02-20 17:53:02 -0500 | [diff] [blame] | 209 | struct ext4_journal_cb_entry *jce) |
| 210 | { |
Dmitry Monakhov | 5d3ee20 | 2013-04-03 22:08:52 -0400 | [diff] [blame] | 211 | bool deleted; |
Bobi Jam | 18aadd4 | 2012-02-20 17:53:02 -0500 | [diff] [blame] | 212 | struct ext4_sb_info *sbi = |
| 213 | EXT4_SB(handle->h_transaction->t_journal->j_private); |
| 214 | |
| 215 | spin_lock(&sbi->s_md_lock); |
Dmitry Monakhov | 5d3ee20 | 2013-04-03 22:08:52 -0400 | [diff] [blame] | 216 | deleted = !list_empty(&jce->jce_list); |
Bobi Jam | 18aadd4 | 2012-02-20 17:53:02 -0500 | [diff] [blame] | 217 | list_del_init(&jce->jce_list); |
| 218 | spin_unlock(&sbi->s_md_lock); |
Dmitry Monakhov | 5d3ee20 | 2013-04-03 22:08:52 -0400 | [diff] [blame] | 219 | return deleted; |
Bobi Jam | 18aadd4 | 2012-02-20 17:53:02 -0500 | [diff] [blame] | 220 | } |
| 221 | |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 222 | int |
| 223 | ext4_mark_iloc_dirty(handle_t *handle, |
| 224 | struct inode *inode, |
| 225 | struct ext4_iloc *iloc); |
| 226 | |
| 227 | /* |
| 228 | * On success, We end up with an outstanding reference count against |
| 229 | * iloc->bh. This _must_ be cleaned up later. |
| 230 | */ |
| 231 | |
| 232 | int ext4_reserve_inode_write(handle_t *handle, struct inode *inode, |
| 233 | struct ext4_iloc *iloc); |
| 234 | |
| 235 | int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode); |
| 236 | |
| 237 | /* |
Theodore Ts'o | e4684b3 | 2009-11-24 11:05:59 -0500 | [diff] [blame] | 238 | * Wrapper functions with which ext4 calls into JBD. |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 239 | */ |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 240 | int __ext4_journal_get_write_access(const char *where, unsigned int line, |
| 241 | handle_t *handle, struct buffer_head *bh); |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 242 | |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 243 | int __ext4_forget(const char *where, unsigned int line, handle_t *handle, |
| 244 | int is_metadata, struct inode *inode, |
| 245 | struct buffer_head *bh, ext4_fsblk_t blocknr); |
Theodore Ts'o | d6797d1 | 2009-11-22 20:52:12 -0500 | [diff] [blame] | 246 | |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 247 | int __ext4_journal_get_create_access(const char *where, unsigned int line, |
Andrew Morton | 8984d13 | 2006-12-06 20:37:15 -0800 | [diff] [blame] | 248 | handle_t *handle, struct buffer_head *bh); |
| 249 | |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 250 | int __ext4_handle_dirty_metadata(const char *where, unsigned int line, |
| 251 | handle_t *handle, struct inode *inode, |
| 252 | struct buffer_head *bh); |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 253 | |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 254 | int __ext4_handle_dirty_super(const char *where, unsigned int line, |
Artem Bityutskiy | b50924c | 2012-07-22 20:37:31 -0400 | [diff] [blame] | 255 | handle_t *handle, struct super_block *sb); |
Theodore Ts'o | a037515 | 2010-06-11 23:14:04 -0400 | [diff] [blame] | 256 | |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 257 | #define ext4_journal_get_write_access(handle, bh) \ |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 258 | __ext4_journal_get_write_access(__func__, __LINE__, (handle), (bh)) |
Theodore Ts'o | d6797d1 | 2009-11-22 20:52:12 -0500 | [diff] [blame] | 259 | #define ext4_forget(handle, is_metadata, inode, bh, block_nr) \ |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 260 | __ext4_forget(__func__, __LINE__, (handle), (is_metadata), (inode), \ |
| 261 | (bh), (block_nr)) |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 262 | #define ext4_journal_get_create_access(handle, bh) \ |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 263 | __ext4_journal_get_create_access(__func__, __LINE__, (handle), (bh)) |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 264 | #define ext4_handle_dirty_metadata(handle, inode, bh) \ |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 265 | __ext4_handle_dirty_metadata(__func__, __LINE__, (handle), (inode), \ |
| 266 | (bh)) |
Theodore Ts'o | a037515 | 2010-06-11 23:14:04 -0400 | [diff] [blame] | 267 | #define ext4_handle_dirty_super(handle, sb) \ |
Artem Bityutskiy | b50924c | 2012-07-22 20:37:31 -0400 | [diff] [blame] | 268 | __ext4_handle_dirty_super(__func__, __LINE__, (handle), (sb)) |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 269 | |
Theodore Ts'o | 9924a92 | 2013-02-08 21:59:22 -0500 | [diff] [blame] | 270 | handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line, |
Jan Kara | 5fe2fe8 | 2013-06-04 12:37:50 -0400 | [diff] [blame] | 271 | int type, int blocks, int rsv_blocks); |
Theodore Ts'o | c398eda | 2010-07-27 11:56:40 -0400 | [diff] [blame] | 272 | int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle); |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 273 | |
Curt Wohlgemuth | d3d1faf | 2009-09-29 11:01:03 -0400 | [diff] [blame] | 274 | #define EXT4_NOJOURNAL_MAX_REF_COUNT ((unsigned long) 4096) |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 275 | |
Curt Wohlgemuth | d3d1faf | 2009-09-29 11:01:03 -0400 | [diff] [blame] | 276 | /* Note: Do not use this for NULL handles. This is only to determine if |
| 277 | * a properly allocated handle is using a journal or not. */ |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 278 | static inline int ext4_handle_valid(handle_t *handle) |
| 279 | { |
Curt Wohlgemuth | d3d1faf | 2009-09-29 11:01:03 -0400 | [diff] [blame] | 280 | if ((unsigned long)handle < EXT4_NOJOURNAL_MAX_REF_COUNT) |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 281 | return 0; |
| 282 | return 1; |
| 283 | } |
| 284 | |
| 285 | static inline void ext4_handle_sync(handle_t *handle) |
| 286 | { |
| 287 | if (ext4_handle_valid(handle)) |
| 288 | handle->h_sync = 1; |
| 289 | } |
| 290 | |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 291 | static inline int ext4_handle_is_aborted(handle_t *handle) |
| 292 | { |
| 293 | if (ext4_handle_valid(handle)) |
| 294 | return is_handle_aborted(handle); |
| 295 | return 0; |
| 296 | } |
| 297 | |
| 298 | static inline int ext4_handle_has_enough_credits(handle_t *handle, int needed) |
| 299 | { |
| 300 | if (ext4_handle_valid(handle) && handle->h_buffer_credits < needed) |
| 301 | return 0; |
| 302 | return 1; |
| 303 | } |
| 304 | |
Theodore Ts'o | 9924a92 | 2013-02-08 21:59:22 -0500 | [diff] [blame] | 305 | #define ext4_journal_start_sb(sb, type, nblocks) \ |
Jan Kara | 5fe2fe8 | 2013-06-04 12:37:50 -0400 | [diff] [blame] | 306 | __ext4_journal_start_sb((sb), __LINE__, (type), (nblocks), 0) |
Theodore Ts'o | 9924a92 | 2013-02-08 21:59:22 -0500 | [diff] [blame] | 307 | |
| 308 | #define ext4_journal_start(inode, type, nblocks) \ |
Jan Kara | 5fe2fe8 | 2013-06-04 12:37:50 -0400 | [diff] [blame] | 309 | __ext4_journal_start((inode), __LINE__, (type), (nblocks), 0) |
| 310 | |
| 311 | #define ext4_journal_start_with_reserve(inode, type, blocks, rsv_blocks) \ |
| 312 | __ext4_journal_start((inode), __LINE__, (type), (blocks), (rsv_blocks)) |
Theodore Ts'o | 9924a92 | 2013-02-08 21:59:22 -0500 | [diff] [blame] | 313 | |
| 314 | static inline handle_t *__ext4_journal_start(struct inode *inode, |
| 315 | unsigned int line, int type, |
Jan Kara | 5fe2fe8 | 2013-06-04 12:37:50 -0400 | [diff] [blame] | 316 | int blocks, int rsv_blocks) |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 317 | { |
Jan Kara | 5fe2fe8 | 2013-06-04 12:37:50 -0400 | [diff] [blame] | 318 | return __ext4_journal_start_sb(inode->i_sb, line, type, blocks, |
| 319 | rsv_blocks); |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 320 | } |
| 321 | |
| 322 | #define ext4_journal_stop(handle) \ |
Theodore Ts'o | c398eda | 2010-07-27 11:56:40 -0400 | [diff] [blame] | 323 | __ext4_journal_stop(__func__, __LINE__, (handle)) |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 324 | |
Jan Kara | 6b523df | 2013-06-04 13:21:11 -0400 | [diff] [blame] | 325 | #define ext4_journal_start_reserved(handle, type) \ |
Jan Kara | 5fe2fe8 | 2013-06-04 12:37:50 -0400 | [diff] [blame] | 326 | __ext4_journal_start_reserved((handle), __LINE__, (type)) |
| 327 | |
| 328 | handle_t *__ext4_journal_start_reserved(handle_t *handle, unsigned int line, |
| 329 | int type); |
| 330 | |
| 331 | static inline void ext4_journal_free_reserved(handle_t *handle) |
| 332 | { |
| 333 | if (ext4_handle_valid(handle)) |
| 334 | jbd2_journal_free_reserved(handle); |
| 335 | } |
| 336 | |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 337 | static inline handle_t *ext4_journal_current_handle(void) |
| 338 | { |
| 339 | return journal_current_handle(); |
| 340 | } |
| 341 | |
| 342 | static inline int ext4_journal_extend(handle_t *handle, int nblocks) |
| 343 | { |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 344 | if (ext4_handle_valid(handle)) |
| 345 | return jbd2_journal_extend(handle, nblocks); |
| 346 | return 0; |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 347 | } |
| 348 | |
| 349 | static inline int ext4_journal_restart(handle_t *handle, int nblocks) |
| 350 | { |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 351 | if (ext4_handle_valid(handle)) |
| 352 | return jbd2_journal_restart(handle, nblocks); |
| 353 | return 0; |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 354 | } |
| 355 | |
| 356 | static inline int ext4_journal_blocks_per_page(struct inode *inode) |
| 357 | { |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 358 | if (EXT4_JOURNAL(inode) != NULL) |
| 359 | return jbd2_journal_blocks_per_page(inode); |
| 360 | return 0; |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 361 | } |
| 362 | |
| 363 | static inline int ext4_journal_force_commit(journal_t *journal) |
| 364 | { |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 365 | if (journal) |
| 366 | return jbd2_journal_force_commit(journal); |
| 367 | return 0; |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 368 | } |
| 369 | |
Jan Kara | ee0876b | 2016-04-24 00:56:08 -0400 | [diff] [blame] | 370 | static inline int ext4_jbd2_inode_add_write(handle_t *handle, |
| 371 | struct inode *inode) |
Jan Kara | 678aaf4 | 2008-07-11 19:27:31 -0400 | [diff] [blame] | 372 | { |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 373 | if (ext4_handle_valid(handle)) |
Jan Kara | 41617e1 | 2016-04-24 00:56:07 -0400 | [diff] [blame] | 374 | return jbd2_journal_inode_add_write(handle, |
| 375 | EXT4_I(inode)->jinode); |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 376 | return 0; |
Jan Kara | 678aaf4 | 2008-07-11 19:27:31 -0400 | [diff] [blame] | 377 | } |
| 378 | |
Jan Kara | ee0876b | 2016-04-24 00:56:08 -0400 | [diff] [blame] | 379 | static inline int ext4_jbd2_inode_add_wait(handle_t *handle, |
| 380 | struct inode *inode) |
| 381 | { |
| 382 | if (ext4_handle_valid(handle)) |
| 383 | return jbd2_journal_inode_add_wait(handle, |
| 384 | EXT4_I(inode)->jinode); |
| 385 | return 0; |
| 386 | } |
| 387 | |
Jan Kara | b436b9b | 2009-12-08 23:51:10 -0500 | [diff] [blame] | 388 | static inline void ext4_update_inode_fsync_trans(handle_t *handle, |
| 389 | struct inode *inode, |
| 390 | int datasync) |
| 391 | { |
| 392 | struct ext4_inode_info *ei = EXT4_I(inode); |
| 393 | |
| 394 | if (ext4_handle_valid(handle)) { |
| 395 | ei->i_sync_tid = handle->h_transaction->t_tid; |
| 396 | if (datasync) |
| 397 | ei->i_datasync_tid = handle->h_transaction->t_tid; |
| 398 | } |
| 399 | } |
| 400 | |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 401 | /* super.c */ |
| 402 | int ext4_force_commit(struct super_block *sb); |
| 403 | |
Lukas Czerner | 3d2b158 | 2012-02-20 17:53:00 -0500 | [diff] [blame] | 404 | /* |
| 405 | * Ext4 inode journal modes |
| 406 | */ |
| 407 | #define EXT4_INODE_JOURNAL_DATA_MODE 0x01 /* journal data mode */ |
| 408 | #define EXT4_INODE_ORDERED_DATA_MODE 0x02 /* ordered data mode */ |
| 409 | #define EXT4_INODE_WRITEBACK_DATA_MODE 0x04 /* writeback data mode */ |
| 410 | |
| 411 | static inline int ext4_inode_journal_mode(struct inode *inode) |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 412 | { |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 413 | if (EXT4_JOURNAL(inode) == NULL) |
Lukas Czerner | 3d2b158 | 2012-02-20 17:53:00 -0500 | [diff] [blame] | 414 | return EXT4_INODE_WRITEBACK_DATA_MODE; /* writeback */ |
| 415 | /* We do not support data journalling with delayed allocation */ |
| 416 | if (!S_ISREG(inode->i_mode) || |
Sergey Karamov | 73b92a2 | 2016-12-10 17:54:58 -0500 | [diff] [blame] | 417 | test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA || |
| 418 | (ext4_test_inode_flag(inode, EXT4_INODE_JOURNAL_DATA) && |
| 419 | !test_opt(inode->i_sb, DELALLOC))) { |
| 420 | /* We do not support data journalling for encrypted data */ |
| 421 | if (S_ISREG(inode->i_mode) && ext4_encrypted_inode(inode)) |
| 422 | return EXT4_INODE_ORDERED_DATA_MODE; /* ordered */ |
Lukas Czerner | 3d2b158 | 2012-02-20 17:53:00 -0500 | [diff] [blame] | 423 | return EXT4_INODE_JOURNAL_DATA_MODE; /* journal data */ |
Sergey Karamov | 73b92a2 | 2016-12-10 17:54:58 -0500 | [diff] [blame] | 424 | } |
Lukas Czerner | 3d2b158 | 2012-02-20 17:53:00 -0500 | [diff] [blame] | 425 | if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA) |
| 426 | return EXT4_INODE_ORDERED_DATA_MODE; /* ordered */ |
| 427 | if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA) |
| 428 | return EXT4_INODE_WRITEBACK_DATA_MODE; /* writeback */ |
Sergey Karamov | 73b92a2 | 2016-12-10 17:54:58 -0500 | [diff] [blame] | 429 | BUG(); |
Lukas Czerner | 3d2b158 | 2012-02-20 17:53:00 -0500 | [diff] [blame] | 430 | } |
| 431 | |
| 432 | static inline int ext4_should_journal_data(struct inode *inode) |
| 433 | { |
| 434 | return ext4_inode_journal_mode(inode) & EXT4_INODE_JOURNAL_DATA_MODE; |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 435 | } |
| 436 | |
| 437 | static inline int ext4_should_order_data(struct inode *inode) |
| 438 | { |
Lukas Czerner | 3d2b158 | 2012-02-20 17:53:00 -0500 | [diff] [blame] | 439 | return ext4_inode_journal_mode(inode) & EXT4_INODE_ORDERED_DATA_MODE; |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 440 | } |
| 441 | |
| 442 | static inline int ext4_should_writeback_data(struct inode *inode) |
| 443 | { |
Lukas Czerner | 3d2b158 | 2012-02-20 17:53:00 -0500 | [diff] [blame] | 444 | return ext4_inode_journal_mode(inode) & EXT4_INODE_WRITEBACK_DATA_MODE; |
Dave Kleikamp | 470decc | 2006-10-11 01:20:57 -0700 | [diff] [blame] | 445 | } |
| 446 | |
Jiaying Zhang | 744692d | 2010-03-04 16:14:02 -0500 | [diff] [blame] | 447 | /* |
| 448 | * This function controls whether or not we should try to go down the |
| 449 | * dioread_nolock code paths, which makes it safe to avoid taking |
| 450 | * i_mutex for direct I/O reads. This only works for extent-based |
Christoph Hellwig | 206f7ab | 2010-06-14 14:42:49 -0400 | [diff] [blame] | 451 | * files, and it doesn't work if data journaling is enabled, since the |
| 452 | * dioread_nolock code uses b_private to pass information back to the |
| 453 | * I/O completion handler, and this conflicts with the jbd's use of |
| 454 | * b_private. |
Jiaying Zhang | 744692d | 2010-03-04 16:14:02 -0500 | [diff] [blame] | 455 | */ |
| 456 | static inline int ext4_should_dioread_nolock(struct inode *inode) |
| 457 | { |
| 458 | if (!test_opt(inode->i_sb, DIOREAD_NOLOCK)) |
| 459 | return 0; |
Jiaying Zhang | 744692d | 2010-03-04 16:14:02 -0500 | [diff] [blame] | 460 | if (!S_ISREG(inode->i_mode)) |
| 461 | return 0; |
Dmitry Monakhov | 12e9b89 | 2010-05-16 22:00:00 -0400 | [diff] [blame] | 462 | if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) |
Jiaying Zhang | 744692d | 2010-03-04 16:14:02 -0500 | [diff] [blame] | 463 | return 0; |
| 464 | if (ext4_should_journal_data(inode)) |
| 465 | return 0; |
| 466 | return 1; |
| 467 | } |
| 468 | |
Christoph Hellwig | 3dcf545 | 2008-04-29 18:13:32 -0400 | [diff] [blame] | 469 | #endif /* _EXT4_JBD2_H */ |