commit.c 33.6 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0+
2
/*
3
 * linux/fs/jbd2/commit.c
4 5 6 7 8 9 10 11 12 13 14
 *
 * Written by Stephen C. Tweedie <sct@redhat.com>, 1998
 *
 * Copyright 1998 Red Hat corp --- All Rights Reserved
 *
 * Journal commit routines for the generic filesystem journaling code;
 * part of the ext2fs journaling system.
 */

#include <linux/time.h>
#include <linux/fs.h>
15
#include <linux/jbd2.h>
16 17 18 19
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/pagemap.h>
20
#include <linux/jiffies.h>
21
#include <linux/crc32.h>
22 23
#include <linux/writeback.h>
#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 33
 */
static void journal_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
{
34 35
	struct buffer_head *orig_bh = bh->b_private;

36 37 38 39 40
	BUFFER_TRACE(bh, "");
	if (uptodate)
		set_buffer_uptodate(bh);
	else
		clear_buffer_uptodate(bh);
41 42
	if (orig_bh) {
		clear_bit_unlock(BH_Shadow, &orig_bh->b_state);
43
		smp_mb__after_atomic();
44 45
		wake_up_bit(&orig_bh->b_state, BH_Shadow);
	}
46 47 48 49
	unlock_buffer(bh);
}

/*
50 51
 * When an ext4 file is truncated, it is possible that some pages are not
 * successfully freed, because they are attached to a committing transaction.
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
 * After the transaction commits, these pages are left on the LRU, with no
 * ->mapping, and with attached buffers.  These pages are trivially reclaimable
 * by the VM, but their apparent absence upsets the VM accounting, and it makes
 * the numbers in /proc/meminfo look odd.
 *
 * So here, we have a buffer which has just come off the forget list.  Look to
 * see if we can strip all buffers from the backing page.
 *
 * Called under lock_journal(), and possibly under journal_datalist_lock.  The
 * caller provided us with a ref against the buffer, and we drop that here.
 */
static void release_buffer_page(struct buffer_head *bh)
{
	struct page *page;

	if (buffer_dirty(bh))
		goto nope;
	if (atomic_read(&bh->b_count) != 1)
		goto nope;
	page = bh->b_page;
	if (!page)
		goto nope;
	if (page->mapping)
		goto nope;

	/* OK, it's a truncated page */
N
Nick Piggin 已提交
78
	if (!trylock_page(page))
79 80
		goto nope;

81
	get_page(page);
82 83 84
	__brelse(bh);
	try_to_free_buffers(page);
	unlock_page(page);
85
	put_page(page);
86 87 88 89 90 91
	return;

nope:
	__brelse(bh);
}

92
static void jbd2_commit_block_csum_set(journal_t *j, struct buffer_head *bh)
D
Darrick J. Wong 已提交
93 94 95 96
{
	struct commit_header *h;
	__u32 csum;

97
	if (!jbd2_journal_has_csum_v2or3(j))
D
Darrick J. Wong 已提交
98 99
		return;

100
	h = (struct commit_header *)(bh->b_data);
D
Darrick J. Wong 已提交
101 102 103
	h->h_chksum_type = 0;
	h->h_chksum_size = 0;
	h->h_chksum[0] = 0;
104
	csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize);
D
Darrick J. Wong 已提交
105 106 107
	h->h_chksum[0] = cpu_to_be32(csum);
}

108 109
/*
 * Done it all: now submit the commit record.  We should have
110 111 112 113 114 115
 * cleaned up our previous buffers by now, so if we are in abort
 * mode we can now just skip the rest of the journal write
 * entirely.
 *
 * Returns 1 if the journal needs to be aborted or 0 on success
 */
116 117 118 119
static int journal_submit_commit_record(journal_t *journal,
					transaction_t *commit_transaction,
					struct buffer_head **cbh,
					__u32 crc32_sum)
120
{
121
	struct commit_header *tmp;
122
	struct buffer_head *bh;
123
	int ret;
124
	struct timespec64 now;
125

126 127
	*cbh = NULL;

128 129 130
	if (is_journal_aborted(journal))
		return 0;

131 132
	bh = jbd2_journal_get_descriptor_buffer(commit_transaction,
						JBD2_COMMIT_BLOCK);
133
	if (!bh)
134 135
		return 1;

136
	tmp = (struct commit_header *)bh->b_data;
137
	ktime_get_coarse_real_ts64(&now);
138 139
	tmp->h_commit_sec = cpu_to_be64(now.tv_sec);
	tmp->h_commit_nsec = cpu_to_be32(now.tv_nsec);
140

141
	if (jbd2_has_feature_checksum(journal)) {
142 143 144
		tmp->h_chksum_type 	= JBD2_CRC32_CHKSUM;
		tmp->h_chksum_size 	= JBD2_CRC32_CHKSUM_SIZE;
		tmp->h_chksum[0] 	= cpu_to_be32(crc32_sum);
145
	}
146
	jbd2_commit_block_csum_set(journal, bh);
147

148
	BUFFER_TRACE(bh, "submit commit block");
149
	lock_buffer(bh);
150
	clear_buffer_dirty(bh);
151 152 153 154
	set_buffer_uptodate(bh);
	bh->b_end_io = journal_end_buffer_io_sync;

	if (journal->j_flags & JBD2_BARRIER &&
155
	    !jbd2_has_feature_async_commit(journal))
156 157
		ret = submit_bh(REQ_OP_WRITE,
			REQ_SYNC | REQ_PREFLUSH | REQ_FUA, bh);
158
	else
159
		ret = submit_bh(REQ_OP_WRITE, REQ_SYNC, bh);
160

161 162 163 164 165 166 167 168
	*cbh = bh;
	return ret;
}

/*
 * This function along with journal_submit_commit_record
 * allows to write the commit record asynchronously.
 */
