Merge branch 'ext3-latency-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6.git] / fs / jbd / commit.c
1 /*
2  * linux/fs/jbd/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/jbd.h>
19 #include <linux/errno.h>
20 #include <linux/slab.h>
21 #include <linux/mm.h>
22 #include <linux/pagemap.h>
23 #include <linux/bio.h>
24
25 /*
26  * Default IO end handler for temporary BJ_IO buffer_heads.
27  */
28 static void journal_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
29 {
30         BUFFER_TRACE(bh, "");
31         if (uptodate)
32                 set_buffer_uptodate(bh);
33         else
34                 clear_buffer_uptodate(bh);
35         unlock_buffer(bh);
36 }
37
38 /*
39  * When an ext3-ordered file is truncated, it is possible that many pages are
40  * not successfully freed, because they are attached to a committing transaction.
41  * After the transaction commits, these pages are left on the LRU, with no
42  * ->mapping, and with attached buffers.  These pages are trivially reclaimable
43  * by the VM, but their apparent absence upsets the VM accounting, and it makes
44  * the numbers in /proc/meminfo look odd.
45  *
46  * So here, we have a buffer which has just come off the forget list.  Look to
47  * see if we can strip all buffers from the backing page.
48  *
49  * Called under journal->j_list_lock.  The caller provided us with a ref
50  * against the buffer, and we drop that here.
51  */
52 static void release_buffer_page(struct buffer_head *bh)
53 {
54         struct page *page;
55
56         if (buffer_dirty(bh))
57                 goto nope;
58         if (atomic_read(&bh->b_count) != 1)
59                 goto nope;
60         page = bh->b_page;
61         if (!page)
62                 goto nope;
63         if (page->mapping)
64                 goto nope;
65
66         /* OK, it's a truncated page */
67         if (!trylock_page(page))
68                 goto nope;
69
70         page_cache_get(page);
71         __brelse(bh);
72         try_to_free_buffers(page);
73         unlock_page(page);
74         page_cache_release(page);
75         return;
76
77 nope:
78         __brelse(bh);
79 }
80
81 /*
82  * Decrement reference counter for data buffer. If it has been marked
83  * 'BH_Freed', release it and the page to which it belongs if possible.
84  */
85 static void release_data_buffer(struct buffer_head *bh)
86 {
87         if (buffer_freed(bh)) {
88                 clear_buffer_freed(bh);
89                 release_buffer_page(bh);
90         } else
91                 put_bh(bh);
92 }
93
94 /*
95  * Try to acquire jbd_lock_bh_state() against the buffer, when j_list_lock is
96  * held.  For ranking reasons we must trylock.  If we lose, schedule away and
97  * return 0.  j_list_lock is dropped in this case.
98  */
99 static int inverted_lock(journal_t *journal, struct buffer_head *bh)
100 {
101         if (!jbd_trylock_bh_state(bh)) {
102                 spin_unlock(&journal->j_list_lock);
103                 schedule();
104                 return 0;
105         }
106         return 1;
107 }
108
109 /* Done it all: now write the commit record.  We should have
110  * cleaned up our previous buffers by now, so if we are in abort
111  * mode we can now just skip the rest of the journal write
112  * entirely.
113  *
114  * Returns 1 if the journal needs to be aborted or 0 on success
115  */
116 static int journal_write_commit_record(journal_t *journal,
117                                         transaction_t *commit_transaction)
118 {
119         struct journal_head *descriptor;
120         struct buffer_head *bh;
121         journal_header_t *header;
122         int ret;
123         int barrier_done = 0;
124
125         if (is_journal_aborted(journal))
126                 return 0;
127
128         descriptor = journal_get_descriptor_buffer(journal);
129         if (!descriptor)
130                 return 1;
131
132         bh = jh2bh(descriptor);
133
134         header = (journal_header_t *)(bh->b_data);
135         header->h_magic = cpu_to_be32(JFS_MAGIC_NUMBER);
136         header->h_blocktype = cpu_to_be32(JFS_COMMIT_BLOCK);
137         header->h_sequence = cpu_to_be32(commit_transaction->t_tid);
138
139         JBUFFER_TRACE(descriptor, "write commit block");
140         set_buffer_dirty(bh);
141         if (journal->j_flags & JFS_BARRIER) {
142                 set_buffer_ordered(bh);
143                 barrier_done = 1;
144         }
145         ret = sync_dirty_buffer(bh);
146         if (barrier_done)
147                 clear_buffer_ordered(bh);
148         /* is it possible for another commit to fail at roughly
149          * the same time as this one?  If so, we don't want to
150          * trust the barrier flag in the super, but instead want
151          * to remember if we sent a barrier request
152          */
153         if (ret == -EOPNOTSUPP && barrier_done) {
154                 char b[BDEVNAME_SIZE];
155
156                 printk(KERN_WARNING
157                         "JBD: barrier-based sync failed on %s - "
158                         "disabling barriers\n",
159                         bdevname(journal->j_dev, b));
160                 spin_lock(&journal->j_state_lock);
161                 journal->j_flags &= ~JFS_BARRIER;
162                 spin_unlock(&journal->j_state_lock);
163
164                 /* And try again, without the barrier */
165                 set_buffer_uptodate(bh);
166                 set_buffer_dirty(bh);
167                 ret = sync_dirty_buffer(bh);
168         }
169         put_bh(bh);             /* One for getblk() */
170         journal_put_journal_head(descriptor);
171
172         return (ret == -EIO);
173 }
174
175 static void journal_do_submit_data(struct buffer_head **wbuf, int bufs,
176                                    int write_op)
177 {
178         int i;
179
180         for (i = 0; i < bufs; i++) {
181                 wbuf[i]->b_end_io = end_buffer_write_sync;
182                 /* We use-up our safety reference in submit_bh() */
183                 submit_bh(write_op, wbuf[i]);
184         }
185 }
186
187 /*
188  *  Submit all the data buffers to disk
189  */
190 static int journal_submit_data_buffers(journal_t *journal,
191                                        transaction_t *commit_transaction,
192                                        int write_op)
193 {
194         struct journal_head *jh;
195         struct buffer_head *bh;
196         int locked;
197         int bufs = 0;
198         struct buffer_head **wbuf = journal->j_wbuf;
199         int err = 0;
200
201         /*
202          * Whenever we unlock the journal and sleep, things can get added
203          * onto ->t_sync_datalist, so we have to keep looping back to
204          * write_out_data until we *know* that the list is empty.
205          *
206          * Cleanup any flushed data buffers from the data list.  Even in
207          * abort mode, we want to flush this out as soon as possible.
208          */
209 write_out_data:
210         cond_resched();
211         spin_lock(&journal->j_list_lock);
212
213         while (commit_transaction->t_sync_datalist) {
214                 jh = commit_transaction->t_sync_datalist;
215                 bh = jh2bh(jh);
216                 locked = 0;
217
218                 /* Get reference just to make sure buffer does not disappear
219                  * when we are forced to drop various locks */
220                 get_bh(bh);
221                 /* If the buffer is dirty, we need to submit IO and hence
222                  * we need the buffer lock. We try to lock the buffer without
223                  * blocking. If we fail, we need to drop j_list_lock and do
224                  * blocking lock_buffer().
225                  */
226                 if (buffer_dirty(bh)) {
227                         if (!trylock_buffer(bh)) {
228                                 BUFFER_TRACE(bh, "needs blocking lock");
229                                 spin_unlock(&journal->j_list_lock);
230                                 /* Write out all data to prevent deadlocks */
231                                 journal_do_submit_data(wbuf, bufs, write_op);
232                                 bufs = 0;
233                                 lock_buffer(bh);
234                                 spin_lock(&journal->j_list_lock);
235                         }
236                         locked = 1;
237                 }
238                 /* We have to get bh_state lock. Again out of order, sigh. */
239                 if (!inverted_lock(journal, bh)) {
240                         jbd_lock_bh_state(bh);
241                         spin_lock(&journal->j_list_lock);
242                 }
243                 /* Someone already cleaned up the buffer? */
244                 if (!buffer_jbd(bh)
245                         || jh->b_transaction != commit_transaction
246                         || jh->b_jlist != BJ_SyncData) {
247                         jbd_unlock_bh_state(bh);
248                         if (locked)
249                                 unlock_buffer(bh);
250                         BUFFER_TRACE(bh, "already cleaned up");
251                         release_data_buffer(bh);
252                         continue;
253                 }
254                 if (locked && test_clear_buffer_dirty(bh)) {
255                         BUFFER_TRACE(bh, "needs writeout, adding to array");
256                         wbuf[bufs++] = bh;
257                         __journal_file_buffer(jh, commit_transaction,
258                                                 BJ_Locked);
259                         jbd_unlock_bh_state(bh);
260                         if (bufs == journal->j_wbufsize) {
261                                 spin_unlock(&journal->j_list_lock);
262                                 journal_do_submit_data(wbuf, bufs, write_op);
263                                 bufs = 0;
264                                 goto write_out_data;
265                         }
266                 } else if (!locked && buffer_locked(bh)) {
267                         __journal_file_buffer(jh, commit_transaction,
268                                                 BJ_Locked);
269                         jbd_unlock_bh_state(bh);
270                         put_bh(bh);
271                 } else {
272                         BUFFER_TRACE(bh, "writeout complete: unfile");
273                         if (unlikely(!buffer_uptodate(bh)))
274                                 err = -EIO;
275                         __journal_unfile_buffer(jh);
276                         jbd_unlock_bh_state(bh);
277                         if (locked)
278                                 unlock_buffer(bh);
279                         journal_remove_journal_head(bh);
280                         /* One for our safety reference, other for
281                          * journal_remove_journal_head() */
282                         put_bh(bh);
283                         release_data_buffer(bh);
284                 }
285
286                 if (need_resched() || spin_needbreak(&journal->j_list_lock)) {
287                         spin_unlock(&journal->j_list_lock);
288                         goto write_out_data;
289                 }
290         }
291         spin_unlock(&journal->j_list_lock);
292         journal_do_submit_data(wbuf, bufs, write_op);
293
294         return err;
295 }
296
297 /*
298  * journal_commit_transaction
299  *
300  * The primary function for committing a transaction to the log.  This
301  * function is called by the journal thread to begin a complete commit.
302  */
303 void journal_commit_transaction(journal_t *journal)
304 {
305         transaction_t *commit_transaction;
306         struct journal_head *jh, *new_jh, *descriptor;
307         struct buffer_head **wbuf = journal->j_wbuf;
308         int bufs;
309         int flags;
310         int err;
311         unsigned long blocknr;
312         ktime_t start_time;
313         u64 commit_time;
314         char *tagp = NULL;
315         journal_header_t *header;
316         journal_block_tag_t *tag = NULL;
317         int space_left = 0;
318         int first_tag = 0;
319         int tag_flag;
320         int i;
321         int write_op = WRITE;
322
323         /*
324          * First job: lock down the current transaction and wait for
325          * all outstanding updates to complete.
326          */
327
328 #ifdef COMMIT_STATS
329         spin_lock(&journal->j_list_lock);
330         summarise_journal_usage(journal);
331         spin_unlock(&journal->j_list_lock);
332 #endif
333
334         /* Do we need to erase the effects of a prior journal_flush? */
335         if (journal->j_flags & JFS_FLUSHED) {
336                 jbd_debug(3, "super block updated\n");
337                 journal_update_superblock(journal, 1);
338         } else {
339                 jbd_debug(3, "superblock not updated\n");
340         }
341
342         J_ASSERT(journal->j_running_transaction != NULL);
343         J_ASSERT(journal->j_committing_transaction == NULL);
344
345         commit_transaction = journal->j_running_transaction;
346         J_ASSERT(commit_transaction->t_state == T_RUNNING);
347
348         jbd_debug(1, "JBD: starting commit of transaction %d\n",
349                         commit_transaction->t_tid);
350
351         spin_lock(&journal->j_state_lock);
352         commit_transaction->t_state = T_LOCKED;
353
354         if (commit_transaction->t_synchronous_commit)
355                 write_op = WRITE_SYNC;
356         spin_lock(&commit_transaction->t_handle_lock);
357         while (commit_transaction->t_updates) {
358                 DEFINE_WAIT(wait);
359
360                 prepare_to_wait(&journal->j_wait_updates, &wait,
361                                         TASK_UNINTERRUPTIBLE);
362                 if (commit_transaction->t_updates) {
363                         spin_unlock(&commit_transaction->t_handle_lock);
364                         spin_unlock(&journal->j_state_lock);
365                         schedule();
366                         spin_lock(&journal->j_state_lock);
367                         spin_lock(&commit_transaction->t_handle_lock);
368                 }
369                 finish_wait(&journal->j_wait_updates, &wait);
370         }
371         spin_unlock(&commit_transaction->t_handle_lock);
372
373         J_ASSERT (commit_transaction->t_outstanding_credits <=
374                         journal->j_max_transaction_buffers);
375
376         /*
377          * First thing we are allowed to do is to discard any remaining
378          * BJ_Reserved buffers.  Note, it is _not_ permissible to assume
379          * that there are no such buffers: if a large filesystem
380          * operation like a truncate needs to split itself over multiple
381          * transactions, then it may try to do a journal_restart() while
382          * there are still BJ_Reserved buffers outstanding.  These must
383          * be released cleanly from the current transaction.
384          *
385          * In this case, the filesystem must still reserve write access
386          * again before modifying the buffer in the new transaction, but
387          * we do not require it to remember exactly which old buffers it
388          * has reserved.  This is consistent with the existing behaviour
389          * that multiple journal_get_write_access() calls to the same
390          * buffer are perfectly permissable.
391          */
392         while (commit_transaction->t_reserved_list) {
393                 jh = commit_transaction->t_reserved_list;
394                 JBUFFER_TRACE(jh, "reserved, unused: refile");
395                 /*
396                  * A journal_get_undo_access()+journal_release_buffer() may
397                  * leave undo-committed data.
398                  */
399                 if (jh->b_committed_data) {
400                         struct buffer_head *bh = jh2bh(jh);
401
402                         jbd_lock_bh_state(bh);
403                         jbd_free(jh->b_committed_data, bh->b_size);
404                         jh->b_committed_data = NULL;
405                         jbd_unlock_bh_state(bh);
406                 }
407                 journal_refile_buffer(journal, jh);
408         }
409
410         /*
411          * Now try to drop any written-back buffers from the journal's
412          * checkpoint lists.  We do this *before* commit because it potentially
413          * frees some memory
414          */
415         spin_lock(&journal->j_list_lock);
416         __journal_clean_checkpoint_list(journal);
417         spin_unlock(&journal->j_list_lock);
418
419         jbd_debug (3, "JBD: commit phase 1\n");
420
421         /*
422          * Switch to a new revoke table.
423          */
424         journal_switch_revoke_table(journal);
425
426         commit_transaction->t_state = T_FLUSH;
427         journal->j_committing_transaction = commit_transaction;
428         journal->j_running_transaction = NULL;
429         start_time = ktime_get();
430         commit_transaction->t_log_start = journal->j_head;
431         wake_up(&journal->j_wait_transaction_locked);
432         spin_unlock(&journal->j_state_lock);
433
434         jbd_debug (3, "JBD: commit phase 2\n");
435
436         /*
437          * Now start flushing things to disk, in the order they appear
438          * on the transaction lists.  Data blocks go first.
439          */
440         err = journal_submit_data_buffers(journal, commit_transaction,
441                                           write_op);
442
443         /*
444          * Wait for all previously submitted IO to complete.
445          */
446         spin_lock(&journal->j_list_lock);
447         while (commit_transaction->t_locked_list) {
448                 struct buffer_head *bh;
449
450                 jh = commit_transaction->t_locked_list->b_tprev;
451                 bh = jh2bh(jh);
452                 get_bh(bh);
453                 if (buffer_locked(bh)) {
454                         spin_unlock(&journal->j_list_lock);
455                         wait_on_buffer(bh);
456                         spin_lock(&journal->j_list_lock);
457                 }
458                 if (unlikely(!buffer_uptodate(bh))) {
459                         if (!trylock_page(bh->b_page)) {
460                                 spin_unlock(&journal->j_list_lock);
461                                 lock_page(bh->b_page);
462                                 spin_lock(&journal->j_list_lock);
463                         }
464                         if (bh->b_page->mapping)
465                                 set_bit(AS_EIO, &bh->b_page->mapping->flags);
466
467                         unlock_page(bh->b_page);
468                         SetPageError(bh->b_page);
469                         err = -EIO;
470                 }
471                 if (!inverted_lock(journal, bh)) {
472                         put_bh(bh);
473                         spin_lock(&journal->j_list_lock);
474                         continue;
475                 }
476                 if (buffer_jbd(bh) && jh->b_jlist == BJ_Locked) {
477                         __journal_unfile_buffer(jh);
478                         jbd_unlock_bh_state(bh);
479                         journal_remove_journal_head(bh);
480                         put_bh(bh);
481                 } else {
482                         jbd_unlock_bh_state(bh);
483                 }
484                 release_data_buffer(bh);
485                 cond_resched_lock(&journal->j_list_lock);
486         }
487         spin_unlock(&journal->j_list_lock);
488
489         if (err) {
490                 char b[BDEVNAME_SIZE];
491
492                 printk(KERN_WARNING
493                         "JBD: Detected IO errors while flushing file data "
494                         "on %s\n", bdevname(journal->j_fs_dev, b));
495                 if (journal->j_flags & JFS_ABORT_ON_SYNCDATA_ERR)
496                         journal_abort(journal, err);
497                 err = 0;
498         }
499
500         journal_write_revoke_records(journal, commit_transaction);
501
502         /*
503          * If we found any dirty or locked buffers, then we should have
504          * looped back up to the write_out_data label.  If there weren't
505          * any then journal_clean_data_list should have wiped the list
506          * clean by now, so check that it is in fact empty.
507          */
508         J_ASSERT (commit_transaction->t_sync_datalist == NULL);
509
510         jbd_debug (3, "JBD: commit phase 3\n");
511
512         /*
513          * Way to go: we have now written out all of the data for a
514          * transaction!  Now comes the tricky part: we need to write out
515          * metadata.  Loop over the transaction's entire buffer list:
516          */
517         spin_lock(&journal->j_state_lock);
518         commit_transaction->t_state = T_COMMIT;
519         spin_unlock(&journal->j_state_lock);
520
521         J_ASSERT(commit_transaction->t_nr_buffers <=
522                  commit_transaction->t_outstanding_credits);
523
524         descriptor = NULL;
525         bufs = 0;
526         while (commit_transaction->t_buffers) {
527
528                 /* Find the next buffer to be journaled... */
529
530                 jh = commit_transaction->t_buffers;
531
532                 /* If we're in abort mode, we just un-journal the buffer and
533                    release it. */
534
535                 if (is_journal_aborted(journal)) {
536                         clear_buffer_jbddirty(jh2bh(jh));
537                         JBUFFER_TRACE(jh, "journal is aborting: refile");
538                         journal_refile_buffer(journal, jh);
539                         /* If that was the last one, we need to clean up
540                          * any descriptor buffers which may have been
541                          * already allocated, even if we are now
542                          * aborting. */
543                         if (!commit_transaction->t_buffers)
544                                 goto start_journal_io;
545                         continue;
546                 }
547
548                 /* Make sure we have a descriptor block in which to
549                    record the metadata buffer. */
550
551                 if (!descriptor) {
552                         struct buffer_head *bh;
553
554                         J_ASSERT (bufs == 0);
555
556                         jbd_debug(4, "JBD: get descriptor\n");
557
558                         descriptor = journal_get_descriptor_buffer(journal);
559                         if (!descriptor) {
560                                 journal_abort(journal, -EIO);
561                                 continue;
562                         }
563
564                         bh = jh2bh(descriptor);
565                         jbd_debug(4, "JBD: got buffer %llu (%p)\n",
566                                 (unsigned long long)bh->b_blocknr, bh->b_data);
567                         header = (journal_header_t *)&bh->b_data[0];
568                         header->h_magic     = cpu_to_be32(JFS_MAGIC_NUMBER);
569                         header->h_blocktype = cpu_to_be32(JFS_DESCRIPTOR_BLOCK);
570                         header->h_sequence  = cpu_to_be32(commit_transaction->t_tid);
571
572                         tagp = &bh->b_data[sizeof(journal_header_t)];
573                         space_left = bh->b_size - sizeof(journal_header_t);
574                         first_tag = 1;
575                         set_buffer_jwrite(bh);
576                         set_buffer_dirty(bh);
577                         wbuf[bufs++] = bh;
578
579                         /* Record it so that we can wait for IO
580                            completion later */
581                         BUFFER_TRACE(bh, "ph3: file as descriptor");
582                         journal_file_buffer(descriptor, commit_transaction,
583                                         BJ_LogCtl);
584                 }
585
586                 /* Where is the buffer to be written? */
587
588                 err = journal_next_log_block(journal, &blocknr);
589                 /* If the block mapping failed, just abandon the buffer
590                    and repeat this loop: we'll fall into the
591                    refile-on-abort condition above. */
592                 if (err) {
593                         journal_abort(journal, err);
594                         continue;
595                 }
596
597                 /*
598                  * start_this_handle() uses t_outstanding_credits to determine
599                  * the free space in the log, but this counter is changed
600                  * by journal_next_log_block() also.
601                  */
602                 commit_transaction->t_outstanding_credits--;
603
604                 /* Bump b_count to prevent truncate from stumbling over
605                    the shadowed buffer!  @@@ This can go if we ever get
606                    rid of the BJ_IO/BJ_Shadow pairing of buffers. */
607                 atomic_inc(&jh2bh(jh)->b_count);
608
609                 /* Make a temporary IO buffer with which to write it out
610                    (this will requeue both the metadata buffer and the
611                    temporary IO buffer). new_bh goes on BJ_IO*/
612
613                 set_bit(BH_JWrite, &jh2bh(jh)->b_state);
614                 /*
615                  * akpm: journal_write_metadata_buffer() sets
616                  * new_bh->b_transaction to commit_transaction.
617                  * We need to clean this up before we release new_bh
618                  * (which is of type BJ_IO)
619                  */
620                 JBUFFER_TRACE(jh, "ph3: write metadata");
621                 flags = journal_write_metadata_buffer(commit_transaction,
622                                                       jh, &new_jh, blocknr);
623                 set_bit(BH_JWrite, &jh2bh(new_jh)->b_state);
624                 wbuf[bufs++] = jh2bh(new_jh);
625
626                 /* Record the new block's tag in the current descriptor
627                    buffer */
628
629                 tag_flag = 0;
630                 if (flags & 1)
631                         tag_flag |= JFS_FLAG_ESCAPE;
632                 if (!first_tag)
633                         tag_flag |= JFS_FLAG_SAME_UUID;
634
635                 tag = (journal_block_tag_t *) tagp;
636                 tag->t_blocknr = cpu_to_be32(jh2bh(jh)->b_blocknr);
637                 tag->t_flags = cpu_to_be32(tag_flag);
638                 tagp += sizeof(journal_block_tag_t);
639                 space_left -= sizeof(journal_block_tag_t);
640
641                 if (first_tag) {
642                         memcpy (tagp, journal->j_uuid, 16);
643                         tagp += 16;
644                         space_left -= 16;
645                         first_tag = 0;
646                 }
647
648                 /* If there's no more to do, or if the descriptor is full,
649                    let the IO rip! */
650
651                 if (bufs == journal->j_wbufsize ||
652                     commit_transaction->t_buffers == NULL ||
653                     space_left < sizeof(journal_block_tag_t) + 16) {
654
655                         jbd_debug(4, "JBD: Submit %d IOs\n", bufs);
656
657                         /* Write an end-of-descriptor marker before
658                            submitting the IOs.  "tag" still points to
659                            the last tag we set up. */
660
661                         tag->t_flags |= cpu_to_be32(JFS_FLAG_LAST_TAG);
662
663 start_journal_io:
664                         for (i = 0; i < bufs; i++) {
665                                 struct buffer_head *bh = wbuf[i];
666                                 lock_buffer(bh);
667                                 clear_buffer_dirty(bh);
668                                 set_buffer_uptodate(bh);
669                                 bh->b_end_io = journal_end_buffer_io_sync;
670                                 submit_bh(write_op, bh);
671                         }
672                         cond_resched();
673
674                         /* Force a new descriptor to be generated next
675                            time round the loop. */
676                         descriptor = NULL;
677                         bufs = 0;
678                 }
679         }
680
681         /* Lo and behold: we have just managed to send a transaction to
682            the log.  Before we can commit it, wait for the IO so far to
683            complete.  Control buffers being written are on the
684            transaction's t_log_list queue, and metadata buffers are on
685            the t_iobuf_list queue.
686
687            Wait for the buffers in reverse order.  That way we are
688            less likely to be woken up until all IOs have completed, and
689            so we incur less scheduling load.
690         */
691
692         jbd_debug(3, "JBD: commit phase 4\n");
693
694         /*
695          * akpm: these are BJ_IO, and j_list_lock is not needed.
696          * See __journal_try_to_free_buffer.
697          */
698 wait_for_iobuf:
699         while (commit_transaction->t_iobuf_list != NULL) {
700                 struct buffer_head *bh;
701
702                 jh = commit_transaction->t_iobuf_list->b_tprev;
703                 bh = jh2bh(jh);
704                 if (buffer_locked(bh)) {
705                         wait_on_buffer(bh);
706                         goto wait_for_iobuf;
707                 }
708                 if (cond_resched())
709                         goto wait_for_iobuf;
710
711                 if (unlikely(!buffer_uptodate(bh)))
712                         err = -EIO;
713
714                 clear_buffer_jwrite(bh);
715
716                 JBUFFER_TRACE(jh, "ph4: unfile after journal write");
717                 journal_unfile_buffer(journal, jh);
718
719                 /*
720                  * ->t_iobuf_list should contain only dummy buffer_heads
721                  * which were created by journal_write_metadata_buffer().
722                  */
723                 BUFFER_TRACE(bh, "dumping temporary bh");
724                 journal_put_journal_head(jh);
725                 __brelse(bh);
726                 J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
727                 free_buffer_head(bh);
728
729                 /* We also have to unlock and free the corresponding
730                    shadowed buffer */
731                 jh = commit_transaction->t_shadow_list->b_tprev;
732                 bh = jh2bh(jh);
733                 clear_bit(BH_JWrite, &bh->b_state);
734                 J_ASSERT_BH(bh, buffer_jbddirty(bh));
735
736                 /* The metadata is now released for reuse, but we need
737                    to remember it against this transaction so that when
738                    we finally commit, we can do any checkpointing
739                    required. */
740                 JBUFFER_TRACE(jh, "file as BJ_Forget");
741                 journal_file_buffer(jh, commit_transaction, BJ_Forget);
742                 /* Wake up any transactions which were waiting for this
743                    IO to complete */
744                 wake_up_bit(&bh->b_state, BH_Unshadow);
745                 JBUFFER_TRACE(jh, "brelse shadowed buffer");
746                 __brelse(bh);
747         }
748
749         J_ASSERT (commit_transaction->t_shadow_list == NULL);
750
751         jbd_debug(3, "JBD: commit phase 5\n");
752
753         /* Here we wait for the revoke record and descriptor record buffers */
754  wait_for_ctlbuf:
755         while (commit_transaction->t_log_list != NULL) {
756                 struct buffer_head *bh;
757
758                 jh = commit_transaction->t_log_list->b_tprev;
759                 bh = jh2bh(jh);
760                 if (buffer_locked(bh)) {
761                         wait_on_buffer(bh);
762                         goto wait_for_ctlbuf;
763                 }
764                 if (cond_resched())
765                         goto wait_for_ctlbuf;
766
767                 if (unlikely(!buffer_uptodate(bh)))
768                         err = -EIO;
769
770                 BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");
771                 clear_buffer_jwrite(bh);
772                 journal_unfile_buffer(journal, jh);
773                 journal_put_journal_head(jh);
774                 __brelse(bh);           /* One for getblk */
775                 /* AKPM: bforget here */
776         }
777
778         if (err)
779                 journal_abort(journal, err);
780
781         jbd_debug(3, "JBD: commit phase 6\n");
782
783         if (journal_write_commit_record(journal, commit_transaction))
784                 err = -EIO;
785
786         if (err)
787                 journal_abort(journal, err);
788
789         /* End of a transaction!  Finally, we can do checkpoint
790            processing: any buffers committed as a result of this
791            transaction can be removed from any checkpoint list it was on
792            before. */
793
794         jbd_debug(3, "JBD: commit phase 7\n");
795
796         J_ASSERT(commit_transaction->t_sync_datalist == NULL);
797         J_ASSERT(commit_transaction->t_buffers == NULL);
798         J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
799         J_ASSERT(commit_transaction->t_iobuf_list == NULL);
800         J_ASSERT(commit_transaction->t_shadow_list == NULL);
801         J_ASSERT(commit_transaction->t_log_list == NULL);
802
803 restart_loop:
804         /*
805          * As there are other places (journal_unmap_buffer()) adding buffers
806          * to this list we have to be careful and hold the j_list_lock.
807          */
808         spin_lock(&journal->j_list_lock);
809         while (commit_transaction->t_forget) {
810                 transaction_t *cp_transaction;
811                 struct buffer_head *bh;
812
813                 jh = commit_transaction->t_forget;
814                 spin_unlock(&journal->j_list_lock);
815                 bh = jh2bh(jh);
816                 jbd_lock_bh_state(bh);
817                 J_ASSERT_JH(jh, jh->b_transaction == commit_transaction ||
818                         jh->b_transaction == journal->j_running_transaction);
819
820                 /*
821                  * If there is undo-protected committed data against
822                  * this buffer, then we can remove it now.  If it is a
823                  * buffer needing such protection, the old frozen_data
824                  * field now points to a committed version of the
825                  * buffer, so rotate that field to the new committed
826                  * data.
827                  *
828                  * Otherwise, we can just throw away the frozen data now.
829                  */
830                 if (jh->b_committed_data) {
831                         jbd_free(jh->b_committed_data, bh->b_size);
832                         jh->b_committed_data = NULL;
833                         if (jh->b_frozen_data) {
834                                 jh->b_committed_data = jh->b_frozen_data;
835                                 jh->b_frozen_data = NULL;
836                         }
837                 } else if (jh->b_frozen_data) {
838                         jbd_free(jh->b_frozen_data, bh->b_size);
839                         jh->b_frozen_data = NULL;
840                 }
841
842                 spin_lock(&journal->j_list_lock);
843                 cp_transaction = jh->b_cp_transaction;
844                 if (cp_transaction) {
845                         JBUFFER_TRACE(jh, "remove from old cp transaction");
846                         __journal_remove_checkpoint(jh);
847                 }
848
849                 /* Only re-checkpoint the buffer_head if it is marked
850                  * dirty.  If the buffer was added to the BJ_Forget list
851                  * by journal_forget, it may no longer be dirty and
852                  * there's no point in keeping a checkpoint record for
853                  * it. */
854
855                 /* A buffer which has been freed while still being
856                  * journaled by a previous transaction may end up still
857                  * being dirty here, but we want to avoid writing back
858                  * that buffer in the future now that the last use has
859                  * been committed.  That's not only a performance gain,
860                  * it also stops aliasing problems if the buffer is left
861                  * behind for writeback and gets reallocated for another
862                  * use in a different page. */
863                 if (buffer_freed(bh)) {
864                         clear_buffer_freed(bh);
865                         clear_buffer_jbddirty(bh);
866                 }
867
868                 if (buffer_jbddirty(bh)) {
869                         JBUFFER_TRACE(jh, "add to new checkpointing trans");
870                         __journal_insert_checkpoint(jh, commit_transaction);
871                         if (is_journal_aborted(journal))
872                                 clear_buffer_jbddirty(bh);
873                         JBUFFER_TRACE(jh, "refile for checkpoint writeback");
874                         __journal_refile_buffer(jh);
875                         jbd_unlock_bh_state(bh);
876                 } else {
877                         J_ASSERT_BH(bh, !buffer_dirty(bh));
878                         /* The buffer on BJ_Forget list and not jbddirty means
879                          * it has been freed by this transaction and hence it
880                          * could not have been reallocated until this
881                          * transaction has committed. *BUT* it could be
882                          * reallocated once we have written all the data to
883                          * disk and before we process the buffer on BJ_Forget
884                          * list. */
885                         JBUFFER_TRACE(jh, "refile or unfile freed buffer");
886                         __journal_refile_buffer(jh);
887                         if (!jh->b_transaction) {
888                                 jbd_unlock_bh_state(bh);
889                                  /* needs a brelse */
890                                 journal_remove_journal_head(bh);
891                                 release_buffer_page(bh);
892                         } else
893                                 jbd_unlock_bh_state(bh);
894                 }
895                 cond_resched_lock(&journal->j_list_lock);
896         }
897         spin_unlock(&journal->j_list_lock);
898         /*
899          * This is a bit sleazy.  We use j_list_lock to protect transition
900          * of a transaction into T_FINISHED state and calling
901          * __journal_drop_transaction(). Otherwise we could race with
902          * other checkpointing code processing the transaction...
903          */
904         spin_lock(&journal->j_state_lock);
905         spin_lock(&journal->j_list_lock);
906         /*
907          * Now recheck if some buffers did not get attached to the transaction
908          * while the lock was dropped...
909          */
910         if (commit_transaction->t_forget) {
911                 spin_unlock(&journal->j_list_lock);
912                 spin_unlock(&journal->j_state_lock);
913                 goto restart_loop;
914         }
915
916         /* Done with this transaction! */
917
918         jbd_debug(3, "JBD: commit phase 8\n");
919
920         J_ASSERT(commit_transaction->t_state == T_COMMIT);
921
922         commit_transaction->t_state = T_FINISHED;
923         J_ASSERT(commit_transaction == journal->j_committing_transaction);
924         journal->j_commit_sequence = commit_transaction->t_tid;
925         journal->j_committing_transaction = NULL;
926         commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time));
927
928         /*
929          * weight the commit time higher than the average time so we don't
930          * react too strongly to vast changes in commit time
931          */
932         if (likely(journal->j_average_commit_time))
933                 journal->j_average_commit_time = (commit_time*3 +
934                                 journal->j_average_commit_time) / 4;
935         else
936                 journal->j_average_commit_time = commit_time;
937
938         spin_unlock(&journal->j_state_lock);
939
940         if (commit_transaction->t_checkpoint_list == NULL &&
941             commit_transaction->t_checkpoint_io_list == NULL) {
942                 __journal_drop_transaction(journal, commit_transaction);
943         } else {
944                 if (journal->j_checkpoint_transactions == NULL) {
945                         journal->j_checkpoint_transactions = commit_transaction;
946                         commit_transaction->t_cpnext = commit_transaction;
947                         commit_transaction->t_cpprev = commit_transaction;
948                 } else {
949                         commit_transaction->t_cpnext =
950                                 journal->j_checkpoint_transactions;
951                         commit_transaction->t_cpprev =
952                                 commit_transaction->t_cpnext->t_cpprev;
953                         commit_transaction->t_cpnext->t_cpprev =
954                                 commit_transaction;
955                         commit_transaction->t_cpprev->t_cpnext =
956                                 commit_transaction;
957                 }
958         }
959         spin_unlock(&journal->j_list_lock);
960
961         jbd_debug(1, "JBD: commit %d complete, head %d\n",
962                   journal->j_commit_sequence, journal->j_tail_sequence);
963
964         wake_up(&journal->j_wait_done_commit);
965 }