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