169 170
static int journal_wait_on_commit_record(journal_t *journal,
					 struct buffer_head *bh)
171 172 173 174 175
{
	int ret = 0;

	clear_buffer_dirty(bh);
	wait_on_buffer(bh);
176

177 178 179 180 181
	if (unlikely(!buffer_uptodate(bh)))
		ret = -EIO;
	put_bh(bh);            /* One for getblk() */

	return ret;
182 183
}

184 185 186 187 188 189
/*
 * write the filemap data using writepage() address_space_operations.
 * We don't do block allocation here even for delalloc. We don't
 * use writepages() because with dealyed allocation we may be doing
 * block allocation in writepages().
 */
190 191
static int journal_submit_inode_data_buffers(struct address_space *mapping,
		loff_t dirty_start, loff_t dirty_end)
192 193 194 195 196
{
	int ret;
	struct writeback_control wbc = {
		.sync_mode =  WB_SYNC_ALL,
		.nr_to_write = mapping->nrpages * 2,
197 198
		.range_start = dirty_start,
		.range_end = dirty_end,
199 200 201 202 203 204
	};

	ret = generic_writepages(mapping, &wbc);
	return ret;
}

205 206 207 208 209 210 211 212
/*
 * Submit all the data buffers of inode associated with the transaction to
 * disk.
 *
 * We are in a committing transaction. Therefore no new inode can be added to
 * our inode list. We use JI_COMMIT_RUNNING flag to protect inode we currently
 * operate on from being released while we write out pages.
 */
213
static int journal_submit_data_buffers(journal_t *journal,
214 215 216 217 218 219 220 221
		transaction_t *commit_transaction)
{
	struct jbd2_inode *jinode;
	int err, ret = 0;
	struct address_space *mapping;

	spin_lock(&journal->j_list_lock);
	list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
222 223 224
		loff_t dirty_start = jinode->i_dirty_start;
		loff_t dirty_end = jinode->i_dirty_end;

225 226
		if (!(jinode->i_flags & JI_WRITE_DATA))
			continue;
227
		mapping = jinode->i_vfs_inode->i_mapping;
228
		jinode->i_flags |= JI_COMMIT_RUNNING;
229
		spin_unlock(&journal->j_list_lock);
230 231 232 233 234 235
		/*
		 * submit the inode data buffers. We use writepage
		 * instead of writepages. Because writepages can do
		 * block allocation  with delalloc. We need to write
		 * only allocated blocks here.
		 */
236
		trace_jbd2_submit_inode_data(jinode->i_vfs_inode);
237 238
		err = journal_submit_inode_data_buffers(mapping, dirty_start,
				dirty_end);
239 240 241 242
		if (!ret)
			ret = err;
		spin_lock(&journal->j_list_lock);
		J_ASSERT(jinode->i_transaction == commit_transaction);
243 244
		jinode->i_flags &= ~JI_COMMIT_RUNNING;
		smp_mb();
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
		wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
	}
	spin_unlock(&journal->j_list_lock);
	return ret;
}

/*
 * Wait for data submitted for writeout, refile inodes to proper
 * transaction if needed.
 *
 */
static int journal_finish_inode_data_buffers(journal_t *journal,
		transaction_t *commit_transaction)
{
	struct jbd2_inode *jinode, *next_i;
	int err, ret = 0;

262
	/* For locking, see the comment in journal_submit_data_buffers() */
263 264
	spin_lock(&journal->j_list_lock);
	list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
265 266 267
		loff_t dirty_start = jinode->i_dirty_start;
		loff_t dirty_end = jinode->i_dirty_end;

268 269
		if (!(jinode->i_flags & JI_WAIT_DATA))
			continue;
270
		jinode->i_flags |= JI_COMMIT_RUNNING;
271
		spin_unlock(&journal->j_list_lock);
272 273 274
		err = filemap_fdatawait_range_keep_errors(
				jinode->i_vfs_inode->i_mapping, dirty_start,
				dirty_end);
275 276
		if (!ret)
			ret = err;
277
		spin_lock(&journal->j_list_lock);
278 279
		jinode->i_flags &= ~JI_COMMIT_RUNNING;
		smp_mb();
280 281 282 283 284 285 286 287 288 289 290 291 292 293
		wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
	}

	/* Now refile inode to proper lists */
	list_for_each_entry_safe(jinode, next_i,
				 &commit_transaction->t_inode_list, i_list) {
		list_del(&jinode->i_list);
		if (jinode->i_next_transaction) {
			jinode->i_transaction = jinode->i_next_transaction;
			jinode->i_next_transaction = NULL;
			list_add(&jinode->i_list,
				&jinode->i_transaction->t_inode_list);
		} else {
			jinode->i_transaction = NULL;
294 295
			jinode->i_dirty_start = 0;
			jinode->i_dirty_end = 0;
296 297 298 299 300 301 302
		}
	}
	spin_unlock(&journal->j_list_lock);

	return ret;
}

303 304 305 306 307 308
static __u32 jbd2_checksum_data(__u32 crc32_sum, struct buffer_head *bh)
{
	struct page *page = bh->b_page;
	char *addr;
	__u32 checksum;

309
	addr = kmap_atomic(page);
310 311
	checksum = crc32_be(crc32_sum,
		(void *)(addr + offset_in_page(bh->b_data)), bh->b_size);
312
	kunmap_atomic(addr);
313 314 315 316

	return checksum;
}

317
static void write_tag_block(journal_t *j, journal_block_tag_t *tag,
318
				   unsigned long long block)
Z
Zach Brown 已提交
319 320
{
	tag->t_blocknr = cpu_to_be32(block & (u32)~0);
321
	if (jbd2_has_feature_64bit(j))
Z
Zach Brown 已提交
322 323 324
		tag->t_blocknr_high = cpu_to_be32((block >> 31) >> 1);
}

