1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * ext4_jbd2.h |
4 | * |
5 | * Written by Stephen C. Tweedie <sct@redhat.com>, 1999 |
6 | * |
7 | * Copyright 1998--1999 Red Hat corp --- All Rights Reserved |
8 | * |
9 | * Ext4-specific journaling extensions. |
10 | */ |
11 | |
12 | #ifndef _EXT4_JBD2_H |
13 | #define _EXT4_JBD2_H |
14 | |
15 | #include <linux/fs.h> |
16 | #include <linux/jbd2.h> |
17 | #include "ext4.h" |
18 | |
19 | #define EXT4_JOURNAL(inode) (EXT4_SB((inode)->i_sb)->s_journal) |
20 | |
21 | /* Define the number of blocks we need to account to a transaction to |
22 | * modify one block of data. |
23 | * |
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. |
27 | * |
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 |
31 | */ |
32 | |
33 | #define EXT4_SINGLEDATA_TRANS_BLOCKS(sb) \ |
34 | (ext4_has_feature_extents(sb) ? 20U : 8U) |
35 | |
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. */ |
39 | |
40 | #define EXT4_XATTR_TRANS_BLOCKS 6U |
41 | |
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. */ |
47 | |
48 | #define EXT4_DATA_TRANS_BLOCKS(sb) (EXT4_SINGLEDATA_TRANS_BLOCKS(sb) + \ |
49 | EXT4_XATTR_TRANS_BLOCKS - 2 + \ |
50 | EXT4_MAXQUOTAS_TRANS_BLOCKS(sb)) |
51 | |
52 | /* |
53 | * Define the number of metadata blocks we need to account to modify data. |
54 | * |
55 | * This include super block, inode block, quota blocks and xattr blocks |
56 | */ |
57 | #define EXT4_META_TRANS_BLOCKS(sb) (EXT4_XATTR_TRANS_BLOCKS + \ |
58 | EXT4_MAXQUOTAS_TRANS_BLOCKS(sb)) |
59 | |
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. */ |
65 | |
66 | #define EXT4_MAX_TRANS_DATA 64U |
67 | |
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 |
73 | * needed. */ |
74 | |
75 | #define EXT4_RESERVE_TRANS_BLOCKS 12U |
76 | |
77 | /* |
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. |
83 | */ |
84 | #define 12U |
85 | |
86 | #ifdef CONFIG_QUOTA |
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) ((ext4_quota_capable(sb)) ? 1 : 0) |
90 | /* Amount of blocks needed for quota insert/delete - we do some block writes |
91 | * but inode, sb and group updates are done only once */ |
92 | #define EXT4_QUOTA_INIT_BLOCKS(sb) ((ext4_quota_capable(sb)) ?\ |
93 | (DQUOT_INIT_ALLOC*(EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)\ |
94 | +3+DQUOT_INIT_REWRITE) : 0) |
95 | |
96 | #define EXT4_QUOTA_DEL_BLOCKS(sb) ((ext4_quota_capable(sb)) ?\ |
97 | (DQUOT_DEL_ALLOC*(EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)\ |
98 | +3+DQUOT_DEL_REWRITE) : 0) |
99 | #else |
100 | #define EXT4_QUOTA_TRANS_BLOCKS(sb) 0 |
101 | #define EXT4_QUOTA_INIT_BLOCKS(sb) 0 |
102 | #define EXT4_QUOTA_DEL_BLOCKS(sb) 0 |
103 | #endif |
104 | #define EXT4_MAXQUOTAS_TRANS_BLOCKS(sb) (EXT4_MAXQUOTAS*EXT4_QUOTA_TRANS_BLOCKS(sb)) |
105 | #define EXT4_MAXQUOTAS_INIT_BLOCKS(sb) (EXT4_MAXQUOTAS*EXT4_QUOTA_INIT_BLOCKS(sb)) |
106 | #define EXT4_MAXQUOTAS_DEL_BLOCKS(sb) (EXT4_MAXQUOTAS*EXT4_QUOTA_DEL_BLOCKS(sb)) |
107 | |
108 | /* |
109 | * Ext4 handle operation types -- for logging purposes |
110 | */ |
111 | #define EXT4_HT_MISC 0 |
112 | #define EXT4_HT_INODE 1 |
113 | #define EXT4_HT_WRITE_PAGE 2 |
114 | #define EXT4_HT_MAP_BLOCKS 3 |
115 | #define EXT4_HT_DIR 4 |
116 | #define EXT4_HT_TRUNCATE 5 |
117 | #define EXT4_HT_QUOTA 6 |
118 | #define EXT4_HT_RESIZE 7 |
119 | #define EXT4_HT_MIGRATE 8 |
120 | #define EXT4_HT_MOVE_EXTENTS 9 |
121 | #define EXT4_HT_XATTR 10 |
122 | #define EXT4_HT_EXT_CONVERT 11 |
123 | #define EXT4_HT_MAX 12 |
124 | |
125 | /** |
126 | * struct ext4_journal_cb_entry - Base structure for callback information. |
127 | * |
128 | * This struct is a 'seed' structure for a using with your own callback |
129 | * structs. If you are using callbacks you must allocate one of these |
130 | * or another struct of your own definition which has this struct |
131 | * as it's first element and pass it to ext4_journal_callback_add(). |
132 | */ |
133 | struct ext4_journal_cb_entry { |
134 | /* list information for other callbacks attached to the same handle */ |
135 | struct list_head jce_list; |
136 | |
137 | /* Function to call with this callback structure */ |
138 | void (*jce_func)(struct super_block *sb, |
139 | struct ext4_journal_cb_entry *jce, int error); |
140 | |
141 | /* user data goes here */ |
142 | }; |
143 | |
144 | /** |
145 | * ext4_journal_callback_add: add a function to call after transaction commit |
146 | * @handle: active journal transaction handle to register callback on |
147 | * @func: callback function to call after the transaction has committed: |
148 | * @sb: superblock of current filesystem for transaction |
149 | * @jce: returned journal callback data |
150 | * @rc: journal state at commit (0 = transaction committed properly) |
151 | * @jce: journal callback data (internal and function private data struct) |
152 | * |
153 | * The registered function will be called in the context of the journal thread |
154 | * after the transaction for which the handle was created has completed. |
155 | * |
156 | * No locks are held when the callback function is called, so it is safe to |
157 | * call blocking functions from within the callback, but the callback should |
158 | * not block or run for too long, or the filesystem will be blocked waiting for |
159 | * the next transaction to commit. No journaling functions can be used, or |
160 | * there is a risk of deadlock. |
161 | * |
162 | * There is no guaranteed calling order of multiple registered callbacks on |
163 | * the same transaction. |
164 | */ |
165 | static inline void _ext4_journal_callback_add(handle_t *handle, |
166 | struct ext4_journal_cb_entry *jce) |
167 | { |
168 | /* Add the jce to transaction's private list */ |
169 | list_add_tail(new: &jce->jce_list, head: &handle->h_transaction->t_private_list); |
170 | } |
171 | |
172 | static inline void ext4_journal_callback_add(handle_t *handle, |
173 | void (*func)(struct super_block *sb, |
174 | struct ext4_journal_cb_entry *jce, |
175 | int rc), |
176 | struct ext4_journal_cb_entry *jce) |
177 | { |
178 | struct ext4_sb_info *sbi = |
179 | EXT4_SB(sb: handle->h_transaction->t_journal->j_private); |
180 | |
181 | /* Add the jce to transaction's private list */ |
182 | jce->jce_func = func; |
183 | spin_lock(lock: &sbi->s_md_lock); |
184 | _ext4_journal_callback_add(handle, jce); |
185 | spin_unlock(lock: &sbi->s_md_lock); |
186 | } |
187 | |
188 | |
189 | /** |
190 | * ext4_journal_callback_del: delete a registered callback |
191 | * @handle: active journal transaction handle on which callback was registered |
192 | * @jce: registered journal callback entry to unregister |
193 | * Return true if object was successfully removed |
194 | */ |
195 | static inline bool ext4_journal_callback_try_del(handle_t *handle, |
196 | struct ext4_journal_cb_entry *jce) |
197 | { |
198 | bool deleted; |
199 | struct ext4_sb_info *sbi = |
200 | EXT4_SB(sb: handle->h_transaction->t_journal->j_private); |
201 | |
202 | spin_lock(lock: &sbi->s_md_lock); |
203 | deleted = !list_empty(head: &jce->jce_list); |
204 | list_del_init(entry: &jce->jce_list); |
205 | spin_unlock(lock: &sbi->s_md_lock); |
206 | return deleted; |
207 | } |
208 | |
209 | int |
210 | ext4_mark_iloc_dirty(handle_t *handle, |
211 | struct inode *inode, |
212 | struct ext4_iloc *iloc); |
213 | |
214 | /* |
215 | * On success, We end up with an outstanding reference count against |
216 | * iloc->bh. This _must_ be cleaned up later. |
217 | */ |
218 | |
219 | int ext4_reserve_inode_write(handle_t *handle, struct inode *inode, |
220 | struct ext4_iloc *iloc); |
221 | |
222 | #define ext4_mark_inode_dirty(__h, __i) \ |
223 | __ext4_mark_inode_dirty((__h), (__i), __func__, __LINE__) |
224 | int __ext4_mark_inode_dirty(handle_t *handle, struct inode *inode, |
225 | const char *func, unsigned int line); |
226 | |
227 | int ext4_expand_extra_isize(struct inode *inode, |
228 | unsigned int , |
229 | struct ext4_iloc *iloc); |
230 | /* |
231 | * Wrapper functions with which ext4 calls into JBD. |
232 | */ |
233 | int __ext4_journal_get_write_access(const char *where, unsigned int line, |
234 | handle_t *handle, struct super_block *sb, |
235 | struct buffer_head *bh, |
236 | enum ext4_journal_trigger_type trigger_type); |
237 | |
238 | int __ext4_forget(const char *where, unsigned int line, handle_t *handle, |
239 | int is_metadata, struct inode *inode, |
240 | struct buffer_head *bh, ext4_fsblk_t blocknr); |
241 | |
242 | int __ext4_journal_get_create_access(const char *where, unsigned int line, |
243 | handle_t *handle, struct super_block *sb, |
244 | struct buffer_head *bh, |
245 | enum ext4_journal_trigger_type trigger_type); |
246 | |
247 | int __ext4_handle_dirty_metadata(const char *where, unsigned int line, |
248 | handle_t *handle, struct inode *inode, |
249 | struct buffer_head *bh); |
250 | |
251 | #define ext4_journal_get_write_access(handle, sb, bh, trigger_type) \ |
252 | __ext4_journal_get_write_access(__func__, __LINE__, (handle), (sb), \ |
253 | (bh), (trigger_type)) |
254 | #define ext4_forget(handle, is_metadata, inode, bh, block_nr) \ |
255 | __ext4_forget(__func__, __LINE__, (handle), (is_metadata), (inode), \ |
256 | (bh), (block_nr)) |
257 | #define ext4_journal_get_create_access(handle, sb, bh, trigger_type) \ |
258 | __ext4_journal_get_create_access(__func__, __LINE__, (handle), (sb), \ |
259 | (bh), (trigger_type)) |
260 | #define ext4_handle_dirty_metadata(handle, inode, bh) \ |
261 | __ext4_handle_dirty_metadata(__func__, __LINE__, (handle), (inode), \ |
262 | (bh)) |
263 | |
264 | handle_t *__ext4_journal_start_sb(struct inode *inode, struct super_block *sb, |
265 | unsigned int line, int type, int blocks, |
266 | int rsv_blocks, int revoke_creds); |
267 | int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle); |
268 | |
269 | #define EXT4_NOJOURNAL_MAX_REF_COUNT ((unsigned long) 4096) |
270 | |
271 | /* Note: Do not use this for NULL handles. This is only to determine if |
272 | * a properly allocated handle is using a journal or not. */ |
273 | static inline int ext4_handle_valid(handle_t *handle) |
274 | { |
275 | if ((unsigned long)handle < EXT4_NOJOURNAL_MAX_REF_COUNT) |
276 | return 0; |
277 | return 1; |
278 | } |
279 | |
280 | static inline void ext4_handle_sync(handle_t *handle) |
281 | { |
282 | if (ext4_handle_valid(handle)) |
283 | handle->h_sync = 1; |
284 | } |
285 | |
286 | static inline int ext4_handle_is_aborted(handle_t *handle) |
287 | { |
288 | if (ext4_handle_valid(handle)) |
289 | return is_handle_aborted(handle); |
290 | return 0; |
291 | } |
292 | |
293 | static inline int ext4_free_metadata_revoke_credits(struct super_block *sb, |
294 | int blocks) |
295 | { |
296 | /* Freeing each metadata block can result in freeing one cluster */ |
297 | return blocks * EXT4_SB(sb)->s_cluster_ratio; |
298 | } |
299 | |
300 | static inline int ext4_trans_default_revoke_credits(struct super_block *sb) |
301 | { |
302 | return ext4_free_metadata_revoke_credits(sb, blocks: 8); |
303 | } |
304 | |
305 | #define ext4_journal_start_sb(sb, type, nblocks) \ |
306 | __ext4_journal_start_sb(NULL, (sb), __LINE__, (type), (nblocks), 0,\ |
307 | ext4_trans_default_revoke_credits(sb)) |
308 | |
309 | #define ext4_journal_start(inode, type, nblocks) \ |
310 | __ext4_journal_start((inode), __LINE__, (type), (nblocks), 0, \ |
311 | ext4_trans_default_revoke_credits((inode)->i_sb)) |
312 | |
313 | #define ext4_journal_start_with_reserve(inode, type, blocks, rsv_blocks)\ |
314 | __ext4_journal_start((inode), __LINE__, (type), (blocks), (rsv_blocks),\ |
315 | ext4_trans_default_revoke_credits((inode)->i_sb)) |
316 | |
317 | #define ext4_journal_start_with_revoke(inode, type, blocks, revoke_creds) \ |
318 | __ext4_journal_start((inode), __LINE__, (type), (blocks), 0, \ |
319 | (revoke_creds)) |
320 | |
321 | static inline handle_t *__ext4_journal_start(struct inode *inode, |
322 | unsigned int line, int type, |
323 | int blocks, int rsv_blocks, |
324 | int revoke_creds) |
325 | { |
326 | return __ext4_journal_start_sb(inode, sb: inode->i_sb, line, type, blocks, |
327 | rsv_blocks, revoke_creds); |
328 | } |
329 | |
330 | #define ext4_journal_stop(handle) \ |
331 | __ext4_journal_stop(__func__, __LINE__, (handle)) |
332 | |
333 | #define ext4_journal_start_reserved(handle, type) \ |
334 | __ext4_journal_start_reserved((handle), __LINE__, (type)) |
335 | |
336 | handle_t *__ext4_journal_start_reserved(handle_t *handle, unsigned int line, |
337 | int type); |
338 | |
339 | static inline handle_t *ext4_journal_current_handle(void) |
340 | { |
341 | return journal_current_handle(); |
342 | } |
343 | |
344 | static inline int ext4_journal_extend(handle_t *handle, int nblocks, int revoke) |
345 | { |
346 | if (ext4_handle_valid(handle)) |
347 | return jbd2_journal_extend(handle, nblocks, revoke_records: revoke); |
348 | return 0; |
349 | } |
350 | |
351 | static inline int ext4_journal_restart(handle_t *handle, int nblocks, |
352 | int revoke) |
353 | { |
354 | if (ext4_handle_valid(handle)) |
355 | return jbd2__journal_restart(handle, nblocks, revoke_records: revoke, GFP_NOFS); |
356 | return 0; |
357 | } |
358 | |
359 | int __ext4_journal_ensure_credits(handle_t *handle, int check_cred, |
360 | int extend_cred, int revoke_cred); |
361 | |
362 | |
363 | /* |
364 | * Ensure @handle has at least @check_creds credits available. If not, |
365 | * transaction will be extended or restarted to contain at least @extend_cred |
366 | * credits. Before restarting transaction @fn is executed to allow for cleanup |
367 | * before the transaction is restarted. |
368 | * |
369 | * The return value is < 0 in case of error, 0 in case the handle has enough |
370 | * credits or transaction extension succeeded, 1 in case transaction had to be |
371 | * restarted. |
372 | */ |
373 | #define ext4_journal_ensure_credits_fn(handle, check_cred, extend_cred, \ |
374 | revoke_cred, fn) \ |
375 | ({ \ |
376 | __label__ __ensure_end; \ |
377 | int err = __ext4_journal_ensure_credits((handle), (check_cred), \ |
378 | (extend_cred), (revoke_cred)); \ |
379 | \ |
380 | if (err <= 0) \ |
381 | goto __ensure_end; \ |
382 | err = (fn); \ |
383 | if (err < 0) \ |
384 | goto __ensure_end; \ |
385 | err = ext4_journal_restart((handle), (extend_cred), (revoke_cred)); \ |
386 | if (err == 0) \ |
387 | err = 1; \ |
388 | __ensure_end: \ |
389 | err; \ |
390 | }) |
391 | |
392 | /* |
393 | * Ensure given handle has at least requested amount of credits available, |
394 | * possibly restarting transaction if needed. We also make sure the transaction |
395 | * has space for at least ext4_trans_default_revoke_credits(sb) revoke records |
396 | * as freeing one or two blocks is very common pattern and requesting this is |
397 | * very cheap. |
398 | */ |
399 | static inline int ext4_journal_ensure_credits(handle_t *handle, int credits, |
400 | int revoke_creds) |
401 | { |
402 | return ext4_journal_ensure_credits_fn(handle, credits, credits, |
403 | revoke_creds, 0); |
404 | } |
405 | |
406 | static inline int ext4_journal_blocks_per_page(struct inode *inode) |
407 | { |
408 | if (EXT4_JOURNAL(inode) != NULL) |
409 | return jbd2_journal_blocks_per_page(inode); |
410 | return 0; |
411 | } |
412 | |
413 | static inline int ext4_journal_force_commit(journal_t *journal) |
414 | { |
415 | if (journal) |
416 | return jbd2_journal_force_commit(journal); |
417 | return 0; |
418 | } |
419 | |
420 | static inline int ext4_jbd2_inode_add_write(handle_t *handle, |
421 | struct inode *inode, loff_t start_byte, loff_t length) |
422 | { |
423 | if (ext4_handle_valid(handle)) |
424 | return jbd2_journal_inode_ranged_write(handle, |
425 | inode: EXT4_I(inode)->jinode, start_byte, length); |
426 | return 0; |
427 | } |
428 | |
429 | static inline int ext4_jbd2_inode_add_wait(handle_t *handle, |
430 | struct inode *inode, loff_t start_byte, loff_t length) |
431 | { |
432 | if (ext4_handle_valid(handle)) |
433 | return jbd2_journal_inode_ranged_wait(handle, |
434 | inode: EXT4_I(inode)->jinode, start_byte, length); |
435 | return 0; |
436 | } |
437 | |
438 | static inline void ext4_update_inode_fsync_trans(handle_t *handle, |
439 | struct inode *inode, |
440 | int datasync) |
441 | { |
442 | struct ext4_inode_info *ei = EXT4_I(inode); |
443 | |
444 | if (ext4_handle_valid(handle) && !is_handle_aborted(handle)) { |
445 | ei->i_sync_tid = handle->h_transaction->t_tid; |
446 | if (datasync) |
447 | ei->i_datasync_tid = handle->h_transaction->t_tid; |
448 | } |
449 | } |
450 | |
451 | /* super.c */ |
452 | int ext4_force_commit(struct super_block *sb); |
453 | |
454 | /* |
455 | * Ext4 inode journal modes |
456 | */ |
457 | #define EXT4_INODE_JOURNAL_DATA_MODE 0x01 /* journal data mode */ |
458 | #define EXT4_INODE_ORDERED_DATA_MODE 0x02 /* ordered data mode */ |
459 | #define EXT4_INODE_WRITEBACK_DATA_MODE 0x04 /* writeback data mode */ |
460 | |
461 | int ext4_inode_journal_mode(struct inode *inode); |
462 | |
463 | static inline int ext4_should_journal_data(struct inode *inode) |
464 | { |
465 | return ext4_inode_journal_mode(inode) & EXT4_INODE_JOURNAL_DATA_MODE; |
466 | } |
467 | |
468 | static inline int ext4_should_order_data(struct inode *inode) |
469 | { |
470 | return ext4_inode_journal_mode(inode) & EXT4_INODE_ORDERED_DATA_MODE; |
471 | } |
472 | |
473 | static inline int ext4_should_writeback_data(struct inode *inode) |
474 | { |
475 | return ext4_inode_journal_mode(inode) & EXT4_INODE_WRITEBACK_DATA_MODE; |
476 | } |
477 | |
478 | static inline int ext4_free_data_revoke_credits(struct inode *inode, int blocks) |
479 | { |
480 | if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) |
481 | return 0; |
482 | if (!ext4_should_journal_data(inode)) |
483 | return 0; |
484 | /* |
485 | * Data blocks in one extent are contiguous, just account for partial |
486 | * clusters at extent boundaries |
487 | */ |
488 | return blocks + 2*(EXT4_SB(sb: inode->i_sb)->s_cluster_ratio - 1); |
489 | } |
490 | |
491 | /* |
492 | * This function controls whether or not we should try to go down the |
493 | * dioread_nolock code paths, which makes it safe to avoid taking |
494 | * i_rwsem for direct I/O reads. This only works for extent-based |
495 | * files, and it doesn't work if data journaling is enabled, since the |
496 | * dioread_nolock code uses b_private to pass information back to the |
497 | * I/O completion handler, and this conflicts with the jbd's use of |
498 | * b_private. |
499 | */ |
500 | static inline int ext4_should_dioread_nolock(struct inode *inode) |
501 | { |
502 | if (!test_opt(inode->i_sb, DIOREAD_NOLOCK)) |
503 | return 0; |
504 | if (!S_ISREG(inode->i_mode)) |
505 | return 0; |
506 | if (!(ext4_test_inode_flag(inode, bit: EXT4_INODE_EXTENTS))) |
507 | return 0; |
508 | if (ext4_should_journal_data(inode)) |
509 | return 0; |
510 | /* temporary fix to prevent generic/422 test failures */ |
511 | if (!test_opt(inode->i_sb, DELALLOC)) |
512 | return 0; |
513 | return 1; |
514 | } |
515 | |
516 | #endif /* _EXT4_JBD2_H */ |
517 | |