1 The Linux Journalling API 1 The Linux Journalling API
2 ========================= 2 =========================
3 3
4 Overview 4 Overview
5 -------- 5 --------
6 6
7 Details 7 Details
8 ~~~~~~~ 8 ~~~~~~~
9 9
10 The journalling layer is easy to use. You need 10 The journalling layer is easy to use. You need to first of all create a
11 journal_t data structure. There are two calls 11 journal_t data structure. There are two calls to do this dependent on
12 how you decide to allocate the physical media 12 how you decide to allocate the physical media on which the journal
13 resides. The jbd2_journal_init_inode() call is 13 resides. The jbd2_journal_init_inode() call is for journals stored in
14 filesystem inodes, or the jbd2_journal_init_de 14 filesystem inodes, or the jbd2_journal_init_dev() call can be used
15 for journal stored on a raw device (in a conti 15 for journal stored on a raw device (in a continuous range of blocks). A
16 journal_t is a typedef for a struct pointer, s 16 journal_t is a typedef for a struct pointer, so when you are finally
17 finished make sure you call jbd2_journal_destr 17 finished make sure you call jbd2_journal_destroy() on it to free up
18 any used kernel memory. 18 any used kernel memory.
19 19
20 Once you have got your journal_t object you ne 20 Once you have got your journal_t object you need to 'mount' or load the
21 journal file. The journalling layer expects th 21 journal file. The journalling layer expects the space for the journal
22 was already allocated and initialized properly 22 was already allocated and initialized properly by the userspace tools.
23 When loading the journal you must call jbd2_jo 23 When loading the journal you must call jbd2_journal_load() to process
24 journal contents. If the client file system de 24 journal contents. If the client file system detects the journal contents
25 does not need to be processed (or even need no 25 does not need to be processed (or even need not have valid contents), it
26 may call jbd2_journal_wipe() to clear the jour 26 may call jbd2_journal_wipe() to clear the journal contents before
27 calling jbd2_journal_load(). 27 calling jbd2_journal_load().
28 28
29 Note that jbd2_journal_wipe(..,0) calls 29 Note that jbd2_journal_wipe(..,0) calls
30 jbd2_journal_skip_recovery() for you if it det 30 jbd2_journal_skip_recovery() for you if it detects any outstanding
31 transactions in the journal and similarly jbd2 31 transactions in the journal and similarly jbd2_journal_load() will
32 call jbd2_journal_recover() if necessary. I wo 32 call jbd2_journal_recover() if necessary. I would advise reading
33 ext4_load_journal() in fs/ext4/super.c for exa 33 ext4_load_journal() in fs/ext4/super.c for examples on this stage.
34 34
35 Now you can go ahead and start modifying the u 35 Now you can go ahead and start modifying the underlying filesystem.
36 Almost. 36 Almost.
37 37
38 You still need to actually journal your filesy 38 You still need to actually journal your filesystem changes, this is done
39 by wrapping them into transactions. Additional 39 by wrapping them into transactions. Additionally you also need to wrap
40 the modification of each of the buffers with c 40 the modification of each of the buffers with calls to the journal layer,
41 so it knows what the modifications you are act 41 so it knows what the modifications you are actually making are. To do
42 this use jbd2_journal_start() which returns a 42 this use jbd2_journal_start() which returns a transaction handle.
43 43
44 jbd2_journal_start() and its counterpart jbd2_ 44 jbd2_journal_start() and its counterpart jbd2_journal_stop(),
45 which indicates the end of a transaction are n 45 which indicates the end of a transaction are nestable calls, so you can
46 reenter a transaction if necessary, but rememb 46 reenter a transaction if necessary, but remember you must call
47 jbd2_journal_stop() the same number of times a 47 jbd2_journal_stop() the same number of times as
48 jbd2_journal_start() before the transaction is 48 jbd2_journal_start() before the transaction is completed (or more
49 accurately leaves the update phase). Ext4/VFS 49 accurately leaves the update phase). Ext4/VFS makes use of this feature to
50 simplify handling of inode dirtying, quota sup 50 simplify handling of inode dirtying, quota support, etc.
51 51
52 Inside each transaction you need to wrap the m 52 Inside each transaction you need to wrap the modifications to the
53 individual buffers (blocks). Before you start 53 individual buffers (blocks). Before you start to modify a buffer you
54 need to call jbd2_journal_get_create_access() 54 need to call jbd2_journal_get_create_access() /
55 jbd2_journal_get_write_access() / 55 jbd2_journal_get_write_access() /
56 jbd2_journal_get_undo_access() as appropriate, 56 jbd2_journal_get_undo_access() as appropriate, this allows the
57 journalling layer to copy the unmodified 57 journalling layer to copy the unmodified
58 data if it needs to. After all the buffer may 58 data if it needs to. After all the buffer may be part of a previously
59 uncommitted transaction. At this point you are 59 uncommitted transaction. At this point you are at last ready to modify a
60 buffer, and once you are have done so you need 60 buffer, and once you are have done so you need to call
61 jbd2_journal_dirty_metadata(). Or if you've as 61 jbd2_journal_dirty_metadata(). Or if you've asked for access to a
62 buffer you now know is now longer required to 62 buffer you now know is now longer required to be pushed back on the
63 device you can call jbd2_journal_forget() in m 63 device you can call jbd2_journal_forget() in much the same way as you
64 might have used bforget() in the past. 64 might have used bforget() in the past.
65 65
66 A jbd2_journal_flush() may be called at any ti 66 A jbd2_journal_flush() may be called at any time to commit and
67 checkpoint all your transactions. 67 checkpoint all your transactions.
68 68
69 Then at umount time , in your put_super() you 69 Then at umount time , in your put_super() you can then call
70 jbd2_journal_destroy() to clean up your in-cor 70 jbd2_journal_destroy() to clean up your in-core journal object.
71 71
72 Unfortunately there a couple of ways the journ 72 Unfortunately there a couple of ways the journal layer can cause a
73 deadlock. The first thing to note is that each 73 deadlock. The first thing to note is that each task can only have a
74 single outstanding transaction at any one time 74 single outstanding transaction at any one time, remember nothing commits
75 until the outermost jbd2_journal_stop(). This 75 until the outermost jbd2_journal_stop(). This means you must complete
76 the transaction at the end of each file/inode/ 76 the transaction at the end of each file/inode/address etc. operation you
77 perform, so that the journalling system isn't 77 perform, so that the journalling system isn't re-entered on another
78 journal. Since transactions can't be nested/ba 78 journal. Since transactions can't be nested/batched across differing
79 journals, and another filesystem other than yo 79 journals, and another filesystem other than yours (say ext4) may be
80 modified in a later syscall. 80 modified in a later syscall.
81 81
82 The second case to bear in mind is that jbd2_j 82 The second case to bear in mind is that jbd2_journal_start() can block
83 if there isn't enough space in the journal for 83 if there isn't enough space in the journal for your transaction (based
84 on the passed nblocks param) - when it blocks 84 on the passed nblocks param) - when it blocks it merely(!) needs to wait
85 for transactions to complete and be committed 85 for transactions to complete and be committed from other tasks, so
86 essentially we are waiting for jbd2_journal_st 86 essentially we are waiting for jbd2_journal_stop(). So to avoid
87 deadlocks you must treat jbd2_journal_start() 87 deadlocks you must treat jbd2_journal_start() /
88 jbd2_journal_stop() as if they were semaphores 88 jbd2_journal_stop() as if they were semaphores and include them in
89 your semaphore ordering rules to prevent 89 your semaphore ordering rules to prevent
90 deadlocks. Note that jbd2_journal_extend() has 90 deadlocks. Note that jbd2_journal_extend() has similar blocking
91 behaviour to jbd2_journal_start() so you can d 91 behaviour to jbd2_journal_start() so you can deadlock here just as
92 easily as on jbd2_journal_start(). 92 easily as on jbd2_journal_start().
93 93
94 Try to reserve the right number of blocks the 94 Try to reserve the right number of blocks the first time. ;-). This will
95 be the maximum number of blocks you are going 95 be the maximum number of blocks you are going to touch in this
96 transaction. I advise having a look at at leas 96 transaction. I advise having a look at at least ext4_jbd.h to see the
97 basis on which ext4 uses to make these decisio 97 basis on which ext4 uses to make these decisions.
98 98
99 Another wriggle to watch out for is your on-di 99 Another wriggle to watch out for is your on-disk block allocation
100 strategy. Why? Because, if you do a delete, yo 100 strategy. Why? Because, if you do a delete, you need to ensure you
101 haven't reused any of the freed blocks until t 101 haven't reused any of the freed blocks until the transaction freeing
102 these blocks commits. If you reused these bloc 102 these blocks commits. If you reused these blocks and crash happens,
103 there is no way to restore the contents of the 103 there is no way to restore the contents of the reallocated blocks at the
104 end of the last fully committed transaction. O 104 end of the last fully committed transaction. One simple way of doing
105 this is to mark blocks as free in internal in- 105 this is to mark blocks as free in internal in-memory block allocation
106 structures only after the transaction freeing 106 structures only after the transaction freeing them commits. Ext4 uses
107 journal commit callback for this purpose. 107 journal commit callback for this purpose.
108 108
109 With journal commit callbacks you can ask the 109 With journal commit callbacks you can ask the journalling layer to call
110 a callback function when the transaction is fi 110 a callback function when the transaction is finally committed to disk,
111 so that you can do some of your own management 111 so that you can do some of your own management. You ask the journalling
112 layer for calling the callback by simply setti 112 layer for calling the callback by simply setting
113 ``journal->j_commit_callback`` function pointe 113 ``journal->j_commit_callback`` function pointer and that function is
114 called after each transaction commit. You can 114 called after each transaction commit. You can also use
115 ``transaction->t_private_list`` for attaching 115 ``transaction->t_private_list`` for attaching entries to a transaction
116 that need processing when the transaction comm 116 that need processing when the transaction commits.
117 117
118 JBD2 also provides a way to block all transact 118 JBD2 also provides a way to block all transaction updates via
119 jbd2_journal_lock_updates() / 119 jbd2_journal_lock_updates() /
120 jbd2_journal_unlock_updates(). Ext4 uses this 120 jbd2_journal_unlock_updates(). Ext4 uses this when it wants a
121 window with a clean and stable fs for a moment 121 window with a clean and stable fs for a moment. E.g.
122 122
123 :: 123 ::
124 124
125 125
126 jbd2_journal_lock_updates() //stop new 126 jbd2_journal_lock_updates() //stop new stuff happening..
127 jbd2_journal_flush() // checkpo 127 jbd2_journal_flush() // checkpoint everything.
128 ..do stuff on stable fs 128 ..do stuff on stable fs
129 jbd2_journal_unlock_updates() // carry 129 jbd2_journal_unlock_updates() // carry on with filesystem use.
130 130
131 The opportunities for abuse and DOS attacks wi 131 The opportunities for abuse and DOS attacks with this should be obvious,
132 if you allow unprivileged userspace to trigger 132 if you allow unprivileged userspace to trigger codepaths containing
133 these calls. 133 these calls.
134 134
135 Fast commits <<
136 ~~~~~~~~~~~~ <<
137 <<
138 JBD2 to also allows you to perform file-system <<
139 fast commits. In order to use fast commits, yo <<
140 callbacks that perform corresponding work: <<
141 <<
142 `journal->j_fc_cleanup_cb`: Cleanup function c <<
143 fast commit. <<
144 <<
145 `journal->j_fc_replay_cb`: Replay function cal <<
146 blocks. <<
147 <<
148 File system is free to perform fast commits as <<
149 gets permission from JBD2 to do so by calling <<
150 :c:func:`jbd2_fc_begin_commit()`. Once a fast <<
151 file system should tell JBD2 about it by call <<
152 :c:func:`jbd2_fc_end_commit()`. If the file sy <<
153 commit immediately after stopping the fast com <<
154 :c:func:`jbd2_fc_end_commit_fallback()`. This <<
155 fails for some reason and the only way to guar <<
156 perform the full traditional commit. <<
157 <<
158 JBD2 helper functions to manage fast commit bu <<
159 :c:func:`jbd2_fc_get_buf()` and :c:func:`jbd2_ <<
160 and wait on IO completion of fast commit buffe <<
161 <<
162 Currently, only Ext4 implements fast commits. <<
163 of fast commits, please refer to the top level <<
164 fs/ext4/fast_commit.c. <<
165 <<
166 Summary 135 Summary
167 ~~~~~~~ 136 ~~~~~~~
168 137
169 Using the journal is a matter of wrapping the 138 Using the journal is a matter of wrapping the different context changes,
170 being each mount, each modification (transacti 139 being each mount, each modification (transaction) and each changed
171 buffer to tell the journalling layer about the 140 buffer to tell the journalling layer about them.
172 141
173 Data Types 142 Data Types
174 ---------- 143 ----------
175 144
176 The journalling layer uses typedefs to 'hide' 145 The journalling layer uses typedefs to 'hide' the concrete definitions
177 of the structures used. As a client of the JBD 146 of the structures used. As a client of the JBD2 layer you can just rely
178 on the using the pointer as a magic cookie of 147 on the using the pointer as a magic cookie of some sort. Obviously the
179 hiding is not enforced as this is 'C'. 148 hiding is not enforced as this is 'C'.
180 149
181 Structures 150 Structures
182 ~~~~~~~~~~ 151 ~~~~~~~~~~
183 152
184 .. kernel-doc:: include/linux/jbd2.h 153 .. kernel-doc:: include/linux/jbd2.h
185 :internal: 154 :internal:
186 155
187 Functions 156 Functions
188 --------- 157 ---------
189 158
190 The functions here are split into two groups t 159 The functions here are split into two groups those that affect a journal
191 as a whole, and those which are used to manage 160 as a whole, and those which are used to manage transactions
192 161
193 Journal Level 162 Journal Level
194 ~~~~~~~~~~~~~ 163 ~~~~~~~~~~~~~
195 164
196 .. kernel-doc:: fs/jbd2/journal.c 165 .. kernel-doc:: fs/jbd2/journal.c
197 :export: 166 :export:
198 167
199 .. kernel-doc:: fs/jbd2/recovery.c 168 .. kernel-doc:: fs/jbd2/recovery.c
200 :internal: 169 :internal:
201 170
202 Transaction Level !! 171 Transasction Level
203 ~~~~~~~~~~~~~~~~~~ 172 ~~~~~~~~~~~~~~~~~~
204 173
205 .. kernel-doc:: fs/jbd2/transaction.c 174 .. kernel-doc:: fs/jbd2/transaction.c
206 175
207 See also 176 See also
208 -------- 177 --------
209 178
210 `Journaling the Linux ext2fs Filesystem, Linux 179 `Journaling the Linux ext2fs Filesystem, LinuxExpo 98, Stephen
211 Tweedie <http://kernel.org/pub/linux/kernel/pe 180 Tweedie <http://kernel.org/pub/linux/kernel/people/sct/ext3/journal-design.ps.gz>`__
212 181
213 `Ext3 Journalling FileSystem, OLS 2000, Dr. St 182 `Ext3 Journalling FileSystem, OLS 2000, Dr. Stephen
214 Tweedie <http://olstrans.sourceforge.net/relea 183 Tweedie <http://olstrans.sourceforge.net/release/OLS2000-ext3/OLS2000-ext3.html>`__
215 184
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.