Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0+
2 : /*
3 : * linux/fs/jbd2/commit.c
4 : *
5 : * Written by Stephen C. Tweedie <sct@redhat.com>, 1998
6 : *
7 : * Copyright 1998 Red Hat corp --- All Rights Reserved
8 : *
9 : * Journal commit routines for the generic filesystem journaling code;
10 : * part of the ext2fs journaling system.
11 : */
12 :
13 : #include <linux/time.h>
14 : #include <linux/fs.h>
15 : #include <linux/jbd2.h>
16 : #include <linux/errno.h>
17 : #include <linux/slab.h>
18 : #include <linux/mm.h>
19 : #include <linux/pagemap.h>
20 : #include <linux/jiffies.h>
21 : #include <linux/crc32.h>
22 : #include <linux/writeback.h>
23 : #include <linux/backing-dev.h>
24 : #include <linux/bio.h>
25 : #include <linux/blkdev.h>
26 : #include <linux/bitops.h>
27 : #include <trace/events/jbd2.h>
28 :
29 : /*
30 : * IO end handler for temporary buffer_heads handling writes to the journal.
31 : */
32 4119084 : static void journal_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
33 : {
34 4119084 : struct buffer_head *orig_bh = bh->b_private;
35 :
36 4119084 : BUFFER_TRACE(bh, "");
37 4119084 : if (uptodate)
38 4119084 : set_buffer_uptodate(bh);
39 : else
40 0 : clear_buffer_uptodate(bh);
41 4119084 : if (orig_bh) {
42 3703898 : clear_bit_unlock(BH_Shadow, &orig_bh->b_state);
43 3703898 : smp_mb__after_atomic();
44 3703898 : wake_up_bit(&orig_bh->b_state, BH_Shadow);
45 : }
46 4119084 : unlock_buffer(bh);
47 4119084 : }
48 :
49 : /*
50 : * When an ext4 file is truncated, it is possible that some pages are not
51 : * successfully freed, because they are attached to a committing transaction.
52 : * After the transaction commits, these pages are left on the LRU, with no
53 : * ->mapping, and with attached buffers. These pages are trivially reclaimable
54 : * by the VM, but their apparent absence upsets the VM accounting, and it makes
55 : * the numbers in /proc/meminfo look odd.
56 : *
57 : * So here, we have a buffer which has just come off the forget list. Look to
58 : * see if we can strip all buffers from the backing page.
59 : *
60 : * Called under lock_journal(), and possibly under journal_datalist_lock. The
61 : * caller provided us with a ref against the buffer, and we drop that here.
62 : */
63 123594 : static void release_buffer_page(struct buffer_head *bh)
64 : {
65 123594 : struct folio *folio;
66 :
67 247188 : if (buffer_dirty(bh))
68 0 : goto nope;
69 123594 : if (atomic_read(&bh->b_count) != 1)
70 27640 : goto nope;
71 95954 : folio = bh->b_folio;
72 95954 : if (folio->mapping)
73 95954 : goto nope;
74 :
75 : /* OK, it's a truncated page */
76 0 : if (!folio_trylock(folio))
77 0 : goto nope;
78 :
79 0 : folio_get(folio);
80 0 : __brelse(bh);
81 0 : try_to_free_buffers(folio);
82 0 : folio_unlock(folio);
83 0 : folio_put(folio);
84 0 : return;
85 :
86 123594 : nope:
87 123594 : __brelse(bh);
88 : }
89 :
90 206978 : static void jbd2_commit_block_csum_set(journal_t *j, struct buffer_head *bh)
91 : {
92 206978 : struct commit_header *h;
93 206978 : __u32 csum;
94 :
95 206978 : if (!jbd2_journal_has_csum_v2or3(j))
96 : return;
97 :
98 206517 : h = (struct commit_header *)(bh->b_data);
99 206517 : h->h_chksum_type = 0;
100 206517 : h->h_chksum_size = 0;
101 206517 : h->h_chksum[0] = 0;
102 206517 : csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize);
103 206517 : h->h_chksum[0] = cpu_to_be32(csum);
104 : }
105 :
106 : /*
107 : * Done it all: now submit the commit record. We should have
108 : * cleaned up our previous buffers by now, so if we are in abort
109 : * mode we can now just skip the rest of the journal write
110 : * entirely.
111 : *
112 : * Returns 1 if the journal needs to be aborted or 0 on success
113 : */
114 206991 : static int journal_submit_commit_record(journal_t *journal,
115 : transaction_t *commit_transaction,
116 : struct buffer_head **cbh,
117 : __u32 crc32_sum)
118 : {
119 206991 : struct commit_header *tmp;
120 206991 : struct buffer_head *bh;
121 206991 : struct timespec64 now;
122 206991 : blk_opf_t write_flags = REQ_OP_WRITE | REQ_SYNC;
123 :
124 206991 : *cbh = NULL;
125 :
126 206991 : if (is_journal_aborted(journal))
127 : return 0;
128 :
129 206978 : bh = jbd2_journal_get_descriptor_buffer(commit_transaction,
130 : JBD2_COMMIT_BLOCK);
131 206978 : if (!bh)
132 : return 1;
133 :
134 206978 : tmp = (struct commit_header *)bh->b_data;
135 206978 : ktime_get_coarse_real_ts64(&now);
136 206978 : tmp->h_commit_sec = cpu_to_be64(now.tv_sec);
137 206978 : tmp->h_commit_nsec = cpu_to_be32(now.tv_nsec);
138 :
139 413956 : if (jbd2_has_feature_checksum(journal)) {
140 0 : tmp->h_chksum_type = JBD2_CRC32_CHKSUM;
141 0 : tmp->h_chksum_size = JBD2_CRC32_CHKSUM_SIZE;
142 0 : tmp->h_chksum[0] = cpu_to_be32(crc32_sum);
143 : }
144 206978 : jbd2_commit_block_csum_set(journal, bh);
145 :
146 206978 : BUFFER_TRACE(bh, "submit commit block");
147 206978 : lock_buffer(bh);
148 206978 : clear_buffer_dirty(bh);
149 206978 : set_buffer_uptodate(bh);
150 206978 : bh->b_end_io = journal_end_buffer_io_sync;
151 :
152 413956 : if (journal->j_flags & JBD2_BARRIER &&
153 : !jbd2_has_feature_async_commit(journal))
154 206978 : write_flags |= REQ_PREFLUSH | REQ_FUA;
155 :
156 206978 : submit_bh(write_flags, bh);
157 206978 : *cbh = bh;
158 206978 : return 0;
159 : }
160 :
161 : /*
162 : * This function along with journal_submit_commit_record
163 : * allows to write the commit record asynchronously.
164 : */
165 206978 : static int journal_wait_on_commit_record(journal_t *journal,
166 : struct buffer_head *bh)
167 : {
168 206978 : int ret = 0;
169 :
170 206978 : clear_buffer_dirty(bh);
171 206978 : wait_on_buffer(bh);
172 :
173 620934 : if (unlikely(!buffer_uptodate(bh)))
174 0 : ret = -EIO;
175 206978 : put_bh(bh); /* One for getblk() */
176 :
177 206978 : return ret;
178 : }
179 :
180 : /* Send all the data buffers related to an inode */
181 0 : int jbd2_submit_inode_data(journal_t *journal, struct jbd2_inode *jinode)
182 : {
183 0 : if (!jinode || !(jinode->i_flags & JI_WRITE_DATA))
184 : return 0;
185 :
186 0 : trace_jbd2_submit_inode_data(jinode->i_vfs_inode);
187 0 : return journal->j_submit_inode_data_buffers(jinode);
188 :
189 : }
190 : EXPORT_SYMBOL(jbd2_submit_inode_data);
191 :
192 0 : int jbd2_wait_inode_data(journal_t *journal, struct jbd2_inode *jinode)
193 : {
194 0 : if (!jinode || !(jinode->i_flags & JI_WAIT_DATA) ||
195 0 : !jinode->i_vfs_inode || !jinode->i_vfs_inode->i_mapping)
196 : return 0;
197 0 : return filemap_fdatawait_range_keep_errors(
198 : jinode->i_vfs_inode->i_mapping, jinode->i_dirty_start,
199 : jinode->i_dirty_end);
200 : }
201 : EXPORT_SYMBOL(jbd2_wait_inode_data);
202 :
203 : /*
204 : * Submit all the data buffers of inode associated with the transaction to
205 : * disk.
206 : *
207 : * We are in a committing transaction. Therefore no new inode can be added to
208 : * our inode list. We use JI_COMMIT_RUNNING flag to protect inode we currently
209 : * operate on from being released while we write out pages.
210 : */
211 206991 : static int journal_submit_data_buffers(journal_t *journal,
212 : transaction_t *commit_transaction)
213 : {
214 206991 : struct jbd2_inode *jinode;
215 206991 : int err, ret = 0;
216 :
217 206991 : spin_lock(&journal->j_list_lock);
218 376065 : list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
219 169074 : if (!(jinode->i_flags & JI_WRITE_DATA))
220 5 : continue;
221 169069 : jinode->i_flags |= JI_COMMIT_RUNNING;
222 169069 : spin_unlock(&journal->j_list_lock);
223 : /* submit the inode data buffers. */
224 169069 : trace_jbd2_submit_inode_data(jinode->i_vfs_inode);
225 169069 : if (journal->j_submit_inode_data_buffers) {
226 169069 : err = journal->j_submit_inode_data_buffers(jinode);
227 169069 : if (!ret)
228 169069 : ret = err;
229 : }
230 169069 : spin_lock(&journal->j_list_lock);
231 169069 : J_ASSERT(jinode->i_transaction == commit_transaction);
232 169069 : jinode->i_flags &= ~JI_COMMIT_RUNNING;
233 169069 : smp_mb();
234 169069 : wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
235 : }
236 206991 : spin_unlock(&journal->j_list_lock);
237 206991 : return ret;
238 : }
239 :
240 169072 : int jbd2_journal_finish_inode_data_buffers(struct jbd2_inode *jinode)
241 : {
242 169072 : struct address_space *mapping = jinode->i_vfs_inode->i_mapping;
243 :
244 169072 : return filemap_fdatawait_range_keep_errors(mapping,
245 : jinode->i_dirty_start,
246 : jinode->i_dirty_end);
247 : }
248 :
249 : /*
250 : * Wait for data submitted for writeout, refile inodes to proper
251 : * transaction if needed.
252 : *
253 : */
254 206991 : static int journal_finish_inode_data_buffers(journal_t *journal,
255 : transaction_t *commit_transaction)
256 : {
257 206991 : struct jbd2_inode *jinode, *next_i;
258 206991 : int err, ret = 0;
259 :
260 : /* For locking, see the comment in journal_submit_data_buffers() */
261 206991 : spin_lock(&journal->j_list_lock);
262 376063 : list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
263 169072 : if (!(jinode->i_flags & JI_WAIT_DATA))
264 0 : continue;
265 169072 : jinode->i_flags |= JI_COMMIT_RUNNING;
266 169072 : spin_unlock(&journal->j_list_lock);
267 : /* wait for the inode data buffers writeout. */
268 169072 : if (journal->j_finish_inode_data_buffers) {
269 169072 : err = journal->j_finish_inode_data_buffers(jinode);
270 169072 : if (!ret)
271 169072 : ret = err;
272 : }
273 169072 : spin_lock(&journal->j_list_lock);
274 169072 : jinode->i_flags &= ~JI_COMMIT_RUNNING;
275 169072 : smp_mb();
276 169072 : wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
277 : }
278 :
279 : /* Now refile inode to proper lists */
280 376063 : list_for_each_entry_safe(jinode, next_i,
281 : &commit_transaction->t_inode_list, i_list) {
282 169072 : list_del(&jinode->i_list);
283 169072 : if (jinode->i_next_transaction) {
284 64 : jinode->i_transaction = jinode->i_next_transaction;
285 64 : jinode->i_next_transaction = NULL;
286 64 : list_add(&jinode->i_list,
287 : &jinode->i_transaction->t_inode_list);
288 : } else {
289 169008 : jinode->i_transaction = NULL;
290 169008 : jinode->i_dirty_start = 0;
291 169008 : jinode->i_dirty_end = 0;
292 : }
293 : }
294 206991 : spin_unlock(&journal->j_list_lock);
295 :
296 206991 : return ret;
297 : }
298 :
299 0 : static __u32 jbd2_checksum_data(__u32 crc32_sum, struct buffer_head *bh)
300 : {
301 0 : struct page *page = bh->b_page;
302 0 : char *addr;
303 0 : __u32 checksum;
304 :
305 0 : addr = kmap_atomic(page);
306 0 : checksum = crc32_be(crc32_sum,
307 0 : (void *)(addr + offset_in_page(bh->b_data)), bh->b_size);
308 0 : kunmap_atomic(addr);
309 :
310 0 : return checksum;
311 : }
312 :
313 3703898 : static void write_tag_block(journal_t *j, journal_block_tag_t *tag,
314 : unsigned long long block)
315 : {
316 3703898 : tag->t_blocknr = cpu_to_be32(block & (u32)~0);
317 7407796 : if (jbd2_has_feature_64bit(j))
318 3702496 : tag->t_blocknr_high = cpu_to_be32((block >> 31) >> 1);
319 3703898 : }
320 :
321 3703898 : static void jbd2_block_tag_csum_set(journal_t *j, journal_block_tag_t *tag,
322 : struct buffer_head *bh, __u32 sequence)
323 : {
324 3703898 : journal_block_tag3_t *tag3 = (journal_block_tag3_t *)tag;
325 3703898 : struct page *page = bh->b_page;
326 3703898 : __u8 *addr;
327 3703898 : __u32 csum32;
328 3703898 : __be32 seq;
329 :
330 3703898 : if (!jbd2_journal_has_csum_v2or3(j))
331 10316 : return;
332 :
333 3693582 : seq = cpu_to_be32(sequence);
334 3693582 : addr = kmap_atomic(page);
335 3693582 : csum32 = jbd2_chksum(j, j->j_csum_seed, (__u8 *)&seq, sizeof(seq));
336 3693582 : csum32 = jbd2_chksum(j, csum32, addr + offset_in_page(bh->b_data),
337 3693582 : bh->b_size);
338 3693582 : kunmap_atomic(addr);
339 :
340 7387164 : if (jbd2_has_feature_csum3(j))
341 3693582 : tag3->t_checksum = cpu_to_be32(csum32);
342 : else
343 0 : tag->t_checksum = cpu_to_be16(csum32);
344 : }
345 : /*
346 : * jbd2_journal_commit_transaction
347 : *
348 : * The primary function for committing a transaction to the log. This
349 : * function is called by the journal thread to begin a complete commit.
350 : */
351 206990 : void jbd2_journal_commit_transaction(journal_t *journal)
352 : {
353 206990 : struct transaction_stats_s stats;
354 206990 : transaction_t *commit_transaction;
355 206990 : struct journal_head *jh;
356 206990 : struct buffer_head *descriptor;
357 206990 : struct buffer_head **wbuf = journal->j_wbuf;
358 206990 : int bufs;
359 206990 : int flags;
360 206990 : int err;
361 206990 : unsigned long long blocknr;
362 206990 : ktime_t start_time;
363 206990 : u64 commit_time;
364 206990 : char *tagp = NULL;
365 206990 : journal_block_tag_t *tag = NULL;
366 206990 : int space_left = 0;
367 206990 : int first_tag = 0;
368 206990 : int tag_flag;
369 206990 : int i;
370 206990 : int tag_bytes = journal_tag_bytes(journal);
371 206989 : struct buffer_head *cbh = NULL; /* For transactional checksums */
372 206989 : __u32 crc32_sum = ~0;
373 206989 : struct blk_plug plug;
374 : /* Tail of the journal */
375 206989 : unsigned long first_block;
376 206989 : tid_t first_tid;
377 206989 : int update_tail;
378 206989 : int csum_size = 0;
379 206989 : LIST_HEAD(io_bufs);
380 206989 : LIST_HEAD(log_bufs);
381 :
382 206989 : if (jbd2_journal_has_csum_v2or3(journal))
383 206529 : csum_size = sizeof(struct jbd2_journal_block_tail);
384 :
385 : /*
386 : * First job: lock down the current transaction and wait for
387 : * all outstanding updates to complete.
388 : */
389 :
390 : /* Do we need to erase the effects of a prior jbd2_journal_flush? */
391 206990 : if (journal->j_flags & JBD2_FLUSHED) {
392 1643 : jbd2_debug(3, "super block updated\n");
393 1643 : mutex_lock_io(&journal->j_checkpoint_mutex);
394 : /*
395 : * We hold j_checkpoint_mutex so tail cannot change under us.
396 : * We don't need any special data guarantees for writing sb
397 : * since journal is empty and it is ok for write to be
398 : * flushed only with transaction commit.
399 : */
400 1644 : jbd2_journal_update_sb_log_tail(journal,
401 : journal->j_tail_sequence,
402 : journal->j_tail,
403 : REQ_SYNC);
404 1644 : mutex_unlock(&journal->j_checkpoint_mutex);
405 : } else {
406 : jbd2_debug(3, "superblock not updated\n");
407 : }
408 :
409 206991 : J_ASSERT(journal->j_running_transaction != NULL);
410 206991 : J_ASSERT(journal->j_committing_transaction == NULL);
411 :
412 206991 : write_lock(&journal->j_state_lock);
413 206991 : journal->j_flags |= JBD2_FULL_COMMIT_ONGOING;
414 206991 : while (journal->j_flags & JBD2_FAST_COMMIT_ONGOING) {
415 0 : DEFINE_WAIT(wait);
416 :
417 0 : prepare_to_wait(&journal->j_fc_wait, &wait,
418 : TASK_UNINTERRUPTIBLE);
419 0 : write_unlock(&journal->j_state_lock);
420 0 : schedule();
421 0 : write_lock(&journal->j_state_lock);
422 0 : finish_wait(&journal->j_fc_wait, &wait);
423 : /*
424 : * TODO: by blocking fast commits here, we are increasing
425 : * fsync() latency slightly. Strictly speaking, we don't need
426 : * to block fast commits until the transaction enters T_FLUSH
427 : * state. So an optimization is possible where we block new fast
428 : * commits here and wait for existing ones to complete
429 : * just before we enter T_FLUSH. That way, the existing fast
430 : * commits and this full commit can proceed parallely.
431 : */
432 : }
433 206991 : write_unlock(&journal->j_state_lock);
434 :
435 206991 : commit_transaction = journal->j_running_transaction;
436 :
437 206991 : trace_jbd2_start_commit(journal, commit_transaction);
438 206991 : jbd2_debug(1, "JBD2: starting commit of transaction %d\n",
439 : commit_transaction->t_tid);
440 :
441 206991 : write_lock(&journal->j_state_lock);
442 206991 : journal->j_fc_off = 0;
443 206991 : J_ASSERT(commit_transaction->t_state == T_RUNNING);
444 206991 : commit_transaction->t_state = T_LOCKED;
445 :
446 206991 : trace_jbd2_commit_locking(journal, commit_transaction);
447 206991 : stats.run.rs_wait = commit_transaction->t_max_wait;
448 206991 : stats.run.rs_request_delay = 0;
449 206991 : stats.run.rs_locked = jiffies;
450 206991 : if (commit_transaction->t_requested)
451 413720 : stats.run.rs_request_delay =
452 : jbd2_time_diff(commit_transaction->t_requested,
453 : stats.run.rs_locked);
454 206991 : stats.run.rs_running = jbd2_time_diff(commit_transaction->t_start,
455 : stats.run.rs_locked);
456 :
457 : // waits for any t_updates to finish
458 206991 : jbd2_journal_wait_updates(journal);
459 :
460 206991 : commit_transaction->t_state = T_SWITCH;
461 :
462 206991 : J_ASSERT (atomic_read(&commit_transaction->t_outstanding_credits) <=
463 : journal->j_max_transaction_buffers);
464 :
465 : /*
466 : * First thing we are allowed to do is to discard any remaining
467 : * BJ_Reserved buffers. Note, it is _not_ permissible to assume
468 : * that there are no such buffers: if a large filesystem
469 : * operation like a truncate needs to split itself over multiple
470 : * transactions, then it may try to do a jbd2_journal_restart() while
471 : * there are still BJ_Reserved buffers outstanding. These must
472 : * be released cleanly from the current transaction.
473 : *
474 : * In this case, the filesystem must still reserve write access
475 : * again before modifying the buffer in the new transaction, but
476 : * we do not require it to remember exactly which old buffers it
477 : * has reserved. This is consistent with the existing behaviour
478 : * that multiple jbd2_journal_get_write_access() calls to the same
479 : * buffer are perfectly permissible.
480 : * We use journal->j_state_lock here to serialize processing of
481 : * t_reserved_list with eviction of buffers from journal_unmap_buffer().
482 : */
483 222391 : while (commit_transaction->t_reserved_list) {
484 15400 : jh = commit_transaction->t_reserved_list;
485 15400 : JBUFFER_TRACE(jh, "reserved, unused: refile");
486 : /*
487 : * A jbd2_journal_get_undo_access()+jbd2_journal_release_buffer() may
488 : * leave undo-committed data.
489 : */
490 15400 : if (jh->b_committed_data) {
491 0 : struct buffer_head *bh = jh2bh(jh);
492 :
493 0 : spin_lock(&jh->b_state_lock);
494 0 : jbd2_free(jh->b_committed_data, bh->b_size);
495 0 : jh->b_committed_data = NULL;
496 0 : spin_unlock(&jh->b_state_lock);
497 : }
498 15400 : jbd2_journal_refile_buffer(journal, jh);
499 : }
500 :
501 206991 : write_unlock(&journal->j_state_lock);
502 : /*
503 : * Now try to drop any written-back buffers from the journal's
504 : * checkpoint lists. We do this *before* commit because it potentially
505 : * frees some memory
506 : */
507 206991 : spin_lock(&journal->j_list_lock);
508 206991 : __jbd2_journal_clean_checkpoint_list(journal, false);
509 206991 : spin_unlock(&journal->j_list_lock);
510 :
511 206991 : jbd2_debug(3, "JBD2: commit phase 1\n");
512 :
513 : /*
514 : * Clear revoked flag to reflect there is no revoked buffers
515 : * in the next transaction which is going to be started.
516 : */
517 206991 : jbd2_clear_buffer_revoked_flags(journal);
518 :
519 : /*
520 : * Switch to a new revoke table.
521 : */
522 206991 : jbd2_journal_switch_revoke_table(journal);
523 :
524 206991 : write_lock(&journal->j_state_lock);
525 : /*
526 : * Reserved credits cannot be claimed anymore, free them
527 : */
528 206991 : atomic_sub(atomic_read(&journal->j_reserved_credits),
529 : &commit_transaction->t_outstanding_credits);
530 :
531 206991 : trace_jbd2_commit_flushing(journal, commit_transaction);
532 206991 : stats.run.rs_flushing = jiffies;
533 206991 : stats.run.rs_locked = jbd2_time_diff(stats.run.rs_locked,
534 : stats.run.rs_flushing);
535 :
536 206991 : commit_transaction->t_state = T_FLUSH;
537 206991 : journal->j_committing_transaction = commit_transaction;
538 206991 : journal->j_running_transaction = NULL;
539 206991 : start_time = ktime_get();
540 206991 : commit_transaction->t_log_start = journal->j_head;
541 206991 : wake_up_all(&journal->j_wait_transaction_locked);
542 206991 : write_unlock(&journal->j_state_lock);
543 :
544 206991 : jbd2_debug(3, "JBD2: commit phase 2a\n");
545 :
546 : /*
547 : * Now start flushing things to disk, in the order they appear
548 : * on the transaction lists. Data blocks go first.
549 : */
550 206991 : err = journal_submit_data_buffers(journal, commit_transaction);
551 206991 : if (err)
552 0 : jbd2_journal_abort(journal, err);
553 :
554 206991 : blk_start_plug(&plug);
555 206991 : jbd2_journal_write_revoke_records(commit_transaction, &log_bufs);
556 :
557 206991 : jbd2_debug(3, "JBD2: commit phase 2b\n");
558 :
559 : /*
560 : * Way to go: we have now written out all of the data for a
561 : * transaction! Now comes the tricky part: we need to write out
562 : * metadata. Loop over the transaction's entire buffer list:
563 : */
564 206991 : write_lock(&journal->j_state_lock);
565 206991 : commit_transaction->t_state = T_COMMIT;
566 206991 : write_unlock(&journal->j_state_lock);
567 :
568 206991 : trace_jbd2_commit_logging(journal, commit_transaction);
569 206991 : stats.run.rs_logging = jiffies;
570 206991 : stats.run.rs_flushing = jbd2_time_diff(stats.run.rs_flushing,
571 : stats.run.rs_logging);
572 206991 : stats.run.rs_blocks = commit_transaction->t_nr_buffers;
573 206991 : stats.run.rs_blocks_logged = 0;
574 :
575 206991 : J_ASSERT(commit_transaction->t_nr_buffers <=
576 : atomic_read(&commit_transaction->t_outstanding_credits));
577 :
578 : err = 0;
579 : bufs = 0;
580 : descriptor = NULL;
581 3910990 : while (commit_transaction->t_buffers) {
582 :
583 : /* Find the next buffer to be journaled... */
584 :
585 3703999 : jh = commit_transaction->t_buffers;
586 :
587 : /* If we're in abort mode, we just un-journal the buffer and
588 : release it. */
589 :
590 3703999 : if (is_journal_aborted(journal)) {
591 101 : clear_buffer_jbddirty(jh2bh(jh));
592 101 : JBUFFER_TRACE(jh, "journal is aborting: refile");
593 101 : jbd2_buffer_abort_trigger(jh,
594 101 : jh->b_frozen_data ?
595 : jh->b_frozen_triggers :
596 : jh->b_triggers);
597 101 : jbd2_journal_refile_buffer(journal, jh);
598 : /* If that was the last one, we need to clean up
599 : * any descriptor buffers which may have been
600 : * already allocated, even if we are now
601 : * aborting. */
602 101 : if (!commit_transaction->t_buffers)
603 12 : goto start_journal_io;
604 89 : continue;
605 : }
606 :
607 : /* Make sure we have a descriptor block in which to
608 : record the metadata buffer. */
609 :
610 3703898 : if (!descriptor) {
611 208208 : J_ASSERT (bufs == 0);
612 :
613 208208 : jbd2_debug(4, "JBD2: get descriptor\n");
614 :
615 208208 : descriptor = jbd2_journal_get_descriptor_buffer(
616 : commit_transaction,
617 : JBD2_DESCRIPTOR_BLOCK);
618 208208 : if (!descriptor) {
619 0 : jbd2_journal_abort(journal, -EIO);
620 0 : continue;
621 : }
622 :
623 208208 : jbd2_debug(4, "JBD2: got buffer %llu (%p)\n",
624 : (unsigned long long)descriptor->b_blocknr,
625 : descriptor->b_data);
626 208208 : tagp = &descriptor->b_data[sizeof(journal_header_t)];
627 208208 : space_left = descriptor->b_size -
628 : sizeof(journal_header_t);
629 208208 : first_tag = 1;
630 208208 : set_buffer_jwrite(descriptor);
631 208208 : set_buffer_dirty(descriptor);
632 208208 : wbuf[bufs++] = descriptor;
633 :
634 : /* Record it so that we can wait for IO
635 : completion later */
636 208208 : BUFFER_TRACE(descriptor, "ph3: file as descriptor");
637 208208 : jbd2_file_log_bh(&log_bufs, descriptor);
638 : }
639 :
640 : /* Where is the buffer to be written? */
641 :
642 3703898 : err = jbd2_journal_next_log_block(journal, &blocknr);
643 : /* If the block mapping failed, just abandon the buffer
644 : and repeat this loop: we'll fall into the
645 : refile-on-abort condition above. */
646 3703898 : if (err) {
647 0 : jbd2_journal_abort(journal, err);
648 0 : continue;
649 : }
650 :
651 : /*
652 : * start_this_handle() uses t_outstanding_credits to determine
653 : * the free space in the log.
654 : */
655 3703898 : atomic_dec(&commit_transaction->t_outstanding_credits);
656 :
657 : /* Bump b_count to prevent truncate from stumbling over
658 : the shadowed buffer! @@@ This can go if we ever get
659 : rid of the shadow pairing of buffers. */
660 3703898 : atomic_inc(&jh2bh(jh)->b_count);
661 :
662 : /*
663 : * Make a temporary IO buffer with which to write it out
664 : * (this will requeue the metadata buffer to BJ_Shadow).
665 : */
666 3703898 : set_bit(BH_JWrite, &jh2bh(jh)->b_state);
667 3703898 : JBUFFER_TRACE(jh, "ph3: write metadata");
668 3703898 : flags = jbd2_journal_write_metadata_buffer(commit_transaction,
669 3703898 : jh, &wbuf[bufs], blocknr);
670 3703898 : if (flags < 0) {
671 0 : jbd2_journal_abort(journal, flags);
672 0 : continue;
673 : }
674 3703898 : jbd2_file_log_bh(&io_bufs, wbuf[bufs]);
675 :
676 : /* Record the new block's tag in the current descriptor
677 : buffer */
678 :
679 3703898 : tag_flag = 0;
680 3703898 : if (flags & 1)
681 0 : tag_flag |= JBD2_FLAG_ESCAPE;
682 3703898 : if (!first_tag)
683 3495690 : tag_flag |= JBD2_FLAG_SAME_UUID;
684 :
685 3703898 : tag = (journal_block_tag_t *) tagp;
686 3703898 : write_tag_block(journal, tag, jh2bh(jh)->b_blocknr);
687 3703898 : tag->t_flags = cpu_to_be16(tag_flag);
688 3703898 : jbd2_block_tag_csum_set(journal, tag, wbuf[bufs],
689 : commit_transaction->t_tid);
690 3703898 : tagp += tag_bytes;
691 3703898 : space_left -= tag_bytes;
692 3703898 : bufs++;
693 :
694 3703898 : if (first_tag) {
695 416416 : memcpy (tagp, journal->j_uuid, 16);
696 208208 : tagp += 16;
697 208208 : space_left -= 16;
698 208208 : first_tag = 0;
699 : }
700 :
701 : /* If there's no more to do, or if the descriptor is full,
702 : let the IO rip! */
703 :
704 3703898 : if (bufs == journal->j_wbufsize ||
705 3703898 : commit_transaction->t_buffers == NULL ||
706 3499337 : space_left < tag_bytes + 16 + csum_size) {
707 :
708 208208 : jbd2_debug(4, "JBD2: Submit %d IOs\n", bufs);
709 :
710 : /* Write an end-of-descriptor marker before
711 : submitting the IOs. "tag" still points to
712 : the last tag we set up. */
713 :
714 208208 : tag->t_flags |= cpu_to_be16(JBD2_FLAG_LAST_TAG);
715 208220 : start_journal_io:
716 208220 : if (descriptor)
717 208208 : jbd2_descriptor_block_csum_set(journal,
718 : descriptor);
719 :
720 4120326 : for (i = 0; i < bufs; i++) {
721 3912106 : struct buffer_head *bh = wbuf[i];
722 : /*
723 : * Compute checksum.
724 : */
725 7824212 : if (jbd2_has_feature_checksum(journal)) {
726 0 : crc32_sum =
727 0 : jbd2_checksum_data(crc32_sum, bh);
728 : }
729 :
730 3912106 : lock_buffer(bh);
731 3912106 : clear_buffer_dirty(bh);
732 3912106 : set_buffer_uptodate(bh);
733 3912106 : bh->b_end_io = journal_end_buffer_io_sync;
734 3912106 : submit_bh(REQ_OP_WRITE | REQ_SYNC, bh);
735 : }
736 208220 : cond_resched();
737 :
738 : /* Force a new descriptor to be generated next
739 : time round the loop. */
740 208220 : descriptor = NULL;
741 208220 : bufs = 0;
742 : }
743 : }
744 :
745 206991 : err = journal_finish_inode_data_buffers(journal, commit_transaction);
746 206991 : if (err) {
747 0 : printk(KERN_WARNING
748 : "JBD2: Detected IO errors while flushing file data "
749 : "on %s\n", journal->j_devname);
750 0 : if (journal->j_flags & JBD2_ABORT_ON_SYNCDATA_ERR)
751 0 : jbd2_journal_abort(journal, err);
752 : err = 0;
753 : }
754 :
755 : /*
756 : * Get current oldest transaction in the log before we issue flush
757 : * to the filesystem device. After the flush we can be sure that
758 : * blocks of all older transactions are checkpointed to persistent
759 : * storage and we will be safe to update journal start in the
760 : * superblock with the numbers we get here.
761 : */
762 206991 : update_tail =
763 206991 : jbd2_journal_get_log_tail(journal, &first_tid, &first_block);
764 :
765 206991 : write_lock(&journal->j_state_lock);
766 206991 : if (update_tail) {
767 174330 : long freed = first_block - journal->j_tail;
768 :
769 174330 : if (first_block < journal->j_tail)
770 27692 : freed += journal->j_last - journal->j_first;
771 : /* Update tail only if we free significant amount of space */
772 174330 : if (freed < jbd2_journal_get_max_txn_bufs(journal))
773 174126 : update_tail = 0;
774 : }
775 206991 : J_ASSERT(commit_transaction->t_state == T_COMMIT);
776 206991 : commit_transaction->t_state = T_COMMIT_DFLUSH;
777 206991 : write_unlock(&journal->j_state_lock);
778 :
779 : /*
780 : * If the journal is not located on the file system device,
781 : * then we must flush the file system device before we issue
782 : * the commit record
783 : */
784 206991 : if (commit_transaction->t_need_data_flush &&
785 109674 : (journal->j_fs_dev != journal->j_dev) &&
786 0 : (journal->j_flags & JBD2_BARRIER))
787 0 : blkdev_issue_flush(journal->j_fs_dev);
788 :
789 : /* Done it all: now write the commit record asynchronously. */
790 413982 : if (jbd2_has_feature_async_commit(journal)) {
791 0 : err = journal_submit_commit_record(journal, commit_transaction,
792 : &cbh, crc32_sum);
793 0 : if (err)
794 0 : jbd2_journal_abort(journal, err);
795 : }
796 :
797 206991 : blk_finish_plug(&plug);
798 :
799 : /* Lo and behold: we have just managed to send a transaction to
800 : the log. Before we can commit it, wait for the IO so far to
801 : complete. Control buffers being written are on the
802 : transaction's t_log_list queue, and metadata buffers are on
803 : the io_bufs list.
804 :
805 : Wait for the buffers in reverse order. That way we are
806 : less likely to be woken up until all IOs have completed, and
807 : so we incur less scheduling load.
808 : */
809 :
810 206991 : jbd2_debug(3, "JBD2: commit phase 3\n");
811 :
812 3910889 : while (!list_empty(&io_bufs)) {
813 3703898 : struct buffer_head *bh = list_entry(io_bufs.prev,
814 : struct buffer_head,
815 : b_assoc_buffers);
816 :
817 3703898 : wait_on_buffer(bh);
818 3703898 : cond_resched();
819 :
820 7407796 : if (unlikely(!buffer_uptodate(bh)))
821 0 : err = -EIO;
822 3703898 : jbd2_unfile_log_bh(bh);
823 3703898 : stats.run.rs_blocks_logged++;
824 :
825 : /*
826 : * The list contains temporary buffer heads created by
827 : * jbd2_journal_write_metadata_buffer().
828 : */
829 3703898 : BUFFER_TRACE(bh, "dumping temporary bh");
830 3703898 : __brelse(bh);
831 3703898 : J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
832 3703898 : free_buffer_head(bh);
833 :
834 : /* We also have to refile the corresponding shadowed buffer */
835 3703898 : jh = commit_transaction->t_shadow_list->b_tprev;
836 3703898 : bh = jh2bh(jh);
837 3703898 : clear_buffer_jwrite(bh);
838 7407796 : J_ASSERT_BH(bh, buffer_jbddirty(bh));
839 7407796 : J_ASSERT_BH(bh, !buffer_shadow(bh));
840 :
841 : /* The metadata is now released for reuse, but we need
842 : to remember it against this transaction so that when
843 : we finally commit, we can do any checkpointing
844 : required. */
845 3703898 : JBUFFER_TRACE(jh, "file as BJ_Forget");
846 3703898 : jbd2_journal_file_buffer(jh, commit_transaction, BJ_Forget);
847 3703898 : JBUFFER_TRACE(jh, "brelse shadowed buffer");
848 3703898 : __brelse(bh);
849 : }
850 :
851 206991 : J_ASSERT (commit_transaction->t_shadow_list == NULL);
852 :
853 : jbd2_debug(3, "JBD2: commit phase 4\n");
854 :
855 : /* Here we wait for the revoke record and descriptor record buffers */
856 454961 : while (!list_empty(&log_bufs)) {
857 247970 : struct buffer_head *bh;
858 :
859 247970 : bh = list_entry(log_bufs.prev, struct buffer_head, b_assoc_buffers);
860 247970 : wait_on_buffer(bh);
861 247970 : cond_resched();
862 :
863 495940 : if (unlikely(!buffer_uptodate(bh)))
864 0 : err = -EIO;
865 :
866 247970 : BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");
867 247970 : clear_buffer_jwrite(bh);
868 247970 : jbd2_unfile_log_bh(bh);
869 247970 : stats.run.rs_blocks_logged++;
870 247970 : __brelse(bh); /* One for getblk */
871 : /* AKPM: bforget here */
872 : }
873 :
874 206991 : if (err)
875 0 : jbd2_journal_abort(journal, err);
876 :
877 206991 : jbd2_debug(3, "JBD2: commit phase 5\n");
878 206991 : write_lock(&journal->j_state_lock);
879 206991 : J_ASSERT(commit_transaction->t_state == T_COMMIT_DFLUSH);
880 206991 : commit_transaction->t_state = T_COMMIT_JFLUSH;
881 206991 : write_unlock(&journal->j_state_lock);
882 :
883 413982 : if (!jbd2_has_feature_async_commit(journal)) {
884 206991 : err = journal_submit_commit_record(journal, commit_transaction,
885 : &cbh, crc32_sum);
886 206991 : if (err)
887 0 : jbd2_journal_abort(journal, err);
888 : }
889 206991 : if (cbh)
890 206978 : err = journal_wait_on_commit_record(journal, cbh);
891 206991 : stats.run.rs_blocks_logged++;
892 413982 : if (jbd2_has_feature_async_commit(journal) &&
893 0 : journal->j_flags & JBD2_BARRIER) {
894 0 : blkdev_issue_flush(journal->j_dev);
895 : }
896 :
897 206991 : if (err)
898 0 : jbd2_journal_abort(journal, err);
899 :
900 206991 : WARN_ON_ONCE(
901 : atomic_read(&commit_transaction->t_outstanding_credits) < 0);
902 :
903 : /*
904 : * Now disk caches for filesystem device are flushed so we are safe to
905 : * erase checkpointed transactions from the log by updating journal
906 : * superblock.
907 : */
908 206991 : if (update_tail)
909 204 : jbd2_update_log_tail(journal, first_tid, first_block);
910 :
911 : /* End of a transaction! Finally, we can do checkpoint
912 : processing: any buffers committed as a result of this
913 : transaction can be removed from any checkpoint list it was on
914 : before. */
915 :
916 206991 : jbd2_debug(3, "JBD2: commit phase 6\n");
917 :
918 206991 : J_ASSERT(list_empty(&commit_transaction->t_inode_list));
919 206991 : J_ASSERT(commit_transaction->t_buffers == NULL);
920 206991 : J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
921 206991 : J_ASSERT(commit_transaction->t_shadow_list == NULL);
922 :
923 206991 : restart_loop:
924 : /*
925 : * As there are other places (journal_unmap_buffer()) adding buffers
926 : * to this list we have to be careful and hold the j_list_lock.
927 : */
928 206991 : spin_lock(&journal->j_list_lock);
929 4034483 : while (commit_transaction->t_forget) {
930 3827492 : transaction_t *cp_transaction;
931 3827492 : struct buffer_head *bh;
932 3827492 : int try_to_free = 0;
933 3827492 : bool drop_ref;
934 :
935 3827492 : jh = commit_transaction->t_forget;
936 3827492 : spin_unlock(&journal->j_list_lock);
937 3827492 : bh = jh2bh(jh);
938 : /*
939 : * Get a reference so that bh cannot be freed before we are
940 : * done with it.
941 : */
942 3827492 : get_bh(bh);
943 3827492 : spin_lock(&jh->b_state_lock);
944 3827492 : J_ASSERT_JH(jh, jh->b_transaction == commit_transaction);
945 :
946 : /*
947 : * If there is undo-protected committed data against
948 : * this buffer, then we can remove it now. If it is a
949 : * buffer needing such protection, the old frozen_data
950 : * field now points to a committed version of the
951 : * buffer, so rotate that field to the new committed
952 : * data.
953 : *
954 : * Otherwise, we can just throw away the frozen data now.
955 : *
956 : * We also know that the frozen data has already fired
957 : * its triggers if they exist, so we can clear that too.
958 : */
959 3827492 : if (jh->b_committed_data) {
960 0 : jbd2_free(jh->b_committed_data, bh->b_size);
961 0 : jh->b_committed_data = NULL;
962 0 : if (jh->b_frozen_data) {
963 0 : jh->b_committed_data = jh->b_frozen_data;
964 0 : jh->b_frozen_data = NULL;
965 0 : jh->b_frozen_triggers = NULL;
966 : }
967 3827492 : } else if (jh->b_frozen_data) {
968 30308 : jbd2_free(jh->b_frozen_data, bh->b_size);
969 30308 : jh->b_frozen_data = NULL;
970 30308 : jh->b_frozen_triggers = NULL;
971 : }
972 :
973 3827492 : spin_lock(&journal->j_list_lock);
974 3827492 : cp_transaction = jh->b_cp_transaction;
975 3827492 : if (cp_transaction) {
976 1325241 : JBUFFER_TRACE(jh, "remove from old cp transaction");
977 1325241 : cp_transaction->t_chp_stats.cs_dropped++;
978 1325241 : __jbd2_journal_remove_checkpoint(jh);
979 : }
980 :
981 : /* Only re-checkpoint the buffer_head if it is marked
982 : * dirty. If the buffer was added to the BJ_Forget list
983 : * by jbd2_journal_forget, it may no longer be dirty and
984 : * there's no point in keeping a checkpoint record for
985 : * it. */
986 :
987 : /*
988 : * A buffer which has been freed while still being journaled
989 : * by a previous transaction, refile the buffer to BJ_Forget of
990 : * the running transaction. If the just committed transaction
991 : * contains "add to orphan" operation, we can completely
992 : * invalidate the buffer now. We are rather through in that
993 : * since the buffer may be still accessible when blocksize <
994 : * pagesize and it is attached to the last partial page.
995 : */
996 7654984 : if (buffer_freed(bh) && !jh->b_next_transaction) {
997 1819 : struct address_space *mapping;
998 :
999 1819 : clear_buffer_freed(bh);
1000 1819 : clear_buffer_jbddirty(bh);
1001 :
1002 : /*
1003 : * Block device buffers need to stay mapped all the
1004 : * time, so it is enough to clear buffer_jbddirty and
1005 : * buffer_freed bits. For the file mapping buffers (i.e.
1006 : * journalled data) we need to unmap buffer and clear
1007 : * more bits. We also need to be careful about the check
1008 : * because the data page mapping can get cleared under
1009 : * our hands. Note that if mapping == NULL, we don't
1010 : * need to make buffer unmapped because the page is
1011 : * already detached from the mapping and buffers cannot
1012 : * get reused.
1013 : */
1014 1819 : mapping = READ_ONCE(bh->b_folio->mapping);
1015 1819 : if (mapping && !sb_is_blkdev_sb(mapping->host->i_sb)) {
1016 0 : clear_buffer_mapped(bh);
1017 0 : clear_buffer_new(bh);
1018 0 : clear_buffer_req(bh);
1019 0 : bh->b_bdev = NULL;
1020 : }
1021 : }
1022 :
1023 7654984 : if (buffer_jbddirty(bh)) {
1024 3703898 : JBUFFER_TRACE(jh, "add to new checkpointing trans");
1025 3703898 : __jbd2_journal_insert_checkpoint(jh, commit_transaction);
1026 3703898 : if (is_journal_aborted(journal))
1027 61 : clear_buffer_jbddirty(bh);
1028 : } else {
1029 247188 : J_ASSERT_BH(bh, !buffer_dirty(bh));
1030 : /*
1031 : * The buffer on BJ_Forget list and not jbddirty means
1032 : * it has been freed by this transaction and hence it
1033 : * could not have been reallocated until this
1034 : * transaction has committed. *BUT* it could be
1035 : * reallocated once we have written all the data to
1036 : * disk and before we process the buffer on BJ_Forget
1037 : * list.
1038 : */
1039 123594 : if (!jh->b_next_transaction)
1040 123594 : try_to_free = 1;
1041 : }
1042 3827492 : JBUFFER_TRACE(jh, "refile or unfile buffer");
1043 3827492 : drop_ref = __jbd2_journal_refile_buffer(jh);
1044 3827492 : spin_unlock(&jh->b_state_lock);
1045 3827492 : if (drop_ref)
1046 3495773 : jbd2_journal_put_journal_head(jh);
1047 3827492 : if (try_to_free)
1048 123594 : release_buffer_page(bh); /* Drops bh reference */
1049 : else
1050 3703898 : __brelse(bh);
1051 3827492 : cond_resched_lock(&journal->j_list_lock);
1052 : }
1053 206991 : spin_unlock(&journal->j_list_lock);
1054 : /*
1055 : * This is a bit sleazy. We use j_list_lock to protect transition
1056 : * of a transaction into T_FINISHED state and calling
1057 : * __jbd2_journal_drop_transaction(). Otherwise we could race with
1058 : * other checkpointing code processing the transaction...
1059 : */
1060 206991 : write_lock(&journal->j_state_lock);
1061 206991 : spin_lock(&journal->j_list_lock);
1062 : /*
1063 : * Now recheck if some buffers did not get attached to the transaction
1064 : * while the lock was dropped...
1065 : */
1066 206991 : if (commit_transaction->t_forget) {
1067 0 : spin_unlock(&journal->j_list_lock);
1068 0 : write_unlock(&journal->j_state_lock);
1069 0 : goto restart_loop;
1070 : }
1071 :
1072 : /* Add the transaction to the checkpoint list
1073 : * __journal_remove_checkpoint() can not destroy transaction
1074 : * under us because it is not marked as T_FINISHED yet */
1075 206991 : if (journal->j_checkpoint_transactions == NULL) {
1076 61285 : journal->j_checkpoint_transactions = commit_transaction;
1077 61285 : commit_transaction->t_cpnext = commit_transaction;
1078 61285 : commit_transaction->t_cpprev = commit_transaction;
1079 : } else {
1080 145706 : commit_transaction->t_cpnext =
1081 : journal->j_checkpoint_transactions;
1082 145706 : commit_transaction->t_cpprev =
1083 145706 : commit_transaction->t_cpnext->t_cpprev;
1084 145706 : commit_transaction->t_cpnext->t_cpprev =
1085 : commit_transaction;
1086 145706 : commit_transaction->t_cpprev->t_cpnext =
1087 : commit_transaction;
1088 : }
1089 206991 : spin_unlock(&journal->j_list_lock);
1090 :
1091 : /* Done with this transaction! */
1092 :
1093 206991 : jbd2_debug(3, "JBD2: commit phase 7\n");
1094 :
1095 206991 : J_ASSERT(commit_transaction->t_state == T_COMMIT_JFLUSH);
1096 :
1097 206991 : commit_transaction->t_start = jiffies;
1098 206991 : stats.run.rs_logging = jbd2_time_diff(stats.run.rs_logging,
1099 : commit_transaction->t_start);
1100 :
1101 : /*
1102 : * File the transaction statistics
1103 : */
1104 206991 : stats.ts_tid = commit_transaction->t_tid;
1105 206991 : stats.run.rs_handle_count =
1106 206991 : atomic_read(&commit_transaction->t_handle_count);
1107 206991 : trace_jbd2_run_stats(journal->j_fs_dev->bd_dev,
1108 : commit_transaction->t_tid, &stats.run);
1109 206991 : stats.ts_requested = (commit_transaction->t_requested) ? 1 : 0;
1110 :
1111 206991 : commit_transaction->t_state = T_COMMIT_CALLBACK;
1112 206991 : J_ASSERT(commit_transaction == journal->j_committing_transaction);
1113 206991 : journal->j_commit_sequence = commit_transaction->t_tid;
1114 206991 : journal->j_committing_transaction = NULL;
1115 206991 : commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time));
1116 :
1117 : /*
1118 : * weight the commit time higher than the average time so we don't
1119 : * react too strongly to vast changes in the commit time
1120 : */
1121 206991 : if (likely(journal->j_average_commit_time))
1122 205436 : journal->j_average_commit_time = (commit_time +
1123 205436 : journal->j_average_commit_time*3) / 4;
1124 : else
1125 1555 : journal->j_average_commit_time = commit_time;
1126 :
1127 206991 : write_unlock(&journal->j_state_lock);
1128 :
1129 206991 : if (journal->j_commit_callback)
1130 206991 : journal->j_commit_callback(journal, commit_transaction);
1131 206991 : if (journal->j_fc_cleanup_callback)
1132 0 : journal->j_fc_cleanup_callback(journal, 1, commit_transaction->t_tid);
1133 :
1134 206991 : trace_jbd2_end_commit(journal, commit_transaction);
1135 206991 : jbd2_debug(1, "JBD2: commit %d complete, head %d\n",
1136 : journal->j_commit_sequence, journal->j_tail_sequence);
1137 :
1138 206991 : write_lock(&journal->j_state_lock);
1139 206991 : journal->j_flags &= ~JBD2_FULL_COMMIT_ONGOING;
1140 206991 : journal->j_flags &= ~JBD2_FAST_COMMIT_ONGOING;
1141 206991 : spin_lock(&journal->j_list_lock);
1142 206991 : commit_transaction->t_state = T_FINISHED;
1143 : /* Check if the transaction can be dropped now that we are finished */
1144 206991 : if (commit_transaction->t_checkpoint_list == NULL) {
1145 2430 : __jbd2_journal_drop_transaction(journal, commit_transaction);
1146 2430 : jbd2_journal_free_transaction(commit_transaction);
1147 : }
1148 206991 : spin_unlock(&journal->j_list_lock);
1149 206991 : write_unlock(&journal->j_state_lock);
1150 206991 : wake_up(&journal->j_wait_done_commit);
1151 206991 : wake_up(&journal->j_fc_wait);
1152 :
1153 : /*
1154 : * Calculate overall stats
1155 : */
1156 206991 : spin_lock(&journal->j_history_lock);
1157 206991 : journal->j_stats.ts_tid++;
1158 206991 : journal->j_stats.ts_requested += stats.ts_requested;
1159 206991 : journal->j_stats.run.rs_wait += stats.run.rs_wait;
1160 206991 : journal->j_stats.run.rs_request_delay += stats.run.rs_request_delay;
1161 206991 : journal->j_stats.run.rs_running += stats.run.rs_running;
1162 206991 : journal->j_stats.run.rs_locked += stats.run.rs_locked;
1163 206991 : journal->j_stats.run.rs_flushing += stats.run.rs_flushing;
1164 206991 : journal->j_stats.run.rs_logging += stats.run.rs_logging;
1165 206991 : journal->j_stats.run.rs_handle_count += stats.run.rs_handle_count;
1166 206991 : journal->j_stats.run.rs_blocks += stats.run.rs_blocks;
1167 206991 : journal->j_stats.run.rs_blocks_logged += stats.run.rs_blocks_logged;
1168 206991 : spin_unlock(&journal->j_history_lock);
1169 206991 : }
|