325 326 327
static void jbd2_block_tag_csum_set(journal_t *j, journal_block_tag_t *tag,
				    struct buffer_head *bh, __u32 sequence)
{
328
	journal_block_tag3_t *tag3 = (journal_block_tag3_t *)tag;
329 330
	struct page *page = bh->b_page;
	__u8 *addr;
331
	__u32 csum32;
332
	__be32 seq;
333

334
	if (!jbd2_journal_has_csum_v2or3(j))
335 336
		return;

337
	seq = cpu_to_be32(sequence);
338
	addr = kmap_atomic(page);
339
	csum32 = jbd2_chksum(j, j->j_csum_seed, (__u8 *)&seq, sizeof(seq));
340 341
	csum32 = jbd2_chksum(j, csum32, addr + offset_in_page(bh->b_data),
			     bh->b_size);
342
	kunmap_atomic(addr);
343

344
	if (jbd2_has_feature_csum3(j))
345 346 347
		tag3->t_checksum = cpu_to_be32(csum32);
	else
		tag->t_checksum = cpu_to_be16(csum32);
348
}
349
/*
350
 * jbd2_journal_commit_transaction
351 352 353 354
 *
 * The primary function for committing a transaction to the log.  This
 * function is called by the journal thread to begin a complete commit.
 */
