diff options
Diffstat (limited to 'fs/ext4/ext4_jbd2.h')
-rw-r--r-- | fs/ext4/ext4_jbd2.h | 231 |
1 files changed, 231 insertions, 0 deletions
diff --git a/fs/ext4/ext4_jbd2.h b/fs/ext4/ext4_jbd2.h new file mode 100644 index 000000000000..9255a7d28b24 --- /dev/null +++ b/fs/ext4/ext4_jbd2.h | |||
@@ -0,0 +1,231 @@ | |||
1 | /* | ||
2 | * ext4_jbd2.h | ||
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 | |||
15 | #ifndef _EXT4_JBD2_H | ||
16 | #define _EXT4_JBD2_H | ||
17 | |||
18 | #include <linux/fs.h> | ||
19 | #include <linux/jbd2.h> | ||
20 | #include "ext4.h" | ||
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 | ||
29 | * block to complete the transaction. | ||
30 | * | ||
31 | * For extents-enabled fs we may have to allocate and modify up to | ||
32 | * 5 levels of tree + root which are stored in the inode. */ | ||
33 | |||
34 | #define EXT4_SINGLEDATA_TRANS_BLOCKS(sb) \ | ||
35 | (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS) \ | ||
36 | || test_opt(sb, EXTENTS) ? 27U : 8U) | ||
37 | |||
38 | /* Extended attribute operations touch at most two data buffers, | ||
39 | * two bitmap buffers, and two group summaries, in addition to the inode | ||
40 | * and the superblock, which are already accounted for. */ | ||
41 | |||
42 | #define EXT4_XATTR_TRANS_BLOCKS 6U | ||
43 | |||
44 | /* Define the minimum size for a transaction which modifies data. This | ||
45 | * needs to take into account the fact that we may end up modifying two | ||
46 | * quota files too (one for the group, one for the user quota). The | ||
47 | * superblock only gets updated once, of course, so don't bother | ||
48 | * counting that again for the quota updates. */ | ||
49 | |||
50 | #define EXT4_DATA_TRANS_BLOCKS(sb) (EXT4_SINGLEDATA_TRANS_BLOCKS(sb) + \ | ||
51 | EXT4_XATTR_TRANS_BLOCKS - 2 + \ | ||
52 | 2*EXT4_QUOTA_TRANS_BLOCKS(sb)) | ||
53 | |||
54 | /* Delete operations potentially hit one directory's namespace plus an | ||
55 | * entire inode, plus arbitrary amounts of bitmap/indirection data. Be | ||
56 | * generous. We can grow the delete transaction later if necessary. */ | ||
57 | |||
58 | #define EXT4_DELETE_TRANS_BLOCKS(sb) (2 * EXT4_DATA_TRANS_BLOCKS(sb) + 64) | ||
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 | #define EXT4_INDEX_EXTRA_TRANS_BLOCKS 8 | ||
78 | |||
79 | #ifdef CONFIG_QUOTA | ||
80 | /* Amount of blocks needed for quota update - we know that the structure was | ||
81 | * allocated so we need to update only inode+data */ | ||
82 | #define EXT4_QUOTA_TRANS_BLOCKS(sb) (test_opt(sb, QUOTA) ? 2 : 0) | ||
83 | /* Amount of blocks needed for quota insert/delete - we do some block writes | ||
84 | * but inode, sb and group updates are done only once */ | ||
85 | #define EXT4_QUOTA_INIT_BLOCKS(sb) (test_opt(sb, QUOTA) ? (DQUOT_INIT_ALLOC*\ | ||
86 | (EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)+3+DQUOT_INIT_REWRITE) : 0) | ||
87 | #define EXT4_QUOTA_DEL_BLOCKS(sb) (test_opt(sb, QUOTA) ? (DQUOT_DEL_ALLOC*\ | ||
88 | (EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)+3+DQUOT_DEL_REWRITE) : 0) | ||
89 | #else | ||
90 | #define EXT4_QUOTA_TRANS_BLOCKS(sb) 0 | ||
91 | #define EXT4_QUOTA_INIT_BLOCKS(sb) 0 | ||
92 | #define EXT4_QUOTA_DEL_BLOCKS(sb) 0 | ||
93 | #endif | ||
94 | |||
95 | int | ||
96 | ext4_mark_iloc_dirty(handle_t *handle, | ||
97 | struct inode *inode, | ||
98 | struct ext4_iloc *iloc); | ||
99 | |||
100 | /* | ||
101 | * On success, We end up with an outstanding reference count against | ||
102 | * iloc->bh. This _must_ be cleaned up later. | ||
103 | */ | ||
104 | |||
105 | int ext4_reserve_inode_write(handle_t *handle, struct inode *inode, | ||
106 | struct ext4_iloc *iloc); | ||
107 | |||
108 | int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode); | ||
109 | |||
110 | /* | ||
111 | * Wrapper functions with which ext4 calls into JBD. The intent here is | ||
112 | * to allow these to be turned into appropriate stubs so ext4 can control | ||
113 | * ext2 filesystems, so ext2+ext4 systems only nee one fs. This work hasn't | ||
114 | * been done yet. | ||
115 | */ | ||
116 | |||
117 | static inline void ext4_journal_release_buffer(handle_t *handle, | ||
118 | struct buffer_head *bh) | ||
119 | { | ||
120 | jbd2_journal_release_buffer(handle, bh); | ||
121 | } | ||
122 | |||
123 | void ext4_journal_abort_handle(const char *caller, const char *err_fn, | ||
124 | struct buffer_head *bh, handle_t *handle, int err); | ||
125 | |||
126 | int __ext4_journal_get_undo_access(const char *where, handle_t *handle, | ||
127 | struct buffer_head *bh); | ||
128 | |||
129 | int __ext4_journal_get_write_access(const char *where, handle_t *handle, | ||
130 | struct buffer_head *bh); | ||
131 | |||
132 | int __ext4_journal_forget(const char *where, handle_t *handle, | ||
133 | struct buffer_head *bh); | ||
134 | |||
135 | int __ext4_journal_revoke(const char *where, handle_t *handle, | ||
136 | ext4_fsblk_t blocknr, struct buffer_head *bh); | ||
137 | |||
138 | int __ext4_journal_get_create_access(const char *where, | ||
139 | handle_t *handle, struct buffer_head *bh); | ||
140 | |||
141 | int __ext4_journal_dirty_metadata(const char *where, | ||
142 | handle_t *handle, struct buffer_head *bh); | ||
143 | |||
144 | #define ext4_journal_get_undo_access(handle, bh) \ | ||
145 | __ext4_journal_get_undo_access(__FUNCTION__, (handle), (bh)) | ||
146 | #define ext4_journal_get_write_access(handle, bh) \ | ||
147 | __ext4_journal_get_write_access(__FUNCTION__, (handle), (bh)) | ||
148 | #define ext4_journal_revoke(handle, blocknr, bh) \ | ||
149 | __ext4_journal_revoke(__FUNCTION__, (handle), (blocknr), (bh)) | ||
150 | #define ext4_journal_get_create_access(handle, bh) \ | ||
151 | __ext4_journal_get_create_access(__FUNCTION__, (handle), (bh)) | ||
152 | #define ext4_journal_dirty_metadata(handle, bh) \ | ||
153 | __ext4_journal_dirty_metadata(__FUNCTION__, (handle), (bh)) | ||
154 | #define ext4_journal_forget(handle, bh) \ | ||
155 | __ext4_journal_forget(__FUNCTION__, (handle), (bh)) | ||
156 | |||
157 | int ext4_journal_dirty_data(handle_t *handle, struct buffer_head *bh); | ||
158 | |||
159 | handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks); | ||
160 | int __ext4_journal_stop(const char *where, handle_t *handle); | ||
161 | |||
162 | static inline handle_t *ext4_journal_start(struct inode *inode, int nblocks) | ||
163 | { | ||
164 | return ext4_journal_start_sb(inode->i_sb, nblocks); | ||
165 | } | ||
166 | |||
167 | #define ext4_journal_stop(handle) \ | ||
168 | __ext4_journal_stop(__FUNCTION__, (handle)) | ||
169 | |||
170 | static inline handle_t *ext4_journal_current_handle(void) | ||
171 | { | ||
172 | return journal_current_handle(); | ||
173 | } | ||
174 | |||
175 | static inline int ext4_journal_extend(handle_t *handle, int nblocks) | ||
176 | { | ||
177 | return jbd2_journal_extend(handle, nblocks); | ||
178 | } | ||
179 | |||
180 | static inline int ext4_journal_restart(handle_t *handle, int nblocks) | ||
181 | { | ||
182 | return jbd2_journal_restart(handle, nblocks); | ||
183 | } | ||
184 | |||
185 | static inline int ext4_journal_blocks_per_page(struct inode *inode) | ||
186 | { | ||
187 | return jbd2_journal_blocks_per_page(inode); | ||
188 | } | ||
189 | |||
190 | static inline int ext4_journal_force_commit(journal_t *journal) | ||
191 | { | ||
192 | return jbd2_journal_force_commit(journal); | ||
193 | } | ||
194 | |||
195 | /* super.c */ | ||
196 | int ext4_force_commit(struct super_block *sb); | ||
197 | |||
198 | static inline int ext4_should_journal_data(struct inode *inode) | ||
199 | { | ||
200 | if (!S_ISREG(inode->i_mode)) | ||
201 | return 1; | ||
202 | if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) | ||
203 | return 1; | ||
204 | if (EXT4_I(inode)->i_flags & EXT4_JOURNAL_DATA_FL) | ||
205 | return 1; | ||
206 | return 0; | ||
207 | } | ||
208 | |||
209 | static inline int ext4_should_order_data(struct inode *inode) | ||
210 | { | ||
211 | if (!S_ISREG(inode->i_mode)) | ||
212 | return 0; | ||
213 | if (EXT4_I(inode)->i_flags & EXT4_JOURNAL_DATA_FL) | ||
214 | return 0; | ||
215 | if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA) | ||
216 | return 1; | ||
217 | return 0; | ||
218 | } | ||
219 | |||
220 | static inline int ext4_should_writeback_data(struct inode *inode) | ||
221 | { | ||
222 | if (!S_ISREG(inode->i_mode)) | ||
223 | return 0; | ||
224 | if (EXT4_I(inode)->i_flags & EXT4_JOURNAL_DATA_FL) | ||
225 | return 0; | ||
226 | if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA) | ||
227 | return 1; | ||
228 | return 0; | ||
229 | } | ||
230 | |||
231 | #endif /* _EXT4_JBD2_H */ | ||