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