Branch data Line data Source code
1 : : /*
2 : : * linux/include/linux/jbd2.h
3 : : *
4 : : * Written by Stephen C. Tweedie <sct@redhat.com>
5 : : *
6 : : * Copyright 1998-2000 Red Hat, Inc --- 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 : : * Definitions for transaction data structures for the buffer cache
13 : : * filesystem journaling support.
14 : : */
15 : :
16 : : #ifndef _LINUX_JBD2_H
17 : : #define _LINUX_JBD2_H
18 : :
19 : : /* Allow this file to be included directly into e2fsprogs */
20 : : #ifndef __KERNEL__
21 : : #include "jfs_compat.h"
22 : : #define JBD2_DEBUG
23 : : #else
24 : :
25 : : #include <linux/types.h>
26 : : #include <linux/buffer_head.h>
27 : : #include <linux/journal-head.h>
28 : : #include <linux/stddef.h>
29 : : #include <linux/mutex.h>
30 : : #include <linux/timer.h>
31 : : #include <linux/slab.h>
32 : : #include <crypto/hash.h>
33 : : #endif
34 : :
35 : : #define journal_oom_retry 1
36 : :
37 : : /*
38 : : * Define JBD2_PARANIOD_IOFAIL to cause a kernel BUG() if ext4 finds
39 : : * certain classes of error which can occur due to failed IOs. Under
40 : : * normal use we want ext4 to continue after such errors, because
41 : : * hardware _can_ fail, but for debugging purposes when running tests on
42 : : * known-good hardware we may want to trap these errors.
43 : : */
44 : : #undef JBD2_PARANOID_IOFAIL
45 : :
46 : : /*
47 : : * The default maximum commit age, in seconds.
48 : : */
49 : : #define JBD2_DEFAULT_MAX_COMMIT_AGE 5
50 : :
51 : : #ifdef CONFIG_JBD2_DEBUG
52 : : /*
53 : : * Define JBD2_EXPENSIVE_CHECKING to enable more expensive internal
54 : : * consistency checks. By default we don't do this unless
55 : : * CONFIG_JBD2_DEBUG is on.
56 : : */
57 : : #define JBD2_EXPENSIVE_CHECKING
58 : : extern ushort jbd2_journal_enable_debug;
59 : : void __jbd2_debug(int level, const char *file, const char *func,
60 : : unsigned int line, const char *fmt, ...);
61 : :
62 : : #define jbd_debug(n, fmt, a...) \
63 : : __jbd2_debug((n), __FILE__, __func__, __LINE__, (fmt), ##a)
64 : : #else
65 : : #define jbd_debug(n, fmt, a...) /**/
66 : : #endif
67 : :
68 : : extern void *jbd2_alloc(size_t size, gfp_t flags);
69 : : extern void jbd2_free(void *ptr, size_t size);
70 : :
71 : : #define JBD2_MIN_JOURNAL_BLOCKS 1024
72 : :
73 : : #ifdef __KERNEL__
74 : :
75 : : /**
76 : : * typedef handle_t - The handle_t type represents a single atomic update being performed by some process.
77 : : *
78 : : * All filesystem modifications made by the process go
79 : : * through this handle. Recursive operations (such as quota operations)
80 : : * are gathered into a single update.
81 : : *
82 : : * The buffer credits field is used to account for journaled buffers
83 : : * being modified by the running process. To ensure that there is
84 : : * enough log space for all outstanding operations, we need to limit the
85 : : * number of outstanding buffers possible at any time. When the
86 : : * operation completes, any buffer credits not used are credited back to
87 : : * the transaction, so that at all times we know how many buffers the
88 : : * outstanding updates on a transaction might possibly touch.
89 : : *
90 : : * This is an opaque datatype.
91 : : **/
92 : : typedef struct jbd2_journal_handle handle_t; /* Atomic operation type */
93 : :
94 : :
95 : : /**
96 : : * typedef journal_t - The journal_t maintains all of the journaling state information for a single filesystem.
97 : : *
98 : : * journal_t is linked to from the fs superblock structure.
99 : : *
100 : : * We use the journal_t to keep track of all outstanding transaction
101 : : * activity on the filesystem, and to manage the state of the log
102 : : * writing process.
103 : : *
104 : : * This is an opaque datatype.
105 : : **/
106 : : typedef struct journal_s journal_t; /* Journal control structure */
107 : : #endif
108 : :
109 : : /*
110 : : * Internal structures used by the logging mechanism:
111 : : */
112 : :
113 : : #define JBD2_MAGIC_NUMBER 0xc03b3998U /* The first 4 bytes of /dev/random! */
114 : :
115 : : /*
116 : : * On-disk structures
117 : : */
118 : :
119 : : /*
120 : : * Descriptor block types:
121 : : */
122 : :
123 : : #define JBD2_DESCRIPTOR_BLOCK 1
124 : : #define JBD2_COMMIT_BLOCK 2
125 : : #define JBD2_SUPERBLOCK_V1 3
126 : : #define JBD2_SUPERBLOCK_V2 4
127 : : #define JBD2_REVOKE_BLOCK 5
128 : :
129 : : /*
130 : : * Standard header for all descriptor blocks:
131 : : */
132 : : typedef struct journal_header_s
133 : : {
134 : : __be32 h_magic;
135 : : __be32 h_blocktype;
136 : : __be32 h_sequence;
137 : : } journal_header_t;
138 : :
139 : : /*
140 : : * Checksum types.
141 : : */
142 : : #define JBD2_CRC32_CHKSUM 1
143 : : #define JBD2_MD5_CHKSUM 2
144 : : #define JBD2_SHA1_CHKSUM 3
145 : : #define JBD2_CRC32C_CHKSUM 4
146 : :
147 : : #define JBD2_CRC32_CHKSUM_SIZE 4
148 : :
149 : : #define JBD2_CHECKSUM_BYTES (32 / sizeof(u32))
150 : : /*
151 : : * Commit block header for storing transactional checksums:
152 : : *
153 : : * NOTE: If FEATURE_COMPAT_CHECKSUM (checksum v1) is set, the h_chksum*
154 : : * fields are used to store a checksum of the descriptor and data blocks.
155 : : *
156 : : * If FEATURE_INCOMPAT_CSUM_V2 (checksum v2) is set, then the h_chksum
157 : : * field is used to store crc32c(uuid+commit_block). Each journal metadata
158 : : * block gets its own checksum, and data block checksums are stored in
159 : : * journal_block_tag (in the descriptor). The other h_chksum* fields are
160 : : * not used.
161 : : *
162 : : * Checksum v1 and v2 are mutually exclusive features.
163 : : */
164 : : struct commit_header {
165 : : __be32 h_magic;
166 : : __be32 h_blocktype;
167 : : __be32 h_sequence;
168 : : unsigned char h_chksum_type;
169 : : unsigned char h_chksum_size;
170 : : unsigned char h_padding[2];
171 : : __be32 h_chksum[JBD2_CHECKSUM_BYTES];
172 : : __be64 h_commit_sec;
173 : : __be32 h_commit_nsec;
174 : : };
175 : :
176 : : /*
177 : : * The block tag: used to describe a single buffer in the journal.
178 : : * t_blocknr_high is only used if INCOMPAT_64BIT is set, so this
179 : : * raw struct shouldn't be used for pointer math or sizeof() - use
180 : : * journal_tag_bytes(journal) instead to compute this.
181 : : */
182 : : typedef struct journal_block_tag_s
183 : : {
184 : : __be32 t_blocknr; /* The on-disk block number */
185 : : __be16 t_checksum; /* truncated crc32c(uuid+seq+block) */
186 : : __be16 t_flags; /* See below */
187 : : __be32 t_blocknr_high; /* most-significant high 32bits. */
188 : : } journal_block_tag_t;
189 : :
190 : : #define JBD2_TAG_SIZE32 (offsetof(journal_block_tag_t, t_blocknr_high))
191 : : #define JBD2_TAG_SIZE64 (sizeof(journal_block_tag_t))
192 : :
193 : : /* Tail of descriptor block, for checksumming */
194 : : struct jbd2_journal_block_tail {
195 : : __be32 t_checksum; /* crc32c(uuid+descr_block) */
196 : : };
197 : :
198 : : /*
199 : : * The revoke descriptor: used on disk to describe a series of blocks to
200 : : * be revoked from the log
201 : : */
202 : : typedef struct jbd2_journal_revoke_header_s
203 : : {
204 : : journal_header_t r_header;
205 : : __be32 r_count; /* Count of bytes used in the block */
206 : : } jbd2_journal_revoke_header_t;
207 : :
208 : : /* Tail of revoke block, for checksumming */
209 : : struct jbd2_journal_revoke_tail {
210 : : __be32 r_checksum; /* crc32c(uuid+revoke_block) */
211 : : };
212 : :
213 : : /* Definitions for the journal tag flags word: */
214 : : #define JBD2_FLAG_ESCAPE 1 /* on-disk block is escaped */
215 : : #define JBD2_FLAG_SAME_UUID 2 /* block has same uuid as previous */
216 : : #define JBD2_FLAG_DELETED 4 /* block deleted by this transaction */
217 : : #define JBD2_FLAG_LAST_TAG 8 /* last tag in this descriptor block */
218 : :
219 : :
220 : : /*
221 : : * The journal superblock. All fields are in big-endian byte order.
222 : : */
223 : : typedef struct journal_superblock_s
224 : : {
225 : : /* 0x0000 */
226 : : journal_header_t s_header;
227 : :
228 : : /* 0x000C */
229 : : /* Static information describing the journal */
230 : : __be32 s_blocksize; /* journal device blocksize */
231 : : __be32 s_maxlen; /* total blocks in journal file */
232 : : __be32 s_first; /* first block of log information */
233 : :
234 : : /* 0x0018 */
235 : : /* Dynamic information describing the current state of the log */
236 : : __be32 s_sequence; /* first commit ID expected in log */
237 : : __be32 s_start; /* blocknr of start of log */
238 : :
239 : : /* 0x0020 */
240 : : /* Error value, as set by jbd2_journal_abort(). */
241 : : __be32 s_errno;
242 : :
243 : : /* 0x0024 */
244 : : /* Remaining fields are only valid in a version-2 superblock */
245 : : __be32 s_feature_compat; /* compatible feature set */
246 : : __be32 s_feature_incompat; /* incompatible feature set */
247 : : __be32 s_feature_ro_compat; /* readonly-compatible feature set */
248 : : /* 0x0030 */
249 : : __u8 s_uuid[16]; /* 128-bit uuid for journal */
250 : :
251 : : /* 0x0040 */
252 : : __be32 s_nr_users; /* Nr of filesystems sharing log */
253 : :
254 : : __be32 s_dynsuper; /* Blocknr of dynamic superblock copy*/
255 : :
256 : : /* 0x0048 */
257 : : __be32 s_max_transaction; /* Limit of journal blocks per trans.*/
258 : : __be32 s_max_trans_data; /* Limit of data blocks per trans. */
259 : :
260 : : /* 0x0050 */
261 : : __u8 s_checksum_type; /* checksum type */
262 : : __u8 s_padding2[3];
263 : : __u32 s_padding[42];
264 : : __be32 s_checksum; /* crc32c(superblock) */
265 : :
266 : : /* 0x0100 */
267 : : __u8 s_users[16*48]; /* ids of all fs'es sharing the log */
268 : : /* 0x0400 */
269 : : } journal_superblock_t;
270 : :
271 : : #define JBD2_HAS_COMPAT_FEATURE(j,mask) \
272 : : ((j)->j_format_version >= 2 && \
273 : : ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
274 : : #define JBD2_HAS_RO_COMPAT_FEATURE(j,mask) \
275 : : ((j)->j_format_version >= 2 && \
276 : : ((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask))))
277 : : #define JBD2_HAS_INCOMPAT_FEATURE(j,mask) \
278 : : ((j)->j_format_version >= 2 && \
279 : : ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
280 : :
281 : : #define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001
282 : :
283 : : #define JBD2_FEATURE_INCOMPAT_REVOKE 0x00000001
284 : : #define JBD2_FEATURE_INCOMPAT_64BIT 0x00000002
285 : : #define JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT 0x00000004
286 : : #define JBD2_FEATURE_INCOMPAT_CSUM_V2 0x00000008
287 : :
288 : : /* Features known to this kernel version: */
289 : : #define JBD2_KNOWN_COMPAT_FEATURES JBD2_FEATURE_COMPAT_CHECKSUM
290 : : #define JBD2_KNOWN_ROCOMPAT_FEATURES 0
291 : : #define JBD2_KNOWN_INCOMPAT_FEATURES (JBD2_FEATURE_INCOMPAT_REVOKE | \
292 : : JBD2_FEATURE_INCOMPAT_64BIT | \
293 : : JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT | \
294 : : JBD2_FEATURE_INCOMPAT_CSUM_V2)
295 : :
296 : : #ifdef __KERNEL__
297 : :
298 : : #include <linux/fs.h>
299 : : #include <linux/sched.h>
300 : :
301 : : enum jbd_state_bits {
302 : : BH_JBD /* Has an attached ext3 journal_head */
303 : : = BH_PrivateStart,
304 : : BH_JWrite, /* Being written to log (@@@ DEBUGGING) */
305 : : BH_Freed, /* Has been freed (truncated) */
306 : : BH_Revoked, /* Has been revoked from the log */
307 : : BH_RevokeValid, /* Revoked flag is valid */
308 : : BH_JBDDirty, /* Is dirty but journaled */
309 : : BH_State, /* Pins most journal_head state */
310 : : BH_JournalHead, /* Pins bh->b_private and jh->b_bh */
311 : : BH_Shadow, /* IO on shadow buffer is running */
312 : : BH_Verified, /* Metadata block has been verified ok */
313 : : BH_JBDPrivateStart, /* First bit available for private use by FS */
314 : : };
315 : :
316 : 120376 : BUFFER_FNS(JBD, jbd)
317 : 112898 : BUFFER_FNS(JWrite, jwrite)
318 : 637041 : BUFFER_FNS(JBDDirty, jbddirty)
319 : 729063 : TAS_BUFFER_FNS(JBDDirty, jbddirty)
320 : 118819 : BUFFER_FNS(Revoked, revoked)
321 : 16034017 : TAS_BUFFER_FNS(Revoked, revoked)
322 : 42770 : BUFFER_FNS(RevokeValid, revokevalid)
323 : 16066809 : TAS_BUFFER_FNS(RevokeValid, revokevalid)
324 : 10 : BUFFER_FNS(Freed, freed)
325 : 70418 : BUFFER_FNS(Shadow, shadow)
326 : 2040022 : BUFFER_FNS(Verified, verified)
327 : :
328 : : #include <linux/jbd_common.h>
329 : :
330 : : #define J_ASSERT(assert) BUG_ON(!(assert))
331 : :
332 : : #define J_ASSERT_BH(bh, expr) J_ASSERT(expr)
333 : : #define J_ASSERT_JH(jh, expr) J_ASSERT(expr)
334 : :
335 : : #if defined(JBD2_PARANOID_IOFAIL)
336 : : #define J_EXPECT(expr, why...) J_ASSERT(expr)
337 : : #define J_EXPECT_BH(bh, expr, why...) J_ASSERT_BH(bh, expr)
338 : : #define J_EXPECT_JH(jh, expr, why...) J_ASSERT_JH(jh, expr)
339 : : #else
340 : : #define __journal_expect(expr, why...) \
341 : : ({ \
342 : : int val = (expr); \
343 : : if (!val) { \
344 : : printk(KERN_ERR \
345 : : "JBD2 unexpected failure: %s: %s;\n", \
346 : : __func__, #expr); \
347 : : printk(KERN_ERR why "\n"); \
348 : : } \
349 : : val; \
350 : : })
351 : : #define J_EXPECT(expr, why...) __journal_expect(expr, ## why)
352 : : #define J_EXPECT_BH(bh, expr, why...) __journal_expect(expr, ## why)
353 : : #define J_EXPECT_JH(jh, expr, why...) __journal_expect(expr, ## why)
354 : : #endif
355 : :
356 : : /* Flags in jbd_inode->i_flags */
357 : : #define __JI_COMMIT_RUNNING 0
358 : : /* Commit of the inode data in progress. We use this flag to protect us from
359 : : * concurrent deletion of inode. We cannot use reference to inode for this
360 : : * since we cannot afford doing last iput() on behalf of kjournald
361 : : */
362 : : #define JI_COMMIT_RUNNING (1 << __JI_COMMIT_RUNNING)
363 : :
364 : : /**
365 : : * struct jbd_inode is the structure linking inodes in ordered mode
366 : : * present in a transaction so that we can sync them during commit.
367 : : */
368 : : struct jbd2_inode {
369 : : /* Which transaction does this inode belong to? Either the running
370 : : * transaction or the committing one. [j_list_lock] */
371 : : transaction_t *i_transaction;
372 : :
373 : : /* Pointer to the running transaction modifying inode's data in case
374 : : * there is already a committing transaction touching it. [j_list_lock] */
375 : : transaction_t *i_next_transaction;
376 : :
377 : : /* List of inodes in the i_transaction [j_list_lock] */
378 : : struct list_head i_list;
379 : :
380 : : /* VFS inode this inode belongs to [constant during the lifetime
381 : : * of the structure] */
382 : : struct inode *i_vfs_inode;
383 : :
384 : : /* Flags of inode [j_list_lock] */
385 : : unsigned long i_flags;
386 : : };
387 : :
388 : : struct jbd2_revoke_table_s;
389 : :
390 : : /**
391 : : * struct handle_s - The handle_s type is the concrete type associated with
392 : : * handle_t.
393 : : * @h_transaction: Which compound transaction is this update a part of?
394 : : * @h_buffer_credits: Number of remaining buffers we are allowed to dirty.
395 : : * @h_ref: Reference count on this handle
396 : : * @h_err: Field for caller's use to track errors through large fs operations
397 : : * @h_sync: flag for sync-on-close
398 : : * @h_jdata: flag to force data journaling
399 : : * @h_aborted: flag indicating fatal error on handle
400 : : **/
401 : :
402 : : /* Docbook can't yet cope with the bit fields, but will leave the documentation
403 : : * in so it can be fixed later.
404 : : */
405 : :
406 : : struct jbd2_journal_handle
407 : : {
408 : : union {
409 : : /* Which compound transaction is this update a part of? */
410 : : transaction_t *h_transaction;
411 : : /* Which journal handle belongs to - used iff h_reserved set */
412 : : journal_t *h_journal;
413 : : };
414 : :
415 : : /* Handle reserved for finishing the logical operation */
416 : : handle_t *h_rsv_handle;
417 : :
418 : : /* Number of remaining buffers we are allowed to dirty: */
419 : : int h_buffer_credits;
420 : :
421 : : /* Reference count on this handle */
422 : : int h_ref;
423 : :
424 : : /* Field for caller's use to track errors through large fs */
425 : : /* operations */
426 : : int h_err;
427 : :
428 : : /* Flags [no locking] */
429 : : unsigned int h_sync: 1; /* sync-on-close */
430 : : unsigned int h_jdata: 1; /* force data journaling */
431 : : unsigned int h_reserved: 1; /* handle with reserved credits */
432 : : unsigned int h_aborted: 1; /* fatal error on handle */
433 : : unsigned int h_type: 8; /* for handle statistics */
434 : : unsigned int h_line_no: 16; /* for handle statistics */
435 : :
436 : : unsigned long h_start_jiffies;
437 : : unsigned int h_requested_credits;
438 : :
439 : : #ifdef CONFIG_DEBUG_LOCK_ALLOC
440 : : struct lockdep_map h_lockdep_map;
441 : : #endif
442 : : };
443 : :
444 : :
445 : : /*
446 : : * Some stats for checkpoint phase
447 : : */
448 : : struct transaction_chp_stats_s {
449 : : unsigned long cs_chp_time;
450 : : __u32 cs_forced_to_close;
451 : : __u32 cs_written;
452 : : __u32 cs_dropped;
453 : : };
454 : :
455 : : /* The transaction_t type is the guts of the journaling mechanism. It
456 : : * tracks a compound transaction through its various states:
457 : : *
458 : : * RUNNING: accepting new updates
459 : : * LOCKED: Updates still running but we don't accept new ones
460 : : * RUNDOWN: Updates are tidying up but have finished requesting
461 : : * new buffers to modify (state not used for now)
462 : : * FLUSH: All updates complete, but we are still writing to disk
463 : : * COMMIT: All data on disk, writing commit record
464 : : * FINISHED: We still have to keep the transaction for checkpointing.
465 : : *
466 : : * The transaction keeps track of all of the buffers modified by a
467 : : * running transaction, and all of the buffers committed but not yet
468 : : * flushed to home for finished transactions.
469 : : */
470 : :
471 : : /*
472 : : * Lock ranking:
473 : : *
474 : : * j_list_lock
475 : : * ->jbd_lock_bh_journal_head() (This is "innermost")
476 : : *
477 : : * j_state_lock
478 : : * ->jbd_lock_bh_state()
479 : : *
480 : : * jbd_lock_bh_state()
481 : : * ->j_list_lock
482 : : *
483 : : * j_state_lock
484 : : * ->t_handle_lock
485 : : *
486 : : * j_state_lock
487 : : * ->j_list_lock (journal_unmap_buffer)
488 : : *
489 : : */
490 : :
491 : : struct transaction_s
492 : : {
493 : : /* Pointer to the journal for this transaction. [no locking] */
494 : : journal_t *t_journal;
495 : :
496 : : /* Sequence number for this transaction [no locking] */
497 : : tid_t t_tid;
498 : :
499 : : /*
500 : : * Transaction's current state
501 : : * [no locking - only kjournald2 alters this]
502 : : * [j_list_lock] guards transition of a transaction into T_FINISHED
503 : : * state and subsequent call of __jbd2_journal_drop_transaction()
504 : : * FIXME: needs barriers
505 : : * KLUDGE: [use j_state_lock]
506 : : */
507 : : enum {
508 : : T_RUNNING,
509 : : T_LOCKED,
510 : : T_FLUSH,
511 : : T_COMMIT,
512 : : T_COMMIT_DFLUSH,
513 : : T_COMMIT_JFLUSH,
514 : : T_COMMIT_CALLBACK,
515 : : T_FINISHED
516 : : } t_state;
517 : :
518 : : /*
519 : : * Where in the log does this transaction's commit start? [no locking]
520 : : */
521 : : unsigned long t_log_start;
522 : :
523 : : /* Number of buffers on the t_buffers list [j_list_lock] */
524 : : int t_nr_buffers;
525 : :
526 : : /*
527 : : * Doubly-linked circular list of all buffers reserved but not yet
528 : : * modified by this transaction [j_list_lock]
529 : : */
530 : : struct journal_head *t_reserved_list;
531 : :
532 : : /*
533 : : * Doubly-linked circular list of all metadata buffers owned by this
534 : : * transaction [j_list_lock]
535 : : */
536 : : struct journal_head *t_buffers;
537 : :
538 : : /*
539 : : * Doubly-linked circular list of all forget buffers (superseded
540 : : * buffers which we can un-checkpoint once this transaction commits)
541 : : * [j_list_lock]
542 : : */
543 : : struct journal_head *t_forget;
544 : :
545 : : /*
546 : : * Doubly-linked circular list of all buffers still to be flushed before
547 : : * this transaction can be checkpointed. [j_list_lock]
548 : : */
549 : : struct journal_head *t_checkpoint_list;
550 : :
551 : : /*
552 : : * Doubly-linked circular list of all buffers submitted for IO while
553 : : * checkpointing. [j_list_lock]
554 : : */
555 : : struct journal_head *t_checkpoint_io_list;
556 : :
557 : : /*
558 : : * Doubly-linked circular list of metadata buffers being shadowed by log
559 : : * IO. The IO buffers on the iobuf list and the shadow buffers on this
560 : : * list match each other one for one at all times. [j_list_lock]
561 : : */
562 : : struct journal_head *t_shadow_list;
563 : :
564 : : /*
565 : : * List of inodes whose data we've modified in data=ordered mode.
566 : : * [j_list_lock]
567 : : */
568 : : struct list_head t_inode_list;
569 : :
570 : : /*
571 : : * Protects info related to handles
572 : : */
573 : : spinlock_t t_handle_lock;
574 : :
575 : : /*
576 : : * Longest time some handle had to wait for running transaction
577 : : */
578 : : unsigned long t_max_wait;
579 : :
580 : : /*
581 : : * When transaction started
582 : : */
583 : : unsigned long t_start;
584 : :
585 : : /*
586 : : * When commit was requested
587 : : */
588 : : unsigned long t_requested;
589 : :
590 : : /*
591 : : * Checkpointing stats [j_checkpoint_sem]
592 : : */
593 : : struct transaction_chp_stats_s t_chp_stats;
594 : :
595 : : /*
596 : : * Number of outstanding updates running on this transaction
597 : : * [t_handle_lock]
598 : : */
599 : : atomic_t t_updates;
600 : :
601 : : /*
602 : : * Number of buffers reserved for use by all handles in this transaction
603 : : * handle but not yet modified. [t_handle_lock]
604 : : */
605 : : atomic_t t_outstanding_credits;
606 : :
607 : : /*
608 : : * Forward and backward links for the circular list of all transactions
609 : : * awaiting checkpoint. [j_list_lock]
610 : : */
611 : : transaction_t *t_cpnext, *t_cpprev;
612 : :
613 : : /*
614 : : * When will the transaction expire (become due for commit), in jiffies?
615 : : * [no locking]
616 : : */
617 : : unsigned long t_expires;
618 : :
619 : : /*
620 : : * When this transaction started, in nanoseconds [no locking]
621 : : */
622 : : ktime_t t_start_time;
623 : :
624 : : /*
625 : : * How many handles used this transaction? [t_handle_lock]
626 : : */
627 : : atomic_t t_handle_count;
628 : :
629 : : /*
630 : : * This transaction is being forced and some process is
631 : : * waiting for it to finish.
632 : : */
633 : : unsigned int t_synchronous_commit:1;
634 : :
635 : : /* Disk flush needs to be sent to fs partition [no locking] */
636 : : int t_need_data_flush;
637 : :
638 : : /*
639 : : * For use by the filesystem to store fs-specific data
640 : : * structures associated with the transaction
641 : : */
642 : : struct list_head t_private_list;
643 : : };
644 : :
645 : : struct transaction_run_stats_s {
646 : : unsigned long rs_wait;
647 : : unsigned long rs_request_delay;
648 : : unsigned long rs_running;
649 : : unsigned long rs_locked;
650 : : unsigned long rs_flushing;
651 : : unsigned long rs_logging;
652 : :
653 : : __u32 rs_handle_count;
654 : : __u32 rs_blocks;
655 : : __u32 rs_blocks_logged;
656 : : };
657 : :
658 : : struct transaction_stats_s {
659 : : unsigned long ts_tid;
660 : : unsigned long ts_requested;
661 : : struct transaction_run_stats_s run;
662 : : };
663 : :
664 : : static inline unsigned long
665 : : jbd2_time_diff(unsigned long start, unsigned long end)
666 : : {
667 [ + - ][ + - ]: 16129058 : if (end >= start)
[ + - ][ + - ]
[ + - ]
668 : 16129058 : return end - start;
669 : :
670 : 0 : return end + (MAX_JIFFY_OFFSET - start);
671 : : }
672 : :
673 : : #define JBD2_NR_BATCH 64
674 : :
675 : : /**
676 : : * struct journal_s - The journal_s type is the concrete type associated with
677 : : * journal_t.
678 : : * @j_flags: General journaling state flags
679 : : * @j_errno: Is there an outstanding uncleared error on the journal (from a
680 : : * prior abort)?
681 : : * @j_sb_buffer: First part of superblock buffer
682 : : * @j_superblock: Second part of superblock buffer
683 : : * @j_format_version: Version of the superblock format
684 : : * @j_state_lock: Protect the various scalars in the journal
685 : : * @j_barrier_count: Number of processes waiting to create a barrier lock
686 : : * @j_barrier: The barrier lock itself
687 : : * @j_running_transaction: The current running transaction..
688 : : * @j_committing_transaction: the transaction we are pushing to disk
689 : : * @j_checkpoint_transactions: a linked circular list of all transactions
690 : : * waiting for checkpointing
691 : : * @j_wait_transaction_locked: Wait queue for waiting for a locked transaction
692 : : * to start committing, or for a barrier lock to be released
693 : : * @j_wait_done_commit: Wait queue for waiting for commit to complete
694 : : * @j_wait_commit: Wait queue to trigger commit
695 : : * @j_wait_updates: Wait queue to wait for updates to complete
696 : : * @j_wait_reserved: Wait queue to wait for reserved buffer credits to drop
697 : : * @j_checkpoint_mutex: Mutex for locking against concurrent checkpoints
698 : : * @j_head: Journal head - identifies the first unused block in the journal
699 : : * @j_tail: Journal tail - identifies the oldest still-used block in the
700 : : * journal.
701 : : * @j_free: Journal free - how many free blocks are there in the journal?
702 : : * @j_first: The block number of the first usable block
703 : : * @j_last: The block number one beyond the last usable block
704 : : * @j_dev: Device where we store the journal
705 : : * @j_blocksize: blocksize for the location where we store the journal.
706 : : * @j_blk_offset: starting block offset for into the device where we store the
707 : : * journal
708 : : * @j_fs_dev: Device which holds the client fs. For internal journal this will
709 : : * be equal to j_dev
710 : : * @j_reserved_credits: Number of buffers reserved from the running transaction
711 : : * @j_maxlen: Total maximum capacity of the journal region on disk.
712 : : * @j_list_lock: Protects the buffer lists and internal buffer state.
713 : : * @j_inode: Optional inode where we store the journal. If present, all journal
714 : : * block numbers are mapped into this inode via bmap().
715 : : * @j_tail_sequence: Sequence number of the oldest transaction in the log
716 : : * @j_transaction_sequence: Sequence number of the next transaction to grant
717 : : * @j_commit_sequence: Sequence number of the most recently committed
718 : : * transaction
719 : : * @j_commit_request: Sequence number of the most recent transaction wanting
720 : : * commit
721 : : * @j_uuid: Uuid of client object.
722 : : * @j_task: Pointer to the current commit thread for this journal
723 : : * @j_max_transaction_buffers: Maximum number of metadata buffers to allow in a
724 : : * single compound commit transaction
725 : : * @j_commit_interval: What is the maximum transaction lifetime before we begin
726 : : * a commit?
727 : : * @j_commit_timer: The timer used to wakeup the commit thread
728 : : * @j_revoke_lock: Protect the revoke table
729 : : * @j_revoke: The revoke table - maintains the list of revoked blocks in the
730 : : * current transaction.
731 : : * @j_revoke_table: alternate revoke tables for j_revoke
732 : : * @j_wbuf: array of buffer_heads for jbd2_journal_commit_transaction
733 : : * @j_wbufsize: maximum number of buffer_heads allowed in j_wbuf, the
734 : : * number that will fit in j_blocksize
735 : : * @j_last_sync_writer: most recent pid which did a synchronous write
736 : : * @j_history: Buffer storing the transactions statistics history
737 : : * @j_history_max: Maximum number of transactions in the statistics history
738 : : * @j_history_cur: Current number of transactions in the statistics history
739 : : * @j_history_lock: Protect the transactions statistics history
740 : : * @j_proc_entry: procfs entry for the jbd statistics directory
741 : : * @j_stats: Overall statistics
742 : : * @j_private: An opaque pointer to fs-private information.
743 : : */
744 : :
745 : : struct journal_s
746 : : {
747 : : /* General journaling state flags [j_state_lock] */
748 : : unsigned long j_flags;
749 : :
750 : : /*
751 : : * Is there an outstanding uncleared error on the journal (from a prior
752 : : * abort)? [j_state_lock]
753 : : */
754 : : int j_errno;
755 : :
756 : : /* The superblock buffer */
757 : : struct buffer_head *j_sb_buffer;
758 : : journal_superblock_t *j_superblock;
759 : :
760 : : /* Version of the superblock format */
761 : : int j_format_version;
762 : :
763 : : /*
764 : : * Protect the various scalars in the journal
765 : : */
766 : : rwlock_t j_state_lock;
767 : :
768 : : /*
769 : : * Number of processes waiting to create a barrier lock [j_state_lock]
770 : : */
771 : : int j_barrier_count;
772 : :
773 : : /* The barrier lock itself */
774 : : struct mutex j_barrier;
775 : :
776 : : /*
777 : : * Transactions: The current running transaction...
778 : : * [j_state_lock] [caller holding open handle]
779 : : */
780 : : transaction_t *j_running_transaction;
781 : :
782 : : /*
783 : : * the transaction we are pushing to disk
784 : : * [j_state_lock] [caller holding open handle]
785 : : */
786 : : transaction_t *j_committing_transaction;
787 : :
788 : : /*
789 : : * ... and a linked circular list of all transactions waiting for
790 : : * checkpointing. [j_list_lock]
791 : : */
792 : : transaction_t *j_checkpoint_transactions;
793 : :
794 : : /*
795 : : * Wait queue for waiting for a locked transaction to start committing,
796 : : * or for a barrier lock to be released
797 : : */
798 : : wait_queue_head_t j_wait_transaction_locked;
799 : :
800 : : /* Wait queue for waiting for commit to complete */
801 : : wait_queue_head_t j_wait_done_commit;
802 : :
803 : : /* Wait queue to trigger commit */
804 : : wait_queue_head_t j_wait_commit;
805 : :
806 : : /* Wait queue to wait for updates to complete */
807 : : wait_queue_head_t j_wait_updates;
808 : :
809 : : /* Wait queue to wait for reserved buffer credits to drop */
810 : : wait_queue_head_t j_wait_reserved;
811 : :
812 : : /* Semaphore for locking against concurrent checkpoints */
813 : : struct mutex j_checkpoint_mutex;
814 : :
815 : : /*
816 : : * List of buffer heads used by the checkpoint routine. This
817 : : * was moved from jbd2_log_do_checkpoint() to reduce stack
818 : : * usage. Access to this array is controlled by the
819 : : * j_checkpoint_mutex. [j_checkpoint_mutex]
820 : : */
821 : : struct buffer_head *j_chkpt_bhs[JBD2_NR_BATCH];
822 : :
823 : : /*
824 : : * Journal head: identifies the first unused block in the journal.
825 : : * [j_state_lock]
826 : : */
827 : : unsigned long j_head;
828 : :
829 : : /*
830 : : * Journal tail: identifies the oldest still-used block in the journal.
831 : : * [j_state_lock]
832 : : */
833 : : unsigned long j_tail;
834 : :
835 : : /*
836 : : * Journal free: how many free blocks are there in the journal?
837 : : * [j_state_lock]
838 : : */
839 : : unsigned long j_free;
840 : :
841 : : /*
842 : : * Journal start and end: the block numbers of the first usable block
843 : : * and one beyond the last usable block in the journal. [j_state_lock]
844 : : */
845 : : unsigned long j_first;
846 : : unsigned long j_last;
847 : :
848 : : /*
849 : : * Device, blocksize and starting block offset for the location where we
850 : : * store the journal.
851 : : */
852 : : struct block_device *j_dev;
853 : : int j_blocksize;
854 : : unsigned long long j_blk_offset;
855 : : char j_devname[BDEVNAME_SIZE+24];
856 : :
857 : : /*
858 : : * Device which holds the client fs. For internal journal this will be
859 : : * equal to j_dev.
860 : : */
861 : : struct block_device *j_fs_dev;
862 : :
863 : : /* Total maximum capacity of the journal region on disk. */
864 : : unsigned int j_maxlen;
865 : :
866 : : /* Number of buffers reserved from the running transaction */
867 : : atomic_t j_reserved_credits;
868 : :
869 : : /*
870 : : * Protects the buffer lists and internal buffer state.
871 : : */
872 : : spinlock_t j_list_lock;
873 : :
874 : : /* Optional inode where we store the journal. If present, all */
875 : : /* journal block numbers are mapped into this inode via */
876 : : /* bmap(). */
877 : : struct inode *j_inode;
878 : :
879 : : /*
880 : : * Sequence number of the oldest transaction in the log [j_state_lock]
881 : : */
882 : : tid_t j_tail_sequence;
883 : :
884 : : /*
885 : : * Sequence number of the next transaction to grant [j_state_lock]
886 : : */
887 : : tid_t j_transaction_sequence;
888 : :
889 : : /*
890 : : * Sequence number of the most recently committed transaction
891 : : * [j_state_lock].
892 : : */
893 : : tid_t j_commit_sequence;
894 : :
895 : : /*
896 : : * Sequence number of the most recent transaction wanting commit
897 : : * [j_state_lock]
898 : : */
899 : : tid_t j_commit_request;
900 : :
901 : : /*
902 : : * Journal uuid: identifies the object (filesystem, LVM volume etc)
903 : : * backed by this journal. This will eventually be replaced by an array
904 : : * of uuids, allowing us to index multiple devices within a single
905 : : * journal and to perform atomic updates across them.
906 : : */
907 : : __u8 j_uuid[16];
908 : :
909 : : /* Pointer to the current commit thread for this journal */
910 : : struct task_struct *j_task;
911 : :
912 : : /*
913 : : * Maximum number of metadata buffers to allow in a single compound
914 : : * commit transaction
915 : : */
916 : : int j_max_transaction_buffers;
917 : :
918 : : /*
919 : : * What is the maximum transaction lifetime before we begin a commit?
920 : : */
921 : : unsigned long j_commit_interval;
922 : :
923 : : /* The timer used to wakeup the commit thread: */
924 : : struct timer_list j_commit_timer;
925 : :
926 : : /*
927 : : * The revoke table: maintains the list of revoked blocks in the
928 : : * current transaction. [j_revoke_lock]
929 : : */
930 : : spinlock_t j_revoke_lock;
931 : : struct jbd2_revoke_table_s *j_revoke;
932 : : struct jbd2_revoke_table_s *j_revoke_table[2];
933 : :
934 : : /*
935 : : * array of bhs for jbd2_journal_commit_transaction
936 : : */
937 : : struct buffer_head **j_wbuf;
938 : : int j_wbufsize;
939 : :
940 : : /*
941 : : * this is the pid of hte last person to run a synchronous operation
942 : : * through the journal
943 : : */
944 : : pid_t j_last_sync_writer;
945 : :
946 : : /*
947 : : * the average amount of time in nanoseconds it takes to commit a
948 : : * transaction to disk. [j_state_lock]
949 : : */
950 : : u64 j_average_commit_time;
951 : :
952 : : /*
953 : : * minimum and maximum times that we should wait for
954 : : * additional filesystem operations to get batched into a
955 : : * synchronous handle in microseconds
956 : : */
957 : : u32 j_min_batch_time;
958 : : u32 j_max_batch_time;
959 : :
960 : : /* This function is called when a transaction is closed */
961 : : void (*j_commit_callback)(journal_t *,
962 : : transaction_t *);
963 : :
964 : : /*
965 : : * Journal statistics
966 : : */
967 : : spinlock_t j_history_lock;
968 : : struct proc_dir_entry *j_proc_entry;
969 : : struct transaction_stats_s j_stats;
970 : :
971 : : /* Failed journal commit ID */
972 : : unsigned int j_failed_commit;
973 : :
974 : : /*
975 : : * An opaque pointer to fs-private information. ext3 puts its
976 : : * superblock pointer here
977 : : */
978 : : void *j_private;
979 : :
980 : : /* Reference to checksum algorithm driver via cryptoapi */
981 : : struct crypto_shash *j_chksum_driver;
982 : :
983 : : /* Precomputed journal UUID checksum for seeding other checksums */
984 : : __u32 j_csum_seed;
985 : : };
986 : :
987 : : /*
988 : : * Journal flag definitions
989 : : */
990 : : #define JBD2_UNMOUNT 0x001 /* Journal thread is being destroyed */
991 : : #define JBD2_ABORT 0x002 /* Journaling has been aborted for errors. */
992 : : #define JBD2_ACK_ERR 0x004 /* The errno in the sb has been acked */
993 : : #define JBD2_FLUSHED 0x008 /* The journal superblock has been flushed */
994 : : #define JBD2_LOADED 0x010 /* The journal superblock has been loaded */
995 : : #define JBD2_BARRIER 0x020 /* Use IDE barriers */
996 : : #define JBD2_ABORT_ON_SYNCDATA_ERR 0x040 /* Abort the journal on file
997 : : * data write error in ordered
998 : : * mode */
999 : :
1000 : : /*
1001 : : * Function declarations for the journaling transaction and buffer
1002 : : * management
1003 : : */
1004 : :
1005 : : /* Filing buffers */
1006 : : extern void jbd2_journal_unfile_buffer(journal_t *, struct journal_head *);
1007 : : extern void __jbd2_journal_refile_buffer(struct journal_head *);
1008 : : extern void jbd2_journal_refile_buffer(journal_t *, struct journal_head *);
1009 : : extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
1010 : : extern void __journal_free_buffer(struct journal_head *bh);
1011 : : extern void jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
1012 : : extern void __journal_clean_data_list(transaction_t *transaction);
1013 : : static inline void jbd2_file_log_bh(struct list_head *head, struct buffer_head *bh)
1014 : : {
1015 : 91658 : list_add_tail(&bh->b_assoc_buffers, head);
1016 : : }
1017 : : static inline void jbd2_unfile_log_bh(struct buffer_head *bh)
1018 : : {
1019 : 91658 : list_del_init(&bh->b_assoc_buffers);
1020 : : }
1021 : :
1022 : : /* Log buffer allocation */
1023 : : struct buffer_head *jbd2_journal_get_descriptor_buffer(journal_t *journal);
1024 : : int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
1025 : : int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
1026 : : unsigned long *block);
1027 : : void __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
1028 : : void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
1029 : :
1030 : : /* Commit management */
1031 : : extern void jbd2_journal_commit_transaction(journal_t *);
1032 : :
1033 : : /* Checkpoint list management */
1034 : : int __jbd2_journal_clean_checkpoint_list(journal_t *journal);
1035 : : int __jbd2_journal_remove_checkpoint(struct journal_head *);
1036 : : void __jbd2_journal_insert_checkpoint(struct journal_head *, transaction_t *);
1037 : :
1038 : :
1039 : : /*
1040 : : * Triggers
1041 : : */
1042 : :
1043 : : struct jbd2_buffer_trigger_type {
1044 : : /*
1045 : : * Fired a the moment data to write to the journal are known to be
1046 : : * stable - so either at the moment b_frozen_data is created or just
1047 : : * before a buffer is written to the journal. mapped_data is a mapped
1048 : : * buffer that is the frozen data for commit.
1049 : : */
1050 : : void (*t_frozen)(struct jbd2_buffer_trigger_type *type,
1051 : : struct buffer_head *bh, void *mapped_data,
1052 : : size_t size);
1053 : :
1054 : : /*
1055 : : * Fired during journal abort for dirty buffers that will not be
1056 : : * committed.
1057 : : */
1058 : : void (*t_abort)(struct jbd2_buffer_trigger_type *type,
1059 : : struct buffer_head *bh);
1060 : : };
1061 : :
1062 : : extern void jbd2_buffer_frozen_trigger(struct journal_head *jh,
1063 : : void *mapped_data,
1064 : : struct jbd2_buffer_trigger_type *triggers);
1065 : : extern void jbd2_buffer_abort_trigger(struct journal_head *jh,
1066 : : struct jbd2_buffer_trigger_type *triggers);
1067 : :
1068 : : /* Buffer IO */
1069 : : extern int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
1070 : : struct journal_head *jh_in,
1071 : : struct buffer_head **bh_out,
1072 : : sector_t blocknr);
1073 : :
1074 : : /* Transaction locking */
1075 : : extern void __wait_on_journal (journal_t *);
1076 : :
1077 : : /* Transaction cache support */
1078 : : extern void jbd2_journal_destroy_transaction_cache(void);
1079 : : extern int jbd2_journal_init_transaction_cache(void);
1080 : : extern void jbd2_journal_free_transaction(transaction_t *);
1081 : :
1082 : : /*
1083 : : * Journal locking.
1084 : : *
1085 : : * We need to lock the journal during transaction state changes so that nobody
1086 : : * ever tries to take a handle on the running transaction while we are in the
1087 : : * middle of moving it to the commit phase. j_state_lock does this.
1088 : : *
1089 : : * Note that the locking is completely interrupt unsafe. We never touch
1090 : : * journal structures from interrupts.
1091 : : */
1092 : :
1093 : : static inline handle_t *journal_current_handle(void)
1094 : : {
1095 : 36092809 : return current->journal_info;
1096 : : }
1097 : :
1098 : : /* The journaling code user interface:
1099 : : *
1100 : : * Create and destroy handles
1101 : : * Register buffer modifications against the current transaction.
1102 : : */
1103 : :
1104 : : extern handle_t *jbd2_journal_start(journal_t *, int nblocks);
1105 : : extern handle_t *jbd2__journal_start(journal_t *, int blocks, int rsv_blocks,
1106 : : gfp_t gfp_mask, unsigned int type,
1107 : : unsigned int line_no);
1108 : : extern int jbd2_journal_restart(handle_t *, int nblocks);
1109 : : extern int jbd2__journal_restart(handle_t *, int nblocks, gfp_t gfp_mask);
1110 : : extern int jbd2_journal_start_reserved(handle_t *handle,
1111 : : unsigned int type, unsigned int line_no);
1112 : : extern void jbd2_journal_free_reserved(handle_t *handle);
1113 : : extern int jbd2_journal_extend (handle_t *, int nblocks);
1114 : : extern int jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
1115 : : extern int jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
1116 : : extern int jbd2_journal_get_undo_access(handle_t *, struct buffer_head *);
1117 : : void jbd2_journal_set_triggers(struct buffer_head *,
1118 : : struct jbd2_buffer_trigger_type *type);
1119 : : extern int jbd2_journal_dirty_metadata (handle_t *, struct buffer_head *);
1120 : : extern int jbd2_journal_forget (handle_t *, struct buffer_head *);
1121 : : extern void journal_sync_buffer (struct buffer_head *);
1122 : : extern int jbd2_journal_invalidatepage(journal_t *,
1123 : : struct page *, unsigned int, unsigned int);
1124 : : extern int jbd2_journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
1125 : : extern int jbd2_journal_stop(handle_t *);
1126 : : extern int jbd2_journal_flush (journal_t *);
1127 : : extern void jbd2_journal_lock_updates (journal_t *);
1128 : : extern void jbd2_journal_unlock_updates (journal_t *);
1129 : :
1130 : : extern journal_t * jbd2_journal_init_dev(struct block_device *bdev,
1131 : : struct block_device *fs_dev,
1132 : : unsigned long long start, int len, int bsize);
1133 : : extern journal_t * jbd2_journal_init_inode (struct inode *);
1134 : : extern int jbd2_journal_update_format (journal_t *);
1135 : : extern int jbd2_journal_check_used_features
1136 : : (journal_t *, unsigned long, unsigned long, unsigned long);
1137 : : extern int jbd2_journal_check_available_features
1138 : : (journal_t *, unsigned long, unsigned long, unsigned long);
1139 : : extern int jbd2_journal_set_features
1140 : : (journal_t *, unsigned long, unsigned long, unsigned long);
1141 : : extern void jbd2_journal_clear_features
1142 : : (journal_t *, unsigned long, unsigned long, unsigned long);
1143 : : extern int jbd2_journal_load (journal_t *journal);
1144 : : extern int jbd2_journal_destroy (journal_t *);
1145 : : extern int jbd2_journal_recover (journal_t *journal);
1146 : : extern int jbd2_journal_wipe (journal_t *, int);
1147 : : extern int jbd2_journal_skip_recovery (journal_t *);
1148 : : extern void jbd2_journal_update_sb_errno(journal_t *);
1149 : : extern void jbd2_journal_update_sb_log_tail (journal_t *, tid_t,
1150 : : unsigned long, int);
1151 : : extern void __jbd2_journal_abort_hard (journal_t *);
1152 : : extern void jbd2_journal_abort (journal_t *, int);
1153 : : extern int jbd2_journal_errno (journal_t *);
1154 : : extern void jbd2_journal_ack_err (journal_t *);
1155 : : extern int jbd2_journal_clear_err (journal_t *);
1156 : : extern int jbd2_journal_bmap(journal_t *, unsigned long, unsigned long long *);
1157 : : extern int jbd2_journal_force_commit(journal_t *);
1158 : : extern int jbd2_journal_force_commit_nested(journal_t *);
1159 : : extern int jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *inode);
1160 : : extern int jbd2_journal_begin_ordered_truncate(journal_t *journal,
1161 : : struct jbd2_inode *inode, loff_t new_size);
1162 : : extern void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode);
1163 : : extern void jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_inode *jinode);
1164 : :
1165 : : /*
1166 : : * journal_head management
1167 : : */
1168 : : struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh);
1169 : : struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh);
1170 : : void jbd2_journal_put_journal_head(struct journal_head *jh);
1171 : :
1172 : : /*
1173 : : * handle management
1174 : : */
1175 : : extern struct kmem_cache *jbd2_handle_cache;
1176 : :
1177 : : static inline handle_t *jbd2_alloc_handle(gfp_t gfp_flags)
1178 : : {
1179 : 9662855 : return kmem_cache_zalloc(jbd2_handle_cache, gfp_flags);
1180 : : }
1181 : :
1182 : : static inline void jbd2_free_handle(handle_t *handle)
1183 : : {
1184 : 9664394 : kmem_cache_free(jbd2_handle_cache, handle);
1185 : : }
1186 : :
1187 : : /*
1188 : : * jbd2_inode management (optional, for those file systems that want to use
1189 : : * dynamically allocated jbd2_inode structures)
1190 : : */
1191 : : extern struct kmem_cache *jbd2_inode_cache;
1192 : :
1193 : : static inline struct jbd2_inode *jbd2_alloc_inode(gfp_t gfp_flags)
1194 : : {
1195 : 329204 : return kmem_cache_alloc(jbd2_inode_cache, gfp_flags);
1196 : : }
1197 : :
1198 : : static inline void jbd2_free_inode(struct jbd2_inode *jinode)
1199 : : {
1200 : 335468 : kmem_cache_free(jbd2_inode_cache, jinode);
1201 : : }
1202 : :
1203 : : /* Primary revoke support */
1204 : : #define JOURNAL_REVOKE_DEFAULT_HASH 256
1205 : : extern int jbd2_journal_init_revoke(journal_t *, int);
1206 : : extern void jbd2_journal_destroy_revoke_caches(void);
1207 : : extern int jbd2_journal_init_revoke_caches(void);
1208 : :
1209 : : extern void jbd2_journal_destroy_revoke(journal_t *);
1210 : : extern int jbd2_journal_revoke (handle_t *, unsigned long long, struct buffer_head *);
1211 : : extern int jbd2_journal_cancel_revoke(handle_t *, struct journal_head *);
1212 : : extern void jbd2_journal_write_revoke_records(journal_t *journal,
1213 : : transaction_t *transaction,
1214 : : struct list_head *log_bufs,
1215 : : int write_op);
1216 : :
1217 : : /* Recovery revoke support */
1218 : : extern int jbd2_journal_set_revoke(journal_t *, unsigned long long, tid_t);
1219 : : extern int jbd2_journal_test_revoke(journal_t *, unsigned long long, tid_t);
1220 : : extern void jbd2_journal_clear_revoke(journal_t *);
1221 : : extern void jbd2_journal_switch_revoke_table(journal_t *journal);
1222 : : extern void jbd2_clear_buffer_revoked_flags(journal_t *journal);
1223 : :
1224 : : /*
1225 : : * The log thread user interface:
1226 : : *
1227 : : * Request space in the current transaction, and force transaction commit
1228 : : * transitions on demand.
1229 : : */
1230 : :
1231 : : int jbd2_log_start_commit(journal_t *journal, tid_t tid);
1232 : : int __jbd2_log_start_commit(journal_t *journal, tid_t tid);
1233 : : int jbd2_journal_start_commit(journal_t *journal, tid_t *tid);
1234 : : int jbd2_log_wait_commit(journal_t *journal, tid_t tid);
1235 : : int jbd2_complete_transaction(journal_t *journal, tid_t tid);
1236 : : int jbd2_log_do_checkpoint(journal_t *journal);
1237 : : int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid);
1238 : :
1239 : : void __jbd2_log_wait_for_space(journal_t *journal);
1240 : : extern void __jbd2_journal_drop_transaction(journal_t *, transaction_t *);
1241 : : extern int jbd2_cleanup_journal_tail(journal_t *);
1242 : :
1243 : : /* Debugging code only: */
1244 : :
1245 : : #define jbd_ENOSYS() \
1246 : : do { \
1247 : : printk (KERN_ERR "JBD unimplemented function %s\n", __func__); \
1248 : : current->state = TASK_UNINTERRUPTIBLE; \
1249 : : schedule(); \
1250 : : } while (1)
1251 : :
1252 : : /*
1253 : : * is_journal_abort
1254 : : *
1255 : : * Simple test wrapper function to test the JBD2_ABORT state flag. This
1256 : : * bit, when set, indicates that we have had a fatal error somewhere,
1257 : : * either inside the journaling layer or indicated to us by the client
1258 : : * (eg. ext3), and that we and should not commit any further
1259 : : * transactions.
1260 : : */
1261 : :
1262 : : static inline int is_journal_aborted(journal_t *journal)
1263 : : {
1264 : 62369163 : return journal->j_flags & JBD2_ABORT;
1265 : : }
1266 : :
1267 : : static inline int is_handle_aborted(handle_t *handle)
1268 : : {
1269 [ + - ][ + - ]: 62113272 : if (handle->h_aborted || !handle->h_transaction)
[ + + ][ + # ]
[ + ][ + - ]
[ + ][ + + ]
[ + - ][ + - ]
[ + ]
[ + + + + ]
[ + + ][ + - ]
[ + - ][ + - ]
[ + - ]
1270 : : return 1;
1271 : 62113478 : return is_journal_aborted(handle->h_transaction->t_journal);
1272 : : }
1273 : :
1274 : : static inline void jbd2_journal_abort_handle(handle_t *handle)
1275 : : {
1276 : 0 : handle->h_aborted = 1;
1277 : : }
1278 : :
1279 : : #endif /* __KERNEL__ */
1280 : :
1281 : : /* Comparison functions for transaction IDs: perform comparisons using
1282 : : * modulo arithmetic so that they work over sequence number wraps. */
1283 : :
1284 : : static inline int tid_gt(tid_t x, tid_t y)
1285 : : {
1286 : 171600 : int difference = (x - y);
1287 : 20656 : return (difference > 0);
1288 : : }
1289 : :
1290 : : static inline int tid_geq(tid_t x, tid_t y)
1291 : : {
1292 : 32074 : int difference = (x - y);
1293 : : return (difference >= 0);
1294 : : }
1295 : :
1296 : : extern int jbd2_journal_blocks_per_page(struct inode *inode);
1297 : : extern size_t journal_tag_bytes(journal_t *journal);
1298 : :
1299 : : /*
1300 : : * We reserve t_outstanding_credits >> JBD2_CONTROL_BLOCKS_SHIFT for
1301 : : * transaction control blocks.
1302 : : */
1303 : : #define JBD2_CONTROL_BLOCKS_SHIFT 5
1304 : :
1305 : : /*
1306 : : * Return the minimum number of blocks which must be free in the journal
1307 : : * before a new transaction may be started. Must be called under j_state_lock.
1308 : : */
1309 : : static inline int jbd2_space_needed(journal_t *journal)
1310 : : {
1311 : : int nblocks = journal->j_max_transaction_buffers;
1312 : 9663999 : return nblocks + (nblocks >> JBD2_CONTROL_BLOCKS_SHIFT);
1313 : : }
1314 : :
1315 : : /*
1316 : : * Return number of free blocks in the log. Must be called under j_state_lock.
1317 : : */
1318 : : static inline unsigned long jbd2_log_space_left(journal_t *journal)
1319 : : {
1320 : : /* Allow for rounding errors */
1321 : 9666311 : unsigned long free = journal->j_free - 32;
1322 : :
1323 [ + + ]: 9666311 : if (journal->j_committing_transaction) {
[ + + # # ]
[ # # ][ # # ]
1324 : 89683 : unsigned long committing = atomic_read(&journal->
1325 : : j_committing_transaction->t_outstanding_credits);
1326 : :
1327 : : /* Transaction + control blocks */
1328 : 89683 : free -= committing + (committing >> JBD2_CONTROL_BLOCKS_SHIFT);
1329 : : }
1330 : : return free;
1331 : : }
1332 : :
1333 : : /*
1334 : : * Definitions which augment the buffer_head layer
1335 : : */
1336 : :
1337 : : /* journaling buffer types */
1338 : : #define BJ_None 0 /* Not journaled */
1339 : : #define BJ_Metadata 1 /* Normal journaled metadata */
1340 : : #define BJ_Forget 2 /* Buffer superseded by this transaction */
1341 : : #define BJ_Shadow 3 /* Buffer contents being shadowed to the log */
1342 : : #define BJ_Reserved 4 /* Buffer is reserved for access by journal */
1343 : : #define BJ_Types 5
1344 : :
1345 : : extern int jbd_blocks_per_page(struct inode *inode);
1346 : :
1347 : : /* JBD uses a CRC32 checksum */
1348 : : #define JBD_MAX_CHECKSUM_SIZE 4
1349 : :
1350 : : static inline u32 jbd2_chksum(journal_t *journal, u32 crc,
1351 : : const void *address, unsigned int length)
1352 : : {
1353 : : struct {
1354 : : struct shash_desc shash;
1355 : : char ctx[JBD_MAX_CHECKSUM_SIZE];
1356 : : } desc;
1357 : : int err;
1358 : :
1359 [ # # ][ # # ]: 0 : BUG_ON(crypto_shash_descsize(journal->j_chksum_driver) >
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1360 : : JBD_MAX_CHECKSUM_SIZE);
1361 : :
1362 : 0 : desc.shash.tfm = journal->j_chksum_driver;
1363 : 0 : desc.shash.flags = 0;
1364 : 0 : *(u32 *)desc.ctx = crc;
1365 : :
1366 : 0 : err = crypto_shash_update(&desc.shash, address, length);
1367 [ - + ][ # # ]: 41896 : BUG_ON(err);
[ - + ][ - + ]
[ # # ]
1368 : :
1369 : 0 : return *(u32 *)desc.ctx;
1370 : : }
1371 : :
1372 : : /* Return most recent uncommitted transaction */
1373 : : static inline tid_t jbd2_get_latest_transaction(journal_t *journal)
1374 : : {
1375 : : tid_t tid;
1376 : :
1377 : 5916 : read_lock(&journal->j_state_lock);
1378 : 5916 : tid = journal->j_commit_request;
1379 [ + + ]: 5916 : if (journal->j_running_transaction)
1380 : 1715 : tid = journal->j_running_transaction->t_tid;
1381 : : read_unlock(&journal->j_state_lock);
1382 : : return tid;
1383 : : }
1384 : :
1385 : : #ifdef __KERNEL__
1386 : :
1387 : : #define buffer_trace_init(bh) do {} while (0)
1388 : : #define print_buffer_fields(bh) do {} while (0)
1389 : : #define print_buffer_trace(bh) do {} while (0)
1390 : : #define BUFFER_TRACE(bh, info) do {} while (0)
1391 : : #define BUFFER_TRACE2(bh, bh2, info) do {} while (0)
1392 : : #define JBUFFER_TRACE(jh, info) do {} while (0)
1393 : :
1394 : : #endif /* __KERNEL__ */
1395 : :
1396 : : #endif /* _LINUX_JBD2_H */
|
