Branch data Line data Source code
1 : : /*
2 : : * linux/fs/jbd2/journal.c
3 : : *
4 : : * Written by Stephen C. Tweedie <sct@redhat.com>, 1998
5 : : *
6 : : * Copyright 1998 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 : : * Generic filesystem journal-writing code; part of the ext2fs
13 : : * journaling system.
14 : : *
15 : : * This file manages journals: areas of disk reserved for logging
16 : : * transactional updates. This includes the kernel journaling thread
17 : : * which is responsible for scheduling updates to the log.
18 : : *
19 : : * We do not actually manage the physical storage of the journal in this
20 : : * file: that is left to a per-journal policy function, which allows us
21 : : * to store the journal within a filesystem-specified area for ext2
22 : : * journaling (ext2 can use a reserved inode for storing the log).
23 : : */
24 : :
25 : : #include <linux/module.h>
26 : : #include <linux/time.h>
27 : : #include <linux/fs.h>
28 : : #include <linux/jbd2.h>
29 : : #include <linux/errno.h>
30 : : #include <linux/slab.h>
31 : : #include <linux/init.h>
32 : : #include <linux/mm.h>
33 : : #include <linux/freezer.h>
34 : : #include <linux/pagemap.h>
35 : : #include <linux/kthread.h>
36 : : #include <linux/poison.h>
37 : : #include <linux/proc_fs.h>
38 : : #include <linux/seq_file.h>
39 : : #include <linux/math64.h>
40 : : #include <linux/hash.h>
41 : : #include <linux/log2.h>
42 : : #include <linux/vmalloc.h>
43 : : #include <linux/backing-dev.h>
44 : : #include <linux/bitops.h>
45 : : #include <linux/ratelimit.h>
46 : :
47 : : #define CREATE_TRACE_POINTS
48 : : #include <trace/events/jbd2.h>
49 : :
50 : : #include <asm/uaccess.h>
51 : : #include <asm/page.h>
52 : :
53 : : #ifdef CONFIG_JBD2_DEBUG
54 : : ushort jbd2_journal_enable_debug __read_mostly;
55 : : EXPORT_SYMBOL(jbd2_journal_enable_debug);
56 : :
57 : : module_param_named(jbd2_debug, jbd2_journal_enable_debug, ushort, 0644);
58 : : MODULE_PARM_DESC(jbd2_debug, "Debugging level for jbd2");
59 : : #endif
60 : :
61 : : EXPORT_SYMBOL(jbd2_journal_extend);
62 : : EXPORT_SYMBOL(jbd2_journal_stop);
63 : : EXPORT_SYMBOL(jbd2_journal_lock_updates);
64 : : EXPORT_SYMBOL(jbd2_journal_unlock_updates);
65 : : EXPORT_SYMBOL(jbd2_journal_get_write_access);
66 : : EXPORT_SYMBOL(jbd2_journal_get_create_access);
67 : : EXPORT_SYMBOL(jbd2_journal_get_undo_access);
68 : : EXPORT_SYMBOL(jbd2_journal_set_triggers);
69 : : EXPORT_SYMBOL(jbd2_journal_dirty_metadata);
70 : : EXPORT_SYMBOL(jbd2_journal_forget);
71 : : #if 0
72 : : EXPORT_SYMBOL(journal_sync_buffer);
73 : : #endif
74 : : EXPORT_SYMBOL(jbd2_journal_flush);
75 : : EXPORT_SYMBOL(jbd2_journal_revoke);
76 : :
77 : : EXPORT_SYMBOL(jbd2_journal_init_dev);
78 : : EXPORT_SYMBOL(jbd2_journal_init_inode);
79 : : EXPORT_SYMBOL(jbd2_journal_check_used_features);
80 : : EXPORT_SYMBOL(jbd2_journal_check_available_features);
81 : : EXPORT_SYMBOL(jbd2_journal_set_features);
82 : : EXPORT_SYMBOL(jbd2_journal_load);
83 : : EXPORT_SYMBOL(jbd2_journal_destroy);
84 : : EXPORT_SYMBOL(jbd2_journal_abort);
85 : : EXPORT_SYMBOL(jbd2_journal_errno);
86 : : EXPORT_SYMBOL(jbd2_journal_ack_err);
87 : : EXPORT_SYMBOL(jbd2_journal_clear_err);
88 : : EXPORT_SYMBOL(jbd2_log_wait_commit);
89 : : EXPORT_SYMBOL(jbd2_log_start_commit);
90 : : EXPORT_SYMBOL(jbd2_journal_start_commit);
91 : : EXPORT_SYMBOL(jbd2_journal_force_commit_nested);
92 : : EXPORT_SYMBOL(jbd2_journal_wipe);
93 : : EXPORT_SYMBOL(jbd2_journal_blocks_per_page);
94 : : EXPORT_SYMBOL(jbd2_journal_invalidatepage);
95 : : EXPORT_SYMBOL(jbd2_journal_try_to_free_buffers);
96 : : EXPORT_SYMBOL(jbd2_journal_force_commit);
97 : : EXPORT_SYMBOL(jbd2_journal_file_inode);
98 : : EXPORT_SYMBOL(jbd2_journal_init_jbd_inode);
99 : : EXPORT_SYMBOL(jbd2_journal_release_jbd_inode);
100 : : EXPORT_SYMBOL(jbd2_journal_begin_ordered_truncate);
101 : : EXPORT_SYMBOL(jbd2_inode_cache);
102 : :
103 : : static void __journal_abort_soft (journal_t *journal, int errno);
104 : : static int jbd2_journal_create_slab(size_t slab_size);
105 : :
106 : : #ifdef CONFIG_JBD2_DEBUG
107 : : void __jbd2_debug(int level, const char *file, const char *func,
108 : : unsigned int line, const char *fmt, ...)
109 : : {
110 : : struct va_format vaf;
111 : : va_list args;
112 : :
113 : : if (level > jbd2_journal_enable_debug)
114 : : return;
115 : : va_start(args, fmt);
116 : : vaf.fmt = fmt;
117 : : vaf.va = &args;
118 : : printk(KERN_DEBUG "%s: (%s, %u): %pV\n", file, func, line, &vaf);
119 : : va_end(args);
120 : : }
121 : : EXPORT_SYMBOL(__jbd2_debug);
122 : : #endif
123 : :
124 : : /* Checksumming functions */
125 : 0 : int jbd2_verify_csum_type(journal_t *j, journal_superblock_t *sb)
126 : : {
127 [ # # ][ # # ]: 0 : if (!JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V2))
[ # # ][ # # ]
128 : : return 1;
129 : :
130 : 0 : return sb->s_checksum_type == JBD2_CRC32C_CHKSUM;
131 : : }
132 : :
133 : 0 : static __be32 jbd2_superblock_csum(journal_t *j, journal_superblock_t *sb)
134 : : {
135 : : __u32 csum;
136 : : __be32 old_csum;
137 : :
138 : 0 : old_csum = sb->s_checksum;
139 : 0 : sb->s_checksum = 0;
140 : : csum = jbd2_chksum(j, ~0, (char *)sb, sizeof(journal_superblock_t));
141 : 0 : sb->s_checksum = old_csum;
142 : :
143 [ # # ]: 0 : return cpu_to_be32(csum);
144 : : }
145 : :
146 : 0 : int jbd2_superblock_csum_verify(journal_t *j, journal_superblock_t *sb)
147 : : {
148 [ # # ][ # # ]: 0 : if (!JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V2))
149 : : return 1;
150 : :
151 : 0 : return sb->s_checksum == jbd2_superblock_csum(j, sb);
152 : : }
153 : :
154 : 0 : void jbd2_superblock_csum_set(journal_t *j, journal_superblock_t *sb)
155 : : {
156 [ + - ][ - + ]: 13 : if (!JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V2))
157 : 0 : return;
158 : :
159 : 0 : sb->s_checksum = jbd2_superblock_csum(j, sb);
160 : : }
161 : :
162 : : /*
163 : : * Helper function used to manage commit timeouts
164 : : */
165 : :
166 : 0 : static void commit_timeout(unsigned long __data)
167 : : {
168 : 356 : struct task_struct * p = (struct task_struct *) __data;
169 : :
170 : 356 : wake_up_process(p);
171 : 356 : }
172 : :
173 : : /*
174 : : * kjournald2: The main thread function used to manage a logging device
175 : : * journal.
176 : : *
177 : : * This kernel thread is responsible for two things:
178 : : *
179 : : * 1) COMMIT: Every so often we need to commit the current state of the
180 : : * filesystem to disk. The journal thread is responsible for writing
181 : : * all of the metadata buffers to disk.
182 : : *
183 : : * 2) CHECKPOINT: We cannot reuse a used section of the log file until all
184 : : * of the data in that part of the log has been rewritten elsewhere on
185 : : * the disk. Flushing these old buffers to reclaim space in the log is
186 : : * known as checkpointing, and this thread is responsible for that job.
187 : : */
188 : :
189 : 0 : static int kjournald2(void *arg)
190 : : {
191 : : journal_t *journal = arg;
192 : : transaction_t *transaction;
193 : :
194 : : /*
195 : : * Set up an interval timer which can be used to trigger a commit wakeup
196 : : * after the commit interval expires
197 : : */
198 : 0 : setup_timer(&journal->j_commit_timer, commit_timeout,
199 : : (unsigned long)current);
200 : :
201 : 0 : set_freezable();
202 : :
203 : : /* Record that the journal thread is running */
204 : 0 : journal->j_task = current;
205 : 0 : wake_up(&journal->j_wait_done_commit);
206 : :
207 : : /*
208 : : * And now, wait forever for commit wakeup events.
209 : : */
210 : 0 : write_lock(&journal->j_state_lock);
211 : :
212 : : loop:
213 [ + - ]: 41204 : if (journal->j_flags & JBD2_UNMOUNT)
214 : : goto end_loop;
215 : :
216 : : jbd_debug(1, "commit_sequence=%d, commit_request=%d\n",
217 : : journal->j_commit_sequence, journal->j_commit_request);
218 : :
219 [ + + ]: 41204 : if (journal->j_commit_sequence != journal->j_commit_request) {
220 : : jbd_debug(1, "OK, requests differ\n");
221 : : write_unlock(&journal->j_state_lock);
222 : 20656 : del_timer_sync(&journal->j_commit_timer);
223 : 20656 : jbd2_journal_commit_transaction(journal);
224 : 20656 : write_lock(&journal->j_state_lock);
225 : 41204 : goto loop;
226 : : }
227 : :
228 : 20548 : wake_up(&journal->j_wait_done_commit);
229 [ - + ]: 20548 : if (freezing(current)) {
230 : : /*
231 : : * The simpler the better. Flushing journal isn't a
232 : : * good idea, because that depends on threads that may
233 : : * be already stopped.
234 : : */
235 : : jbd_debug(1, "Now suspending kjournald2\n");
236 : : write_unlock(&journal->j_state_lock);
237 : : try_to_freeze();
238 : 0 : write_lock(&journal->j_state_lock);
239 : : } else {
240 : : /*
241 : : * We assume on resume that commits are already there,
242 : : * so we don't sleep
243 : : */
244 : 41096 : DEFINE_WAIT(wait);
245 : : int should_sleep = 1;
246 : :
247 : 20548 : prepare_to_wait(&journal->j_wait_commit, &wait,
248 : : TASK_INTERRUPTIBLE);
249 [ - + ]: 20548 : if (journal->j_commit_sequence != journal->j_commit_request)
250 : : should_sleep = 0;
251 : 20548 : transaction = journal->j_running_transaction;
252 [ + + ][ - + ]: 20548 : if (transaction && time_after_eq(jiffies,
253 : : transaction->t_expires))
254 : : should_sleep = 0;
255 [ - + ]: 20548 : if (journal->j_flags & JBD2_UNMOUNT)
256 : : should_sleep = 0;
257 [ + - ]: 20548 : if (should_sleep) {
258 : : write_unlock(&journal->j_state_lock);
259 : 20548 : schedule();
260 : 20548 : write_lock(&journal->j_state_lock);
261 : : }
262 : 20548 : finish_wait(&journal->j_wait_commit, &wait);
263 : : }
264 : :
265 : : jbd_debug(1, "kjournald2 wakes\n");
266 : :
267 : : /*
268 : : * Were we woken up by a commit wakeup event?
269 : : */
270 : 20548 : transaction = journal->j_running_transaction;
271 [ - + ][ + + ]: 20548 : if (transaction && time_after_eq(jiffies, transaction->t_expires)) {
272 : 1372 : journal->j_commit_request = transaction->t_tid;
273 : : jbd_debug(1, "woke because of timeout\n");
274 : : }
275 : : goto loop;
276 : :
277 : : end_loop:
278 : : write_unlock(&journal->j_state_lock);
279 : 0 : del_timer_sync(&journal->j_commit_timer);
280 : 0 : journal->j_task = NULL;
281 : 0 : wake_up(&journal->j_wait_done_commit);
282 : : jbd_debug(1, "Journal thread exiting.\n");
283 : 0 : return 0;
284 : : }
285 : :
286 : 0 : static int jbd2_journal_start_thread(journal_t *journal)
287 : : {
288 : : struct task_struct *t;
289 : :
290 [ # # ]: 0 : t = kthread_run(kjournald2, journal, "jbd2/%s",
291 : : journal->j_devname);
292 [ # # ]: 0 : if (IS_ERR(t))
293 : 0 : return PTR_ERR(t);
294 : :
295 [ # # ][ # # ]: 0 : wait_event(journal->j_wait_done_commit, journal->j_task != NULL);
296 : : return 0;
297 : : }
298 : :
299 : 0 : static void journal_kill_thread(journal_t *journal)
300 : : {
301 : 0 : write_lock(&journal->j_state_lock);
302 : 0 : journal->j_flags |= JBD2_UNMOUNT;
303 : :
304 [ # # ]: 0 : while (journal->j_task) {
305 : 0 : wake_up(&journal->j_wait_commit);
306 : : write_unlock(&journal->j_state_lock);
307 [ # # ][ # # ]: 0 : wait_event(journal->j_wait_done_commit, journal->j_task == NULL);
308 : 0 : write_lock(&journal->j_state_lock);
309 : : }
310 : : write_unlock(&journal->j_state_lock);
311 : 0 : }
312 : :
313 : : /*
314 : : * jbd2_journal_write_metadata_buffer: write a metadata buffer to the journal.
315 : : *
316 : : * Writes a metadata buffer to a given disk block. The actual IO is not
317 : : * performed but a new buffer_head is constructed which labels the data
318 : : * to be written with the correct destination disk block.
319 : : *
320 : : * Any magic-number escaping which needs to be done will cause a
321 : : * copy-out here. If the buffer happens to start with the
322 : : * JBD2_MAGIC_NUMBER, then we can't write it to the log directly: the
323 : : * magic number is only written to the log for descripter blocks. In
324 : : * this case, we copy the data and replace the first word with 0, and we
325 : : * return a result code which indicates that this buffer needs to be
326 : : * marked as an escaped buffer in the corresponding log descriptor
327 : : * block. The missing word can then be restored when the block is read
328 : : * during recovery.
329 : : *
330 : : * If the source buffer has already been modified by a new transaction
331 : : * since we took the last commit snapshot, we use the frozen copy of
332 : : * that data for IO. If we end up using the existing buffer_head's data
333 : : * for the write, then we have to make sure nobody modifies it while the
334 : : * IO is in progress. do_get_write_access() handles this.
335 : : *
336 : : * The function returns a pointer to the buffer_head to be used for IO.
337 : : *
338 : : *
339 : : * Return value:
340 : : * <0: Error
341 : : * >=0: Finished OK
342 : : *
343 : : * On success:
344 : : * Bit 0 set == escape performed on the data
345 : : * Bit 1 set == buffer copy-out performed (kfree the data after IO)
346 : : */
347 : :
348 : 0 : int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
349 : 140178 : struct journal_head *jh_in,
350 : : struct buffer_head **bh_out,
351 : : sector_t blocknr)
352 : : {
353 : : int need_copy_out = 0;
354 : : int done_copy_out = 0;
355 : : int do_escape = 0;
356 : : char *mapped_data;
357 : : struct buffer_head *new_bh;
358 : : struct page *new_page;
359 : : unsigned int new_offset;
360 : : struct buffer_head *bh_in = jh2bh(jh_in);
361 : 70418 : journal_t *journal = transaction->t_journal;
362 : :
363 : : /*
364 : : * The buffer really shouldn't be locked: only the current committing
365 : : * transaction is allowed to write it, so nobody else is allowed
366 : : * to do any IO.
367 : : *
368 : : * akpm: except if we're journalling data, and write() output is
369 : : * also part of a shared mapping, and another thread has
370 : : * decided to launch a writepage() against this buffer.
371 : : */
372 [ + - ]: 70418 : J_ASSERT_BH(bh_in, buffer_jbddirty(bh_in));
373 : :
374 : : retry_alloc:
375 : 70418 : new_bh = alloc_buffer_head(GFP_NOFS);
376 [ - + ]: 70418 : if (!new_bh) {
377 : : /*
378 : : * Failure is not an option, but __GFP_NOFAIL is going
379 : : * away; so we retry ourselves here.
380 : : */
381 : 0 : congestion_wait(BLK_RW_ASYNC, HZ/50);
382 : 0 : goto retry_alloc;
383 : : }
384 : :
385 : : /* keep subsequent assertions sane */
386 : 70418 : atomic_set(&new_bh->b_count, 1);
387 : :
388 : : jbd_lock_bh_state(bh_in);
389 : : repeat:
390 : : /*
391 : : * If a new transaction has already done a buffer copy-out, then
392 : : * we use that version of the data for the commit.
393 : : */
394 [ + + ]: 70418 : if (jh_in->b_frozen_data) {
395 : : done_copy_out = 1;
396 : 1316 : new_page = virt_to_page(jh_in->b_frozen_data);
397 : 658 : new_offset = offset_in_page(jh_in->b_frozen_data);
398 : : } else {
399 : 69760 : new_page = jh2bh(jh_in)->b_page;
400 : 69760 : new_offset = offset_in_page(jh2bh(jh_in)->b_data);
401 : : }
402 : :
403 : 70418 : mapped_data = kmap_atomic(new_page);
404 : : /*
405 : : * Fire data frozen trigger if data already wasn't frozen. Do this
406 : : * before checking for escaping, as the trigger may modify the magic
407 : : * offset. If a copy-out happens afterwards, it will have the correct
408 : : * data in the buffer.
409 : : */
410 [ + + ]: 70418 : if (!done_copy_out)
411 : 69760 : jbd2_buffer_frozen_trigger(jh_in, mapped_data + new_offset,
412 : : jh_in->b_triggers);
413 : :
414 : : /*
415 : : * Check for escaping
416 : : */
417 [ - + ]: 70418 : if (*((__be32 *)(mapped_data + new_offset)) ==
418 : : cpu_to_be32(JBD2_MAGIC_NUMBER)) {
419 : : need_copy_out = 1;
420 : : do_escape = 1;
421 : : }
422 : 70418 : kunmap_atomic(mapped_data);
423 : :
424 : : /*
425 : : * Do we need to do a data copy?
426 : : */
427 [ - + ]: 70418 : if (need_copy_out && !done_copy_out) {
428 : : char *tmp;
429 : :
430 : : jbd_unlock_bh_state(bh_in);
431 : 0 : tmp = jbd2_alloc(bh_in->b_size, GFP_NOFS);
432 [ # # ]: 0 : if (!tmp) {
433 : : brelse(new_bh);
434 : : return -ENOMEM;
435 : : }
436 : : jbd_lock_bh_state(bh_in);
437 [ # # ]: 0 : if (jh_in->b_frozen_data) {
438 : 0 : jbd2_free(tmp, bh_in->b_size);
439 : 0 : goto repeat;
440 : : }
441 : :
442 : 0 : jh_in->b_frozen_data = tmp;
443 : 0 : mapped_data = kmap_atomic(new_page);
444 : 0 : memcpy(tmp, mapped_data + new_offset, bh_in->b_size);
445 : 0 : kunmap_atomic(mapped_data);
446 : :
447 : 0 : new_page = virt_to_page(tmp);
448 : 0 : new_offset = offset_in_page(tmp);
449 : : done_copy_out = 1;
450 : :
451 : : /*
452 : : * This isn't strictly necessary, as we're using frozen
453 : : * data for the escaping, but it keeps consistency with
454 : : * b_frozen_data usage.
455 : : */
456 : 0 : jh_in->b_frozen_triggers = jh_in->b_triggers;
457 : : }
458 : :
459 : : /*
460 : : * Did we need to do an escaping? Now we've done all the
461 : : * copying, we can finally do so.
462 : : */
463 [ - + ]: 70418 : if (do_escape) {
464 : 0 : mapped_data = kmap_atomic(new_page);
465 : 0 : *((unsigned int *)(mapped_data + new_offset)) = 0;
466 : 0 : kunmap_atomic(mapped_data);
467 : : }
468 : :
469 : 70418 : set_bh_page(new_bh, new_page, new_offset);
470 : 70418 : new_bh->b_size = bh_in->b_size;
471 : 70418 : new_bh->b_bdev = journal->j_dev;
472 : 70418 : new_bh->b_blocknr = blocknr;
473 : 70418 : new_bh->b_private = bh_in;
474 : : set_buffer_mapped(new_bh);
475 : : set_buffer_dirty(new_bh);
476 : :
477 : 70418 : *bh_out = new_bh;
478 : :
479 : : /*
480 : : * The to-be-written buffer needs to get moved to the io queue,
481 : : * and the original buffer whose contents we are shadowing or
482 : : * copying is moved to the transaction's shadow queue.
483 : : */
484 : : JBUFFER_TRACE(jh_in, "file as BJ_Shadow");
485 : : spin_lock(&journal->j_list_lock);
486 : 70418 : __jbd2_journal_file_buffer(jh_in, transaction, BJ_Shadow);
487 : : spin_unlock(&journal->j_list_lock);
488 : : set_buffer_shadow(bh_in);
489 : : jbd_unlock_bh_state(bh_in);
490 : :
491 : 70418 : return do_escape | (done_copy_out << 1);
492 : : }
493 : :
494 : : /*
495 : : * Allocation code for the journal file. Manage the space left in the
496 : : * journal, so that we can begin checkpointing when appropriate.
497 : : */
498 : :
499 : : /*
500 : : * Called with j_state_lock locked for writing.
501 : : * Returns true if a transaction commit was started.
502 : : */
503 : 0 : int __jbd2_log_start_commit(journal_t *journal, tid_t target)
504 : : {
505 : : /* Return if the txn has already requested to be committed */
506 [ + + ]: 24691 : if (journal->j_commit_request == target)
507 : : return 0;
508 : :
509 : : /*
510 : : * The only transaction we can possibly wait upon is the
511 : : * currently running transaction (if it exists). Otherwise,
512 : : * the target tid must be an old one.
513 : : */
514 [ + - ][ + - ]: 20303 : if (journal->j_running_transaction &&
515 : 20303 : journal->j_running_transaction->t_tid == target) {
516 : : /*
517 : : * We want a new commit: OK, mark the request and wakeup the
518 : : * commit thread. We do _not_ do the commit ourselves.
519 : : */
520 : :
521 : 20303 : journal->j_commit_request = target;
522 : : jbd_debug(1, "JBD2: requesting commit %d/%d\n",
523 : : journal->j_commit_request,
524 : : journal->j_commit_sequence);
525 : 20303 : journal->j_running_transaction->t_requested = jiffies;
526 : 20303 : wake_up(&journal->j_wait_commit);
527 : 20303 : return 1;
528 [ # # ]: 0 : } else if (!tid_geq(journal->j_commit_request, target))
529 : : /* This should never happen, but if it does, preserve
530 : : the evidence before kjournald goes into a loop and
531 : : increments j_commit_sequence beyond all recognition. */
532 [ # # ][ # # ]: 0 : WARN_ONCE(1, "JBD2: bad log_start_commit: %u %u %u %u\n",
[ # # ]
533 : : journal->j_commit_request,
534 : : journal->j_commit_sequence,
535 : : target, journal->j_running_transaction ?
536 : : journal->j_running_transaction->t_tid : 0);
537 : : return 0;
538 : : }
539 : :
540 : 0 : int jbd2_log_start_commit(journal_t *journal, tid_t tid)
541 : : {
542 : : int ret;
543 : :
544 : 22977 : write_lock(&journal->j_state_lock);
545 : 22978 : ret = __jbd2_log_start_commit(journal, tid);
546 : : write_unlock(&journal->j_state_lock);
547 : 22978 : return ret;
548 : : }
549 : :
550 : : /*
551 : : * Force and wait any uncommitted transactions. We can only force the running
552 : : * transaction if we don't have an active handle, otherwise, we will deadlock.
553 : : * Returns: <0 in case of error,
554 : : * 0 if nothing to commit,
555 : : * 1 if transaction was successfully committed.
556 : : */
557 : 0 : static int __jbd2_journal_force_commit(journal_t *journal)
558 : : {
559 : : transaction_t *transaction = NULL;
560 : : tid_t tid;
561 : : int need_to_start = 0, ret = 0;
562 : :
563 : 105 : read_lock(&journal->j_state_lock);
564 [ + + ][ + - ]: 210 : if (journal->j_running_transaction && !current->journal_info) {
565 : : transaction = journal->j_running_transaction;
566 [ + + ]: 102 : if (!tid_geq(journal->j_commit_request, transaction->t_tid))
567 : : need_to_start = 1;
568 [ + + ]: 3 : } else if (journal->j_committing_transaction)
569 : : transaction = journal->j_committing_transaction;
570 : :
571 [ + + ]: 105 : if (!transaction) {
572 : : /* Nothing to commit */
573 : : read_unlock(&journal->j_state_lock);
574 : 2 : return 0;
575 : : }
576 : 103 : tid = transaction->t_tid;
577 : : read_unlock(&journal->j_state_lock);
578 [ + + ]: 103 : if (need_to_start)
579 : 100 : jbd2_log_start_commit(journal, tid);
580 : 103 : ret = jbd2_log_wait_commit(journal, tid);
581 [ + - ]: 103 : if (!ret)
582 : : ret = 1;
583 : :
584 : 103 : return ret;
585 : : }
586 : :
587 : : /**
588 : : * Force and wait upon a commit if the calling process is not within
589 : : * transaction. This is used for forcing out undo-protected data which contains
590 : : * bitmaps, when the fs is running out of space.
591 : : *
592 : : * @journal: journal to force
593 : : * Returns true if progress was made.
594 : : */
595 : 0 : int jbd2_journal_force_commit_nested(journal_t *journal)
596 : : {
597 : : int ret;
598 : :
599 : 0 : ret = __jbd2_journal_force_commit(journal);
600 : 0 : return ret > 0;
601 : : }
602 : :
603 : : /**
604 : : * int journal_force_commit() - force any uncommitted transactions
605 : : * @journal: journal to force
606 : : *
607 : : * Caller want unconditional commit. We can only force the running transaction
608 : : * if we don't have an active handle, otherwise, we will deadlock.
609 : : */
610 : 0 : int jbd2_journal_force_commit(journal_t *journal)
611 : : {
612 : : int ret;
613 : :
614 [ - + ]: 105 : J_ASSERT(!current->journal_info);
615 : 105 : ret = __jbd2_journal_force_commit(journal);
616 [ + + ]: 105 : if (ret > 0)
617 : : ret = 0;
618 : 0 : return ret;
619 : : }
620 : :
621 : : /*
622 : : * Start a commit of the current running transaction (if any). Returns true
623 : : * if a transaction is going to be committed (or is currently already
624 : : * committing), and fills its tid in at *ptid
625 : : */
626 : 0 : int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid)
627 : : {
628 : : int ret = 0;
629 : :
630 : 5916 : write_lock(&journal->j_state_lock);
631 [ + + ]: 5916 : if (journal->j_running_transaction) {
632 : 1713 : tid_t tid = journal->j_running_transaction->t_tid;
633 : :
634 : 1713 : __jbd2_log_start_commit(journal, tid);
635 : : /* There's a running transaction and we've just made sure
636 : : * it's commit has been scheduled. */
637 [ + - ]: 1713 : if (ptid)
638 : 1713 : *ptid = tid;
639 : : ret = 1;
640 [ + + ]: 4203 : } else if (journal->j_committing_transaction) {
641 : : /*
642 : : * If commit has been started, then we have to wait for
643 : : * completion of that transaction.
644 : : */
645 [ + - ]: 2432 : if (ptid)
646 : 2432 : *ptid = journal->j_committing_transaction->t_tid;
647 : : ret = 1;
648 : : }
649 : : write_unlock(&journal->j_state_lock);
650 : 5916 : return ret;
651 : : }
652 : :
653 : : /*
654 : : * Return 1 if a given transaction has not yet sent barrier request
655 : : * connected with a transaction commit. If 0 is returned, transaction
656 : : * may or may not have sent the barrier. Used to avoid sending barrier
657 : : * twice in common cases.
658 : : */
659 : 0 : int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid)
660 : : {
661 : : int ret = 0;
662 : : transaction_t *commit_trans;
663 : :
664 [ + ]: 31649 : if (!(journal->j_flags & JBD2_BARRIER))
665 : : return 0;
666 : 31651 : read_lock(&journal->j_state_lock);
667 : : /* Transaction already committed? */
668 [ + + ]: 31645 : if (tid_geq(journal->j_commit_sequence, tid))
669 : : goto out;
670 : 30047 : commit_trans = journal->j_committing_transaction;
671 [ + + ][ + + ]: 30047 : if (!commit_trans || commit_trans->t_tid != tid) {
672 : : ret = 1;
673 : : goto out;
674 : : }
675 : : /*
676 : : * Transaction is being committed and we already proceeded to
677 : : * submitting a flush to fs partition?
678 : : */
679 [ - + ]: 10517 : if (journal->j_fs_dev != journal->j_dev) {
680 [ # # ][ # # ]: 0 : if (!commit_trans->t_need_data_flush ||
681 : 0 : commit_trans->t_state >= T_COMMIT_DFLUSH)
682 : : goto out;
683 : : } else {
684 [ + + ]: 10517 : if (commit_trans->t_state >= T_COMMIT_JFLUSH)
685 : : goto out;
686 : : }
687 : : ret = 1;
688 : : out:
689 : : read_unlock(&journal->j_state_lock);
690 : 31651 : return ret;
691 : : }
692 : : EXPORT_SYMBOL(jbd2_trans_will_send_data_barrier);
693 : :
694 : : /*
695 : : * Wait for a specified commit to complete.
696 : : * The caller may not hold the journal lock.
697 : : */
698 : 0 : int jbd2_log_wait_commit(journal_t *journal, tid_t tid)
699 : : {
700 : : int err = 0;
701 : :
702 : 30156 : read_lock(&journal->j_state_lock);
703 : : #ifdef CONFIG_JBD2_DEBUG
704 : : if (!tid_geq(journal->j_commit_request, tid)) {
705 : : printk(KERN_ERR
706 : : "%s: error: j_commit_request=%d, tid=%d\n",
707 : : __func__, journal->j_commit_request, tid);
708 : : }
709 : : #endif
710 [ + + ]: 60312 : while (tid_gt(tid, journal->j_commit_sequence)) {
711 : : jbd_debug(1, "JBD2: want %d, j_commit_sequence=%d\n",
712 : : tid, journal->j_commit_sequence);
713 : 30157 : wake_up(&journal->j_wait_commit);
714 : : read_unlock(&journal->j_state_lock);
715 [ + - ][ + + ]: 60460 : wait_event(journal->j_wait_done_commit,
716 : : !tid_gt(tid, journal->j_commit_sequence));
717 : 30157 : read_lock(&journal->j_state_lock);
718 : : }
719 : : read_unlock(&journal->j_state_lock);
720 : :
721 [ - + ]: 30157 : if (unlikely(is_journal_aborted(journal)))
722 : : err = -EIO;
723 : 30157 : return err;
724 : : }
725 : :
726 : : /*
727 : : * When this function returns the transaction corresponding to tid
728 : : * will be completed. If the transaction has currently running, start
729 : : * committing that transaction before waiting for it to complete. If
730 : : * the transaction id is stale, it is by definition already completed,
731 : : * so just return SUCCESS.
732 : : */
733 : 0 : int jbd2_complete_transaction(journal_t *journal, tid_t tid)
734 : : {
735 : : int need_to_wait = 1;
736 : :
737 : 29034 : read_lock(&journal->j_state_lock);
738 [ + + ][ + + ]: 29034 : if (journal->j_running_transaction &&
739 : 20042 : journal->j_running_transaction->t_tid == tid) {
740 [ + + ]: 18756 : if (journal->j_commit_request != tid) {
741 : : /* transaction not yet started, so request it */
742 : : read_unlock(&journal->j_state_lock);
743 : 18380 : jbd2_log_start_commit(journal, tid);
744 : 18380 : goto wait_commit;
745 : : }
746 [ + + ][ + + ]: 10278 : } else if (!(journal->j_committing_transaction &&
747 : 9278 : journal->j_committing_transaction->t_tid == tid))
748 : : need_to_wait = 0;
749 : : read_unlock(&journal->j_state_lock);
750 [ + + ]: 10654 : if (!need_to_wait)
751 : : return 0;
752 : : wait_commit:
753 : 27987 : return jbd2_log_wait_commit(journal, tid);
754 : : }
755 : : EXPORT_SYMBOL(jbd2_complete_transaction);
756 : :
757 : : /*
758 : : * Log buffer allocation routines:
759 : : */
760 : :
761 : 0 : int jbd2_journal_next_log_block(journal_t *journal, unsigned long long *retp)
762 : : {
763 : : unsigned long blocknr;
764 : :
765 : 112314 : write_lock(&journal->j_state_lock);
766 [ - + ]: 112314 : J_ASSERT(journal->j_free > 1);
767 : :
768 : 112314 : blocknr = journal->j_head;
769 : 112314 : journal->j_head++;
770 : 112314 : journal->j_free--;
771 [ + + ]: 112314 : if (journal->j_head == journal->j_last)
772 : 3 : journal->j_head = journal->j_first;
773 : : write_unlock(&journal->j_state_lock);
774 : 112314 : return jbd2_journal_bmap(journal, blocknr, retp);
775 : : }
776 : :
777 : : /*
778 : : * Conversion of logical to physical block numbers for the journal
779 : : *
780 : : * On external journals the journal blocks are identity-mapped, so
781 : : * this is a no-op. If needed, we can use j_blk_offset - everything is
782 : : * ready.
783 : : */
784 : 0 : int jbd2_journal_bmap(journal_t *journal, unsigned long blocknr,
785 : : unsigned long long *retp)
786 : : {
787 : : int err = 0;
788 : : unsigned long long ret;
789 : :
790 [ + - ]: 112314 : if (journal->j_inode) {
791 : 112314 : ret = bmap(journal->j_inode, blocknr);
792 [ + - ]: 224628 : if (ret)
793 : 112314 : *retp = ret;
794 : : else {
795 : 0 : printk(KERN_ALERT "%s: journal block not found "
796 : : "at offset %lu on %s\n",
797 : 0 : __func__, blocknr, journal->j_devname);
798 : : err = -EIO;
799 : 0 : __journal_abort_soft(journal, err);
800 : : }
801 : : } else {
802 : 0 : *retp = blocknr; /* +journal->j_blk_offset */
803 : : }
804 : 112314 : return err;
805 : : }
806 : :
807 : : /*
808 : : * We play buffer_head aliasing tricks to write data/metadata blocks to
809 : : * the journal without copying their contents, but for journal
810 : : * descriptor blocks we do need to generate bona fide buffers.
811 : : *
812 : : * After the caller of jbd2_journal_get_descriptor_buffer() has finished modifying
813 : : * the buffer's contents they really should run flush_dcache_page(bh->b_page).
814 : : * But we don't bother doing that, so there will be coherency problems with
815 : : * mmaps of blockdevs which hold live JBD-controlled filesystems.
816 : : */
817 : 0 : struct buffer_head *jbd2_journal_get_descriptor_buffer(journal_t *journal)
818 : : {
819 : : struct buffer_head *bh;
820 : : unsigned long long blocknr;
821 : : int err;
822 : :
823 : 41896 : err = jbd2_journal_next_log_block(journal, &blocknr);
824 : :
825 [ + - ]: 41896 : if (err)
826 : : return NULL;
827 : :
828 : 41896 : bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
829 [ + - ]: 41896 : if (!bh)
830 : : return NULL;
831 : : lock_buffer(bh);
832 [ + - ]: 41896 : memset(bh->b_data, 0, journal->j_blocksize);
833 : : set_buffer_uptodate(bh);
834 : 41896 : unlock_buffer(bh);
835 : : BUFFER_TRACE(bh, "return this buffer");
836 : 41896 : return bh;
837 : : }
838 : :
839 : : /*
840 : : * Return tid of the oldest transaction in the journal and block in the journal
841 : : * where the transaction starts.
842 : : *
843 : : * If the journal is now empty, return which will be the next transaction ID
844 : : * we will write and where will that transaction start.
845 : : *
846 : : * The return value is 0 if journal tail cannot be pushed any further, 1 if
847 : : * it can.
848 : : */
849 : 0 : int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
850 : : unsigned long *block)
851 : : {
852 : : transaction_t *transaction;
853 : : int ret;
854 : :
855 : 20656 : read_lock(&journal->j_state_lock);
856 : : spin_lock(&journal->j_list_lock);
857 : 41312 : transaction = journal->j_checkpoint_transactions;
858 [ + + ]: 41312 : if (transaction) {
859 : 20617 : *tid = transaction->t_tid;
860 : 20617 : *block = transaction->t_log_start;
861 [ + - ]: 39 : } else if ((transaction = journal->j_committing_transaction) != NULL) {
862 : 39 : *tid = transaction->t_tid;
863 : 39 : *block = transaction->t_log_start;
864 [ # # ]: 0 : } else if ((transaction = journal->j_running_transaction) != NULL) {
865 : 0 : *tid = transaction->t_tid;
866 : 0 : *block = journal->j_head;
867 : : } else {
868 : 0 : *tid = journal->j_transaction_sequence;
869 : 0 : *block = journal->j_head;
870 : : }
871 : 20656 : ret = tid_gt(*tid, journal->j_tail_sequence);
872 : : spin_unlock(&journal->j_list_lock);
873 : : read_unlock(&journal->j_state_lock);
874 : :
875 : 20656 : return ret;
876 : : }
877 : :
878 : : /*
879 : : * Update information in journal structure and in on disk journal superblock
880 : : * about log tail. This function does not check whether information passed in
881 : : * really pushes log tail further. It's responsibility of the caller to make
882 : : * sure provided log tail information is valid (e.g. by holding
883 : : * j_checkpoint_mutex all the time between computing log tail and calling this
884 : : * function as is the case with jbd2_cleanup_journal_tail()).
885 : : *
886 : : * Requires j_checkpoint_mutex
887 : : */
888 : 0 : void __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
889 : : {
890 : : unsigned long freed;
891 : :
892 [ - + ]: 13 : BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
893 : :
894 : : /*
895 : : * We cannot afford for write to remain in drive's caches since as
896 : : * soon as we update j_tail, next transaction can start reusing journal
897 : : * space and if we lose sb update during power failure we'd replay
898 : : * old transaction with possibly newly overwritten data.
899 : : */
900 : 13 : jbd2_journal_update_sb_log_tail(journal, tid, block, WRITE_FUA);
901 : 13 : write_lock(&journal->j_state_lock);
902 : 13 : freed = block - journal->j_tail;
903 [ + + ]: 13 : if (block < journal->j_tail)
904 : 3 : freed += journal->j_last - journal->j_first;
905 : :
906 : : trace_jbd2_update_log_tail(journal, tid, block, freed);
907 : : jbd_debug(1,
908 : : "Cleaning journal tail from %d to %d (offset %lu), "
909 : : "freeing %lu\n",
910 : : journal->j_tail_sequence, tid, block, freed);
911 : :
912 : 0 : journal->j_free += freed;
913 : 0 : journal->j_tail_sequence = tid;
914 : 0 : journal->j_tail = block;
915 : : write_unlock(&journal->j_state_lock);
916 : 13 : }
917 : :
918 : : /*
919 : : * This is a variaon of __jbd2_update_log_tail which checks for validity of
920 : : * provided log tail and locks j_checkpoint_mutex. So it is safe against races
921 : : * with other threads updating log tail.
922 : : */
923 : 0 : void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
924 : : {
925 : 13 : mutex_lock(&journal->j_checkpoint_mutex);
926 [ + - ]: 13 : if (tid_gt(tid, journal->j_tail_sequence))
927 : 13 : __jbd2_update_log_tail(journal, tid, block);
928 : 13 : mutex_unlock(&journal->j_checkpoint_mutex);
929 : 13 : }
930 : :
931 : : struct jbd2_stats_proc_session {
932 : : journal_t *journal;
933 : : struct transaction_stats_s *stats;
934 : : int start;
935 : : int max;
936 : : };
937 : :
938 : 0 : static void *jbd2_seq_info_start(struct seq_file *seq, loff_t *pos)
939 : : {
940 [ + + ]: 2 : return *pos ? NULL : SEQ_START_TOKEN;
941 : : }
942 : :
943 : 0 : static void *jbd2_seq_info_next(struct seq_file *seq, void *v, loff_t *pos)
944 : : {
945 : 1 : return NULL;
946 : : }
947 : :
948 : 0 : static int jbd2_seq_info_show(struct seq_file *seq, void *v)
949 : : {
950 : 1 : struct jbd2_stats_proc_session *s = seq->private;
951 : :
952 [ + - ]: 1 : if (v != SEQ_START_TOKEN)
953 : : return 0;
954 : 1 : seq_printf(seq, "%lu transactions (%lu requested), "
955 : : "each up to %u blocks\n",
956 : 1 : s->stats->ts_tid, s->stats->ts_requested,
957 : 1 : s->journal->j_max_transaction_buffers);
958 [ + - ]: 1 : if (s->stats->ts_tid == 0)
959 : : return 0;
960 : 1 : seq_printf(seq, "average: \n %ums waiting for transaction\n",
961 : 1 : jiffies_to_msecs(s->stats->run.rs_wait / s->stats->ts_tid));
962 [ + - ]: 1 : seq_printf(seq, " %ums request delay\n",
963 : 1 : (s->stats->ts_requested == 0) ? 0 :
964 : 1 : jiffies_to_msecs(s->stats->run.rs_request_delay /
965 : : s->stats->ts_requested));
966 : 1 : seq_printf(seq, " %ums running transaction\n",
967 : 1 : jiffies_to_msecs(s->stats->run.rs_running / s->stats->ts_tid));
968 : 1 : seq_printf(seq, " %ums transaction was being locked\n",
969 : 1 : jiffies_to_msecs(s->stats->run.rs_locked / s->stats->ts_tid));
970 : 1 : seq_printf(seq, " %ums flushing data (in ordered mode)\n",
971 : 1 : jiffies_to_msecs(s->stats->run.rs_flushing / s->stats->ts_tid));
972 : 1 : seq_printf(seq, " %ums logging transaction\n",
973 : 1 : jiffies_to_msecs(s->stats->run.rs_logging / s->stats->ts_tid));
974 : 1 : seq_printf(seq, " %lluus average transaction commit time\n",
975 : 1 : div_u64(s->journal->j_average_commit_time, 1000));
976 : 1 : seq_printf(seq, " %lu handles per transaction\n",
977 : 1 : s->stats->run.rs_handle_count / s->stats->ts_tid);
978 : 1 : seq_printf(seq, " %lu blocks per transaction\n",
979 : 1 : s->stats->run.rs_blocks / s->stats->ts_tid);
980 : 1 : seq_printf(seq, " %lu logged blocks per transaction\n",
981 : 1 : s->stats->run.rs_blocks_logged / s->stats->ts_tid);
982 : 1 : return 0;
983 : : }
984 : :
985 : 0 : static void jbd2_seq_info_stop(struct seq_file *seq, void *v)
986 : : {
987 : 2 : }
988 : :
989 : : static const struct seq_operations jbd2_seq_info_ops = {
990 : : .start = jbd2_seq_info_start,
991 : : .next = jbd2_seq_info_next,
992 : : .stop = jbd2_seq_info_stop,
993 : : .show = jbd2_seq_info_show,
994 : : };
995 : :
996 : 0 : static int jbd2_seq_info_open(struct inode *inode, struct file *file)
997 : : {
998 : 1 : journal_t *journal = PDE_DATA(inode);
999 : : struct jbd2_stats_proc_session *s;
1000 : : int rc, size;
1001 : :
1002 : : s = kmalloc(sizeof(*s), GFP_KERNEL);
1003 [ + - ]: 1 : if (s == NULL)
1004 : : return -ENOMEM;
1005 : : size = sizeof(struct transaction_stats_s);
1006 : 1 : s->stats = kmalloc(size, GFP_KERNEL);
1007 [ - + ]: 1 : if (s->stats == NULL) {
1008 : 0 : kfree(s);
1009 : 0 : return -ENOMEM;
1010 : : }
1011 : : spin_lock(&journal->j_history_lock);
1012 : 1 : memcpy(s->stats, &journal->j_stats, size);
1013 : 1 : s->journal = journal;
1014 : : spin_unlock(&journal->j_history_lock);
1015 : :
1016 : 1 : rc = seq_open(file, &jbd2_seq_info_ops);
1017 [ + - ]: 2 : if (rc == 0) {
1018 : 1 : struct seq_file *m = file->private_data;
1019 : 1 : m->private = s;
1020 : : } else {
1021 : 0 : kfree(s->stats);
1022 : 0 : kfree(s);
1023 : : }
1024 : 1 : return rc;
1025 : :
1026 : : }
1027 : :
1028 : 0 : static int jbd2_seq_info_release(struct inode *inode, struct file *file)
1029 : : {
1030 : 1 : struct seq_file *seq = file->private_data;
1031 : 1 : struct jbd2_stats_proc_session *s = seq->private;
1032 : 1 : kfree(s->stats);
1033 : 1 : kfree(s);
1034 : 1 : return seq_release(inode, file);
1035 : : }
1036 : :
1037 : : static const struct file_operations jbd2_seq_info_fops = {
1038 : : .owner = THIS_MODULE,
1039 : : .open = jbd2_seq_info_open,
1040 : : .read = seq_read,
1041 : : .llseek = seq_lseek,
1042 : : .release = jbd2_seq_info_release,
1043 : : };
1044 : :
1045 : : static struct proc_dir_entry *proc_jbd2_stats;
1046 : :
1047 : 0 : static void jbd2_stats_proc_init(journal_t *journal)
1048 : : {
1049 : 0 : journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats);
1050 [ # # ]: 0 : if (journal->j_proc_entry) {
1051 : 0 : proc_create_data("info", S_IRUGO, journal->j_proc_entry,
1052 : : &jbd2_seq_info_fops, journal);
1053 : : }
1054 : 0 : }
1055 : :
1056 : 0 : static void jbd2_stats_proc_exit(journal_t *journal)
1057 : : {
1058 : 0 : remove_proc_entry("info", journal->j_proc_entry);
1059 : 0 : remove_proc_entry(journal->j_devname, proc_jbd2_stats);
1060 : 0 : }
1061 : :
1062 : : /*
1063 : : * Management for journal control blocks: functions to create and
1064 : : * destroy journal_t structures, and to initialise and read existing
1065 : : * journal blocks from disk. */
1066 : :
1067 : : /* First: create and setup a journal_t object in memory. We initialise
1068 : : * very few fields yet: that has to wait until we have created the
1069 : : * journal structures from from scratch, or loaded them from disk. */
1070 : :
1071 : 0 : static journal_t * journal_init_common (void)
1072 : : {
1073 : : journal_t *journal;
1074 : : int err;
1075 : :
1076 : : journal = kzalloc(sizeof(*journal), GFP_KERNEL);
1077 [ # # ]: 0 : if (!journal)
1078 : : return NULL;
1079 : :
1080 : 0 : init_waitqueue_head(&journal->j_wait_transaction_locked);
1081 : 0 : init_waitqueue_head(&journal->j_wait_done_commit);
1082 : 0 : init_waitqueue_head(&journal->j_wait_commit);
1083 : 0 : init_waitqueue_head(&journal->j_wait_updates);
1084 : 0 : init_waitqueue_head(&journal->j_wait_reserved);
1085 : 0 : mutex_init(&journal->j_barrier);
1086 : 0 : mutex_init(&journal->j_checkpoint_mutex);
1087 : 0 : spin_lock_init(&journal->j_revoke_lock);
1088 : 0 : spin_lock_init(&journal->j_list_lock);
1089 : 0 : rwlock_init(&journal->j_state_lock);
1090 : :
1091 : 0 : journal->j_commit_interval = (HZ * JBD2_DEFAULT_MAX_COMMIT_AGE);
1092 : 0 : journal->j_min_batch_time = 0;
1093 : 0 : journal->j_max_batch_time = 15000; /* 15ms */
1094 : 0 : atomic_set(&journal->j_reserved_credits, 0);
1095 : :
1096 : : /* The journal is marked for error until we succeed with recovery! */
1097 : 0 : journal->j_flags = JBD2_ABORT;
1098 : :
1099 : : /* Set up a default-sized revoke table for the new mount. */
1100 : 0 : err = jbd2_journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH);
1101 [ # # ]: 0 : if (err) {
1102 : 0 : kfree(journal);
1103 : 0 : return NULL;
1104 : : }
1105 : :
1106 : 0 : spin_lock_init(&journal->j_history_lock);
1107 : :
1108 : 0 : return journal;
1109 : : }
1110 : :
1111 : : /* jbd2_journal_init_dev and jbd2_journal_init_inode:
1112 : : *
1113 : : * Create a journal structure assigned some fixed set of disk blocks to
1114 : : * the journal. We don't actually touch those disk blocks yet, but we
1115 : : * need to set up all of the mapping information to tell the journaling
1116 : : * system where the journal blocks are.
1117 : : *
1118 : : */
1119 : :
1120 : : /**
1121 : : * journal_t * jbd2_journal_init_dev() - creates and initialises a journal structure
1122 : : * @bdev: Block device on which to create the journal
1123 : : * @fs_dev: Device which hold journalled filesystem for this journal.
1124 : : * @start: Block nr Start of journal.
1125 : : * @len: Length of the journal in blocks.
1126 : : * @blocksize: blocksize of journalling device
1127 : : *
1128 : : * Returns: a newly created journal_t *
1129 : : *
1130 : : * jbd2_journal_init_dev creates a journal which maps a fixed contiguous
1131 : : * range of blocks on an arbitrary block device.
1132 : : *
1133 : : */
1134 : 0 : journal_t * jbd2_journal_init_dev(struct block_device *bdev,
1135 : : struct block_device *fs_dev,
1136 : : unsigned long long start, int len, int blocksize)
1137 : : {
1138 : 0 : journal_t *journal = journal_init_common();
1139 : : struct buffer_head *bh;
1140 : : char *p;
1141 : : int n;
1142 : :
1143 [ # # ]: 0 : if (!journal)
1144 : : return NULL;
1145 : :
1146 : : /* journal descriptor can store up to n blocks -bzzz */
1147 : 0 : journal->j_blocksize = blocksize;
1148 : 0 : journal->j_dev = bdev;
1149 : 0 : journal->j_fs_dev = fs_dev;
1150 : 0 : journal->j_blk_offset = start;
1151 : 0 : journal->j_maxlen = len;
1152 : 0 : bdevname(journal->j_dev, journal->j_devname);
1153 : : p = journal->j_devname;
1154 [ # # ]: 0 : while ((p = strchr(p, '/')))
1155 : 0 : *p = '!';
1156 : 0 : jbd2_stats_proc_init(journal);
1157 : 0 : n = journal->j_blocksize / sizeof(journal_block_tag_t);
1158 : 0 : journal->j_wbufsize = n;
1159 : 0 : journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
1160 [ # # ]: 0 : if (!journal->j_wbuf) {
1161 : 0 : printk(KERN_ERR "%s: Can't allocate bhs for commit thread\n",
1162 : : __func__);
1163 : 0 : goto out_err;
1164 : : }
1165 : :
1166 : 0 : bh = __getblk(journal->j_dev, start, journal->j_blocksize);
1167 [ # # ]: 0 : if (!bh) {
1168 : 0 : printk(KERN_ERR
1169 : : "%s: Cannot get buffer for journal superblock\n",
1170 : : __func__);
1171 : 0 : goto out_err;
1172 : : }
1173 : 0 : journal->j_sb_buffer = bh;
1174 : 0 : journal->j_superblock = (journal_superblock_t *)bh->b_data;
1175 : :
1176 : 0 : return journal;
1177 : : out_err:
1178 : 0 : kfree(journal->j_wbuf);
1179 : 0 : jbd2_stats_proc_exit(journal);
1180 : 0 : kfree(journal);
1181 : 0 : return NULL;
1182 : : }
1183 : :
1184 : : /**
1185 : : * journal_t * jbd2_journal_init_inode () - creates a journal which maps to a inode.
1186 : : * @inode: An inode to create the journal in
1187 : : *
1188 : : * jbd2_journal_init_inode creates a journal which maps an on-disk inode as
1189 : : * the journal. The inode must exist already, must support bmap() and
1190 : : * must have all data blocks preallocated.
1191 : : */
1192 : 0 : journal_t * jbd2_journal_init_inode (struct inode *inode)
1193 : : {
1194 : : struct buffer_head *bh;
1195 : 0 : journal_t *journal = journal_init_common();
1196 : : char *p;
1197 : : int err;
1198 : : int n;
1199 : : unsigned long long blocknr;
1200 : :
1201 [ # # ]: 0 : if (!journal)
1202 : : return NULL;
1203 : :
1204 : 0 : journal->j_dev = journal->j_fs_dev = inode->i_sb->s_bdev;
1205 : 0 : journal->j_inode = inode;
1206 : 0 : bdevname(journal->j_dev, journal->j_devname);
1207 : : p = journal->j_devname;
1208 [ # # ]: 0 : while ((p = strchr(p, '/')))
1209 : 0 : *p = '!';
1210 : 0 : p = journal->j_devname + strlen(journal->j_devname);
1211 : 0 : sprintf(p, "-%lu", journal->j_inode->i_ino);
1212 : : jbd_debug(1,
1213 : : "journal %p: inode %s/%ld, size %Ld, bits %d, blksize %ld\n",
1214 : : journal, inode->i_sb->s_id, inode->i_ino,
1215 : : (long long) inode->i_size,
1216 : : inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize);
1217 : :
1218 : 0 : journal->j_maxlen = inode->i_size >> inode->i_sb->s_blocksize_bits;
1219 : 0 : journal->j_blocksize = inode->i_sb->s_blocksize;
1220 : 0 : jbd2_stats_proc_init(journal);
1221 : :
1222 : : /* journal descriptor can store up to n blocks -bzzz */
1223 : 0 : n = journal->j_blocksize / sizeof(journal_block_tag_t);
1224 : 0 : journal->j_wbufsize = n;
1225 : 0 : journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
1226 [ # # ]: 0 : if (!journal->j_wbuf) {
1227 : 0 : printk(KERN_ERR "%s: Can't allocate bhs for commit thread\n",
1228 : : __func__);
1229 : 0 : goto out_err;
1230 : : }
1231 : :
1232 : 0 : err = jbd2_journal_bmap(journal, 0, &blocknr);
1233 : : /* If that failed, give up */
1234 [ # # ]: 0 : if (err) {
1235 : 0 : printk(KERN_ERR "%s: Cannot locate journal superblock\n",
1236 : : __func__);
1237 : 0 : goto out_err;
1238 : : }
1239 : :
1240 : 0 : bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
1241 [ # # ]: 0 : if (!bh) {
1242 : 0 : printk(KERN_ERR
1243 : : "%s: Cannot get buffer for journal superblock\n",
1244 : : __func__);
1245 : 0 : goto out_err;
1246 : : }
1247 : 0 : journal->j_sb_buffer = bh;
1248 : 0 : journal->j_superblock = (journal_superblock_t *)bh->b_data;
1249 : :
1250 : 0 : return journal;
1251 : : out_err:
1252 : 0 : kfree(journal->j_wbuf);
1253 : 0 : jbd2_stats_proc_exit(journal);
1254 : 0 : kfree(journal);
1255 : 0 : return NULL;
1256 : : }
1257 : :
1258 : : /*
1259 : : * If the journal init or create aborts, we need to mark the journal
1260 : : * superblock as being NULL to prevent the journal destroy from writing
1261 : : * back a bogus superblock.
1262 : : */
1263 : : static void journal_fail_superblock (journal_t *journal)
1264 : : {
1265 : 0 : struct buffer_head *bh = journal->j_sb_buffer;
1266 : : brelse(bh);
1267 : 0 : journal->j_sb_buffer = NULL;
1268 : : }
1269 : :
1270 : : /*
1271 : : * Given a journal_t structure, initialise the various fields for
1272 : : * startup of a new journaling session. We use this both when creating
1273 : : * a journal, and after recovering an old journal to reset it for
1274 : : * subsequent use.
1275 : : */
1276 : :
1277 : 0 : static int journal_reset(journal_t *journal)
1278 : : {
1279 : 0 : journal_superblock_t *sb = journal->j_superblock;
1280 : : unsigned long long first, last;
1281 : :
1282 [ # # ]: 0 : first = be32_to_cpu(sb->s_first);
1283 [ # # ]: 0 : last = be32_to_cpu(sb->s_maxlen);
1284 [ # # ]: 0 : if (first + JBD2_MIN_JOURNAL_BLOCKS > last + 1) {
1285 : 0 : printk(KERN_ERR "JBD2: Journal too short (blocks %llu-%llu).\n",
1286 : : first, last);
1287 : : journal_fail_superblock(journal);
1288 : 0 : return -EINVAL;
1289 : : }
1290 : :
1291 : 0 : journal->j_first = first;
1292 : 0 : journal->j_last = last;
1293 : :
1294 : 0 : journal->j_head = first;
1295 : 0 : journal->j_tail = first;
1296 : 0 : journal->j_free = last - first;
1297 : :
1298 : 0 : journal->j_tail_sequence = journal->j_transaction_sequence;
1299 : 0 : journal->j_commit_sequence = journal->j_transaction_sequence - 1;
1300 : 0 : journal->j_commit_request = journal->j_commit_sequence;
1301 : :
1302 : 0 : journal->j_max_transaction_buffers = journal->j_maxlen / 4;
1303 : :
1304 : : /*
1305 : : * As a special case, if the on-disk copy is already marked as needing
1306 : : * no recovery (s_start == 0), then we can safely defer the superblock
1307 : : * update until the next commit by setting JBD2_FLUSHED. This avoids
1308 : : * attempting a write to a potential-readonly device.
1309 : : */
1310 [ # # ]: 0 : if (sb->s_start == 0) {
1311 : : jbd_debug(1, "JBD2: Skipping superblock update on recovered sb "
1312 : : "(start %ld, seq %d, errno %d)\n",
1313 : : journal->j_tail, journal->j_tail_sequence,
1314 : : journal->j_errno);
1315 : 0 : journal->j_flags |= JBD2_FLUSHED;
1316 : : } else {
1317 : : /* Lock here to make assertions happy... */
1318 : 0 : mutex_lock(&journal->j_checkpoint_mutex);
1319 : : /*
1320 : : * Update log tail information. We use WRITE_FUA since new
1321 : : * transaction will start reusing journal space and so we
1322 : : * must make sure information about current log tail is on
1323 : : * disk before that.
1324 : : */
1325 : 0 : jbd2_journal_update_sb_log_tail(journal,
1326 : : journal->j_tail_sequence,
1327 : : journal->j_tail,
1328 : : WRITE_FUA);
1329 : 0 : mutex_unlock(&journal->j_checkpoint_mutex);
1330 : : }
1331 : 0 : return jbd2_journal_start_thread(journal);
1332 : : }
1333 : :
1334 : 0 : static void jbd2_write_superblock(journal_t *journal, int write_op)
1335 : : {
1336 : 13 : struct buffer_head *bh = journal->j_sb_buffer;
1337 : 13 : journal_superblock_t *sb = journal->j_superblock;
1338 : : int ret;
1339 : :
1340 : : trace_jbd2_write_superblock(journal, write_op);
1341 [ - + ]: 13 : if (!(journal->j_flags & JBD2_BARRIER))
1342 : 0 : write_op &= ~(REQ_FUA | REQ_FLUSH);
1343 : : lock_buffer(bh);
1344 [ - + ]: 13 : if (buffer_write_io_error(bh)) {
1345 : : /*
1346 : : * Oh, dear. A previous attempt to write the journal
1347 : : * superblock failed. This could happen because the
1348 : : * USB device was yanked out. Or it could happen to
1349 : : * be a transient write error and maybe the block will
1350 : : * be remapped. Nothing we can do but to retry the
1351 : : * write and hope for the best.
1352 : : */
1353 : 0 : printk(KERN_ERR "JBD2: previous I/O error detected "
1354 : : "for journal superblock update for %s.\n",
1355 : 0 : journal->j_devname);
1356 : : clear_buffer_write_io_error(bh);
1357 : : set_buffer_uptodate(bh);
1358 : : }
1359 : 13 : jbd2_superblock_csum_set(journal, sb);
1360 : : get_bh(bh);
1361 : 13 : bh->b_end_io = end_buffer_write_sync;
1362 : 13 : ret = submit_bh(write_op, bh);
1363 : : wait_on_buffer(bh);
1364 [ - + ]: 26 : if (buffer_write_io_error(bh)) {
1365 : : clear_buffer_write_io_error(bh);
1366 : : set_buffer_uptodate(bh);
1367 : : ret = -EIO;
1368 : : }
1369 [ - + ]: 13 : if (ret) {
1370 : 0 : printk(KERN_ERR "JBD2: Error %d detected when updating "
1371 : : "journal superblock for %s.\n", ret,
1372 : 0 : journal->j_devname);
1373 : : }
1374 : 13 : }
1375 : :
1376 : : /**
1377 : : * jbd2_journal_update_sb_log_tail() - Update log tail in journal sb on disk.
1378 : : * @journal: The journal to update.
1379 : : * @tail_tid: TID of the new transaction at the tail of the log
1380 : : * @tail_block: The first block of the transaction at the tail of the log
1381 : : * @write_op: With which operation should we write the journal sb
1382 : : *
1383 : : * Update a journal's superblock information about log tail and write it to
1384 : : * disk, waiting for the IO to complete.
1385 : : */
1386 : 0 : void jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid,
1387 : : unsigned long tail_block, int write_op)
1388 : : {
1389 : 13 : journal_superblock_t *sb = journal->j_superblock;
1390 : :
1391 [ - + ]: 13 : BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
1392 : : jbd_debug(1, "JBD2: updating superblock (start %lu, seq %u)\n",
1393 : : tail_block, tail_tid);
1394 : :
1395 [ - + ]: 13 : sb->s_sequence = cpu_to_be32(tail_tid);
1396 [ - + ]: 13 : sb->s_start = cpu_to_be32(tail_block);
1397 : :
1398 : 13 : jbd2_write_superblock(journal, write_op);
1399 : :
1400 : : /* Log is no longer empty */
1401 : 13 : write_lock(&journal->j_state_lock);
1402 [ - + ]: 13 : WARN_ON(!sb->s_sequence);
1403 : 0 : journal->j_flags &= ~JBD2_FLUSHED;
1404 : : write_unlock(&journal->j_state_lock);
1405 : 13 : }
1406 : :
1407 : : /**
1408 : : * jbd2_mark_journal_empty() - Mark on disk journal as empty.
1409 : : * @journal: The journal to update.
1410 : : *
1411 : : * Update a journal's dynamic superblock fields to show that journal is empty.
1412 : : * Write updated superblock to disk waiting for IO to complete.
1413 : : */
1414 : 0 : static void jbd2_mark_journal_empty(journal_t *journal)
1415 : : {
1416 : 0 : journal_superblock_t *sb = journal->j_superblock;
1417 : :
1418 [ # # ]: 0 : BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
1419 : 0 : read_lock(&journal->j_state_lock);
1420 : : /* Is it already empty? */
1421 [ # # ]: 0 : if (sb->s_start == 0) {
1422 : : read_unlock(&journal->j_state_lock);
1423 : 0 : return;
1424 : : }
1425 : : jbd_debug(1, "JBD2: Marking journal as empty (seq %d)\n",
1426 : : journal->j_tail_sequence);
1427 : :
1428 [ # # ]: 0 : sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
1429 : 0 : sb->s_start = cpu_to_be32(0);
1430 : : read_unlock(&journal->j_state_lock);
1431 : :
1432 : 0 : jbd2_write_superblock(journal, WRITE_FUA);
1433 : :
1434 : : /* Log is no longer empty */
1435 : 0 : write_lock(&journal->j_state_lock);
1436 : 0 : journal->j_flags |= JBD2_FLUSHED;
1437 : : write_unlock(&journal->j_state_lock);
1438 : : }
1439 : :
1440 : :
1441 : : /**
1442 : : * jbd2_journal_update_sb_errno() - Update error in the journal.
1443 : : * @journal: The journal to update.
1444 : : *
1445 : : * Update a journal's errno. Write updated superblock to disk waiting for IO
1446 : : * to complete.
1447 : : */
1448 : 0 : void jbd2_journal_update_sb_errno(journal_t *journal)
1449 : : {
1450 : 0 : journal_superblock_t *sb = journal->j_superblock;
1451 : :
1452 : 0 : read_lock(&journal->j_state_lock);
1453 : : jbd_debug(1, "JBD2: updating superblock error (errno %d)\n",
1454 : : journal->j_errno);
1455 [ # # ]: 0 : sb->s_errno = cpu_to_be32(journal->j_errno);
1456 : : read_unlock(&journal->j_state_lock);
1457 : :
1458 : 0 : jbd2_write_superblock(journal, WRITE_SYNC);
1459 : 0 : }
1460 : : EXPORT_SYMBOL(jbd2_journal_update_sb_errno);
1461 : :
1462 : : /*
1463 : : * Read the superblock for a given journal, performing initial
1464 : : * validation of the format.
1465 : : */
1466 : 0 : static int journal_get_superblock(journal_t *journal)
1467 : : {
1468 : : struct buffer_head *bh;
1469 : : journal_superblock_t *sb;
1470 : : int err = -EIO;
1471 : :
1472 : 0 : bh = journal->j_sb_buffer;
1473 : :
1474 [ # # ]: 0 : J_ASSERT(bh != NULL);
1475 [ # # ]: 0 : if (!buffer_uptodate(bh)) {
1476 : 0 : ll_rw_block(READ, 1, &bh);
1477 : 0 : wait_on_buffer(bh);
1478 [ # # ]: 0 : if (!buffer_uptodate(bh)) {
1479 : 0 : printk(KERN_ERR
1480 : : "JBD2: IO error reading journal superblock\n");
1481 : 0 : goto out;
1482 : : }
1483 : : }
1484 : :
1485 [ # # ]: 0 : if (buffer_verified(bh))
1486 : : return 0;
1487 : :
1488 : 0 : sb = journal->j_superblock;
1489 : :
1490 : : err = -EINVAL;
1491 : :
1492 [ # # ][ # # ]: 0 : if (sb->s_header.h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER) ||
1493 [ # # ]: 0 : sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) {
1494 : 0 : printk(KERN_WARNING "JBD2: no valid journal superblock found\n");
1495 : 0 : goto out;
1496 : : }
1497 : :
1498 [ # # ]: 0 : switch(be32_to_cpu(sb->s_header.h_blocktype)) {
[ # # # ]
1499 : : case JBD2_SUPERBLOCK_V1:
1500 : 0 : journal->j_format_version = 1;
1501 : 0 : break;
1502 : : case JBD2_SUPERBLOCK_V2:
1503 : 0 : journal->j_format_version = 2;
1504 : 0 : break;
1505 : : default:
1506 : 0 : printk(KERN_WARNING "JBD2: unrecognised superblock format ID\n");
1507 : 0 : goto out;
1508 : : }
1509 : :
1510 [ # # ][ # # ]: 0 : if (be32_to_cpu(sb->s_maxlen) < journal->j_maxlen)
1511 [ # # ]: 0 : journal->j_maxlen = be32_to_cpu(sb->s_maxlen);
1512 [ # # ][ # # ]: 0 : else if (be32_to_cpu(sb->s_maxlen) > journal->j_maxlen) {
1513 : 0 : printk(KERN_WARNING "JBD2: journal file too short\n");
1514 : 0 : goto out;
1515 : : }
1516 : :
1517 [ # # ][ # # ]: 0 : if (be32_to_cpu(sb->s_first) == 0 ||
[ # # ][ # # ]
1518 [ # # ]: 0 : be32_to_cpu(sb->s_first) >= journal->j_maxlen) {
1519 [ # # ]: 0 : printk(KERN_WARNING
1520 : : "JBD2: Invalid start block of journal: %u\n",
1521 : 0 : be32_to_cpu(sb->s_first));
1522 : 0 : goto out;
1523 : : }
1524 : :
1525 [ # # ][ # # ]: 0 : if (JBD2_HAS_COMPAT_FEATURE(journal, JBD2_FEATURE_COMPAT_CHECKSUM) &&
[ # # ]
1526 : 0 : JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2)) {
1527 : : /* Can't have checksum v1 and v2 on at the same time! */
1528 : 0 : printk(KERN_ERR "JBD2: Can't enable checksumming v1 and v2 "
1529 : : "at the same time!\n");
1530 : 0 : goto out;
1531 : : }
1532 : :
1533 [ # # ]: 0 : if (!jbd2_verify_csum_type(journal, sb)) {
1534 : 0 : printk(KERN_ERR "JBD2: Unknown checksum type\n");
1535 : 0 : goto out;
1536 : : }
1537 : :
1538 : : /* Load the checksum driver */
1539 [ # # ][ # # ]: 0 : if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2)) {
1540 : 0 : journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
1541 [ # # ]: 0 : if (IS_ERR(journal->j_chksum_driver)) {
1542 : 0 : printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n");
1543 : 0 : err = PTR_ERR(journal->j_chksum_driver);
1544 : 0 : journal->j_chksum_driver = NULL;
1545 : 0 : goto out;
1546 : : }
1547 : : }
1548 : :
1549 : : /* Check superblock checksum */
1550 [ # # ]: 0 : if (!jbd2_superblock_csum_verify(journal, sb)) {
1551 : 0 : printk(KERN_ERR "JBD2: journal checksum error\n");
1552 : 0 : goto out;
1553 : : }
1554 : :
1555 : : /* Precompute checksum seed for all metadata */
1556 [ # # ][ # # ]: 0 : if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2))
1557 : 0 : journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid,
1558 : : sizeof(sb->s_uuid));
1559 : :
1560 : 0 : set_buffer_verified(bh);
1561 : :
1562 : 0 : return 0;
1563 : :
1564 : : out:
1565 : : journal_fail_superblock(journal);
1566 : 0 : return err;
1567 : : }
1568 : :
1569 : : /*
1570 : : * Load the on-disk journal superblock and read the key fields into the
1571 : : * journal_t.
1572 : : */
1573 : :
1574 : 0 : static int load_superblock(journal_t *journal)
1575 : : {
1576 : : int err;
1577 : : journal_superblock_t *sb;
1578 : :
1579 : 0 : err = journal_get_superblock(journal);
1580 [ # # ]: 0 : if (err)
1581 : : return err;
1582 : :
1583 : 0 : sb = journal->j_superblock;
1584 : :
1585 [ # # ]: 0 : journal->j_tail_sequence = be32_to_cpu(sb->s_sequence);
1586 [ # # ]: 0 : journal->j_tail = be32_to_cpu(sb->s_start);
1587 [ # # ]: 0 : journal->j_first = be32_to_cpu(sb->s_first);
1588 [ # # ]: 0 : journal->j_last = be32_to_cpu(sb->s_maxlen);
1589 [ # # ]: 0 : journal->j_errno = be32_to_cpu(sb->s_errno);
1590 : :
1591 : 0 : return 0;
1592 : : }
1593 : :
1594 : :
1595 : : /**
1596 : : * int jbd2_journal_load() - Read journal from disk.
1597 : : * @journal: Journal to act on.
1598 : : *
1599 : : * Given a journal_t structure which tells us which disk blocks contain
1600 : : * a journal, read the journal from disk to initialise the in-memory
1601 : : * structures.
1602 : : */
1603 : 0 : int jbd2_journal_load(journal_t *journal)
1604 : : {
1605 : : int err;
1606 : : journal_superblock_t *sb;
1607 : :
1608 : 0 : err = load_superblock(journal);
1609 [ # # ]: 0 : if (err)
1610 : : return err;
1611 : :
1612 : 0 : sb = journal->j_superblock;
1613 : : /* If this is a V2 superblock, then we have to check the
1614 : : * features flags on it. */
1615 : :
1616 [ # # ]: 0 : if (journal->j_format_version >= 2) {
1617 [ # # ]: 0 : if ((sb->s_feature_ro_compat &
1618 [ # # ]: 0 : ~cpu_to_be32(JBD2_KNOWN_ROCOMPAT_FEATURES)) ||
1619 : 0 : (sb->s_feature_incompat &
1620 : : ~cpu_to_be32(JBD2_KNOWN_INCOMPAT_FEATURES))) {
1621 : 0 : printk(KERN_WARNING
1622 : : "JBD2: Unrecognised features on journal\n");
1623 : 0 : return -EINVAL;
1624 : : }
1625 : : }
1626 : :
1627 : : /*
1628 : : * Create a slab for this blocksize
1629 : : */
1630 [ # # ]: 0 : err = jbd2_journal_create_slab(be32_to_cpu(sb->s_blocksize));
1631 [ # # ]: 0 : if (err)
1632 : : return err;
1633 : :
1634 : : /* Let the recovery code check whether it needs to recover any
1635 : : * data from the journal. */
1636 [ # # ]: 0 : if (jbd2_journal_recover(journal))
1637 : : goto recovery_error;
1638 : :
1639 [ # # ]: 0 : if (journal->j_failed_commit) {
1640 : 0 : printk(KERN_ERR "JBD2: journal transaction %u on %s "
1641 : : "is corrupt.\n", journal->j_failed_commit,
1642 : 0 : journal->j_devname);
1643 : 0 : return -EIO;
1644 : : }
1645 : :
1646 : : /* OK, we've finished with the dynamic journal bits:
1647 : : * reinitialise the dynamic contents of the superblock in memory
1648 : : * and reset them on disk. */
1649 [ # # ]: 0 : if (journal_reset(journal))
1650 : : goto recovery_error;
1651 : :
1652 : 0 : journal->j_flags &= ~JBD2_ABORT;
1653 : 0 : journal->j_flags |= JBD2_LOADED;
1654 : 0 : return 0;
1655 : :
1656 : : recovery_error:
1657 : 0 : printk(KERN_WARNING "JBD2: recovery failed\n");
1658 : 0 : return -EIO;
1659 : : }
1660 : :
1661 : : /**
1662 : : * void jbd2_journal_destroy() - Release a journal_t structure.
1663 : : * @journal: Journal to act on.
1664 : : *
1665 : : * Release a journal_t structure once it is no longer in use by the
1666 : : * journaled object.
1667 : : * Return <0 if we couldn't clean up the journal.
1668 : : */
1669 : 0 : int jbd2_journal_destroy(journal_t *journal)
1670 : : {
1671 : : int err = 0;
1672 : :
1673 : : /* Wait for the commit thread to wake up and die. */
1674 : 0 : journal_kill_thread(journal);
1675 : :
1676 : : /* Force a final log commit */
1677 [ # # ]: 0 : if (journal->j_running_transaction)
1678 : 0 : jbd2_journal_commit_transaction(journal);
1679 : :
1680 : : /* Force any old transactions to disk */
1681 : :
1682 : : /* Totally anal locking here... */
1683 : : spin_lock(&journal->j_list_lock);
1684 [ # # ]: 0 : while (journal->j_checkpoint_transactions != NULL) {
1685 : : spin_unlock(&journal->j_list_lock);
1686 : 0 : mutex_lock(&journal->j_checkpoint_mutex);
1687 : 0 : jbd2_log_do_checkpoint(journal);
1688 : 0 : mutex_unlock(&journal->j_checkpoint_mutex);
1689 : : spin_lock(&journal->j_list_lock);
1690 : : }
1691 : :
1692 [ # # ]: 0 : J_ASSERT(journal->j_running_transaction == NULL);
1693 [ # # ]: 0 : J_ASSERT(journal->j_committing_transaction == NULL);
1694 [ # # ]: 0 : J_ASSERT(journal->j_checkpoint_transactions == NULL);
1695 : : spin_unlock(&journal->j_list_lock);
1696 : :
1697 [ # # ]: 0 : if (journal->j_sb_buffer) {
1698 [ # # ]: 0 : if (!is_journal_aborted(journal)) {
1699 : 0 : mutex_lock(&journal->j_checkpoint_mutex);
1700 : 0 : jbd2_mark_journal_empty(journal);
1701 : 0 : mutex_unlock(&journal->j_checkpoint_mutex);
1702 : : } else
1703 : : err = -EIO;
1704 : 0 : brelse(journal->j_sb_buffer);
1705 : : }
1706 : :
1707 [ # # ]: 0 : if (journal->j_proc_entry)
1708 : 0 : jbd2_stats_proc_exit(journal);
1709 [ # # ]: 0 : if (journal->j_inode)
1710 : 0 : iput(journal->j_inode);
1711 [ # # ]: 0 : if (journal->j_revoke)
1712 : 0 : jbd2_journal_destroy_revoke(journal);
1713 [ # # ]: 0 : if (journal->j_chksum_driver)
1714 : : crypto_free_shash(journal->j_chksum_driver);
1715 : 0 : kfree(journal->j_wbuf);
1716 : 0 : kfree(journal);
1717 : :
1718 : 0 : return err;
1719 : : }
1720 : :
1721 : :
1722 : : /**
1723 : : *int jbd2_journal_check_used_features () - Check if features specified are used.
1724 : : * @journal: Journal to check.
1725 : : * @compat: bitmask of compatible features
1726 : : * @ro: bitmask of features that force read-only mount
1727 : : * @incompat: bitmask of incompatible features
1728 : : *
1729 : : * Check whether the journal uses all of a given set of
1730 : : * features. Return true (non-zero) if it does.
1731 : : **/
1732 : :
1733 : 0 : int jbd2_journal_check_used_features (journal_t *journal, unsigned long compat,
1734 : : unsigned long ro, unsigned long incompat)
1735 : : {
1736 : : journal_superblock_t *sb;
1737 : :
1738 [ + - ]: 42770 : if (!compat && !ro && !incompat)
1739 : : return 1;
1740 : : /* Load journal superblock if it is not loaded yet. */
1741 [ - + # # ]: 42770 : if (journal->j_format_version == 0 &&
1742 : 0 : journal_get_superblock(journal) != 0)
1743 : : return 0;
1744 [ + - ]: 85540 : if (journal->j_format_version == 1)
1745 : : return 0;
1746 : :
1747 : 42770 : sb = journal->j_superblock;
1748 : :
1749 [ - + ][ + - ]: 128310 : if (((be32_to_cpu(sb->s_feature_compat) & compat) == compat) &&
[ + - ]
1750 [ - + ][ - + ]: 85540 : ((be32_to_cpu(sb->s_feature_ro_compat) & ro) == ro) &&
1751 [ - + ]: 42770 : ((be32_to_cpu(sb->s_feature_incompat) & incompat) == incompat))
1752 : : return 1;
1753 : :
1754 : 0 : return 0;
1755 : : }
1756 : :
1757 : : /**
1758 : : * int jbd2_journal_check_available_features() - Check feature set in journalling layer
1759 : : * @journal: Journal to check.
1760 : : * @compat: bitmask of compatible features
1761 : : * @ro: bitmask of features that force read-only mount
1762 : : * @incompat: bitmask of incompatible features
1763 : : *
1764 : : * Check whether the journaling code supports the use of
1765 : : * all of a given set of features on this journal. Return true
1766 : : * (non-zero) if it can. */
1767 : :
1768 : 0 : int jbd2_journal_check_available_features (journal_t *journal, unsigned long compat,
1769 : : unsigned long ro, unsigned long incompat)
1770 : : {
1771 [ # # ][ # # ]: 0 : if (!compat && !ro && !incompat)
1772 : : return 1;
1773 : :
1774 : : /* We can support any known requested features iff the
1775 : : * superblock is in version 2. Otherwise we fail to support any
1776 : : * extended sb features. */
1777 : :
1778 [ # # ][ # # ]: 0 : if (journal->j_format_version != 2)
1779 : : return 0;
1780 : :
1781 [ # # ][ # # ]: 0 : if ((compat & JBD2_KNOWN_COMPAT_FEATURES) == compat &&
[ # # ][ # # ]
1782 [ # # ][ # # ]: 0 : (ro & JBD2_KNOWN_ROCOMPAT_FEATURES) == ro &&
1783 : 0 : (incompat & JBD2_KNOWN_INCOMPAT_FEATURES) == incompat)
1784 : : return 1;
1785 : :
1786 : 0 : return 0;
1787 : : }
1788 : :
1789 : : /**
1790 : : * int jbd2_journal_set_features () - Mark a given journal feature in the superblock
1791 : : * @journal: Journal to act on.
1792 : : * @compat: bitmask of compatible features
1793 : : * @ro: bitmask of features that force read-only mount
1794 : : * @incompat: bitmask of incompatible features
1795 : : *
1796 : : * Mark a given journal feature as present on the
1797 : : * superblock. Returns true if the requested features could be set.
1798 : : *
1799 : : */
1800 : :
1801 : 0 : int jbd2_journal_set_features (journal_t *journal, unsigned long compat,
1802 : : unsigned long ro, unsigned long incompat)
1803 : : {
1804 : : #define INCOMPAT_FEATURE_ON(f) \
1805 : : ((incompat & (f)) && !(sb->s_feature_incompat & cpu_to_be32(f)))
1806 : : #define COMPAT_FEATURE_ON(f) \
1807 : : ((compat & (f)) && !(sb->s_feature_compat & cpu_to_be32(f)))
1808 : : journal_superblock_t *sb;
1809 : :
1810 [ - + ]: 42770 : if (jbd2_journal_check_used_features(journal, compat, ro, incompat))
1811 : : return 1;
1812 : :
1813 [ # # ]: 0 : if (!jbd2_journal_check_available_features(journal, compat, ro, incompat))
1814 : : return 0;
1815 : :
1816 : : /* Asking for checksumming v2 and v1? Only give them v2. */
1817 [ - + ][ # # ]: 42770 : if (incompat & JBD2_FEATURE_INCOMPAT_CSUM_V2 &&
1818 : 0 : compat & JBD2_FEATURE_COMPAT_CHECKSUM)
1819 : 0 : compat &= ~JBD2_FEATURE_COMPAT_CHECKSUM;
1820 : :
1821 : : jbd_debug(1, "Setting new features 0x%lx/0x%lx/0x%lx\n",
1822 : : compat, ro, incompat);
1823 : :
1824 : 42770 : sb = journal->j_superblock;
1825 : :
1826 : : /* If enabling v2 checksums, update superblock */
1827 [ - + ][ # # ]: 42770 : if (INCOMPAT_FEATURE_ON(JBD2_FEATURE_INCOMPAT_CSUM_V2)) {
1828 : 0 : sb->s_checksum_type = JBD2_CRC32C_CHKSUM;
1829 : 0 : sb->s_feature_compat &=
1830 : : ~cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM);
1831 : :
1832 : : /* Load the checksum driver */
1833 [ # # ]: 0 : if (journal->j_chksum_driver == NULL) {
1834 : 0 : journal->j_chksum_driver = crypto_alloc_shash("crc32c",
1835 : : 0, 0);
1836 [ # # ]: 0 : if (IS_ERR(journal->j_chksum_driver)) {
1837 : 0 : printk(KERN_ERR "JBD2: Cannot load crc32c "
1838 : : "driver.\n");
1839 : 0 : journal->j_chksum_driver = NULL;
1840 : 0 : return 0;
1841 : : }
1842 : : }
1843 : :
1844 : : /* Precompute checksum seed for all metadata */
1845 [ # # ][ # # ]: 0 : if (JBD2_HAS_INCOMPAT_FEATURE(journal,
1846 : : JBD2_FEATURE_INCOMPAT_CSUM_V2))
1847 : 0 : journal->j_csum_seed = jbd2_chksum(journal, ~0,
1848 : 0 : sb->s_uuid,
1849 : : sizeof(sb->s_uuid));
1850 : : }
1851 : :
1852 : : /* If enabling v1 checksums, downgrade superblock */
1853 [ - + ][ # # ]: 42770 : if (COMPAT_FEATURE_ON(JBD2_FEATURE_COMPAT_CHECKSUM))
1854 : 0 : sb->s_feature_incompat &=
1855 : : ~cpu_to_be32(JBD2_FEATURE_INCOMPAT_CSUM_V2);
1856 : :
1857 [ # # ]: 42770 : sb->s_feature_compat |= cpu_to_be32(compat);
1858 [ # # ]: 0 : sb->s_feature_ro_compat |= cpu_to_be32(ro);
1859 [ # # ]: 0 : sb->s_feature_incompat |= cpu_to_be32(incompat);
1860 : :
1861 : 0 : return 1;
1862 : : #undef COMPAT_FEATURE_ON
1863 : : #undef INCOMPAT_FEATURE_ON
1864 : : }
1865 : :
1866 : : /*
1867 : : * jbd2_journal_clear_features () - Clear a given journal feature in the
1868 : : * superblock
1869 : : * @journal: Journal to act on.
1870 : : * @compat: bitmask of compatible features
1871 : : * @ro: bitmask of features that force read-only mount
1872 : : * @incompat: bitmask of incompatible features
1873 : : *
1874 : : * Clear a given journal feature as present on the
1875 : : * superblock.
1876 : : */
1877 : 0 : void jbd2_journal_clear_features(journal_t *journal, unsigned long compat,
1878 : : unsigned long ro, unsigned long incompat)
1879 : : {
1880 : : journal_superblock_t *sb;
1881 : :
1882 : : jbd_debug(1, "Clear features 0x%lx/0x%lx/0x%lx\n",
1883 : : compat, ro, incompat);
1884 : :
1885 : 0 : sb = journal->j_superblock;
1886 : :
1887 [ # # ]: 0 : sb->s_feature_compat &= ~cpu_to_be32(compat);
1888 [ # # ]: 0 : sb->s_feature_ro_compat &= ~cpu_to_be32(ro);
1889 [ # # ]: 0 : sb->s_feature_incompat &= ~cpu_to_be32(incompat);
1890 : 0 : }
1891 : : EXPORT_SYMBOL(jbd2_journal_clear_features);
1892 : :
1893 : : /**
1894 : : * int jbd2_journal_flush () - Flush journal
1895 : : * @journal: Journal to act on.
1896 : : *
1897 : : * Flush all data for a given journal to disk and empty the journal.
1898 : : * Filesystems can use this when remounting readonly to ensure that
1899 : : * recovery does not need to happen on remount.
1900 : : */
1901 : :
1902 : 0 : int jbd2_journal_flush(journal_t *journal)
1903 : : {
1904 : : int err = 0;
1905 : : transaction_t *transaction = NULL;
1906 : :
1907 : 0 : write_lock(&journal->j_state_lock);
1908 : :
1909 : : /* Force everything buffered to the log... */
1910 [ # # ]: 0 : if (journal->j_running_transaction) {
1911 : : transaction = journal->j_running_transaction;
1912 : 0 : __jbd2_log_start_commit(journal, transaction->t_tid);
1913 [ # # ]: 0 : } else if (journal->j_committing_transaction)
1914 : : transaction = journal->j_committing_transaction;
1915 : :
1916 : : /* Wait for the log commit to complete... */
1917 [ # # ]: 0 : if (transaction) {
1918 : 0 : tid_t tid = transaction->t_tid;
1919 : :
1920 : : write_unlock(&journal->j_state_lock);
1921 : 0 : jbd2_log_wait_commit(journal, tid);
1922 : : } else {
1923 : : write_unlock(&journal->j_state_lock);
1924 : : }
1925 : :
1926 : : /* ...and flush everything in the log out to disk. */
1927 : : spin_lock(&journal->j_list_lock);
1928 [ # # ][ # # ]: 0 : while (!err && journal->j_checkpoint_transactions != NULL) {
1929 : : spin_unlock(&journal->j_list_lock);
1930 : 0 : mutex_lock(&journal->j_checkpoint_mutex);
1931 : 0 : err = jbd2_log_do_checkpoint(journal);
1932 : 0 : mutex_unlock(&journal->j_checkpoint_mutex);
1933 : : spin_lock(&journal->j_list_lock);
1934 : : }
1935 : : spin_unlock(&journal->j_list_lock);
1936 : :
1937 [ # # ]: 0 : if (is_journal_aborted(journal))
1938 : : return -EIO;
1939 : :
1940 : 0 : mutex_lock(&journal->j_checkpoint_mutex);
1941 : 0 : jbd2_cleanup_journal_tail(journal);
1942 : :
1943 : : /* Finally, mark the journal as really needing no recovery.
1944 : : * This sets s_start==0 in the underlying superblock, which is
1945 : : * the magic code for a fully-recovered superblock. Any future
1946 : : * commits of data to the journal will restore the current
1947 : : * s_start value. */
1948 : 0 : jbd2_mark_journal_empty(journal);
1949 : 0 : mutex_unlock(&journal->j_checkpoint_mutex);
1950 : 0 : write_lock(&journal->j_state_lock);
1951 [ # # ]: 0 : J_ASSERT(!journal->j_running_transaction);
1952 [ # # ]: 0 : J_ASSERT(!journal->j_committing_transaction);
1953 [ # # ]: 0 : J_ASSERT(!journal->j_checkpoint_transactions);
1954 [ # # ]: 0 : J_ASSERT(journal->j_head == journal->j_tail);
1955 [ # # ]: 0 : J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence);
1956 : : write_unlock(&journal->j_state_lock);
1957 : 0 : return 0;
1958 : : }
1959 : :
1960 : : /**
1961 : : * int jbd2_journal_wipe() - Wipe journal contents
1962 : : * @journal: Journal to act on.
1963 : : * @write: flag (see below)
1964 : : *
1965 : : * Wipe out all of the contents of a journal, safely. This will produce
1966 : : * a warning if the journal contains any valid recovery information.
1967 : : * Must be called between journal_init_*() and jbd2_journal_load().
1968 : : *
1969 : : * If 'write' is non-zero, then we wipe out the journal on disk; otherwise
1970 : : * we merely suppress recovery.
1971 : : */
1972 : :
1973 : 0 : int jbd2_journal_wipe(journal_t *journal, int write)
1974 : : {
1975 : : int err = 0;
1976 : :
1977 [ # # ]: 0 : J_ASSERT (!(journal->j_flags & JBD2_LOADED));
1978 : :
1979 : 0 : err = load_superblock(journal);
1980 [ # # ]: 0 : if (err)
1981 : : return err;
1982 : :
1983 [ # # ]: 0 : if (!journal->j_tail)
1984 : : goto no_recovery;
1985 : :
1986 [ # # ]: 0 : printk(KERN_WARNING "JBD2: %s recovery information on journal\n",
1987 : : write ? "Clearing" : "Ignoring");
1988 : :
1989 : 0 : err = jbd2_journal_skip_recovery(journal);
1990 [ # # ]: 0 : if (write) {
1991 : : /* Lock to make assertions happy... */
1992 : 0 : mutex_lock(&journal->j_checkpoint_mutex);
1993 : 0 : jbd2_mark_journal_empty(journal);
1994 : 0 : mutex_unlock(&journal->j_checkpoint_mutex);
1995 : : }
1996 : :
1997 : : no_recovery:
1998 : 0 : return err;
1999 : : }
2000 : :
2001 : : /*
2002 : : * Journal abort has very specific semantics, which we describe
2003 : : * for journal abort.
2004 : : *
2005 : : * Two internal functions, which provide abort to the jbd layer
2006 : : * itself are here.
2007 : : */
2008 : :
2009 : : /*
2010 : : * Quick version for internal journal use (doesn't lock the journal).
2011 : : * Aborts hard --- we mark the abort as occurred, but do _nothing_ else,
2012 : : * and don't attempt to make any other journal updates.
2013 : : */
2014 : 0 : void __jbd2_journal_abort_hard(journal_t *journal)
2015 : : {
2016 : : transaction_t *transaction;
2017 : :
2018 [ # # ]: 0 : if (journal->j_flags & JBD2_ABORT)
2019 : 0 : return;
2020 : :
2021 : 0 : printk(KERN_ERR "Aborting journal on device %s.\n",
2022 : 0 : journal->j_devname);
2023 : :
2024 : 0 : write_lock(&journal->j_state_lock);
2025 : 0 : journal->j_flags |= JBD2_ABORT;
2026 : 0 : transaction = journal->j_running_transaction;
2027 [ # # ]: 0 : if (transaction)
2028 : 0 : __jbd2_log_start_commit(journal, transaction->t_tid);
2029 : : write_unlock(&journal->j_state_lock);
2030 : : }
2031 : :
2032 : : /* Soft abort: record the abort error status in the journal superblock,
2033 : : * but don't do any other IO. */
2034 : 0 : static void __journal_abort_soft (journal_t *journal, int errno)
2035 : : {
2036 [ # # ]: 0 : if (journal->j_flags & JBD2_ABORT)
2037 : 0 : return;
2038 : :
2039 [ # # ]: 0 : if (!journal->j_errno)
2040 : 0 : journal->j_errno = errno;
2041 : :
2042 : 0 : __jbd2_journal_abort_hard(journal);
2043 : :
2044 [ # # ]: 0 : if (errno)
2045 : 0 : jbd2_journal_update_sb_errno(journal);
2046 : : }
2047 : :
2048 : : /**
2049 : : * void jbd2_journal_abort () - Shutdown the journal immediately.
2050 : : * @journal: the journal to shutdown.
2051 : : * @errno: an error number to record in the journal indicating
2052 : : * the reason for the shutdown.
2053 : : *
2054 : : * Perform a complete, immediate shutdown of the ENTIRE
2055 : : * journal (not of a single transaction). This operation cannot be
2056 : : * undone without closing and reopening the journal.
2057 : : *
2058 : : * The jbd2_journal_abort function is intended to support higher level error
2059 : : * recovery mechanisms such as the ext2/ext3 remount-readonly error
2060 : : * mode.
2061 : : *
2062 : : * Journal abort has very specific semantics. Any existing dirty,
2063 : : * unjournaled buffers in the main filesystem will still be written to
2064 : : * disk by bdflush, but the journaling mechanism will be suspended
2065 : : * immediately and no further transaction commits will be honoured.
2066 : : *
2067 : : * Any dirty, journaled buffers will be written back to disk without
2068 : : * hitting the journal. Atomicity cannot be guaranteed on an aborted
2069 : : * filesystem, but we _do_ attempt to leave as much data as possible
2070 : : * behind for fsck to use for cleanup.
2071 : : *
2072 : : * Any attempt to get a new transaction handle on a journal which is in
2073 : : * ABORT state will just result in an -EROFS error return. A
2074 : : * jbd2_journal_stop on an existing handle will return -EIO if we have
2075 : : * entered abort state during the update.
2076 : : *
2077 : : * Recursive transactions are not disturbed by journal abort until the
2078 : : * final jbd2_journal_stop, which will receive the -EIO error.
2079 : : *
2080 : : * Finally, the jbd2_journal_abort call allows the caller to supply an errno
2081 : : * which will be recorded (if possible) in the journal superblock. This
2082 : : * allows a client to record failure conditions in the middle of a
2083 : : * transaction without having to complete the transaction to record the
2084 : : * failure to disk. ext3_error, for example, now uses this
2085 : : * functionality.
2086 : : *
2087 : : * Errors which originate from within the journaling layer will NOT
2088 : : * supply an errno; a null errno implies that absolutely no further
2089 : : * writes are done to the journal (unless there are any already in
2090 : : * progress).
2091 : : *
2092 : : */
2093 : :
2094 : 0 : void jbd2_journal_abort(journal_t *journal, int errno)
2095 : : {
2096 : 0 : __journal_abort_soft(journal, errno);
2097 : 0 : }
2098 : :
2099 : : /**
2100 : : * int jbd2_journal_errno () - returns the journal's error state.
2101 : : * @journal: journal to examine.
2102 : : *
2103 : : * This is the errno number set with jbd2_journal_abort(), the last
2104 : : * time the journal was mounted - if the journal was stopped
2105 : : * without calling abort this will be 0.
2106 : : *
2107 : : * If the journal has been aborted on this mount time -EROFS will
2108 : : * be returned.
2109 : : */
2110 : 0 : int jbd2_journal_errno(journal_t *journal)
2111 : : {
2112 : : int err;
2113 : :
2114 : 0 : read_lock(&journal->j_state_lock);
2115 [ # # ]: 0 : if (journal->j_flags & JBD2_ABORT)
2116 : : err = -EROFS;
2117 : : else
2118 : 0 : err = journal->j_errno;
2119 : : read_unlock(&journal->j_state_lock);
2120 : 0 : return err;
2121 : : }
2122 : :
2123 : : /**
2124 : : * int jbd2_journal_clear_err () - clears the journal's error state
2125 : : * @journal: journal to act on.
2126 : : *
2127 : : * An error must be cleared or acked to take a FS out of readonly
2128 : : * mode.
2129 : : */
2130 : 0 : int jbd2_journal_clear_err(journal_t *journal)
2131 : : {
2132 : : int err = 0;
2133 : :
2134 : 0 : write_lock(&journal->j_state_lock);
2135 [ # # ]: 0 : if (journal->j_flags & JBD2_ABORT)
2136 : : err = -EROFS;
2137 : : else
2138 : 0 : journal->j_errno = 0;
2139 : : write_unlock(&journal->j_state_lock);
2140 : 0 : return err;
2141 : : }
2142 : :
2143 : : /**
2144 : : * void jbd2_journal_ack_err() - Ack journal err.
2145 : : * @journal: journal to act on.
2146 : : *
2147 : : * An error must be cleared or acked to take a FS out of readonly
2148 : : * mode.
2149 : : */
2150 : 0 : void jbd2_journal_ack_err(journal_t *journal)
2151 : : {
2152 : 0 : write_lock(&journal->j_state_lock);
2153 [ # # ]: 0 : if (journal->j_errno)
2154 : 0 : journal->j_flags |= JBD2_ACK_ERR;
2155 : : write_unlock(&journal->j_state_lock);
2156 : 0 : }
2157 : :
2158 : 0 : int jbd2_journal_blocks_per_page(struct inode *inode)
2159 : : {
2160 : 259989 : return 1 << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
2161 : : }
2162 : :
2163 : : /*
2164 : : * helper functions to deal with 32 or 64bit block numbers.
2165 : : */
2166 : 0 : size_t journal_tag_bytes(journal_t *journal)
2167 : : {
2168 : : journal_block_tag_t tag;
2169 : : size_t x = 0;
2170 : :
2171 [ + - ][ - + ]: 20656 : if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2))
2172 : : x += sizeof(tag.t_checksum);
2173 : :
2174 [ + - ][ - + ]: 20656 : if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT))
2175 : 0 : return x + JBD2_TAG_SIZE64;
2176 : : else
2177 : 20656 : return x + JBD2_TAG_SIZE32;
2178 : : }
2179 : :
2180 : : /*
2181 : : * JBD memory management
2182 : : *
2183 : : * These functions are used to allocate block-sized chunks of memory
2184 : : * used for making copies of buffer_head data. Very often it will be
2185 : : * page-sized chunks of data, but sometimes it will be in
2186 : : * sub-page-size chunks. (For example, 16k pages on Power systems
2187 : : * with a 4k block file system.) For blocks smaller than a page, we
2188 : : * use a SLAB allocator. There are slab caches for each block size,
2189 : : * which are allocated at mount time, if necessary, and we only free
2190 : : * (all of) the slab caches when/if the jbd2 module is unloaded. For
2191 : : * this reason we don't need to a mutex to protect access to
2192 : : * jbd2_slab[] allocating or releasing memory; only in
2193 : : * jbd2_journal_create_slab().
2194 : : */
2195 : : #define JBD2_MAX_SLABS 8
2196 : : static struct kmem_cache *jbd2_slab[JBD2_MAX_SLABS];
2197 : :
2198 : : static const char *jbd2_slab_names[JBD2_MAX_SLABS] = {
2199 : : "jbd2_1k", "jbd2_2k", "jbd2_4k", "jbd2_8k",
2200 : : "jbd2_16k", "jbd2_32k", "jbd2_64k", "jbd2_128k"
2201 : : };
2202 : :
2203 : :
2204 : 0 : static void jbd2_journal_destroy_slabs(void)
2205 : : {
2206 : : int i;
2207 : :
2208 [ # # ]: 0 : for (i = 0; i < JBD2_MAX_SLABS; i++) {
2209 [ # # ]: 0 : if (jbd2_slab[i])
2210 : 0 : kmem_cache_destroy(jbd2_slab[i]);
2211 : 0 : jbd2_slab[i] = NULL;
2212 : : }
2213 : 0 : }
2214 : :
2215 : 0 : static int jbd2_journal_create_slab(size_t size)
2216 : : {
2217 : : static DEFINE_MUTEX(jbd2_slab_create_mutex);
2218 [ # # ][ # # ]: 0 : int i = order_base_2(size) - 10;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
2219 : : size_t slab_size;
2220 : :
2221 [ # # ]: 0 : if (size == PAGE_SIZE)
2222 : : return 0;
2223 : :
2224 [ # # ]: 0 : if (i >= JBD2_MAX_SLABS)
2225 : : return -EINVAL;
2226 : :
2227 [ # # ]: 0 : if (unlikely(i < 0))
2228 : : i = 0;
2229 : 0 : mutex_lock(&jbd2_slab_create_mutex);
2230 [ # # ]: 0 : if (jbd2_slab[i]) {
2231 : 0 : mutex_unlock(&jbd2_slab_create_mutex);
2232 : 0 : return 0; /* Already created */
2233 : : }
2234 : :
2235 : 0 : slab_size = 1 << (i+10);
2236 : 0 : jbd2_slab[i] = kmem_cache_create(jbd2_slab_names[i], slab_size,
2237 : : slab_size, 0, NULL);
2238 : 0 : mutex_unlock(&jbd2_slab_create_mutex);
2239 [ # # ]: 0 : if (!jbd2_slab[i]) {
2240 : 0 : printk(KERN_EMERG "JBD2: no memory for jbd2_slab cache\n");
2241 : 0 : return -ENOMEM;
2242 : : }
2243 : : return 0;
2244 : : }
2245 : :
2246 : 0 : static struct kmem_cache *get_slab(size_t size)
2247 : : {
2248 [ # # ][ # # ]: 0 : int i = order_base_2(size) - 10;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
2249 : :
2250 [ # # ]: 0 : BUG_ON(i >= JBD2_MAX_SLABS);
2251 [ # # ]: 0 : if (unlikely(i < 0))
2252 : : i = 0;
2253 [ # # ]: 0 : BUG_ON(jbd2_slab[i] == NULL);
2254 : 0 : return jbd2_slab[i];
2255 : : }
2256 : :
2257 : 0 : void *jbd2_alloc(size_t size, gfp_t flags)
2258 : : {
2259 : : void *ptr;
2260 : :
2261 [ - + ]: 678 : BUG_ON(size & (size-1)); /* Must be a power of 2 */
2262 : :
2263 : 678 : flags |= __GFP_REPEAT;
2264 [ + - ]: 678 : if (size == PAGE_SIZE)
2265 : 678 : ptr = (void *)__get_free_pages(flags, 0);
2266 [ # # ]: 0 : else if (size > PAGE_SIZE) {
2267 [ # # ][ # # ]: 0 : int order = get_order(size);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2268 : :
2269 [ # # ]: 0 : if (order < 3)
2270 : 0 : ptr = (void *)__get_free_pages(flags, order);
2271 : : else
2272 : 0 : ptr = vmalloc(size);
2273 : : } else
2274 : 0 : ptr = kmem_cache_alloc(get_slab(size), flags);
2275 : :
2276 : : /* Check alignment; SLUB has gotten this wrong in the past,
2277 : : * and this can lead to user data corruption! */
2278 [ - + ]: 678 : BUG_ON(((unsigned long) ptr) & (size-1));
2279 : :
2280 : 678 : return ptr;
2281 : : }
2282 : :
2283 : 0 : void jbd2_free(void *ptr, size_t size)
2284 : : {
2285 [ + - ]: 678 : if (size == PAGE_SIZE) {
2286 : 678 : free_pages((unsigned long)ptr, 0);
2287 : 678 : return;
2288 : : }
2289 [ # # ]: 0 : if (size > PAGE_SIZE) {
2290 [ # # ][ # # ]: 0 : int order = get_order(size);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2291 : :
2292 [ # # ]: 0 : if (order < 3)
2293 : 0 : free_pages((unsigned long)ptr, order);
2294 : : else
2295 : 0 : vfree(ptr);
2296 : : return;
2297 : : }
2298 : 0 : kmem_cache_free(get_slab(size), ptr);
2299 : : };
2300 : :
2301 : : /*
2302 : : * Journal_head storage management
2303 : : */
2304 : : static struct kmem_cache *jbd2_journal_head_cache;
2305 : : #ifdef CONFIG_JBD2_DEBUG
2306 : : static atomic_t nr_journal_heads = ATOMIC_INIT(0);
2307 : : #endif
2308 : :
2309 : 0 : static int jbd2_journal_init_journal_head_cache(void)
2310 : : {
2311 : : int retval;
2312 : :
2313 [ # # ]: 0 : J_ASSERT(jbd2_journal_head_cache == NULL);
2314 : 0 : jbd2_journal_head_cache = kmem_cache_create("jbd2_journal_head",
2315 : : sizeof(struct journal_head),
2316 : : 0, /* offset */
2317 : : SLAB_TEMPORARY, /* flags */
2318 : : NULL); /* ctor */
2319 : : retval = 0;
2320 [ # # ]: 0 : if (!jbd2_journal_head_cache) {
2321 : : retval = -ENOMEM;
2322 : 0 : printk(KERN_EMERG "JBD2: no memory for journal_head cache\n");
2323 : : }
2324 : 0 : return retval;
2325 : : }
2326 : :
2327 : : static void jbd2_journal_destroy_journal_head_cache(void)
2328 : : {
2329 [ # # ]: 0 : if (jbd2_journal_head_cache) {
2330 : 0 : kmem_cache_destroy(jbd2_journal_head_cache);
2331 : 0 : jbd2_journal_head_cache = NULL;
2332 : : }
2333 : : }
2334 : :
2335 : : /*
2336 : : * journal_head splicing and dicing
2337 : : */
2338 : 0 : static struct journal_head *journal_alloc_journal_head(void)
2339 : : {
2340 : : struct journal_head *ret;
2341 : :
2342 : : #ifdef CONFIG_JBD2_DEBUG
2343 : : atomic_inc(&nr_journal_heads);
2344 : : #endif
2345 : 60461 : ret = kmem_cache_zalloc(jbd2_journal_head_cache, GFP_NOFS);
2346 [ - + ]: 60464 : if (!ret) {
2347 : : jbd_debug(1, "out of memory for journal_head\n");
2348 [ # # ]: 0 : pr_notice_ratelimited("ENOMEM in %s, retrying.\n", __func__);
2349 [ # # ]: 0 : while (!ret) {
2350 : 0 : yield();
2351 : 0 : ret = kmem_cache_zalloc(jbd2_journal_head_cache, GFP_NOFS);
2352 : : }
2353 : : }
2354 : 3 : return ret;
2355 : : }
2356 : :
2357 : : static void journal_free_journal_head(struct journal_head *jh)
2358 : : {
2359 : : #ifdef CONFIG_JBD2_DEBUG
2360 : : atomic_dec(&nr_journal_heads);
2361 : : memset(jh, JBD2_POISON_FREE, sizeof(*jh));
2362 : : #endif
2363 : 59914 : kmem_cache_free(jbd2_journal_head_cache, jh);
2364 : : }
2365 : :
2366 : : /*
2367 : : * A journal_head is attached to a buffer_head whenever JBD has an
2368 : : * interest in the buffer.
2369 : : *
2370 : : * Whenever a buffer has an attached journal_head, its ->b_state:BH_JBD bit
2371 : : * is set. This bit is tested in core kernel code where we need to take
2372 : : * JBD-specific actions. Testing the zeroness of ->b_private is not reliable
2373 : : * there.
2374 : : *
2375 : : * When a buffer has its BH_JBD bit set, its ->b_count is elevated by one.
2376 : : *
2377 : : * When a buffer has its BH_JBD bit set it is immune from being released by
2378 : : * core kernel code, mainly via ->b_count.
2379 : : *
2380 : : * A journal_head is detached from its buffer_head when the journal_head's
2381 : : * b_jcount reaches zero. Running transaction (b_transaction) and checkpoint
2382 : : * transaction (b_cp_transaction) hold their references to b_jcount.
2383 : : *
2384 : : * Various places in the kernel want to attach a journal_head to a buffer_head
2385 : : * _before_ attaching the journal_head to a transaction. To protect the
2386 : : * journal_head in this situation, jbd2_journal_add_journal_head elevates the
2387 : : * journal_head's b_jcount refcount by one. The caller must call
2388 : : * jbd2_journal_put_journal_head() to undo this.
2389 : : *
2390 : : * So the typical usage would be:
2391 : : *
2392 : : * (Attach a journal_head if needed. Increments b_jcount)
2393 : : * struct journal_head *jh = jbd2_journal_add_journal_head(bh);
2394 : : * ...
2395 : : * (Get another reference for transaction)
2396 : : * jbd2_journal_grab_journal_head(bh);
2397 : : * jh->b_transaction = xxx;
2398 : : * (Put original reference)
2399 : : * jbd2_journal_put_journal_head(jh);
2400 : : */
2401 : :
2402 : : /*
2403 : : * Give a buffer_head a journal_head.
2404 : : *
2405 : : * May sleep.
2406 : : */
2407 : 32070161 : struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh)
2408 : : {
2409 : : struct journal_head *jh;
2410 : : struct journal_head *new_jh = NULL;
2411 : :
2412 : : repeat:
2413 [ + + ]: 16065161 : if (!buffer_jbd(bh))
2414 : 60461 : new_jh = journal_alloc_journal_head();
2415 : :
2416 : : jbd_lock_bh_journal_head(bh);
2417 [ + + ]: 32130624 : if (buffer_jbd(bh)) {
2418 : : jh = bh2jh(bh);
2419 : : } else {
2420 [ + + ][ + - ]: 60463 : J_ASSERT_BH(bh,
[ + - ][ - + ]
2421 : : (atomic_read(&bh->b_count) > 0) ||
2422 : : (bh->b_page && bh->b_page->mapping));
2423 : :
2424 [ - + ]: 60463 : if (!new_jh) {
2425 : : jbd_unlock_bh_journal_head(bh);
2426 : : goto repeat;
2427 : : }
2428 : :
2429 : : jh = new_jh;
2430 : : new_jh = NULL; /* We consumed it */
2431 : : set_buffer_jbd(bh);
2432 : 60463 : bh->b_private = jh;
2433 : 60463 : jh->b_bh = bh;
2434 : : get_bh(bh);
2435 : : BUFFER_TRACE(bh, "added journal_head");
2436 : : }
2437 : 16065463 : jh->b_jcount++;
2438 : : jbd_unlock_bh_journal_head(bh);
2439 [ + + ]: 16066420 : if (new_jh)
2440 : : journal_free_journal_head(new_jh);
2441 : 16066420 : return bh->b_private;
2442 : : }
2443 : :
2444 : : /*
2445 : : * Grab a ref against this buffer_head's journal_head. If it ended up not
2446 : : * having a journal_head, return NULL
2447 : : */
2448 : 0 : struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh)
2449 : : {
2450 : : struct journal_head *jh = NULL;
2451 : :
2452 : : jbd_lock_bh_journal_head(bh);
2453 [ + + ]: 18119602 : if (buffer_jbd(bh)) {
2454 : : jh = bh2jh(bh);
2455 : 16197998 : jh->b_jcount++;
2456 : : }
2457 : : jbd_unlock_bh_journal_head(bh);
2458 : 18119701 : return jh;
2459 : : }
2460 : :
2461 : 0 : static void __journal_remove_journal_head(struct buffer_head *bh)
2462 : : {
2463 : 59913 : struct journal_head *jh = bh2jh(bh);
2464 : :
2465 [ - + ]: 59913 : J_ASSERT_JH(jh, jh->b_jcount >= 0);
2466 [ - + ]: 59913 : J_ASSERT_JH(jh, jh->b_transaction == NULL);
2467 [ - + ]: 59913 : J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
2468 [ - + ]: 59913 : J_ASSERT_JH(jh, jh->b_cp_transaction == NULL);
2469 [ - + ]: 59913 : J_ASSERT_JH(jh, jh->b_jlist == BJ_None);
2470 [ - + ]: 59913 : J_ASSERT_BH(bh, buffer_jbd(bh));
2471 [ - + ]: 59913 : J_ASSERT_BH(bh, jh2bh(jh) == bh);
2472 : : BUFFER_TRACE(bh, "remove journal_head");
2473 [ - + ]: 59913 : if (jh->b_frozen_data) {
2474 : 0 : printk(KERN_WARNING "%s: freeing b_frozen_data\n", __func__);
2475 : 0 : jbd2_free(jh->b_frozen_data, bh->b_size);
2476 : : }
2477 [ - + ]: 59913 : if (jh->b_committed_data) {
2478 : 0 : printk(KERN_WARNING "%s: freeing b_committed_data\n", __func__);
2479 : 0 : jbd2_free(jh->b_committed_data, bh->b_size);
2480 : : }
2481 : 59913 : bh->b_private = NULL;
2482 : 59913 : jh->b_bh = NULL; /* debug, really */
2483 : : clear_buffer_jbd(bh);
2484 : : journal_free_journal_head(jh);
2485 : 59913 : }
2486 : :
2487 : : /*
2488 : : * Drop a reference on the passed journal_head. If it fell to zero then
2489 : : * release the journal_head from the buffer_head.
2490 : : */
2491 : 0 : void jbd2_journal_put_journal_head(struct journal_head *jh)
2492 : : {
2493 : : struct buffer_head *bh = jh2bh(jh);
2494 : :
2495 : : jbd_lock_bh_journal_head(bh);
2496 [ - + ]: 32260038 : J_ASSERT_JH(jh, jh->b_jcount > 0);
2497 : 32260038 : --jh->b_jcount;
2498 [ + + ]: 32260038 : if (!jh->b_jcount) {
2499 : 59913 : __journal_remove_journal_head(bh);
2500 : : jbd_unlock_bh_journal_head(bh);
2501 : 59913 : __brelse(bh);
2502 : : } else
2503 : : jbd_unlock_bh_journal_head(bh);
2504 : 32264445 : }
2505 : :
2506 : : /*
2507 : : * Initialize jbd inode head
2508 : : */
2509 : 0 : void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode)
2510 : : {
2511 : 329236 : jinode->i_transaction = NULL;
2512 : 329236 : jinode->i_next_transaction = NULL;
2513 : 329236 : jinode->i_vfs_inode = inode;
2514 : 329236 : jinode->i_flags = 0;
2515 : 329236 : INIT_LIST_HEAD(&jinode->i_list);
2516 : 329236 : }
2517 : :
2518 : : /*
2519 : : * Function to be called before we start removing inode from memory (i.e.,
2520 : : * clear_inode() is a fine place to be called from). It removes inode from
2521 : : * transaction's lists.
2522 : : */
2523 : 0 : void jbd2_journal_release_jbd_inode(journal_t *journal,
2524 : : struct jbd2_inode *jinode)
2525 : : {
2526 [ + - ]: 335468 : if (!journal)
2527 : 335468 : return;
2528 : : restart:
2529 : : spin_lock(&journal->j_list_lock);
2530 : : /* Is commit writing out inode - we have to wait */
2531 [ - + ]: 335468 : if (test_bit(__JI_COMMIT_RUNNING, &jinode->i_flags)) {
2532 : : wait_queue_head_t *wq;
2533 : 0 : DEFINE_WAIT_BIT(wait, &jinode->i_flags, __JI_COMMIT_RUNNING);
2534 : 0 : wq = bit_waitqueue(&jinode->i_flags, __JI_COMMIT_RUNNING);
2535 : 0 : prepare_to_wait(wq, &wait.wait, TASK_UNINTERRUPTIBLE);
2536 : : spin_unlock(&journal->j_list_lock);
2537 : 0 : schedule();
2538 : 0 : finish_wait(wq, &wait.wait);
2539 : : goto restart;
2540 : : }
2541 : :
2542 [ + + ]: 335468 : if (jinode->i_transaction) {
2543 : : list_del(&jinode->i_list);
2544 : 42 : jinode->i_transaction = NULL;
2545 : : }
2546 : : spin_unlock(&journal->j_list_lock);
2547 : : }
2548 : :
2549 : :
2550 : : #ifdef CONFIG_PROC_FS
2551 : :
2552 : : #define JBD2_STATS_PROC_NAME "fs/jbd2"
2553 : :
2554 : 0 : static void __init jbd2_create_jbd_stats_proc_entry(void)
2555 : : {
2556 : 0 : proc_jbd2_stats = proc_mkdir(JBD2_STATS_PROC_NAME, NULL);
2557 : 0 : }
2558 : :
2559 : 0 : static void __exit jbd2_remove_jbd_stats_proc_entry(void)
2560 : : {
2561 [ # # ]: 0 : if (proc_jbd2_stats)
2562 : 0 : remove_proc_entry(JBD2_STATS_PROC_NAME, NULL);
2563 : 0 : }
2564 : :
2565 : : #else
2566 : :
2567 : : #define jbd2_create_jbd_stats_proc_entry() do {} while (0)
2568 : : #define jbd2_remove_jbd_stats_proc_entry() do {} while (0)
2569 : :
2570 : : #endif
2571 : :
2572 : : struct kmem_cache *jbd2_handle_cache, *jbd2_inode_cache;
2573 : :
2574 : 0 : static int __init jbd2_journal_init_handle_cache(void)
2575 : : {
2576 : 0 : jbd2_handle_cache = KMEM_CACHE(jbd2_journal_handle, SLAB_TEMPORARY);
2577 [ # # ]: 0 : if (jbd2_handle_cache == NULL) {
2578 : 0 : printk(KERN_EMERG "JBD2: failed to create handle cache\n");
2579 : 0 : return -ENOMEM;
2580 : : }
2581 : 0 : jbd2_inode_cache = KMEM_CACHE(jbd2_inode, 0);
2582 [ # # ]: 0 : if (jbd2_inode_cache == NULL) {
2583 : 0 : printk(KERN_EMERG "JBD2: failed to create inode cache\n");
2584 : 0 : kmem_cache_destroy(jbd2_handle_cache);
2585 : 0 : return -ENOMEM;
2586 : : }
2587 : : return 0;
2588 : : }
2589 : :
2590 : 0 : static void jbd2_journal_destroy_handle_cache(void)
2591 : : {
2592 [ # # ]: 0 : if (jbd2_handle_cache)
2593 : 0 : kmem_cache_destroy(jbd2_handle_cache);
2594 [ # # ]: 0 : if (jbd2_inode_cache)
2595 : 0 : kmem_cache_destroy(jbd2_inode_cache);
2596 : :
2597 : 0 : }
2598 : :
2599 : : /*
2600 : : * Module startup and shutdown
2601 : : */
2602 : :
2603 : 0 : static int __init journal_init_caches(void)
2604 : : {
2605 : : int ret;
2606 : :
2607 : 0 : ret = jbd2_journal_init_revoke_caches();
2608 [ # # ]: 0 : if (ret == 0)
2609 : 0 : ret = jbd2_journal_init_journal_head_cache();
2610 [ # # ]: 0 : if (ret == 0)
2611 : 0 : ret = jbd2_journal_init_handle_cache();
2612 [ # # ]: 0 : if (ret == 0)
2613 : 0 : ret = jbd2_journal_init_transaction_cache();
2614 : 0 : return ret;
2615 : : }
2616 : :
2617 : 0 : static void jbd2_journal_destroy_caches(void)
2618 : : {
2619 : 0 : jbd2_journal_destroy_revoke_caches();
2620 : : jbd2_journal_destroy_journal_head_cache();
2621 : 0 : jbd2_journal_destroy_handle_cache();
2622 : 0 : jbd2_journal_destroy_transaction_cache();
2623 : 0 : jbd2_journal_destroy_slabs();
2624 : 0 : }
2625 : :
2626 : 0 : static int __init journal_init(void)
2627 : : {
2628 : : int ret;
2629 : :
2630 : : BUILD_BUG_ON(sizeof(struct journal_superblock_s) != 1024);
2631 : :
2632 : 0 : ret = journal_init_caches();
2633 [ # # ]: 0 : if (ret == 0) {
2634 : 0 : jbd2_create_jbd_stats_proc_entry();
2635 : : } else {
2636 : 0 : jbd2_journal_destroy_caches();
2637 : : }
2638 : 0 : return ret;
2639 : : }
2640 : :
2641 : 0 : static void __exit journal_exit(void)
2642 : : {
2643 : : #ifdef CONFIG_JBD2_DEBUG
2644 : : int n = atomic_read(&nr_journal_heads);
2645 : : if (n)
2646 : : printk(KERN_ERR "JBD2: leaked %d journal_heads!\n", n);
2647 : : #endif
2648 : 0 : jbd2_remove_jbd_stats_proc_entry();
2649 : 0 : jbd2_journal_destroy_caches();
2650 : 0 : }
2651 : :
2652 : : MODULE_LICENSE("GPL");
2653 : : module_init(journal_init);
2654 : : module_exit(journal_exit);
2655 : :
|
