1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/time.h>
21#include <linux/fs.h>
22#include <linux/jbd2.h>
23#include <linux/errno.h>
24#include <linux/slab.h>
25#include <linux/timer.h>
26#include <linux/mm.h>
27#include <linux/highmem.h>
28#include <linux/hrtimer.h>
29#include <linux/backing-dev.h>
30#include <linux/bug.h>
31#include <linux/module.h>
32
33#include <trace/events/jbd2.h>
34
35static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh);
36static void __jbd2_journal_unfile_buffer(struct journal_head *jh);
37
38static struct kmem_cache *transaction_cache;
39int __init jbd2_journal_init_transaction_cache(void)
40{
41 J_ASSERT(!transaction_cache);
42 transaction_cache = kmem_cache_create("jbd2_transaction_s",
43 sizeof(transaction_t),
44 0,
45 SLAB_HWCACHE_ALIGN|SLAB_TEMPORARY,
46 NULL);
47 if (transaction_cache)
48 return 0;
49 return -ENOMEM;
50}
51
52void jbd2_journal_destroy_transaction_cache(void)
53{
54 if (transaction_cache) {
55 kmem_cache_destroy(transaction_cache);
56 transaction_cache = NULL;
57 }
58}
59
60void jbd2_journal_free_transaction(transaction_t *transaction)
61{
62 if (unlikely(ZERO_OR_NULL_PTR(transaction)))
63 return;
64 kmem_cache_free(transaction_cache, transaction);
65}
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82static transaction_t *
83jbd2_get_transaction(journal_t *journal, transaction_t *transaction)
84{
85 transaction->t_journal = journal;
86 transaction->t_state = T_RUNNING;
87 transaction->t_start_time = ktime_get();
88 transaction->t_tid = journal->j_transaction_sequence++;
89 transaction->t_expires = jiffies + journal->j_commit_interval;
90 spin_lock_init(&transaction->t_handle_lock);
91 atomic_set(&transaction->t_updates, 0);
92 atomic_set(&transaction->t_outstanding_credits,
93 atomic_read(&journal->j_reserved_credits));
94 atomic_set(&transaction->t_handle_count, 0);
95 INIT_LIST_HEAD(&transaction->t_inode_list);
96 INIT_LIST_HEAD(&transaction->t_private_list);
97
98
99 journal->j_commit_timer.expires = round_jiffies_up(transaction->t_expires);
100 add_timer(&journal->j_commit_timer);
101
102 J_ASSERT(journal->j_running_transaction == NULL);
103 journal->j_running_transaction = transaction;
104 transaction->t_max_wait = 0;
105 transaction->t_start = jiffies;
106 transaction->t_requested = 0;
107
108 return transaction;
109}
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129static inline void update_t_max_wait(transaction_t *transaction,
130 unsigned long ts)
131{
132#ifdef CONFIG_JBD2_DEBUG
133 if (jbd2_journal_enable_debug &&
134 time_after(transaction->t_start, ts)) {
135 ts = jbd2_time_diff(ts, transaction->t_start);
136 spin_lock(&transaction->t_handle_lock);
137 if (ts > transaction->t_max_wait)
138 transaction->t_max_wait = ts;
139 spin_unlock(&transaction->t_handle_lock);
140 }
141#endif
142}
143
144
145
146
147
148
149static void wait_transaction_locked(journal_t *journal)
150 __releases(journal->j_state_lock)
151{
152 DEFINE_WAIT(wait);
153 int need_to_start;
154 tid_t tid = journal->j_running_transaction->t_tid;
155
156 prepare_to_wait(&journal->j_wait_transaction_locked, &wait,
157 TASK_UNINTERRUPTIBLE);
158 need_to_start = !tid_geq(journal->j_commit_request, tid);
159 read_unlock(&journal->j_state_lock);
160 if (need_to_start)
161 jbd2_log_start_commit(journal, tid);
162 schedule();
163 finish_wait(&journal->j_wait_transaction_locked, &wait);
164}
165
166static void sub_reserved_credits(journal_t *journal, int blocks)
167{
168 atomic_sub(blocks, &journal->j_reserved_credits);
169 wake_up(&journal->j_wait_reserved);
170}
171
172
173
174
175
176
177
178static int add_transaction_credits(journal_t *journal, int blocks,
179 int rsv_blocks)
180{
181 transaction_t *t = journal->j_running_transaction;
182 int needed;
183 int total = blocks + rsv_blocks;
184
185
186
187
188
189 if (t->t_state == T_LOCKED) {
190 wait_transaction_locked(journal);
191 return 1;
192 }
193
194
195
196
197
198
199 needed = atomic_add_return(total, &t->t_outstanding_credits);
200 if (needed > journal->j_max_transaction_buffers) {
201
202
203
204
205
206 atomic_sub(total, &t->t_outstanding_credits);
207
208
209
210
211
212 if (atomic_read(&journal->j_reserved_credits) + total >
213 journal->j_max_transaction_buffers) {
214 read_unlock(&journal->j_state_lock);
215 wait_event(journal->j_wait_reserved,
216 atomic_read(&journal->j_reserved_credits) + total <=
217 journal->j_max_transaction_buffers);
218 return 1;
219 }
220
221 wait_transaction_locked(journal);
222 return 1;
223 }
224
225
226
227
228
229
230
231
232
233
234
235
236 if (jbd2_log_space_left(journal) < jbd2_space_needed(journal)) {
237 atomic_sub(total, &t->t_outstanding_credits);
238 read_unlock(&journal->j_state_lock);
239 write_lock(&journal->j_state_lock);
240 if (jbd2_log_space_left(journal) < jbd2_space_needed(journal))
241 __jbd2_log_wait_for_space(journal);
242 write_unlock(&journal->j_state_lock);
243 return 1;
244 }
245
246
247 if (!rsv_blocks)
248 return 0;
249
250 needed = atomic_add_return(rsv_blocks, &journal->j_reserved_credits);
251
252 if (needed > journal->j_max_transaction_buffers / 2) {
253 sub_reserved_credits(journal, rsv_blocks);
254 atomic_sub(total, &t->t_outstanding_credits);
255 read_unlock(&journal->j_state_lock);
256 wait_event(journal->j_wait_reserved,
257 atomic_read(&journal->j_reserved_credits) + rsv_blocks
258 <= journal->j_max_transaction_buffers / 2);
259 return 1;
260 }
261 return 0;
262}
263
264
265
266
267
268
269
270
271static int start_this_handle(journal_t *journal, handle_t *handle,
272 gfp_t gfp_mask)
273{
274 transaction_t *transaction, *new_transaction = NULL;
275 int blocks = handle->h_buffer_credits;
276 int rsv_blocks = 0;
277 unsigned long ts = jiffies;
278
279 if (handle->h_rsv_handle)
280 rsv_blocks = handle->h_rsv_handle->h_buffer_credits;
281
282
283
284
285
286
287 if ((rsv_blocks > journal->j_max_transaction_buffers / 2) ||
288 (rsv_blocks + blocks > journal->j_max_transaction_buffers)) {
289 printk(KERN_ERR "JBD2: %s wants too many credits "
290 "credits:%d rsv_credits:%d max:%d\n",
291 current->comm, blocks, rsv_blocks,
292 journal->j_max_transaction_buffers);
293 WARN_ON(1);
294 return -ENOSPC;
295 }
296
297alloc_transaction:
298 if (!journal->j_running_transaction) {
299
300
301
302
303 if ((gfp_mask & __GFP_FS) == 0)
304 gfp_mask |= __GFP_NOFAIL;
305 new_transaction = kmem_cache_zalloc(transaction_cache,
306 gfp_mask);
307 if (!new_transaction)
308 return -ENOMEM;
309 }
310
311 jbd_debug(3, "New handle %p going live.\n", handle);
312
313
314
315
316
317repeat:
318 read_lock(&journal->j_state_lock);
319 BUG_ON(journal->j_flags & JBD2_UNMOUNT);
320 if (is_journal_aborted(journal) ||
321 (journal->j_errno != 0 && !(journal->j_flags & JBD2_ACK_ERR))) {
322 read_unlock(&journal->j_state_lock);
323 jbd2_journal_free_transaction(new_transaction);
324 return -EROFS;
325 }
326
327
328
329
330
331
332 if (!handle->h_reserved && journal->j_barrier_count) {
333 read_unlock(&journal->j_state_lock);
334 wait_event(journal->j_wait_transaction_locked,
335 journal->j_barrier_count == 0);
336 goto repeat;
337 }
338
339 if (!journal->j_running_transaction) {
340 read_unlock(&journal->j_state_lock);
341 if (!new_transaction)
342 goto alloc_transaction;
343 write_lock(&journal->j_state_lock);
344 if (!journal->j_running_transaction &&
345 (handle->h_reserved || !journal->j_barrier_count)) {
346 jbd2_get_transaction(journal, new_transaction);
347 new_transaction = NULL;
348 }
349 write_unlock(&journal->j_state_lock);
350 goto repeat;
351 }
352
353 transaction = journal->j_running_transaction;
354
355 if (!handle->h_reserved) {
356
357 if (add_transaction_credits(journal, blocks, rsv_blocks))
358 goto repeat;
359 } else {
360
361
362
363
364
365 sub_reserved_credits(journal, blocks);
366 handle->h_reserved = 0;
367 }
368
369
370
371
372 update_t_max_wait(transaction, ts);
373 handle->h_transaction = transaction;
374 handle->h_requested_credits = blocks;
375 handle->h_start_jiffies = jiffies;
376 atomic_inc(&transaction->t_updates);
377 atomic_inc(&transaction->t_handle_count);
378 jbd_debug(4, "Handle %p given %d credits (total %d, free %lu)\n",
379 handle, blocks,
380 atomic_read(&transaction->t_outstanding_credits),
381 jbd2_log_space_left(journal));
382 read_unlock(&journal->j_state_lock);
383 current->journal_info = handle;
384
385 lock_map_acquire(&handle->h_lockdep_map);
386 jbd2_journal_free_transaction(new_transaction);
387 return 0;
388}
389
390static struct lock_class_key jbd2_handle_key;
391
392
393static handle_t *new_handle(int nblocks)
394{
395 handle_t *handle = jbd2_alloc_handle(GFP_NOFS);
396 if (!handle)
397 return NULL;
398 handle->h_buffer_credits = nblocks;
399 handle->h_ref = 1;
400
401 lockdep_init_map(&handle->h_lockdep_map, "jbd2_handle",
402 &jbd2_handle_key, 0);
403
404 return handle;
405}
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426handle_t *jbd2__journal_start(journal_t *journal, int nblocks, int rsv_blocks,
427 gfp_t gfp_mask, unsigned int type,
428 unsigned int line_no)
429{
430 handle_t *handle = journal_current_handle();
431 int err;
432
433 if (!journal)
434 return ERR_PTR(-EROFS);
435
436 if (handle) {
437 J_ASSERT(handle->h_transaction->t_journal == journal);
438 handle->h_ref++;
439 return handle;
440 }
441
442 handle = new_handle(nblocks);
443 if (!handle)
444 return ERR_PTR(-ENOMEM);
445 if (rsv_blocks) {
446 handle_t *rsv_handle;
447
448 rsv_handle = new_handle(rsv_blocks);
449 if (!rsv_handle) {
450 jbd2_free_handle(handle);
451 return ERR_PTR(-ENOMEM);
452 }
453 rsv_handle->h_reserved = 1;
454 rsv_handle->h_journal = journal;
455 handle->h_rsv_handle = rsv_handle;
456 }
457
458 err = start_this_handle(journal, handle, gfp_mask);
459 if (err < 0) {
460 if (handle->h_rsv_handle)
461 jbd2_free_handle(handle->h_rsv_handle);
462 jbd2_free_handle(handle);
463 return ERR_PTR(err);
464 }
465 handle->h_type = type;
466 handle->h_line_no = line_no;
467 trace_jbd2_handle_start(journal->j_fs_dev->bd_dev,
468 handle->h_transaction->t_tid, type,
469 line_no, nblocks);
470 return handle;
471}
472EXPORT_SYMBOL(jbd2__journal_start);
473
474
475handle_t *jbd2_journal_start(journal_t *journal, int nblocks)
476{
477 return jbd2__journal_start(journal, nblocks, 0, GFP_NOFS, 0, 0);
478}
479EXPORT_SYMBOL(jbd2_journal_start);
480
481void jbd2_journal_free_reserved(handle_t *handle)
482{
483 journal_t *journal = handle->h_journal;
484
485 WARN_ON(!handle->h_reserved);
486 sub_reserved_credits(journal, handle->h_buffer_credits);
487 jbd2_free_handle(handle);
488}
489EXPORT_SYMBOL(jbd2_journal_free_reserved);
490
491
492
493
494
495
496
497
498
499
500
501
502
503int jbd2_journal_start_reserved(handle_t *handle, unsigned int type,
504 unsigned int line_no)
505{
506 journal_t *journal = handle->h_journal;
507 int ret = -EIO;
508
509 if (WARN_ON(!handle->h_reserved)) {
510
511 jbd2_journal_stop(handle);
512 return ret;
513 }
514
515
516
517
518 if (WARN_ON(current->journal_info)) {
519 jbd2_journal_free_reserved(handle);
520 return ret;
521 }
522
523 handle->h_journal = NULL;
524
525
526
527
528 ret = start_this_handle(journal, handle, GFP_NOFS);
529 if (ret < 0) {
530 jbd2_journal_free_reserved(handle);
531 return ret;
532 }
533 handle->h_type = type;
534 handle->h_line_no = line_no;
535 return 0;
536}
537EXPORT_SYMBOL(jbd2_journal_start_reserved);
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559int jbd2_journal_extend(handle_t *handle, int nblocks)
560{
561 transaction_t *transaction = handle->h_transaction;
562 journal_t *journal;
563 int result;
564 int wanted;
565
566 if (is_handle_aborted(handle))
567 return -EROFS;
568 journal = transaction->t_journal;
569
570 result = 1;
571
572 read_lock(&journal->j_state_lock);
573
574
575 if (transaction->t_state != T_RUNNING) {
576 jbd_debug(3, "denied handle %p %d blocks: "
577 "transaction not running\n", handle, nblocks);
578 goto error_out;
579 }
580
581 spin_lock(&transaction->t_handle_lock);
582 wanted = atomic_add_return(nblocks,
583 &transaction->t_outstanding_credits);
584
585 if (wanted > journal->j_max_transaction_buffers) {
586 jbd_debug(3, "denied handle %p %d blocks: "
587 "transaction too large\n", handle, nblocks);
588 atomic_sub(nblocks, &transaction->t_outstanding_credits);
589 goto unlock;
590 }
591
592 if (wanted + (wanted >> JBD2_CONTROL_BLOCKS_SHIFT) >
593 jbd2_log_space_left(journal)) {
594 jbd_debug(3, "denied handle %p %d blocks: "
595 "insufficient log space\n", handle, nblocks);
596 atomic_sub(nblocks, &transaction->t_outstanding_credits);
597 goto unlock;
598 }
599
600 trace_jbd2_handle_extend(journal->j_fs_dev->bd_dev,
601 transaction->t_tid,
602 handle->h_type, handle->h_line_no,
603 handle->h_buffer_credits,
604 nblocks);
605
606 handle->h_buffer_credits += nblocks;
607 handle->h_requested_credits += nblocks;
608 result = 0;
609
610 jbd_debug(3, "extended handle %p by %d\n", handle, nblocks);
611unlock:
612 spin_unlock(&transaction->t_handle_lock);
613error_out:
614 read_unlock(&journal->j_state_lock);
615 return result;
616}
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634int jbd2__journal_restart(handle_t *handle, int nblocks, gfp_t gfp_mask)
635{
636 transaction_t *transaction = handle->h_transaction;
637 journal_t *journal;
638 tid_t tid;
639 int need_to_start, ret;
640
641
642
643 if (is_handle_aborted(handle))
644 return 0;
645 journal = transaction->t_journal;
646
647
648
649
650
651 J_ASSERT(atomic_read(&transaction->t_updates) > 0);
652 J_ASSERT(journal_current_handle() == handle);
653
654 read_lock(&journal->j_state_lock);
655 spin_lock(&transaction->t_handle_lock);
656 atomic_sub(handle->h_buffer_credits,
657 &transaction->t_outstanding_credits);
658 if (handle->h_rsv_handle) {
659 sub_reserved_credits(journal,
660 handle->h_rsv_handle->h_buffer_credits);
661 }
662 if (atomic_dec_and_test(&transaction->t_updates))
663 wake_up(&journal->j_wait_updates);
664 tid = transaction->t_tid;
665 spin_unlock(&transaction->t_handle_lock);
666 handle->h_transaction = NULL;
667 current->journal_info = NULL;
668
669 jbd_debug(2, "restarting handle %p\n", handle);
670 need_to_start = !tid_geq(journal->j_commit_request, tid);
671 read_unlock(&journal->j_state_lock);
672 if (need_to_start)
673 jbd2_log_start_commit(journal, tid);
674
675 lock_map_release(&handle->h_lockdep_map);
676 handle->h_buffer_credits = nblocks;
677 ret = start_this_handle(journal, handle, gfp_mask);
678 return ret;
679}
680EXPORT_SYMBOL(jbd2__journal_restart);
681
682
683int jbd2_journal_restart(handle_t *handle, int nblocks)
684{
685 return jbd2__journal_restart(handle, nblocks, GFP_NOFS);
686}
687EXPORT_SYMBOL(jbd2_journal_restart);
688
689
690
691
692
693
694
695
696
697
698
699void jbd2_journal_lock_updates(journal_t *journal)
700{
701 DEFINE_WAIT(wait);
702
703 write_lock(&journal->j_state_lock);
704 ++journal->j_barrier_count;
705
706
707 if (atomic_read(&journal->j_reserved_credits)) {
708 write_unlock(&journal->j_state_lock);
709 wait_event(journal->j_wait_reserved,
710 atomic_read(&journal->j_reserved_credits) == 0);
711 write_lock(&journal->j_state_lock);
712 }
713
714
715 while (1) {
716 transaction_t *transaction = journal->j_running_transaction;
717
718 if (!transaction)
719 break;
720
721 spin_lock(&transaction->t_handle_lock);
722 prepare_to_wait(&journal->j_wait_updates, &wait,
723 TASK_UNINTERRUPTIBLE);
724 if (!atomic_read(&transaction->t_updates)) {
725 spin_unlock(&transaction->t_handle_lock);
726 finish_wait(&journal->j_wait_updates, &wait);
727 break;
728 }
729 spin_unlock(&transaction->t_handle_lock);
730 write_unlock(&journal->j_state_lock);
731 schedule();
732 finish_wait(&journal->j_wait_updates, &wait);
733 write_lock(&journal->j_state_lock);
734 }
735 write_unlock(&journal->j_state_lock);
736
737
738
739
740
741
742
743 mutex_lock(&journal->j_barrier);
744}
745
746
747
748
749
750
751
752
753
754void jbd2_journal_unlock_updates (journal_t *journal)
755{
756 J_ASSERT(journal->j_barrier_count != 0);
757
758 mutex_unlock(&journal->j_barrier);
759 write_lock(&journal->j_state_lock);
760 --journal->j_barrier_count;
761 write_unlock(&journal->j_state_lock);
762 wake_up(&journal->j_wait_transaction_locked);
763}
764
765static void warn_dirty_buffer(struct buffer_head *bh)
766{
767 printk(KERN_WARNING
768 "JBD2: Spotted dirty metadata buffer (dev = %pg, blocknr = %llu). "
769 "There's a risk of filesystem corruption in case of system "
770 "crash.\n",
771 bh->b_bdev, (unsigned long long)bh->b_blocknr);
772}
773
774
775static void jbd2_freeze_jh_data(struct journal_head *jh)
776{
777 struct page *page;
778 int offset;
779 char *source;
780 struct buffer_head *bh = jh2bh(jh);
781
782 J_EXPECT_JH(jh, buffer_uptodate(bh), "Possible IO failure.\n");
783 page = bh->b_page;
784 offset = offset_in_page(bh->b_data);
785 source = kmap_atomic(page);
786
787 jbd2_buffer_frozen_trigger(jh, source + offset, jh->b_triggers);
788 memcpy(jh->b_frozen_data, source + offset, bh->b_size);
789 kunmap_atomic(source);
790
791
792
793
794
795 jh->b_frozen_triggers = jh->b_triggers;
796}
797
798
799
800
801
802
803
804
805
806
807
808static int
809do_get_write_access(handle_t *handle, struct journal_head *jh,
810 int force_copy)
811{
812 struct buffer_head *bh;
813 transaction_t *transaction = handle->h_transaction;
814 journal_t *journal;
815 int error;
816 char *frozen_buffer = NULL;
817 unsigned long start_lock, time_lock;
818
819 if (is_handle_aborted(handle))
820 return -EROFS;
821 journal = transaction->t_journal;
822
823 jbd_debug(5, "journal_head %p, force_copy %d\n", jh, force_copy);
824
825 JBUFFER_TRACE(jh, "entry");
826repeat:
827 bh = jh2bh(jh);
828
829
830
831 start_lock = jiffies;
832 lock_buffer(bh);
833 jbd_lock_bh_state(bh);
834
835
836 time_lock = jbd2_time_diff(start_lock, jiffies);
837 if (time_lock > HZ/10)
838 trace_jbd2_lock_buffer_stall(bh->b_bdev->bd_dev,
839 jiffies_to_msecs(time_lock));
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854 if (buffer_dirty(bh)) {
855
856
857
858
859 if (jh->b_transaction) {
860 J_ASSERT_JH(jh,
861 jh->b_transaction == transaction ||
862 jh->b_transaction ==
863 journal->j_committing_transaction);
864 if (jh->b_next_transaction)
865 J_ASSERT_JH(jh, jh->b_next_transaction ==
866 transaction);
867 warn_dirty_buffer(bh);
868 }
869
870
871
872
873
874 JBUFFER_TRACE(jh, "Journalling dirty buffer");
875 clear_buffer_dirty(bh);
876 set_buffer_jbddirty(bh);
877 }
878
879 unlock_buffer(bh);
880
881 error = -EROFS;
882 if (is_handle_aborted(handle)) {
883 jbd_unlock_bh_state(bh);
884 goto out;
885 }
886 error = 0;
887
888
889
890
891
892 if (jh->b_transaction == transaction ||
893 jh->b_next_transaction == transaction)
894 goto done;
895
896
897
898
899
900 jh->b_modified = 0;
901
902
903
904
905
906
907 if (!jh->b_transaction) {
908 JBUFFER_TRACE(jh, "no transaction");
909 J_ASSERT_JH(jh, !jh->b_next_transaction);
910 JBUFFER_TRACE(jh, "file as BJ_Reserved");
911
912
913
914
915
916 smp_wmb();
917 spin_lock(&journal->j_list_lock);
918 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
919 spin_unlock(&journal->j_list_lock);
920 goto done;
921 }
922
923
924
925
926 if (jh->b_frozen_data) {
927 JBUFFER_TRACE(jh, "has frozen data");
928 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
929 goto attach_next;
930 }
931
932 JBUFFER_TRACE(jh, "owned by older transaction");
933 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
934 J_ASSERT_JH(jh, jh->b_transaction == journal->j_committing_transaction);
935
936
937
938
939
940
941
942
943
944
945 if (buffer_shadow(bh)) {
946 JBUFFER_TRACE(jh, "on shadow: sleep");
947 jbd_unlock_bh_state(bh);
948 wait_on_bit_io(&bh->b_state, BH_Shadow, TASK_UNINTERRUPTIBLE);
949 goto repeat;
950 }
951
952
953
954
955
956
957
958
959
960
961
962
963
964 if (jh->b_jlist == BJ_Metadata || force_copy) {
965 JBUFFER_TRACE(jh, "generate frozen data");
966 if (!frozen_buffer) {
967 JBUFFER_TRACE(jh, "allocate memory for buffer");
968 jbd_unlock_bh_state(bh);
969 frozen_buffer = jbd2_alloc(jh2bh(jh)->b_size,
970 GFP_NOFS | __GFP_NOFAIL);
971 goto repeat;
972 }
973 jh->b_frozen_data = frozen_buffer;
974 frozen_buffer = NULL;
975 jbd2_freeze_jh_data(jh);
976 }
977attach_next:
978
979
980
981
982
983 smp_wmb();
984 jh->b_next_transaction = transaction;
985
986done:
987 jbd_unlock_bh_state(bh);
988
989
990
991
992
993 jbd2_journal_cancel_revoke(handle, jh);
994
995out:
996 if (unlikely(frozen_buffer))
997 jbd2_free(frozen_buffer, bh->b_size);
998
999 JBUFFER_TRACE(jh, "exit");
1000 return error;
1001}
1002
1003
1004static bool jbd2_write_access_granted(handle_t *handle, struct buffer_head *bh,
1005 bool undo)
1006{
1007 struct journal_head *jh;
1008 bool ret = false;
1009
1010
1011 if (buffer_dirty(bh))
1012 return false;
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025 rcu_read_lock();
1026 if (!buffer_jbd(bh))
1027 goto out;
1028
1029 jh = READ_ONCE(bh->b_private);
1030 if (!jh)
1031 goto out;
1032
1033 if (undo && !jh->b_committed_data)
1034 goto out;
1035 if (jh->b_transaction != handle->h_transaction &&
1036 jh->b_next_transaction != handle->h_transaction)
1037 goto out;
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047 smp_mb();
1048 if (unlikely(jh->b_bh != bh))
1049 goto out;
1050 ret = true;
1051out:
1052 rcu_read_unlock();
1053 return ret;
1054}
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067int jbd2_journal_get_write_access(handle_t *handle, struct buffer_head *bh)
1068{
1069 struct journal_head *jh;
1070 int rc;
1071
1072 if (jbd2_write_access_granted(handle, bh, false))
1073 return 0;
1074
1075 jh = jbd2_journal_add_journal_head(bh);
1076
1077
1078
1079 rc = do_get_write_access(handle, jh, 0);
1080 jbd2_journal_put_journal_head(jh);
1081 return rc;
1082}
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104int jbd2_journal_get_create_access(handle_t *handle, struct buffer_head *bh)
1105{
1106 transaction_t *transaction = handle->h_transaction;
1107 journal_t *journal;
1108 struct journal_head *jh = jbd2_journal_add_journal_head(bh);
1109 int err;
1110
1111 jbd_debug(5, "journal_head %p\n", jh);
1112 err = -EROFS;
1113 if (is_handle_aborted(handle))
1114 goto out;
1115 journal = transaction->t_journal;
1116 err = 0;
1117
1118 JBUFFER_TRACE(jh, "entry");
1119
1120
1121
1122
1123
1124
1125
1126 jbd_lock_bh_state(bh);
1127 J_ASSERT_JH(jh, (jh->b_transaction == transaction ||
1128 jh->b_transaction == NULL ||
1129 (jh->b_transaction == journal->j_committing_transaction &&
1130 jh->b_jlist == BJ_Forget)));
1131
1132 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
1133 J_ASSERT_JH(jh, buffer_locked(jh2bh(jh)));
1134
1135 if (jh->b_transaction == NULL) {
1136
1137
1138
1139
1140
1141
1142
1143
1144 clear_buffer_dirty(jh2bh(jh));
1145
1146 jh->b_modified = 0;
1147
1148 JBUFFER_TRACE(jh, "file as BJ_Reserved");
1149 spin_lock(&journal->j_list_lock);
1150 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
1151 } else if (jh->b_transaction == journal->j_committing_transaction) {
1152
1153 jh->b_modified = 0;
1154
1155 JBUFFER_TRACE(jh, "set next transaction");
1156 spin_lock(&journal->j_list_lock);
1157 jh->b_next_transaction = transaction;
1158 }
1159 spin_unlock(&journal->j_list_lock);
1160 jbd_unlock_bh_state(bh);
1161
1162
1163
1164
1165
1166
1167
1168
1169 JBUFFER_TRACE(jh, "cancelling revoke");
1170 jbd2_journal_cancel_revoke(handle, jh);
1171out:
1172 jbd2_journal_put_journal_head(jh);
1173 return err;
1174}
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202int jbd2_journal_get_undo_access(handle_t *handle, struct buffer_head *bh)
1203{
1204 int err;
1205 struct journal_head *jh;
1206 char *committed_data = NULL;
1207
1208 JBUFFER_TRACE(jh, "entry");
1209 if (jbd2_write_access_granted(handle, bh, true))
1210 return 0;
1211
1212 jh = jbd2_journal_add_journal_head(bh);
1213
1214
1215
1216
1217
1218 err = do_get_write_access(handle, jh, 1);
1219 if (err)
1220 goto out;
1221
1222repeat:
1223 if (!jh->b_committed_data)
1224 committed_data = jbd2_alloc(jh2bh(jh)->b_size,
1225 GFP_NOFS|__GFP_NOFAIL);
1226
1227 jbd_lock_bh_state(bh);
1228 if (!jh->b_committed_data) {
1229
1230
1231 JBUFFER_TRACE(jh, "generate b_committed data");
1232 if (!committed_data) {
1233 jbd_unlock_bh_state(bh);
1234 goto repeat;
1235 }
1236
1237 jh->b_committed_data = committed_data;
1238 committed_data = NULL;
1239 memcpy(jh->b_committed_data, bh->b_data, bh->b_size);
1240 }
1241 jbd_unlock_bh_state(bh);
1242out:
1243 jbd2_journal_put_journal_head(jh);
1244 if (unlikely(committed_data))
1245 jbd2_free(committed_data, bh->b_size);
1246 return err;
1247}
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260void jbd2_journal_set_triggers(struct buffer_head *bh,
1261 struct jbd2_buffer_trigger_type *type)
1262{
1263 struct journal_head *jh = jbd2_journal_grab_journal_head(bh);
1264
1265 if (WARN_ON(!jh))
1266 return;
1267 jh->b_triggers = type;
1268 jbd2_journal_put_journal_head(jh);
1269}
1270
1271void jbd2_buffer_frozen_trigger(struct journal_head *jh, void *mapped_data,
1272 struct jbd2_buffer_trigger_type *triggers)
1273{
1274 struct buffer_head *bh = jh2bh(jh);
1275
1276 if (!triggers || !triggers->t_frozen)
1277 return;
1278
1279 triggers->t_frozen(triggers, bh, mapped_data, bh->b_size);
1280}
1281
1282void jbd2_buffer_abort_trigger(struct journal_head *jh,
1283 struct jbd2_buffer_trigger_type *triggers)
1284{
1285 if (!triggers || !triggers->t_abort)
1286 return;
1287
1288 triggers->t_abort(triggers, jh2bh(jh));
1289}
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314int jbd2_journal_dirty_metadata(handle_t *handle, struct buffer_head *bh)
1315{
1316 transaction_t *transaction = handle->h_transaction;
1317 journal_t *journal;
1318 struct journal_head *jh;
1319 int ret = 0;
1320
1321 if (is_handle_aborted(handle))
1322 return -EROFS;
1323 if (!buffer_jbd(bh)) {
1324 ret = -EUCLEAN;
1325 goto out;
1326 }
1327
1328
1329
1330
1331 jh = bh2jh(bh);
1332
1333
1334
1335
1336
1337
1338 if (jh->b_transaction != transaction &&
1339 jh->b_next_transaction != transaction) {
1340 jbd_lock_bh_state(bh);
1341 J_ASSERT_JH(jh, jh->b_transaction == transaction ||
1342 jh->b_next_transaction == transaction);
1343 jbd_unlock_bh_state(bh);
1344 }
1345 if (jh->b_modified == 1) {
1346
1347 if (jh->b_transaction == transaction &&
1348 jh->b_jlist != BJ_Metadata) {
1349 jbd_lock_bh_state(bh);
1350 J_ASSERT_JH(jh, jh->b_transaction != transaction ||
1351 jh->b_jlist == BJ_Metadata);
1352 jbd_unlock_bh_state(bh);
1353 }
1354 goto out;
1355 }
1356
1357 journal = transaction->t_journal;
1358 jbd_debug(5, "journal_head %p\n", jh);
1359 JBUFFER_TRACE(jh, "entry");
1360
1361 jbd_lock_bh_state(bh);
1362
1363 if (jh->b_modified == 0) {
1364
1365
1366
1367
1368
1369 jh->b_modified = 1;
1370 if (handle->h_buffer_credits <= 0) {
1371 ret = -ENOSPC;
1372 goto out_unlock_bh;
1373 }
1374 handle->h_buffer_credits--;
1375 }
1376
1377
1378
1379
1380
1381
1382
1383
1384 if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) {
1385 JBUFFER_TRACE(jh, "fastpath");
1386 if (unlikely(jh->b_transaction !=
1387 journal->j_running_transaction)) {
1388 printk(KERN_ERR "JBD2: %s: "
1389 "jh->b_transaction (%llu, %p, %u) != "
1390 "journal->j_running_transaction (%p, %u)\n",
1391 journal->j_devname,
1392 (unsigned long long) bh->b_blocknr,
1393 jh->b_transaction,
1394 jh->b_transaction ? jh->b_transaction->t_tid : 0,
1395 journal->j_running_transaction,
1396 journal->j_running_transaction ?
1397 journal->j_running_transaction->t_tid : 0);
1398 ret = -EINVAL;
1399 }
1400 goto out_unlock_bh;
1401 }
1402
1403 set_buffer_jbddirty(bh);
1404
1405
1406
1407
1408
1409
1410
1411 if (jh->b_transaction != transaction) {
1412 JBUFFER_TRACE(jh, "already on other transaction");
1413 if (unlikely(((jh->b_transaction !=
1414 journal->j_committing_transaction)) ||
1415 (jh->b_next_transaction != transaction))) {
1416 printk(KERN_ERR "jbd2_journal_dirty_metadata: %s: "
1417 "bad jh for block %llu: "
1418 "transaction (%p, %u), "
1419 "jh->b_transaction (%p, %u), "
1420 "jh->b_next_transaction (%p, %u), jlist %u\n",
1421 journal->j_devname,
1422 (unsigned long long) bh->b_blocknr,
1423 transaction, transaction->t_tid,
1424 jh->b_transaction,
1425 jh->b_transaction ?
1426 jh->b_transaction->t_tid : 0,
1427 jh->b_next_transaction,
1428 jh->b_next_transaction ?
1429 jh->b_next_transaction->t_tid : 0,
1430 jh->b_jlist);
1431 WARN_ON(1);
1432 ret = -EINVAL;
1433 }
1434
1435
1436 goto out_unlock_bh;
1437 }
1438
1439
1440 J_ASSERT_JH(jh, jh->b_frozen_data == NULL);
1441
1442 JBUFFER_TRACE(jh, "file as BJ_Metadata");
1443 spin_lock(&journal->j_list_lock);
1444 __jbd2_journal_file_buffer(jh, transaction, BJ_Metadata);
1445 spin_unlock(&journal->j_list_lock);
1446out_unlock_bh:
1447 jbd_unlock_bh_state(bh);
1448out:
1449 JBUFFER_TRACE(jh, "exit");
1450 return ret;
1451}
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470int jbd2_journal_forget (handle_t *handle, struct buffer_head *bh)
1471{
1472 transaction_t *transaction = handle->h_transaction;
1473 journal_t *journal;
1474 struct journal_head *jh;
1475 int drop_reserve = 0;
1476 int err = 0;
1477 int was_modified = 0;
1478
1479 if (is_handle_aborted(handle))
1480 return -EROFS;
1481 journal = transaction->t_journal;
1482
1483 BUFFER_TRACE(bh, "entry");
1484
1485 jbd_lock_bh_state(bh);
1486
1487 if (!buffer_jbd(bh))
1488 goto not_jbd;
1489 jh = bh2jh(bh);
1490
1491
1492
1493 if (!J_EXPECT_JH(jh, !jh->b_committed_data,
1494 "inconsistent data on disk")) {
1495 err = -EIO;
1496 goto not_jbd;
1497 }
1498
1499
1500 was_modified = jh->b_modified;
1501
1502
1503
1504
1505
1506 jh->b_modified = 0;
1507
1508 if (jh->b_transaction == transaction) {
1509 J_ASSERT_JH(jh, !jh->b_frozen_data);
1510
1511
1512
1513
1514 clear_buffer_dirty(bh);
1515 clear_buffer_jbddirty(bh);
1516
1517 JBUFFER_TRACE(jh, "belongs to current transaction: unfile");
1518
1519
1520
1521
1522
1523 if (was_modified)
1524 drop_reserve = 1;
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538 spin_lock(&journal->j_list_lock);
1539 if (jh->b_cp_transaction) {
1540 __jbd2_journal_temp_unlink_buffer(jh);
1541 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
1542 } else {
1543 __jbd2_journal_unfile_buffer(jh);
1544 if (!buffer_jbd(bh)) {
1545 spin_unlock(&journal->j_list_lock);
1546 jbd_unlock_bh_state(bh);
1547 __bforget(bh);
1548 goto drop;
1549 }
1550 }
1551 spin_unlock(&journal->j_list_lock);
1552 } else if (jh->b_transaction) {
1553 J_ASSERT_JH(jh, (jh->b_transaction ==
1554 journal->j_committing_transaction));
1555
1556
1557 JBUFFER_TRACE(jh, "belongs to older transaction");
1558
1559
1560
1561 if (jh->b_next_transaction) {
1562 J_ASSERT(jh->b_next_transaction == transaction);
1563 spin_lock(&journal->j_list_lock);
1564 jh->b_next_transaction = NULL;
1565 spin_unlock(&journal->j_list_lock);
1566
1567
1568
1569
1570
1571 if (was_modified)
1572 drop_reserve = 1;
1573 }
1574 }
1575
1576not_jbd:
1577 jbd_unlock_bh_state(bh);
1578 __brelse(bh);
1579drop:
1580 if (drop_reserve) {
1581
1582 handle->h_buffer_credits++;
1583 }
1584 return err;
1585}
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603int jbd2_journal_stop(handle_t *handle)
1604{
1605 transaction_t *transaction = handle->h_transaction;
1606 journal_t *journal;
1607 int err = 0, wait_for_commit = 0;
1608 tid_t tid;
1609 pid_t pid;
1610
1611 if (!transaction) {
1612
1613
1614
1615
1616
1617 if (--handle->h_ref > 0) {
1618 jbd_debug(4, "h_ref %d -> %d\n", handle->h_ref + 1,
1619 handle->h_ref);
1620 return err;
1621 } else {
1622 if (handle->h_rsv_handle)
1623 jbd2_free_handle(handle->h_rsv_handle);
1624 goto free_and_exit;
1625 }
1626 }
1627 journal = transaction->t_journal;
1628
1629 J_ASSERT(journal_current_handle() == handle);
1630
1631 if (is_handle_aborted(handle))
1632 err = -EIO;
1633 else
1634 J_ASSERT(atomic_read(&transaction->t_updates) > 0);
1635
1636 if (--handle->h_ref > 0) {
1637 jbd_debug(4, "h_ref %d -> %d\n", handle->h_ref + 1,
1638 handle->h_ref);
1639 return err;
1640 }
1641
1642 jbd_debug(4, "Handle %p going down\n", handle);
1643 trace_jbd2_handle_stats(journal->j_fs_dev->bd_dev,
1644 transaction->t_tid,
1645 handle->h_type, handle->h_line_no,
1646 jiffies - handle->h_start_jiffies,
1647 handle->h_sync, handle->h_requested_credits,
1648 (handle->h_requested_credits -
1649 handle->h_buffer_credits));
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680 pid = current->pid;
1681 if (handle->h_sync && journal->j_last_sync_writer != pid &&
1682 journal->j_max_batch_time) {
1683 u64 commit_time, trans_time;
1684
1685 journal->j_last_sync_writer = pid;
1686
1687 read_lock(&journal->j_state_lock);
1688 commit_time = journal->j_average_commit_time;
1689 read_unlock(&journal->j_state_lock);
1690
1691 trans_time = ktime_to_ns(ktime_sub(ktime_get(),
1692 transaction->t_start_time));
1693
1694 commit_time = max_t(u64, commit_time,
1695 1000*journal->j_min_batch_time);
1696 commit_time = min_t(u64, commit_time,
1697 1000*journal->j_max_batch_time);
1698
1699 if (trans_time < commit_time) {
1700 ktime_t expires = ktime_add_ns(ktime_get(),
1701 commit_time);
1702 set_current_state(TASK_UNINTERRUPTIBLE);
1703 schedule_hrtimeout(&expires, HRTIMER_MODE_ABS);
1704 }
1705 }
1706
1707 if (handle->h_sync)
1708 transaction->t_synchronous_commit = 1;
1709 current->journal_info = NULL;
1710 atomic_sub(handle->h_buffer_credits,
1711 &transaction->t_outstanding_credits);
1712
1713
1714
1715
1716
1717
1718
1719 if (handle->h_sync ||
1720 (atomic_read(&transaction->t_outstanding_credits) >
1721 journal->j_max_transaction_buffers) ||
1722 time_after_eq(jiffies, transaction->t_expires)) {
1723
1724
1725
1726
1727 jbd_debug(2, "transaction too old, requesting commit for "
1728 "handle %p\n", handle);
1729
1730 jbd2_log_start_commit(journal, transaction->t_tid);
1731
1732
1733
1734
1735
1736 if (handle->h_sync && !(current->flags & PF_MEMALLOC))
1737 wait_for_commit = 1;
1738 }
1739
1740
1741
1742
1743
1744
1745
1746 tid = transaction->t_tid;
1747 if (atomic_dec_and_test(&transaction->t_updates)) {
1748 wake_up(&journal->j_wait_updates);
1749 if (journal->j_barrier_count)
1750 wake_up(&journal->j_wait_transaction_locked);
1751 }
1752
1753 if (wait_for_commit)
1754 err = jbd2_log_wait_commit(journal, tid);
1755
1756 lock_map_release(&handle->h_lockdep_map);
1757
1758 if (handle->h_rsv_handle)
1759 jbd2_journal_free_reserved(handle->h_rsv_handle);
1760free_and_exit:
1761 jbd2_free_handle(handle);
1762 return err;
1763}
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781static inline void
1782__blist_add_buffer(struct journal_head **list, struct journal_head *jh)
1783{
1784 if (!*list) {
1785 jh->b_tnext = jh->b_tprev = jh;
1786 *list = jh;
1787 } else {
1788
1789 struct journal_head *first = *list, *last = first->b_tprev;
1790 jh->b_tprev = last;
1791 jh->b_tnext = first;
1792 last->b_tnext = first->b_tprev = jh;
1793 }
1794}
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805static inline void
1806__blist_del_buffer(struct journal_head **list, struct journal_head *jh)
1807{
1808 if (*list == jh) {
1809 *list = jh->b_tnext;
1810 if (*list == jh)
1811 *list = NULL;
1812 }
1813 jh->b_tprev->b_tnext = jh->b_tnext;
1814 jh->b_tnext->b_tprev = jh->b_tprev;
1815}
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh)
1829{
1830 struct journal_head **list = NULL;
1831 transaction_t *transaction;
1832 struct buffer_head *bh = jh2bh(jh);
1833
1834 J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh));
1835 transaction = jh->b_transaction;
1836 if (transaction)
1837 assert_spin_locked(&transaction->t_journal->j_list_lock);
1838
1839 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
1840 if (jh->b_jlist != BJ_None)
1841 J_ASSERT_JH(jh, transaction != NULL);
1842
1843 switch (jh->b_jlist) {
1844 case BJ_None:
1845 return;
1846 case BJ_Metadata:
1847 transaction->t_nr_buffers--;
1848 J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0);
1849 list = &transaction->t_buffers;
1850 break;
1851 case BJ_Forget:
1852 list = &transaction->t_forget;
1853 break;
1854 case BJ_Shadow:
1855 list = &transaction->t_shadow_list;
1856 break;
1857 case BJ_Reserved:
1858 list = &transaction->t_reserved_list;
1859 break;
1860 }
1861
1862 __blist_del_buffer(list, jh);
1863 jh->b_jlist = BJ_None;
1864 if (test_clear_buffer_jbddirty(bh))
1865 mark_buffer_dirty(bh);
1866}
1867
1868
1869
1870
1871
1872
1873
1874
1875static void __jbd2_journal_unfile_buffer(struct journal_head *jh)
1876{
1877 __jbd2_journal_temp_unlink_buffer(jh);
1878 jh->b_transaction = NULL;
1879 jbd2_journal_put_journal_head(jh);
1880}
1881
1882void jbd2_journal_unfile_buffer(journal_t *journal, struct journal_head *jh)
1883{
1884 struct buffer_head *bh = jh2bh(jh);
1885
1886
1887 get_bh(bh);
1888 jbd_lock_bh_state(bh);
1889 spin_lock(&journal->j_list_lock);
1890 __jbd2_journal_unfile_buffer(jh);
1891 spin_unlock(&journal->j_list_lock);
1892 jbd_unlock_bh_state(bh);
1893 __brelse(bh);
1894}
1895
1896
1897
1898
1899
1900
1901static void
1902__journal_try_to_free_buffer(journal_t *journal, struct buffer_head *bh)
1903{
1904 struct journal_head *jh;
1905
1906 jh = bh2jh(bh);
1907
1908 if (buffer_locked(bh) || buffer_dirty(bh))
1909 goto out;
1910
1911 if (jh->b_next_transaction != NULL || jh->b_transaction != NULL)
1912 goto out;
1913
1914 spin_lock(&journal->j_list_lock);
1915 if (jh->b_cp_transaction != NULL) {
1916
1917 JBUFFER_TRACE(jh, "remove from checkpoint list");
1918 __jbd2_journal_remove_checkpoint(jh);
1919 }
1920 spin_unlock(&journal->j_list_lock);
1921out:
1922 return;
1923}
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963int jbd2_journal_try_to_free_buffers(journal_t *journal,
1964 struct page *page, gfp_t gfp_mask)
1965{
1966 struct buffer_head *head;
1967 struct buffer_head *bh;
1968 int ret = 0;
1969
1970 J_ASSERT(PageLocked(page));
1971
1972 head = page_buffers(page);
1973 bh = head;
1974 do {
1975 struct journal_head *jh;
1976
1977
1978
1979
1980
1981
1982 jh = jbd2_journal_grab_journal_head(bh);
1983 if (!jh)
1984 continue;
1985
1986 jbd_lock_bh_state(bh);
1987 __journal_try_to_free_buffer(journal, bh);
1988 jbd2_journal_put_journal_head(jh);
1989 jbd_unlock_bh_state(bh);
1990 if (buffer_jbd(bh))
1991 goto busy;
1992 } while ((bh = bh->b_this_page) != head);
1993
1994 ret = try_to_free_buffers(page);
1995
1996busy:
1997 return ret;
1998}
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012static int __dispose_buffer(struct journal_head *jh, transaction_t *transaction)
2013{
2014 int may_free = 1;
2015 struct buffer_head *bh = jh2bh(jh);
2016
2017 if (jh->b_cp_transaction) {
2018 JBUFFER_TRACE(jh, "on running+cp transaction");
2019 __jbd2_journal_temp_unlink_buffer(jh);
2020
2021
2022
2023
2024
2025 clear_buffer_dirty(bh);
2026 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
2027 may_free = 0;
2028 } else {
2029 JBUFFER_TRACE(jh, "on running transaction");
2030 __jbd2_journal_unfile_buffer(jh);
2031 }
2032 return may_free;
2033}
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh,
2083 int partial_page)
2084{
2085 transaction_t *transaction;
2086 struct journal_head *jh;
2087 int may_free = 1;
2088
2089 BUFFER_TRACE(bh, "entry");
2090
2091
2092
2093
2094
2095
2096
2097 if (!buffer_jbd(bh))
2098 goto zap_buffer_unlocked;
2099
2100
2101 write_lock(&journal->j_state_lock);
2102 jbd_lock_bh_state(bh);
2103 spin_lock(&journal->j_list_lock);
2104
2105 jh = jbd2_journal_grab_journal_head(bh);
2106 if (!jh)
2107 goto zap_buffer_no_jh;
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 transaction = jh->b_transaction;
2133 if (transaction == NULL) {
2134
2135
2136
2137
2138 if (!jh->b_cp_transaction) {
2139 JBUFFER_TRACE(jh, "not on any transaction: zap");
2140 goto zap_buffer;
2141 }
2142
2143 if (!buffer_dirty(bh)) {
2144
2145 __jbd2_journal_remove_checkpoint(jh);
2146 goto zap_buffer;
2147 }
2148
2149
2150
2151
2152
2153 if (journal->j_running_transaction) {
2154
2155
2156
2157 JBUFFER_TRACE(jh, "checkpointed: add to BJ_Forget");
2158 may_free = __dispose_buffer(jh,
2159 journal->j_running_transaction);
2160 goto zap_buffer;
2161 } else {
2162
2163
2164
2165
2166 if (journal->j_committing_transaction) {
2167 JBUFFER_TRACE(jh, "give to committing trans");
2168 may_free = __dispose_buffer(jh,
2169 journal->j_committing_transaction);
2170 goto zap_buffer;
2171 } else {
2172
2173
2174 clear_buffer_jbddirty(bh);
2175 __jbd2_journal_remove_checkpoint(jh);
2176 goto zap_buffer;
2177 }
2178 }
2179 } else if (transaction == journal->j_committing_transaction) {
2180 JBUFFER_TRACE(jh, "on committing transaction");
2181
2182
2183
2184
2185
2186 if (partial_page) {
2187 jbd2_journal_put_journal_head(jh);
2188 spin_unlock(&journal->j_list_lock);
2189 jbd_unlock_bh_state(bh);
2190 write_unlock(&journal->j_state_lock);
2191 return -EBUSY;
2192 }
2193
2194
2195
2196
2197
2198
2199 set_buffer_freed(bh);
2200 if (journal->j_running_transaction && buffer_jbddirty(bh))
2201 jh->b_next_transaction = journal->j_running_transaction;
2202 jbd2_journal_put_journal_head(jh);
2203 spin_unlock(&journal->j_list_lock);
2204 jbd_unlock_bh_state(bh);
2205 write_unlock(&journal->j_state_lock);
2206 return 0;
2207 } else {
2208
2209
2210
2211
2212
2213
2214 J_ASSERT_JH(jh, transaction == journal->j_running_transaction);
2215 JBUFFER_TRACE(jh, "on running transaction");
2216 may_free = __dispose_buffer(jh, transaction);
2217 }
2218
2219zap_buffer:
2220
2221
2222
2223
2224
2225
2226
2227
2228 jh->b_modified = 0;
2229 jbd2_journal_put_journal_head(jh);
2230zap_buffer_no_jh:
2231 spin_unlock(&journal->j_list_lock);
2232 jbd_unlock_bh_state(bh);
2233 write_unlock(&journal->j_state_lock);
2234zap_buffer_unlocked:
2235 clear_buffer_dirty(bh);
2236 J_ASSERT_BH(bh, !buffer_jbddirty(bh));
2237 clear_buffer_mapped(bh);
2238 clear_buffer_req(bh);
2239 clear_buffer_new(bh);
2240 clear_buffer_delay(bh);
2241 clear_buffer_unwritten(bh);
2242 bh->b_bdev = NULL;
2243 return may_free;
2244}
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258int jbd2_journal_invalidatepage(journal_t *journal,
2259 struct page *page,
2260 unsigned int offset,
2261 unsigned int length)
2262{
2263 struct buffer_head *head, *bh, *next;
2264 unsigned int stop = offset + length;
2265 unsigned int curr_off = 0;
2266 int partial_page = (offset || length < PAGE_SIZE);
2267 int may_free = 1;
2268 int ret = 0;
2269
2270 if (!PageLocked(page))
2271 BUG();
2272 if (!page_has_buffers(page))
2273 return 0;
2274
2275 BUG_ON(stop > PAGE_SIZE || stop < length);
2276
2277
2278
2279
2280
2281 head = bh = page_buffers(page);
2282 do {
2283 unsigned int next_off = curr_off + bh->b_size;
2284 next = bh->b_this_page;
2285
2286 if (next_off > stop)
2287 return 0;
2288
2289 if (offset <= curr_off) {
2290
2291 lock_buffer(bh);
2292 ret = journal_unmap_buffer(journal, bh, partial_page);
2293 unlock_buffer(bh);
2294 if (ret < 0)
2295 return ret;
2296 may_free &= ret;
2297 }
2298 curr_off = next_off;
2299 bh = next;
2300
2301 } while (bh != head);
2302
2303 if (!partial_page) {
2304 if (may_free && try_to_free_buffers(page))
2305 J_ASSERT(!page_has_buffers(page));
2306 }
2307 return 0;
2308}
2309
2310
2311
2312
2313void __jbd2_journal_file_buffer(struct journal_head *jh,
2314 transaction_t *transaction, int jlist)
2315{
2316 struct journal_head **list = NULL;
2317 int was_dirty = 0;
2318 struct buffer_head *bh = jh2bh(jh);
2319
2320 J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh));
2321 assert_spin_locked(&transaction->t_journal->j_list_lock);
2322
2323 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
2324 J_ASSERT_JH(jh, jh->b_transaction == transaction ||
2325 jh->b_transaction == NULL);
2326
2327 if (jh->b_transaction && jh->b_jlist == jlist)
2328 return;
2329
2330 if (jlist == BJ_Metadata || jlist == BJ_Reserved ||
2331 jlist == BJ_Shadow || jlist == BJ_Forget) {
2332
2333
2334
2335
2336
2337
2338
2339 if (buffer_dirty(bh))
2340 warn_dirty_buffer(bh);
2341 if (test_clear_buffer_dirty(bh) ||
2342 test_clear_buffer_jbddirty(bh))
2343 was_dirty = 1;
2344 }
2345
2346 if (jh->b_transaction)
2347 __jbd2_journal_temp_unlink_buffer(jh);
2348 else
2349 jbd2_journal_grab_journal_head(bh);
2350 jh->b_transaction = transaction;
2351
2352 switch (jlist) {
2353 case BJ_None:
2354 J_ASSERT_JH(jh, !jh->b_committed_data);
2355 J_ASSERT_JH(jh, !jh->b_frozen_data);
2356 return;
2357 case BJ_Metadata:
2358 transaction->t_nr_buffers++;
2359 list = &transaction->t_buffers;
2360 break;
2361 case BJ_Forget:
2362 list = &transaction->t_forget;
2363 break;
2364 case BJ_Shadow:
2365 list = &transaction->t_shadow_list;
2366 break;
2367 case BJ_Reserved:
2368 list = &transaction->t_reserved_list;
2369 break;
2370 }
2371
2372 __blist_add_buffer(list, jh);
2373 jh->b_jlist = jlist;
2374
2375 if (was_dirty)
2376 set_buffer_jbddirty(bh);
2377}
2378
2379void jbd2_journal_file_buffer(struct journal_head *jh,
2380 transaction_t *transaction, int jlist)
2381{
2382 jbd_lock_bh_state(jh2bh(jh));
2383 spin_lock(&transaction->t_journal->j_list_lock);
2384 __jbd2_journal_file_buffer(jh, transaction, jlist);
2385 spin_unlock(&transaction->t_journal->j_list_lock);
2386 jbd_unlock_bh_state(jh2bh(jh));
2387}
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400void __jbd2_journal_refile_buffer(struct journal_head *jh)
2401{
2402 int was_dirty, jlist;
2403 struct buffer_head *bh = jh2bh(jh);
2404
2405 J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh));
2406 if (jh->b_transaction)
2407 assert_spin_locked(&jh->b_transaction->t_journal->j_list_lock);
2408
2409
2410 if (jh->b_next_transaction == NULL) {
2411 __jbd2_journal_unfile_buffer(jh);
2412 return;
2413 }
2414
2415
2416
2417
2418
2419
2420 was_dirty = test_clear_buffer_jbddirty(bh);
2421 __jbd2_journal_temp_unlink_buffer(jh);
2422
2423
2424
2425
2426
2427 jh->b_transaction = jh->b_next_transaction;
2428 jh->b_next_transaction = NULL;
2429 if (buffer_freed(bh))
2430 jlist = BJ_Forget;
2431 else if (jh->b_modified)
2432 jlist = BJ_Metadata;
2433 else
2434 jlist = BJ_Reserved;
2435 __jbd2_journal_file_buffer(jh, jh->b_transaction, jlist);
2436 J_ASSERT_JH(jh, jh->b_transaction->t_state == T_RUNNING);
2437
2438 if (was_dirty)
2439 set_buffer_jbddirty(bh);
2440}
2441
2442
2443
2444
2445
2446
2447
2448void jbd2_journal_refile_buffer(journal_t *journal, struct journal_head *jh)
2449{
2450 struct buffer_head *bh = jh2bh(jh);
2451
2452
2453 get_bh(bh);
2454 jbd_lock_bh_state(bh);
2455 spin_lock(&journal->j_list_lock);
2456 __jbd2_journal_refile_buffer(jh);
2457 jbd_unlock_bh_state(bh);
2458 spin_unlock(&journal->j_list_lock);
2459 __brelse(bh);
2460}
2461
2462
2463
2464
2465int jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *jinode)
2466{
2467 transaction_t *transaction = handle->h_transaction;
2468 journal_t *journal;
2469
2470 if (is_handle_aborted(handle))
2471 return -EROFS;
2472 journal = transaction->t_journal;
2473
2474 jbd_debug(4, "Adding inode %lu, tid:%d\n", jinode->i_vfs_inode->i_ino,
2475 transaction->t_tid);
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490 if (jinode->i_transaction == transaction ||
2491 jinode->i_next_transaction == transaction)
2492 return 0;
2493
2494 spin_lock(&journal->j_list_lock);
2495
2496 if (jinode->i_transaction == transaction ||
2497 jinode->i_next_transaction == transaction)
2498 goto done;
2499
2500
2501
2502
2503
2504
2505 if (!transaction->t_need_data_flush)
2506 transaction->t_need_data_flush = 1;
2507
2508
2509 if (jinode->i_transaction) {
2510 J_ASSERT(jinode->i_next_transaction == NULL);
2511 J_ASSERT(jinode->i_transaction ==
2512 journal->j_committing_transaction);
2513 jinode->i_next_transaction = transaction;
2514 goto done;
2515 }
2516
2517 J_ASSERT(!jinode->i_next_transaction);
2518 jinode->i_transaction = transaction;
2519 list_add(&jinode->i_list, &transaction->t_inode_list);
2520done:
2521 spin_unlock(&journal->j_list_lock);
2522
2523 return 0;
2524}
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546int jbd2_journal_begin_ordered_truncate(journal_t *journal,
2547 struct jbd2_inode *jinode,
2548 loff_t new_size)
2549{
2550 transaction_t *inode_trans, *commit_trans;
2551 int ret = 0;
2552
2553
2554 if (!jinode->i_transaction)
2555 goto out;
2556
2557
2558
2559 read_lock(&journal->j_state_lock);
2560 commit_trans = journal->j_committing_transaction;
2561 read_unlock(&journal->j_state_lock);
2562 spin_lock(&journal->j_list_lock);
2563 inode_trans = jinode->i_transaction;
2564 spin_unlock(&journal->j_list_lock);
2565 if (inode_trans == commit_trans) {
2566 ret = filemap_fdatawrite_range(jinode->i_vfs_inode->i_mapping,
2567 new_size, LLONG_MAX);
2568 if (ret)
2569 jbd2_journal_abort(journal, ret);
2570 }
2571out:
2572 return ret;
2573}
2574