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/blkdev.h>
26#include <trace/events/jbd2.h>
27
28
29
30
31
32
33static inline void __buffer_unlink_first(struct journal_head *jh)
34{
35 transaction_t *transaction = jh->b_cp_transaction;
36
37 jh->b_cpnext->b_cpprev = jh->b_cpprev;
38 jh->b_cpprev->b_cpnext = jh->b_cpnext;
39 if (transaction->t_checkpoint_list == jh) {
40 transaction->t_checkpoint_list = jh->b_cpnext;
41 if (transaction->t_checkpoint_list == jh)
42 transaction->t_checkpoint_list = NULL;
43 }
44}
45
46
47
48
49
50
51static inline void __buffer_unlink(struct journal_head *jh)
52{
53 transaction_t *transaction = jh->b_cp_transaction;
54
55 __buffer_unlink_first(jh);
56 if (transaction->t_checkpoint_io_list == jh) {
57 transaction->t_checkpoint_io_list = jh->b_cpnext;
58 if (transaction->t_checkpoint_io_list == jh)
59 transaction->t_checkpoint_io_list = NULL;
60 }
61}
62
63
64
65
66
67
68static inline void __buffer_relink_io(struct journal_head *jh)
69{
70 transaction_t *transaction = jh->b_cp_transaction;
71
72 __buffer_unlink_first(jh);
73
74 if (!transaction->t_checkpoint_io_list) {
75 jh->b_cpnext = jh->b_cpprev = jh;
76 } else {
77 jh->b_cpnext = transaction->t_checkpoint_io_list;
78 jh->b_cpprev = transaction->t_checkpoint_io_list->b_cpprev;
79 jh->b_cpprev->b_cpnext = jh;
80 jh->b_cpnext->b_cpprev = jh;
81 }
82 transaction->t_checkpoint_io_list = jh;
83}
84
85
86
87
88
89
90
91
92static int __try_to_free_cp_buf(struct journal_head *jh)
93{
94 int ret = 0;
95 struct buffer_head *bh = jh2bh(jh);
96
97 if (jh->b_transaction == NULL && !buffer_locked(bh) &&
98 !buffer_dirty(bh) && !buffer_write_io_error(bh)) {
99 JBUFFER_TRACE(jh, "remove from checkpoint list");
100 ret = __jbd2_journal_remove_checkpoint(jh) + 1;
101 }
102 return ret;
103}
104
105
106
107
108
109
110
111void __jbd2_log_wait_for_space(journal_t *journal)
112{
113 int nblocks, space_left;
114
115
116 nblocks = jbd2_space_needed(journal);
117 while (jbd2_log_space_left(journal) < nblocks) {
118 write_unlock(&journal->j_state_lock);
119 mutex_lock(&journal->j_checkpoint_mutex);
120
121
122
123
124
125
126
127
128
129
130
131
132 write_lock(&journal->j_state_lock);
133 if (journal->j_flags & JBD2_ABORT) {
134 mutex_unlock(&journal->j_checkpoint_mutex);
135 return;
136 }
137 spin_lock(&journal->j_list_lock);
138 nblocks = jbd2_space_needed(journal);
139 space_left = jbd2_log_space_left(journal);
140 if (space_left < nblocks) {
141 int chkpt = journal->j_checkpoint_transactions != NULL;
142 tid_t tid = 0;
143
144 if (journal->j_committing_transaction)
145 tid = journal->j_committing_transaction->t_tid;
146 spin_unlock(&journal->j_list_lock);
147 write_unlock(&journal->j_state_lock);
148 if (chkpt) {
149 jbd2_log_do_checkpoint(journal);
150 } else if (jbd2_cleanup_journal_tail(journal) == 0) {
151
152 ;
153 } else if (tid) {
154
155
156
157
158
159 mutex_unlock(&journal->j_checkpoint_mutex);
160 jbd2_log_wait_commit(journal, tid);
161 write_lock(&journal->j_state_lock);
162 continue;
163 } else {
164 printk(KERN_ERR "%s: needed %d blocks and "
165 "only had %d space available\n",
166 __func__, nblocks, space_left);
167 printk(KERN_ERR "%s: no way to get more "
168 "journal space in %s\n", __func__,
169 journal->j_devname);
170 WARN_ON(1);
171 jbd2_journal_abort(journal, 0);
172 }
173 write_lock(&journal->j_state_lock);
174 } else {
175 spin_unlock(&journal->j_list_lock);
176 }
177 mutex_unlock(&journal->j_checkpoint_mutex);
178 }
179}
180
181static void
182__flush_batch(journal_t *journal, int *batch_count)
183{
184 int i;
185 struct blk_plug plug;
186
187 blk_start_plug(&plug);
188 for (i = 0; i < *batch_count; i++)
189 write_dirty_buffer(journal->j_chkpt_bhs[i], WRITE_SYNC);
190 blk_finish_plug(&plug);
191
192 for (i = 0; i < *batch_count; i++) {
193 struct buffer_head *bh = journal->j_chkpt_bhs[i];
194 BUFFER_TRACE(bh, "brelse");
195 __brelse(bh);
196 }
197 *batch_count = 0;
198}
199
200
201
202
203
204
205
206
207
208int jbd2_log_do_checkpoint(journal_t *journal)
209{
210 struct journal_head *jh;
211 struct buffer_head *bh;
212 transaction_t *transaction;
213 tid_t this_tid;
214 int result, batch_count = 0;
215
216 jbd_debug(1, "Start checkpoint\n");
217
218
219
220
221
222
223 result = jbd2_cleanup_journal_tail(journal);
224 trace_jbd2_checkpoint(journal, result);
225 jbd_debug(1, "cleanup_journal_tail returned %d\n", result);
226 if (result <= 0)
227 return result;
228
229
230
231
232
233 result = 0;
234 spin_lock(&journal->j_list_lock);
235 if (!journal->j_checkpoint_transactions)
236 goto out;
237 transaction = journal->j_checkpoint_transactions;
238 if (transaction->t_chp_stats.cs_chp_time == 0)
239 transaction->t_chp_stats.cs_chp_time = jiffies;
240 this_tid = transaction->t_tid;
241restart:
242
243
244
245
246
247 if (journal->j_checkpoint_transactions != transaction ||
248 transaction->t_tid != this_tid)
249 goto out;
250
251
252 while (transaction->t_checkpoint_list) {
253 jh = transaction->t_checkpoint_list;
254 bh = jh2bh(jh);
255
256 if (buffer_locked(bh)) {
257 spin_unlock(&journal->j_list_lock);
258 get_bh(bh);
259 wait_on_buffer(bh);
260
261 BUFFER_TRACE(bh, "brelse");
262 __brelse(bh);
263 goto retry;
264 }
265 if (jh->b_transaction != NULL) {
266 transaction_t *t = jh->b_transaction;
267 tid_t tid = t->t_tid;
268
269 transaction->t_chp_stats.cs_forced_to_close++;
270 spin_unlock(&journal->j_list_lock);
271 if (unlikely(journal->j_flags & JBD2_UNMOUNT))
272
273
274
275
276
277
278 printk(KERN_ERR
279 "JBD2: %s: Waiting for Godot: block %llu\n",
280 journal->j_devname, (unsigned long long) bh->b_blocknr);
281
282 jbd2_log_start_commit(journal, tid);
283 jbd2_log_wait_commit(journal, tid);
284 goto retry;
285 }
286 if (!buffer_dirty(bh)) {
287 if (unlikely(buffer_write_io_error(bh)) && !result)
288 result = -EIO;
289 BUFFER_TRACE(bh, "remove from checkpoint");
290 if (__jbd2_journal_remove_checkpoint(jh))
291
292 goto out;
293 continue;
294 }
295
296
297
298
299
300
301
302
303 BUFFER_TRACE(bh, "queue");
304 get_bh(bh);
305 J_ASSERT_BH(bh, !buffer_jwrite(bh));
306 journal->j_chkpt_bhs[batch_count++] = bh;
307 __buffer_relink_io(jh);
308 transaction->t_chp_stats.cs_written++;
309 if ((batch_count == JBD2_NR_BATCH) ||
310 need_resched() ||
311 spin_needbreak(&journal->j_list_lock))
312 goto unlock_and_flush;
313 }
314
315 if (batch_count) {
316 unlock_and_flush:
317 spin_unlock(&journal->j_list_lock);
318 retry:
319 if (batch_count)
320 __flush_batch(journal, &batch_count);
321 spin_lock(&journal->j_list_lock);
322 goto restart;
323 }
324
325
326
327
328
329restart2:
330
331 if (journal->j_checkpoint_transactions != transaction ||
332 transaction->t_tid != this_tid)
333 goto out;
334
335 while (transaction->t_checkpoint_io_list) {
336 jh = transaction->t_checkpoint_io_list;
337 bh = jh2bh(jh);
338 if (buffer_locked(bh)) {
339 spin_unlock(&journal->j_list_lock);
340 get_bh(bh);
341 wait_on_buffer(bh);
342
343 BUFFER_TRACE(bh, "brelse");
344 __brelse(bh);
345 spin_lock(&journal->j_list_lock);
346 goto restart2;
347 }
348 if (unlikely(buffer_write_io_error(bh)) && !result)
349 result = -EIO;
350
351
352
353
354
355
356 if (__jbd2_journal_remove_checkpoint(jh))
357 break;
358 }
359out:
360 spin_unlock(&journal->j_list_lock);
361 if (result < 0)
362 jbd2_journal_abort(journal, result);
363 else
364 result = jbd2_cleanup_journal_tail(journal);
365
366 return (result < 0) ? result : 0;
367}
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387int jbd2_cleanup_journal_tail(journal_t *journal)
388{
389 tid_t first_tid;
390 unsigned long blocknr;
391
392 if (is_journal_aborted(journal))
393 return -EIO;
394
395 if (!jbd2_journal_get_log_tail(journal, &first_tid, &blocknr))
396 return 1;
397 J_ASSERT(blocknr != 0);
398
399
400
401
402
403
404
405
406
407 if (journal->j_flags & JBD2_BARRIER)
408 blkdev_issue_flush(journal->j_fs_dev, GFP_NOFS, NULL);
409
410 return __jbd2_update_log_tail(journal, first_tid, blocknr);
411}
412
413
414
415
416
417
418
419
420
421
422
423
424
425static int journal_clean_one_cp_list(struct journal_head *jh, bool destroy)
426{
427 struct journal_head *last_jh;
428 struct journal_head *next_jh = jh;
429 int ret;
430
431 if (!jh)
432 return 0;
433
434 last_jh = jh->b_cpprev;
435 do {
436 jh = next_jh;
437 next_jh = jh->b_cpnext;
438 if (!destroy)
439 ret = __try_to_free_cp_buf(jh);
440 else
441 ret = __jbd2_journal_remove_checkpoint(jh) + 1;
442 if (!ret)
443 return 0;
444 if (ret == 2)
445 return 1;
446
447
448
449
450
451
452 if (need_resched())
453 return 0;
454 } while (jh != last_jh);
455
456 return 0;
457}
458
459
460
461
462
463
464
465
466
467void __jbd2_journal_clean_checkpoint_list(journal_t *journal, bool destroy)
468{
469 transaction_t *transaction, *last_transaction, *next_transaction;
470 int ret;
471
472 transaction = journal->j_checkpoint_transactions;
473 if (!transaction)
474 return;
475
476 last_transaction = transaction->t_cpprev;
477 next_transaction = transaction;
478 do {
479 transaction = next_transaction;
480 next_transaction = transaction->t_cpnext;
481 ret = journal_clean_one_cp_list(transaction->t_checkpoint_list,
482 destroy);
483
484
485
486
487
488 if (need_resched())
489 return;
490 if (ret)
491 continue;
492
493
494
495
496
497 ret = journal_clean_one_cp_list(transaction->
498 t_checkpoint_io_list, destroy);
499 if (need_resched())
500 return;
501
502
503
504
505
506 if (!ret)
507 return;
508 } while (transaction != last_transaction);
509}
510
511
512
513
514
515void jbd2_journal_destroy_checkpoint(journal_t *journal)
516{
517
518
519
520
521 while (1) {
522 spin_lock(&journal->j_list_lock);
523 if (!journal->j_checkpoint_transactions) {
524 spin_unlock(&journal->j_list_lock);
525 break;
526 }
527 __jbd2_journal_clean_checkpoint_list(journal, true);
528 spin_unlock(&journal->j_list_lock);
529 cond_resched();
530 }
531}
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551int __jbd2_journal_remove_checkpoint(struct journal_head *jh)
552{
553 struct transaction_chp_stats_s *stats;
554 transaction_t *transaction;
555 journal_t *journal;
556 int ret = 0;
557
558 JBUFFER_TRACE(jh, "entry");
559
560 if ((transaction = jh->b_cp_transaction) == NULL) {
561 JBUFFER_TRACE(jh, "not on transaction");
562 goto out;
563 }
564 journal = transaction->t_journal;
565
566 JBUFFER_TRACE(jh, "removing from transaction");
567 __buffer_unlink(jh);
568 jh->b_cp_transaction = NULL;
569 jbd2_journal_put_journal_head(jh);
570
571 if (transaction->t_checkpoint_list != NULL ||
572 transaction->t_checkpoint_io_list != NULL)
573 goto out;
574
575
576
577
578
579
580
581
582
583
584 if (transaction->t_state != T_FINISHED)
585 goto out;
586
587
588
589 stats = &transaction->t_chp_stats;
590 if (stats->cs_chp_time)
591 stats->cs_chp_time = jbd2_time_diff(stats->cs_chp_time,
592 jiffies);
593 trace_jbd2_checkpoint_stats(journal->j_fs_dev->bd_dev,
594 transaction->t_tid, stats);
595
596 __jbd2_journal_drop_transaction(journal, transaction);
597 jbd2_journal_free_transaction(transaction);
598 ret = 1;
599out:
600 return ret;
601}
602
603
604
605
606
607
608
609
610
611void __jbd2_journal_insert_checkpoint(struct journal_head *jh,
612 transaction_t *transaction)
613{
614 JBUFFER_TRACE(jh, "entry");
615 J_ASSERT_JH(jh, buffer_dirty(jh2bh(jh)) || buffer_jbddirty(jh2bh(jh)));
616 J_ASSERT_JH(jh, jh->b_cp_transaction == NULL);
617
618
619 jbd2_journal_grab_journal_head(jh2bh(jh));
620 jh->b_cp_transaction = transaction;
621
622 if (!transaction->t_checkpoint_list) {
623 jh->b_cpnext = jh->b_cpprev = jh;
624 } else {
625 jh->b_cpnext = transaction->t_checkpoint_list;
626 jh->b_cpprev = transaction->t_checkpoint_list->b_cpprev;
627 jh->b_cpprev->b_cpnext = jh;
628 jh->b_cpnext->b_cpprev = jh;
629 }
630 transaction->t_checkpoint_list = jh;
631}
632
633
634
635
636
637
638
639
640
641
642
643void __jbd2_journal_drop_transaction(journal_t *journal, transaction_t *transaction)
644{
645 assert_spin_locked(&journal->j_list_lock);
646 if (transaction->t_cpnext) {
647 transaction->t_cpnext->t_cpprev = transaction->t_cpprev;
648 transaction->t_cpprev->t_cpnext = transaction->t_cpnext;
649 if (journal->j_checkpoint_transactions == transaction)
650 journal->j_checkpoint_transactions =
651 transaction->t_cpnext;
652 if (journal->j_checkpoint_transactions == transaction)
653 journal->j_checkpoint_transactions = NULL;
654 }
655
656 J_ASSERT(transaction->t_state == T_FINISHED);
657 J_ASSERT(transaction->t_buffers == NULL);
658 J_ASSERT(transaction->t_forget == NULL);
659 J_ASSERT(transaction->t_shadow_list == NULL);
660 J_ASSERT(transaction->t_checkpoint_list == NULL);
661 J_ASSERT(transaction->t_checkpoint_io_list == NULL);
662 J_ASSERT(atomic_read(&transaction->t_updates) == 0);
663 J_ASSERT(journal->j_committing_transaction != transaction);
664 J_ASSERT(journal->j_running_transaction != transaction);
665
666 trace_jbd2_drop_transaction(journal, transaction);
667
668 jbd_debug(1, "Dropping transaction %d, all done\n", transaction->t_tid);
669}
670