355
void jbd2_journal_commit_transaction(journal_t *journal)
356
{
357
	struct transaction_stats_s stats;
358
	transaction_t *commit_transaction;
359 360
	struct journal_head *jh;
	struct buffer_head *descriptor;
361 362 363 364
	struct buffer_head **wbuf = journal->j_wbuf;
	int bufs;
	int flags;
	int err;
365
	unsigned long long blocknr;
J
Josef Bacik 已提交
366 367
	ktime_t start_time;
	u64 commit_time;
368 369 370 371 372
	char *tagp = NULL;
	journal_block_tag_t *tag = NULL;
	int space_left = 0;
	int first_tag = 0;
	int tag_flag;
373
	int i;
Z
Zach Brown 已提交
374
	int tag_bytes = journal_tag_bytes(journal);
375 376
	struct buffer_head *cbh = NULL; /* For transactional checksums */
	__u32 crc32_sum = ~0;
377
	struct blk_plug plug;
378 379 380 381
	/* Tail of the journal */
	unsigned long first_block;
	tid_t first_tid;
	int update_tail;
382
	int csum_size = 0;
383
	LIST_HEAD(io_bufs);
384
	LIST_HEAD(log_bufs);
385

386
	if (jbd2_journal_has_csum_v2or3(journal))
387
		csum_size = sizeof(struct jbd2_journal_block_tail);
388 389 390 391 392 393

	/*
	 * First job: lock down the current transaction and wait for
	 * all outstanding updates to complete.
	 */

394 395
	/* Do we need to erase the effects of a prior jbd2_journal_flush? */
	if (journal->j_flags & JBD2_FLUSHED) {
396
		jbd_debug(3, "super block updated\n");
397
		mutex_lock_io(&journal->j_checkpoint_mutex);
398 399 400 401 402 403 404 405 406
		/*
		 * We hold j_checkpoint_mutex so tail cannot change under us.
		 * We don't need any special data guarantees for writing sb
		 * since journal is empty and it is ok for write to be
		 * flushed only with transaction commit.
		 */
		jbd2_journal_update_sb_log_tail(journal,
						journal->j_tail_sequence,
						journal->j_tail,
407
						REQ_SYNC);
408
		mutex_unlock(&journal->j_checkpoint_mutex);
409 410 411 412 413 414 415 416 417
	} else {
		jbd_debug(3, "superblock not updated\n");
	}

	J_ASSERT(journal->j_running_transaction != NULL);
	J_ASSERT(journal->j_committing_transaction == NULL);

	commit_transaction = journal->j_running_transaction;

418
	trace_jbd2_start_commit(journal, commit_transaction);
E
Eryu Guan 已提交
419
	jbd_debug(1, "JBD2: starting commit of transaction %d\n",
420 421
			commit_transaction->t_tid);

422
	write_lock(&journal->j_state_lock);
423
	J_ASSERT(commit_transaction->t_state == T_RUNNING);
424
	commit_transaction->t_state = T_LOCKED;
425
	WRITE_ONCE(commit_transaction->t_locked_time, jiffies);
426

427
	trace_jbd2_commit_locking(journal, commit_transaction);
428
	stats.run.rs_wait = commit_transaction->t_max_wait;
429
	stats.run.rs_request_delay = 0;
430
	stats.run.rs_locked = jiffies;
431 432 433 434
	if (commit_transaction->t_requested)
		stats.run.rs_request_delay =
			jbd2_time_diff(commit_transaction->t_requested,
				       stats.run.rs_locked);
435 436
	stats.run.rs_running = jbd2_time_diff(commit_transaction->t_start,
					      stats.run.rs_locked);
437

438
	spin_lock(&commit_transaction->t_handle_lock);
439
	while (atomic_read(&commit_transaction->t_updates)) {
440 441 442 443
		DEFINE_WAIT(wait);

		prepare_to_wait(&journal->j_wait_updates, &wait,
					TASK_UNINTERRUPTIBLE);
444
		if (atomic_read(&commit_transaction->t_updates)) {
445
			spin_unlock(&commit_transaction->t_handle_lock);
446
			write_unlock(&journal->j_state_lock);
447
			schedule();
448
			write_lock(&journal->j_state_lock);
449 450 451 452 453 454
			spin_lock(&commit_transaction->t_handle_lock);
		}
		finish_wait(&journal->j_wait_updates, &wait);
	}
	spin_unlock(&commit_transaction->t_handle_lock);

455
	J_ASSERT (atomic_read(&commit_transaction->t_outstanding_credits) <=
456 457 458 459 460 461 462
			journal->j_max_transaction_buffers);

	/*
	 * First thing we are allowed to do is to discard any remaining
	 * BJ_Reserved buffers.  Note, it is _not_ permissible to assume
	 * that there are no such buffers: if a large filesystem
	 * operation like a truncate needs to split itself over multiple
463
	 * transactions, then it may try to do a jbd2_journal_restart() while
464 465 466 467 468 469 470
	 * there are still BJ_Reserved buffers outstanding.  These must
	 * be released cleanly from the current transaction.
	 *
	 * In this case, the filesystem must still reserve write access
	 * again before modifying the buffer in the new transaction, but
	 * we do not require it to remember exactly which old buffers it
	 * has reserved.  This is consistent with the existing behaviour
471
	 * that multiple jbd2_journal_get_write_access() calls to the same
L
Lucas De Marchi 已提交
472
	 * buffer are perfectly permissible.
473 474 475 476 477
	 */
	while (commit_transaction->t_reserved_list) {
		jh = commit_transaction->t_reserved_list;
		JBUFFER_TRACE(jh, "reserved, unused: refile");
		/*
478
		 * A jbd2_journal_get_undo_access()+jbd2_journal_release_buffer() may
479 480 481 482 483 484
		 * leave undo-committed data.
		 */
		if (jh->b_committed_data) {
			struct buffer_head *bh = jh2bh(jh);

			jbd_lock_bh_state(bh);
M
Mingming Cao 已提交
485
			jbd2_free(jh->b_committed_data, bh->b_size);
486 487 488
			jh->b_committed_data = NULL;
			jbd_unlock_bh_state(bh);
		}
489
		jbd2_journal_refile_buffer(journal, jh);
490 491 492 493 494 495 496 497
	}

	/*
	 * Now try to drop any written-back buffers from the journal's
	 * checkpoint lists.  We do this *before* commit because it potentially
	 * frees some memory
	 */
	spin_lock(&journal->j_list_lock);
498
	__jbd2_journal_clean_checkpoint_list(journal, false);
499 500
	spin_unlock(&journal->j_list_lock);

E
Eryu Guan 已提交
501
	jbd_debug(3, "JBD2: commit phase 1\n");
502

503 504 505 506 507 508
	/*
	 * Clear revoked flag to reflect there is no revoked buffers
	 * in the next transaction which is going to be started.
	 */
	jbd2_clear_buffer_revoked_flags(journal);

509 510 511
	/*
	 * Switch to a new revoke table.
	 */
512
	jbd2_journal_switch_revoke_table(journal);
513

J
Jan Kara 已提交
514 515 516 517 518 519
	/*
	 * Reserved credits cannot be claimed anymore, free them
	 */
	atomic_sub(atomic_read(&journal->j_reserved_credits),
		   &commit_transaction->t_outstanding_credits);

520
	trace_jbd2_commit_flushing(journal, commit_transaction);
521 522 523
	stats.run.rs_flushing = jiffies;
	stats.run.rs_locked = jbd2_time_diff(stats.run.rs_locked,
					     stats.run.rs_flushing);
524

525 526 527
	commit_transaction->t_state = T_FLUSH;
	journal->j_committing_transaction = commit_transaction;
	journal->j_running_transaction = NULL;
J
Josef Bacik 已提交
528
	start_time = ktime_get();
529 530
	commit_transaction->t_log_start = journal->j_head;
	wake_up(&journal->j_wait_transaction_locked);
531
	write_unlock(&journal->j_state_lock);
532

533
	jbd_debug(3, "JBD2: commit phase 2a\n");
534 535 536 537 538

	/*
	 * Now start flushing things to disk, in the order they appear
	 * on the transaction lists.  Data blocks go first.
	 */
539
	err = journal_submit_data_buffers(journal, commit_transaction);
540
	if (err)
541
		jbd2_journal_abort(journal, err);
542

543
	blk_start_plug(&plug);
544
	jbd2_journal_write_revoke_records(commit_transaction, &log_bufs);
545

546
	jbd_debug(3, "JBD2: commit phase 2b\n");
547 548 549 550 551 552

	/*
	 * Way to go: we have now written out all of the data for a
	 * transaction!  Now comes the tricky part: we need to write out
	 * metadata.  Loop over the transaction's entire buffer list:
	 */
553
	write_lock(&journal->j_state_lock);
554
	commit_transaction->t_state = T_COMMIT;
555
	write_unlock(&journal->j_state_lock);
556

557
	trace_jbd2_commit_logging(journal, commit_transaction);
558 559 560
	stats.run.rs_logging = jiffies;
	stats.run.rs_flushing = jbd2_time_diff(stats.run.rs_flushing,
					       stats.run.rs_logging);
561 562
	stats.run.rs_blocks =
		atomic_read(&commit_transaction->t_outstanding_credits);
563
	stats.run.rs_blocks_logged = 0;
564

565
	J_ASSERT(commit_transaction->t_nr_buffers <=
566
		 atomic_read(&commit_transaction->t_outstanding_credits));
567

568
	err = 0;
569
	bufs = 0;
570
	descriptor = NULL;
571 572 573 574 575 576 577
	while (commit_transaction->t_buffers) {

		/* Find the next buffer to be journaled... */

		jh = commit_transaction->t_buffers;

		/* If we're in abort mode, we just un-journal the buffer and
578
		   release it. */
579 580

		if (is_journal_aborted(journal)) {
581
			clear_buffer_jbddirty(jh2bh(jh));
582
			JBUFFER_TRACE(jh, "journal is aborting: refile");
J
Joel Becker 已提交
583 584 585 586
			jbd2_buffer_abort_trigger(jh,
						  jh->b_frozen_data ?
						  jh->b_frozen_triggers :
						  jh->b_triggers);
587
			jbd2_journal_refile_buffer(journal, jh);
588 589 590 591 592 593 594 595 596 597 598 599 600 601 602
			/* If that was the last one, we need to clean up
			 * any descriptor buffers which may have been
			 * already allocated, even if we are now
			 * aborting. */
			if (!commit_transaction->t_buffers)
				goto start_journal_io;
			continue;
		}

		/* Make sure we have a descriptor block in which to
		   record the metadata buffer. */

		if (!descriptor) {
			J_ASSERT (bufs == 0);

E
Eryu Guan 已提交
603
			jbd_debug(4, "JBD2: get descriptor\n");
604

605 606 607
			descriptor = jbd2_journal_get_descriptor_buffer(
							commit_transaction,
							JBD2_DESCRIPTOR_BLOCK);
608
			if (!descriptor) {
609
				jbd2_journal_abort(journal, -EIO);
610 611 612
				continue;
			}

E
Eryu Guan 已提交
613
			jbd_debug(4, "JBD2: got buffer %llu (%p)\n",
614 615 616 617 618
				(unsigned long long)descriptor->b_blocknr,
				descriptor->b_data);
			tagp = &descriptor->b_data[sizeof(journal_header_t)];
			space_left = descriptor->b_size -
						sizeof(journal_header_t);
619
			first_tag = 1;
620 621 622
			set_buffer_jwrite(descriptor);
			set_buffer_dirty(descriptor);
			wbuf[bufs++] = descriptor;
623 624 625

			/* Record it so that we can wait for IO
                           completion later */
626 627
			BUFFER_TRACE(descriptor, "ph3: file as descriptor");
			jbd2_file_log_bh(&log_bufs, descriptor);
628 629 630 631
		}

		/* Where is the buffer to be written? */

632
		err = jbd2_journal_next_log_block(journal, &blocknr);
633 634 635 636
		/* If the block mapping failed, just abandon the buffer
		   and repeat this loop: we'll fall into the
		   refile-on-abort condition above. */
		if (err) {
637
			jbd2_journal_abort(journal, err);
638 639 640 641 642 643
			continue;
		}

		/*
		 * start_this_handle() uses t_outstanding_credits to determine
		 * the free space in the log, but this counter is changed
644
		 * by jbd2_journal_next_log_block() also.
645
		 */
646
		atomic_dec(&commit_transaction->t_outstanding_credits);
647 648 649

		/* Bump b_count to prevent truncate from stumbling over
                   the shadowed buffer!  @@@ This can go if we ever get
650
                   rid of the shadow pairing of buffers. */
651 652 653
		atomic_inc(&jh2bh(jh)->b_count);

		/*
654 655
		 * Make a temporary IO buffer with which to write it out
		 * (this will requeue the metadata buffer to BJ_Shadow).
656
		 */
657
		set_bit(BH_JWrite, &jh2bh(jh)->b_state);
658
		JBUFFER_TRACE(jh, "ph3: write metadata");
659
		flags = jbd2_journal_write_metadata_buffer(commit_transaction,
660
						jh, &wbuf[bufs], blocknr);
661 662 663 664
		if (flags < 0) {
			jbd2_journal_abort(journal, flags);
			continue;
		}
665
		jbd2_file_log_bh(&io_bufs, wbuf[bufs]);
666 667 668 669 670 671

		/* Record the new block's tag in the current descriptor
                   buffer */

		tag_flag = 0;
		if (flags & 1)
672
			tag_flag |= JBD2_FLAG_ESCAPE;
673
		if (!first_tag)
674
			tag_flag |= JBD2_FLAG_SAME_UUID;
675 676

		tag = (journal_block_tag_t *) tagp;
677
		write_tag_block(journal, tag, jh2bh(jh)->b_blocknr);
678
		tag->t_flags = cpu_to_be16(tag_flag);
679
		jbd2_block_tag_csum_set(journal, tag, wbuf[bufs],
680
					commit_transaction->t_tid);
Z
Zach Brown 已提交
681 682
		tagp += tag_bytes;
		space_left -= tag_bytes;
683
		bufs++;
684 685 686 687 688 689 690 691 692 693 694 695 696

		if (first_tag) {
			memcpy (tagp, journal->j_uuid, 16);
			tagp += 16;
			space_left -= 16;
			first_tag = 0;
		}

		/* If there's no more to do, or if the descriptor is full,
		   let the IO rip! */

		if (bufs == journal->j_wbufsize ||
		    commit_transaction->t_buffers == NULL ||
697
		    space_left < tag_bytes + 16 + csum_size) {
698

E
Eryu Guan 已提交
699
			jbd_debug(4, "JBD2: Submit %d IOs\n", bufs);
700 701 702 703 704

			/* Write an end-of-descriptor marker before
                           submitting the IOs.  "tag" still points to
                           the last tag we set up. */

705
			tag->t_flags |= cpu_to_be16(JBD2_FLAG_LAST_TAG);
706
start_journal_io:
707 708 709 710
			if (descriptor)
				jbd2_descriptor_block_csum_set(journal,
							descriptor);

711 712
			for (i = 0; i < bufs; i++) {
				struct buffer_head *bh = wbuf[i];
713 714 715
				/*
				 * Compute checksum.
				 */
716
				if (jbd2_has_feature_checksum(journal)) {
717 718 719 720
					crc32_sum =
					    jbd2_checksum_data(crc32_sum, bh);
				}

721 722 723 724
				lock_buffer(bh);
				clear_buffer_dirty(bh);
				set_buffer_uptodate(bh);
				bh->b_end_io = journal_end_buffer_io_sync;
725
				submit_bh(REQ_OP_WRITE, REQ_SYNC, bh);
726 727
			}
			cond_resched();
728
			stats.run.rs_blocks_logged += bufs;
729 730 731 732 733 734 735 736

			/* Force a new descriptor to be generated next
                           time round the loop. */
			descriptor = NULL;
			bufs = 0;
		}
	}

737 738 739 740 741 742 743 744 745 746
	err = journal_finish_inode_data_buffers(journal, commit_transaction);
	if (err) {
		printk(KERN_WARNING
			"JBD2: Detected IO errors while flushing file data "
		       "on %s\n", journal->j_devname);
		if (journal->j_flags & JBD2_ABORT_ON_SYNCDATA_ERR)
			jbd2_journal_abort(journal, err);
		err = 0;
	}

747 748 749 750 751 752 753 754 755 756
	/*
	 * Get current oldest transaction in the log before we issue flush
	 * to the filesystem device. After the flush we can be sure that
	 * blocks of all older transactions are checkpointed to persistent
	 * storage and we will be safe to update journal start in the
	 * superblock with the numbers we get here.
	 */
	update_tail =
		jbd2_journal_get_log_tail(journal, &first_tid, &first_block);

757
	write_lock(&journal->j_state_lock);
758 759 760 761 762 763 764 765 766
	if (update_tail) {
		long freed = first_block - journal->j_tail;

		if (first_block < journal->j_tail)
			freed += journal->j_last - journal->j_first;
		/* Update tail only if we free significant amount of space */
		if (freed < journal->j_maxlen / 4)
			update_tail = 0;
	}
767 768 769
	J_ASSERT(commit_transaction->t_state == T_COMMIT);
	commit_transaction->t_state = T_COMMIT_DFLUSH;
	write_unlock(&journal->j_state_lock);
770

771 772 773 774 775
	/* 
	 * If the journal is not located on the file system device,
	 * then we must flush the file system device before we issue
	 * the commit record
	 */
776
	if (commit_transaction->t_need_data_flush &&
777 778
	    (journal->j_fs_dev != journal->j_dev) &&
	    (journal->j_flags & JBD2_BARRIER))
779
		blkdev_issue_flush(journal->j_fs_dev, GFP_NOFS, NULL);
780

781
	/* Done it all: now write the commit record asynchronously. */
782
	if (jbd2_has_feature_async_commit(journal)) {
783 784 785 786
		err = journal_submit_commit_record(journal, commit_transaction,
						 &cbh, crc32_sum);
		if (err)
			__jbd2_journal_abort_hard(journal);
787
	}
788

789 790
	blk_finish_plug(&plug);

791 792 793 794
	/* Lo and behold: we have just managed to send a transaction to
           the log.  Before we can commit it, wait for the IO so far to
           complete.  Control buffers being written are on the
           transaction's t_log_list queue, and metadata buffers are on
795
           the io_bufs list.
796 797 798 799 800 801

	   Wait for the buffers in reverse order.  That way we are
	   less likely to be woken up until all IOs have completed, and
	   so we incur less scheduling load.
	*/

E
Eryu Guan 已提交
802
	jbd_debug(3, "JBD2: commit phase 3\n");
803

804 805 806 807
	while (!list_empty(&io_bufs)) {
		struct buffer_head *bh = list_entry(io_bufs.prev,
						    struct buffer_head,
						    b_assoc_buffers);
808

809 810
		wait_on_buffer(bh);
		cond_resched();
811 812 813

		if (unlikely(!buffer_uptodate(bh)))
			err = -EIO;
814
		jbd2_unfile_log_bh(bh);
815 816

		/*
817 818
		 * The list contains temporary buffer heads created by
		 * jbd2_journal_write_metadata_buffer().
819 820 821 822 823 824
		 */
		BUFFER_TRACE(bh, "dumping temporary bh");
		__brelse(bh);
		J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
		free_buffer_head(bh);

825
		/* We also have to refile the corresponding shadowed buffer */
826 827
		jh = commit_transaction->t_shadow_list->b_tprev;
		bh = jh2bh(jh);
828
		clear_buffer_jwrite(bh);
829
		J_ASSERT_BH(bh, buffer_jbddirty(bh));
830
		J_ASSERT_BH(bh, !buffer_shadow(bh));
831 832 833 834 835 836

		/* The metadata is now released for reuse, but we need
                   to remember it against this transaction so that when
                   we finally commit, we can do any checkpointing
                   required. */
		JBUFFER_TRACE(jh, "file as BJ_Forget");
837
		jbd2_journal_file_buffer(jh, commit_transaction, BJ_Forget);
838 839 840 841 842 843
		JBUFFER_TRACE(jh, "brelse shadowed buffer");
		__brelse(bh);
	}

	J_ASSERT (commit_transaction->t_shadow_list == NULL);

E
Eryu Guan 已提交
844
	jbd_debug(3, "JBD2: commit phase 4\n");
845 846

	/* Here we wait for the revoke record and descriptor record buffers */
847
	while (!list_empty(&log_bufs)) {
848 849
		struct buffer_head *bh;

850 851 852
		bh = list_entry(log_bufs.prev, struct buffer_head, b_assoc_buffers);
		wait_on_buffer(bh);
		cond_resched();
853 854 855 856 857 858

		if (unlikely(!buffer_uptodate(bh)))
			err = -EIO;

		BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");
		clear_buffer_jwrite(bh);
859
		jbd2_unfile_log_bh(bh);
860 861 862 863
		__brelse(bh);		/* One for getblk */
		/* AKPM: bforget here */
	}

864 865 866
	if (err)
		jbd2_journal_abort(journal, err);

E
Eryu Guan 已提交
867
	jbd_debug(3, "JBD2: commit phase 5\n");
868 869 870 871
	write_lock(&journal->j_state_lock);
	J_ASSERT(commit_transaction->t_state == T_COMMIT_DFLUSH);
	commit_transaction->t_state = T_COMMIT_JFLUSH;
	write_unlock(&journal->j_state_lock);
872

873
	if (!jbd2_has_feature_async_commit(journal)) {
874 875 876 877 878
		err = journal_submit_commit_record(journal, commit_transaction,
						&cbh, crc32_sum);
		if (err)
			__jbd2_journal_abort_hard(journal);
	}
879
	if (cbh)
880
		err = journal_wait_on_commit_record(journal, cbh);
881
	if (jbd2_has_feature_async_commit(journal) &&
882
	    journal->j_flags & JBD2_BARRIER) {
883
		blkdev_issue_flush(journal->j_dev, GFP_NOFS, NULL);
884
	}
885 886

	if (err)
887
		jbd2_journal_abort(journal, err);
888

889 890 891 892 893 894 895 896
	/*
	 * Now disk caches for filesystem device are flushed so we are safe to
	 * erase checkpointed transactions from the log by updating journal
	 * superblock.
	 */
	if (update_tail)
		jbd2_update_log_tail(journal, first_tid, first_block);

897 898 899 900 901
	/* End of a transaction!  Finally, we can do checkpoint
           processing: any buffers committed as a result of this
           transaction can be removed from any checkpoint list it was on
           before. */

E
Eryu Guan 已提交
902
	jbd_debug(3, "JBD2: commit phase 6\n");
903

904
	J_ASSERT(list_empty(&commit_transaction->t_inode_list));
905 906 907 908 909 910 911 912 913 914 915 916 917
	J_ASSERT(commit_transaction->t_buffers == NULL);
	J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
	J_ASSERT(commit_transaction->t_shadow_list == NULL);

restart_loop:
	/*
	 * As there are other places (journal_unmap_buffer()) adding buffers
	 * to this list we have to be careful and hold the j_list_lock.
	 */
	spin_lock(&journal->j_list_lock);
	while (commit_transaction->t_forget) {
		transaction_t *cp_transaction;
		struct buffer_head *bh;
918
		int try_to_free = 0;
919 920 921 922

		jh = commit_transaction->t_forget;
		spin_unlock(&journal->j_list_lock);
		bh = jh2bh(jh);
923 924 925 926 927
		/*
		 * Get a reference so that bh cannot be freed before we are
		 * done with it.
		 */
		get_bh(bh);
928
		jbd_lock_bh_state(bh);
929
		J_ASSERT_JH(jh,	jh->b_transaction == commit_transaction);
930 931 932 933 934 935 936 937 938 939

		/*
		 * If there is undo-protected committed data against
		 * this buffer, then we can remove it now.  If it is a
		 * buffer needing such protection, the old frozen_data
		 * field now points to a committed version of the
		 * buffer, so rotate that field to the new committed
		 * data.
		 *
		 * Otherwise, we can just throw away the frozen data now.
J
Joel Becker 已提交
940 941 942
		 *
		 * We also know that the frozen data has already fired
		 * its triggers if they exist, so we can clear that too.
943 944
		 */
		if (jh->b_committed_data) {
M
Mingming Cao 已提交
945
			jbd2_free(jh->b_committed_data, bh->b_size);
946 947 948 949
			jh->b_committed_data = NULL;
			if (jh->b_frozen_data) {
				jh->b_committed_data = jh->b_frozen_data;
				jh->b_frozen_data = NULL;
J
Joel Becker 已提交
950
				jh->b_frozen_triggers = NULL;
951 952
			}
		} else if (jh->b_frozen_data) {
M
Mingming Cao 已提交
953
			jbd2_free(jh->b_frozen_data, bh->b_size);
954
			jh->b_frozen_data = NULL;
J
Joel Becker 已提交
955
			jh->b_frozen_triggers = NULL;
956 957 958 959 960 961
		}

		spin_lock(&journal->j_list_lock);
		cp_transaction = jh->b_cp_transaction;
		if (cp_transaction) {
			JBUFFER_TRACE(jh, "remove from old cp transaction");
962
			cp_transaction->t_chp_stats.cs_dropped++;
963
			__jbd2_journal_remove_checkpoint(jh);
964 965 966 967
		}

		/* Only re-checkpoint the buffer_head if it is marked
		 * dirty.  If the buffer was added to the BJ_Forget list
968
		 * by jbd2_journal_forget, it may no longer be dirty and
969 970 971
		 * there's no point in keeping a checkpoint record for
		 * it. */

972
		/*
973 974 975 976 977 978 979 980 981 982 983 984 985 986 987
		 * A buffer which has been freed while still being journaled
		 * by a previous transaction, refile the buffer to BJ_Forget of
		 * the running transaction. If the just committed transaction
		 * contains "add to orphan" operation, we can completely
		 * invalidate the buffer now. We are rather through in that
		 * since the buffer may be still accessible when blocksize <
		 * pagesize and it is attached to the last partial page.
		 */
		if (buffer_freed(bh) && !jh->b_next_transaction) {
			clear_buffer_freed(bh);
			clear_buffer_jbddirty(bh);
			clear_buffer_mapped(bh);
			clear_buffer_new(bh);
			clear_buffer_req(bh);
			bh->b_bdev = NULL;
988 989 990 991
		}

		if (buffer_jbddirty(bh)) {
			JBUFFER_TRACE(jh, "add to new checkpointing trans");
992
			__jbd2_journal_insert_checkpoint(jh, commit_transaction);
993 994
			if (is_journal_aborted(journal))
				clear_buffer_jbddirty(bh);
995 996
		} else {
			J_ASSERT_BH(bh, !buffer_dirty(bh));
997 998
			/*
			 * The buffer on BJ_Forget list and not jbddirty means
999 1000 1001 1002 1003
			 * it has been freed by this transaction and hence it
			 * could not have been reallocated until this
			 * transaction has committed. *BUT* it could be
			 * reallocated once we have written all the data to
			 * disk and before we process the buffer on BJ_Forget
1004 1005 1006 1007
			 * list.
			 */
			if (!jh->b_next_transaction)
				try_to_free = 1;
1008
		}
1009 1010 1011 1012 1013 1014 1015
		JBUFFER_TRACE(jh, "refile or unfile buffer");
		__jbd2_journal_refile_buffer(jh);
		jbd_unlock_bh_state(bh);
		if (try_to_free)
			release_buffer_page(bh);	/* Drops bh reference */
		else
			__brelse(bh);
1016 1017 1018 1019
		cond_resched_lock(&journal->j_list_lock);
	}
	spin_unlock(&journal->j_list_lock);
	/*
1020 1021 1022 1023
	 * This is a bit sleazy.  We use j_list_lock to protect transition
	 * of a transaction into T_FINISHED state and calling
	 * __jbd2_journal_drop_transaction(). Otherwise we could race with
	 * other checkpointing code processing the transaction...
1024
	 */
1025
	write_lock(&journal->j_state_lock);
1026 1027 1028 1029 1030 1031 1032
	spin_lock(&journal->j_list_lock);
	/*
	 * Now recheck if some buffers did not get attached to the transaction
	 * while the lock was dropped...
	 */
	if (commit_transaction->t_forget) {
		spin_unlock(&journal->j_list_lock);
1033
		write_unlock(&journal->j_state_lock);
1034 1035 1036
		goto restart_loop;
	}

1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
	/* Add the transaction to the checkpoint list
	 * __journal_remove_checkpoint() can not destroy transaction
	 * under us because it is not marked as T_FINISHED yet */
	if (journal->j_checkpoint_transactions == NULL) {
		journal->j_checkpoint_transactions = commit_transaction;
		commit_transaction->t_cpnext = commit_transaction;
		commit_transaction->t_cpprev = commit_transaction;
	} else {
		commit_transaction->t_cpnext =
			journal->j_checkpoint_transactions;
		commit_transaction->t_cpprev =
			commit_transaction->t_cpnext->t_cpprev;
		commit_transaction->t_cpnext->t_cpprev =
			commit_transaction;
		commit_transaction->t_cpprev->t_cpnext =
				commit_transaction;
	}
	spin_unlock(&journal->j_list_lock);

1056 1057
	/* Done with this transaction! */

E
Eryu Guan 已提交
1058
	jbd_debug(3, "JBD2: commit phase 7\n");
1059

1060
	J_ASSERT(commit_transaction->t_state == T_COMMIT_JFLUSH);
1061

1062
	commit_transaction->t_start = jiffies;
1063 1064
	stats.run.rs_logging = jbd2_time_diff(stats.run.rs_logging,
					      commit_transaction->t_start);
1065 1066

	/*
1067
	 * File the transaction statistics
1068 1069
	 */
	stats.ts_tid = commit_transaction->t_tid;
1070 1071
	stats.run.rs_handle_count =
		atomic_read(&commit_transaction->t_handle_count);
1072 1073
	trace_jbd2_run_stats(journal->j_fs_dev->bd_dev,
			     commit_transaction->t_tid, &stats.run);
1074
	stats.ts_requested = (commit_transaction->t_requested) ? 1 : 0;
1075

1076
	commit_transaction->t_state = T_COMMIT_CALLBACK;
1077 1078 1079
	J_ASSERT(commit_transaction == journal->j_committing_transaction);
	journal->j_commit_sequence = commit_transaction->t_tid;
	journal->j_committing_transaction = NULL;
J
Josef Bacik 已提交
1080
	commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time));
