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