blob: c03d4dce4d76a0751ae9eee57066a77f0bfb0fb6 [file] [log] [blame]
Dave Kleikamp470decc2006-10-11 01:20:57 -07001/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002 * linux/fs/jbd2/journal.c
Dave Kleikamp470decc2006-10-11 01:20:57 -07003 *
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>
Mingming Caof7f4bcc2006-10-11 01:20:59 -070028#include <linux/jbd2.h>
Dave Kleikamp470decc2006-10-11 01:20:57 -070029#include <linux/errno.h>
30#include <linux/slab.h>
Dave Kleikamp470decc2006-10-11 01:20:57 -070031#include <linux/init.h>
32#include <linux/mm.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080033#include <linux/freezer.h>
Dave Kleikamp470decc2006-10-11 01:20:57 -070034#include <linux/pagemap.h>
35#include <linux/kthread.h>
36#include <linux/poison.h>
37#include <linux/proc_fs.h>
Jose R. Santos0f49d5d2007-07-18 08:50:18 -040038#include <linux/debugfs.h>
Johann Lombardi8e85fb32008-01-28 23:58:27 -050039#include <linux/seq_file.h>
Simon Holm Thøgersenc225aa52009-01-11 22:34:01 -050040#include <linux/math64.h>
Theodore Ts'o879c5e62009-06-17 11:47:48 -040041#include <linux/hash.h>
Theodore Ts'od2eecb02009-12-07 10:36:20 -050042#include <linux/log2.h>
43#include <linux/vmalloc.h>
Theodore Ts'o879c5e62009-06-17 11:47:48 -040044
45#define CREATE_TRACE_POINTS
46#include <trace/events/jbd2.h>
Dave Kleikamp470decc2006-10-11 01:20:57 -070047
48#include <asm/uaccess.h>
49#include <asm/page.h>
50
Mingming Caof7f4bcc2006-10-11 01:20:59 -070051EXPORT_SYMBOL(jbd2_journal_start);
52EXPORT_SYMBOL(jbd2_journal_restart);
53EXPORT_SYMBOL(jbd2_journal_extend);
54EXPORT_SYMBOL(jbd2_journal_stop);
55EXPORT_SYMBOL(jbd2_journal_lock_updates);
56EXPORT_SYMBOL(jbd2_journal_unlock_updates);
57EXPORT_SYMBOL(jbd2_journal_get_write_access);
58EXPORT_SYMBOL(jbd2_journal_get_create_access);
59EXPORT_SYMBOL(jbd2_journal_get_undo_access);
Joel Beckere06c8222008-09-11 15:35:47 -070060EXPORT_SYMBOL(jbd2_journal_set_triggers);
Mingming Caof7f4bcc2006-10-11 01:20:59 -070061EXPORT_SYMBOL(jbd2_journal_dirty_metadata);
62EXPORT_SYMBOL(jbd2_journal_release_buffer);
63EXPORT_SYMBOL(jbd2_journal_forget);
Dave Kleikamp470decc2006-10-11 01:20:57 -070064#if 0
65EXPORT_SYMBOL(journal_sync_buffer);
66#endif
Mingming Caof7f4bcc2006-10-11 01:20:59 -070067EXPORT_SYMBOL(jbd2_journal_flush);
68EXPORT_SYMBOL(jbd2_journal_revoke);
Dave Kleikamp470decc2006-10-11 01:20:57 -070069
Mingming Caof7f4bcc2006-10-11 01:20:59 -070070EXPORT_SYMBOL(jbd2_journal_init_dev);
71EXPORT_SYMBOL(jbd2_journal_init_inode);
72EXPORT_SYMBOL(jbd2_journal_update_format);
73EXPORT_SYMBOL(jbd2_journal_check_used_features);
74EXPORT_SYMBOL(jbd2_journal_check_available_features);
75EXPORT_SYMBOL(jbd2_journal_set_features);
Mingming Caof7f4bcc2006-10-11 01:20:59 -070076EXPORT_SYMBOL(jbd2_journal_load);
77EXPORT_SYMBOL(jbd2_journal_destroy);
Mingming Caof7f4bcc2006-10-11 01:20:59 -070078EXPORT_SYMBOL(jbd2_journal_abort);
79EXPORT_SYMBOL(jbd2_journal_errno);
80EXPORT_SYMBOL(jbd2_journal_ack_err);
81EXPORT_SYMBOL(jbd2_journal_clear_err);
82EXPORT_SYMBOL(jbd2_log_wait_commit);
Theodore Ts'o3b799d12009-12-09 20:42:53 -050083EXPORT_SYMBOL(jbd2_log_start_commit);
Mingming Caof7f4bcc2006-10-11 01:20:59 -070084EXPORT_SYMBOL(jbd2_journal_start_commit);
85EXPORT_SYMBOL(jbd2_journal_force_commit_nested);
86EXPORT_SYMBOL(jbd2_journal_wipe);
87EXPORT_SYMBOL(jbd2_journal_blocks_per_page);
88EXPORT_SYMBOL(jbd2_journal_invalidatepage);
89EXPORT_SYMBOL(jbd2_journal_try_to_free_buffers);
90EXPORT_SYMBOL(jbd2_journal_force_commit);
Jan Karac851ed52008-07-11 19:27:31 -040091EXPORT_SYMBOL(jbd2_journal_file_inode);
92EXPORT_SYMBOL(jbd2_journal_init_jbd_inode);
93EXPORT_SYMBOL(jbd2_journal_release_jbd_inode);
94EXPORT_SYMBOL(jbd2_journal_begin_ordered_truncate);
Dave Kleikamp470decc2006-10-11 01:20:57 -070095
96static int journal_convert_superblock_v1(journal_t *, journal_superblock_t *);
97static void __journal_abort_soft (journal_t *journal, int errno);
Theodore Ts'od2eecb02009-12-07 10:36:20 -050098static int jbd2_journal_create_slab(size_t slab_size);
Dave Kleikamp470decc2006-10-11 01:20:57 -070099
100/*
101 * Helper function used to manage commit timeouts
102 */
103
104static void commit_timeout(unsigned long __data)
105{
106 struct task_struct * p = (struct task_struct *) __data;
107
108 wake_up_process(p);
109}
110
111/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700112 * kjournald2: The main thread function used to manage a logging device
Dave Kleikamp470decc2006-10-11 01:20:57 -0700113 * journal.
114 *
115 * This kernel thread is responsible for two things:
116 *
117 * 1) COMMIT: Every so often we need to commit the current state of the
118 * filesystem to disk. The journal thread is responsible for writing
119 * all of the metadata buffers to disk.
120 *
121 * 2) CHECKPOINT: We cannot reuse a used section of the log file until all
122 * of the data in that part of the log has been rewritten elsewhere on
123 * the disk. Flushing these old buffers to reclaim space in the log is
124 * known as checkpointing, and this thread is responsible for that job.
125 */
126
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700127static int kjournald2(void *arg)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700128{
129 journal_t *journal = arg;
130 transaction_t *transaction;
131
132 /*
133 * Set up an interval timer which can be used to trigger a commit wakeup
134 * after the commit interval expires
135 */
136 setup_timer(&journal->j_commit_timer, commit_timeout,
137 (unsigned long)current);
138
139 /* Record that the journal thread is running */
140 journal->j_task = current;
141 wake_up(&journal->j_wait_done_commit);
142
Dave Kleikamp470decc2006-10-11 01:20:57 -0700143 /*
144 * And now, wait forever for commit wakeup events.
145 */
146 spin_lock(&journal->j_state_lock);
147
148loop:
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700149 if (journal->j_flags & JBD2_UNMOUNT)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700150 goto end_loop;
151
152 jbd_debug(1, "commit_sequence=%d, commit_request=%d\n",
153 journal->j_commit_sequence, journal->j_commit_request);
154
155 if (journal->j_commit_sequence != journal->j_commit_request) {
156 jbd_debug(1, "OK, requests differ\n");
157 spin_unlock(&journal->j_state_lock);
158 del_timer_sync(&journal->j_commit_timer);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700159 jbd2_journal_commit_transaction(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700160 spin_lock(&journal->j_state_lock);
161 goto loop;
162 }
163
164 wake_up(&journal->j_wait_done_commit);
165 if (freezing(current)) {
166 /*
167 * The simpler the better. Flushing journal isn't a
168 * good idea, because that depends on threads that may
169 * be already stopped.
170 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700171 jbd_debug(1, "Now suspending kjournald2\n");
Dave Kleikamp470decc2006-10-11 01:20:57 -0700172 spin_unlock(&journal->j_state_lock);
173 refrigerator();
174 spin_lock(&journal->j_state_lock);
175 } else {
176 /*
177 * We assume on resume that commits are already there,
178 * so we don't sleep
179 */
180 DEFINE_WAIT(wait);
181 int should_sleep = 1;
182
183 prepare_to_wait(&journal->j_wait_commit, &wait,
184 TASK_INTERRUPTIBLE);
185 if (journal->j_commit_sequence != journal->j_commit_request)
186 should_sleep = 0;
187 transaction = journal->j_running_transaction;
188 if (transaction && time_after_eq(jiffies,
189 transaction->t_expires))
190 should_sleep = 0;
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700191 if (journal->j_flags & JBD2_UNMOUNT)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700192 should_sleep = 0;
193 if (should_sleep) {
194 spin_unlock(&journal->j_state_lock);
195 schedule();
196 spin_lock(&journal->j_state_lock);
197 }
198 finish_wait(&journal->j_wait_commit, &wait);
199 }
200
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700201 jbd_debug(1, "kjournald2 wakes\n");
Dave Kleikamp470decc2006-10-11 01:20:57 -0700202
203 /*
204 * Were we woken up by a commit wakeup event?
205 */
206 transaction = journal->j_running_transaction;
207 if (transaction && time_after_eq(jiffies, transaction->t_expires)) {
208 journal->j_commit_request = transaction->t_tid;
209 jbd_debug(1, "woke because of timeout\n");
210 }
211 goto loop;
212
213end_loop:
214 spin_unlock(&journal->j_state_lock);
215 del_timer_sync(&journal->j_commit_timer);
216 journal->j_task = NULL;
217 wake_up(&journal->j_wait_done_commit);
218 jbd_debug(1, "Journal thread exiting.\n");
219 return 0;
220}
221
Pavel Emelianov97f06782007-05-08 00:30:42 -0700222static int jbd2_journal_start_thread(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700223{
Pavel Emelianov97f06782007-05-08 00:30:42 -0700224 struct task_struct *t;
225
Theodore Ts'o90576c02009-09-29 15:51:30 -0400226 t = kthread_run(kjournald2, journal, "jbd2/%s",
227 journal->j_devname);
Pavel Emelianov97f06782007-05-08 00:30:42 -0700228 if (IS_ERR(t))
229 return PTR_ERR(t);
230
Al Viro1076d172008-03-29 03:07:18 +0000231 wait_event(journal->j_wait_done_commit, journal->j_task != NULL);
Pavel Emelianov97f06782007-05-08 00:30:42 -0700232 return 0;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700233}
234
235static void journal_kill_thread(journal_t *journal)
236{
237 spin_lock(&journal->j_state_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700238 journal->j_flags |= JBD2_UNMOUNT;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700239
240 while (journal->j_task) {
241 wake_up(&journal->j_wait_commit);
242 spin_unlock(&journal->j_state_lock);
Al Viro1076d172008-03-29 03:07:18 +0000243 wait_event(journal->j_wait_done_commit, journal->j_task == NULL);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700244 spin_lock(&journal->j_state_lock);
245 }
246 spin_unlock(&journal->j_state_lock);
247}
248
249/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700250 * jbd2_journal_write_metadata_buffer: write a metadata buffer to the journal.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700251 *
252 * Writes a metadata buffer to a given disk block. The actual IO is not
253 * performed but a new buffer_head is constructed which labels the data
254 * to be written with the correct destination disk block.
255 *
256 * Any magic-number escaping which needs to be done will cause a
257 * copy-out here. If the buffer happens to start with the
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700258 * JBD2_MAGIC_NUMBER, then we can't write it to the log directly: the
Dave Kleikamp470decc2006-10-11 01:20:57 -0700259 * magic number is only written to the log for descripter blocks. In
260 * this case, we copy the data and replace the first word with 0, and we
261 * return a result code which indicates that this buffer needs to be
262 * marked as an escaped buffer in the corresponding log descriptor
263 * block. The missing word can then be restored when the block is read
264 * during recovery.
265 *
266 * If the source buffer has already been modified by a new transaction
267 * since we took the last commit snapshot, we use the frozen copy of
268 * that data for IO. If we end up using the existing buffer_head's data
269 * for the write, then we *have* to lock the buffer to prevent anyone
270 * else from using and possibly modifying it while the IO is in
271 * progress.
272 *
273 * The function returns a pointer to the buffer_heads to be used for IO.
274 *
275 * We assume that the journal has already been locked in this function.
276 *
277 * Return value:
278 * <0: Error
279 * >=0: Finished OK
280 *
281 * On success:
282 * Bit 0 set == escape performed on the data
283 * Bit 1 set == buffer copy-out performed (kfree the data after IO)
284 */
285
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700286int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
Dave Kleikamp470decc2006-10-11 01:20:57 -0700287 struct journal_head *jh_in,
288 struct journal_head **jh_out,
Mingming Cao18eba7a2006-10-11 01:21:13 -0700289 unsigned long long blocknr)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700290{
291 int need_copy_out = 0;
292 int done_copy_out = 0;
293 int do_escape = 0;
294 char *mapped_data;
295 struct buffer_head *new_bh;
296 struct journal_head *new_jh;
297 struct page *new_page;
298 unsigned int new_offset;
299 struct buffer_head *bh_in = jh2bh(jh_in);
Joel Beckere06c8222008-09-11 15:35:47 -0700300 struct jbd2_buffer_trigger_type *triggers;
dingdinghua96577c42009-07-13 17:55:35 -0400301 journal_t *journal = transaction->t_journal;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700302
303 /*
304 * The buffer really shouldn't be locked: only the current committing
305 * transaction is allowed to write it, so nobody else is allowed
306 * to do any IO.
307 *
308 * akpm: except if we're journalling data, and write() output is
309 * also part of a shared mapping, and another thread has
310 * decided to launch a writepage() against this buffer.
311 */
312 J_ASSERT_BH(bh_in, buffer_jbddirty(bh_in));
313
314 new_bh = alloc_buffer_head(GFP_NOFS|__GFP_NOFAIL);
dingdinghua96577c42009-07-13 17:55:35 -0400315 /* keep subsequent assertions sane */
316 new_bh->b_state = 0;
317 init_buffer(new_bh, NULL, NULL);
318 atomic_set(&new_bh->b_count, 1);
319 new_jh = jbd2_journal_add_journal_head(new_bh); /* This sleeps */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700320
321 /*
322 * If a new transaction has already done a buffer copy-out, then
323 * we use that version of the data for the commit.
324 */
325 jbd_lock_bh_state(bh_in);
326repeat:
327 if (jh_in->b_frozen_data) {
328 done_copy_out = 1;
329 new_page = virt_to_page(jh_in->b_frozen_data);
330 new_offset = offset_in_page(jh_in->b_frozen_data);
Joel Beckere06c8222008-09-11 15:35:47 -0700331 triggers = jh_in->b_frozen_triggers;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700332 } else {
333 new_page = jh2bh(jh_in)->b_page;
334 new_offset = offset_in_page(jh2bh(jh_in)->b_data);
Joel Beckere06c8222008-09-11 15:35:47 -0700335 triggers = jh_in->b_triggers;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700336 }
337
338 mapped_data = kmap_atomic(new_page, KM_USER0);
339 /*
Joel Beckere06c8222008-09-11 15:35:47 -0700340 * Fire any commit trigger. Do this before checking for escaping,
341 * as the trigger may modify the magic offset. If a copy-out
342 * happens afterwards, it will have the correct data in the buffer.
343 */
344 jbd2_buffer_commit_trigger(jh_in, mapped_data + new_offset,
345 triggers);
346
347 /*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700348 * Check for escaping
349 */
350 if (*((__be32 *)(mapped_data + new_offset)) ==
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700351 cpu_to_be32(JBD2_MAGIC_NUMBER)) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700352 need_copy_out = 1;
353 do_escape = 1;
354 }
355 kunmap_atomic(mapped_data, KM_USER0);
356
357 /*
358 * Do we need to do a data copy?
359 */
360 if (need_copy_out && !done_copy_out) {
361 char *tmp;
362
363 jbd_unlock_bh_state(bh_in);
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400364 tmp = jbd2_alloc(bh_in->b_size, GFP_NOFS);
Theodore Ts'oe6ec1162009-12-01 09:04:42 -0500365 if (!tmp) {
366 jbd2_journal_put_journal_head(new_jh);
367 return -ENOMEM;
368 }
Dave Kleikamp470decc2006-10-11 01:20:57 -0700369 jbd_lock_bh_state(bh_in);
370 if (jh_in->b_frozen_data) {
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400371 jbd2_free(tmp, bh_in->b_size);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700372 goto repeat;
373 }
374
375 jh_in->b_frozen_data = tmp;
376 mapped_data = kmap_atomic(new_page, KM_USER0);
377 memcpy(tmp, mapped_data + new_offset, jh2bh(jh_in)->b_size);
378 kunmap_atomic(mapped_data, KM_USER0);
379
380 new_page = virt_to_page(tmp);
381 new_offset = offset_in_page(tmp);
382 done_copy_out = 1;
Joel Beckere06c8222008-09-11 15:35:47 -0700383
384 /*
385 * This isn't strictly necessary, as we're using frozen
386 * data for the escaping, but it keeps consistency with
387 * b_frozen_data usage.
388 */
389 jh_in->b_frozen_triggers = jh_in->b_triggers;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700390 }
391
392 /*
393 * Did we need to do an escaping? Now we've done all the
394 * copying, we can finally do so.
395 */
396 if (do_escape) {
397 mapped_data = kmap_atomic(new_page, KM_USER0);
398 *((unsigned int *)(mapped_data + new_offset)) = 0;
399 kunmap_atomic(mapped_data, KM_USER0);
400 }
401
Dave Kleikamp470decc2006-10-11 01:20:57 -0700402 set_bh_page(new_bh, new_page, new_offset);
403 new_jh->b_transaction = NULL;
404 new_bh->b_size = jh2bh(jh_in)->b_size;
405 new_bh->b_bdev = transaction->t_journal->j_dev;
406 new_bh->b_blocknr = blocknr;
407 set_buffer_mapped(new_bh);
408 set_buffer_dirty(new_bh);
409
410 *jh_out = new_jh;
411
412 /*
413 * The to-be-written buffer needs to get moved to the io queue,
414 * and the original buffer whose contents we are shadowing or
415 * copying is moved to the transaction's shadow queue.
416 */
417 JBUFFER_TRACE(jh_in, "file as BJ_Shadow");
dingdinghua96577c42009-07-13 17:55:35 -0400418 spin_lock(&journal->j_list_lock);
419 __jbd2_journal_file_buffer(jh_in, transaction, BJ_Shadow);
420 spin_unlock(&journal->j_list_lock);
421 jbd_unlock_bh_state(bh_in);
422
Dave Kleikamp470decc2006-10-11 01:20:57 -0700423 JBUFFER_TRACE(new_jh, "file as BJ_IO");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700424 jbd2_journal_file_buffer(new_jh, transaction, BJ_IO);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700425
426 return do_escape | (done_copy_out << 1);
427}
428
429/*
430 * Allocation code for the journal file. Manage the space left in the
431 * journal, so that we can begin checkpointing when appropriate.
432 */
433
434/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700435 * __jbd2_log_space_left: Return the number of free blocks left in the journal.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700436 *
437 * Called with the journal already locked.
438 *
439 * Called under j_state_lock
440 */
441
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700442int __jbd2_log_space_left(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700443{
444 int left = journal->j_free;
445
446 assert_spin_locked(&journal->j_state_lock);
447
448 /*
449 * Be pessimistic here about the number of those free blocks which
450 * might be required for log descriptor control blocks.
451 */
452
453#define MIN_LOG_RESERVED_BLOCKS 32 /* Allow for rounding errors */
454
455 left -= MIN_LOG_RESERVED_BLOCKS;
456
457 if (left <= 0)
458 return 0;
459 left -= (left >> 3);
460 return left;
461}
462
463/*
Jan Karac88ccea2009-02-10 11:27:46 -0500464 * Called under j_state_lock. Returns true if a transaction commit was started.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700465 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700466int __jbd2_log_start_commit(journal_t *journal, tid_t target)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700467{
468 /*
469 * Are we already doing a recent enough commit?
470 */
471 if (!tid_geq(journal->j_commit_request, target)) {
472 /*
473 * We want a new commit: OK, mark the request and wakup the
474 * commit thread. We do _not_ do the commit ourselves.
475 */
476
477 journal->j_commit_request = target;
478 jbd_debug(1, "JBD: requesting commit %d/%d\n",
479 journal->j_commit_request,
480 journal->j_commit_sequence);
481 wake_up(&journal->j_wait_commit);
482 return 1;
483 }
484 return 0;
485}
486
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700487int jbd2_log_start_commit(journal_t *journal, tid_t tid)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700488{
489 int ret;
490
491 spin_lock(&journal->j_state_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700492 ret = __jbd2_log_start_commit(journal, tid);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700493 spin_unlock(&journal->j_state_lock);
494 return ret;
495}
496
497/*
498 * Force and wait upon a commit if the calling process is not within
499 * transaction. This is used for forcing out undo-protected data which contains
500 * bitmaps, when the fs is running out of space.
501 *
502 * We can only force the running transaction if we don't have an active handle;
503 * otherwise, we will deadlock.
504 *
505 * Returns true if a transaction was started.
506 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700507int jbd2_journal_force_commit_nested(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700508{
509 transaction_t *transaction = NULL;
510 tid_t tid;
511
512 spin_lock(&journal->j_state_lock);
513 if (journal->j_running_transaction && !current->journal_info) {
514 transaction = journal->j_running_transaction;
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700515 __jbd2_log_start_commit(journal, transaction->t_tid);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700516 } else if (journal->j_committing_transaction)
517 transaction = journal->j_committing_transaction;
518
519 if (!transaction) {
520 spin_unlock(&journal->j_state_lock);
521 return 0; /* Nothing to retry */
522 }
523
524 tid = transaction->t_tid;
525 spin_unlock(&journal->j_state_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700526 jbd2_log_wait_commit(journal, tid);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700527 return 1;
528}
529
530/*
531 * Start a commit of the current running transaction (if any). Returns true
Jan Karac88ccea2009-02-10 11:27:46 -0500532 * if a transaction is going to be committed (or is currently already
533 * committing), and fills its tid in at *ptid
Dave Kleikamp470decc2006-10-11 01:20:57 -0700534 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700535int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700536{
537 int ret = 0;
538
539 spin_lock(&journal->j_state_lock);
540 if (journal->j_running_transaction) {
541 tid_t tid = journal->j_running_transaction->t_tid;
542
Jan Karac88ccea2009-02-10 11:27:46 -0500543 __jbd2_log_start_commit(journal, tid);
544 /* There's a running transaction and we've just made sure
545 * it's commit has been scheduled. */
546 if (ptid)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700547 *ptid = tid;
Jan Karac88ccea2009-02-10 11:27:46 -0500548 ret = 1;
549 } else if (journal->j_committing_transaction) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700550 /*
551 * If ext3_write_super() recently started a commit, then we
552 * have to wait for completion of that transaction
553 */
Jan Karac88ccea2009-02-10 11:27:46 -0500554 if (ptid)
555 *ptid = journal->j_committing_transaction->t_tid;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700556 ret = 1;
557 }
558 spin_unlock(&journal->j_state_lock);
559 return ret;
560}
561
562/*
563 * Wait for a specified commit to complete.
564 * The caller may not hold the journal lock.
565 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700566int jbd2_log_wait_commit(journal_t *journal, tid_t tid)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700567{
568 int err = 0;
569
Jose R. Santose23291b2007-07-18 08:57:06 -0400570#ifdef CONFIG_JBD2_DEBUG
Dave Kleikamp470decc2006-10-11 01:20:57 -0700571 spin_lock(&journal->j_state_lock);
572 if (!tid_geq(journal->j_commit_request, tid)) {
573 printk(KERN_EMERG
574 "%s: error: j_commit_request=%d, tid=%d\n",
Harvey Harrison329d2912008-04-17 10:38:59 -0400575 __func__, journal->j_commit_request, tid);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700576 }
577 spin_unlock(&journal->j_state_lock);
578#endif
579 spin_lock(&journal->j_state_lock);
580 while (tid_gt(tid, journal->j_commit_sequence)) {
581 jbd_debug(1, "JBD: want %d, j_commit_sequence=%d\n",
582 tid, journal->j_commit_sequence);
583 wake_up(&journal->j_wait_commit);
584 spin_unlock(&journal->j_state_lock);
585 wait_event(journal->j_wait_done_commit,
586 !tid_gt(tid, journal->j_commit_sequence));
587 spin_lock(&journal->j_state_lock);
588 }
589 spin_unlock(&journal->j_state_lock);
590
591 if (unlikely(is_journal_aborted(journal))) {
592 printk(KERN_EMERG "journal commit I/O error\n");
593 err = -EIO;
594 }
595 return err;
596}
597
598/*
599 * Log buffer allocation routines:
600 */
601
Mingming Cao18eba7a2006-10-11 01:21:13 -0700602int jbd2_journal_next_log_block(journal_t *journal, unsigned long long *retp)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700603{
604 unsigned long blocknr;
605
606 spin_lock(&journal->j_state_lock);
607 J_ASSERT(journal->j_free > 1);
608
609 blocknr = journal->j_head;
610 journal->j_head++;
611 journal->j_free--;
612 if (journal->j_head == journal->j_last)
613 journal->j_head = journal->j_first;
614 spin_unlock(&journal->j_state_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700615 return jbd2_journal_bmap(journal, blocknr, retp);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700616}
617
618/*
619 * Conversion of logical to physical block numbers for the journal
620 *
621 * On external journals the journal blocks are identity-mapped, so
622 * this is a no-op. If needed, we can use j_blk_offset - everything is
623 * ready.
624 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700625int jbd2_journal_bmap(journal_t *journal, unsigned long blocknr,
Mingming Cao18eba7a2006-10-11 01:21:13 -0700626 unsigned long long *retp)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700627{
628 int err = 0;
Mingming Cao18eba7a2006-10-11 01:21:13 -0700629 unsigned long long ret;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700630
631 if (journal->j_inode) {
632 ret = bmap(journal->j_inode, blocknr);
633 if (ret)
634 *retp = ret;
635 else {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700636 printk(KERN_ALERT "%s: journal block not found "
637 "at offset %lu on %s\n",
Theodore Ts'o05496762008-09-16 14:36:17 -0400638 __func__, blocknr, journal->j_devname);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700639 err = -EIO;
640 __journal_abort_soft(journal, err);
641 }
642 } else {
643 *retp = blocknr; /* +journal->j_blk_offset */
644 }
645 return err;
646}
647
648/*
649 * We play buffer_head aliasing tricks to write data/metadata blocks to
650 * the journal without copying their contents, but for journal
651 * descriptor blocks we do need to generate bona fide buffers.
652 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700653 * After the caller of jbd2_journal_get_descriptor_buffer() has finished modifying
Dave Kleikamp470decc2006-10-11 01:20:57 -0700654 * the buffer's contents they really should run flush_dcache_page(bh->b_page).
655 * But we don't bother doing that, so there will be coherency problems with
656 * mmaps of blockdevs which hold live JBD-controlled filesystems.
657 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700658struct journal_head *jbd2_journal_get_descriptor_buffer(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700659{
660 struct buffer_head *bh;
Mingming Cao18eba7a2006-10-11 01:21:13 -0700661 unsigned long long blocknr;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700662 int err;
663
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700664 err = jbd2_journal_next_log_block(journal, &blocknr);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700665
666 if (err)
667 return NULL;
668
669 bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
Jan Kara4b905672009-01-06 14:53:35 -0500670 if (!bh)
671 return NULL;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700672 lock_buffer(bh);
673 memset(bh->b_data, 0, journal->j_blocksize);
674 set_buffer_uptodate(bh);
675 unlock_buffer(bh);
676 BUFFER_TRACE(bh, "return this buffer");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700677 return jbd2_journal_add_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700678}
679
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500680struct jbd2_stats_proc_session {
681 journal_t *journal;
682 struct transaction_stats_s *stats;
683 int start;
684 int max;
685};
686
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500687static void *jbd2_seq_info_start(struct seq_file *seq, loff_t *pos)
688{
689 return *pos ? NULL : SEQ_START_TOKEN;
690}
691
692static void *jbd2_seq_info_next(struct seq_file *seq, void *v, loff_t *pos)
693{
694 return NULL;
695}
696
697static int jbd2_seq_info_show(struct seq_file *seq, void *v)
698{
699 struct jbd2_stats_proc_session *s = seq->private;
700
701 if (v != SEQ_START_TOKEN)
702 return 0;
Theodore Ts'obf699322009-09-30 00:32:06 -0400703 seq_printf(seq, "%lu transaction, each up to %u blocks\n",
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500704 s->stats->ts_tid,
705 s->journal->j_max_transaction_buffers);
706 if (s->stats->ts_tid == 0)
707 return 0;
708 seq_printf(seq, "average: \n %ums waiting for transaction\n",
Theodore Ts'obf699322009-09-30 00:32:06 -0400709 jiffies_to_msecs(s->stats->run.rs_wait / s->stats->ts_tid));
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500710 seq_printf(seq, " %ums running transaction\n",
Theodore Ts'obf699322009-09-30 00:32:06 -0400711 jiffies_to_msecs(s->stats->run.rs_running / s->stats->ts_tid));
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500712 seq_printf(seq, " %ums transaction was being locked\n",
Theodore Ts'obf699322009-09-30 00:32:06 -0400713 jiffies_to_msecs(s->stats->run.rs_locked / s->stats->ts_tid));
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500714 seq_printf(seq, " %ums flushing data (in ordered mode)\n",
Theodore Ts'obf699322009-09-30 00:32:06 -0400715 jiffies_to_msecs(s->stats->run.rs_flushing / s->stats->ts_tid));
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500716 seq_printf(seq, " %ums logging transaction\n",
Theodore Ts'obf699322009-09-30 00:32:06 -0400717 jiffies_to_msecs(s->stats->run.rs_logging / s->stats->ts_tid));
Simon Holm Thøgersenc225aa52009-01-11 22:34:01 -0500718 seq_printf(seq, " %lluus average transaction commit time\n",
719 div_u64(s->journal->j_average_commit_time, 1000));
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500720 seq_printf(seq, " %lu handles per transaction\n",
Theodore Ts'obf699322009-09-30 00:32:06 -0400721 s->stats->run.rs_handle_count / s->stats->ts_tid);
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500722 seq_printf(seq, " %lu blocks per transaction\n",
Theodore Ts'obf699322009-09-30 00:32:06 -0400723 s->stats->run.rs_blocks / s->stats->ts_tid);
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500724 seq_printf(seq, " %lu logged blocks per transaction\n",
Theodore Ts'obf699322009-09-30 00:32:06 -0400725 s->stats->run.rs_blocks_logged / s->stats->ts_tid);
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500726 return 0;
727}
728
729static void jbd2_seq_info_stop(struct seq_file *seq, void *v)
730{
731}
732
James Morris88e9d342009-09-22 16:43:43 -0700733static const struct seq_operations jbd2_seq_info_ops = {
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500734 .start = jbd2_seq_info_start,
735 .next = jbd2_seq_info_next,
736 .stop = jbd2_seq_info_stop,
737 .show = jbd2_seq_info_show,
738};
739
740static int jbd2_seq_info_open(struct inode *inode, struct file *file)
741{
742 journal_t *journal = PDE(inode)->data;
743 struct jbd2_stats_proc_session *s;
744 int rc, size;
745
746 s = kmalloc(sizeof(*s), GFP_KERNEL);
747 if (s == NULL)
748 return -ENOMEM;
749 size = sizeof(struct transaction_stats_s);
750 s->stats = kmalloc(size, GFP_KERNEL);
751 if (s->stats == NULL) {
752 kfree(s);
753 return -ENOMEM;
754 }
755 spin_lock(&journal->j_history_lock);
756 memcpy(s->stats, &journal->j_stats, size);
757 s->journal = journal;
758 spin_unlock(&journal->j_history_lock);
759
760 rc = seq_open(file, &jbd2_seq_info_ops);
761 if (rc == 0) {
762 struct seq_file *m = file->private_data;
763 m->private = s;
764 } else {
765 kfree(s->stats);
766 kfree(s);
767 }
768 return rc;
769
770}
771
772static int jbd2_seq_info_release(struct inode *inode, struct file *file)
773{
774 struct seq_file *seq = file->private_data;
775 struct jbd2_stats_proc_session *s = seq->private;
776 kfree(s->stats);
777 kfree(s);
778 return seq_release(inode, file);
779}
780
Alexey Dobriyan828c0952009-10-01 15:43:56 -0700781static const struct file_operations jbd2_seq_info_fops = {
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500782 .owner = THIS_MODULE,
783 .open = jbd2_seq_info_open,
784 .read = seq_read,
785 .llseek = seq_lseek,
786 .release = jbd2_seq_info_release,
787};
788
789static struct proc_dir_entry *proc_jbd2_stats;
790
791static void jbd2_stats_proc_init(journal_t *journal)
792{
Theodore Ts'o05496762008-09-16 14:36:17 -0400793 journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats);
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500794 if (journal->j_proc_entry) {
Denis V. Lunev79da3662008-04-29 01:02:11 -0700795 proc_create_data("info", S_IRUGO, journal->j_proc_entry,
796 &jbd2_seq_info_fops, journal);
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500797 }
798}
799
800static void jbd2_stats_proc_exit(journal_t *journal)
801{
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500802 remove_proc_entry("info", journal->j_proc_entry);
Theodore Ts'o05496762008-09-16 14:36:17 -0400803 remove_proc_entry(journal->j_devname, proc_jbd2_stats);
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500804}
805
Dave Kleikamp470decc2006-10-11 01:20:57 -0700806/*
807 * Management for journal control blocks: functions to create and
808 * destroy journal_t structures, and to initialise and read existing
809 * journal blocks from disk. */
810
811/* First: create and setup a journal_t object in memory. We initialise
812 * very few fields yet: that has to wait until we have created the
813 * journal structures from from scratch, or loaded them from disk. */
814
815static journal_t * journal_init_common (void)
816{
817 journal_t *journal;
818 int err;
819
Andrew Morton3ebfdf82009-12-23 08:05:15 -0500820 journal = kzalloc(sizeof(*journal), GFP_KERNEL);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700821 if (!journal)
822 goto fail;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700823
824 init_waitqueue_head(&journal->j_wait_transaction_locked);
825 init_waitqueue_head(&journal->j_wait_logspace);
826 init_waitqueue_head(&journal->j_wait_done_commit);
827 init_waitqueue_head(&journal->j_wait_checkpoint);
828 init_waitqueue_head(&journal->j_wait_commit);
829 init_waitqueue_head(&journal->j_wait_updates);
830 mutex_init(&journal->j_barrier);
831 mutex_init(&journal->j_checkpoint_mutex);
832 spin_lock_init(&journal->j_revoke_lock);
833 spin_lock_init(&journal->j_list_lock);
834 spin_lock_init(&journal->j_state_lock);
835
Mingming Caocd02ff02007-10-16 18:38:25 -0400836 journal->j_commit_interval = (HZ * JBD2_DEFAULT_MAX_COMMIT_AGE);
Theodore Ts'o30773842009-01-03 20:27:38 -0500837 journal->j_min_batch_time = 0;
838 journal->j_max_batch_time = 15000; /* 15ms */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700839
840 /* The journal is marked for error until we succeed with recovery! */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700841 journal->j_flags = JBD2_ABORT;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700842
843 /* Set up a default-sized revoke table for the new mount. */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700844 err = jbd2_journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700845 if (err) {
846 kfree(journal);
847 goto fail;
848 }
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500849
Theodore Ts'obf699322009-09-30 00:32:06 -0400850 spin_lock_init(&journal->j_history_lock);
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500851
Dave Kleikamp470decc2006-10-11 01:20:57 -0700852 return journal;
853fail:
854 return NULL;
855}
856
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700857/* jbd2_journal_init_dev and jbd2_journal_init_inode:
Dave Kleikamp470decc2006-10-11 01:20:57 -0700858 *
859 * Create a journal structure assigned some fixed set of disk blocks to
860 * the journal. We don't actually touch those disk blocks yet, but we
861 * need to set up all of the mapping information to tell the journaling
862 * system where the journal blocks are.
863 *
864 */
865
866/**
Randy Dunlap5648ba52008-04-17 10:38:59 -0400867 * journal_t * jbd2_journal_init_dev() - creates and initialises a journal structure
Dave Kleikamp470decc2006-10-11 01:20:57 -0700868 * @bdev: Block device on which to create the journal
869 * @fs_dev: Device which hold journalled filesystem for this journal.
870 * @start: Block nr Start of journal.
871 * @len: Length of the journal in blocks.
872 * @blocksize: blocksize of journalling device
Randy Dunlap5648ba52008-04-17 10:38:59 -0400873 *
874 * Returns: a newly created journal_t *
Dave Kleikamp470decc2006-10-11 01:20:57 -0700875 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700876 * jbd2_journal_init_dev creates a journal which maps a fixed contiguous
Dave Kleikamp470decc2006-10-11 01:20:57 -0700877 * range of blocks on an arbitrary block device.
878 *
879 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700880journal_t * jbd2_journal_init_dev(struct block_device *bdev,
Dave Kleikamp470decc2006-10-11 01:20:57 -0700881 struct block_device *fs_dev,
Mingming Cao18eba7a2006-10-11 01:21:13 -0700882 unsigned long long start, int len, int blocksize)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700883{
884 journal_t *journal = journal_init_common();
885 struct buffer_head *bh;
Theodore Ts'o05496762008-09-16 14:36:17 -0400886 char *p;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700887 int n;
888
889 if (!journal)
890 return NULL;
891
892 /* journal descriptor can store up to n blocks -bzzz */
893 journal->j_blocksize = blocksize;
Jan Kara4b905672009-01-06 14:53:35 -0500894 jbd2_stats_proc_init(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700895 n = journal->j_blocksize / sizeof(journal_block_tag_t);
896 journal->j_wbufsize = n;
897 journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
898 if (!journal->j_wbuf) {
899 printk(KERN_ERR "%s: Cant allocate bhs for commit thread\n",
Harvey Harrison329d2912008-04-17 10:38:59 -0400900 __func__);
Jan Kara4b905672009-01-06 14:53:35 -0500901 goto out_err;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700902 }
903 journal->j_dev = bdev;
904 journal->j_fs_dev = fs_dev;
905 journal->j_blk_offset = start;
906 journal->j_maxlen = len;
Theodore Ts'o05496762008-09-16 14:36:17 -0400907 bdevname(journal->j_dev, journal->j_devname);
908 p = journal->j_devname;
909 while ((p = strchr(p, '/')))
910 *p = '!';
Dave Kleikamp470decc2006-10-11 01:20:57 -0700911
912 bh = __getblk(journal->j_dev, start, journal->j_blocksize);
Jan Kara4b905672009-01-06 14:53:35 -0500913 if (!bh) {
914 printk(KERN_ERR
915 "%s: Cannot get buffer for journal superblock\n",
916 __func__);
917 goto out_err;
918 }
Dave Kleikamp470decc2006-10-11 01:20:57 -0700919 journal->j_sb_buffer = bh;
920 journal->j_superblock = (journal_superblock_t *)bh->b_data;
Jan Kara4b905672009-01-06 14:53:35 -0500921
Dave Kleikamp470decc2006-10-11 01:20:57 -0700922 return journal;
Jan Kara4b905672009-01-06 14:53:35 -0500923out_err:
Tao Ma7b02bec2009-11-10 17:13:22 +0800924 kfree(journal->j_wbuf);
Jan Kara4b905672009-01-06 14:53:35 -0500925 jbd2_stats_proc_exit(journal);
926 kfree(journal);
927 return NULL;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700928}
929
930/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700931 * journal_t * jbd2_journal_init_inode () - creates a journal which maps to a inode.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700932 * @inode: An inode to create the journal in
933 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700934 * jbd2_journal_init_inode creates a journal which maps an on-disk inode as
Dave Kleikamp470decc2006-10-11 01:20:57 -0700935 * the journal. The inode must exist already, must support bmap() and
936 * must have all data blocks preallocated.
937 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700938journal_t * jbd2_journal_init_inode (struct inode *inode)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700939{
940 struct buffer_head *bh;
941 journal_t *journal = journal_init_common();
Theodore Ts'o05496762008-09-16 14:36:17 -0400942 char *p;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700943 int err;
944 int n;
Mingming Cao18eba7a2006-10-11 01:21:13 -0700945 unsigned long long blocknr;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700946
947 if (!journal)
948 return NULL;
949
950 journal->j_dev = journal->j_fs_dev = inode->i_sb->s_bdev;
951 journal->j_inode = inode;
Theodore Ts'o05496762008-09-16 14:36:17 -0400952 bdevname(journal->j_dev, journal->j_devname);
953 p = journal->j_devname;
954 while ((p = strchr(p, '/')))
955 *p = '!';
956 p = journal->j_devname + strlen(journal->j_devname);
Theodore Ts'o90576c02009-09-29 15:51:30 -0400957 sprintf(p, "-%lu", journal->j_inode->i_ino);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700958 jbd_debug(1,
959 "journal %p: inode %s/%ld, size %Ld, bits %d, blksize %ld\n",
960 journal, inode->i_sb->s_id, inode->i_ino,
961 (long long) inode->i_size,
962 inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize);
963
964 journal->j_maxlen = inode->i_size >> inode->i_sb->s_blocksize_bits;
965 journal->j_blocksize = inode->i_sb->s_blocksize;
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500966 jbd2_stats_proc_init(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700967
968 /* journal descriptor can store up to n blocks -bzzz */
969 n = journal->j_blocksize / sizeof(journal_block_tag_t);
970 journal->j_wbufsize = n;
971 journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
972 if (!journal->j_wbuf) {
973 printk(KERN_ERR "%s: Cant allocate bhs for commit thread\n",
Harvey Harrison329d2912008-04-17 10:38:59 -0400974 __func__);
Jan Kara4b905672009-01-06 14:53:35 -0500975 goto out_err;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700976 }
977
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700978 err = jbd2_journal_bmap(journal, 0, &blocknr);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700979 /* If that failed, give up */
980 if (err) {
981 printk(KERN_ERR "%s: Cannnot locate journal superblock\n",
Harvey Harrison329d2912008-04-17 10:38:59 -0400982 __func__);
Jan Kara4b905672009-01-06 14:53:35 -0500983 goto out_err;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700984 }
985
986 bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
Jan Kara4b905672009-01-06 14:53:35 -0500987 if (!bh) {
988 printk(KERN_ERR
989 "%s: Cannot get buffer for journal superblock\n",
990 __func__);
991 goto out_err;
992 }
Dave Kleikamp470decc2006-10-11 01:20:57 -0700993 journal->j_sb_buffer = bh;
994 journal->j_superblock = (journal_superblock_t *)bh->b_data;
995
996 return journal;
Jan Kara4b905672009-01-06 14:53:35 -0500997out_err:
Tao Ma7b02bec2009-11-10 17:13:22 +0800998 kfree(journal->j_wbuf);
Jan Kara4b905672009-01-06 14:53:35 -0500999 jbd2_stats_proc_exit(journal);
1000 kfree(journal);
1001 return NULL;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001002}
1003
1004/*
1005 * If the journal init or create aborts, we need to mark the journal
1006 * superblock as being NULL to prevent the journal destroy from writing
1007 * back a bogus superblock.
1008 */
1009static void journal_fail_superblock (journal_t *journal)
1010{
1011 struct buffer_head *bh = journal->j_sb_buffer;
1012 brelse(bh);
1013 journal->j_sb_buffer = NULL;
1014}
1015
1016/*
1017 * Given a journal_t structure, initialise the various fields for
1018 * startup of a new journaling session. We use this both when creating
1019 * a journal, and after recovering an old journal to reset it for
1020 * subsequent use.
1021 */
1022
1023static int journal_reset(journal_t *journal)
1024{
1025 journal_superblock_t *sb = journal->j_superblock;
Mingming Cao18eba7a2006-10-11 01:21:13 -07001026 unsigned long long first, last;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001027
1028 first = be32_to_cpu(sb->s_first);
1029 last = be32_to_cpu(sb->s_maxlen);
Jan Karaf6f50e22009-07-17 10:40:01 -04001030 if (first + JBD2_MIN_JOURNAL_BLOCKS > last + 1) {
1031 printk(KERN_ERR "JBD: Journal too short (blocks %llu-%llu).\n",
1032 first, last);
1033 journal_fail_superblock(journal);
1034 return -EINVAL;
1035 }
Dave Kleikamp470decc2006-10-11 01:20:57 -07001036
1037 journal->j_first = first;
1038 journal->j_last = last;
1039
1040 journal->j_head = first;
1041 journal->j_tail = first;
1042 journal->j_free = last - first;
1043
1044 journal->j_tail_sequence = journal->j_transaction_sequence;
1045 journal->j_commit_sequence = journal->j_transaction_sequence - 1;
1046 journal->j_commit_request = journal->j_commit_sequence;
1047
1048 journal->j_max_transaction_buffers = journal->j_maxlen / 4;
1049
1050 /* Add the dynamic fields and write it to disk. */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001051 jbd2_journal_update_superblock(journal, 1);
Pavel Emelianov97f06782007-05-08 00:30:42 -07001052 return jbd2_journal_start_thread(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001053}
1054
1055/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001056 * void jbd2_journal_update_superblock() - Update journal sb on disk.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001057 * @journal: The journal to update.
1058 * @wait: Set to '0' if you don't want to wait for IO completion.
1059 *
1060 * Update a journal's dynamic superblock fields and write it to disk,
1061 * optionally waiting for the IO to complete.
1062 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001063void jbd2_journal_update_superblock(journal_t *journal, int wait)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001064{
1065 journal_superblock_t *sb = journal->j_superblock;
1066 struct buffer_head *bh = journal->j_sb_buffer;
1067
1068 /*
1069 * As a special case, if the on-disk copy is already marked as needing
1070 * no recovery (s_start == 0) and there are no outstanding transactions
1071 * in the filesystem, then we can safely defer the superblock update
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001072 * until the next commit by setting JBD2_FLUSHED. This avoids
Dave Kleikamp470decc2006-10-11 01:20:57 -07001073 * attempting a write to a potential-readonly device.
1074 */
1075 if (sb->s_start == 0 && journal->j_tail_sequence ==
1076 journal->j_transaction_sequence) {
1077 jbd_debug(1,"JBD: Skipping superblock update on recovered sb "
1078 "(start %ld, seq %d, errno %d)\n",
1079 journal->j_tail, journal->j_tail_sequence,
1080 journal->j_errno);
1081 goto out;
1082 }
1083
Theodore Ts'o914258b2008-10-06 21:35:40 -04001084 if (buffer_write_io_error(bh)) {
1085 /*
1086 * Oh, dear. A previous attempt to write the journal
1087 * superblock failed. This could happen because the
1088 * USB device was yanked out. Or it could happen to
1089 * be a transient write error and maybe the block will
1090 * be remapped. Nothing we can do but to retry the
1091 * write and hope for the best.
1092 */
1093 printk(KERN_ERR "JBD2: previous I/O error detected "
1094 "for journal superblock update for %s.\n",
1095 journal->j_devname);
1096 clear_buffer_write_io_error(bh);
1097 set_buffer_uptodate(bh);
1098 }
1099
Dave Kleikamp470decc2006-10-11 01:20:57 -07001100 spin_lock(&journal->j_state_lock);
1101 jbd_debug(1,"JBD: updating superblock (start %ld, seq %d, errno %d)\n",
1102 journal->j_tail, journal->j_tail_sequence, journal->j_errno);
1103
1104 sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
1105 sb->s_start = cpu_to_be32(journal->j_tail);
1106 sb->s_errno = cpu_to_be32(journal->j_errno);
1107 spin_unlock(&journal->j_state_lock);
1108
1109 BUFFER_TRACE(bh, "marking dirty");
1110 mark_buffer_dirty(bh);
Theodore Ts'o914258b2008-10-06 21:35:40 -04001111 if (wait) {
Dave Kleikamp470decc2006-10-11 01:20:57 -07001112 sync_dirty_buffer(bh);
Theodore Ts'o914258b2008-10-06 21:35:40 -04001113 if (buffer_write_io_error(bh)) {
1114 printk(KERN_ERR "JBD2: I/O error detected "
1115 "when updating journal superblock for %s.\n",
1116 journal->j_devname);
1117 clear_buffer_write_io_error(bh);
1118 set_buffer_uptodate(bh);
1119 }
1120 } else
Dave Kleikamp470decc2006-10-11 01:20:57 -07001121 ll_rw_block(SWRITE, 1, &bh);
1122
1123out:
1124 /* If we have just flushed the log (by marking s_start==0), then
1125 * any future commit will have to be careful to update the
1126 * superblock again to re-record the true start of the log. */
1127
1128 spin_lock(&journal->j_state_lock);
1129 if (sb->s_start)
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001130 journal->j_flags &= ~JBD2_FLUSHED;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001131 else
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001132 journal->j_flags |= JBD2_FLUSHED;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001133 spin_unlock(&journal->j_state_lock);
1134}
1135
1136/*
1137 * Read the superblock for a given journal, performing initial
1138 * validation of the format.
1139 */
1140
1141static int journal_get_superblock(journal_t *journal)
1142{
1143 struct buffer_head *bh;
1144 journal_superblock_t *sb;
1145 int err = -EIO;
1146
1147 bh = journal->j_sb_buffer;
1148
1149 J_ASSERT(bh != NULL);
1150 if (!buffer_uptodate(bh)) {
1151 ll_rw_block(READ, 1, &bh);
1152 wait_on_buffer(bh);
1153 if (!buffer_uptodate(bh)) {
1154 printk (KERN_ERR
1155 "JBD: IO error reading journal superblock\n");
1156 goto out;
1157 }
1158 }
1159
1160 sb = journal->j_superblock;
1161
1162 err = -EINVAL;
1163
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001164 if (sb->s_header.h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER) ||
Dave Kleikamp470decc2006-10-11 01:20:57 -07001165 sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) {
1166 printk(KERN_WARNING "JBD: no valid journal superblock found\n");
1167 goto out;
1168 }
1169
1170 switch(be32_to_cpu(sb->s_header.h_blocktype)) {
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001171 case JBD2_SUPERBLOCK_V1:
Dave Kleikamp470decc2006-10-11 01:20:57 -07001172 journal->j_format_version = 1;
1173 break;
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001174 case JBD2_SUPERBLOCK_V2:
Dave Kleikamp470decc2006-10-11 01:20:57 -07001175 journal->j_format_version = 2;
1176 break;
1177 default:
1178 printk(KERN_WARNING "JBD: unrecognised superblock format ID\n");
1179 goto out;
1180 }
1181
1182 if (be32_to_cpu(sb->s_maxlen) < journal->j_maxlen)
1183 journal->j_maxlen = be32_to_cpu(sb->s_maxlen);
1184 else if (be32_to_cpu(sb->s_maxlen) > journal->j_maxlen) {
1185 printk (KERN_WARNING "JBD: journal file too short\n");
1186 goto out;
1187 }
1188
1189 return 0;
1190
1191out:
1192 journal_fail_superblock(journal);
1193 return err;
1194}
1195
1196/*
1197 * Load the on-disk journal superblock and read the key fields into the
1198 * journal_t.
1199 */
1200
1201static int load_superblock(journal_t *journal)
1202{
1203 int err;
1204 journal_superblock_t *sb;
1205
1206 err = journal_get_superblock(journal);
1207 if (err)
1208 return err;
1209
1210 sb = journal->j_superblock;
1211
1212 journal->j_tail_sequence = be32_to_cpu(sb->s_sequence);
1213 journal->j_tail = be32_to_cpu(sb->s_start);
1214 journal->j_first = be32_to_cpu(sb->s_first);
1215 journal->j_last = be32_to_cpu(sb->s_maxlen);
1216 journal->j_errno = be32_to_cpu(sb->s_errno);
1217
1218 return 0;
1219}
1220
1221
1222/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001223 * int jbd2_journal_load() - Read journal from disk.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001224 * @journal: Journal to act on.
1225 *
1226 * Given a journal_t structure which tells us which disk blocks contain
1227 * a journal, read the journal from disk to initialise the in-memory
1228 * structures.
1229 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001230int jbd2_journal_load(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001231{
1232 int err;
1233 journal_superblock_t *sb;
1234
1235 err = load_superblock(journal);
1236 if (err)
1237 return err;
1238
1239 sb = journal->j_superblock;
1240 /* If this is a V2 superblock, then we have to check the
1241 * features flags on it. */
1242
1243 if (journal->j_format_version >= 2) {
1244 if ((sb->s_feature_ro_compat &
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001245 ~cpu_to_be32(JBD2_KNOWN_ROCOMPAT_FEATURES)) ||
Dave Kleikamp470decc2006-10-11 01:20:57 -07001246 (sb->s_feature_incompat &
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001247 ~cpu_to_be32(JBD2_KNOWN_INCOMPAT_FEATURES))) {
Dave Kleikamp470decc2006-10-11 01:20:57 -07001248 printk (KERN_WARNING
1249 "JBD: Unrecognised features on journal\n");
1250 return -EINVAL;
1251 }
1252 }
1253
Theodore Ts'od2eecb02009-12-07 10:36:20 -05001254 /*
1255 * Create a slab for this blocksize
1256 */
1257 err = jbd2_journal_create_slab(be32_to_cpu(sb->s_blocksize));
1258 if (err)
1259 return err;
1260
Dave Kleikamp470decc2006-10-11 01:20:57 -07001261 /* Let the recovery code check whether it needs to recover any
1262 * data from the journal. */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001263 if (jbd2_journal_recover(journal))
Dave Kleikamp470decc2006-10-11 01:20:57 -07001264 goto recovery_error;
1265
Theodore Ts'oe6a47422009-11-15 15:31:37 -05001266 if (journal->j_failed_commit) {
1267 printk(KERN_ERR "JBD2: journal transaction %u on %s "
1268 "is corrupt.\n", journal->j_failed_commit,
1269 journal->j_devname);
1270 return -EIO;
1271 }
1272
Dave Kleikamp470decc2006-10-11 01:20:57 -07001273 /* OK, we've finished with the dynamic journal bits:
1274 * reinitialise the dynamic contents of the superblock in memory
1275 * and reset them on disk. */
1276 if (journal_reset(journal))
1277 goto recovery_error;
1278
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001279 journal->j_flags &= ~JBD2_ABORT;
1280 journal->j_flags |= JBD2_LOADED;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001281 return 0;
1282
1283recovery_error:
1284 printk (KERN_WARNING "JBD: recovery failed\n");
1285 return -EIO;
1286}
1287
1288/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001289 * void jbd2_journal_destroy() - Release a journal_t structure.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001290 * @journal: Journal to act on.
1291 *
1292 * Release a journal_t structure once it is no longer in use by the
1293 * journaled object.
Hidehiro Kawai44519fa2008-10-10 20:29:13 -04001294 * Return <0 if we couldn't clean up the journal.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001295 */
Hidehiro Kawai44519fa2008-10-10 20:29:13 -04001296int jbd2_journal_destroy(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001297{
Hidehiro Kawai44519fa2008-10-10 20:29:13 -04001298 int err = 0;
1299
Dave Kleikamp470decc2006-10-11 01:20:57 -07001300 /* Wait for the commit thread to wake up and die. */
1301 journal_kill_thread(journal);
1302
1303 /* Force a final log commit */
1304 if (journal->j_running_transaction)
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001305 jbd2_journal_commit_transaction(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001306
1307 /* Force any old transactions to disk */
1308
1309 /* Totally anal locking here... */
1310 spin_lock(&journal->j_list_lock);
1311 while (journal->j_checkpoint_transactions != NULL) {
1312 spin_unlock(&journal->j_list_lock);
Theodore Ts'o1a0d3782008-11-05 00:09:22 -05001313 mutex_lock(&journal->j_checkpoint_mutex);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001314 jbd2_log_do_checkpoint(journal);
Theodore Ts'o1a0d3782008-11-05 00:09:22 -05001315 mutex_unlock(&journal->j_checkpoint_mutex);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001316 spin_lock(&journal->j_list_lock);
1317 }
1318
1319 J_ASSERT(journal->j_running_transaction == NULL);
1320 J_ASSERT(journal->j_committing_transaction == NULL);
1321 J_ASSERT(journal->j_checkpoint_transactions == NULL);
1322 spin_unlock(&journal->j_list_lock);
1323
Dave Kleikamp470decc2006-10-11 01:20:57 -07001324 if (journal->j_sb_buffer) {
Hidehiro Kawai44519fa2008-10-10 20:29:13 -04001325 if (!is_journal_aborted(journal)) {
1326 /* We can now mark the journal as empty. */
1327 journal->j_tail = 0;
1328 journal->j_tail_sequence =
1329 ++journal->j_transaction_sequence;
1330 jbd2_journal_update_superblock(journal, 1);
1331 } else {
1332 err = -EIO;
1333 }
Dave Kleikamp470decc2006-10-11 01:20:57 -07001334 brelse(journal->j_sb_buffer);
1335 }
1336
Johann Lombardi8e85fb32008-01-28 23:58:27 -05001337 if (journal->j_proc_entry)
1338 jbd2_stats_proc_exit(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001339 if (journal->j_inode)
1340 iput(journal->j_inode);
1341 if (journal->j_revoke)
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001342 jbd2_journal_destroy_revoke(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001343 kfree(journal->j_wbuf);
1344 kfree(journal);
Hidehiro Kawai44519fa2008-10-10 20:29:13 -04001345
1346 return err;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001347}
1348
1349
1350/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001351 *int jbd2_journal_check_used_features () - Check if features specified are used.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001352 * @journal: Journal to check.
1353 * @compat: bitmask of compatible features
1354 * @ro: bitmask of features that force read-only mount
1355 * @incompat: bitmask of incompatible features
1356 *
1357 * Check whether the journal uses all of a given set of
1358 * features. Return true (non-zero) if it does.
1359 **/
1360
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001361int jbd2_journal_check_used_features (journal_t *journal, unsigned long compat,
Dave Kleikamp470decc2006-10-11 01:20:57 -07001362 unsigned long ro, unsigned long incompat)
1363{
1364 journal_superblock_t *sb;
1365
1366 if (!compat && !ro && !incompat)
1367 return 1;
1368 if (journal->j_format_version == 1)
1369 return 0;
1370
1371 sb = journal->j_superblock;
1372
1373 if (((be32_to_cpu(sb->s_feature_compat) & compat) == compat) &&
1374 ((be32_to_cpu(sb->s_feature_ro_compat) & ro) == ro) &&
1375 ((be32_to_cpu(sb->s_feature_incompat) & incompat) == incompat))
1376 return 1;
1377
1378 return 0;
1379}
1380
1381/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001382 * int jbd2_journal_check_available_features() - Check feature set in journalling layer
Dave Kleikamp470decc2006-10-11 01:20:57 -07001383 * @journal: Journal to check.
1384 * @compat: bitmask of compatible features
1385 * @ro: bitmask of features that force read-only mount
1386 * @incompat: bitmask of incompatible features
1387 *
1388 * Check whether the journaling code supports the use of
1389 * all of a given set of features on this journal. Return true
1390 * (non-zero) if it can. */
1391
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001392int jbd2_journal_check_available_features (journal_t *journal, unsigned long compat,
Dave Kleikamp470decc2006-10-11 01:20:57 -07001393 unsigned long ro, unsigned long incompat)
1394{
1395 journal_superblock_t *sb;
1396
1397 if (!compat && !ro && !incompat)
1398 return 1;
1399
1400 sb = journal->j_superblock;
1401
1402 /* We can support any known requested features iff the
1403 * superblock is in version 2. Otherwise we fail to support any
1404 * extended sb features. */
1405
1406 if (journal->j_format_version != 2)
1407 return 0;
1408
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001409 if ((compat & JBD2_KNOWN_COMPAT_FEATURES) == compat &&
1410 (ro & JBD2_KNOWN_ROCOMPAT_FEATURES) == ro &&
1411 (incompat & JBD2_KNOWN_INCOMPAT_FEATURES) == incompat)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001412 return 1;
1413
1414 return 0;
1415}
1416
1417/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001418 * int jbd2_journal_set_features () - Mark a given journal feature in the superblock
Dave Kleikamp470decc2006-10-11 01:20:57 -07001419 * @journal: Journal to act on.
1420 * @compat: bitmask of compatible features
1421 * @ro: bitmask of features that force read-only mount
1422 * @incompat: bitmask of incompatible features
1423 *
1424 * Mark a given journal feature as present on the
1425 * superblock. Returns true if the requested features could be set.
1426 *
1427 */
1428
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001429int jbd2_journal_set_features (journal_t *journal, unsigned long compat,
Dave Kleikamp470decc2006-10-11 01:20:57 -07001430 unsigned long ro, unsigned long incompat)
1431{
1432 journal_superblock_t *sb;
1433
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001434 if (jbd2_journal_check_used_features(journal, compat, ro, incompat))
Dave Kleikamp470decc2006-10-11 01:20:57 -07001435 return 1;
1436
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001437 if (!jbd2_journal_check_available_features(journal, compat, ro, incompat))
Dave Kleikamp470decc2006-10-11 01:20:57 -07001438 return 0;
1439
1440 jbd_debug(1, "Setting new features 0x%lx/0x%lx/0x%lx\n",
1441 compat, ro, incompat);
1442
1443 sb = journal->j_superblock;
1444
1445 sb->s_feature_compat |= cpu_to_be32(compat);
1446 sb->s_feature_ro_compat |= cpu_to_be32(ro);
1447 sb->s_feature_incompat |= cpu_to_be32(incompat);
1448
1449 return 1;
1450}
1451
Girish Shilamkar818d2762008-01-28 23:58:27 -05001452/*
1453 * jbd2_journal_clear_features () - Clear a given journal feature in the
1454 * superblock
1455 * @journal: Journal to act on.
1456 * @compat: bitmask of compatible features
1457 * @ro: bitmask of features that force read-only mount
1458 * @incompat: bitmask of incompatible features
1459 *
1460 * Clear a given journal feature as present on the
1461 * superblock.
1462 */
1463void jbd2_journal_clear_features(journal_t *journal, unsigned long compat,
1464 unsigned long ro, unsigned long incompat)
1465{
1466 journal_superblock_t *sb;
1467
1468 jbd_debug(1, "Clear features 0x%lx/0x%lx/0x%lx\n",
1469 compat, ro, incompat);
1470
1471 sb = journal->j_superblock;
1472
1473 sb->s_feature_compat &= ~cpu_to_be32(compat);
1474 sb->s_feature_ro_compat &= ~cpu_to_be32(ro);
1475 sb->s_feature_incompat &= ~cpu_to_be32(incompat);
1476}
1477EXPORT_SYMBOL(jbd2_journal_clear_features);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001478
1479/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001480 * int jbd2_journal_update_format () - Update on-disk journal structure.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001481 * @journal: Journal to act on.
1482 *
1483 * Given an initialised but unloaded journal struct, poke about in the
1484 * on-disk structure to update it to the most recent supported version.
1485 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001486int jbd2_journal_update_format (journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001487{
1488 journal_superblock_t *sb;
1489 int err;
1490
1491 err = journal_get_superblock(journal);
1492 if (err)
1493 return err;
1494
1495 sb = journal->j_superblock;
1496
1497 switch (be32_to_cpu(sb->s_header.h_blocktype)) {
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001498 case JBD2_SUPERBLOCK_V2:
Dave Kleikamp470decc2006-10-11 01:20:57 -07001499 return 0;
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001500 case JBD2_SUPERBLOCK_V1:
Dave Kleikamp470decc2006-10-11 01:20:57 -07001501 return journal_convert_superblock_v1(journal, sb);
1502 default:
1503 break;
1504 }
1505 return -EINVAL;
1506}
1507
1508static int journal_convert_superblock_v1(journal_t *journal,
1509 journal_superblock_t *sb)
1510{
1511 int offset, blocksize;
1512 struct buffer_head *bh;
1513
1514 printk(KERN_WARNING
1515 "JBD: Converting superblock from version 1 to 2.\n");
1516
1517 /* Pre-initialise new fields to zero */
1518 offset = ((char *) &(sb->s_feature_compat)) - ((char *) sb);
1519 blocksize = be32_to_cpu(sb->s_blocksize);
1520 memset(&sb->s_feature_compat, 0, blocksize-offset);
1521
1522 sb->s_nr_users = cpu_to_be32(1);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001523 sb->s_header.h_blocktype = cpu_to_be32(JBD2_SUPERBLOCK_V2);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001524 journal->j_format_version = 2;
1525
1526 bh = journal->j_sb_buffer;
1527 BUFFER_TRACE(bh, "marking dirty");
1528 mark_buffer_dirty(bh);
1529 sync_dirty_buffer(bh);
1530 return 0;
1531}
1532
1533
1534/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001535 * int jbd2_journal_flush () - Flush journal
Dave Kleikamp470decc2006-10-11 01:20:57 -07001536 * @journal: Journal to act on.
1537 *
1538 * Flush all data for a given journal to disk and empty the journal.
1539 * Filesystems can use this when remounting readonly to ensure that
1540 * recovery does not need to happen on remount.
1541 */
1542
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001543int jbd2_journal_flush(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001544{
1545 int err = 0;
1546 transaction_t *transaction = NULL;
1547 unsigned long old_tail;
1548
1549 spin_lock(&journal->j_state_lock);
1550
1551 /* Force everything buffered to the log... */
1552 if (journal->j_running_transaction) {
1553 transaction = journal->j_running_transaction;
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001554 __jbd2_log_start_commit(journal, transaction->t_tid);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001555 } else if (journal->j_committing_transaction)
1556 transaction = journal->j_committing_transaction;
1557
1558 /* Wait for the log commit to complete... */
1559 if (transaction) {
1560 tid_t tid = transaction->t_tid;
1561
1562 spin_unlock(&journal->j_state_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001563 jbd2_log_wait_commit(journal, tid);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001564 } else {
1565 spin_unlock(&journal->j_state_lock);
1566 }
1567
1568 /* ...and flush everything in the log out to disk. */
1569 spin_lock(&journal->j_list_lock);
1570 while (!err && journal->j_checkpoint_transactions != NULL) {
1571 spin_unlock(&journal->j_list_lock);
Hidehiro Kawai44519fa2008-10-10 20:29:13 -04001572 mutex_lock(&journal->j_checkpoint_mutex);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001573 err = jbd2_log_do_checkpoint(journal);
Hidehiro Kawai44519fa2008-10-10 20:29:13 -04001574 mutex_unlock(&journal->j_checkpoint_mutex);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001575 spin_lock(&journal->j_list_lock);
1576 }
1577 spin_unlock(&journal->j_list_lock);
Hidehiro Kawai44519fa2008-10-10 20:29:13 -04001578
1579 if (is_journal_aborted(journal))
1580 return -EIO;
1581
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001582 jbd2_cleanup_journal_tail(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001583
1584 /* Finally, mark the journal as really needing no recovery.
1585 * This sets s_start==0 in the underlying superblock, which is
1586 * the magic code for a fully-recovered superblock. Any future
1587 * commits of data to the journal will restore the current
1588 * s_start value. */
1589 spin_lock(&journal->j_state_lock);
1590 old_tail = journal->j_tail;
1591 journal->j_tail = 0;
1592 spin_unlock(&journal->j_state_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001593 jbd2_journal_update_superblock(journal, 1);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001594 spin_lock(&journal->j_state_lock);
1595 journal->j_tail = old_tail;
1596
1597 J_ASSERT(!journal->j_running_transaction);
1598 J_ASSERT(!journal->j_committing_transaction);
1599 J_ASSERT(!journal->j_checkpoint_transactions);
1600 J_ASSERT(journal->j_head == journal->j_tail);
1601 J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence);
1602 spin_unlock(&journal->j_state_lock);
Hidehiro Kawai44519fa2008-10-10 20:29:13 -04001603 return 0;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001604}
1605
1606/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001607 * int jbd2_journal_wipe() - Wipe journal contents
Dave Kleikamp470decc2006-10-11 01:20:57 -07001608 * @journal: Journal to act on.
1609 * @write: flag (see below)
1610 *
1611 * Wipe out all of the contents of a journal, safely. This will produce
1612 * a warning if the journal contains any valid recovery information.
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001613 * Must be called between journal_init_*() and jbd2_journal_load().
Dave Kleikamp470decc2006-10-11 01:20:57 -07001614 *
1615 * If 'write' is non-zero, then we wipe out the journal on disk; otherwise
1616 * we merely suppress recovery.
1617 */
1618
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001619int jbd2_journal_wipe(journal_t *journal, int write)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001620{
1621 journal_superblock_t *sb;
1622 int err = 0;
1623
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001624 J_ASSERT (!(journal->j_flags & JBD2_LOADED));
Dave Kleikamp470decc2006-10-11 01:20:57 -07001625
1626 err = load_superblock(journal);
1627 if (err)
1628 return err;
1629
1630 sb = journal->j_superblock;
1631
1632 if (!journal->j_tail)
1633 goto no_recovery;
1634
1635 printk (KERN_WARNING "JBD: %s recovery information on journal\n",
1636 write ? "Clearing" : "Ignoring");
1637
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001638 err = jbd2_journal_skip_recovery(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001639 if (write)
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001640 jbd2_journal_update_superblock(journal, 1);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001641
1642 no_recovery:
1643 return err;
1644}
1645
1646/*
Dave Kleikamp470decc2006-10-11 01:20:57 -07001647 * Journal abort has very specific semantics, which we describe
1648 * for journal abort.
1649 *
Alberto Bertoglibfcd3552009-06-09 00:06:20 -04001650 * Two internal functions, which provide abort to the jbd layer
Dave Kleikamp470decc2006-10-11 01:20:57 -07001651 * itself are here.
1652 */
1653
1654/*
1655 * Quick version for internal journal use (doesn't lock the journal).
1656 * Aborts hard --- we mark the abort as occurred, but do _nothing_ else,
1657 * and don't attempt to make any other journal updates.
1658 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001659void __jbd2_journal_abort_hard(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001660{
1661 transaction_t *transaction;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001662
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001663 if (journal->j_flags & JBD2_ABORT)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001664 return;
1665
1666 printk(KERN_ERR "Aborting journal on device %s.\n",
Theodore Ts'o05496762008-09-16 14:36:17 -04001667 journal->j_devname);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001668
1669 spin_lock(&journal->j_state_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001670 journal->j_flags |= JBD2_ABORT;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001671 transaction = journal->j_running_transaction;
1672 if (transaction)
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001673 __jbd2_log_start_commit(journal, transaction->t_tid);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001674 spin_unlock(&journal->j_state_lock);
1675}
1676
1677/* Soft abort: record the abort error status in the journal superblock,
1678 * but don't do any other IO. */
1679static void __journal_abort_soft (journal_t *journal, int errno)
1680{
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001681 if (journal->j_flags & JBD2_ABORT)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001682 return;
1683
1684 if (!journal->j_errno)
1685 journal->j_errno = errno;
1686
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001687 __jbd2_journal_abort_hard(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001688
1689 if (errno)
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001690 jbd2_journal_update_superblock(journal, 1);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001691}
1692
1693/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001694 * void jbd2_journal_abort () - Shutdown the journal immediately.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001695 * @journal: the journal to shutdown.
1696 * @errno: an error number to record in the journal indicating
1697 * the reason for the shutdown.
1698 *
1699 * Perform a complete, immediate shutdown of the ENTIRE
1700 * journal (not of a single transaction). This operation cannot be
1701 * undone without closing and reopening the journal.
1702 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001703 * The jbd2_journal_abort function is intended to support higher level error
Dave Kleikamp470decc2006-10-11 01:20:57 -07001704 * recovery mechanisms such as the ext2/ext3 remount-readonly error
1705 * mode.
1706 *
1707 * Journal abort has very specific semantics. Any existing dirty,
1708 * unjournaled buffers in the main filesystem will still be written to
1709 * disk by bdflush, but the journaling mechanism will be suspended
1710 * immediately and no further transaction commits will be honoured.
1711 *
1712 * Any dirty, journaled buffers will be written back to disk without
1713 * hitting the journal. Atomicity cannot be guaranteed on an aborted
1714 * filesystem, but we _do_ attempt to leave as much data as possible
1715 * behind for fsck to use for cleanup.
1716 *
1717 * Any attempt to get a new transaction handle on a journal which is in
1718 * ABORT state will just result in an -EROFS error return. A
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001719 * jbd2_journal_stop on an existing handle will return -EIO if we have
Dave Kleikamp470decc2006-10-11 01:20:57 -07001720 * entered abort state during the update.
1721 *
1722 * Recursive transactions are not disturbed by journal abort until the
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001723 * final jbd2_journal_stop, which will receive the -EIO error.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001724 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001725 * Finally, the jbd2_journal_abort call allows the caller to supply an errno
Dave Kleikamp470decc2006-10-11 01:20:57 -07001726 * which will be recorded (if possible) in the journal superblock. This
1727 * allows a client to record failure conditions in the middle of a
1728 * transaction without having to complete the transaction to record the
1729 * failure to disk. ext3_error, for example, now uses this
1730 * functionality.
1731 *
1732 * Errors which originate from within the journaling layer will NOT
1733 * supply an errno; a null errno implies that absolutely no further
1734 * writes are done to the journal (unless there are any already in
1735 * progress).
1736 *
1737 */
1738
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001739void jbd2_journal_abort(journal_t *journal, int errno)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001740{
1741 __journal_abort_soft(journal, errno);
1742}
1743
1744/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001745 * int jbd2_journal_errno () - returns the journal's error state.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001746 * @journal: journal to examine.
1747 *
Alberto Bertoglibfcd3552009-06-09 00:06:20 -04001748 * This is the errno number set with jbd2_journal_abort(), the last
Dave Kleikamp470decc2006-10-11 01:20:57 -07001749 * time the journal was mounted - if the journal was stopped
1750 * without calling abort this will be 0.
1751 *
1752 * If the journal has been aborted on this mount time -EROFS will
1753 * be returned.
1754 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001755int jbd2_journal_errno(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001756{
1757 int err;
1758
1759 spin_lock(&journal->j_state_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001760 if (journal->j_flags & JBD2_ABORT)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001761 err = -EROFS;
1762 else
1763 err = journal->j_errno;
1764 spin_unlock(&journal->j_state_lock);
1765 return err;
1766}
1767
1768/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001769 * int jbd2_journal_clear_err () - clears the journal's error state
Dave Kleikamp470decc2006-10-11 01:20:57 -07001770 * @journal: journal to act on.
1771 *
Alberto Bertoglibfcd3552009-06-09 00:06:20 -04001772 * An error must be cleared or acked to take a FS out of readonly
Dave Kleikamp470decc2006-10-11 01:20:57 -07001773 * mode.
1774 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001775int jbd2_journal_clear_err(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001776{
1777 int err = 0;
1778
1779 spin_lock(&journal->j_state_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001780 if (journal->j_flags & JBD2_ABORT)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001781 err = -EROFS;
1782 else
1783 journal->j_errno = 0;
1784 spin_unlock(&journal->j_state_lock);
1785 return err;
1786}
1787
1788/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001789 * void jbd2_journal_ack_err() - Ack journal err.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001790 * @journal: journal to act on.
1791 *
Alberto Bertoglibfcd3552009-06-09 00:06:20 -04001792 * An error must be cleared or acked to take a FS out of readonly
Dave Kleikamp470decc2006-10-11 01:20:57 -07001793 * mode.
1794 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001795void jbd2_journal_ack_err(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001796{
1797 spin_lock(&journal->j_state_lock);
1798 if (journal->j_errno)
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001799 journal->j_flags |= JBD2_ACK_ERR;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001800 spin_unlock(&journal->j_state_lock);
1801}
1802
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001803int jbd2_journal_blocks_per_page(struct inode *inode)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001804{
1805 return 1 << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
1806}
1807
1808/*
Zach Brownb517bea2006-10-11 01:21:08 -07001809 * helper functions to deal with 32 or 64bit block numbers.
1810 */
1811size_t journal_tag_bytes(journal_t *journal)
1812{
1813 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT))
Mingming Caocd02ff02007-10-16 18:38:25 -04001814 return JBD2_TAG_SIZE64;
Zach Brownb517bea2006-10-11 01:21:08 -07001815 else
Mingming Caocd02ff02007-10-16 18:38:25 -04001816 return JBD2_TAG_SIZE32;
Zach Brownb517bea2006-10-11 01:21:08 -07001817}
1818
1819/*
Theodore Ts'od2eecb02009-12-07 10:36:20 -05001820 * JBD memory management
1821 *
1822 * These functions are used to allocate block-sized chunks of memory
1823 * used for making copies of buffer_head data. Very often it will be
1824 * page-sized chunks of data, but sometimes it will be in
1825 * sub-page-size chunks. (For example, 16k pages on Power systems
1826 * with a 4k block file system.) For blocks smaller than a page, we
1827 * use a SLAB allocator. There are slab caches for each block size,
1828 * which are allocated at mount time, if necessary, and we only free
1829 * (all of) the slab caches when/if the jbd2 module is unloaded. For
1830 * this reason we don't need to a mutex to protect access to
1831 * jbd2_slab[] allocating or releasing memory; only in
1832 * jbd2_journal_create_slab().
1833 */
1834#define JBD2_MAX_SLABS 8
1835static struct kmem_cache *jbd2_slab[JBD2_MAX_SLABS];
1836static DECLARE_MUTEX(jbd2_slab_create_sem);
1837
1838static const char *jbd2_slab_names[JBD2_MAX_SLABS] = {
1839 "jbd2_1k", "jbd2_2k", "jbd2_4k", "jbd2_8k",
1840 "jbd2_16k", "jbd2_32k", "jbd2_64k", "jbd2_128k"
1841};
1842
1843
1844static void jbd2_journal_destroy_slabs(void)
1845{
1846 int i;
1847
1848 for (i = 0; i < JBD2_MAX_SLABS; i++) {
1849 if (jbd2_slab[i])
1850 kmem_cache_destroy(jbd2_slab[i]);
1851 jbd2_slab[i] = NULL;
1852 }
1853}
1854
1855static int jbd2_journal_create_slab(size_t size)
1856{
1857 int i = order_base_2(size) - 10;
1858 size_t slab_size;
1859
1860 if (size == PAGE_SIZE)
1861 return 0;
1862
1863 if (i >= JBD2_MAX_SLABS)
1864 return -EINVAL;
1865
1866 if (unlikely(i < 0))
1867 i = 0;
1868 down(&jbd2_slab_create_sem);
1869 if (jbd2_slab[i]) {
1870 up(&jbd2_slab_create_sem);
1871 return 0; /* Already created */
1872 }
1873
1874 slab_size = 1 << (i+10);
1875 jbd2_slab[i] = kmem_cache_create(jbd2_slab_names[i], slab_size,
1876 slab_size, 0, NULL);
1877 up(&jbd2_slab_create_sem);
1878 if (!jbd2_slab[i]) {
1879 printk(KERN_EMERG "JBD2: no memory for jbd2_slab cache\n");
1880 return -ENOMEM;
1881 }
1882 return 0;
1883}
1884
1885static struct kmem_cache *get_slab(size_t size)
1886{
1887 int i = order_base_2(size) - 10;
1888
1889 BUG_ON(i >= JBD2_MAX_SLABS);
1890 if (unlikely(i < 0))
1891 i = 0;
1892 BUG_ON(jbd2_slab[i] == 0);
1893 return jbd2_slab[i];
1894}
1895
1896void *jbd2_alloc(size_t size, gfp_t flags)
1897{
1898 void *ptr;
1899
1900 BUG_ON(size & (size-1)); /* Must be a power of 2 */
1901
1902 flags |= __GFP_REPEAT;
1903 if (size == PAGE_SIZE)
1904 ptr = (void *)__get_free_pages(flags, 0);
1905 else if (size > PAGE_SIZE) {
1906 int order = get_order(size);
1907
1908 if (order < 3)
1909 ptr = (void *)__get_free_pages(flags, order);
1910 else
1911 ptr = vmalloc(size);
1912 } else
1913 ptr = kmem_cache_alloc(get_slab(size), flags);
1914
1915 /* Check alignment; SLUB has gotten this wrong in the past,
1916 * and this can lead to user data corruption! */
1917 BUG_ON(((unsigned long) ptr) & (size-1));
1918
1919 return ptr;
1920}
1921
1922void jbd2_free(void *ptr, size_t size)
1923{
1924 if (size == PAGE_SIZE) {
1925 free_pages((unsigned long)ptr, 0);
1926 return;
1927 }
1928 if (size > PAGE_SIZE) {
1929 int order = get_order(size);
1930
1931 if (order < 3)
1932 free_pages((unsigned long)ptr, order);
1933 else
1934 vfree(ptr);
1935 return;
1936 }
1937 kmem_cache_free(get_slab(size), ptr);
1938};
1939
1940/*
Dave Kleikamp470decc2006-10-11 01:20:57 -07001941 * Journal_head storage management
1942 */
Christoph Lametere18b8902006-12-06 20:33:20 -08001943static struct kmem_cache *jbd2_journal_head_cache;
Jose R. Santose23291b2007-07-18 08:57:06 -04001944#ifdef CONFIG_JBD2_DEBUG
Dave Kleikamp470decc2006-10-11 01:20:57 -07001945static atomic_t nr_journal_heads = ATOMIC_INIT(0);
1946#endif
1947
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001948static int journal_init_jbd2_journal_head_cache(void)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001949{
1950 int retval;
1951
Al Viro1076d172008-03-29 03:07:18 +00001952 J_ASSERT(jbd2_journal_head_cache == NULL);
Johann Lombardia920e942006-10-11 01:21:00 -07001953 jbd2_journal_head_cache = kmem_cache_create("jbd2_journal_head",
Dave Kleikamp470decc2006-10-11 01:20:57 -07001954 sizeof(struct journal_head),
1955 0, /* offset */
Mingming Cao77160952008-01-28 23:58:27 -05001956 SLAB_TEMPORARY, /* flags */
Paul Mundt20c2df82007-07-20 10:11:58 +09001957 NULL); /* ctor */
Dave Kleikamp470decc2006-10-11 01:20:57 -07001958 retval = 0;
Al Viro1076d172008-03-29 03:07:18 +00001959 if (!jbd2_journal_head_cache) {
Dave Kleikamp470decc2006-10-11 01:20:57 -07001960 retval = -ENOMEM;
1961 printk(KERN_EMERG "JBD: no memory for journal_head cache\n");
1962 }
1963 return retval;
1964}
1965
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001966static void jbd2_journal_destroy_jbd2_journal_head_cache(void)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001967{
Duane Griffin8a9362e2008-04-17 10:38:59 -04001968 if (jbd2_journal_head_cache) {
1969 kmem_cache_destroy(jbd2_journal_head_cache);
1970 jbd2_journal_head_cache = NULL;
1971 }
Dave Kleikamp470decc2006-10-11 01:20:57 -07001972}
1973
1974/*
1975 * journal_head splicing and dicing
1976 */
1977static struct journal_head *journal_alloc_journal_head(void)
1978{
1979 struct journal_head *ret;
1980 static unsigned long last_warning;
1981
Jose R. Santose23291b2007-07-18 08:57:06 -04001982#ifdef CONFIG_JBD2_DEBUG
Dave Kleikamp470decc2006-10-11 01:20:57 -07001983 atomic_inc(&nr_journal_heads);
1984#endif
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001985 ret = kmem_cache_alloc(jbd2_journal_head_cache, GFP_NOFS);
Al Viro1076d172008-03-29 03:07:18 +00001986 if (!ret) {
Dave Kleikamp470decc2006-10-11 01:20:57 -07001987 jbd_debug(1, "out of memory for journal_head\n");
1988 if (time_after(jiffies, last_warning + 5*HZ)) {
1989 printk(KERN_NOTICE "ENOMEM in %s, retrying.\n",
Harvey Harrison329d2912008-04-17 10:38:59 -04001990 __func__);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001991 last_warning = jiffies;
1992 }
Al Viro1076d172008-03-29 03:07:18 +00001993 while (!ret) {
Dave Kleikamp470decc2006-10-11 01:20:57 -07001994 yield();
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001995 ret = kmem_cache_alloc(jbd2_journal_head_cache, GFP_NOFS);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001996 }
1997 }
1998 return ret;
1999}
2000
2001static void journal_free_journal_head(struct journal_head *jh)
2002{
Jose R. Santose23291b2007-07-18 08:57:06 -04002003#ifdef CONFIG_JBD2_DEBUG
Dave Kleikamp470decc2006-10-11 01:20:57 -07002004 atomic_dec(&nr_journal_heads);
Mingming Caocd02ff02007-10-16 18:38:25 -04002005 memset(jh, JBD2_POISON_FREE, sizeof(*jh));
Dave Kleikamp470decc2006-10-11 01:20:57 -07002006#endif
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002007 kmem_cache_free(jbd2_journal_head_cache, jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002008}
2009
2010/*
2011 * A journal_head is attached to a buffer_head whenever JBD has an
2012 * interest in the buffer.
2013 *
2014 * Whenever a buffer has an attached journal_head, its ->b_state:BH_JBD bit
2015 * is set. This bit is tested in core kernel code where we need to take
2016 * JBD-specific actions. Testing the zeroness of ->b_private is not reliable
2017 * there.
2018 *
2019 * When a buffer has its BH_JBD bit set, its ->b_count is elevated by one.
2020 *
2021 * When a buffer has its BH_JBD bit set it is immune from being released by
2022 * core kernel code, mainly via ->b_count.
2023 *
2024 * A journal_head may be detached from its buffer_head when the journal_head's
2025 * b_transaction, b_cp_transaction and b_next_transaction pointers are NULL.
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002026 * Various places in JBD call jbd2_journal_remove_journal_head() to indicate that the
Dave Kleikamp470decc2006-10-11 01:20:57 -07002027 * journal_head can be dropped if needed.
2028 *
2029 * Various places in the kernel want to attach a journal_head to a buffer_head
2030 * _before_ attaching the journal_head to a transaction. To protect the
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002031 * journal_head in this situation, jbd2_journal_add_journal_head elevates the
Dave Kleikamp470decc2006-10-11 01:20:57 -07002032 * journal_head's b_jcount refcount by one. The caller must call
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002033 * jbd2_journal_put_journal_head() to undo this.
Dave Kleikamp470decc2006-10-11 01:20:57 -07002034 *
2035 * So the typical usage would be:
2036 *
2037 * (Attach a journal_head if needed. Increments b_jcount)
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002038 * struct journal_head *jh = jbd2_journal_add_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002039 * ...
2040 * jh->b_transaction = xxx;
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002041 * jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002042 *
2043 * Now, the journal_head's b_jcount is zero, but it is safe from being released
2044 * because it has a non-zero b_transaction.
2045 */
2046
2047/*
2048 * Give a buffer_head a journal_head.
2049 *
2050 * Doesn't need the journal lock.
2051 * May sleep.
2052 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002053struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07002054{
2055 struct journal_head *jh;
2056 struct journal_head *new_jh = NULL;
2057
2058repeat:
2059 if (!buffer_jbd(bh)) {
2060 new_jh = journal_alloc_journal_head();
2061 memset(new_jh, 0, sizeof(*new_jh));
2062 }
2063
2064 jbd_lock_bh_journal_head(bh);
2065 if (buffer_jbd(bh)) {
2066 jh = bh2jh(bh);
2067 } else {
2068 J_ASSERT_BH(bh,
2069 (atomic_read(&bh->b_count) > 0) ||
2070 (bh->b_page && bh->b_page->mapping));
2071
2072 if (!new_jh) {
2073 jbd_unlock_bh_journal_head(bh);
2074 goto repeat;
2075 }
2076
2077 jh = new_jh;
2078 new_jh = NULL; /* We consumed it */
2079 set_buffer_jbd(bh);
2080 bh->b_private = jh;
2081 jh->b_bh = bh;
2082 get_bh(bh);
2083 BUFFER_TRACE(bh, "added journal_head");
2084 }
2085 jh->b_jcount++;
2086 jbd_unlock_bh_journal_head(bh);
2087 if (new_jh)
2088 journal_free_journal_head(new_jh);
2089 return bh->b_private;
2090}
2091
2092/*
2093 * Grab a ref against this buffer_head's journal_head. If it ended up not
2094 * having a journal_head, return NULL
2095 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002096struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07002097{
2098 struct journal_head *jh = NULL;
2099
2100 jbd_lock_bh_journal_head(bh);
2101 if (buffer_jbd(bh)) {
2102 jh = bh2jh(bh);
2103 jh->b_jcount++;
2104 }
2105 jbd_unlock_bh_journal_head(bh);
2106 return jh;
2107}
2108
2109static void __journal_remove_journal_head(struct buffer_head *bh)
2110{
2111 struct journal_head *jh = bh2jh(bh);
2112
2113 J_ASSERT_JH(jh, jh->b_jcount >= 0);
2114
2115 get_bh(bh);
2116 if (jh->b_jcount == 0) {
2117 if (jh->b_transaction == NULL &&
2118 jh->b_next_transaction == NULL &&
2119 jh->b_cp_transaction == NULL) {
2120 J_ASSERT_JH(jh, jh->b_jlist == BJ_None);
2121 J_ASSERT_BH(bh, buffer_jbd(bh));
2122 J_ASSERT_BH(bh, jh2bh(jh) == bh);
2123 BUFFER_TRACE(bh, "remove journal_head");
2124 if (jh->b_frozen_data) {
2125 printk(KERN_WARNING "%s: freeing "
2126 "b_frozen_data\n",
Harvey Harrison329d2912008-04-17 10:38:59 -04002127 __func__);
Mingming Caoaf1e76d2007-10-16 18:38:25 -04002128 jbd2_free(jh->b_frozen_data, bh->b_size);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002129 }
2130 if (jh->b_committed_data) {
2131 printk(KERN_WARNING "%s: freeing "
2132 "b_committed_data\n",
Harvey Harrison329d2912008-04-17 10:38:59 -04002133 __func__);
Mingming Caoaf1e76d2007-10-16 18:38:25 -04002134 jbd2_free(jh->b_committed_data, bh->b_size);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002135 }
2136 bh->b_private = NULL;
2137 jh->b_bh = NULL; /* debug, really */
2138 clear_buffer_jbd(bh);
2139 __brelse(bh);
2140 journal_free_journal_head(jh);
2141 } else {
2142 BUFFER_TRACE(bh, "journal_head was locked");
2143 }
2144 }
2145}
2146
2147/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002148 * jbd2_journal_remove_journal_head(): if the buffer isn't attached to a transaction
Dave Kleikamp470decc2006-10-11 01:20:57 -07002149 * and has a zero b_jcount then remove and release its journal_head. If we did
2150 * see that the buffer is not used by any transaction we also "logically"
2151 * decrement ->b_count.
2152 *
2153 * We in fact take an additional increment on ->b_count as a convenience,
2154 * because the caller usually wants to do additional things with the bh
2155 * after calling here.
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002156 * The caller of jbd2_journal_remove_journal_head() *must* run __brelse(bh) at some
Dave Kleikamp470decc2006-10-11 01:20:57 -07002157 * time. Once the caller has run __brelse(), the buffer is eligible for
2158 * reaping by try_to_free_buffers().
2159 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002160void jbd2_journal_remove_journal_head(struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07002161{
2162 jbd_lock_bh_journal_head(bh);
2163 __journal_remove_journal_head(bh);
2164 jbd_unlock_bh_journal_head(bh);
2165}
2166
2167/*
2168 * Drop a reference on the passed journal_head. If it fell to zero then try to
2169 * release the journal_head from the buffer_head.
2170 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002171void jbd2_journal_put_journal_head(struct journal_head *jh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07002172{
2173 struct buffer_head *bh = jh2bh(jh);
2174
2175 jbd_lock_bh_journal_head(bh);
2176 J_ASSERT_JH(jh, jh->b_jcount > 0);
2177 --jh->b_jcount;
2178 if (!jh->b_jcount && !jh->b_transaction) {
2179 __journal_remove_journal_head(bh);
2180 __brelse(bh);
2181 }
2182 jbd_unlock_bh_journal_head(bh);
2183}
2184
2185/*
Jan Karac851ed52008-07-11 19:27:31 -04002186 * Initialize jbd inode head
2187 */
2188void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode)
2189{
2190 jinode->i_transaction = NULL;
2191 jinode->i_next_transaction = NULL;
2192 jinode->i_vfs_inode = inode;
2193 jinode->i_flags = 0;
2194 INIT_LIST_HEAD(&jinode->i_list);
2195}
2196
2197/*
2198 * Function to be called before we start removing inode from memory (i.e.,
2199 * clear_inode() is a fine place to be called from). It removes inode from
2200 * transaction's lists.
2201 */
2202void jbd2_journal_release_jbd_inode(journal_t *journal,
2203 struct jbd2_inode *jinode)
2204{
2205 int writeout = 0;
2206
2207 if (!journal)
2208 return;
2209restart:
2210 spin_lock(&journal->j_list_lock);
2211 /* Is commit writing out inode - we have to wait */
2212 if (jinode->i_flags & JI_COMMIT_RUNNING) {
2213 wait_queue_head_t *wq;
2214 DEFINE_WAIT_BIT(wait, &jinode->i_flags, __JI_COMMIT_RUNNING);
2215 wq = bit_waitqueue(&jinode->i_flags, __JI_COMMIT_RUNNING);
2216 prepare_to_wait(wq, &wait.wait, TASK_UNINTERRUPTIBLE);
2217 spin_unlock(&journal->j_list_lock);
2218 schedule();
2219 finish_wait(wq, &wait.wait);
2220 goto restart;
2221 }
2222
2223 /* Do we need to wait for data writeback? */
2224 if (journal->j_committing_transaction == jinode->i_transaction)
2225 writeout = 1;
2226 if (jinode->i_transaction) {
2227 list_del(&jinode->i_list);
2228 jinode->i_transaction = NULL;
2229 }
2230 spin_unlock(&journal->j_list_lock);
2231}
2232
2233/*
Jose R. Santos0f49d5d2007-07-18 08:50:18 -04002234 * debugfs tunables
Dave Kleikamp470decc2006-10-11 01:20:57 -07002235 */
Jose R. Santos6f38c742007-10-16 18:38:25 -04002236#ifdef CONFIG_JBD2_DEBUG
2237u8 jbd2_journal_enable_debug __read_mostly;
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002238EXPORT_SYMBOL(jbd2_journal_enable_debug);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002239
Jose R. Santos0f49d5d2007-07-18 08:50:18 -04002240#define JBD2_DEBUG_NAME "jbd2-debug"
Dave Kleikamp470decc2006-10-11 01:20:57 -07002241
Jose R. Santos6f38c742007-10-16 18:38:25 -04002242static struct dentry *jbd2_debugfs_dir;
2243static struct dentry *jbd2_debug;
Jose R. Santos0f49d5d2007-07-18 08:50:18 -04002244
2245static void __init jbd2_create_debugfs_entry(void)
Dave Kleikamp470decc2006-10-11 01:20:57 -07002246{
Jose R. Santos0f49d5d2007-07-18 08:50:18 -04002247 jbd2_debugfs_dir = debugfs_create_dir("jbd2", NULL);
2248 if (jbd2_debugfs_dir)
Yin Kangkai765f8362009-12-15 14:48:25 -08002249 jbd2_debug = debugfs_create_u8(JBD2_DEBUG_NAME,
2250 S_IRUGO | S_IWUSR,
Jose R. Santos0f49d5d2007-07-18 08:50:18 -04002251 jbd2_debugfs_dir,
2252 &jbd2_journal_enable_debug);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002253}
2254
Jose R. Santos0f49d5d2007-07-18 08:50:18 -04002255static void __exit jbd2_remove_debugfs_entry(void)
Dave Kleikamp470decc2006-10-11 01:20:57 -07002256{
Jose R. Santos6f38c742007-10-16 18:38:25 -04002257 debugfs_remove(jbd2_debug);
2258 debugfs_remove(jbd2_debugfs_dir);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002259}
2260
2261#else
2262
Jose R. Santos0f49d5d2007-07-18 08:50:18 -04002263static void __init jbd2_create_debugfs_entry(void)
2264{
Jose R. Santos0f49d5d2007-07-18 08:50:18 -04002265}
2266
2267static void __exit jbd2_remove_debugfs_entry(void)
2268{
Jose R. Santos0f49d5d2007-07-18 08:50:18 -04002269}
Dave Kleikamp470decc2006-10-11 01:20:57 -07002270
2271#endif
2272
Johann Lombardi8e85fb32008-01-28 23:58:27 -05002273#ifdef CONFIG_PROC_FS
2274
2275#define JBD2_STATS_PROC_NAME "fs/jbd2"
2276
2277static void __init jbd2_create_jbd_stats_proc_entry(void)
2278{
2279 proc_jbd2_stats = proc_mkdir(JBD2_STATS_PROC_NAME, NULL);
2280}
2281
2282static void __exit jbd2_remove_jbd_stats_proc_entry(void)
2283{
2284 if (proc_jbd2_stats)
2285 remove_proc_entry(JBD2_STATS_PROC_NAME, NULL);
2286}
2287
2288#else
2289
2290#define jbd2_create_jbd_stats_proc_entry() do {} while (0)
2291#define jbd2_remove_jbd_stats_proc_entry() do {} while (0)
2292
2293#endif
2294
Christoph Lametere18b8902006-12-06 20:33:20 -08002295struct kmem_cache *jbd2_handle_cache;
Dave Kleikamp470decc2006-10-11 01:20:57 -07002296
2297static int __init journal_init_handle_cache(void)
2298{
Johann Lombardia920e942006-10-11 01:21:00 -07002299 jbd2_handle_cache = kmem_cache_create("jbd2_journal_handle",
Dave Kleikamp470decc2006-10-11 01:20:57 -07002300 sizeof(handle_t),
2301 0, /* offset */
Mingming Cao77160952008-01-28 23:58:27 -05002302 SLAB_TEMPORARY, /* flags */
Paul Mundt20c2df82007-07-20 10:11:58 +09002303 NULL); /* ctor */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002304 if (jbd2_handle_cache == NULL) {
Dave Kleikamp470decc2006-10-11 01:20:57 -07002305 printk(KERN_EMERG "JBD: failed to create handle cache\n");
2306 return -ENOMEM;
2307 }
2308 return 0;
2309}
2310
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002311static void jbd2_journal_destroy_handle_cache(void)
Dave Kleikamp470decc2006-10-11 01:20:57 -07002312{
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002313 if (jbd2_handle_cache)
2314 kmem_cache_destroy(jbd2_handle_cache);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002315}
2316
2317/*
2318 * Module startup and shutdown
2319 */
2320
2321static int __init journal_init_caches(void)
2322{
2323 int ret;
2324
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002325 ret = jbd2_journal_init_revoke_caches();
Dave Kleikamp470decc2006-10-11 01:20:57 -07002326 if (ret == 0)
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002327 ret = journal_init_jbd2_journal_head_cache();
Dave Kleikamp470decc2006-10-11 01:20:57 -07002328 if (ret == 0)
2329 ret = journal_init_handle_cache();
2330 return ret;
2331}
2332
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002333static void jbd2_journal_destroy_caches(void)
Dave Kleikamp470decc2006-10-11 01:20:57 -07002334{
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002335 jbd2_journal_destroy_revoke_caches();
2336 jbd2_journal_destroy_jbd2_journal_head_cache();
2337 jbd2_journal_destroy_handle_cache();
Theodore Ts'od2eecb02009-12-07 10:36:20 -05002338 jbd2_journal_destroy_slabs();
Dave Kleikamp470decc2006-10-11 01:20:57 -07002339}
2340
2341static int __init journal_init(void)
2342{
2343 int ret;
2344
2345 BUILD_BUG_ON(sizeof(struct journal_superblock_s) != 1024);
2346
2347 ret = journal_init_caches();
Duane Griffin620de4e2008-04-29 22:02:47 -04002348 if (ret == 0) {
2349 jbd2_create_debugfs_entry();
2350 jbd2_create_jbd_stats_proc_entry();
2351 } else {
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002352 jbd2_journal_destroy_caches();
Duane Griffin620de4e2008-04-29 22:02:47 -04002353 }
Dave Kleikamp470decc2006-10-11 01:20:57 -07002354 return ret;
2355}
2356
2357static void __exit journal_exit(void)
2358{
Jose R. Santose23291b2007-07-18 08:57:06 -04002359#ifdef CONFIG_JBD2_DEBUG
Dave Kleikamp470decc2006-10-11 01:20:57 -07002360 int n = atomic_read(&nr_journal_heads);
2361 if (n)
2362 printk(KERN_EMERG "JBD: leaked %d journal_heads!\n", n);
2363#endif
Jose R. Santos0f49d5d2007-07-18 08:50:18 -04002364 jbd2_remove_debugfs_entry();
Johann Lombardi8e85fb32008-01-28 23:58:27 -05002365 jbd2_remove_jbd_stats_proc_entry();
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002366 jbd2_journal_destroy_caches();
Dave Kleikamp470decc2006-10-11 01:20:57 -07002367}
2368
Theodore Ts'o879c5e62009-06-17 11:47:48 -04002369/*
2370 * jbd2_dev_to_name is a utility function used by the jbd2 and ext4
2371 * tracing infrastructure to map a dev_t to a device name.
2372 *
2373 * The caller should use rcu_read_lock() in order to make sure the
2374 * device name stays valid until its done with it. We use
2375 * rcu_read_lock() as well to make sure we're safe in case the caller
2376 * gets sloppy, and because rcu_read_lock() is cheap and can be safely
2377 * nested.
2378 */
2379struct devname_cache {
2380 struct rcu_head rcu;
2381 dev_t device;
2382 char devname[BDEVNAME_SIZE];
2383};
2384#define CACHE_SIZE_BITS 6
2385static struct devname_cache *devcache[1 << CACHE_SIZE_BITS];
2386static DEFINE_SPINLOCK(devname_cache_lock);
2387
2388static void free_devcache(struct rcu_head *rcu)
2389{
2390 kfree(rcu);
2391}
2392
2393const char *jbd2_dev_to_name(dev_t device)
2394{
2395 int i = hash_32(device, CACHE_SIZE_BITS);
2396 char *ret;
2397 struct block_device *bd;
Theodore Ts'ob5744802009-06-20 23:34:44 -04002398 static struct devname_cache *new_dev;
Theodore Ts'o879c5e62009-06-17 11:47:48 -04002399
2400 rcu_read_lock();
2401 if (devcache[i] && devcache[i]->device == device) {
2402 ret = devcache[i]->devname;
2403 rcu_read_unlock();
2404 return ret;
2405 }
2406 rcu_read_unlock();
2407
Theodore Ts'ob5744802009-06-20 23:34:44 -04002408 new_dev = kmalloc(sizeof(struct devname_cache), GFP_KERNEL);
2409 if (!new_dev)
2410 return "NODEV-ALLOCFAILURE"; /* Something non-NULL */
Theodore Ts'o879c5e62009-06-17 11:47:48 -04002411 spin_lock(&devname_cache_lock);
2412 if (devcache[i]) {
2413 if (devcache[i]->device == device) {
Theodore Ts'ob5744802009-06-20 23:34:44 -04002414 kfree(new_dev);
Theodore Ts'o879c5e62009-06-17 11:47:48 -04002415 ret = devcache[i]->devname;
2416 spin_unlock(&devname_cache_lock);
2417 return ret;
2418 }
2419 call_rcu(&devcache[i]->rcu, free_devcache);
2420 }
Theodore Ts'ob5744802009-06-20 23:34:44 -04002421 devcache[i] = new_dev;
Theodore Ts'o879c5e62009-06-17 11:47:48 -04002422 devcache[i]->device = device;
2423 bd = bdget(device);
2424 if (bd) {
2425 bdevname(bd, devcache[i]->devname);
2426 bdput(bd);
2427 } else
2428 __bdevname(device, devcache[i]->devname);
2429 ret = devcache[i]->devname;
2430 spin_unlock(&devname_cache_lock);
2431 return ret;
2432}
2433EXPORT_SYMBOL(jbd2_dev_to_name);
2434
Dave Kleikamp470decc2006-10-11 01:20:57 -07002435MODULE_LICENSE("GPL");
2436module_init(journal_init);
2437module_exit(journal_exit);
2438