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