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