1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include <linux/module.h>
26#include <linux/time.h>
27#include <linux/fs.h>
28#include <linux/jbd2.h>
29#include <linux/errno.h>
30#include <linux/slab.h>
31#include <linux/init.h>
32#include <linux/mm.h>
33#include <linux/freezer.h>
34#include <linux/pagemap.h>
35#include <linux/kthread.h>
36#include <linux/poison.h>
37#include <linux/proc_fs.h>
38#include <linux/debugfs.h>
39#include <linux/seq_file.h>
40#include <linux/math64.h>
41#include <linux/hash.h>
42#include <linux/log2.h>
43#include <linux/vmalloc.h>
44#include <linux/backing-dev.h>
45#include <linux/bitops.h>
46#include <linux/ratelimit.h>
47
48#define CREATE_TRACE_POINTS
49#include <trace/events/jbd2.h>
50
51#include <asm/uaccess.h>
52#include <asm/page.h>
53#include <asm/system.h>
54
55EXPORT_SYMBOL(jbd2_journal_extend);
56EXPORT_SYMBOL(jbd2_journal_stop);
57EXPORT_SYMBOL(jbd2_journal_lock_updates);
58EXPORT_SYMBOL(jbd2_journal_unlock_updates);
59EXPORT_SYMBOL(jbd2_journal_get_write_access);
60EXPORT_SYMBOL(jbd2_journal_get_create_access);
61EXPORT_SYMBOL(jbd2_journal_get_undo_access);
62EXPORT_SYMBOL(jbd2_journal_set_triggers);
63EXPORT_SYMBOL(jbd2_journal_dirty_metadata);
64EXPORT_SYMBOL(jbd2_journal_release_buffer);
65EXPORT_SYMBOL(jbd2_journal_forget);
66#if 0
67EXPORT_SYMBOL(journal_sync_buffer);
68#endif
69EXPORT_SYMBOL(jbd2_journal_flush);
70EXPORT_SYMBOL(jbd2_journal_revoke);
71
72EXPORT_SYMBOL(jbd2_journal_init_dev);
73EXPORT_SYMBOL(jbd2_journal_init_inode);
74EXPORT_SYMBOL(jbd2_journal_update_format);
75EXPORT_SYMBOL(jbd2_journal_check_used_features);
76EXPORT_SYMBOL(jbd2_journal_check_available_features);
77EXPORT_SYMBOL(jbd2_journal_set_features);
78EXPORT_SYMBOL(jbd2_journal_load);
79EXPORT_SYMBOL(jbd2_journal_destroy);
80EXPORT_SYMBOL(jbd2_journal_abort);
81EXPORT_SYMBOL(jbd2_journal_errno);
82EXPORT_SYMBOL(jbd2_journal_ack_err);
83EXPORT_SYMBOL(jbd2_journal_clear_err);
84EXPORT_SYMBOL(jbd2_log_wait_commit);
85EXPORT_SYMBOL(jbd2_log_start_commit);
86EXPORT_SYMBOL(jbd2_journal_start_commit);
87EXPORT_SYMBOL(jbd2_journal_force_commit_nested);
88EXPORT_SYMBOL(jbd2_journal_wipe);
89EXPORT_SYMBOL(jbd2_journal_blocks_per_page);
90EXPORT_SYMBOL(jbd2_journal_invalidatepage);
91EXPORT_SYMBOL(jbd2_journal_try_to_free_buffers);
92EXPORT_SYMBOL(jbd2_journal_force_commit);
93EXPORT_SYMBOL(jbd2_journal_file_inode);
94EXPORT_SYMBOL(jbd2_journal_init_jbd_inode);
95EXPORT_SYMBOL(jbd2_journal_release_jbd_inode);
96EXPORT_SYMBOL(jbd2_journal_begin_ordered_truncate);
97EXPORT_SYMBOL(jbd2_inode_cache);
98
99static int journal_convert_superblock_v1(journal_t *, journal_superblock_t *);
100static void __journal_abort_soft (journal_t *journal, int errno);
101static int jbd2_journal_create_slab(size_t slab_size);
102
103
104
105
106
107static void commit_timeout(unsigned long __data)
108{
109 struct task_struct * p = (struct task_struct *) __data;
110
111 wake_up_process(p);
112}
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130static int kjournald2(void *arg)
131{
132 journal_t *journal = arg;
133 transaction_t *transaction;
134
135
136
137
138
139 setup_timer(&journal->j_commit_timer, commit_timeout,
140 (unsigned long)current);
141
142
143 journal->j_task = current;
144 wake_up(&journal->j_wait_done_commit);
145
146
147
148
149 write_lock(&journal->j_state_lock);
150
151loop:
152 if (journal->j_flags & JBD2_UNMOUNT)
153 goto end_loop;
154
155 jbd_debug(1, "commit_sequence=%d, commit_request=%d\n",
156 journal->j_commit_sequence, journal->j_commit_request);
157
158 if (journal->j_commit_sequence != journal->j_commit_request) {
159 jbd_debug(1, "OK, requests differ\n");
160 write_unlock(&journal->j_state_lock);
161 del_timer_sync(&journal->j_commit_timer);
162 jbd2_journal_commit_transaction(journal);
163 write_lock(&journal->j_state_lock);
164 goto loop;
165 }
166
167 wake_up(&journal->j_wait_done_commit);
168 if (freezing(current)) {
169
170
171
172
173
174 jbd_debug(1, "Now suspending kjournald2\n");
175 write_unlock(&journal->j_state_lock);
176 refrigerator();
177 write_lock(&journal->j_state_lock);
178 } else {
179
180
181
182
183 DEFINE_WAIT(wait);
184 int should_sleep = 1;
185
186 prepare_to_wait(&journal->j_wait_commit, &wait,
187 TASK_INTERRUPTIBLE);
188 if (journal->j_commit_sequence != journal->j_commit_request)
189 should_sleep = 0;
190 transaction = journal->j_running_transaction;
191 if (transaction && time_after_eq(jiffies,
192 transaction->t_expires))
193 should_sleep = 0;
194 if (journal->j_flags & JBD2_UNMOUNT)
195 should_sleep = 0;
196 if (should_sleep) {
197 write_unlock(&journal->j_state_lock);
198 schedule();
199 write_lock(&journal->j_state_lock);
200 }
201 finish_wait(&journal->j_wait_commit, &wait);
202 }
203
204 jbd_debug(1, "kjournald2 wakes\n");
205
206
207
208
209 transaction = journal->j_running_transaction;
210 if (transaction && time_after_eq(jiffies, transaction->t_expires)) {
211 journal->j_commit_request = transaction->t_tid;
212 jbd_debug(1, "woke because of timeout\n");
213 }
214 goto loop;
215
216end_loop:
217 write_unlock(&journal->j_state_lock);
218 del_timer_sync(&journal->j_commit_timer);
219 journal->j_task = NULL;
220 wake_up(&journal->j_wait_done_commit);
221 jbd_debug(1, "Journal thread exiting.\n");
222 return 0;
223}
224
225static int jbd2_journal_start_thread(journal_t *journal)
226{
227 struct task_struct *t;
228
229 t = kthread_run(kjournald2, journal, "jbd2/%s",
230 journal->j_devname);
231 if (IS_ERR(t))
232 return PTR_ERR(t);
233
234 wait_event(journal->j_wait_done_commit, journal->j_task != NULL);
235 return 0;
236}
237
238static void journal_kill_thread(journal_t *journal)
239{
240 write_lock(&journal->j_state_lock);
241 journal->j_flags |= JBD2_UNMOUNT;
242
243 while (journal->j_task) {
244 wake_up(&journal->j_wait_commit);
245 write_unlock(&journal->j_state_lock);
246 wait_event(journal->j_wait_done_commit, journal->j_task == NULL);
247 write_lock(&journal->j_state_lock);
248 }
249 write_unlock(&journal->j_state_lock);
250}
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
290 struct journal_head *jh_in,
291 struct journal_head **jh_out,
292 unsigned long long blocknr)
293{
294 int need_copy_out = 0;
295 int done_copy_out = 0;
296 int do_escape = 0;
297 char *mapped_data;
298 struct buffer_head *new_bh;
299 struct journal_head *new_jh;
300 struct page *new_page;
301 unsigned int new_offset;
302 struct buffer_head *bh_in = jh2bh(jh_in);
303 journal_t *journal = transaction->t_journal;
304
305
306
307
308
309
310
311
312
313
314 J_ASSERT_BH(bh_in, buffer_jbddirty(bh_in));
315
316retry_alloc:
317 new_bh = alloc_buffer_head(GFP_NOFS);
318 if (!new_bh) {
319
320
321
322
323 congestion_wait(BLK_RW_ASYNC, HZ/50);
324 goto retry_alloc;
325 }
326
327
328 new_bh->b_state = 0;
329 init_buffer(new_bh, NULL, NULL);
330 atomic_set(&new_bh->b_count, 1);
331 new_jh = jbd2_journal_add_journal_head(new_bh);
332
333
334
335
336
337 jbd_lock_bh_state(bh_in);
338repeat:
339 if (jh_in->b_frozen_data) {
340 done_copy_out = 1;
341 new_page = virt_to_page(jh_in->b_frozen_data);
342 new_offset = offset_in_page(jh_in->b_frozen_data);
343 } else {
344 new_page = jh2bh(jh_in)->b_page;
345 new_offset = offset_in_page(jh2bh(jh_in)->b_data);
346 }
347
348 mapped_data = kmap_atomic(new_page, KM_USER0);
349
350
351
352
353
354
355 if (!done_copy_out)
356 jbd2_buffer_frozen_trigger(jh_in, mapped_data + new_offset,
357 jh_in->b_triggers);
358
359
360
361
362 if (*((__be32 *)(mapped_data + new_offset)) ==
363 cpu_to_be32(JBD2_MAGIC_NUMBER)) {
364 need_copy_out = 1;
365 do_escape = 1;
366 }
367 kunmap_atomic(mapped_data, KM_USER0);
368
369
370
371
372 if (need_copy_out && !done_copy_out) {
373 char *tmp;
374
375 jbd_unlock_bh_state(bh_in);
376 tmp = jbd2_alloc(bh_in->b_size, GFP_NOFS);
377 if (!tmp) {
378 jbd2_journal_put_journal_head(new_jh);
379 return -ENOMEM;
380 }
381 jbd_lock_bh_state(bh_in);
382 if (jh_in->b_frozen_data) {
383 jbd2_free(tmp, bh_in->b_size);
384 goto repeat;
385 }
386
387 jh_in->b_frozen_data = tmp;
388 mapped_data = kmap_atomic(new_page, KM_USER0);
389 memcpy(tmp, mapped_data + new_offset, jh2bh(jh_in)->b_size);
390 kunmap_atomic(mapped_data, KM_USER0);
391
392 new_page = virt_to_page(tmp);
393 new_offset = offset_in_page(tmp);
394 done_copy_out = 1;
395
396
397
398
399
400
401 jh_in->b_frozen_triggers = jh_in->b_triggers;
402 }
403
404
405
406
407
408 if (do_escape) {
409 mapped_data = kmap_atomic(new_page, KM_USER0);
410 *((unsigned int *)(mapped_data + new_offset)) = 0;
411 kunmap_atomic(mapped_data, KM_USER0);
412 }
413
414 set_bh_page(new_bh, new_page, new_offset);
415 new_jh->b_transaction = NULL;
416 new_bh->b_size = jh2bh(jh_in)->b_size;
417 new_bh->b_bdev = transaction->t_journal->j_dev;
418 new_bh->b_blocknr = blocknr;
419 set_buffer_mapped(new_bh);
420 set_buffer_dirty(new_bh);
421
422 *jh_out = new_jh;
423
424
425
426
427
428
429 JBUFFER_TRACE(jh_in, "file as BJ_Shadow");
430 spin_lock(&journal->j_list_lock);
431 __jbd2_journal_file_buffer(jh_in, transaction, BJ_Shadow);
432 spin_unlock(&journal->j_list_lock);
433 jbd_unlock_bh_state(bh_in);
434
435 JBUFFER_TRACE(new_jh, "file as BJ_IO");
436 jbd2_journal_file_buffer(new_jh, transaction, BJ_IO);
437
438 return do_escape | (done_copy_out << 1);
439}
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454int __jbd2_log_space_left(journal_t *journal)
455{
456 int left = journal->j_free;
457
458
459
460
461
462
463
464
465#define MIN_LOG_RESERVED_BLOCKS 32
466
467 left -= MIN_LOG_RESERVED_BLOCKS;
468
469 if (left <= 0)
470 return 0;
471 left -= (left >> 3);
472 return left;
473}
474
475
476
477
478
479int __jbd2_log_start_commit(journal_t *journal, tid_t target)
480{
481
482
483
484 if (!tid_geq(journal->j_commit_request, target)) {
485
486
487
488
489
490 journal->j_commit_request = target;
491 jbd_debug(1, "JBD: requesting commit %d/%d\n",
492 journal->j_commit_request,
493 journal->j_commit_sequence);
494 wake_up(&journal->j_wait_commit);
495 return 1;
496 }
497 return 0;
498}
499
500int jbd2_log_start_commit(journal_t *journal, tid_t tid)
501{
502 int ret;
503
504 write_lock(&journal->j_state_lock);
505 ret = __jbd2_log_start_commit(journal, tid);
506 write_unlock(&journal->j_state_lock);
507 return ret;
508}
509
510
511
512
513
514
515
516
517
518
519
520int jbd2_journal_force_commit_nested(journal_t *journal)
521{
522 transaction_t *transaction = NULL;
523 tid_t tid;
524 int need_to_start = 0;
525
526 read_lock(&journal->j_state_lock);
527 if (journal->j_running_transaction && !current->journal_info) {
528 transaction = journal->j_running_transaction;
529 if (!tid_geq(journal->j_commit_request, transaction->t_tid))
530 need_to_start = 1;
531 } else if (journal->j_committing_transaction)
532 transaction = journal->j_committing_transaction;
533
534 if (!transaction) {
535 read_unlock(&journal->j_state_lock);
536 return 0;
537 }
538
539 tid = transaction->t_tid;
540 read_unlock(&journal->j_state_lock);
541 if (need_to_start)
542 jbd2_log_start_commit(journal, tid);
543 jbd2_log_wait_commit(journal, tid);
544 return 1;
545}
546
547
548
549
550
551
552int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid)
553{
554 int ret = 0;
555
556 write_lock(&journal->j_state_lock);
557 if (journal->j_running_transaction) {
558 tid_t tid = journal->j_running_transaction->t_tid;
559
560 __jbd2_log_start_commit(journal, tid);
561
562
563 if (ptid)
564 *ptid = tid;
565 ret = 1;
566 } else if (journal->j_committing_transaction) {
567
568
569
570
571 if (ptid)
572 *ptid = journal->j_committing_transaction->t_tid;
573 ret = 1;
574 }
575 write_unlock(&journal->j_state_lock);
576 return ret;
577}
578
579
580
581
582
583int jbd2_log_wait_commit(journal_t *journal, tid_t tid)
584{
585 int err = 0;
586
587 read_lock(&journal->j_state_lock);
588#ifdef CONFIG_JBD2_DEBUG
589 if (!tid_geq(journal->j_commit_request, tid)) {
590 printk(KERN_EMERG
591 "%s: error: j_commit_request=%d, tid=%d\n",
592 __func__, journal->j_commit_request, tid);
593 }
594#endif
595 while (tid_gt(tid, journal->j_commit_sequence)) {
596 jbd_debug(1, "JBD: want %d, j_commit_sequence=%d\n",
597 tid, journal->j_commit_sequence);
598 wake_up(&journal->j_wait_commit);
599 read_unlock(&journal->j_state_lock);
600 wait_event(journal->j_wait_done_commit,
601 !tid_gt(tid, journal->j_commit_sequence));
602 read_lock(&journal->j_state_lock);
603 }
604 read_unlock(&journal->j_state_lock);
605
606 if (unlikely(is_journal_aborted(journal))) {
607 printk(KERN_EMERG "journal commit I/O error\n");
608 err = -EIO;
609 }
610 return err;
611}
612
613
614
615
616
617int jbd2_journal_next_log_block(journal_t *journal, unsigned long long *retp)
618{
619 unsigned long blocknr;
620
621 write_lock(&journal->j_state_lock);
622 J_ASSERT(journal->j_free > 1);
623
624 blocknr = journal->j_head;
625 journal->j_head++;
626 journal->j_free--;
627 if (journal->j_head == journal->j_last)
628 journal->j_head = journal->j_first;
629 write_unlock(&journal->j_state_lock);
630 return jbd2_journal_bmap(journal, blocknr, retp);
631}
632
633
634
635
636
637
638
639
640int jbd2_journal_bmap(journal_t *journal, unsigned long blocknr,
641 unsigned long long *retp)
642{
643 int err = 0;
644 unsigned long long ret;
645
646 if (journal->j_inode) {
647 ret = bmap(journal->j_inode, blocknr);
648 if (ret)
649 *retp = ret;
650 else {
651 printk(KERN_ALERT "%s: journal block not found "
652 "at offset %lu on %s\n",
653 __func__, blocknr, journal->j_devname);
654 err = -EIO;
655 __journal_abort_soft(journal, err);
656 }
657 } else {
658 *retp = blocknr;
659 }
660 return err;
661}
662
663
664
665
666
667
668
669
670
671
672
673struct journal_head *jbd2_journal_get_descriptor_buffer(journal_t *journal)
674{
675 struct buffer_head *bh;
676 unsigned long long blocknr;
677 int err;
678
679 err = jbd2_journal_next_log_block(journal, &blocknr);
680
681 if (err)
682 return NULL;
683
684 bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
685 if (!bh)
686 return NULL;
687 lock_buffer(bh);
688 memset(bh->b_data, 0, journal->j_blocksize);
689 set_buffer_uptodate(bh);
690 unlock_buffer(bh);
691 BUFFER_TRACE(bh, "return this buffer");
692 return jbd2_journal_add_journal_head(bh);
693}
694
695struct jbd2_stats_proc_session {
696 journal_t *journal;
697 struct transaction_stats_s *stats;
698 int start;
699 int max;
700};
701
702static void *jbd2_seq_info_start(struct seq_file *seq, loff_t *pos)
703{
704 return *pos ? NULL : SEQ_START_TOKEN;
705}
706
707static void *jbd2_seq_info_next(struct seq_file *seq, void *v, loff_t *pos)
708{
709 return NULL;
710}
711
712static int jbd2_seq_info_show(struct seq_file *seq, void *v)
713{
714 struct jbd2_stats_proc_session *s = seq->private;
715
716 if (v != SEQ_START_TOKEN)
717 return 0;
718 seq_printf(seq, "%lu transaction, each up to %u blocks\n",
719 s->stats->ts_tid,
720 s->journal->j_max_transaction_buffers);
721 if (s->stats->ts_tid == 0)
722 return 0;
723 seq_printf(seq, "average: \n %ums waiting for transaction\n",
724 jiffies_to_msecs(s->stats->run.rs_wait / s->stats->ts_tid));
725 seq_printf(seq, " %ums running transaction\n",
726 jiffies_to_msecs(s->stats->run.rs_running / s->stats->ts_tid));
727 seq_printf(seq, " %ums transaction was being locked\n",
728 jiffies_to_msecs(s->stats->run.rs_locked / s->stats->ts_tid));
729 seq_printf(seq, " %ums flushing data (in ordered mode)\n",
730 jiffies_to_msecs(s->stats->run.rs_flushing / s->stats->ts_tid));
731 seq_printf(seq, " %ums logging transaction\n",
732 jiffies_to_msecs(s->stats->run.rs_logging / s->stats->ts_tid));
733 seq_printf(seq, " %lluus average transaction commit time\n",
734 div_u64(s->journal->j_average_commit_time, 1000));
735 seq_printf(seq, " %lu handles per transaction\n",
736 s->stats->run.rs_handle_count / s->stats->ts_tid);
737 seq_printf(seq, " %lu blocks per transaction\n",
738 s->stats->run.rs_blocks / s->stats->ts_tid);
739 seq_printf(seq, " %lu logged blocks per transaction\n",
740 s->stats->run.rs_blocks_logged / s->stats->ts_tid);
741 return 0;
742}
743
744static void jbd2_seq_info_stop(struct seq_file *seq, void *v)
745{
746}
747
748static const struct seq_operations jbd2_seq_info_ops = {
749 .start = jbd2_seq_info_start,
750 .next = jbd2_seq_info_next,
751 .stop = jbd2_seq_info_stop,
752 .show = jbd2_seq_info_show,
753};
754
755static int jbd2_seq_info_open(struct inode *inode, struct file *file)
756{
757 journal_t *journal = PDE(inode)->data;
758 struct jbd2_stats_proc_session *s;
759 int rc, size;
760
761 s = kmalloc(sizeof(*s), GFP_KERNEL);
762 if (s == NULL)
763 return -ENOMEM;
764 size = sizeof(struct transaction_stats_s);
765 s->stats = kmalloc(size, GFP_KERNEL);
766 if (s->stats == NULL) {
767 kfree(s);
768 return -ENOMEM;
769 }
770 spin_lock(&journal->j_history_lock);
771 memcpy(s->stats, &journal->j_stats, size);
772 s->journal = journal;
773 spin_unlock(&journal->j_history_lock);
774
775 rc = seq_open(file, &jbd2_seq_info_ops);
776 if (rc == 0) {
777 struct seq_file *m = file->private_data;
778 m->private = s;
779 } else {
780 kfree(s->stats);
781 kfree(s);
782 }
783 return rc;
784
785}
786
787static int jbd2_seq_info_release(struct inode *inode, struct file *file)
788{
789 struct seq_file *seq = file->private_data;
790 struct jbd2_stats_proc_session *s = seq->private;
791 kfree(s->stats);
792 kfree(s);
793 return seq_release(inode, file);
794}
795
796static const struct file_operations jbd2_seq_info_fops = {
797 .owner = THIS_MODULE,
798 .open = jbd2_seq_info_open,
799 .read = seq_read,
800 .llseek = seq_lseek,
801 .release = jbd2_seq_info_release,
802};
803
804static struct proc_dir_entry *proc_jbd2_stats;
805
806static void jbd2_stats_proc_init(journal_t *journal)
807{
808 journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats);
809 if (journal->j_proc_entry) {
810 proc_create_data("info", S_IRUGO, journal->j_proc_entry,
811 &jbd2_seq_info_fops, journal);
812 }
813}
814
815static void jbd2_stats_proc_exit(journal_t *journal)
816{
817 remove_proc_entry("info", journal->j_proc_entry);
818 remove_proc_entry(journal->j_devname, proc_jbd2_stats);
819}
820
821
822
823
824
825
826
827
828
829
830static journal_t * journal_init_common (void)
831{
832 journal_t *journal;
833 int err;
834
835 journal = kzalloc(sizeof(*journal), GFP_KERNEL);
836 if (!journal)
837 return NULL;
838
839 init_waitqueue_head(&journal->j_wait_transaction_locked);
840 init_waitqueue_head(&journal->j_wait_logspace);
841 init_waitqueue_head(&journal->j_wait_done_commit);
842 init_waitqueue_head(&journal->j_wait_checkpoint);
843 init_waitqueue_head(&journal->j_wait_commit);
844 init_waitqueue_head(&journal->j_wait_updates);
845 mutex_init(&journal->j_barrier);
846 mutex_init(&journal->j_checkpoint_mutex);
847 spin_lock_init(&journal->j_revoke_lock);
848 spin_lock_init(&journal->j_list_lock);
849 rwlock_init(&journal->j_state_lock);
850
851 journal->j_commit_interval = (HZ * JBD2_DEFAULT_MAX_COMMIT_AGE);
852 journal->j_min_batch_time = 0;
853 journal->j_max_batch_time = 15000;
854
855
856 journal->j_flags = JBD2_ABORT;
857
858
859 err = jbd2_journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH);
860 if (err) {
861 kfree(journal);
862 return NULL;
863 }
864
865 spin_lock_init(&journal->j_history_lock);
866
867 return journal;
868}
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893journal_t * jbd2_journal_init_dev(struct block_device *bdev,
894 struct block_device *fs_dev,
895 unsigned long long start, int len, int blocksize)
896{
897 journal_t *journal = journal_init_common();
898 struct buffer_head *bh;
899 char *p;
900 int n;
901
902 if (!journal)
903 return NULL;
904
905
906 journal->j_blocksize = blocksize;
907 journal->j_dev = bdev;
908 journal->j_fs_dev = fs_dev;
909 journal->j_blk_offset = start;
910 journal->j_maxlen = len;
911 bdevname(journal->j_dev, journal->j_devname);
912 p = journal->j_devname;
913 while ((p = strchr(p, '/')))
914 *p = '!';
915 jbd2_stats_proc_init(journal);
916 n = journal->j_blocksize / sizeof(journal_block_tag_t);
917 journal->j_wbufsize = n;
918 journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
919 if (!journal->j_wbuf) {
920 printk(KERN_ERR "%s: Cant allocate bhs for commit thread\n",
921 __func__);
922 goto out_err;
923 }
924
925 bh = __getblk(journal->j_dev, start, journal->j_blocksize);
926 if (!bh) {
927 printk(KERN_ERR
928 "%s: Cannot get buffer for journal superblock\n",
929 __func__);
930 goto out_err;
931 }
932 journal->j_sb_buffer = bh;
933 journal->j_superblock = (journal_superblock_t *)bh->b_data;
934
935 return journal;
936out_err:
937 kfree(journal->j_wbuf);
938 jbd2_stats_proc_exit(journal);
939 kfree(journal);
940 return NULL;
941}
942
943
944
945
946
947
948
949
950
951journal_t * jbd2_journal_init_inode (struct inode *inode)
952{
953 struct buffer_head *bh;
954 journal_t *journal = journal_init_common();
955 char *p;
956 int err;
957 int n;
958 unsigned long long blocknr;
959
960 if (!journal)
961 return NULL;
962
963 journal->j_dev = journal->j_fs_dev = inode->i_sb->s_bdev;
964 journal->j_inode = inode;
965 bdevname(journal->j_dev, journal->j_devname);
966 p = journal->j_devname;
967 while ((p = strchr(p, '/')))
968 *p = '!';
969 p = journal->j_devname + strlen(journal->j_devname);
970 sprintf(p, "-%lu", journal->j_inode->i_ino);
971 jbd_debug(1,
972 "journal %p: inode %s/%ld, size %Ld, bits %d, blksize %ld\n",
973 journal, inode->i_sb->s_id, inode->i_ino,
974 (long long) inode->i_size,
975 inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize);
976
977 journal->j_maxlen = inode->i_size >> inode->i_sb->s_blocksize_bits;
978 journal->j_blocksize = inode->i_sb->s_blocksize;
979 jbd2_stats_proc_init(journal);
980
981
982 n = journal->j_blocksize / sizeof(journal_block_tag_t);
983 journal->j_wbufsize = n;
984 journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
985 if (!journal->j_wbuf) {
986 printk(KERN_ERR "%s: Cant allocate bhs for commit thread\n",
987 __func__);
988 goto out_err;
989 }
990
991 err = jbd2_journal_bmap(journal, 0, &blocknr);
992
993 if (err) {
994 printk(KERN_ERR "%s: Cannnot locate journal superblock\n",
995 __func__);
996 goto out_err;
997 }
998
999 bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
1000 if (!bh) {
1001 printk(KERN_ERR
1002 "%s: Cannot get buffer for journal superblock\n",
1003 __func__);
1004 goto out_err;
1005 }
1006 journal->j_sb_buffer = bh;
1007 journal->j_superblock = (journal_superblock_t *)bh->b_data;
1008
1009 return journal;
1010out_err:
1011 kfree(journal->j_wbuf);
1012 jbd2_stats_proc_exit(journal);
1013 kfree(journal);
1014 return NULL;
1015}
1016
1017
1018
1019
1020
1021
1022static void journal_fail_superblock (journal_t *journal)
1023{
1024 struct buffer_head *bh = journal->j_sb_buffer;
1025 brelse(bh);
1026 journal->j_sb_buffer = NULL;
1027}
1028
1029
1030
1031
1032
1033
1034
1035
1036static int journal_reset(journal_t *journal)
1037{
1038 journal_superblock_t *sb = journal->j_superblock;
1039 unsigned long long first, last;
1040
1041 first = be32_to_cpu(sb->s_first);
1042 last = be32_to_cpu(sb->s_maxlen);
1043 if (first + JBD2_MIN_JOURNAL_BLOCKS > last + 1) {
1044 printk(KERN_ERR "JBD: Journal too short (blocks %llu-%llu).\n",
1045 first, last);
1046 journal_fail_superblock(journal);
1047 return -EINVAL;
1048 }
1049
1050 journal->j_first = first;
1051 journal->j_last = last;
1052
1053 journal->j_head = first;
1054 journal->j_tail = first;
1055 journal->j_free = last - first;
1056
1057 journal->j_tail_sequence = journal->j_transaction_sequence;
1058 journal->j_commit_sequence = journal->j_transaction_sequence - 1;
1059 journal->j_commit_request = journal->j_commit_sequence;
1060
1061 journal->j_max_transaction_buffers = journal->j_maxlen / 4;
1062
1063
1064 jbd2_journal_update_superblock(journal, 1);
1065 return jbd2_journal_start_thread(journal);
1066}
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076void jbd2_journal_update_superblock(journal_t *journal, int wait)
1077{
1078 journal_superblock_t *sb = journal->j_superblock;
1079 struct buffer_head *bh = journal->j_sb_buffer;
1080
1081
1082
1083
1084
1085
1086
1087
1088 if (sb->s_start == 0 && journal->j_tail_sequence ==
1089 journal->j_transaction_sequence) {
1090 jbd_debug(1,"JBD: Skipping superblock update on recovered sb "
1091 "(start %ld, seq %d, errno %d)\n",
1092 journal->j_tail, journal->j_tail_sequence,
1093 journal->j_errno);
1094 goto out;
1095 }
1096
1097 if (buffer_write_io_error(bh)) {
1098
1099
1100
1101
1102
1103
1104
1105
1106 printk(KERN_ERR "JBD2: previous I/O error detected "
1107 "for journal superblock update for %s.\n",
1108 journal->j_devname);
1109 clear_buffer_write_io_error(bh);
1110 set_buffer_uptodate(bh);
1111 }
1112
1113 read_lock(&journal->j_state_lock);
1114 jbd_debug(1,"JBD: updating superblock (start %ld, seq %d, errno %d)\n",
1115 journal->j_tail, journal->j_tail_sequence, journal->j_errno);
1116
1117 sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
1118 sb->s_start = cpu_to_be32(journal->j_tail);
1119 sb->s_errno = cpu_to_be32(journal->j_errno);
1120 read_unlock(&journal->j_state_lock);
1121
1122 BUFFER_TRACE(bh, "marking dirty");
1123 mark_buffer_dirty(bh);
1124 if (wait) {
1125 sync_dirty_buffer(bh);
1126 if (buffer_write_io_error(bh)) {
1127 printk(KERN_ERR "JBD2: I/O error detected "
1128 "when updating journal superblock for %s.\n",
1129 journal->j_devname);
1130 clear_buffer_write_io_error(bh);
1131 set_buffer_uptodate(bh);
1132 }
1133 } else
1134 write_dirty_buffer(bh, WRITE);
1135
1136out:
1137
1138
1139
1140
1141 write_lock(&journal->j_state_lock);
1142 if (sb->s_start)
1143 journal->j_flags &= ~JBD2_FLUSHED;
1144 else
1145 journal->j_flags |= JBD2_FLUSHED;
1146 write_unlock(&journal->j_state_lock);
1147}
1148
1149
1150
1151
1152
1153
1154static int journal_get_superblock(journal_t *journal)
1155{
1156 struct buffer_head *bh;
1157 journal_superblock_t *sb;
1158 int err = -EIO;
1159
1160 bh = journal->j_sb_buffer;
1161
1162 J_ASSERT(bh != NULL);
1163 if (!buffer_uptodate(bh)) {
1164 ll_rw_block(READ, 1, &bh);
1165 wait_on_buffer(bh);
1166 if (!buffer_uptodate(bh)) {
1167 printk (KERN_ERR
1168 "JBD: IO error reading journal superblock\n");
1169 goto out;
1170 }
1171 }
1172
1173 sb = journal->j_superblock;
1174
1175 err = -EINVAL;
1176
1177 if (sb->s_header.h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER) ||
1178 sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) {
1179 printk(KERN_WARNING "JBD: no valid journal superblock found\n");
1180 goto out;
1181 }
1182
1183 switch(be32_to_cpu(sb->s_header.h_blocktype)) {
1184 case JBD2_SUPERBLOCK_V1:
1185 journal->j_format_version = 1;
1186 break;
1187 case JBD2_SUPERBLOCK_V2:
1188 journal->j_format_version = 2;
1189 break;
1190 default:
1191 printk(KERN_WARNING "JBD: unrecognised superblock format ID\n");
1192 goto out;
1193 }
1194
1195 if (be32_to_cpu(sb->s_maxlen) < journal->j_maxlen)
1196 journal->j_maxlen = be32_to_cpu(sb->s_maxlen);
1197 else if (be32_to_cpu(sb->s_maxlen) > journal->j_maxlen) {
1198 printk (KERN_WARNING "JBD: journal file too short\n");
1199 goto out;
1200 }
1201
1202 return 0;
1203
1204out:
1205 journal_fail_superblock(journal);
1206 return err;
1207}
1208
1209
1210
1211
1212
1213
1214static int load_superblock(journal_t *journal)
1215{
1216 int err;
1217 journal_superblock_t *sb;
1218
1219 err = journal_get_superblock(journal);
1220 if (err)
1221 return err;
1222
1223 sb = journal->j_superblock;
1224
1225 journal->j_tail_sequence = be32_to_cpu(sb->s_sequence);
1226 journal->j_tail = be32_to_cpu(sb->s_start);
1227 journal->j_first = be32_to_cpu(sb->s_first);
1228 journal->j_last = be32_to_cpu(sb->s_maxlen);
1229 journal->j_errno = be32_to_cpu(sb->s_errno);
1230
1231 return 0;
1232}
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243int jbd2_journal_load(journal_t *journal)
1244{
1245 int err;
1246 journal_superblock_t *sb;
1247
1248 err = load_superblock(journal);
1249 if (err)
1250 return err;
1251
1252 sb = journal->j_superblock;
1253
1254
1255
1256 if (journal->j_format_version >= 2) {
1257 if ((sb->s_feature_ro_compat &
1258 ~cpu_to_be32(JBD2_KNOWN_ROCOMPAT_FEATURES)) ||
1259 (sb->s_feature_incompat &
1260 ~cpu_to_be32(JBD2_KNOWN_INCOMPAT_FEATURES))) {
1261 printk (KERN_WARNING
1262 "JBD: Unrecognised features on journal\n");
1263 return -EINVAL;
1264 }
1265 }
1266
1267
1268
1269
1270 err = jbd2_journal_create_slab(be32_to_cpu(sb->s_blocksize));
1271 if (err)
1272 return err;
1273
1274
1275
1276 if (jbd2_journal_recover(journal))
1277 goto recovery_error;
1278
1279 if (journal->j_failed_commit) {
1280 printk(KERN_ERR "JBD2: journal transaction %u on %s "
1281 "is corrupt.\n", journal->j_failed_commit,
1282 journal->j_devname);
1283 return -EIO;
1284 }
1285
1286
1287
1288
1289 if (journal_reset(journal))
1290 goto recovery_error;
1291
1292 journal->j_flags &= ~JBD2_ABORT;
1293 journal->j_flags |= JBD2_LOADED;
1294 return 0;
1295
1296recovery_error:
1297 printk (KERN_WARNING "JBD: recovery failed\n");
1298 return -EIO;
1299}
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309int jbd2_journal_destroy(journal_t *journal)
1310{
1311 int err = 0;
1312
1313
1314 journal_kill_thread(journal);
1315
1316
1317 if (journal->j_running_transaction)
1318 jbd2_journal_commit_transaction(journal);
1319
1320
1321
1322
1323 spin_lock(&journal->j_list_lock);
1324 while (journal->j_checkpoint_transactions != NULL) {
1325 spin_unlock(&journal->j_list_lock);
1326 mutex_lock(&journal->j_checkpoint_mutex);
1327 jbd2_log_do_checkpoint(journal);
1328 mutex_unlock(&journal->j_checkpoint_mutex);
1329 spin_lock(&journal->j_list_lock);
1330 }
1331
1332 J_ASSERT(journal->j_running_transaction == NULL);
1333 J_ASSERT(journal->j_committing_transaction == NULL);
1334 J_ASSERT(journal->j_checkpoint_transactions == NULL);
1335 spin_unlock(&journal->j_list_lock);
1336
1337 if (journal->j_sb_buffer) {
1338 if (!is_journal_aborted(journal)) {
1339
1340 journal->j_tail = 0;
1341 journal->j_tail_sequence =
1342 ++journal->j_transaction_sequence;
1343 jbd2_journal_update_superblock(journal, 1);
1344 } else {
1345 err = -EIO;
1346 }
1347 brelse(journal->j_sb_buffer);
1348 }
1349
1350 if (journal->j_proc_entry)
1351 jbd2_stats_proc_exit(journal);
1352 if (journal->j_inode)
1353 iput(journal->j_inode);
1354 if (journal->j_revoke)
1355 jbd2_journal_destroy_revoke(journal);
1356 kfree(journal->j_wbuf);
1357 kfree(journal);
1358
1359 return err;
1360}
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374int jbd2_journal_check_used_features (journal_t *journal, unsigned long compat,
1375 unsigned long ro, unsigned long incompat)
1376{
1377 journal_superblock_t *sb;
1378
1379 if (!compat && !ro && !incompat)
1380 return 1;
1381
1382 if (journal->j_format_version == 0 &&
1383 journal_get_superblock(journal) != 0)
1384 return 0;
1385 if (journal->j_format_version == 1)
1386 return 0;
1387
1388 sb = journal->j_superblock;
1389
1390 if (((be32_to_cpu(sb->s_feature_compat) & compat) == compat) &&
1391 ((be32_to_cpu(sb->s_feature_ro_compat) & ro) == ro) &&
1392 ((be32_to_cpu(sb->s_feature_incompat) & incompat) == incompat))
1393 return 1;
1394
1395 return 0;
1396}
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409int jbd2_journal_check_available_features (journal_t *journal, unsigned long compat,
1410 unsigned long ro, unsigned long incompat)
1411{
1412 if (!compat && !ro && !incompat)
1413 return 1;
1414
1415
1416
1417
1418
1419 if (journal->j_format_version != 2)
1420 return 0;
1421
1422 if ((compat & JBD2_KNOWN_COMPAT_FEATURES) == compat &&
1423 (ro & JBD2_KNOWN_ROCOMPAT_FEATURES) == ro &&
1424 (incompat & JBD2_KNOWN_INCOMPAT_FEATURES) == incompat)
1425 return 1;
1426
1427 return 0;
1428}
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442int jbd2_journal_set_features (journal_t *journal, unsigned long compat,
1443 unsigned long ro, unsigned long incompat)
1444{
1445 journal_superblock_t *sb;
1446
1447 if (jbd2_journal_check_used_features(journal, compat, ro, incompat))
1448 return 1;
1449
1450 if (!jbd2_journal_check_available_features(journal, compat, ro, incompat))
1451 return 0;
1452
1453 jbd_debug(1, "Setting new features 0x%lx/0x%lx/0x%lx\n",
1454 compat, ro, incompat);
1455
1456 sb = journal->j_superblock;
1457
1458 sb->s_feature_compat |= cpu_to_be32(compat);
1459 sb->s_feature_ro_compat |= cpu_to_be32(ro);
1460 sb->s_feature_incompat |= cpu_to_be32(incompat);
1461
1462 return 1;
1463}
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476void jbd2_journal_clear_features(journal_t *journal, unsigned long compat,
1477 unsigned long ro, unsigned long incompat)
1478{
1479 journal_superblock_t *sb;
1480
1481 jbd_debug(1, "Clear features 0x%lx/0x%lx/0x%lx\n",
1482 compat, ro, incompat);
1483
1484 sb = journal->j_superblock;
1485
1486 sb->s_feature_compat &= ~cpu_to_be32(compat);
1487 sb->s_feature_ro_compat &= ~cpu_to_be32(ro);
1488 sb->s_feature_incompat &= ~cpu_to_be32(incompat);
1489}
1490EXPORT_SYMBOL(jbd2_journal_clear_features);
1491
1492
1493
1494
1495
1496
1497
1498
1499int jbd2_journal_update_format (journal_t *journal)
1500{
1501 journal_superblock_t *sb;
1502 int err;
1503
1504 err = journal_get_superblock(journal);
1505 if (err)
1506 return err;
1507
1508 sb = journal->j_superblock;
1509
1510 switch (be32_to_cpu(sb->s_header.h_blocktype)) {
1511 case JBD2_SUPERBLOCK_V2:
1512 return 0;
1513 case JBD2_SUPERBLOCK_V1:
1514 return journal_convert_superblock_v1(journal, sb);
1515 default:
1516 break;
1517 }
1518 return -EINVAL;
1519}
1520
1521static int journal_convert_superblock_v1(journal_t *journal,
1522 journal_superblock_t *sb)
1523{
1524 int offset, blocksize;
1525 struct buffer_head *bh;
1526
1527 printk(KERN_WARNING
1528 "JBD: Converting superblock from version 1 to 2.\n");
1529
1530
1531 offset = ((char *) &(sb->s_feature_compat)) - ((char *) sb);
1532 blocksize = be32_to_cpu(sb->s_blocksize);
1533 memset(&sb->s_feature_compat, 0, blocksize-offset);
1534
1535 sb->s_nr_users = cpu_to_be32(1);
1536 sb->s_header.h_blocktype = cpu_to_be32(JBD2_SUPERBLOCK_V2);
1537 journal->j_format_version = 2;
1538
1539 bh = journal->j_sb_buffer;
1540 BUFFER_TRACE(bh, "marking dirty");
1541 mark_buffer_dirty(bh);
1542 sync_dirty_buffer(bh);
1543 return 0;
1544}
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556int jbd2_journal_flush(journal_t *journal)
1557{
1558 int err = 0;
1559 transaction_t *transaction = NULL;
1560 unsigned long old_tail;
1561
1562 write_lock(&journal->j_state_lock);
1563
1564
1565 if (journal->j_running_transaction) {
1566 transaction = journal->j_running_transaction;
1567 __jbd2_log_start_commit(journal, transaction->t_tid);
1568 } else if (journal->j_committing_transaction)
1569 transaction = journal->j_committing_transaction;
1570
1571
1572 if (transaction) {
1573 tid_t tid = transaction->t_tid;
1574
1575 write_unlock(&journal->j_state_lock);
1576 jbd2_log_wait_commit(journal, tid);
1577 } else {
1578 write_unlock(&journal->j_state_lock);
1579 }
1580
1581
1582 spin_lock(&journal->j_list_lock);
1583 while (!err && journal->j_checkpoint_transactions != NULL) {
1584 spin_unlock(&journal->j_list_lock);
1585 mutex_lock(&journal->j_checkpoint_mutex);
1586 err = jbd2_log_do_checkpoint(journal);
1587 mutex_unlock(&journal->j_checkpoint_mutex);
1588 spin_lock(&journal->j_list_lock);
1589 }
1590 spin_unlock(&journal->j_list_lock);
1591
1592 if (is_journal_aborted(journal))
1593 return -EIO;
1594
1595 jbd2_cleanup_journal_tail(journal);
1596
1597
1598
1599
1600
1601
1602 write_lock(&journal->j_state_lock);
1603 old_tail = journal->j_tail;
1604 journal->j_tail = 0;
1605 write_unlock(&journal->j_state_lock);
1606 jbd2_journal_update_superblock(journal, 1);
1607 write_lock(&journal->j_state_lock);
1608 journal->j_tail = old_tail;
1609
1610 J_ASSERT(!journal->j_running_transaction);
1611 J_ASSERT(!journal->j_committing_transaction);
1612 J_ASSERT(!journal->j_checkpoint_transactions);
1613 J_ASSERT(journal->j_head == journal->j_tail);
1614 J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence);
1615 write_unlock(&journal->j_state_lock);
1616 return 0;
1617}
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632int jbd2_journal_wipe(journal_t *journal, int write)
1633{
1634 int err = 0;
1635
1636 J_ASSERT (!(journal->j_flags & JBD2_LOADED));
1637
1638 err = load_superblock(journal);
1639 if (err)
1640 return err;
1641
1642 if (!journal->j_tail)
1643 goto no_recovery;
1644
1645 printk (KERN_WARNING "JBD: %s recovery information on journal\n",
1646 write ? "Clearing" : "Ignoring");
1647
1648 err = jbd2_journal_skip_recovery(journal);
1649 if (write)
1650 jbd2_journal_update_superblock(journal, 1);
1651
1652 no_recovery:
1653 return err;
1654}
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669void __jbd2_journal_abort_hard(journal_t *journal)
1670{
1671 transaction_t *transaction;
1672
1673 if (journal->j_flags & JBD2_ABORT)
1674 return;
1675
1676 printk(KERN_ERR "Aborting journal on device %s.\n",
1677 journal->j_devname);
1678
1679 write_lock(&journal->j_state_lock);
1680 journal->j_flags |= JBD2_ABORT;
1681 transaction = journal->j_running_transaction;
1682 if (transaction)
1683 __jbd2_log_start_commit(journal, transaction->t_tid);
1684 write_unlock(&journal->j_state_lock);
1685}
1686
1687
1688
1689static void __journal_abort_soft (journal_t *journal, int errno)
1690{
1691 if (journal->j_flags & JBD2_ABORT)
1692 return;
1693
1694 if (!journal->j_errno)
1695 journal->j_errno = errno;
1696
1697 __jbd2_journal_abort_hard(journal);
1698
1699 if (errno)
1700 jbd2_journal_update_superblock(journal, 1);
1701}
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749void jbd2_journal_abort(journal_t *journal, int errno)
1750{
1751 __journal_abort_soft(journal, errno);
1752}
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765int jbd2_journal_errno(journal_t *journal)
1766{
1767 int err;
1768
1769 read_lock(&journal->j_state_lock);
1770 if (journal->j_flags & JBD2_ABORT)
1771 err = -EROFS;
1772 else
1773 err = journal->j_errno;
1774 read_unlock(&journal->j_state_lock);
1775 return err;
1776}
1777
1778
1779
1780
1781
1782
1783
1784
1785int jbd2_journal_clear_err(journal_t *journal)
1786{
1787 int err = 0;
1788
1789 write_lock(&journal->j_state_lock);
1790 if (journal->j_flags & JBD2_ABORT)
1791 err = -EROFS;
1792 else
1793 journal->j_errno = 0;
1794 write_unlock(&journal->j_state_lock);
1795 return err;
1796}
1797
1798
1799
1800
1801
1802
1803
1804
1805void jbd2_journal_ack_err(journal_t *journal)
1806{
1807 write_lock(&journal->j_state_lock);
1808 if (journal->j_errno)
1809 journal->j_flags |= JBD2_ACK_ERR;
1810 write_unlock(&journal->j_state_lock);
1811}
1812
1813int jbd2_journal_blocks_per_page(struct inode *inode)
1814{
1815 return 1 << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
1816}
1817
1818
1819
1820
1821size_t journal_tag_bytes(journal_t *journal)
1822{
1823 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT))
1824 return JBD2_TAG_SIZE64;
1825 else
1826 return JBD2_TAG_SIZE32;
1827}
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844#define JBD2_MAX_SLABS 8
1845static struct kmem_cache *jbd2_slab[JBD2_MAX_SLABS];
1846
1847static const char *jbd2_slab_names[JBD2_MAX_SLABS] = {
1848 "jbd2_1k", "jbd2_2k", "jbd2_4k", "jbd2_8k",
1849 "jbd2_16k", "jbd2_32k", "jbd2_64k", "jbd2_128k"
1850};
1851
1852
1853static void jbd2_journal_destroy_slabs(void)
1854{
1855 int i;
1856
1857 for (i = 0; i < JBD2_MAX_SLABS; i++) {
1858 if (jbd2_slab[i])
1859 kmem_cache_destroy(jbd2_slab[i]);
1860 jbd2_slab[i] = NULL;
1861 }
1862}
1863
1864static int jbd2_journal_create_slab(size_t size)
1865{
1866 static DEFINE_MUTEX(jbd2_slab_create_mutex);
1867 int i = order_base_2(size) - 10;
1868 size_t slab_size;
1869
1870 if (size == PAGE_SIZE)
1871 return 0;
1872
1873 if (i >= JBD2_MAX_SLABS)
1874 return -EINVAL;
1875
1876 if (unlikely(i < 0))
1877 i = 0;
1878 mutex_lock(&jbd2_slab_create_mutex);
1879 if (jbd2_slab[i]) {
1880 mutex_unlock(&jbd2_slab_create_mutex);
1881 return 0;
1882 }
1883
1884 slab_size = 1 << (i+10);
1885 jbd2_slab[i] = kmem_cache_create(jbd2_slab_names[i], slab_size,
1886 slab_size, 0, NULL);
1887 mutex_unlock(&jbd2_slab_create_mutex);
1888 if (!jbd2_slab[i]) {
1889 printk(KERN_EMERG "JBD2: no memory for jbd2_slab cache\n");
1890 return -ENOMEM;
1891 }
1892 return 0;
1893}
1894
1895static struct kmem_cache *get_slab(size_t size)
1896{
1897 int i = order_base_2(size) - 10;
1898
1899 BUG_ON(i >= JBD2_MAX_SLABS);
1900 if (unlikely(i < 0))
1901 i = 0;
1902 BUG_ON(jbd2_slab[i] == NULL);
1903 return jbd2_slab[i];
1904}
1905
1906void *jbd2_alloc(size_t size, gfp_t flags)
1907{
1908 void *ptr;
1909
1910 BUG_ON(size & (size-1));
1911
1912 flags |= __GFP_REPEAT;
1913 if (size == PAGE_SIZE)
1914 ptr = (void *)__get_free_pages(flags, 0);
1915 else if (size > PAGE_SIZE) {
1916 int order = get_order(size);
1917
1918 if (order < 3)
1919 ptr = (void *)__get_free_pages(flags, order);
1920 else
1921 ptr = vmalloc(size);
1922 } else
1923 ptr = kmem_cache_alloc(get_slab(size), flags);
1924
1925
1926
1927 BUG_ON(((unsigned long) ptr) & (size-1));
1928
1929 return ptr;
1930}
1931
1932void jbd2_free(void *ptr, size_t size)
1933{
1934 if (size == PAGE_SIZE) {
1935 free_pages((unsigned long)ptr, 0);
1936 return;
1937 }
1938 if (size > PAGE_SIZE) {
1939 int order = get_order(size);
1940
1941 if (order < 3)
1942 free_pages((unsigned long)ptr, order);
1943 else
1944 vfree(ptr);
1945 return;
1946 }
1947 kmem_cache_free(get_slab(size), ptr);
1948};
1949
1950
1951
1952
1953static struct kmem_cache *jbd2_journal_head_cache;
1954#ifdef CONFIG_JBD2_DEBUG
1955static atomic_t nr_journal_heads = ATOMIC_INIT(0);
1956#endif
1957
1958static int journal_init_jbd2_journal_head_cache(void)
1959{
1960 int retval;
1961
1962 J_ASSERT(jbd2_journal_head_cache == NULL);
1963 jbd2_journal_head_cache = kmem_cache_create("jbd2_journal_head",
1964 sizeof(struct journal_head),
1965 0,
1966 SLAB_TEMPORARY,
1967 NULL);
1968 retval = 0;
1969 if (!jbd2_journal_head_cache) {
1970 retval = -ENOMEM;
1971 printk(KERN_EMERG "JBD: no memory for journal_head cache\n");
1972 }
1973 return retval;
1974}
1975
1976static void jbd2_journal_destroy_jbd2_journal_head_cache(void)
1977{
1978 if (jbd2_journal_head_cache) {
1979 kmem_cache_destroy(jbd2_journal_head_cache);
1980 jbd2_journal_head_cache = NULL;
1981 }
1982}
1983
1984
1985
1986
1987static struct journal_head *journal_alloc_journal_head(void)
1988{
1989 struct journal_head *ret;
1990
1991#ifdef CONFIG_JBD2_DEBUG
1992 atomic_inc(&nr_journal_heads);
1993#endif
1994 ret = kmem_cache_alloc(jbd2_journal_head_cache, GFP_NOFS);
1995 if (!ret) {
1996 jbd_debug(1, "out of memory for journal_head\n");
1997 pr_notice_ratelimited("ENOMEM in %s, retrying.\n", __func__);
1998 while (!ret) {
1999 yield();
2000 ret = kmem_cache_alloc(jbd2_journal_head_cache, GFP_NOFS);
2001 }
2002 }
2003 return ret;
2004}
2005
2006static void journal_free_journal_head(struct journal_head *jh)
2007{
2008#ifdef CONFIG_JBD2_DEBUG
2009 atomic_dec(&nr_journal_heads);
2010 memset(jh, JBD2_POISON_FREE, sizeof(*jh));
2011#endif
2012 kmem_cache_free(jbd2_journal_head_cache, jh);
2013}
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh)
2059{
2060 struct journal_head *jh;
2061 struct journal_head *new_jh = NULL;
2062
2063repeat:
2064 if (!buffer_jbd(bh)) {
2065 new_jh = journal_alloc_journal_head();
2066 memset(new_jh, 0, sizeof(*new_jh));
2067 }
2068
2069 jbd_lock_bh_journal_head(bh);
2070 if (buffer_jbd(bh)) {
2071 jh = bh2jh(bh);
2072 } else {
2073 J_ASSERT_BH(bh,
2074 (atomic_read(&bh->b_count) > 0) ||
2075 (bh->b_page && bh->b_page->mapping));
2076
2077 if (!new_jh) {
2078 jbd_unlock_bh_journal_head(bh);
2079 goto repeat;
2080 }
2081
2082 jh = new_jh;
2083 new_jh = NULL;
2084 set_buffer_jbd(bh);
2085 bh->b_private = jh;
2086 jh->b_bh = bh;
2087 get_bh(bh);
2088 BUFFER_TRACE(bh, "added journal_head");
2089 }
2090 jh->b_jcount++;
2091 jbd_unlock_bh_journal_head(bh);
2092 if (new_jh)
2093 journal_free_journal_head(new_jh);
2094 return bh->b_private;
2095}
2096
2097
2098
2099
2100
2101struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh)
2102{
2103 struct journal_head *jh = NULL;
2104
2105 jbd_lock_bh_journal_head(bh);
2106 if (buffer_jbd(bh)) {
2107 jh = bh2jh(bh);
2108 jh->b_jcount++;
2109 }
2110 jbd_unlock_bh_journal_head(bh);
2111 return jh;
2112}
2113
2114static void __journal_remove_journal_head(struct buffer_head *bh)
2115{
2116 struct journal_head *jh = bh2jh(bh);
2117
2118 J_ASSERT_JH(jh, jh->b_jcount >= 0);
2119
2120 get_bh(bh);
2121 if (jh->b_jcount == 0) {
2122 if (jh->b_transaction == NULL &&
2123 jh->b_next_transaction == NULL &&
2124 jh->b_cp_transaction == NULL) {
2125 J_ASSERT_JH(jh, jh->b_jlist == BJ_None);
2126 J_ASSERT_BH(bh, buffer_jbd(bh));
2127 J_ASSERT_BH(bh, jh2bh(jh) == bh);
2128 BUFFER_TRACE(bh, "remove journal_head");
2129 if (jh->b_frozen_data) {
2130 printk(KERN_WARNING "%s: freeing "
2131 "b_frozen_data\n",
2132 __func__);
2133 jbd2_free(jh->b_frozen_data, bh->b_size);
2134 }
2135 if (jh->b_committed_data) {
2136 printk(KERN_WARNING "%s: freeing "
2137 "b_committed_data\n",
2138 __func__);
2139 jbd2_free(jh->b_committed_data, bh->b_size);
2140 }
2141 bh->b_private = NULL;
2142 jh->b_bh = NULL;
2143 clear_buffer_jbd(bh);
2144 __brelse(bh);
2145 journal_free_journal_head(jh);
2146 } else {
2147 BUFFER_TRACE(bh, "journal_head was locked");
2148 }
2149 }
2150}
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165void jbd2_journal_remove_journal_head(struct buffer_head *bh)
2166{
2167 jbd_lock_bh_journal_head(bh);
2168 __journal_remove_journal_head(bh);
2169 jbd_unlock_bh_journal_head(bh);
2170}
2171
2172
2173
2174
2175
2176void jbd2_journal_put_journal_head(struct journal_head *jh)
2177{
2178 struct buffer_head *bh = jh2bh(jh);
2179
2180 jbd_lock_bh_journal_head(bh);
2181 J_ASSERT_JH(jh, jh->b_jcount > 0);
2182 --jh->b_jcount;
2183 if (!jh->b_jcount && !jh->b_transaction) {
2184 __journal_remove_journal_head(bh);
2185 __brelse(bh);
2186 }
2187 jbd_unlock_bh_journal_head(bh);
2188}
2189
2190
2191
2192
2193void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode)
2194{
2195 jinode->i_transaction = NULL;
2196 jinode->i_next_transaction = NULL;
2197 jinode->i_vfs_inode = inode;
2198 jinode->i_flags = 0;
2199 INIT_LIST_HEAD(&jinode->i_list);
2200}
2201
2202
2203
2204
2205
2206
2207void jbd2_journal_release_jbd_inode(journal_t *journal,
2208 struct jbd2_inode *jinode)
2209{
2210 if (!journal)
2211 return;
2212restart:
2213 spin_lock(&journal->j_list_lock);
2214
2215 if (test_bit(__JI_COMMIT_RUNNING, &jinode->i_flags)) {
2216 wait_queue_head_t *wq;
2217 DEFINE_WAIT_BIT(wait, &jinode->i_flags, __JI_COMMIT_RUNNING);
2218 wq = bit_waitqueue(&jinode->i_flags, __JI_COMMIT_RUNNING);
2219 prepare_to_wait(wq, &wait.wait, TASK_UNINTERRUPTIBLE);
2220 spin_unlock(&journal->j_list_lock);
2221 schedule();
2222 finish_wait(wq, &wait.wait);
2223 goto restart;
2224 }
2225
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
2234
2235
2236#ifdef CONFIG_JBD2_DEBUG
2237u8 jbd2_journal_enable_debug __read_mostly;
2238EXPORT_SYMBOL(jbd2_journal_enable_debug);
2239
2240#define JBD2_DEBUG_NAME "jbd2-debug"
2241
2242static struct dentry *jbd2_debugfs_dir;
2243static struct dentry *jbd2_debug;
2244
2245static void __init jbd2_create_debugfs_entry(void)
2246{
2247 jbd2_debugfs_dir = debugfs_create_dir("jbd2", NULL);
2248 if (jbd2_debugfs_dir)
2249 jbd2_debug = debugfs_create_u8(JBD2_DEBUG_NAME,
2250 S_IRUGO | S_IWUSR,
2251 jbd2_debugfs_dir,
2252 &jbd2_journal_enable_debug);
2253}
2254
2255static void __exit jbd2_remove_debugfs_entry(void)
2256{
2257 debugfs_remove(jbd2_debug);
2258 debugfs_remove(jbd2_debugfs_dir);
2259}
2260
2261#else
2262
2263static void __init jbd2_create_debugfs_entry(void)
2264{
2265}
2266
2267static void __exit jbd2_remove_debugfs_entry(void)
2268{
2269}
2270
2271#endif
2272
2273#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
2295struct kmem_cache *jbd2_handle_cache, *jbd2_inode_cache;
2296
2297static int __init journal_init_handle_cache(void)
2298{
2299 jbd2_handle_cache = KMEM_CACHE(jbd2_journal_handle, SLAB_TEMPORARY);
2300 if (jbd2_handle_cache == NULL) {
2301 printk(KERN_EMERG "JBD2: failed to create handle cache\n");
2302 return -ENOMEM;
2303 }
2304 jbd2_inode_cache = KMEM_CACHE(jbd2_inode, 0);
2305 if (jbd2_inode_cache == NULL) {
2306 printk(KERN_EMERG "JBD2: failed to create inode cache\n");
2307 kmem_cache_destroy(jbd2_handle_cache);
2308 return -ENOMEM;
2309 }
2310 return 0;
2311}
2312
2313static void jbd2_journal_destroy_handle_cache(void)
2314{
2315 if (jbd2_handle_cache)
2316 kmem_cache_destroy(jbd2_handle_cache);
2317 if (jbd2_inode_cache)
2318 kmem_cache_destroy(jbd2_inode_cache);
2319
2320}
2321
2322
2323
2324
2325
2326static int __init journal_init_caches(void)
2327{
2328 int ret;
2329
2330 ret = jbd2_journal_init_revoke_caches();
2331 if (ret == 0)
2332 ret = journal_init_jbd2_journal_head_cache();
2333 if (ret == 0)
2334 ret = journal_init_handle_cache();
2335 return ret;
2336}
2337
2338static void jbd2_journal_destroy_caches(void)
2339{
2340 jbd2_journal_destroy_revoke_caches();
2341 jbd2_journal_destroy_jbd2_journal_head_cache();
2342 jbd2_journal_destroy_handle_cache();
2343 jbd2_journal_destroy_slabs();
2344}
2345
2346static int __init journal_init(void)
2347{
2348 int ret;
2349
2350 BUILD_BUG_ON(sizeof(struct journal_superblock_s) != 1024);
2351
2352 ret = journal_init_caches();
2353 if (ret == 0) {
2354 jbd2_create_debugfs_entry();
2355 jbd2_create_jbd_stats_proc_entry();
2356 } else {
2357 jbd2_journal_destroy_caches();
2358 }
2359 return ret;
2360}
2361
2362static void __exit journal_exit(void)
2363{
2364#ifdef CONFIG_JBD2_DEBUG
2365 int n = atomic_read(&nr_journal_heads);
2366 if (n)
2367 printk(KERN_EMERG "JBD: leaked %d journal_heads!\n", n);
2368#endif
2369 jbd2_remove_debugfs_entry();
2370 jbd2_remove_jbd_stats_proc_entry();
2371 jbd2_journal_destroy_caches();
2372}
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384struct devname_cache {
2385 struct rcu_head rcu;
2386 dev_t device;
2387 char devname[BDEVNAME_SIZE];
2388};
2389#define CACHE_SIZE_BITS 6
2390static struct devname_cache *devcache[1 << CACHE_SIZE_BITS];
2391static DEFINE_SPINLOCK(devname_cache_lock);
2392
2393static void free_devcache(struct rcu_head *rcu)
2394{
2395 kfree(rcu);
2396}
2397
2398const char *jbd2_dev_to_name(dev_t device)
2399{
2400 int i = hash_32(device, CACHE_SIZE_BITS);
2401 char *ret;
2402 struct block_device *bd;
2403 static struct devname_cache *new_dev;
2404
2405 rcu_read_lock();
2406 if (devcache[i] && devcache[i]->device == device) {
2407 ret = devcache[i]->devname;
2408 rcu_read_unlock();
2409 return ret;
2410 }
2411 rcu_read_unlock();
2412
2413 new_dev = kmalloc(sizeof(struct devname_cache), GFP_KERNEL);
2414 if (!new_dev)
2415 return "NODEV-ALLOCFAILURE";
2416 spin_lock(&devname_cache_lock);
2417 if (devcache[i]) {
2418 if (devcache[i]->device == device) {
2419 kfree(new_dev);
2420 ret = devcache[i]->devname;
2421 spin_unlock(&devname_cache_lock);
2422 return ret;
2423 }
2424 call_rcu(&devcache[i]->rcu, free_devcache);
2425 }
2426 devcache[i] = new_dev;
2427 devcache[i]->device = device;
2428 bd = bdget(device);
2429 if (bd) {
2430 bdevname(bd, devcache[i]->devname);
2431 bdput(bd);
2432 } else
2433 __bdevname(device, devcache[i]->devname);
2434 ret = devcache[i]->devname;
2435 spin_unlock(&devname_cache_lock);
2436 return ret;
2437}
2438EXPORT_SYMBOL(jbd2_dev_to_name);
2439
2440MODULE_LICENSE("GPL");
2441module_init(journal_init);
2442module_exit(journal_exit);
2443
2444