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