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