1 // SPDX-License-Identifier: GPL-2.0+
5 * Written by Stephen C. Tweedie <sct@redhat.com>, 1999
7 * Copyright 1998--1999 Red Hat corp --- All Rights Reserved
9 * Ext4-specific journaling extensions.
16 #include <linux/jbd2.h>
19 #define EXT4_JOURNAL(inode) (EXT4_SB((inode)->i_sb)->s_journal)
21 /* Define the number of blocks we need to account to a transaction to
22 * modify one block of data.
24 * We may have to touch one inode, one bitmap buffer, up to three
25 * indirection blocks, the group and superblock summaries, and the data
26 * block to complete the transaction.
28 * For extents-enabled fs we may have to allocate and modify up to
29 * 5 levels of tree, data block (for each of these we need bitmap + group
30 * summaries), root which is stored in the inode, sb
33 #define EXT4_SINGLEDATA_TRANS_BLOCKS(sb) \
34 (ext4_has_feature_extents(sb) ? 20U : 8U)
36 /* Extended attribute operations touch at most two data buffers,
37 * two bitmap buffers, and two group summaries, in addition to the inode
38 * and the superblock, which are already accounted for. */
40 #define EXT4_XATTR_TRANS_BLOCKS 6U
42 /* Define the minimum size for a transaction which modifies data. This
43 * needs to take into account the fact that we may end up modifying two
44 * quota files too (one for the group, one for the user quota). The
45 * superblock only gets updated once, of course, so don't bother
46 * counting that again for the quota updates. */
48 #define EXT4_DATA_TRANS_BLOCKS(sb) (EXT4_SINGLEDATA_TRANS_BLOCKS(sb) + \
49 EXT4_XATTR_TRANS_BLOCKS - 2 + \
50 EXT4_MAXQUOTAS_TRANS_BLOCKS(sb))
53 * Define the number of metadata blocks we need to account to modify data.
55 * This include super block, inode block, quota blocks and xattr blocks
57 #define EXT4_META_TRANS_BLOCKS(sb) (EXT4_XATTR_TRANS_BLOCKS + \
58 EXT4_MAXQUOTAS_TRANS_BLOCKS(sb))
60 /* Define an arbitrary limit for the amount of data we will anticipate
61 * writing to any given transaction. For unbounded transactions such as
62 * write(2) and truncate(2) we can write more than this, but we always
63 * start off at the maximum transaction size and grow the transaction
64 * optimistically as we go. */
66 #define EXT4_MAX_TRANS_DATA 64U
68 /* We break up a large truncate or write transaction once the handle's
69 * buffer credits gets this low, we need either to extend the
70 * transaction or to start a new one. Reserve enough space here for
71 * inode, bitmap, superblock, group and indirection updates for at least
72 * one block, plus two quota updates. Quota allocations are not
75 #define EXT4_RESERVE_TRANS_BLOCKS 12U
78 * Number of credits needed if we need to insert an entry into a
79 * directory. For each new index block, we need 4 blocks (old index
80 * block, new index block, bitmap block, bg summary). For normal
81 * htree directories there are 2 levels; if the largedir feature
82 * enabled it's 3 levels.
84 #define EXT4_INDEX_EXTRA_TRANS_BLOCKS 12U
87 /* Amount of blocks needed for quota update - we know that the structure was
88 * allocated so we need to update only data block */
89 #define EXT4_QUOTA_TRANS_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\
90 ext4_has_feature_quota(sb)) ? 1 : 0)
91 /* Amount of blocks needed for quota insert/delete - we do some block writes
92 * but inode, sb and group updates are done only once */
93 #define EXT4_QUOTA_INIT_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\
94 ext4_has_feature_quota(sb)) ?\
95 (DQUOT_INIT_ALLOC*(EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)\
96 +3+DQUOT_INIT_REWRITE) : 0)
98 #define EXT4_QUOTA_DEL_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\
99 ext4_has_feature_quota(sb)) ?\
100 (DQUOT_DEL_ALLOC*(EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)\
101 +3+DQUOT_DEL_REWRITE) : 0)
103 #define EXT4_QUOTA_TRANS_BLOCKS(sb) 0
104 #define EXT4_QUOTA_INIT_BLOCKS(sb) 0
105 #define EXT4_QUOTA_DEL_BLOCKS(sb) 0
107 #define EXT4_MAXQUOTAS_TRANS_BLOCKS(sb) (EXT4_MAXQUOTAS*EXT4_QUOTA_TRANS_BLOCKS(sb))
108 #define EXT4_MAXQUOTAS_INIT_BLOCKS(sb) (EXT4_MAXQUOTAS*EXT4_QUOTA_INIT_BLOCKS(sb))
109 #define EXT4_MAXQUOTAS_DEL_BLOCKS(sb) (EXT4_MAXQUOTAS*EXT4_QUOTA_DEL_BLOCKS(sb))
112 * Ext4 handle operation types -- for logging purposes
114 #define EXT4_HT_MISC 0
115 #define EXT4_HT_INODE 1
116 #define EXT4_HT_WRITE_PAGE 2
117 #define EXT4_HT_MAP_BLOCKS 3
118 #define EXT4_HT_DIR 4
119 #define EXT4_HT_TRUNCATE 5
120 #define EXT4_HT_QUOTA 6
121 #define EXT4_HT_RESIZE 7
122 #define EXT4_HT_MIGRATE 8
123 #define EXT4_HT_MOVE_EXTENTS 9
124 #define EXT4_HT_XATTR 10
125 #define EXT4_HT_EXT_CONVERT 11
126 #define EXT4_HT_MAX 12
129 * struct ext4_journal_cb_entry - Base structure for callback information.
131 * This struct is a 'seed' structure for a using with your own callback
132 * structs. If you are using callbacks you must allocate one of these
133 * or another struct of your own definition which has this struct
134 * as it's first element and pass it to ext4_journal_callback_add().
136 struct ext4_journal_cb_entry {
137 /* list information for other callbacks attached to the same handle */
138 struct list_head jce_list;
140 /* Function to call with this callback structure */
141 void (*jce_func)(struct super_block *sb,
142 struct ext4_journal_cb_entry *jce, int error);
144 /* user data goes here */
148 * ext4_journal_callback_add: add a function to call after transaction commit
149 * @handle: active journal transaction handle to register callback on
150 * @func: callback function to call after the transaction has committed:
151 * @sb: superblock of current filesystem for transaction
152 * @jce: returned journal callback data
153 * @rc: journal state at commit (0 = transaction committed properly)
154 * @jce: journal callback data (internal and function private data struct)
156 * The registered function will be called in the context of the journal thread
157 * after the transaction for which the handle was created has completed.
159 * No locks are held when the callback function is called, so it is safe to
160 * call blocking functions from within the callback, but the callback should
161 * not block or run for too long, or the filesystem will be blocked waiting for
162 * the next transaction to commit. No journaling functions can be used, or
163 * there is a risk of deadlock.
165 * There is no guaranteed calling order of multiple registered callbacks on
166 * the same transaction.
168 static inline void _ext4_journal_callback_add(handle_t *handle,
169 struct ext4_journal_cb_entry *jce)
171 /* Add the jce to transaction's private list */
172 list_add_tail(&jce->jce_list, &handle->h_transaction->t_private_list);
175 static inline void ext4_journal_callback_add(handle_t *handle,
176 void (*func)(struct super_block *sb,
177 struct ext4_journal_cb_entry *jce,
179 struct ext4_journal_cb_entry *jce)
181 struct ext4_sb_info *sbi =
182 EXT4_SB(handle->h_transaction->t_journal->j_private);
184 /* Add the jce to transaction's private list */
185 jce->jce_func = func;
186 spin_lock(&sbi->s_md_lock);
187 _ext4_journal_callback_add(handle, jce);
188 spin_unlock(&sbi->s_md_lock);
193 * ext4_journal_callback_del: delete a registered callback
194 * @handle: active journal transaction handle on which callback was registered
195 * @jce: registered journal callback entry to unregister
196 * Return true if object was successfully removed
198 static inline bool ext4_journal_callback_try_del(handle_t *handle,
199 struct ext4_journal_cb_entry *jce)
202 struct ext4_sb_info *sbi =
203 EXT4_SB(handle->h_transaction->t_journal->j_private);
205 spin_lock(&sbi->s_md_lock);
206 deleted = !list_empty(&jce->jce_list);
207 list_del_init(&jce->jce_list);
208 spin_unlock(&sbi->s_md_lock);
213 ext4_mark_iloc_dirty(handle_t *handle,
215 struct ext4_iloc *iloc);
218 * On success, We end up with an outstanding reference count against
219 * iloc->bh. This _must_ be cleaned up later.
222 int ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
223 struct ext4_iloc *iloc);
225 #define ext4_mark_inode_dirty(__h, __i) \
226 __ext4_mark_inode_dirty((__h), (__i), __func__, __LINE__)
227 int __ext4_mark_inode_dirty(handle_t *handle, struct inode *inode,
228 const char *func, unsigned int line);
230 int ext4_expand_extra_isize(struct inode *inode,
231 unsigned int new_extra_isize,
232 struct ext4_iloc *iloc);
234 * Wrapper functions with which ext4 calls into JBD.
236 int __ext4_journal_get_write_access(const char *where, unsigned int line,
237 handle_t *handle, struct buffer_head *bh);
239 int __ext4_forget(const char *where, unsigned int line, handle_t *handle,
240 int is_metadata, struct inode *inode,
241 struct buffer_head *bh, ext4_fsblk_t blocknr);
243 int __ext4_journal_get_create_access(const char *where, unsigned int line,
244 handle_t *handle, struct buffer_head *bh);
246 int __ext4_handle_dirty_metadata(const char *where, unsigned int line,
247 handle_t *handle, struct inode *inode,
248 struct buffer_head *bh);
250 int __ext4_handle_dirty_super(const char *where, unsigned int line,
251 handle_t *handle, struct super_block *sb);
253 #define ext4_journal_get_write_access(handle, bh) \
254 __ext4_journal_get_write_access(__func__, __LINE__, (handle), (bh))
255 #define ext4_forget(handle, is_metadata, inode, bh, block_nr) \
256 __ext4_forget(__func__, __LINE__, (handle), (is_metadata), (inode), \
258 #define ext4_journal_get_create_access(handle, bh) \
259 __ext4_journal_get_create_access(__func__, __LINE__, (handle), (bh))
260 #define ext4_handle_dirty_metadata(handle, inode, bh) \
261 __ext4_handle_dirty_metadata(__func__, __LINE__, (handle), (inode), \
263 #define ext4_handle_dirty_super(handle, sb) \
264 __ext4_handle_dirty_super(__func__, __LINE__, (handle), (sb))
266 handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line,
267 int type, int blocks, int rsv_blocks,
269 int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle);
271 #define EXT4_NOJOURNAL_MAX_REF_COUNT ((unsigned long) 4096)
273 /* Note: Do not use this for NULL handles. This is only to determine if
274 * a properly allocated handle is using a journal or not. */
275 static inline int ext4_handle_valid(handle_t *handle)
277 if ((unsigned long)handle < EXT4_NOJOURNAL_MAX_REF_COUNT)
282 static inline void ext4_handle_sync(handle_t *handle)
284 if (ext4_handle_valid(handle))
288 static inline int ext4_handle_is_aborted(handle_t *handle)
290 if (ext4_handle_valid(handle))
291 return is_handle_aborted(handle);
295 static inline int ext4_free_metadata_revoke_credits(struct super_block *sb,
298 /* Freeing each metadata block can result in freeing one cluster */
299 return blocks * EXT4_SB(sb)->s_cluster_ratio;
302 static inline int ext4_trans_default_revoke_credits(struct super_block *sb)
304 return ext4_free_metadata_revoke_credits(sb, 8);
307 #define ext4_journal_start_sb(sb, type, nblocks) \
308 __ext4_journal_start_sb((sb), __LINE__, (type), (nblocks), 0, \
309 ext4_trans_default_revoke_credits(sb))
311 #define ext4_journal_start(inode, type, nblocks) \
312 __ext4_journal_start((inode), __LINE__, (type), (nblocks), 0, \
313 ext4_trans_default_revoke_credits((inode)->i_sb))
315 #define ext4_journal_start_with_reserve(inode, type, blocks, rsv_blocks)\
316 __ext4_journal_start((inode), __LINE__, (type), (blocks), (rsv_blocks),\
317 ext4_trans_default_revoke_credits((inode)->i_sb))
319 #define ext4_journal_start_with_revoke(inode, type, blocks, revoke_creds) \
320 __ext4_journal_start((inode), __LINE__, (type), (blocks), 0, \
323 static inline handle_t *__ext4_journal_start(struct inode *inode,
324 unsigned int line, int type,
325 int blocks, int rsv_blocks,
328 return __ext4_journal_start_sb(inode->i_sb, line, type, blocks,
329 rsv_blocks, revoke_creds);
332 #define ext4_journal_stop(handle) \
333 __ext4_journal_stop(__func__, __LINE__, (handle))
335 #define ext4_journal_start_reserved(handle, type) \
336 __ext4_journal_start_reserved((handle), __LINE__, (type))
338 handle_t *__ext4_journal_start_reserved(handle_t *handle, unsigned int line,
341 static inline handle_t *ext4_journal_current_handle(void)
343 return journal_current_handle();
346 static inline int ext4_journal_extend(handle_t *handle, int nblocks, int revoke)
348 if (ext4_handle_valid(handle))
349 return jbd2_journal_extend(handle, nblocks, revoke);
353 static inline int ext4_journal_restart(handle_t *handle, int nblocks,
356 if (ext4_handle_valid(handle))
357 return jbd2__journal_restart(handle, nblocks, revoke, GFP_NOFS);
361 int __ext4_journal_ensure_credits(handle_t *handle, int check_cred,
362 int extend_cred, int revoke_cred);
366 * Ensure @handle has at least @check_creds credits available. If not,
367 * transaction will be extended or restarted to contain at least @extend_cred
368 * credits. Before restarting transaction @fn is executed to allow for cleanup
369 * before the transaction is restarted.
371 * The return value is < 0 in case of error, 0 in case the handle has enough
372 * credits or transaction extension succeeded, 1 in case transaction had to be
375 #define ext4_journal_ensure_credits_fn(handle, check_cred, extend_cred, \
378 __label__ __ensure_end; \
379 int err = __ext4_journal_ensure_credits((handle), (check_cred), \
380 (extend_cred), (revoke_cred)); \
387 err = ext4_journal_restart((handle), (extend_cred), (revoke_cred)); \
395 * Ensure given handle has at least requested amount of credits available,
396 * possibly restarting transaction if needed. We also make sure the transaction
397 * has space for at least ext4_trans_default_revoke_credits(sb) revoke records
398 * as freeing one or two blocks is very common pattern and requesting this is
401 static inline int ext4_journal_ensure_credits(handle_t *handle, int credits,
404 return ext4_journal_ensure_credits_fn(handle, credits, credits,
408 static inline int ext4_journal_blocks_per_page(struct inode *inode)
410 if (EXT4_JOURNAL(inode) != NULL)
411 return jbd2_journal_blocks_per_page(inode);
415 static inline int ext4_journal_force_commit(journal_t *journal)
418 return jbd2_journal_force_commit(journal);
422 static inline int ext4_jbd2_inode_add_write(handle_t *handle,
423 struct inode *inode, loff_t start_byte, loff_t length)
425 if (ext4_handle_valid(handle))
426 return jbd2_journal_inode_ranged_write(handle,
427 EXT4_I(inode)->jinode, start_byte, length);
431 static inline int ext4_jbd2_inode_add_wait(handle_t *handle,
432 struct inode *inode, loff_t start_byte, loff_t length)
434 if (ext4_handle_valid(handle))
435 return jbd2_journal_inode_ranged_wait(handle,
436 EXT4_I(inode)->jinode, start_byte, length);
440 static inline void ext4_update_inode_fsync_trans(handle_t *handle,
444 struct ext4_inode_info *ei = EXT4_I(inode);
446 if (ext4_handle_valid(handle) && !is_handle_aborted(handle)) {
447 ei->i_sync_tid = handle->h_transaction->t_tid;
449 ei->i_datasync_tid = handle->h_transaction->t_tid;
454 int ext4_force_commit(struct super_block *sb);
457 * Ext4 inode journal modes
459 #define EXT4_INODE_JOURNAL_DATA_MODE 0x01 /* journal data mode */
460 #define EXT4_INODE_ORDERED_DATA_MODE 0x02 /* ordered data mode */
461 #define EXT4_INODE_WRITEBACK_DATA_MODE 0x04 /* writeback data mode */
463 int ext4_inode_journal_mode(struct inode *inode);
465 static inline int ext4_should_journal_data(struct inode *inode)
467 return ext4_inode_journal_mode(inode) & EXT4_INODE_JOURNAL_DATA_MODE;
470 static inline int ext4_should_order_data(struct inode *inode)
472 return ext4_inode_journal_mode(inode) & EXT4_INODE_ORDERED_DATA_MODE;
475 static inline int ext4_should_writeback_data(struct inode *inode)
477 return ext4_inode_journal_mode(inode) & EXT4_INODE_WRITEBACK_DATA_MODE;
480 static inline int ext4_free_data_revoke_credits(struct inode *inode, int blocks)
482 if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
484 if (!ext4_should_journal_data(inode))
487 * Data blocks in one extent are contiguous, just account for partial
488 * clusters at extent boundaries
490 return blocks + 2*(EXT4_SB(inode->i_sb)->s_cluster_ratio - 1);
494 * This function controls whether or not we should try to go down the
495 * dioread_nolock code paths, which makes it safe to avoid taking
496 * i_mutex for direct I/O reads. This only works for extent-based
497 * files, and it doesn't work if data journaling is enabled, since the
498 * dioread_nolock code uses b_private to pass information back to the
499 * I/O completion handler, and this conflicts with the jbd's use of
502 static inline int ext4_should_dioread_nolock(struct inode *inode)
504 if (!test_opt(inode->i_sb, DIOREAD_NOLOCK))
506 if (!S_ISREG(inode->i_mode))
508 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
510 if (ext4_should_journal_data(inode))
512 /* temporary fix to prevent generic/422 test failures */
513 if (!test_opt(inode->i_sb, DELALLOC))
518 #endif /* _EXT4_JBD2_H */