Branch data Line data Source code
1 : : /*
2 : : * linux/fs/jbd/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/jbd.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/debugfs.h>
39 : : #include <linux/ratelimit.h>
40 : :
41 : : #define CREATE_TRACE_POINTS
42 : : #include <trace/events/jbd.h>
43 : :
44 : : #include <asm/uaccess.h>
45 : : #include <asm/page.h>
46 : :
47 : : EXPORT_SYMBOL(journal_start);
48 : : EXPORT_SYMBOL(journal_restart);
49 : : EXPORT_SYMBOL(journal_extend);
50 : : EXPORT_SYMBOL(journal_stop);
51 : : EXPORT_SYMBOL(journal_lock_updates);
52 : : EXPORT_SYMBOL(journal_unlock_updates);
53 : : EXPORT_SYMBOL(journal_get_write_access);
54 : : EXPORT_SYMBOL(journal_get_create_access);
55 : : EXPORT_SYMBOL(journal_get_undo_access);
56 : : EXPORT_SYMBOL(journal_dirty_data);
57 : : EXPORT_SYMBOL(journal_dirty_metadata);
58 : : EXPORT_SYMBOL(journal_release_buffer);
59 : : EXPORT_SYMBOL(journal_forget);
60 : : #if 0
61 : : EXPORT_SYMBOL(journal_sync_buffer);
62 : : #endif
63 : : EXPORT_SYMBOL(journal_flush);
64 : : EXPORT_SYMBOL(journal_revoke);
65 : :
66 : : EXPORT_SYMBOL(journal_init_dev);
67 : : EXPORT_SYMBOL(journal_init_inode);
68 : : EXPORT_SYMBOL(journal_update_format);
69 : : EXPORT_SYMBOL(journal_check_used_features);
70 : : EXPORT_SYMBOL(journal_check_available_features);
71 : : EXPORT_SYMBOL(journal_set_features);
72 : : EXPORT_SYMBOL(journal_create);
73 : : EXPORT_SYMBOL(journal_load);
74 : : EXPORT_SYMBOL(journal_destroy);
75 : : EXPORT_SYMBOL(journal_abort);
76 : : EXPORT_SYMBOL(journal_errno);
77 : : EXPORT_SYMBOL(journal_ack_err);
78 : : EXPORT_SYMBOL(journal_clear_err);
79 : : EXPORT_SYMBOL(log_wait_commit);
80 : : EXPORT_SYMBOL(log_start_commit);
81 : : EXPORT_SYMBOL(journal_start_commit);
82 : : EXPORT_SYMBOL(journal_force_commit_nested);
83 : : EXPORT_SYMBOL(journal_wipe);
84 : : EXPORT_SYMBOL(journal_blocks_per_page);
85 : : EXPORT_SYMBOL(journal_invalidatepage);
86 : : EXPORT_SYMBOL(journal_try_to_free_buffers);
87 : : EXPORT_SYMBOL(journal_force_commit);
88 : :
89 : : static int journal_convert_superblock_v1(journal_t *, journal_superblock_t *);
90 : : static void __journal_abort_soft (journal_t *journal, int errno);
91 : : static const char *journal_dev_name(journal_t *journal, char *buffer);
92 : :
93 : : #ifdef CONFIG_JBD_DEBUG
94 : : void __jbd_debug(int level, const char *file, const char *func,
95 : : unsigned int line, const char *fmt, ...)
96 : : {
97 : : struct va_format vaf;
98 : : va_list args;
99 : :
100 : : if (level > journal_enable_debug)
101 : : return;
102 : : va_start(args, fmt);
103 : : vaf.fmt = fmt;
104 : : vaf.va = &args;
105 : : printk(KERN_DEBUG "%s: (%s, %u): %pV\n", file, func, line, &vaf);
106 : : va_end(args);
107 : : }
108 : : EXPORT_SYMBOL(__jbd_debug);
109 : : #endif
110 : :
111 : : /*
112 : : * Helper function used to manage commit timeouts
113 : : */
114 : :
115 : 0 : static void commit_timeout(unsigned long __data)
116 : : {
117 : 0 : struct task_struct * p = (struct task_struct *) __data;
118 : :
119 : 0 : wake_up_process(p);
120 : 0 : }
121 : :
122 : : /*
123 : : * kjournald: The main thread function used to manage a logging device
124 : : * journal.
125 : : *
126 : : * This kernel thread is responsible for two things:
127 : : *
128 : : * 1) COMMIT: Every so often we need to commit the current state of the
129 : : * filesystem to disk. The journal thread is responsible for writing
130 : : * all of the metadata buffers to disk.
131 : : *
132 : : * 2) CHECKPOINT: We cannot reuse a used section of the log file until all
133 : : * of the data in that part of the log has been rewritten elsewhere on
134 : : * the disk. Flushing these old buffers to reclaim space in the log is
135 : : * known as checkpointing, and this thread is responsible for that job.
136 : : */
137 : :
138 : 0 : static int kjournald(void *arg)
139 : : {
140 : : journal_t *journal = arg;
141 : : transaction_t *transaction;
142 : :
143 : : /*
144 : : * Set up an interval timer which can be used to trigger a commit wakeup
145 : : * after the commit interval expires
146 : : */
147 : 0 : setup_timer(&journal->j_commit_timer, commit_timeout,
148 : : (unsigned long)current);
149 : :
150 : 0 : set_freezable();
151 : :
152 : : /* Record that the journal thread is running */
153 : 0 : journal->j_task = current;
154 : 0 : wake_up(&journal->j_wait_done_commit);
155 : :
156 : 0 : printk(KERN_INFO "kjournald starting. Commit interval %ld seconds\n",
157 : 0 : journal->j_commit_interval / HZ);
158 : :
159 : : /*
160 : : * And now, wait forever for commit wakeup events.
161 : : */
162 : : spin_lock(&journal->j_state_lock);
163 : :
164 : : loop:
165 [ # # ]: 0 : if (journal->j_flags & JFS_UNMOUNT)
166 : : goto end_loop;
167 : :
168 : : jbd_debug(1, "commit_sequence=%d, commit_request=%d\n",
169 : : journal->j_commit_sequence, journal->j_commit_request);
170 : :
171 [ # # ]: 0 : if (journal->j_commit_sequence != journal->j_commit_request) {
172 : : jbd_debug(1, "OK, requests differ\n");
173 : : spin_unlock(&journal->j_state_lock);
174 : 0 : del_timer_sync(&journal->j_commit_timer);
175 : 0 : journal_commit_transaction(journal);
176 : : spin_lock(&journal->j_state_lock);
177 : : goto loop;
178 : : }
179 : :
180 : 0 : wake_up(&journal->j_wait_done_commit);
181 [ # # ]: 0 : if (freezing(current)) {
182 : : /*
183 : : * The simpler the better. Flushing journal isn't a
184 : : * good idea, because that depends on threads that may
185 : : * be already stopped.
186 : : */
187 : : jbd_debug(1, "Now suspending kjournald\n");
188 : : spin_unlock(&journal->j_state_lock);
189 : : try_to_freeze();
190 : : spin_lock(&journal->j_state_lock);
191 : : } else {
192 : : /*
193 : : * We assume on resume that commits are already there,
194 : : * so we don't sleep
195 : : */
196 : 0 : DEFINE_WAIT(wait);
197 : : int should_sleep = 1;
198 : :
199 : 0 : prepare_to_wait(&journal->j_wait_commit, &wait,
200 : : TASK_INTERRUPTIBLE);
201 [ # # ]: 0 : if (journal->j_commit_sequence != journal->j_commit_request)
202 : : should_sleep = 0;
203 : 0 : transaction = journal->j_running_transaction;
204 [ # # ][ # # ]: 0 : if (transaction && time_after_eq(jiffies,
205 : : transaction->t_expires))
206 : : should_sleep = 0;
207 [ # # ]: 0 : if (journal->j_flags & JFS_UNMOUNT)
208 : : should_sleep = 0;
209 [ # # ]: 0 : if (should_sleep) {
210 : : spin_unlock(&journal->j_state_lock);
211 : 0 : schedule();
212 : : spin_lock(&journal->j_state_lock);
213 : : }
214 : 0 : finish_wait(&journal->j_wait_commit, &wait);
215 : : }
216 : :
217 : : jbd_debug(1, "kjournald wakes\n");
218 : :
219 : : /*
220 : : * Were we woken up by a commit wakeup event?
221 : : */
222 : 0 : transaction = journal->j_running_transaction;
223 [ # # ][ # # ]: 0 : if (transaction && time_after_eq(jiffies, transaction->t_expires)) {
224 : 0 : journal->j_commit_request = transaction->t_tid;
225 : : jbd_debug(1, "woke because of timeout\n");
226 : : }
227 : : goto loop;
228 : :
229 : : end_loop:
230 : : spin_unlock(&journal->j_state_lock);
231 : 0 : del_timer_sync(&journal->j_commit_timer);
232 : 0 : journal->j_task = NULL;
233 : 0 : wake_up(&journal->j_wait_done_commit);
234 : : jbd_debug(1, "Journal thread exiting.\n");
235 : 0 : return 0;
236 : : }
237 : :
238 : 0 : static int journal_start_thread(journal_t *journal)
239 : : {
240 : : struct task_struct *t;
241 : :
242 [ # # ]: 0 : t = kthread_run(kjournald, journal, "kjournald");
243 [ # # ]: 0 : if (IS_ERR(t))
244 : 0 : return PTR_ERR(t);
245 : :
246 [ # # ][ # # ]: 0 : wait_event(journal->j_wait_done_commit, journal->j_task != NULL);
247 : : return 0;
248 : : }
249 : :
250 : 0 : static void journal_kill_thread(journal_t *journal)
251 : : {
252 : : spin_lock(&journal->j_state_lock);
253 : 0 : journal->j_flags |= JFS_UNMOUNT;
254 : :
255 [ # # ]: 0 : while (journal->j_task) {
256 : 0 : wake_up(&journal->j_wait_commit);
257 : : spin_unlock(&journal->j_state_lock);
258 [ # # ][ # # ]: 0 : wait_event(journal->j_wait_done_commit,
259 : : journal->j_task == NULL);
260 : : spin_lock(&journal->j_state_lock);
261 : : }
262 : : spin_unlock(&journal->j_state_lock);
263 : 0 : }
264 : :
265 : : /*
266 : : * journal_write_metadata_buffer: write a metadata buffer to the journal.
267 : : *
268 : : * Writes a metadata buffer to a given disk block. The actual IO is not
269 : : * performed but a new buffer_head is constructed which labels the data
270 : : * to be written with the correct destination disk block.
271 : : *
272 : : * Any magic-number escaping which needs to be done will cause a
273 : : * copy-out here. If the buffer happens to start with the
274 : : * JFS_MAGIC_NUMBER, then we can't write it to the log directly: the
275 : : * magic number is only written to the log for descripter blocks. In
276 : : * this case, we copy the data and replace the first word with 0, and we
277 : : * return a result code which indicates that this buffer needs to be
278 : : * marked as an escaped buffer in the corresponding log descriptor
279 : : * block. The missing word can then be restored when the block is read
280 : : * during recovery.
281 : : *
282 : : * If the source buffer has already been modified by a new transaction
283 : : * since we took the last commit snapshot, we use the frozen copy of
284 : : * that data for IO. If we end up using the existing buffer_head's data
285 : : * for the write, then we *have* to lock the buffer to prevent anyone
286 : : * else from using and possibly modifying it while the IO is in
287 : : * progress.
288 : : *
289 : : * The function returns a pointer to the buffer_heads to be used for IO.
290 : : *
291 : : * We assume that the journal has already been locked in this function.
292 : : *
293 : : * Return value:
294 : : * <0: Error
295 : : * >=0: Finished OK
296 : : *
297 : : * On success:
298 : : * Bit 0 set == escape performed on the data
299 : : * Bit 1 set == buffer copy-out performed (kfree the data after IO)
300 : : */
301 : :
302 : 0 : int journal_write_metadata_buffer(transaction_t *transaction,
303 : 0 : struct journal_head *jh_in,
304 : : struct journal_head **jh_out,
305 : : unsigned int blocknr)
306 : : {
307 : : int need_copy_out = 0;
308 : : int done_copy_out = 0;
309 : : int do_escape = 0;
310 : : char *mapped_data;
311 : : struct buffer_head *new_bh;
312 : : struct journal_head *new_jh;
313 : : struct page *new_page;
314 : : unsigned int new_offset;
315 : : struct buffer_head *bh_in = jh2bh(jh_in);
316 : 0 : journal_t *journal = transaction->t_journal;
317 : :
318 : : /*
319 : : * The buffer really shouldn't be locked: only the current committing
320 : : * transaction is allowed to write it, so nobody else is allowed
321 : : * to do any IO.
322 : : *
323 : : * akpm: except if we're journalling data, and write() output is
324 : : * also part of a shared mapping, and another thread has
325 : : * decided to launch a writepage() against this buffer.
326 : : */
327 [ # # ]: 0 : J_ASSERT_BH(bh_in, buffer_jbddirty(bh_in));
328 : :
329 : 0 : new_bh = alloc_buffer_head(GFP_NOFS|__GFP_NOFAIL);
330 : : /* keep subsequent assertions sane */
331 : 0 : atomic_set(&new_bh->b_count, 1);
332 : 0 : new_jh = journal_add_journal_head(new_bh); /* This sleeps */
333 : :
334 : : /*
335 : : * If a new transaction has already done a buffer copy-out, then
336 : : * we use that version of the data for the commit.
337 : : */
338 : : jbd_lock_bh_state(bh_in);
339 : : repeat:
340 [ # # ]: 0 : if (jh_in->b_frozen_data) {
341 : : done_copy_out = 1;
342 : 0 : new_page = virt_to_page(jh_in->b_frozen_data);
343 : 0 : new_offset = offset_in_page(jh_in->b_frozen_data);
344 : : } else {
345 : 0 : new_page = jh2bh(jh_in)->b_page;
346 : 0 : new_offset = offset_in_page(jh2bh(jh_in)->b_data);
347 : : }
348 : :
349 : 0 : mapped_data = kmap_atomic(new_page);
350 : : /*
351 : : * Check for escaping
352 : : */
353 [ # # ]: 0 : if (*((__be32 *)(mapped_data + new_offset)) ==
354 : : cpu_to_be32(JFS_MAGIC_NUMBER)) {
355 : : need_copy_out = 1;
356 : : do_escape = 1;
357 : : }
358 : 0 : kunmap_atomic(mapped_data);
359 : :
360 : : /*
361 : : * Do we need to do a data copy?
362 : : */
363 [ # # ]: 0 : if (need_copy_out && !done_copy_out) {
364 : : char *tmp;
365 : :
366 : : jbd_unlock_bh_state(bh_in);
367 : 0 : tmp = jbd_alloc(bh_in->b_size, GFP_NOFS);
368 : : jbd_lock_bh_state(bh_in);
369 [ # # ]: 0 : if (jh_in->b_frozen_data) {
370 : 0 : jbd_free(tmp, bh_in->b_size);
371 : : goto repeat;
372 : : }
373 : :
374 : 0 : jh_in->b_frozen_data = tmp;
375 : 0 : mapped_data = kmap_atomic(new_page);
376 : 0 : memcpy(tmp, mapped_data + new_offset, jh2bh(jh_in)->b_size);
377 : 0 : kunmap_atomic(mapped_data);
378 : :
379 : 0 : new_page = virt_to_page(tmp);
380 : 0 : new_offset = offset_in_page(tmp);
381 : : done_copy_out = 1;
382 : : }
383 : :
384 : : /*
385 : : * Did we need to do an escaping? Now we've done all the
386 : : * copying, we can finally do so.
387 : : */
388 [ # # ]: 0 : if (do_escape) {
389 : 0 : mapped_data = kmap_atomic(new_page);
390 : 0 : *((unsigned int *)(mapped_data + new_offset)) = 0;
391 : 0 : kunmap_atomic(mapped_data);
392 : : }
393 : :
394 : 0 : set_bh_page(new_bh, new_page, new_offset);
395 : 0 : new_jh->b_transaction = NULL;
396 : 0 : new_bh->b_size = jh2bh(jh_in)->b_size;
397 : 0 : new_bh->b_bdev = transaction->t_journal->j_dev;
398 : 0 : new_bh->b_blocknr = blocknr;
399 : : set_buffer_mapped(new_bh);
400 : : set_buffer_dirty(new_bh);
401 : :
402 : 0 : *jh_out = new_jh;
403 : :
404 : : /*
405 : : * The to-be-written buffer needs to get moved to the io queue,
406 : : * and the original buffer whose contents we are shadowing or
407 : : * copying is moved to the transaction's shadow queue.
408 : : */
409 : : JBUFFER_TRACE(jh_in, "file as BJ_Shadow");
410 : : spin_lock(&journal->j_list_lock);
411 : 0 : __journal_file_buffer(jh_in, transaction, BJ_Shadow);
412 : : spin_unlock(&journal->j_list_lock);
413 : : jbd_unlock_bh_state(bh_in);
414 : :
415 : : JBUFFER_TRACE(new_jh, "file as BJ_IO");
416 : 0 : journal_file_buffer(new_jh, transaction, BJ_IO);
417 : :
418 : 0 : return do_escape | (done_copy_out << 1);
419 : : }
420 : :
421 : : /*
422 : : * Allocation code for the journal file. Manage the space left in the
423 : : * journal, so that we can begin checkpointing when appropriate.
424 : : */
425 : :
426 : : /*
427 : : * __log_space_left: Return the number of free blocks left in the journal.
428 : : *
429 : : * Called with the journal already locked.
430 : : *
431 : : * Called under j_state_lock
432 : : */
433 : :
434 : 0 : int __log_space_left(journal_t *journal)
435 : : {
436 : 0 : int left = journal->j_free;
437 : :
438 [ # # ]: 0 : assert_spin_locked(&journal->j_state_lock);
439 : :
440 : : /*
441 : : * Be pessimistic here about the number of those free blocks which
442 : : * might be required for log descriptor control blocks.
443 : : */
444 : :
445 : : #define MIN_LOG_RESERVED_BLOCKS 32 /* Allow for rounding errors */
446 : :
447 : 0 : left -= MIN_LOG_RESERVED_BLOCKS;
448 : :
449 [ # # ]: 0 : if (left <= 0)
450 : : return 0;
451 : 0 : left -= (left >> 3);
452 : 0 : return left;
453 : : }
454 : :
455 : : /*
456 : : * Called under j_state_lock. Returns true if a transaction commit was started.
457 : : */
458 : 0 : int __log_start_commit(journal_t *journal, tid_t target)
459 : : {
460 : : /*
461 : : * The only transaction we can possibly wait upon is the
462 : : * currently running transaction (if it exists). Otherwise,
463 : : * the target tid must be an old one.
464 : : */
465 [ # # ][ # # ]: 0 : if (journal->j_commit_request != target &&
466 [ # # ]: 0 : journal->j_running_transaction &&
467 : 0 : journal->j_running_transaction->t_tid == target) {
468 : : /*
469 : : * We want a new commit: OK, mark the request and wakeup the
470 : : * commit thread. We do _not_ do the commit ourselves.
471 : : */
472 : :
473 : 0 : journal->j_commit_request = target;
474 : : jbd_debug(1, "JBD: requesting commit %d/%d\n",
475 : : journal->j_commit_request,
476 : : journal->j_commit_sequence);
477 : 0 : wake_up(&journal->j_wait_commit);
478 : 0 : return 1;
479 [ # # ]: 0 : } else if (!tid_geq(journal->j_commit_request, target))
480 : : /* This should never happen, but if it does, preserve
481 : : the evidence before kjournald goes into a loop and
482 : : increments j_commit_sequence beyond all recognition. */
483 [ # # ][ # # ]: 0 : WARN_ONCE(1, "jbd: bad log_start_commit: %u %u %u %u\n",
[ # # ]
484 : : journal->j_commit_request, journal->j_commit_sequence,
485 : : target, journal->j_running_transaction ?
486 : : journal->j_running_transaction->t_tid : 0);
487 : : return 0;
488 : : }
489 : :
490 : 0 : int log_start_commit(journal_t *journal, tid_t tid)
491 : : {
492 : : int ret;
493 : :
494 : : spin_lock(&journal->j_state_lock);
495 : 0 : ret = __log_start_commit(journal, tid);
496 : : spin_unlock(&journal->j_state_lock);
497 : 0 : return ret;
498 : : }
499 : :
500 : : /*
501 : : * Force and wait upon a commit if the calling process is not within
502 : : * transaction. This is used for forcing out undo-protected data which contains
503 : : * bitmaps, when the fs is running out of space.
504 : : *
505 : : * We can only force the running transaction if we don't have an active handle;
506 : : * otherwise, we will deadlock.
507 : : *
508 : : * Returns true if a transaction was started.
509 : : */
510 : 0 : int journal_force_commit_nested(journal_t *journal)
511 : : {
512 : : transaction_t *transaction = NULL;
513 : : tid_t tid;
514 : :
515 : : spin_lock(&journal->j_state_lock);
516 [ # # ][ # # ]: 0 : if (journal->j_running_transaction && !current->journal_info) {
517 : : transaction = journal->j_running_transaction;
518 : 0 : __log_start_commit(journal, transaction->t_tid);
519 [ # # ]: 0 : } else if (journal->j_committing_transaction)
520 : : transaction = journal->j_committing_transaction;
521 : :
522 [ # # ]: 0 : if (!transaction) {
523 : : spin_unlock(&journal->j_state_lock);
524 : 0 : return 0; /* Nothing to retry */
525 : : }
526 : :
527 : 0 : tid = transaction->t_tid;
528 : : spin_unlock(&journal->j_state_lock);
529 : 0 : log_wait_commit(journal, tid);
530 : 0 : return 1;
531 : : }
532 : :
533 : : /*
534 : : * Start a commit of the current running transaction (if any). Returns true
535 : : * if a transaction is going to be committed (or is currently already
536 : : * committing), and fills its tid in at *ptid
537 : : */
538 : 0 : int journal_start_commit(journal_t *journal, tid_t *ptid)
539 : : {
540 : : int ret = 0;
541 : :
542 : : spin_lock(&journal->j_state_lock);
543 [ # # ]: 0 : if (journal->j_running_transaction) {
544 : 0 : tid_t tid = journal->j_running_transaction->t_tid;
545 : :
546 : 0 : __log_start_commit(journal, tid);
547 : : /* There's a running transaction and we've just made sure
548 : : * it's commit has been scheduled. */
549 [ # # ]: 0 : if (ptid)
550 : 0 : *ptid = tid;
551 : : ret = 1;
552 [ # # ]: 0 : } else if (journal->j_committing_transaction) {
553 : : /*
554 : : * If commit has been started, then we have to wait for
555 : : * completion of that transaction.
556 : : */
557 [ # # ]: 0 : if (ptid)
558 : 0 : *ptid = journal->j_committing_transaction->t_tid;
559 : : ret = 1;
560 : : }
561 : : spin_unlock(&journal->j_state_lock);
562 : 0 : return ret;
563 : : }
564 : :
565 : : /*
566 : : * Wait for a specified commit to complete.
567 : : * The caller may not hold the journal lock.
568 : : */
569 : 0 : int log_wait_commit(journal_t *journal, tid_t tid)
570 : : {
571 : : int err = 0;
572 : :
573 : : #ifdef CONFIG_JBD_DEBUG
574 : : spin_lock(&journal->j_state_lock);
575 : : if (!tid_geq(journal->j_commit_request, tid)) {
576 : : printk(KERN_EMERG
577 : : "%s: error: j_commit_request=%d, tid=%d\n",
578 : : __func__, journal->j_commit_request, tid);
579 : : }
580 : : spin_unlock(&journal->j_state_lock);
581 : : #endif
582 : : spin_lock(&journal->j_state_lock);
583 : : /*
584 : : * Not running or committing trans? Must be already committed. This
585 : : * saves us from waiting for a *long* time when tid overflows.
586 : : */
587 [ # # ][ # # ]: 0 : if (!((journal->j_running_transaction &&
[ # # ]
588 : 0 : journal->j_running_transaction->t_tid == tid) ||
589 [ # # ]: 0 : (journal->j_committing_transaction &&
590 : 0 : journal->j_committing_transaction->t_tid == tid)))
591 : : goto out_unlock;
592 : :
593 [ # # ]: 0 : if (!tid_geq(journal->j_commit_waited, tid))
594 : 0 : journal->j_commit_waited = tid;
595 [ # # ]: 0 : while (tid_gt(tid, journal->j_commit_sequence)) {
596 : : jbd_debug(1, "JBD: want %d, j_commit_sequence=%d\n",
597 : : tid, journal->j_commit_sequence);
598 : 0 : wake_up(&journal->j_wait_commit);
599 : : spin_unlock(&journal->j_state_lock);
600 [ # # ][ # # ]: 0 : wait_event(journal->j_wait_done_commit,
601 : : !tid_gt(tid, journal->j_commit_sequence));
602 : : spin_lock(&journal->j_state_lock);
603 : : }
604 : : out_unlock:
605 : : spin_unlock(&journal->j_state_lock);
606 : :
607 [ # # ]: 0 : if (unlikely(is_journal_aborted(journal))) {
608 : 0 : printk(KERN_EMERG "journal commit I/O error\n");
609 : : err = -EIO;
610 : : }
611 : 0 : return err;
612 : : }
613 : :
614 : : /*
615 : : * Return 1 if a given transaction has not yet sent barrier request
616 : : * connected with a transaction commit. If 0 is returned, transaction
617 : : * may or may not have sent the barrier. Used to avoid sending barrier
618 : : * twice in common cases.
619 : : */
620 : 0 : int journal_trans_will_send_data_barrier(journal_t *journal, tid_t tid)
621 : : {
622 : : int ret = 0;
623 : : transaction_t *commit_trans;
624 : :
625 [ # # ]: 0 : if (!(journal->j_flags & JFS_BARRIER))
626 : : return 0;
627 : : spin_lock(&journal->j_state_lock);
628 : : /* Transaction already committed? */
629 [ # # ]: 0 : if (tid_geq(journal->j_commit_sequence, tid))
630 : : goto out;
631 : : /*
632 : : * Transaction is being committed and we already proceeded to
633 : : * writing commit record?
634 : : */
635 : 0 : commit_trans = journal->j_committing_transaction;
636 [ # # ][ # # ]: 0 : if (commit_trans && commit_trans->t_tid == tid &&
[ # # ]
637 : 0 : commit_trans->t_state >= T_COMMIT_RECORD)
638 : : goto out;
639 : : ret = 1;
640 : : out:
641 : : spin_unlock(&journal->j_state_lock);
642 : 0 : return ret;
643 : : }
644 : : EXPORT_SYMBOL(journal_trans_will_send_data_barrier);
645 : :
646 : : /*
647 : : * Log buffer allocation routines:
648 : : */
649 : :
650 : 0 : int journal_next_log_block(journal_t *journal, unsigned int *retp)
651 : : {
652 : : unsigned int blocknr;
653 : :
654 : : spin_lock(&journal->j_state_lock);
655 [ # # ]: 0 : J_ASSERT(journal->j_free > 1);
656 : :
657 : 0 : blocknr = journal->j_head;
658 : 0 : journal->j_head++;
659 : 0 : journal->j_free--;
660 [ # # ]: 0 : if (journal->j_head == journal->j_last)
661 : 0 : journal->j_head = journal->j_first;
662 : : spin_unlock(&journal->j_state_lock);
663 : 0 : return journal_bmap(journal, blocknr, retp);
664 : : }
665 : :
666 : : /*
667 : : * Conversion of logical to physical block numbers for the journal
668 : : *
669 : : * On external journals the journal blocks are identity-mapped, so
670 : : * this is a no-op. If needed, we can use j_blk_offset - everything is
671 : : * ready.
672 : : */
673 : 0 : int journal_bmap(journal_t *journal, unsigned int blocknr,
674 : : unsigned int *retp)
675 : : {
676 : : int err = 0;
677 : : unsigned int ret;
678 : :
679 [ # # ]: 0 : if (journal->j_inode) {
680 : 0 : ret = bmap(journal->j_inode, blocknr);
681 [ # # ]: 0 : if (ret)
682 : 0 : *retp = ret;
683 : : else {
684 : : char b[BDEVNAME_SIZE];
685 : :
686 : 0 : printk(KERN_ALERT "%s: journal block not found "
687 : : "at offset %u on %s\n",
688 : : __func__,
689 : : blocknr,
690 : : bdevname(journal->j_dev, b));
691 : : err = -EIO;
692 : 0 : __journal_abort_soft(journal, err);
693 : : }
694 : : } else {
695 : 0 : *retp = blocknr; /* +journal->j_blk_offset */
696 : : }
697 : 0 : return err;
698 : : }
699 : :
700 : : /*
701 : : * We play buffer_head aliasing tricks to write data/metadata blocks to
702 : : * the journal without copying their contents, but for journal
703 : : * descriptor blocks we do need to generate bona fide buffers.
704 : : *
705 : : * After the caller of journal_get_descriptor_buffer() has finished modifying
706 : : * the buffer's contents they really should run flush_dcache_page(bh->b_page).
707 : : * But we don't bother doing that, so there will be coherency problems with
708 : : * mmaps of blockdevs which hold live JBD-controlled filesystems.
709 : : */
710 : 0 : struct journal_head *journal_get_descriptor_buffer(journal_t *journal)
711 : : {
712 : : struct buffer_head *bh;
713 : : unsigned int blocknr;
714 : : int err;
715 : :
716 : 0 : err = journal_next_log_block(journal, &blocknr);
717 : :
718 [ # # ]: 0 : if (err)
719 : : return NULL;
720 : :
721 : 0 : bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
722 [ # # ]: 0 : if (!bh)
723 : : return NULL;
724 : : lock_buffer(bh);
725 [ # # ]: 0 : memset(bh->b_data, 0, journal->j_blocksize);
726 : : set_buffer_uptodate(bh);
727 : 0 : unlock_buffer(bh);
728 : : BUFFER_TRACE(bh, "return this buffer");
729 : 0 : return journal_add_journal_head(bh);
730 : : }
731 : :
732 : : /*
733 : : * Management for journal control blocks: functions to create and
734 : : * destroy journal_t structures, and to initialise and read existing
735 : : * journal blocks from disk. */
736 : :
737 : : /* First: create and setup a journal_t object in memory. We initialise
738 : : * very few fields yet: that has to wait until we have created the
739 : : * journal structures from from scratch, or loaded them from disk. */
740 : :
741 : 0 : static journal_t * journal_init_common (void)
742 : : {
743 : : journal_t *journal;
744 : : int err;
745 : :
746 : : journal = kzalloc(sizeof(*journal), GFP_KERNEL);
747 [ # # ]: 0 : if (!journal)
748 : : goto fail;
749 : :
750 : 0 : init_waitqueue_head(&journal->j_wait_transaction_locked);
751 : 0 : init_waitqueue_head(&journal->j_wait_logspace);
752 : 0 : init_waitqueue_head(&journal->j_wait_done_commit);
753 : 0 : init_waitqueue_head(&journal->j_wait_checkpoint);
754 : 0 : init_waitqueue_head(&journal->j_wait_commit);
755 : 0 : init_waitqueue_head(&journal->j_wait_updates);
756 : 0 : mutex_init(&journal->j_checkpoint_mutex);
757 : 0 : spin_lock_init(&journal->j_revoke_lock);
758 : 0 : spin_lock_init(&journal->j_list_lock);
759 : 0 : spin_lock_init(&journal->j_state_lock);
760 : :
761 : 0 : journal->j_commit_interval = (HZ * JBD_DEFAULT_MAX_COMMIT_AGE);
762 : :
763 : : /* The journal is marked for error until we succeed with recovery! */
764 : 0 : journal->j_flags = JFS_ABORT;
765 : :
766 : : /* Set up a default-sized revoke table for the new mount. */
767 : 0 : err = journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH);
768 [ # # ]: 0 : if (err) {
769 : 0 : kfree(journal);
770 : 0 : goto fail;
771 : : }
772 : : return journal;
773 : : fail:
774 : : return NULL;
775 : : }
776 : :
777 : : /* journal_init_dev and journal_init_inode:
778 : : *
779 : : * Create a journal structure assigned some fixed set of disk blocks to
780 : : * the journal. We don't actually touch those disk blocks yet, but we
781 : : * need to set up all of the mapping information to tell the journaling
782 : : * system where the journal blocks are.
783 : : *
784 : : */
785 : :
786 : : /**
787 : : * journal_t * journal_init_dev() - creates and initialises a journal structure
788 : : * @bdev: Block device on which to create the journal
789 : : * @fs_dev: Device which hold journalled filesystem for this journal.
790 : : * @start: Block nr Start of journal.
791 : : * @len: Length of the journal in blocks.
792 : : * @blocksize: blocksize of journalling device
793 : : *
794 : : * Returns: a newly created journal_t *
795 : : *
796 : : * journal_init_dev creates a journal which maps a fixed contiguous
797 : : * range of blocks on an arbitrary block device.
798 : : *
799 : : */
800 : 0 : journal_t * journal_init_dev(struct block_device *bdev,
801 : : struct block_device *fs_dev,
802 : : int start, int len, int blocksize)
803 : : {
804 : 0 : journal_t *journal = journal_init_common();
805 : : struct buffer_head *bh;
806 : : int n;
807 : :
808 [ # # ]: 0 : if (!journal)
809 : : return NULL;
810 : :
811 : : /* journal descriptor can store up to n blocks -bzzz */
812 : 0 : journal->j_blocksize = blocksize;
813 : 0 : n = journal->j_blocksize / sizeof(journal_block_tag_t);
814 : 0 : journal->j_wbufsize = n;
815 : 0 : journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
816 [ # # ]: 0 : if (!journal->j_wbuf) {
817 : 0 : printk(KERN_ERR "%s: Can't allocate bhs for commit thread\n",
818 : : __func__);
819 : 0 : goto out_err;
820 : : }
821 : 0 : journal->j_dev = bdev;
822 : 0 : journal->j_fs_dev = fs_dev;
823 : 0 : journal->j_blk_offset = start;
824 : 0 : journal->j_maxlen = len;
825 : :
826 : 0 : bh = __getblk(journal->j_dev, start, journal->j_blocksize);
827 [ # # ]: 0 : if (!bh) {
828 : 0 : printk(KERN_ERR
829 : : "%s: Cannot get buffer for journal superblock\n",
830 : : __func__);
831 : 0 : goto out_err;
832 : : }
833 : 0 : journal->j_sb_buffer = bh;
834 : 0 : journal->j_superblock = (journal_superblock_t *)bh->b_data;
835 : :
836 : 0 : return journal;
837 : : out_err:
838 : 0 : kfree(journal->j_wbuf);
839 : 0 : kfree(journal);
840 : 0 : return NULL;
841 : : }
842 : :
843 : : /**
844 : : * journal_t * journal_init_inode () - creates a journal which maps to a inode.
845 : : * @inode: An inode to create the journal in
846 : : *
847 : : * journal_init_inode creates a journal which maps an on-disk inode as
848 : : * the journal. The inode must exist already, must support bmap() and
849 : : * must have all data blocks preallocated.
850 : : */
851 : 0 : journal_t * journal_init_inode (struct inode *inode)
852 : : {
853 : : struct buffer_head *bh;
854 : 0 : journal_t *journal = journal_init_common();
855 : : int err;
856 : : int n;
857 : : unsigned int blocknr;
858 : :
859 [ # # ]: 0 : if (!journal)
860 : : return NULL;
861 : :
862 : 0 : journal->j_dev = journal->j_fs_dev = inode->i_sb->s_bdev;
863 : 0 : journal->j_inode = inode;
864 : : jbd_debug(1,
865 : : "journal %p: inode %s/%ld, size %Ld, bits %d, blksize %ld\n",
866 : : journal, inode->i_sb->s_id, inode->i_ino,
867 : : (long long) inode->i_size,
868 : : inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize);
869 : :
870 : 0 : journal->j_maxlen = inode->i_size >> inode->i_sb->s_blocksize_bits;
871 : 0 : journal->j_blocksize = inode->i_sb->s_blocksize;
872 : :
873 : : /* journal descriptor can store up to n blocks -bzzz */
874 : 0 : n = journal->j_blocksize / sizeof(journal_block_tag_t);
875 : 0 : journal->j_wbufsize = n;
876 : 0 : journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
877 [ # # ]: 0 : if (!journal->j_wbuf) {
878 : 0 : printk(KERN_ERR "%s: Can't allocate bhs for commit thread\n",
879 : : __func__);
880 : 0 : goto out_err;
881 : : }
882 : :
883 : 0 : err = journal_bmap(journal, 0, &blocknr);
884 : : /* If that failed, give up */
885 [ # # ]: 0 : if (err) {
886 : 0 : printk(KERN_ERR "%s: Cannot locate journal superblock\n",
887 : : __func__);
888 : 0 : goto out_err;
889 : : }
890 : :
891 : 0 : bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
892 [ # # ]: 0 : if (!bh) {
893 : 0 : printk(KERN_ERR
894 : : "%s: Cannot get buffer for journal superblock\n",
895 : : __func__);
896 : 0 : goto out_err;
897 : : }
898 : 0 : journal->j_sb_buffer = bh;
899 : 0 : journal->j_superblock = (journal_superblock_t *)bh->b_data;
900 : :
901 : 0 : return journal;
902 : : out_err:
903 : 0 : kfree(journal->j_wbuf);
904 : 0 : kfree(journal);
905 : 0 : return NULL;
906 : : }
907 : :
908 : : /*
909 : : * If the journal init or create aborts, we need to mark the journal
910 : : * superblock as being NULL to prevent the journal destroy from writing
911 : : * back a bogus superblock.
912 : : */
913 : : static void journal_fail_superblock (journal_t *journal)
914 : : {
915 : 0 : struct buffer_head *bh = journal->j_sb_buffer;
916 : : brelse(bh);
917 : 0 : journal->j_sb_buffer = NULL;
918 : : }
919 : :
920 : : /*
921 : : * Given a journal_t structure, initialise the various fields for
922 : : * startup of a new journaling session. We use this both when creating
923 : : * a journal, and after recovering an old journal to reset it for
924 : : * subsequent use.
925 : : */
926 : :
927 : 0 : static int journal_reset(journal_t *journal)
928 : : {
929 : 0 : journal_superblock_t *sb = journal->j_superblock;
930 : : unsigned int first, last;
931 : :
932 [ # # ]: 0 : first = be32_to_cpu(sb->s_first);
933 [ # # ]: 0 : last = be32_to_cpu(sb->s_maxlen);
934 [ # # ]: 0 : if (first + JFS_MIN_JOURNAL_BLOCKS > last + 1) {
935 : 0 : printk(KERN_ERR "JBD: Journal too short (blocks %u-%u).\n",
936 : : first, last);
937 : : journal_fail_superblock(journal);
938 : 0 : return -EINVAL;
939 : : }
940 : :
941 : 0 : journal->j_first = first;
942 : 0 : journal->j_last = last;
943 : :
944 : 0 : journal->j_head = first;
945 : 0 : journal->j_tail = first;
946 : 0 : journal->j_free = last - first;
947 : :
948 : 0 : journal->j_tail_sequence = journal->j_transaction_sequence;
949 : 0 : journal->j_commit_sequence = journal->j_transaction_sequence - 1;
950 : 0 : journal->j_commit_request = journal->j_commit_sequence;
951 : :
952 : 0 : journal->j_max_transaction_buffers = journal->j_maxlen / 4;
953 : :
954 : : /*
955 : : * As a special case, if the on-disk copy is already marked as needing
956 : : * no recovery (s_start == 0), then we can safely defer the superblock
957 : : * update until the next commit by setting JFS_FLUSHED. This avoids
958 : : * attempting a write to a potential-readonly device.
959 : : */
960 [ # # ]: 0 : if (sb->s_start == 0) {
961 : : jbd_debug(1,"JBD: Skipping superblock update on recovered sb "
962 : : "(start %u, seq %d, errno %d)\n",
963 : : journal->j_tail, journal->j_tail_sequence,
964 : : journal->j_errno);
965 : 0 : journal->j_flags |= JFS_FLUSHED;
966 : : } else {
967 : : /* Lock here to make assertions happy... */
968 : 0 : mutex_lock(&journal->j_checkpoint_mutex);
969 : : /*
970 : : * Update log tail information. We use WRITE_FUA since new
971 : : * transaction will start reusing journal space and so we
972 : : * must make sure information about current log tail is on
973 : : * disk before that.
974 : : */
975 : 0 : journal_update_sb_log_tail(journal,
976 : : journal->j_tail_sequence,
977 : : journal->j_tail,
978 : : WRITE_FUA);
979 : 0 : mutex_unlock(&journal->j_checkpoint_mutex);
980 : : }
981 : 0 : return journal_start_thread(journal);
982 : : }
983 : :
984 : : /**
985 : : * int journal_create() - Initialise the new journal file
986 : : * @journal: Journal to create. This structure must have been initialised
987 : : *
988 : : * Given a journal_t structure which tells us which disk blocks we can
989 : : * use, create a new journal superblock and initialise all of the
990 : : * journal fields from scratch.
991 : : **/
992 : 0 : int journal_create(journal_t *journal)
993 : : {
994 : : unsigned int blocknr;
995 : : struct buffer_head *bh;
996 : : journal_superblock_t *sb;
997 : : int i, err;
998 : :
999 [ # # ]: 0 : if (journal->j_maxlen < JFS_MIN_JOURNAL_BLOCKS) {
1000 : 0 : printk (KERN_ERR "Journal length (%d blocks) too short.\n",
1001 : : journal->j_maxlen);
1002 : : journal_fail_superblock(journal);
1003 : 0 : return -EINVAL;
1004 : : }
1005 : :
1006 [ # # ]: 0 : if (journal->j_inode == NULL) {
1007 : : /*
1008 : : * We don't know what block to start at!
1009 : : */
1010 : 0 : printk(KERN_EMERG
1011 : : "%s: creation of journal on external device!\n",
1012 : : __func__);
1013 : 0 : BUG();
1014 : : }
1015 : :
1016 : : /* Zero out the entire journal on disk. We cannot afford to
1017 : : have any blocks on disk beginning with JFS_MAGIC_NUMBER. */
1018 : : jbd_debug(1, "JBD: Zeroing out journal blocks...\n");
1019 [ # # ]: 0 : for (i = 0; i < journal->j_maxlen; i++) {
1020 : 0 : err = journal_bmap(journal, i, &blocknr);
1021 [ # # ]: 0 : if (err)
1022 : : return err;
1023 : 0 : bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
1024 [ # # ]: 0 : if (unlikely(!bh))
1025 : : return -ENOMEM;
1026 : : lock_buffer(bh);
1027 [ # # ]: 0 : memset (bh->b_data, 0, journal->j_blocksize);
1028 : : BUFFER_TRACE(bh, "marking dirty");
1029 : 0 : mark_buffer_dirty(bh);
1030 : : BUFFER_TRACE(bh, "marking uptodate");
1031 : : set_buffer_uptodate(bh);
1032 : 0 : unlock_buffer(bh);
1033 : 0 : __brelse(bh);
1034 : : }
1035 : :
1036 : 0 : sync_blockdev(journal->j_dev);
1037 : : jbd_debug(1, "JBD: journal cleared.\n");
1038 : :
1039 : : /* OK, fill in the initial static fields in the new superblock */
1040 : 0 : sb = journal->j_superblock;
1041 : :
1042 : 0 : sb->s_header.h_magic = cpu_to_be32(JFS_MAGIC_NUMBER);
1043 : 0 : sb->s_header.h_blocktype = cpu_to_be32(JFS_SUPERBLOCK_V2);
1044 : :
1045 [ # # ]: 0 : sb->s_blocksize = cpu_to_be32(journal->j_blocksize);
1046 [ # # ]: 0 : sb->s_maxlen = cpu_to_be32(journal->j_maxlen);
1047 : 0 : sb->s_first = cpu_to_be32(1);
1048 : :
1049 : 0 : journal->j_transaction_sequence = 1;
1050 : :
1051 : 0 : journal->j_flags &= ~JFS_ABORT;
1052 : 0 : journal->j_format_version = 2;
1053 : :
1054 : 0 : return journal_reset(journal);
1055 : : }
1056 : :
1057 : 0 : static void journal_write_superblock(journal_t *journal, int write_op)
1058 : : {
1059 : 0 : struct buffer_head *bh = journal->j_sb_buffer;
1060 : : int ret;
1061 : :
1062 : : trace_journal_write_superblock(journal, write_op);
1063 [ # # ]: 0 : if (!(journal->j_flags & JFS_BARRIER))
1064 : 0 : write_op &= ~(REQ_FUA | REQ_FLUSH);
1065 : : lock_buffer(bh);
1066 [ # # ]: 0 : if (buffer_write_io_error(bh)) {
1067 : : char b[BDEVNAME_SIZE];
1068 : : /*
1069 : : * Oh, dear. A previous attempt to write the journal
1070 : : * superblock failed. This could happen because the
1071 : : * USB device was yanked out. Or it could happen to
1072 : : * be a transient write error and maybe the block will
1073 : : * be remapped. Nothing we can do but to retry the
1074 : : * write and hope for the best.
1075 : : */
1076 : 0 : printk(KERN_ERR "JBD: previous I/O error detected "
1077 : : "for journal superblock update for %s.\n",
1078 : : journal_dev_name(journal, b));
1079 : : clear_buffer_write_io_error(bh);
1080 : : set_buffer_uptodate(bh);
1081 : : }
1082 : :
1083 : : get_bh(bh);
1084 : 0 : bh->b_end_io = end_buffer_write_sync;
1085 : 0 : ret = submit_bh(write_op, bh);
1086 : : wait_on_buffer(bh);
1087 [ # # ]: 0 : if (buffer_write_io_error(bh)) {
1088 : : clear_buffer_write_io_error(bh);
1089 : : set_buffer_uptodate(bh);
1090 : : ret = -EIO;
1091 : : }
1092 [ # # ]: 0 : if (ret) {
1093 : : char b[BDEVNAME_SIZE];
1094 : 0 : printk(KERN_ERR "JBD: Error %d detected "
1095 : : "when updating journal superblock for %s.\n",
1096 : : ret, journal_dev_name(journal, b));
1097 : : }
1098 : 0 : }
1099 : :
1100 : : /**
1101 : : * journal_update_sb_log_tail() - Update log tail in journal sb on disk.
1102 : : * @journal: The journal to update.
1103 : : * @tail_tid: TID of the new transaction at the tail of the log
1104 : : * @tail_block: The first block of the transaction at the tail of the log
1105 : : * @write_op: With which operation should we write the journal sb
1106 : : *
1107 : : * Update a journal's superblock information about log tail and write it to
1108 : : * disk, waiting for the IO to complete.
1109 : : */
1110 : 0 : void journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid,
1111 : : unsigned int tail_block, int write_op)
1112 : : {
1113 : 0 : journal_superblock_t *sb = journal->j_superblock;
1114 : :
1115 [ # # ]: 0 : BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
1116 : : jbd_debug(1,"JBD: updating superblock (start %u, seq %u)\n",
1117 : : tail_block, tail_tid);
1118 : :
1119 [ # # ]: 0 : sb->s_sequence = cpu_to_be32(tail_tid);
1120 [ # # ]: 0 : sb->s_start = cpu_to_be32(tail_block);
1121 : :
1122 : 0 : journal_write_superblock(journal, write_op);
1123 : :
1124 : : /* Log is no longer empty */
1125 : : spin_lock(&journal->j_state_lock);
1126 [ # # ]: 0 : WARN_ON(!sb->s_sequence);
1127 : 0 : journal->j_flags &= ~JFS_FLUSHED;
1128 : : spin_unlock(&journal->j_state_lock);
1129 : 0 : }
1130 : :
1131 : : /**
1132 : : * mark_journal_empty() - Mark on disk journal as empty.
1133 : : * @journal: The journal to update.
1134 : : *
1135 : : * Update a journal's dynamic superblock fields to show that journal is empty.
1136 : : * Write updated superblock to disk waiting for IO to complete.
1137 : : */
1138 : 0 : static void mark_journal_empty(journal_t *journal)
1139 : : {
1140 : 0 : journal_superblock_t *sb = journal->j_superblock;
1141 : :
1142 [ # # ]: 0 : BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
1143 : : spin_lock(&journal->j_state_lock);
1144 : : /* Is it already empty? */
1145 [ # # ]: 0 : if (sb->s_start == 0) {
1146 : : spin_unlock(&journal->j_state_lock);
1147 : 0 : return;
1148 : : }
1149 : : jbd_debug(1, "JBD: Marking journal as empty (seq %d)\n",
1150 : : journal->j_tail_sequence);
1151 : :
1152 [ # # ]: 0 : sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
1153 : 0 : sb->s_start = cpu_to_be32(0);
1154 : : spin_unlock(&journal->j_state_lock);
1155 : :
1156 : 0 : journal_write_superblock(journal, WRITE_FUA);
1157 : :
1158 : : spin_lock(&journal->j_state_lock);
1159 : : /* Log is empty */
1160 : 0 : journal->j_flags |= JFS_FLUSHED;
1161 : : spin_unlock(&journal->j_state_lock);
1162 : : }
1163 : :
1164 : : /**
1165 : : * journal_update_sb_errno() - Update error in the journal.
1166 : : * @journal: The journal to update.
1167 : : *
1168 : : * Update a journal's errno. Write updated superblock to disk waiting for IO
1169 : : * to complete.
1170 : : */
1171 : 0 : static void journal_update_sb_errno(journal_t *journal)
1172 : : {
1173 : 0 : journal_superblock_t *sb = journal->j_superblock;
1174 : :
1175 : : spin_lock(&journal->j_state_lock);
1176 : : jbd_debug(1, "JBD: updating superblock error (errno %d)\n",
1177 : : journal->j_errno);
1178 [ # # ]: 0 : sb->s_errno = cpu_to_be32(journal->j_errno);
1179 : : spin_unlock(&journal->j_state_lock);
1180 : :
1181 : 0 : journal_write_superblock(journal, WRITE_SYNC);
1182 : 0 : }
1183 : :
1184 : : /*
1185 : : * Read the superblock for a given journal, performing initial
1186 : : * validation of the format.
1187 : : */
1188 : :
1189 : 0 : static int journal_get_superblock(journal_t *journal)
1190 : : {
1191 : : struct buffer_head *bh;
1192 : : journal_superblock_t *sb;
1193 : : int err = -EIO;
1194 : :
1195 : 0 : bh = journal->j_sb_buffer;
1196 : :
1197 [ # # ]: 0 : J_ASSERT(bh != NULL);
1198 [ # # ]: 0 : if (!buffer_uptodate(bh)) {
1199 : 0 : ll_rw_block(READ, 1, &bh);
1200 : 0 : wait_on_buffer(bh);
1201 [ # # ]: 0 : if (!buffer_uptodate(bh)) {
1202 : 0 : printk (KERN_ERR
1203 : : "JBD: IO error reading journal superblock\n");
1204 : 0 : goto out;
1205 : : }
1206 : : }
1207 : :
1208 : 0 : sb = journal->j_superblock;
1209 : :
1210 : : err = -EINVAL;
1211 : :
1212 [ # # ][ # # ]: 0 : if (sb->s_header.h_magic != cpu_to_be32(JFS_MAGIC_NUMBER) ||
1213 [ # # ]: 0 : sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) {
1214 : 0 : printk(KERN_WARNING "JBD: no valid journal superblock found\n");
1215 : 0 : goto out;
1216 : : }
1217 : :
1218 [ # # ]: 0 : switch(be32_to_cpu(sb->s_header.h_blocktype)) {
[ # # # ]
1219 : : case JFS_SUPERBLOCK_V1:
1220 : 0 : journal->j_format_version = 1;
1221 : 0 : break;
1222 : : case JFS_SUPERBLOCK_V2:
1223 : 0 : journal->j_format_version = 2;
1224 : 0 : break;
1225 : : default:
1226 : 0 : printk(KERN_WARNING "JBD: unrecognised superblock format ID\n");
1227 : 0 : goto out;
1228 : : }
1229 : :
1230 [ # # ][ # # ]: 0 : if (be32_to_cpu(sb->s_maxlen) < journal->j_maxlen)
1231 [ # # ]: 0 : journal->j_maxlen = be32_to_cpu(sb->s_maxlen);
1232 [ # # ][ # # ]: 0 : else if (be32_to_cpu(sb->s_maxlen) > journal->j_maxlen) {
1233 : 0 : printk (KERN_WARNING "JBD: journal file too short\n");
1234 : 0 : goto out;
1235 : : }
1236 : :
1237 [ # # ][ # # ]: 0 : if (be32_to_cpu(sb->s_first) == 0 ||
[ # # ][ # # ]
1238 [ # # ]: 0 : be32_to_cpu(sb->s_first) >= journal->j_maxlen) {
1239 [ # # ]: 0 : printk(KERN_WARNING
1240 : : "JBD: Invalid start block of journal: %u\n",
1241 : 0 : be32_to_cpu(sb->s_first));
1242 : 0 : goto out;
1243 : : }
1244 : :
1245 : : return 0;
1246 : :
1247 : : out:
1248 : : journal_fail_superblock(journal);
1249 : 0 : return err;
1250 : : }
1251 : :
1252 : : /*
1253 : : * Load the on-disk journal superblock and read the key fields into the
1254 : : * journal_t.
1255 : : */
1256 : :
1257 : 0 : static int load_superblock(journal_t *journal)
1258 : : {
1259 : : int err;
1260 : : journal_superblock_t *sb;
1261 : :
1262 : 0 : err = journal_get_superblock(journal);
1263 [ # # ]: 0 : if (err)
1264 : : return err;
1265 : :
1266 : 0 : sb = journal->j_superblock;
1267 : :
1268 [ # # ]: 0 : journal->j_tail_sequence = be32_to_cpu(sb->s_sequence);
1269 [ # # ]: 0 : journal->j_tail = be32_to_cpu(sb->s_start);
1270 [ # # ]: 0 : journal->j_first = be32_to_cpu(sb->s_first);
1271 [ # # ]: 0 : journal->j_last = be32_to_cpu(sb->s_maxlen);
1272 [ # # ]: 0 : journal->j_errno = be32_to_cpu(sb->s_errno);
1273 : :
1274 : 0 : return 0;
1275 : : }
1276 : :
1277 : :
1278 : : /**
1279 : : * int journal_load() - Read journal from disk.
1280 : : * @journal: Journal to act on.
1281 : : *
1282 : : * Given a journal_t structure which tells us which disk blocks contain
1283 : : * a journal, read the journal from disk to initialise the in-memory
1284 : : * structures.
1285 : : */
1286 : 0 : int journal_load(journal_t *journal)
1287 : : {
1288 : : int err;
1289 : : journal_superblock_t *sb;
1290 : :
1291 : 0 : err = load_superblock(journal);
1292 [ # # ]: 0 : if (err)
1293 : : return err;
1294 : :
1295 : 0 : sb = journal->j_superblock;
1296 : : /* If this is a V2 superblock, then we have to check the
1297 : : * features flags on it. */
1298 : :
1299 [ # # ]: 0 : if (journal->j_format_version >= 2) {
1300 [ # # ]: 0 : if ((sb->s_feature_ro_compat &
1301 [ # # ]: 0 : ~cpu_to_be32(JFS_KNOWN_ROCOMPAT_FEATURES)) ||
1302 : 0 : (sb->s_feature_incompat &
1303 : : ~cpu_to_be32(JFS_KNOWN_INCOMPAT_FEATURES))) {
1304 : 0 : printk (KERN_WARNING
1305 : : "JBD: Unrecognised features on journal\n");
1306 : 0 : return -EINVAL;
1307 : : }
1308 : : }
1309 : :
1310 : : /* Let the recovery code check whether it needs to recover any
1311 : : * data from the journal. */
1312 [ # # ]: 0 : if (journal_recover(journal))
1313 : : goto recovery_error;
1314 : :
1315 : : /* OK, we've finished with the dynamic journal bits:
1316 : : * reinitialise the dynamic contents of the superblock in memory
1317 : : * and reset them on disk. */
1318 [ # # ]: 0 : if (journal_reset(journal))
1319 : : goto recovery_error;
1320 : :
1321 : 0 : journal->j_flags &= ~JFS_ABORT;
1322 : 0 : journal->j_flags |= JFS_LOADED;
1323 : 0 : return 0;
1324 : :
1325 : : recovery_error:
1326 : 0 : printk (KERN_WARNING "JBD: recovery failed\n");
1327 : 0 : return -EIO;
1328 : : }
1329 : :
1330 : : /**
1331 : : * void journal_destroy() - Release a journal_t structure.
1332 : : * @journal: Journal to act on.
1333 : : *
1334 : : * Release a journal_t structure once it is no longer in use by the
1335 : : * journaled object.
1336 : : * Return <0 if we couldn't clean up the journal.
1337 : : */
1338 : 0 : int journal_destroy(journal_t *journal)
1339 : : {
1340 : : int err = 0;
1341 : :
1342 : :
1343 : : /* Wait for the commit thread to wake up and die. */
1344 : 0 : journal_kill_thread(journal);
1345 : :
1346 : : /* Force a final log commit */
1347 [ # # ]: 0 : if (journal->j_running_transaction)
1348 : 0 : journal_commit_transaction(journal);
1349 : :
1350 : : /* Force any old transactions to disk */
1351 : :
1352 : : /* We cannot race with anybody but must keep assertions happy */
1353 : 0 : mutex_lock(&journal->j_checkpoint_mutex);
1354 : : /* Totally anal locking here... */
1355 : : spin_lock(&journal->j_list_lock);
1356 [ # # ]: 0 : while (journal->j_checkpoint_transactions != NULL) {
1357 : : spin_unlock(&journal->j_list_lock);
1358 : 0 : log_do_checkpoint(journal);
1359 : : spin_lock(&journal->j_list_lock);
1360 : : }
1361 : :
1362 [ # # ]: 0 : J_ASSERT(journal->j_running_transaction == NULL);
1363 [ # # ]: 0 : J_ASSERT(journal->j_committing_transaction == NULL);
1364 [ # # ]: 0 : J_ASSERT(journal->j_checkpoint_transactions == NULL);
1365 : : spin_unlock(&journal->j_list_lock);
1366 : :
1367 [ # # ]: 0 : if (journal->j_sb_buffer) {
1368 [ # # ]: 0 : if (!is_journal_aborted(journal)) {
1369 : 0 : journal->j_tail_sequence =
1370 : 0 : ++journal->j_transaction_sequence;
1371 : 0 : mark_journal_empty(journal);
1372 : : } else
1373 : : err = -EIO;
1374 : 0 : brelse(journal->j_sb_buffer);
1375 : : }
1376 : 0 : mutex_unlock(&journal->j_checkpoint_mutex);
1377 : :
1378 [ # # ]: 0 : if (journal->j_inode)
1379 : 0 : iput(journal->j_inode);
1380 [ # # ]: 0 : if (journal->j_revoke)
1381 : 0 : journal_destroy_revoke(journal);
1382 : 0 : kfree(journal->j_wbuf);
1383 : 0 : kfree(journal);
1384 : :
1385 : 0 : return err;
1386 : : }
1387 : :
1388 : :
1389 : : /**
1390 : : *int journal_check_used_features () - Check if features specified are used.
1391 : : * @journal: Journal to check.
1392 : : * @compat: bitmask of compatible features
1393 : : * @ro: bitmask of features that force read-only mount
1394 : : * @incompat: bitmask of incompatible features
1395 : : *
1396 : : * Check whether the journal uses all of a given set of
1397 : : * features. Return true (non-zero) if it does.
1398 : : **/
1399 : :
1400 : 0 : int journal_check_used_features (journal_t *journal, unsigned long compat,
1401 : : unsigned long ro, unsigned long incompat)
1402 : : {
1403 : : journal_superblock_t *sb;
1404 : :
1405 [ # # ]: 0 : if (!compat && !ro && !incompat)
1406 : : return 1;
1407 [ # # ]: 0 : if (journal->j_format_version == 1)
1408 : : return 0;
1409 : :
1410 : 0 : sb = journal->j_superblock;
1411 : :
1412 [ # # ][ # # ]: 0 : if (((be32_to_cpu(sb->s_feature_compat) & compat) == compat) &&
[ # # ]
1413 [ # # ][ # # ]: 0 : ((be32_to_cpu(sb->s_feature_ro_compat) & ro) == ro) &&
1414 [ # # ]: 0 : ((be32_to_cpu(sb->s_feature_incompat) & incompat) == incompat))
1415 : : return 1;
1416 : :
1417 : 0 : return 0;
1418 : : }
1419 : :
1420 : : /**
1421 : : * int journal_check_available_features() - Check feature set in journalling layer
1422 : : * @journal: Journal to check.
1423 : : * @compat: bitmask of compatible features
1424 : : * @ro: bitmask of features that force read-only mount
1425 : : * @incompat: bitmask of incompatible features
1426 : : *
1427 : : * Check whether the journaling code supports the use of
1428 : : * all of a given set of features on this journal. Return true
1429 : : * (non-zero) if it can. */
1430 : :
1431 : 0 : int journal_check_available_features (journal_t *journal, unsigned long compat,
1432 : : unsigned long ro, unsigned long incompat)
1433 : : {
1434 [ # # ][ # # ]: 0 : if (!compat && !ro && !incompat)
1435 : : return 1;
1436 : :
1437 : : /* We can support any known requested features iff the
1438 : : * superblock is in version 2. Otherwise we fail to support any
1439 : : * extended sb features. */
1440 : :
1441 [ # # ][ # # ]: 0 : if (journal->j_format_version != 2)
1442 : : return 0;
1443 : :
1444 [ # # ][ # # ]: 0 : if ((compat & JFS_KNOWN_COMPAT_FEATURES) == compat &&
1445 [ # # ][ # # ]: 0 : (ro & JFS_KNOWN_ROCOMPAT_FEATURES) == ro &&
1446 : 0 : (incompat & JFS_KNOWN_INCOMPAT_FEATURES) == incompat)
1447 : : return 1;
1448 : :
1449 : 0 : return 0;
1450 : : }
1451 : :
1452 : : /**
1453 : : * int journal_set_features () - Mark a given journal feature in the superblock
1454 : : * @journal: Journal to act on.
1455 : : * @compat: bitmask of compatible features
1456 : : * @ro: bitmask of features that force read-only mount
1457 : : * @incompat: bitmask of incompatible features
1458 : : *
1459 : : * Mark a given journal feature as present on the
1460 : : * superblock. Returns true if the requested features could be set.
1461 : : *
1462 : : */
1463 : :
1464 : 0 : int journal_set_features (journal_t *journal, unsigned long compat,
1465 : : unsigned long ro, unsigned long incompat)
1466 : : {
1467 : : journal_superblock_t *sb;
1468 : :
1469 [ # # ]: 0 : if (journal_check_used_features(journal, compat, ro, incompat))
1470 : : return 1;
1471 : :
1472 [ # # ]: 0 : if (!journal_check_available_features(journal, compat, ro, incompat))
1473 : : return 0;
1474 : :
1475 : : jbd_debug(1, "Setting new features 0x%lx/0x%lx/0x%lx\n",
1476 : : compat, ro, incompat);
1477 : :
1478 : 0 : sb = journal->j_superblock;
1479 : :
1480 [ # # ]: 0 : sb->s_feature_compat |= cpu_to_be32(compat);
1481 [ # # ]: 0 : sb->s_feature_ro_compat |= cpu_to_be32(ro);
1482 [ # # ]: 0 : sb->s_feature_incompat |= cpu_to_be32(incompat);
1483 : :
1484 : 0 : return 1;
1485 : : }
1486 : :
1487 : :
1488 : : /**
1489 : : * int journal_update_format () - Update on-disk journal structure.
1490 : : * @journal: Journal to act on.
1491 : : *
1492 : : * Given an initialised but unloaded journal struct, poke about in the
1493 : : * on-disk structure to update it to the most recent supported version.
1494 : : */
1495 : 0 : int journal_update_format (journal_t *journal)
1496 : : {
1497 : : journal_superblock_t *sb;
1498 : : int err;
1499 : :
1500 : 0 : err = journal_get_superblock(journal);
1501 [ # # ]: 0 : if (err)
1502 : : return err;
1503 : :
1504 : 0 : sb = journal->j_superblock;
1505 : :
1506 [ # # ]: 0 : switch (be32_to_cpu(sb->s_header.h_blocktype)) {
[ # # # ]
1507 : : case JFS_SUPERBLOCK_V2:
1508 : : return 0;
1509 : : case JFS_SUPERBLOCK_V1:
1510 : 0 : return journal_convert_superblock_v1(journal, sb);
1511 : : default:
1512 : : break;
1513 : : }
1514 : 0 : return -EINVAL;
1515 : : }
1516 : :
1517 : 0 : static int journal_convert_superblock_v1(journal_t *journal,
1518 : : journal_superblock_t *sb)
1519 : : {
1520 : : int offset, blocksize;
1521 : : struct buffer_head *bh;
1522 : :
1523 : 0 : printk(KERN_WARNING
1524 : : "JBD: Converting superblock from version 1 to 2.\n");
1525 : :
1526 : : /* Pre-initialise new fields to zero */
1527 : : offset = ((char *) &(sb->s_feature_compat)) - ((char *) sb);
1528 [ # # ]: 0 : blocksize = be32_to_cpu(sb->s_blocksize);
1529 [ # # ]: 0 : memset(&sb->s_feature_compat, 0, blocksize-offset);
1530 : :
1531 : 0 : sb->s_nr_users = cpu_to_be32(1);
1532 : 0 : sb->s_header.h_blocktype = cpu_to_be32(JFS_SUPERBLOCK_V2);
1533 : 0 : journal->j_format_version = 2;
1534 : :
1535 : 0 : bh = journal->j_sb_buffer;
1536 : : BUFFER_TRACE(bh, "marking dirty");
1537 : 0 : mark_buffer_dirty(bh);
1538 : 0 : sync_dirty_buffer(bh);
1539 : 0 : return 0;
1540 : : }
1541 : :
1542 : :
1543 : : /**
1544 : : * int journal_flush () - Flush journal
1545 : : * @journal: Journal to act on.
1546 : : *
1547 : : * Flush all data for a given journal to disk and empty the journal.
1548 : : * Filesystems can use this when remounting readonly to ensure that
1549 : : * recovery does not need to happen on remount.
1550 : : */
1551 : :
1552 : 0 : int journal_flush(journal_t *journal)
1553 : : {
1554 : : int err = 0;
1555 : : transaction_t *transaction = NULL;
1556 : :
1557 : : spin_lock(&journal->j_state_lock);
1558 : :
1559 : : /* Force everything buffered to the log... */
1560 [ # # ]: 0 : if (journal->j_running_transaction) {
1561 : : transaction = journal->j_running_transaction;
1562 : 0 : __log_start_commit(journal, transaction->t_tid);
1563 [ # # ]: 0 : } else if (journal->j_committing_transaction)
1564 : : transaction = journal->j_committing_transaction;
1565 : :
1566 : : /* Wait for the log commit to complete... */
1567 [ # # ]: 0 : if (transaction) {
1568 : 0 : tid_t tid = transaction->t_tid;
1569 : :
1570 : : spin_unlock(&journal->j_state_lock);
1571 : 0 : log_wait_commit(journal, tid);
1572 : : } else {
1573 : : spin_unlock(&journal->j_state_lock);
1574 : : }
1575 : :
1576 : : /* ...and flush everything in the log out to disk. */
1577 : : spin_lock(&journal->j_list_lock);
1578 [ # # ][ # # ]: 0 : while (!err && journal->j_checkpoint_transactions != NULL) {
1579 : : spin_unlock(&journal->j_list_lock);
1580 : 0 : mutex_lock(&journal->j_checkpoint_mutex);
1581 : 0 : err = log_do_checkpoint(journal);
1582 : 0 : mutex_unlock(&journal->j_checkpoint_mutex);
1583 : : spin_lock(&journal->j_list_lock);
1584 : : }
1585 : : spin_unlock(&journal->j_list_lock);
1586 : :
1587 [ # # ]: 0 : if (is_journal_aborted(journal))
1588 : : return -EIO;
1589 : :
1590 : 0 : mutex_lock(&journal->j_checkpoint_mutex);
1591 : 0 : cleanup_journal_tail(journal);
1592 : :
1593 : : /* Finally, mark the journal as really needing no recovery.
1594 : : * This sets s_start==0 in the underlying superblock, which is
1595 : : * the magic code for a fully-recovered superblock. Any future
1596 : : * commits of data to the journal will restore the current
1597 : : * s_start value. */
1598 : 0 : mark_journal_empty(journal);
1599 : 0 : mutex_unlock(&journal->j_checkpoint_mutex);
1600 : : spin_lock(&journal->j_state_lock);
1601 [ # # ]: 0 : J_ASSERT(!journal->j_running_transaction);
1602 [ # # ]: 0 : J_ASSERT(!journal->j_committing_transaction);
1603 [ # # ]: 0 : J_ASSERT(!journal->j_checkpoint_transactions);
1604 [ # # ]: 0 : J_ASSERT(journal->j_head == journal->j_tail);
1605 [ # # ]: 0 : J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence);
1606 : : spin_unlock(&journal->j_state_lock);
1607 : 0 : return 0;
1608 : : }
1609 : :
1610 : : /**
1611 : : * int journal_wipe() - Wipe journal contents
1612 : : * @journal: Journal to act on.
1613 : : * @write: flag (see below)
1614 : : *
1615 : : * Wipe out all of the contents of a journal, safely. This will produce
1616 : : * a warning if the journal contains any valid recovery information.
1617 : : * Must be called between journal_init_*() and journal_load().
1618 : : *
1619 : : * If 'write' is non-zero, then we wipe out the journal on disk; otherwise
1620 : : * we merely suppress recovery.
1621 : : */
1622 : :
1623 : 0 : int journal_wipe(journal_t *journal, int write)
1624 : : {
1625 : : int err = 0;
1626 : :
1627 [ # # ]: 0 : J_ASSERT (!(journal->j_flags & JFS_LOADED));
1628 : :
1629 : 0 : err = load_superblock(journal);
1630 [ # # ]: 0 : if (err)
1631 : : return err;
1632 : :
1633 [ # # ]: 0 : if (!journal->j_tail)
1634 : : goto no_recovery;
1635 : :
1636 [ # # ]: 0 : printk (KERN_WARNING "JBD: %s recovery information on journal\n",
1637 : : write ? "Clearing" : "Ignoring");
1638 : :
1639 : 0 : err = journal_skip_recovery(journal);
1640 [ # # ]: 0 : if (write) {
1641 : : /* Lock to make assertions happy... */
1642 : 0 : mutex_lock(&journal->j_checkpoint_mutex);
1643 : 0 : mark_journal_empty(journal);
1644 : 0 : mutex_unlock(&journal->j_checkpoint_mutex);
1645 : : }
1646 : :
1647 : : no_recovery:
1648 : 0 : return err;
1649 : : }
1650 : :
1651 : : /*
1652 : : * journal_dev_name: format a character string to describe on what
1653 : : * device this journal is present.
1654 : : */
1655 : :
1656 : : static const char *journal_dev_name(journal_t *journal, char *buffer)
1657 : : {
1658 : : struct block_device *bdev;
1659 : :
1660 [ # # ][ # # ]: 0 : if (journal->j_inode)
[ # # ]
1661 : 0 : bdev = journal->j_inode->i_sb->s_bdev;
1662 : : else
1663 : : bdev = journal->j_dev;
1664 : :
1665 : 0 : return bdevname(bdev, buffer);
1666 : : }
1667 : :
1668 : : /*
1669 : : * Journal abort has very specific semantics, which we describe
1670 : : * for journal abort.
1671 : : *
1672 : : * Two internal function, which provide abort to te jbd layer
1673 : : * itself are here.
1674 : : */
1675 : :
1676 : : /*
1677 : : * Quick version for internal journal use (doesn't lock the journal).
1678 : : * Aborts hard --- we mark the abort as occurred, but do _nothing_ else,
1679 : : * and don't attempt to make any other journal updates.
1680 : : */
1681 : 0 : static void __journal_abort_hard(journal_t *journal)
1682 : : {
1683 : : transaction_t *transaction;
1684 : : char b[BDEVNAME_SIZE];
1685 : :
1686 [ # # ]: 0 : if (journal->j_flags & JFS_ABORT)
1687 : 0 : return;
1688 : :
1689 : 0 : printk(KERN_ERR "Aborting journal on device %s.\n",
1690 : : journal_dev_name(journal, b));
1691 : :
1692 : : spin_lock(&journal->j_state_lock);
1693 : 0 : journal->j_flags |= JFS_ABORT;
1694 : 0 : transaction = journal->j_running_transaction;
1695 [ # # ]: 0 : if (transaction)
1696 : 0 : __log_start_commit(journal, transaction->t_tid);
1697 : : spin_unlock(&journal->j_state_lock);
1698 : : }
1699 : :
1700 : : /* Soft abort: record the abort error status in the journal superblock,
1701 : : * but don't do any other IO. */
1702 : 0 : static void __journal_abort_soft (journal_t *journal, int errno)
1703 : : {
1704 [ # # ]: 0 : if (journal->j_flags & JFS_ABORT)
1705 : 0 : return;
1706 : :
1707 [ # # ]: 0 : if (!journal->j_errno)
1708 : 0 : journal->j_errno = errno;
1709 : :
1710 : 0 : __journal_abort_hard(journal);
1711 : :
1712 [ # # ]: 0 : if (errno)
1713 : 0 : journal_update_sb_errno(journal);
1714 : : }
1715 : :
1716 : : /**
1717 : : * void journal_abort () - Shutdown the journal immediately.
1718 : : * @journal: the journal to shutdown.
1719 : : * @errno: an error number to record in the journal indicating
1720 : : * the reason for the shutdown.
1721 : : *
1722 : : * Perform a complete, immediate shutdown of the ENTIRE
1723 : : * journal (not of a single transaction). This operation cannot be
1724 : : * undone without closing and reopening the journal.
1725 : : *
1726 : : * The journal_abort function is intended to support higher level error
1727 : : * recovery mechanisms such as the ext2/ext3 remount-readonly error
1728 : : * mode.
1729 : : *
1730 : : * Journal abort has very specific semantics. Any existing dirty,
1731 : : * unjournaled buffers in the main filesystem will still be written to
1732 : : * disk by bdflush, but the journaling mechanism will be suspended
1733 : : * immediately and no further transaction commits will be honoured.
1734 : : *
1735 : : * Any dirty, journaled buffers will be written back to disk without
1736 : : * hitting the journal. Atomicity cannot be guaranteed on an aborted
1737 : : * filesystem, but we _do_ attempt to leave as much data as possible
1738 : : * behind for fsck to use for cleanup.
1739 : : *
1740 : : * Any attempt to get a new transaction handle on a journal which is in
1741 : : * ABORT state will just result in an -EROFS error return. A
1742 : : * journal_stop on an existing handle will return -EIO if we have
1743 : : * entered abort state during the update.
1744 : : *
1745 : : * Recursive transactions are not disturbed by journal abort until the
1746 : : * final journal_stop, which will receive the -EIO error.
1747 : : *
1748 : : * Finally, the journal_abort call allows the caller to supply an errno
1749 : : * which will be recorded (if possible) in the journal superblock. This
1750 : : * allows a client to record failure conditions in the middle of a
1751 : : * transaction without having to complete the transaction to record the
1752 : : * failure to disk. ext3_error, for example, now uses this
1753 : : * functionality.
1754 : : *
1755 : : * Errors which originate from within the journaling layer will NOT
1756 : : * supply an errno; a null errno implies that absolutely no further
1757 : : * writes are done to the journal (unless there are any already in
1758 : : * progress).
1759 : : *
1760 : : */
1761 : :
1762 : 0 : void journal_abort(journal_t *journal, int errno)
1763 : : {
1764 : 0 : __journal_abort_soft(journal, errno);
1765 : 0 : }
1766 : :
1767 : : /**
1768 : : * int journal_errno () - returns the journal's error state.
1769 : : * @journal: journal to examine.
1770 : : *
1771 : : * This is the errno numbet set with journal_abort(), the last
1772 : : * time the journal was mounted - if the journal was stopped
1773 : : * without calling abort this will be 0.
1774 : : *
1775 : : * If the journal has been aborted on this mount time -EROFS will
1776 : : * be returned.
1777 : : */
1778 : 0 : int journal_errno(journal_t *journal)
1779 : : {
1780 : : int err;
1781 : :
1782 : : spin_lock(&journal->j_state_lock);
1783 [ # # ]: 0 : if (journal->j_flags & JFS_ABORT)
1784 : : err = -EROFS;
1785 : : else
1786 : 0 : err = journal->j_errno;
1787 : : spin_unlock(&journal->j_state_lock);
1788 : 0 : return err;
1789 : : }
1790 : :
1791 : : /**
1792 : : * int journal_clear_err () - clears the journal's error state
1793 : : * @journal: journal to act on.
1794 : : *
1795 : : * An error must be cleared or Acked to take a FS out of readonly
1796 : : * mode.
1797 : : */
1798 : 0 : int journal_clear_err(journal_t *journal)
1799 : : {
1800 : : int err = 0;
1801 : :
1802 : : spin_lock(&journal->j_state_lock);
1803 [ # # ]: 0 : if (journal->j_flags & JFS_ABORT)
1804 : : err = -EROFS;
1805 : : else
1806 : 0 : journal->j_errno = 0;
1807 : : spin_unlock(&journal->j_state_lock);
1808 : 0 : return err;
1809 : : }
1810 : :
1811 : : /**
1812 : : * void journal_ack_err() - Ack journal err.
1813 : : * @journal: journal to act on.
1814 : : *
1815 : : * An error must be cleared or Acked to take a FS out of readonly
1816 : : * mode.
1817 : : */
1818 : 0 : void journal_ack_err(journal_t *journal)
1819 : : {
1820 : : spin_lock(&journal->j_state_lock);
1821 [ # # ]: 0 : if (journal->j_errno)
1822 : 0 : journal->j_flags |= JFS_ACK_ERR;
1823 : : spin_unlock(&journal->j_state_lock);
1824 : 0 : }
1825 : :
1826 : 0 : int journal_blocks_per_page(struct inode *inode)
1827 : : {
1828 : 0 : return 1 << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
1829 : : }
1830 : :
1831 : : /*
1832 : : * Journal_head storage management
1833 : : */
1834 : : static struct kmem_cache *journal_head_cache;
1835 : : #ifdef CONFIG_JBD_DEBUG
1836 : : static atomic_t nr_journal_heads = ATOMIC_INIT(0);
1837 : : #endif
1838 : :
1839 : 0 : static int journal_init_journal_head_cache(void)
1840 : : {
1841 : : int retval;
1842 : :
1843 [ # # ]: 0 : J_ASSERT(journal_head_cache == NULL);
1844 : 0 : journal_head_cache = kmem_cache_create("journal_head",
1845 : : sizeof(struct journal_head),
1846 : : 0, /* offset */
1847 : : SLAB_TEMPORARY, /* flags */
1848 : : NULL); /* ctor */
1849 : : retval = 0;
1850 [ # # ]: 0 : if (!journal_head_cache) {
1851 : : retval = -ENOMEM;
1852 : 0 : printk(KERN_EMERG "JBD: no memory for journal_head cache\n");
1853 : : }
1854 : 0 : return retval;
1855 : : }
1856 : :
1857 : : static void journal_destroy_journal_head_cache(void)
1858 : : {
1859 [ # # ]: 0 : if (journal_head_cache) {
1860 : 0 : kmem_cache_destroy(journal_head_cache);
1861 : 0 : journal_head_cache = NULL;
1862 : : }
1863 : : }
1864 : :
1865 : : /*
1866 : : * journal_head splicing and dicing
1867 : : */
1868 : 0 : static struct journal_head *journal_alloc_journal_head(void)
1869 : : {
1870 : : struct journal_head *ret;
1871 : :
1872 : : #ifdef CONFIG_JBD_DEBUG
1873 : : atomic_inc(&nr_journal_heads);
1874 : : #endif
1875 : 0 : ret = kmem_cache_zalloc(journal_head_cache, GFP_NOFS);
1876 [ # # ]: 0 : if (ret == NULL) {
1877 : : jbd_debug(1, "out of memory for journal_head\n");
1878 [ # # ]: 0 : printk_ratelimited(KERN_NOTICE "ENOMEM in %s, retrying.\n",
1879 : : __func__);
1880 : :
1881 [ # # ]: 0 : while (ret == NULL) {
1882 : 0 : yield();
1883 : 0 : ret = kmem_cache_zalloc(journal_head_cache, GFP_NOFS);
1884 : : }
1885 : : }
1886 : 0 : return ret;
1887 : : }
1888 : :
1889 : : static void journal_free_journal_head(struct journal_head *jh)
1890 : : {
1891 : : #ifdef CONFIG_JBD_DEBUG
1892 : : atomic_dec(&nr_journal_heads);
1893 : : memset(jh, JBD_POISON_FREE, sizeof(*jh));
1894 : : #endif
1895 : 0 : kmem_cache_free(journal_head_cache, jh);
1896 : : }
1897 : :
1898 : : /*
1899 : : * A journal_head is attached to a buffer_head whenever JBD has an
1900 : : * interest in the buffer.
1901 : : *
1902 : : * Whenever a buffer has an attached journal_head, its ->b_state:BH_JBD bit
1903 : : * is set. This bit is tested in core kernel code where we need to take
1904 : : * JBD-specific actions. Testing the zeroness of ->b_private is not reliable
1905 : : * there.
1906 : : *
1907 : : * When a buffer has its BH_JBD bit set, its ->b_count is elevated by one.
1908 : : *
1909 : : * When a buffer has its BH_JBD bit set it is immune from being released by
1910 : : * core kernel code, mainly via ->b_count.
1911 : : *
1912 : : * A journal_head is detached from its buffer_head when the journal_head's
1913 : : * b_jcount reaches zero. Running transaction (b_transaction) and checkpoint
1914 : : * transaction (b_cp_transaction) hold their references to b_jcount.
1915 : : *
1916 : : * Various places in the kernel want to attach a journal_head to a buffer_head
1917 : : * _before_ attaching the journal_head to a transaction. To protect the
1918 : : * journal_head in this situation, journal_add_journal_head elevates the
1919 : : * journal_head's b_jcount refcount by one. The caller must call
1920 : : * journal_put_journal_head() to undo this.
1921 : : *
1922 : : * So the typical usage would be:
1923 : : *
1924 : : * (Attach a journal_head if needed. Increments b_jcount)
1925 : : * struct journal_head *jh = journal_add_journal_head(bh);
1926 : : * ...
1927 : : * (Get another reference for transaction)
1928 : : * journal_grab_journal_head(bh);
1929 : : * jh->b_transaction = xxx;
1930 : : * (Put original reference)
1931 : : * journal_put_journal_head(jh);
1932 : : */
1933 : :
1934 : : /*
1935 : : * Give a buffer_head a journal_head.
1936 : : *
1937 : : * May sleep.
1938 : : */
1939 : 0 : struct journal_head *journal_add_journal_head(struct buffer_head *bh)
1940 : : {
1941 : : struct journal_head *jh;
1942 : : struct journal_head *new_jh = NULL;
1943 : :
1944 : : repeat:
1945 [ # # ]: 0 : if (!buffer_jbd(bh))
1946 : 0 : new_jh = journal_alloc_journal_head();
1947 : :
1948 : : jbd_lock_bh_journal_head(bh);
1949 [ # # ]: 0 : if (buffer_jbd(bh)) {
1950 : : jh = bh2jh(bh);
1951 : : } else {
1952 [ # # ][ # # ]: 0 : J_ASSERT_BH(bh,
[ # # ][ # # ]
1953 : : (atomic_read(&bh->b_count) > 0) ||
1954 : : (bh->b_page && bh->b_page->mapping));
1955 : :
1956 [ # # ]: 0 : if (!new_jh) {
1957 : : jbd_unlock_bh_journal_head(bh);
1958 : : goto repeat;
1959 : : }
1960 : :
1961 : : jh = new_jh;
1962 : : new_jh = NULL; /* We consumed it */
1963 : : set_buffer_jbd(bh);
1964 : 0 : bh->b_private = jh;
1965 : 0 : jh->b_bh = bh;
1966 : : get_bh(bh);
1967 : : BUFFER_TRACE(bh, "added journal_head");
1968 : : }
1969 : 0 : jh->b_jcount++;
1970 : : jbd_unlock_bh_journal_head(bh);
1971 [ # # ]: 0 : if (new_jh)
1972 : : journal_free_journal_head(new_jh);
1973 : 0 : return bh->b_private;
1974 : : }
1975 : :
1976 : : /*
1977 : : * Grab a ref against this buffer_head's journal_head. If it ended up not
1978 : : * having a journal_head, return NULL
1979 : : */
1980 : 0 : struct journal_head *journal_grab_journal_head(struct buffer_head *bh)
1981 : : {
1982 : : struct journal_head *jh = NULL;
1983 : :
1984 : : jbd_lock_bh_journal_head(bh);
1985 [ # # ]: 0 : if (buffer_jbd(bh)) {
1986 : : jh = bh2jh(bh);
1987 : 0 : jh->b_jcount++;
1988 : : }
1989 : : jbd_unlock_bh_journal_head(bh);
1990 : 0 : return jh;
1991 : : }
1992 : :
1993 : 0 : static void __journal_remove_journal_head(struct buffer_head *bh)
1994 : : {
1995 : 0 : struct journal_head *jh = bh2jh(bh);
1996 : :
1997 [ # # ]: 0 : J_ASSERT_JH(jh, jh->b_jcount >= 0);
1998 [ # # ]: 0 : J_ASSERT_JH(jh, jh->b_transaction == NULL);
1999 [ # # ]: 0 : J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
2000 [ # # ]: 0 : J_ASSERT_JH(jh, jh->b_cp_transaction == NULL);
2001 [ # # ]: 0 : J_ASSERT_JH(jh, jh->b_jlist == BJ_None);
2002 [ # # ]: 0 : J_ASSERT_BH(bh, buffer_jbd(bh));
2003 [ # # ]: 0 : J_ASSERT_BH(bh, jh2bh(jh) == bh);
2004 : : BUFFER_TRACE(bh, "remove journal_head");
2005 [ # # ]: 0 : if (jh->b_frozen_data) {
2006 : 0 : printk(KERN_WARNING "%s: freeing b_frozen_data\n", __func__);
2007 : 0 : jbd_free(jh->b_frozen_data, bh->b_size);
2008 : : }
2009 [ # # ]: 0 : if (jh->b_committed_data) {
2010 : 0 : printk(KERN_WARNING "%s: freeing b_committed_data\n", __func__);
2011 : 0 : jbd_free(jh->b_committed_data, bh->b_size);
2012 : : }
2013 : 0 : bh->b_private = NULL;
2014 : 0 : jh->b_bh = NULL; /* debug, really */
2015 : : clear_buffer_jbd(bh);
2016 : : journal_free_journal_head(jh);
2017 : 0 : }
2018 : :
2019 : : /*
2020 : : * Drop a reference on the passed journal_head. If it fell to zero then
2021 : : * release the journal_head from the buffer_head.
2022 : : */
2023 : 0 : void journal_put_journal_head(struct journal_head *jh)
2024 : : {
2025 : : struct buffer_head *bh = jh2bh(jh);
2026 : :
2027 : : jbd_lock_bh_journal_head(bh);
2028 [ # # ]: 0 : J_ASSERT_JH(jh, jh->b_jcount > 0);
2029 : 0 : --jh->b_jcount;
2030 [ # # ]: 0 : if (!jh->b_jcount) {
2031 : 0 : __journal_remove_journal_head(bh);
2032 : : jbd_unlock_bh_journal_head(bh);
2033 : 0 : __brelse(bh);
2034 : : } else
2035 : : jbd_unlock_bh_journal_head(bh);
2036 : 0 : }
2037 : :
2038 : : /*
2039 : : * debugfs tunables
2040 : : */
2041 : : #ifdef CONFIG_JBD_DEBUG
2042 : :
2043 : : u8 journal_enable_debug __read_mostly;
2044 : : EXPORT_SYMBOL(journal_enable_debug);
2045 : :
2046 : : static struct dentry *jbd_debugfs_dir;
2047 : : static struct dentry *jbd_debug;
2048 : :
2049 : : static void __init jbd_create_debugfs_entry(void)
2050 : : {
2051 : : jbd_debugfs_dir = debugfs_create_dir("jbd", NULL);
2052 : : if (jbd_debugfs_dir)
2053 : : jbd_debug = debugfs_create_u8("jbd-debug", S_IRUGO | S_IWUSR,
2054 : : jbd_debugfs_dir,
2055 : : &journal_enable_debug);
2056 : : }
2057 : :
2058 : : static void __exit jbd_remove_debugfs_entry(void)
2059 : : {
2060 : : debugfs_remove(jbd_debug);
2061 : : debugfs_remove(jbd_debugfs_dir);
2062 : : }
2063 : :
2064 : : #else
2065 : :
2066 : : static inline void jbd_create_debugfs_entry(void)
2067 : : {
2068 : : }
2069 : :
2070 : : static inline void jbd_remove_debugfs_entry(void)
2071 : : {
2072 : : }
2073 : :
2074 : : #endif
2075 : :
2076 : : struct kmem_cache *jbd_handle_cache;
2077 : :
2078 : 0 : static int __init journal_init_handle_cache(void)
2079 : : {
2080 : 0 : jbd_handle_cache = kmem_cache_create("journal_handle",
2081 : : sizeof(handle_t),
2082 : : 0, /* offset */
2083 : : SLAB_TEMPORARY, /* flags */
2084 : : NULL); /* ctor */
2085 [ # # ]: 0 : if (jbd_handle_cache == NULL) {
2086 : 0 : printk(KERN_EMERG "JBD: failed to create handle cache\n");
2087 : 0 : return -ENOMEM;
2088 : : }
2089 : : return 0;
2090 : : }
2091 : :
2092 : : static void journal_destroy_handle_cache(void)
2093 : : {
2094 [ # # ]: 0 : if (jbd_handle_cache)
2095 : 0 : kmem_cache_destroy(jbd_handle_cache);
2096 : : }
2097 : :
2098 : : /*
2099 : : * Module startup and shutdown
2100 : : */
2101 : :
2102 : 0 : static int __init journal_init_caches(void)
2103 : : {
2104 : : int ret;
2105 : :
2106 : 0 : ret = journal_init_revoke_caches();
2107 [ # # ]: 0 : if (ret == 0)
2108 : 0 : ret = journal_init_journal_head_cache();
2109 [ # # ]: 0 : if (ret == 0)
2110 : 0 : ret = journal_init_handle_cache();
2111 : 0 : return ret;
2112 : : }
2113 : :
2114 : 0 : static void journal_destroy_caches(void)
2115 : : {
2116 : 0 : journal_destroy_revoke_caches();
2117 : : journal_destroy_journal_head_cache();
2118 : : journal_destroy_handle_cache();
2119 : 0 : }
2120 : :
2121 : 0 : static int __init journal_init(void)
2122 : : {
2123 : : int ret;
2124 : :
2125 : : BUILD_BUG_ON(sizeof(struct journal_superblock_s) != 1024);
2126 : :
2127 : 0 : ret = journal_init_caches();
2128 [ # # ]: 0 : if (ret != 0)
2129 : 0 : journal_destroy_caches();
2130 : : jbd_create_debugfs_entry();
2131 : 0 : return ret;
2132 : : }
2133 : :
2134 : 0 : static void __exit journal_exit(void)
2135 : : {
2136 : : #ifdef CONFIG_JBD_DEBUG
2137 : : int n = atomic_read(&nr_journal_heads);
2138 : : if (n)
2139 : : printk(KERN_EMERG "JBD: leaked %d journal_heads!\n", n);
2140 : : #endif
2141 : : jbd_remove_debugfs_entry();
2142 : 0 : journal_destroy_caches();
2143 : 0 : }
2144 : :
2145 : : MODULE_LICENSE("GPL");
2146 : : module_init(journal_init);
2147 : : module_exit(journal_exit);
2148 : :
|
