Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux...
[linux-2.6.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 <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                          * filemap_fdatawait_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.run.rs_wait = commit_transaction->t_max_wait;
414         stats.run.rs_locked = jiffies;
415         stats.run.rs_running = jbd2_time_diff(commit_transaction->t_start,
416                                               stats.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.run.rs_flushing = jiffies;
490         stats.run.rs_locked = jbd2_time_diff(stats.run.rs_locked,
491                                              stats.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.run.rs_logging = jiffies;
527         stats.run.rs_flushing = jbd2_time_diff(stats.run.rs_flushing,
528                                                stats.run.rs_logging);
529         stats.run.rs_blocks = commit_transaction->t_outstanding_credits;
530         stats.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                 if (flags < 0) {
640                         jbd2_journal_abort(journal, flags);
641                         continue;
642                 }
643                 set_bit(BH_JWrite, &jh2bh(new_jh)->b_state);
644                 wbuf[bufs++] = jh2bh(new_jh);
645
646                 /* Record the new block's tag in the current descriptor
647                    buffer */
648
649                 tag_flag = 0;
650                 if (flags & 1)
651                         tag_flag |= JBD2_FLAG_ESCAPE;
652                 if (!first_tag)
653                         tag_flag |= JBD2_FLAG_SAME_UUID;
654
655                 tag = (journal_block_tag_t *) tagp;
656                 write_tag_block(tag_bytes, tag, jh2bh(jh)->b_blocknr);
657                 tag->t_flags = cpu_to_be32(tag_flag);
658                 tagp += tag_bytes;
659                 space_left -= tag_bytes;
660
661                 if (first_tag) {
662                         memcpy (tagp, journal->j_uuid, 16);
663                         tagp += 16;
664                         space_left -= 16;
665                         first_tag = 0;
666                 }
667
668                 /* If there's no more to do, or if the descriptor is full,
669                    let the IO rip! */
670
671                 if (bufs == journal->j_wbufsize ||
672                     commit_transaction->t_buffers == NULL ||
673                     space_left < tag_bytes + 16) {
674
675                         jbd_debug(4, "JBD: Submit %d IOs\n", bufs);
676
677                         /* Write an end-of-descriptor marker before
678                            submitting the IOs.  "tag" still points to
679                            the last tag we set up. */
680
681                         tag->t_flags |= cpu_to_be32(JBD2_FLAG_LAST_TAG);
682
683 start_journal_io:
684                         for (i = 0; i < bufs; i++) {
685                                 struct buffer_head *bh = wbuf[i];
686                                 /*
687                                  * Compute checksum.
688                                  */
689                                 if (JBD2_HAS_COMPAT_FEATURE(journal,
690                                         JBD2_FEATURE_COMPAT_CHECKSUM)) {
691                                         crc32_sum =
692                                             jbd2_checksum_data(crc32_sum, bh);
693                                 }
694
695                                 lock_buffer(bh);
696                                 clear_buffer_dirty(bh);
697                                 set_buffer_uptodate(bh);
698                                 bh->b_end_io = journal_end_buffer_io_sync;
699                                 submit_bh(write_op, bh);
700                         }
701                         cond_resched();
702                         stats.run.rs_blocks_logged += bufs;
703
704                         /* Force a new descriptor to be generated next
705                            time round the loop. */
706                         descriptor = NULL;
707                         bufs = 0;
708                 }
709         }
710
711         /* Done it all: now write the commit record asynchronously. */
712
713         if (JBD2_HAS_INCOMPAT_FEATURE(journal,
714                                       JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
715                 err = journal_submit_commit_record(journal, commit_transaction,
716                                                  &cbh, crc32_sum);
717                 if (err)
718                         __jbd2_journal_abort_hard(journal);
719                 if (journal->j_flags & JBD2_BARRIER)
720                         blkdev_issue_flush(journal->j_dev, NULL);
721         }
722
723         /*
724          * This is the right place to wait for data buffers both for ASYNC
725          * and !ASYNC commit. If commit is ASYNC, we need to wait only after
726          * the commit block went to disk (which happens above). If commit is
727          * SYNC, we need to wait for data buffers before we start writing
728          * commit block, which happens below in such setting.
729          */
730         err = journal_finish_inode_data_buffers(journal, commit_transaction);
731         if (err) {
732                 printk(KERN_WARNING
733                         "JBD2: Detected IO errors while flushing file data "
734                        "on %s\n", journal->j_devname);
735                 if (journal->j_flags & JBD2_ABORT_ON_SYNCDATA_ERR)
736                         jbd2_journal_abort(journal, err);
737                 err = 0;
738         }
739
740         /* Lo and behold: we have just managed to send a transaction to
741            the log.  Before we can commit it, wait for the IO so far to
742            complete.  Control buffers being written are on the
743            transaction's t_log_list queue, and metadata buffers are on
744            the t_iobuf_list queue.
745
746            Wait for the buffers in reverse order.  That way we are
747            less likely to be woken up until all IOs have completed, and
748            so we incur less scheduling load.
749         */
750
751         jbd_debug(3, "JBD: commit phase 3\n");
752
753         /*
754          * akpm: these are BJ_IO, and j_list_lock is not needed.
755          * See __journal_try_to_free_buffer.
756          */
757 wait_for_iobuf:
758         while (commit_transaction->t_iobuf_list != NULL) {
759                 struct buffer_head *bh;
760
761                 jh = commit_transaction->t_iobuf_list->b_tprev;
762                 bh = jh2bh(jh);
763                 if (buffer_locked(bh)) {
764                         wait_on_buffer(bh);
765                         goto wait_for_iobuf;
766                 }
767                 if (cond_resched())
768                         goto wait_for_iobuf;
769
770                 if (unlikely(!buffer_uptodate(bh)))
771                         err = -EIO;
772
773                 clear_buffer_jwrite(bh);
774
775                 JBUFFER_TRACE(jh, "ph4: unfile after journal write");
776                 jbd2_journal_unfile_buffer(journal, jh);
777
778                 /*
779                  * ->t_iobuf_list should contain only dummy buffer_heads
780                  * which were created by jbd2_journal_write_metadata_buffer().
781                  */
782                 BUFFER_TRACE(bh, "dumping temporary bh");
783                 jbd2_journal_put_journal_head(jh);
784                 __brelse(bh);
785                 J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
786                 free_buffer_head(bh);
787
788                 /* We also have to unlock and free the corresponding
789                    shadowed buffer */
790                 jh = commit_transaction->t_shadow_list->b_tprev;
791                 bh = jh2bh(jh);
792                 clear_bit(BH_JWrite, &bh->b_state);
793                 J_ASSERT_BH(bh, buffer_jbddirty(bh));
794
795                 /* The metadata is now released for reuse, but we need
796                    to remember it against this transaction so that when
797                    we finally commit, we can do any checkpointing
798                    required. */
799                 JBUFFER_TRACE(jh, "file as BJ_Forget");
800                 jbd2_journal_file_buffer(jh, commit_transaction, BJ_Forget);
801                 /* Wake up any transactions which were waiting for this
802                    IO to complete */
803                 wake_up_bit(&bh->b_state, BH_Unshadow);
804                 JBUFFER_TRACE(jh, "brelse shadowed buffer");
805                 __brelse(bh);
806         }
807
808         J_ASSERT (commit_transaction->t_shadow_list == NULL);
809
810         jbd_debug(3, "JBD: commit phase 4\n");
811
812         /* Here we wait for the revoke record and descriptor record buffers */
813  wait_for_ctlbuf:
814         while (commit_transaction->t_log_list != NULL) {
815                 struct buffer_head *bh;
816
817                 jh = commit_transaction->t_log_list->b_tprev;
818                 bh = jh2bh(jh);
819                 if (buffer_locked(bh)) {
820                         wait_on_buffer(bh);
821                         goto wait_for_ctlbuf;
822                 }
823                 if (cond_resched())
824                         goto wait_for_ctlbuf;
825
826                 if (unlikely(!buffer_uptodate(bh)))
827                         err = -EIO;
828
829                 BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");
830                 clear_buffer_jwrite(bh);
831                 jbd2_journal_unfile_buffer(journal, jh);
832                 jbd2_journal_put_journal_head(jh);
833                 __brelse(bh);           /* One for getblk */
834                 /* AKPM: bforget here */
835         }
836
837         if (err)
838                 jbd2_journal_abort(journal, err);
839
840         jbd_debug(3, "JBD: commit phase 5\n");
841
842         if (!JBD2_HAS_INCOMPAT_FEATURE(journal,
843                                        JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
844                 err = journal_submit_commit_record(journal, commit_transaction,
845                                                 &cbh, crc32_sum);
846                 if (err)
847                         __jbd2_journal_abort_hard(journal);
848         }
849         if (!err && !is_journal_aborted(journal))
850                 err = journal_wait_on_commit_record(journal, cbh);
851
852         if (err)
853                 jbd2_journal_abort(journal, err);
854
855         /* End of a transaction!  Finally, we can do checkpoint
856            processing: any buffers committed as a result of this
857            transaction can be removed from any checkpoint list it was on
858            before. */
859
860         jbd_debug(3, "JBD: commit phase 6\n");
861
862         J_ASSERT(list_empty(&commit_transaction->t_inode_list));
863         J_ASSERT(commit_transaction->t_buffers == NULL);
864         J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
865         J_ASSERT(commit_transaction->t_iobuf_list == NULL);
866         J_ASSERT(commit_transaction->t_shadow_list == NULL);
867         J_ASSERT(commit_transaction->t_log_list == NULL);
868
869 restart_loop:
870         /*
871          * As there are other places (journal_unmap_buffer()) adding buffers
872          * to this list we have to be careful and hold the j_list_lock.
873          */
874         spin_lock(&journal->j_list_lock);
875         while (commit_transaction->t_forget) {
876                 transaction_t *cp_transaction;
877                 struct buffer_head *bh;
878
879                 jh = commit_transaction->t_forget;
880                 spin_unlock(&journal->j_list_lock);
881                 bh = jh2bh(jh);
882                 jbd_lock_bh_state(bh);
883                 J_ASSERT_JH(jh, jh->b_transaction == commit_transaction ||
884                         jh->b_transaction == journal->j_running_transaction);
885
886                 /*
887                  * If there is undo-protected committed data against
888                  * this buffer, then we can remove it now.  If it is a
889                  * buffer needing such protection, the old frozen_data
890                  * field now points to a committed version of the
891                  * buffer, so rotate that field to the new committed
892                  * data.
893                  *
894                  * Otherwise, we can just throw away the frozen data now.
895                  *
896                  * We also know that the frozen data has already fired
897                  * its triggers if they exist, so we can clear that too.
898                  */
899                 if (jh->b_committed_data) {
900                         jbd2_free(jh->b_committed_data, bh->b_size);
901                         jh->b_committed_data = NULL;
902                         if (jh->b_frozen_data) {
903                                 jh->b_committed_data = jh->b_frozen_data;
904                                 jh->b_frozen_data = NULL;
905                                 jh->b_frozen_triggers = NULL;
906                         }
907                 } else if (jh->b_frozen_data) {
908                         jbd2_free(jh->b_frozen_data, bh->b_size);
909                         jh->b_frozen_data = NULL;
910                         jh->b_frozen_triggers = NULL;
911                 }
912
913                 spin_lock(&journal->j_list_lock);
914                 cp_transaction = jh->b_cp_transaction;
915                 if (cp_transaction) {
916                         JBUFFER_TRACE(jh, "remove from old cp transaction");
917                         cp_transaction->t_chp_stats.cs_dropped++;
918                         __jbd2_journal_remove_checkpoint(jh);
919                 }
920
921                 /* Only re-checkpoint the buffer_head if it is marked
922                  * dirty.  If the buffer was added to the BJ_Forget list
923                  * by jbd2_journal_forget, it may no longer be dirty and
924                  * there's no point in keeping a checkpoint record for
925                  * it. */
926
927                 /* A buffer which has been freed while still being
928                  * journaled by a previous transaction may end up still
929                  * being dirty here, but we want to avoid writing back
930                  * that buffer in the future now that the last use has
931                  * been committed.  That's not only a performance gain,
932                  * it also stops aliasing problems if the buffer is left
933                  * behind for writeback and gets reallocated for another
934                  * use in a different page. */
935                 if (buffer_freed(bh)) {
936                         clear_buffer_freed(bh);
937                         clear_buffer_jbddirty(bh);
938                 }
939
940                 if (buffer_jbddirty(bh)) {
941                         JBUFFER_TRACE(jh, "add to new checkpointing trans");
942                         __jbd2_journal_insert_checkpoint(jh, commit_transaction);
943                         if (is_journal_aborted(journal))
944                                 clear_buffer_jbddirty(bh);
945                         JBUFFER_TRACE(jh, "refile for checkpoint writeback");
946                         __jbd2_journal_refile_buffer(jh);
947                         jbd_unlock_bh_state(bh);
948                 } else {
949                         J_ASSERT_BH(bh, !buffer_dirty(bh));
950                         /* The buffer on BJ_Forget list and not jbddirty means
951                          * it has been freed by this transaction and hence it
952                          * could not have been reallocated until this
953                          * transaction has committed. *BUT* it could be
954                          * reallocated once we have written all the data to
955                          * disk and before we process the buffer on BJ_Forget
956                          * list. */
957                         JBUFFER_TRACE(jh, "refile or unfile freed buffer");
958                         __jbd2_journal_refile_buffer(jh);
959                         if (!jh->b_transaction) {
960                                 jbd_unlock_bh_state(bh);
961                                  /* needs a brelse */
962                                 jbd2_journal_remove_journal_head(bh);
963                                 release_buffer_page(bh);
964                         } else
965                                 jbd_unlock_bh_state(bh);
966                 }
967                 cond_resched_lock(&journal->j_list_lock);
968         }
969         spin_unlock(&journal->j_list_lock);
970         /*
971          * This is a bit sleazy.  We use j_list_lock to protect transition
972          * of a transaction into T_FINISHED state and calling
973          * __jbd2_journal_drop_transaction(). Otherwise we could race with
974          * other checkpointing code processing the transaction...
975          */
976         spin_lock(&journal->j_state_lock);
977         spin_lock(&journal->j_list_lock);
978         /*
979          * Now recheck if some buffers did not get attached to the transaction
980          * while the lock was dropped...
981          */
982         if (commit_transaction->t_forget) {
983                 spin_unlock(&journal->j_list_lock);
984                 spin_unlock(&journal->j_state_lock);
985                 goto restart_loop;
986         }
987
988         /* Done with this transaction! */
989
990         jbd_debug(3, "JBD: commit phase 7\n");
991
992         J_ASSERT(commit_transaction->t_state == T_COMMIT);
993
994         commit_transaction->t_start = jiffies;
995         stats.run.rs_logging = jbd2_time_diff(stats.run.rs_logging,
996                                               commit_transaction->t_start);
997
998         /*
999          * File the transaction statistics
1000          */
1001         stats.ts_tid = commit_transaction->t_tid;
1002         stats.run.rs_handle_count = commit_transaction->t_handle_count;
1003         trace_jbd2_run_stats(journal->j_fs_dev->bd_dev,
1004                              commit_transaction->t_tid, &stats.run);
1005
1006         /*
1007          * Calculate overall stats
1008          */
1009         spin_lock(&journal->j_history_lock);
1010         journal->j_stats.ts_tid++;
1011         journal->j_stats.run.rs_wait += stats.run.rs_wait;
1012         journal->j_stats.run.rs_running += stats.run.rs_running;
1013         journal->j_stats.run.rs_locked += stats.run.rs_locked;
1014         journal->j_stats.run.rs_flushing += stats.run.rs_flushing;
1015         journal->j_stats.run.rs_logging += stats.run.rs_logging;
1016         journal->j_stats.run.rs_handle_count += stats.run.rs_handle_count;
1017         journal->j_stats.run.rs_blocks += stats.run.rs_blocks;
1018         journal->j_stats.run.rs_blocks_logged += stats.run.rs_blocks_logged;
1019         spin_unlock(&journal->j_history_lock);
1020
1021         commit_transaction->t_state = T_FINISHED;
1022         J_ASSERT(commit_transaction == journal->j_committing_transaction);
1023         journal->j_commit_sequence = commit_transaction->t_tid;
1024         journal->j_committing_transaction = NULL;
1025         commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time));
1026
1027         /*
1028          * weight the commit time higher than the average time so we don't
1029          * react too strongly to vast changes in the commit time
1030          */
1031         if (likely(journal->j_average_commit_time))
1032                 journal->j_average_commit_time = (commit_time +
1033                                 journal->j_average_commit_time*3) / 4;
1034         else
1035                 journal->j_average_commit_time = commit_time;
1036         spin_unlock(&journal->j_state_lock);
1037
1038         if (commit_transaction->t_checkpoint_list == NULL &&
1039             commit_transaction->t_checkpoint_io_list == NULL) {
1040                 __jbd2_journal_drop_transaction(journal, commit_transaction);
1041                 to_free = 1;
1042         } else {
1043                 if (journal->j_checkpoint_transactions == NULL) {
1044                         journal->j_checkpoint_transactions = commit_transaction;
1045                         commit_transaction->t_cpnext = commit_transaction;
1046                         commit_transaction->t_cpprev = commit_transaction;
1047                 } else {
1048                         commit_transaction->t_cpnext =
1049                                 journal->j_checkpoint_transactions;
1050                         commit_transaction->t_cpprev =
1051                                 commit_transaction->t_cpnext->t_cpprev;
1052                         commit_transaction->t_cpnext->t_cpprev =
1053                                 commit_transaction;
1054                         commit_transaction->t_cpprev->t_cpnext =
1055                                 commit_transaction;
1056                 }
1057         }
1058         spin_unlock(&journal->j_list_lock);
1059
1060         if (journal->j_commit_callback)
1061                 journal->j_commit_callback(journal, commit_transaction);
1062
1063         trace_jbd2_end_commit(journal, commit_transaction);
1064         jbd_debug(1, "JBD: commit %d complete, head %d\n",
1065                   journal->j_commit_sequence, journal->j_tail_sequence);
1066         if (to_free)
1067                 kfree(commit_transaction);
1068
1069         wake_up(&journal->j_wait_done_commit);
1070 }