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