1081

J
Josef Bacik 已提交
1082 1083 1084 1085 1086 1087 1088 1089 1090
	/*
	 * weight the commit time higher than the average time so we don't
	 * react too strongly to vast changes in the commit time
	 */
	if (likely(journal->j_average_commit_time))
		journal->j_average_commit_time = (commit_time +
				journal->j_average_commit_time*3) / 4;
	else
		journal->j_average_commit_time = commit_time;
1091

1092
	write_unlock(&journal->j_state_lock);
1093

1094 1095 1096
	if (journal->j_commit_callback)
		journal->j_commit_callback(journal, commit_transaction);

1097
	trace_jbd2_end_commit(journal, commit_transaction);
E
Eryu Guan 已提交
1098
	jbd_debug(1, "JBD2: commit %d complete, head %d\n",
1099 1100
		  journal->j_commit_sequence, journal->j_tail_sequence);

1101 1102 1103
	write_lock(&journal->j_state_lock);
	spin_lock(&journal->j_list_lock);
	commit_transaction->t_state = T_FINISHED;
1104
	/* Check if the transaction can be dropped now that we are finished */
1105 1106 1107 1108 1109 1110 1111
	if (commit_transaction->t_checkpoint_list == NULL &&
	    commit_transaction->t_checkpoint_io_list == NULL) {
		__jbd2_journal_drop_transaction(journal, commit_transaction);
		jbd2_journal_free_transaction(commit_transaction);
	}
	spin_unlock(&journal->j_list_lock);
	write_unlock(&journal->j_state_lock);
1112
	wake_up(&journal->j_wait_done_commit);
1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129

	/*
	 * Calculate overall stats
	 */
	spin_lock(&journal->j_history_lock);
	journal->j_stats.ts_tid++;
	journal->j_stats.ts_requested += stats.ts_requested;
	journal->j_stats.run.rs_wait += stats.run.rs_wait;
	journal->j_stats.run.rs_request_delay += stats.run.rs_request_delay;
	journal->j_stats.run.rs_running += stats.run.rs_running;
	journal->j_stats.run.rs_locked += stats.run.rs_locked;
	journal->j_stats.run.rs_flushing += stats.run.rs_flushing;
	journal->j_stats.run.rs_logging += stats.run.rs_logging;
	journal->j_stats.run.rs_handle_count += stats.run.rs_handle_count;
	journal->j_stats.run.rs_blocks += stats.run.rs_blocks;
	journal->j_stats.run.rs_blocks_logged += stats.run.rs_blocks_logged;
	spin_unlock(&journal->j_history_lock);
1130
}