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