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