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