| blob | c8aec34089ee82a5abc6a4e7cc10773f86423cff |
1 jbd2: clean up feature test macros with predicate functions
3 From: "Darrick J. Wong" <darrick.wong@oracle.com>
5 Create separate predicate functions to test/set/clear feature flags,
6 thereby replacing the wordy old macros. Furthermore, clean out the
7 places where we open-coded feature tests.
9 Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
10 Signed-off-by: Theodore Ts'o <tytso@mit.edu>
11 ---
12 fs/jbd2/commit.c | 22 ++++++---------
13 fs/jbd2/journal.c | 12 ++++----
14 fs/jbd2/recovery.c | 18 +++++--------
15 fs/jbd2/revoke.c | 4 +--
16 include/linux/jbd2.h | 71 ++++++++++++++++++++++++++++++++++++++++++++++++--
17 5 files changed, 91 insertions(+), 36 deletions(-)
20 diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
21 index 362e5f6..36345fe 100644
22 --- a/fs/jbd2/commit.c
23 +++ b/fs/jbd2/commit.c
24 @@ -142,8 +142,7 @@ static int journal_submit_commit_record(journal_t *journal,
25 tmp->h_commit_sec = cpu_to_be64(now.tv_sec);
26 tmp->h_commit_nsec = cpu_to_be32(now.tv_nsec);
28 - if (JBD2_HAS_COMPAT_FEATURE(journal,
29 - JBD2_FEATURE_COMPAT_CHECKSUM)) {
30 + if (jbd2_has_feature_checksum(journal)) {
31 tmp->h_chksum_type = JBD2_CRC32_CHKSUM;
32 tmp->h_chksum_size = JBD2_CRC32_CHKSUM_SIZE;
33 tmp->h_chksum[0] = cpu_to_be32(crc32_sum);
34 @@ -157,8 +156,7 @@ static int journal_submit_commit_record(journal_t *journal,
35 bh->b_end_io = journal_end_buffer_io_sync;
37 if (journal->j_flags & JBD2_BARRIER &&
38 - !JBD2_HAS_INCOMPAT_FEATURE(journal,
39 - JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT))
40 + !jbd2_has_feature_async_commit(journal))
41 ret = submit_bh(WRITE_SYNC | WRITE_FLUSH_FUA, bh);
42 else
43 ret = submit_bh(WRITE_SYNC, bh);
44 @@ -317,7 +315,7 @@ static void write_tag_block(journal_t *j, journal_block_tag_t *tag,
45 unsigned long long block)
46 {
47 tag->t_blocknr = cpu_to_be32(block & (u32)~0);
48 - if (JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_64BIT))
49 + if (jbd2_has_feature_64bit(j))
50 tag->t_blocknr_high = cpu_to_be32((block >> 31) >> 1);
51 }
53 @@ -356,7 +354,7 @@ static void jbd2_block_tag_csum_set(journal_t *j, journal_block_tag_t *tag,
54 bh->b_size);
55 kunmap_atomic(addr);
57 - if (JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V3))
58 + if (jbd2_has_feature_csum3(j))
59 tag3->t_checksum = cpu_to_be32(csum32);
60 else
61 tag->t_checksum = cpu_to_be16(csum32);
62 @@ -730,8 +728,7 @@ start_journal_io:
63 /*
64 * Compute checksum.
65 */
66 - if (JBD2_HAS_COMPAT_FEATURE(journal,
67 - JBD2_FEATURE_COMPAT_CHECKSUM)) {
68 + if (jbd2_has_feature_checksum(journal)) {
69 crc32_sum =
70 jbd2_checksum_data(crc32_sum, bh);
71 }
72 @@ -797,8 +794,7 @@ start_journal_io:
73 blkdev_issue_flush(journal->j_fs_dev, GFP_NOFS, NULL);
75 /* Done it all: now write the commit record asynchronously. */
76 - if (JBD2_HAS_INCOMPAT_FEATURE(journal,
77 - JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
78 + if (jbd2_has_feature_async_commit(journal)) {
79 err = journal_submit_commit_record(journal, commit_transaction,
80 &cbh, crc32_sum);
81 if (err)
82 @@ -889,8 +885,7 @@ start_journal_io:
83 commit_transaction->t_state = T_COMMIT_JFLUSH;
84 write_unlock(&journal->j_state_lock);
86 - if (!JBD2_HAS_INCOMPAT_FEATURE(journal,
87 - JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
88 + if (!jbd2_has_feature_async_commit(journal)) {
89 err = journal_submit_commit_record(journal, commit_transaction,
90 &cbh, crc32_sum);
91 if (err)
92 @@ -898,8 +893,7 @@ start_journal_io:
93 }
94 if (cbh)
95 err = journal_wait_on_commit_record(journal, cbh);
96 - if (JBD2_HAS_INCOMPAT_FEATURE(journal,
97 - JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT) &&
98 + if (jbd2_has_feature_async_commit(journal) &&
99 journal->j_flags & JBD2_BARRIER) {
100 blkdev_issue_flush(journal->j_dev, GFP_NOFS, NULL);
101 }
102 diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
103 index 474c178..eb8a754 100644
104 --- a/fs/jbd2/journal.c
105 +++ b/fs/jbd2/journal.c
106 @@ -1523,8 +1523,8 @@ static int journal_get_superblock(journal_t *journal)
107 goto out;
108 }
110 - if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2) &&
111 - JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V3)) {
112 + if (jbd2_has_feature_csum2(journal) &&
113 + jbd2_has_feature_csum3(journal)) {
114 /* Can't have checksum v2 and v3 at the same time! */
115 printk(KERN_ERR "JBD2: Can't enable checksumming v2 and v3 "
116 "at the same time!\n");
117 @@ -1532,7 +1532,7 @@ static int journal_get_superblock(journal_t *journal)
118 }
120 if (jbd2_journal_has_csum_v2or3_feature(journal) &&
121 - JBD2_HAS_COMPAT_FEATURE(journal, JBD2_FEATURE_COMPAT_CHECKSUM)) {
122 + jbd2_has_feature_checksum(journal)) {
123 /* Can't have checksum v1 and v2 on at the same time! */
124 printk(KERN_ERR "JBD2: Can't enable checksumming v1 and v2/3 "
125 "at the same time!\n");
126 @@ -2198,15 +2198,15 @@ size_t journal_tag_bytes(journal_t *journal)
127 {
128 size_t sz;
130 - if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V3))
131 + if (jbd2_has_feature_csum3(journal))
132 return sizeof(journal_block_tag3_t);
134 sz = sizeof(journal_block_tag_t);
136 - if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2))
137 + if (jbd2_has_feature_csum2(journal))
138 sz += sizeof(__u16);
140 - if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT))
141 + if (jbd2_has_feature_64bit(journal))
142 return sz;
143 else
144 return sz - sizeof(__u32);
145 diff --git a/fs/jbd2/recovery.c b/fs/jbd2/recovery.c
146 index 5c836d7..7f277e4 100644
147 --- a/fs/jbd2/recovery.c
148 +++ b/fs/jbd2/recovery.c
149 @@ -342,7 +342,7 @@ static inline unsigned long long read_tag_block(journal_t *journal,
150 journal_block_tag_t *tag)
151 {
152 unsigned long long block = be32_to_cpu(tag->t_blocknr);
153 - if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT))
154 + if (jbd2_has_feature_64bit(journal))
155 block |= (u64)be32_to_cpu(tag->t_blocknr_high) << 32;
156 return block;
157 }
158 @@ -411,7 +411,7 @@ static int jbd2_block_tag_csum_verify(journal_t *j, journal_block_tag_t *tag,
159 csum32 = jbd2_chksum(j, j->j_csum_seed, (__u8 *)&seq, sizeof(seq));
160 csum32 = jbd2_chksum(j, csum32, buf, j->j_blocksize);
162 - if (JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V3))
163 + if (jbd2_has_feature_csum3(j))
164 return tag3->t_checksum == cpu_to_be32(csum32);
165 else
166 return tag->t_checksum == cpu_to_be16(csum32);
167 @@ -538,8 +538,7 @@ static int do_one_pass(journal_t *journal,
168 * just skip over the blocks it describes. */
169 if (pass != PASS_REPLAY) {
170 if (pass == PASS_SCAN &&
171 - JBD2_HAS_COMPAT_FEATURE(journal,
172 - JBD2_FEATURE_COMPAT_CHECKSUM) &&
173 + jbd2_has_feature_checksum(journal) &&
174 !info->end_transaction) {
175 if (calc_chksums(journal, bh,
176 &next_log_block,
177 @@ -694,8 +693,7 @@ static int do_one_pass(journal_t *journal,
178 * much to do other than move on to the next sequence
179 * number. */
180 if (pass == PASS_SCAN &&
181 - JBD2_HAS_COMPAT_FEATURE(journal,
182 - JBD2_FEATURE_COMPAT_CHECKSUM)) {
183 + jbd2_has_feature_checksum(journal)) {
184 int chksum_err, chksum_seen;
185 struct commit_header *cbh =
186 (struct commit_header *)bh->b_data;
187 @@ -735,8 +733,7 @@ static int do_one_pass(journal_t *journal,
188 if (chksum_err) {
189 info->end_transaction = next_commit_ID;
191 - if (!JBD2_HAS_INCOMPAT_FEATURE(journal,
192 - JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)){
193 + if (!jbd2_has_feature_async_commit(journal)) {
194 journal->j_failed_commit =
195 next_commit_ID;
196 brelse(bh);
197 @@ -750,8 +747,7 @@ static int do_one_pass(journal_t *journal,
198 bh->b_data)) {
199 info->end_transaction = next_commit_ID;
201 - if (!JBD2_HAS_INCOMPAT_FEATURE(journal,
202 - JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
203 + if (!jbd2_has_feature_async_commit(journal)) {
204 journal->j_failed_commit =
205 next_commit_ID;
206 brelse(bh);
207 @@ -859,7 +855,7 @@ static int scan_revoke_records(journal_t *journal, struct buffer_head *bh,
208 return -EINVAL;
209 max = rcount;
211 - if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT))
212 + if (jbd2_has_feature_64bit(journal))
213 record_len = 8;
215 while (offset + record_len <= max) {
216 diff --git a/fs/jbd2/revoke.c b/fs/jbd2/revoke.c
217 index 0abf2e7..705ae57 100644
218 --- a/fs/jbd2/revoke.c
219 +++ b/fs/jbd2/revoke.c
220 @@ -589,7 +589,7 @@ static void write_one_revoke_record(journal_t *journal,
221 if (jbd2_journal_has_csum_v2or3(journal))
222 csum_size = sizeof(struct jbd2_journal_revoke_tail);
224 - if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT))
225 + if (jbd2_has_feature_64bit(journal))
226 sz = 8;
227 else
228 sz = 4;
229 @@ -619,7 +619,7 @@ static void write_one_revoke_record(journal_t *journal,
230 *descriptorp = descriptor;
231 }
233 - if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT))
234 + if (jbd2_has_feature_64bit(journal))
235 * ((__be64 *)(&descriptor->b_data[offset])) =
236 cpu_to_be64(record->blocknr);
237 else
238 diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
239 index f2a4b07..b5ca231 100644
240 --- a/include/linux/jbd2.h
241 +++ b/include/linux/jbd2.h
242 @@ -278,6 +278,7 @@ typedef struct journal_superblock_s
243 /* 0x0400 */
244 } journal_superblock_t;
246 +/* Use the jbd2_{has,set,clear}_feature_* helpers; these will be removed */
247 #define JBD2_HAS_COMPAT_FEATURE(j,mask) \
248 ((j)->j_format_version >= 2 && \
249 ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
250 @@ -288,7 +289,7 @@ typedef struct journal_superblock_s
251 ((j)->j_format_version >= 2 && \
252 ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
254 -#define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001
255 +#define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001
257 #define JBD2_FEATURE_INCOMPAT_REVOKE 0x00000001
258 #define JBD2_FEATURE_INCOMPAT_64BIT 0x00000002
259 @@ -296,6 +297,8 @@ typedef struct journal_superblock_s
260 #define JBD2_FEATURE_INCOMPAT_CSUM_V2 0x00000008
261 #define JBD2_FEATURE_INCOMPAT_CSUM_V3 0x00000010
263 +/* See "journal feature predicate functions" below */
264 +
265 /* Features known to this kernel version: */
266 #define JBD2_KNOWN_COMPAT_FEATURES JBD2_FEATURE_COMPAT_CHECKSUM
267 #define JBD2_KNOWN_ROCOMPAT_FEATURES 0
268 @@ -1034,6 +1037,69 @@ struct journal_s
269 __u32 j_csum_seed;
270 };
272 +/* journal feature predicate functions */
273 +#define JBD2_FEATURE_COMPAT_FUNCS(name, flagname) \
274 +static inline bool jbd2_has_feature_##name(journal_t *j) \
275 +{ \
276 + return ((j)->j_format_version >= 2 && \
277 + ((j)->j_superblock->s_feature_compat & \
278 + cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname)) != 0); \
279 +} \
280 +static inline void jbd2_set_feature_##name(journal_t *j) \
281 +{ \
282 + (j)->j_superblock->s_feature_compat |= \
283 + cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname); \
284 +} \
285 +static inline void jbd2_clear_feature_##name(journal_t *j) \
286 +{ \
287 + (j)->j_superblock->s_feature_compat &= \
288 + ~cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname); \
289 +}
290 +
291 +#define JBD2_FEATURE_RO_COMPAT_FUNCS(name, flagname) \
292 +static inline bool jbd2_has_feature_##name(journal_t *j) \
293 +{ \
294 + return ((j)->j_format_version >= 2 && \
295 + ((j)->j_superblock->s_feature_ro_compat & \
296 + cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname)) != 0); \
297 +} \
298 +static inline void jbd2_set_feature_##name(journal_t *j) \
299 +{ \
300 + (j)->j_superblock->s_feature_ro_compat |= \
301 + cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname); \
302 +} \
303 +static inline void jbd2_clear_feature_##name(journal_t *j) \
304 +{ \
305 + (j)->j_superblock->s_feature_ro_compat &= \
306 + ~cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname); \
307 +}
308 +
309 +#define JBD2_FEATURE_INCOMPAT_FUNCS(name, flagname) \
310 +static inline bool jbd2_has_feature_##name(journal_t *j) \
311 +{ \
312 + return ((j)->j_format_version >= 2 && \
313 + ((j)->j_superblock->s_feature_incompat & \
314 + cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname)) != 0); \
315 +} \
316 +static inline void jbd2_set_feature_##name(journal_t *j) \
317 +{ \
318 + (j)->j_superblock->s_feature_incompat |= \
319 + cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname); \
320 +} \
321 +static inline void jbd2_clear_feature_##name(journal_t *j) \
322 +{ \
323 + (j)->j_superblock->s_feature_incompat &= \
324 + ~cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname); \
325 +}
326 +
327 +JBD2_FEATURE_COMPAT_FUNCS(checksum, CHECKSUM)
328 +
329 +JBD2_FEATURE_INCOMPAT_FUNCS(revoke, REVOKE)
330 +JBD2_FEATURE_INCOMPAT_FUNCS(64bit, 64BIT)
331 +JBD2_FEATURE_INCOMPAT_FUNCS(async_commit, ASYNC_COMMIT)
332 +JBD2_FEATURE_INCOMPAT_FUNCS(csum2, CSUM_V2)
333 +JBD2_FEATURE_INCOMPAT_FUNCS(csum3, CSUM_V3)
334 +
335 /*
336 * Journal flag definitions
337 */
338 @@ -1340,8 +1406,7 @@ extern size_t journal_tag_bytes(journal_t *journal);
340 static inline bool jbd2_journal_has_csum_v2or3_feature(journal_t *j)
341 {
342 - return JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V2) ||
343 - JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V3);
344 + return jbd2_has_feature_csum2(j) || jbd2_has_feature_csum3(j);
345 }
347 static inline int jbd2_journal_has_csum_v2or3(journal_t *journal)