Merge tag 'for-4.1-rc' of git://git.kernel.org/pub/scm/linux/kernel/git/kishon/linux...
[sfrench/cifs-2.6.git] / fs / jbd2 / transaction.c
1 /*
2  * linux/fs/jbd2/transaction.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  * Generic filesystem transaction handling code; part of the ext2fs
13  * journaling system.
14  *
15  * This file manages transactions (compound commits managed by the
16  * journaling code) and handles (individual atomic operations by the
17  * filesystem).
18  */
19
20 #include <linux/time.h>
21 #include <linux/fs.h>
22 #include <linux/jbd2.h>
23 #include <linux/errno.h>
24 #include <linux/slab.h>
25 #include <linux/timer.h>
26 #include <linux/mm.h>
27 #include <linux/highmem.h>
28 #include <linux/hrtimer.h>
29 #include <linux/backing-dev.h>
30 #include <linux/bug.h>
31 #include <linux/module.h>
32
33 #include <trace/events/jbd2.h>
34
35 static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh);
36 static void __jbd2_journal_unfile_buffer(struct journal_head *jh);
37
38 static struct kmem_cache *transaction_cache;
39 int __init jbd2_journal_init_transaction_cache(void)
40 {
41         J_ASSERT(!transaction_cache);
42         transaction_cache = kmem_cache_create("jbd2_transaction_s",
43                                         sizeof(transaction_t),
44                                         0,
45                                         SLAB_HWCACHE_ALIGN|SLAB_TEMPORARY,
46                                         NULL);
47         if (transaction_cache)
48                 return 0;
49         return -ENOMEM;
50 }
51
52 void jbd2_journal_destroy_transaction_cache(void)
53 {
54         if (transaction_cache) {
55                 kmem_cache_destroy(transaction_cache);
56                 transaction_cache = NULL;
57         }
58 }
59
60 void jbd2_journal_free_transaction(transaction_t *transaction)
61 {
62         if (unlikely(ZERO_OR_NULL_PTR(transaction)))
63                 return;
64         kmem_cache_free(transaction_cache, transaction);
65 }
66
67 /*
68  * jbd2_get_transaction: obtain a new transaction_t object.
69  *
70  * Simply allocate and initialise a new transaction.  Create it in
71  * RUNNING state and add it to the current journal (which should not
72  * have an existing running transaction: we only make a new transaction
73  * once we have started to commit the old one).
74  *
75  * Preconditions:
76  *      The journal MUST be locked.  We don't perform atomic mallocs on the
77  *      new transaction and we can't block without protecting against other
78  *      processes trying to touch the journal while it is in transition.
79  *
80  */
81
82 static transaction_t *
83 jbd2_get_transaction(journal_t *journal, transaction_t *transaction)
84 {
85         transaction->t_journal = journal;
86         transaction->t_state = T_RUNNING;
87         transaction->t_start_time = ktime_get();
88         transaction->t_tid = journal->j_transaction_sequence++;
89         transaction->t_expires = jiffies + journal->j_commit_interval;
90         spin_lock_init(&transaction->t_handle_lock);
91         atomic_set(&transaction->t_updates, 0);
92         atomic_set(&transaction->t_outstanding_credits,
93                    atomic_read(&journal->j_reserved_credits));
94         atomic_set(&transaction->t_handle_count, 0);
95         INIT_LIST_HEAD(&transaction->t_inode_list);
96         INIT_LIST_HEAD(&transaction->t_private_list);
97
98         /* Set up the commit timer for the new transaction. */
99         journal->j_commit_timer.expires = round_jiffies_up(transaction->t_expires);
100         add_timer(&journal->j_commit_timer);
101
102         J_ASSERT(journal->j_running_transaction == NULL);
103         journal->j_running_transaction = transaction;
104         transaction->t_max_wait = 0;
105         transaction->t_start = jiffies;
106         transaction->t_requested = 0;
107
108         return transaction;
109 }
110
111 /*
112  * Handle management.
113  *
114  * A handle_t is an object which represents a single atomic update to a
115  * filesystem, and which tracks all of the modifications which form part
116  * of that one update.
117  */
118
119 /*
120  * Update transaction's maximum wait time, if debugging is enabled.
121  *
122  * In order for t_max_wait to be reliable, it must be protected by a
123  * lock.  But doing so will mean that start_this_handle() can not be
124  * run in parallel on SMP systems, which limits our scalability.  So
125  * unless debugging is enabled, we no longer update t_max_wait, which
126  * means that maximum wait time reported by the jbd2_run_stats
127  * tracepoint will always be zero.
128  */
129 static inline void update_t_max_wait(transaction_t *transaction,
130                                      unsigned long ts)
131 {
132 #ifdef CONFIG_JBD2_DEBUG
133         if (jbd2_journal_enable_debug &&
134             time_after(transaction->t_start, ts)) {
135                 ts = jbd2_time_diff(ts, transaction->t_start);
136                 spin_lock(&transaction->t_handle_lock);
137                 if (ts > transaction->t_max_wait)
138                         transaction->t_max_wait = ts;
139                 spin_unlock(&transaction->t_handle_lock);
140         }
141 #endif
142 }
143
144 /*
145  * Wait until running transaction passes T_LOCKED state. Also starts the commit
146  * if needed. The function expects running transaction to exist and releases
147  * j_state_lock.
148  */
149 static void wait_transaction_locked(journal_t *journal)
150         __releases(journal->j_state_lock)
151 {
152         DEFINE_WAIT(wait);
153         int need_to_start;
154         tid_t tid = journal->j_running_transaction->t_tid;
155
156         prepare_to_wait(&journal->j_wait_transaction_locked, &wait,
157                         TASK_UNINTERRUPTIBLE);
158         need_to_start = !tid_geq(journal->j_commit_request, tid);
159         read_unlock(&journal->j_state_lock);
160         if (need_to_start)
161                 jbd2_log_start_commit(journal, tid);
162         schedule();
163         finish_wait(&journal->j_wait_transaction_locked, &wait);
164 }
165
166 static void sub_reserved_credits(journal_t *journal, int blocks)
167 {
168         atomic_sub(blocks, &journal->j_reserved_credits);
169         wake_up(&journal->j_wait_reserved);
170 }
171
172 /*
173  * Wait until we can add credits for handle to the running transaction.  Called
174  * with j_state_lock held for reading. Returns 0 if handle joined the running
175  * transaction. Returns 1 if we had to wait, j_state_lock is dropped, and
176  * caller must retry.
177  */
178 static int add_transaction_credits(journal_t *journal, int blocks,
179                                    int rsv_blocks)
180 {
181         transaction_t *t = journal->j_running_transaction;
182         int needed;
183         int total = blocks + rsv_blocks;
184
185         /*
186          * If the current transaction is locked down for commit, wait
187          * for the lock to be released.
188          */
189         if (t->t_state == T_LOCKED) {
190                 wait_transaction_locked(journal);
191                 return 1;
192         }
193
194         /*
195          * If there is not enough space left in the log to write all
196          * potential buffers requested by this operation, we need to
197          * stall pending a log checkpoint to free some more log space.
198          */
199         needed = atomic_add_return(total, &t->t_outstanding_credits);
200         if (needed > journal->j_max_transaction_buffers) {
201                 /*
202                  * If the current transaction is already too large,
203                  * then start to commit it: we can then go back and
204                  * attach this handle to a new transaction.
205                  */
206                 atomic_sub(total, &t->t_outstanding_credits);
207                 wait_transaction_locked(journal);
208                 return 1;
209         }
210
211         /*
212          * The commit code assumes that it can get enough log space
213          * without forcing a checkpoint.  This is *critical* for
214          * correctness: a checkpoint of a buffer which is also
215          * associated with a committing transaction creates a deadlock,
216          * so commit simply cannot force through checkpoints.
217          *
218          * We must therefore ensure the necessary space in the journal
219          * *before* starting to dirty potentially checkpointed buffers
220          * in the new transaction.
221          */
222         if (jbd2_log_space_left(journal) < jbd2_space_needed(journal)) {
223                 atomic_sub(total, &t->t_outstanding_credits);
224                 read_unlock(&journal->j_state_lock);
225                 write_lock(&journal->j_state_lock);
226                 if (jbd2_log_space_left(journal) < jbd2_space_needed(journal))
227                         __jbd2_log_wait_for_space(journal);
228                 write_unlock(&journal->j_state_lock);
229                 return 1;
230         }
231
232         /* No reservation? We are done... */
233         if (!rsv_blocks)
234                 return 0;
235
236         needed = atomic_add_return(rsv_blocks, &journal->j_reserved_credits);
237         /* We allow at most half of a transaction to be reserved */
238         if (needed > journal->j_max_transaction_buffers / 2) {
239                 sub_reserved_credits(journal, rsv_blocks);
240                 atomic_sub(total, &t->t_outstanding_credits);
241                 read_unlock(&journal->j_state_lock);
242                 wait_event(journal->j_wait_reserved,
243                          atomic_read(&journal->j_reserved_credits) + rsv_blocks
244                          <= journal->j_max_transaction_buffers / 2);
245                 return 1;
246         }
247         return 0;
248 }
249
250 /*
251  * start_this_handle: Given a handle, deal with any locking or stalling
252  * needed to make sure that there is enough journal space for the handle
253  * to begin.  Attach the handle to a transaction and set up the
254  * transaction's buffer credits.
255  */
256
257 static int start_this_handle(journal_t *journal, handle_t *handle,
258                              gfp_t gfp_mask)
259 {
260         transaction_t   *transaction, *new_transaction = NULL;
261         int             blocks = handle->h_buffer_credits;
262         int             rsv_blocks = 0;
263         unsigned long ts = jiffies;
264
265         /*
266          * 1/2 of transaction can be reserved so we can practically handle
267          * only 1/2 of maximum transaction size per operation
268          */
269         if (WARN_ON(blocks > journal->j_max_transaction_buffers / 2)) {
270                 printk(KERN_ERR "JBD2: %s wants too many credits (%d > %d)\n",
271                        current->comm, blocks,
272                        journal->j_max_transaction_buffers / 2);
273                 return -ENOSPC;
274         }
275
276         if (handle->h_rsv_handle)
277                 rsv_blocks = handle->h_rsv_handle->h_buffer_credits;
278
279 alloc_transaction:
280         if (!journal->j_running_transaction) {
281                 new_transaction = kmem_cache_zalloc(transaction_cache,
282                                                     gfp_mask);
283                 if (!new_transaction) {
284                         /*
285                          * If __GFP_FS is not present, then we may be
286                          * being called from inside the fs writeback
287                          * layer, so we MUST NOT fail.  Since
288                          * __GFP_NOFAIL is going away, we will arrange
289                          * to retry the allocation ourselves.
290                          */
291                         if ((gfp_mask & __GFP_FS) == 0) {
292                                 congestion_wait(BLK_RW_ASYNC, HZ/50);
293                                 goto alloc_transaction;
294                         }
295                         return -ENOMEM;
296                 }
297         }
298
299         jbd_debug(3, "New handle %p going live.\n", handle);
300
301         /*
302          * We need to hold j_state_lock until t_updates has been incremented,
303          * for proper journal barrier handling
304          */
305 repeat:
306         read_lock(&journal->j_state_lock);
307         BUG_ON(journal->j_flags & JBD2_UNMOUNT);
308         if (is_journal_aborted(journal) ||
309             (journal->j_errno != 0 && !(journal->j_flags & JBD2_ACK_ERR))) {
310                 read_unlock(&journal->j_state_lock);
311                 jbd2_journal_free_transaction(new_transaction);
312                 return -EROFS;
313         }
314
315         /*
316          * Wait on the journal's transaction barrier if necessary. Specifically
317          * we allow reserved handles to proceed because otherwise commit could
318          * deadlock on page writeback not being able to complete.
319          */
320         if (!handle->h_reserved && journal->j_barrier_count) {
321                 read_unlock(&journal->j_state_lock);
322                 wait_event(journal->j_wait_transaction_locked,
323                                 journal->j_barrier_count == 0);
324                 goto repeat;
325         }
326
327         if (!journal->j_running_transaction) {
328                 read_unlock(&journal->j_state_lock);
329                 if (!new_transaction)
330                         goto alloc_transaction;
331                 write_lock(&journal->j_state_lock);
332                 if (!journal->j_running_transaction &&
333                     (handle->h_reserved || !journal->j_barrier_count)) {
334                         jbd2_get_transaction(journal, new_transaction);
335                         new_transaction = NULL;
336                 }
337                 write_unlock(&journal->j_state_lock);
338                 goto repeat;
339         }
340
341         transaction = journal->j_running_transaction;
342
343         if (!handle->h_reserved) {
344                 /* We may have dropped j_state_lock - restart in that case */
345                 if (add_transaction_credits(journal, blocks, rsv_blocks))
346                         goto repeat;
347         } else {
348                 /*
349                  * We have handle reserved so we are allowed to join T_LOCKED
350                  * transaction and we don't have to check for transaction size
351                  * and journal space.
352                  */
353                 sub_reserved_credits(journal, blocks);
354                 handle->h_reserved = 0;
355         }
356
357         /* OK, account for the buffers that this operation expects to
358          * use and add the handle to the running transaction. 
359          */
360         update_t_max_wait(transaction, ts);
361         handle->h_transaction = transaction;
362         handle->h_requested_credits = blocks;
363         handle->h_start_jiffies = jiffies;
364         atomic_inc(&transaction->t_updates);
365         atomic_inc(&transaction->t_handle_count);
366         jbd_debug(4, "Handle %p given %d credits (total %d, free %lu)\n",
367                   handle, blocks,
368                   atomic_read(&transaction->t_outstanding_credits),
369                   jbd2_log_space_left(journal));
370         read_unlock(&journal->j_state_lock);
371         current->journal_info = handle;
372
373         lock_map_acquire(&handle->h_lockdep_map);
374         jbd2_journal_free_transaction(new_transaction);
375         return 0;
376 }
377
378 static struct lock_class_key jbd2_handle_key;
379
380 /* Allocate a new handle.  This should probably be in a slab... */
381 static handle_t *new_handle(int nblocks)
382 {
383         handle_t *handle = jbd2_alloc_handle(GFP_NOFS);
384         if (!handle)
385                 return NULL;
386         handle->h_buffer_credits = nblocks;
387         handle->h_ref = 1;
388
389         lockdep_init_map(&handle->h_lockdep_map, "jbd2_handle",
390                                                 &jbd2_handle_key, 0);
391
392         return handle;
393 }
394
395 /**
396  * handle_t *jbd2_journal_start() - Obtain a new handle.
397  * @journal: Journal to start transaction on.
398  * @nblocks: number of block buffer we might modify
399  *
400  * We make sure that the transaction can guarantee at least nblocks of
401  * modified buffers in the log.  We block until the log can guarantee
402  * that much space. Additionally, if rsv_blocks > 0, we also create another
403  * handle with rsv_blocks reserved blocks in the journal. This handle is
404  * is stored in h_rsv_handle. It is not attached to any particular transaction
405  * and thus doesn't block transaction commit. If the caller uses this reserved
406  * handle, it has to set h_rsv_handle to NULL as otherwise jbd2_journal_stop()
407  * on the parent handle will dispose the reserved one. Reserved handle has to
408  * be converted to a normal handle using jbd2_journal_start_reserved() before
409  * it can be used.
410  *
411  * Return a pointer to a newly allocated handle, or an ERR_PTR() value
412  * on failure.
413  */
414 handle_t *jbd2__journal_start(journal_t *journal, int nblocks, int rsv_blocks,
415                               gfp_t gfp_mask, unsigned int type,
416                               unsigned int line_no)
417 {
418         handle_t *handle = journal_current_handle();
419         int err;
420
421         if (!journal)
422                 return ERR_PTR(-EROFS);
423
424         if (handle) {
425                 J_ASSERT(handle->h_transaction->t_journal == journal);
426                 handle->h_ref++;
427                 return handle;
428         }
429
430         handle = new_handle(nblocks);
431         if (!handle)
432                 return ERR_PTR(-ENOMEM);
433         if (rsv_blocks) {
434                 handle_t *rsv_handle;
435
436                 rsv_handle = new_handle(rsv_blocks);
437                 if (!rsv_handle) {
438                         jbd2_free_handle(handle);
439                         return ERR_PTR(-ENOMEM);
440                 }
441                 rsv_handle->h_reserved = 1;
442                 rsv_handle->h_journal = journal;
443                 handle->h_rsv_handle = rsv_handle;
444         }
445
446         err = start_this_handle(journal, handle, gfp_mask);
447         if (err < 0) {
448                 if (handle->h_rsv_handle)
449                         jbd2_free_handle(handle->h_rsv_handle);
450                 jbd2_free_handle(handle);
451                 return ERR_PTR(err);
452         }
453         handle->h_type = type;
454         handle->h_line_no = line_no;
455         trace_jbd2_handle_start(journal->j_fs_dev->bd_dev,
456                                 handle->h_transaction->t_tid, type,
457                                 line_no, nblocks);
458         return handle;
459 }
460 EXPORT_SYMBOL(jbd2__journal_start);
461
462
463 handle_t *jbd2_journal_start(journal_t *journal, int nblocks)
464 {
465         return jbd2__journal_start(journal, nblocks, 0, GFP_NOFS, 0, 0);
466 }
467 EXPORT_SYMBOL(jbd2_journal_start);
468
469 void jbd2_journal_free_reserved(handle_t *handle)
470 {
471         journal_t *journal = handle->h_journal;
472
473         WARN_ON(!handle->h_reserved);
474         sub_reserved_credits(journal, handle->h_buffer_credits);
475         jbd2_free_handle(handle);
476 }
477 EXPORT_SYMBOL(jbd2_journal_free_reserved);
478
479 /**
480  * int jbd2_journal_start_reserved(handle_t *handle) - start reserved handle
481  * @handle: handle to start
482  *
483  * Start handle that has been previously reserved with jbd2_journal_reserve().
484  * This attaches @handle to the running transaction (or creates one if there's
485  * not transaction running). Unlike jbd2_journal_start() this function cannot
486  * block on journal commit, checkpointing, or similar stuff. It can block on
487  * memory allocation or frozen journal though.
488  *
489  * Return 0 on success, non-zero on error - handle is freed in that case.
490  */
491 int jbd2_journal_start_reserved(handle_t *handle, unsigned int type,
492                                 unsigned int line_no)
493 {
494         journal_t *journal = handle->h_journal;
495         int ret = -EIO;
496
497         if (WARN_ON(!handle->h_reserved)) {
498                 /* Someone passed in normal handle? Just stop it. */
499                 jbd2_journal_stop(handle);
500                 return ret;
501         }
502         /*
503          * Usefulness of mixing of reserved and unreserved handles is
504          * questionable. So far nobody seems to need it so just error out.
505          */
506         if (WARN_ON(current->journal_info)) {
507                 jbd2_journal_free_reserved(handle);
508                 return ret;
509         }
510
511         handle->h_journal = NULL;
512         /*
513          * GFP_NOFS is here because callers are likely from writeback or
514          * similarly constrained call sites
515          */
516         ret = start_this_handle(journal, handle, GFP_NOFS);
517         if (ret < 0) {
518                 jbd2_journal_free_reserved(handle);
519                 return ret;
520         }
521         handle->h_type = type;
522         handle->h_line_no = line_no;
523         return 0;
524 }
525 EXPORT_SYMBOL(jbd2_journal_start_reserved);
526
527 /**
528  * int jbd2_journal_extend() - extend buffer credits.
529  * @handle:  handle to 'extend'
530  * @nblocks: nr blocks to try to extend by.
531  *
532  * Some transactions, such as large extends and truncates, can be done
533  * atomically all at once or in several stages.  The operation requests
534  * a credit for a number of buffer modications in advance, but can
535  * extend its credit if it needs more.
536  *
537  * jbd2_journal_extend tries to give the running handle more buffer credits.
538  * It does not guarantee that allocation - this is a best-effort only.
539  * The calling process MUST be able to deal cleanly with a failure to
540  * extend here.
541  *
542  * Return 0 on success, non-zero on failure.
543  *
544  * return code < 0 implies an error
545  * return code > 0 implies normal transaction-full status.
546  */
547 int jbd2_journal_extend(handle_t *handle, int nblocks)
548 {
549         transaction_t *transaction = handle->h_transaction;
550         journal_t *journal;
551         int result;
552         int wanted;
553
554         if (is_handle_aborted(handle))
555                 return -EROFS;
556         journal = transaction->t_journal;
557
558         result = 1;
559
560         read_lock(&journal->j_state_lock);
561
562         /* Don't extend a locked-down transaction! */
563         if (transaction->t_state != T_RUNNING) {
564                 jbd_debug(3, "denied handle %p %d blocks: "
565                           "transaction not running\n", handle, nblocks);
566                 goto error_out;
567         }
568
569         spin_lock(&transaction->t_handle_lock);
570         wanted = atomic_add_return(nblocks,
571                                    &transaction->t_outstanding_credits);
572
573         if (wanted > journal->j_max_transaction_buffers) {
574                 jbd_debug(3, "denied handle %p %d blocks: "
575                           "transaction too large\n", handle, nblocks);
576                 atomic_sub(nblocks, &transaction->t_outstanding_credits);
577                 goto unlock;
578         }
579
580         if (wanted + (wanted >> JBD2_CONTROL_BLOCKS_SHIFT) >
581             jbd2_log_space_left(journal)) {
582                 jbd_debug(3, "denied handle %p %d blocks: "
583                           "insufficient log space\n", handle, nblocks);
584                 atomic_sub(nblocks, &transaction->t_outstanding_credits);
585                 goto unlock;
586         }
587
588         trace_jbd2_handle_extend(journal->j_fs_dev->bd_dev,
589                                  transaction->t_tid,
590                                  handle->h_type, handle->h_line_no,
591                                  handle->h_buffer_credits,
592                                  nblocks);
593
594         handle->h_buffer_credits += nblocks;
595         handle->h_requested_credits += nblocks;
596         result = 0;
597
598         jbd_debug(3, "extended handle %p by %d\n", handle, nblocks);
599 unlock:
600         spin_unlock(&transaction->t_handle_lock);
601 error_out:
602         read_unlock(&journal->j_state_lock);
603         return result;
604 }
605
606
607 /**
608  * int jbd2_journal_restart() - restart a handle .
609  * @handle:  handle to restart
610  * @nblocks: nr credits requested
611  *
612  * Restart a handle for a multi-transaction filesystem
613  * operation.
614  *
615  * If the jbd2_journal_extend() call above fails to grant new buffer credits
616  * to a running handle, a call to jbd2_journal_restart will commit the
617  * handle's transaction so far and reattach the handle to a new
618  * transaction capabable of guaranteeing the requested number of
619  * credits. We preserve reserved handle if there's any attached to the
620  * passed in handle.
621  */
622 int jbd2__journal_restart(handle_t *handle, int nblocks, gfp_t gfp_mask)
623 {
624         transaction_t *transaction = handle->h_transaction;
625         journal_t *journal;
626         tid_t           tid;
627         int             need_to_start, ret;
628
629         /* If we've had an abort of any type, don't even think about
630          * actually doing the restart! */
631         if (is_handle_aborted(handle))
632                 return 0;
633         journal = transaction->t_journal;
634
635         /*
636          * First unlink the handle from its current transaction, and start the
637          * commit on that.
638          */
639         J_ASSERT(atomic_read(&transaction->t_updates) > 0);
640         J_ASSERT(journal_current_handle() == handle);
641
642         read_lock(&journal->j_state_lock);
643         spin_lock(&transaction->t_handle_lock);
644         atomic_sub(handle->h_buffer_credits,
645                    &transaction->t_outstanding_credits);
646         if (handle->h_rsv_handle) {
647                 sub_reserved_credits(journal,
648                                      handle->h_rsv_handle->h_buffer_credits);
649         }
650         if (atomic_dec_and_test(&transaction->t_updates))
651                 wake_up(&journal->j_wait_updates);
652         tid = transaction->t_tid;
653         spin_unlock(&transaction->t_handle_lock);
654         handle->h_transaction = NULL;
655         current->journal_info = NULL;
656
657         jbd_debug(2, "restarting handle %p\n", handle);
658         need_to_start = !tid_geq(journal->j_commit_request, tid);
659         read_unlock(&journal->j_state_lock);
660         if (need_to_start)
661                 jbd2_log_start_commit(journal, tid);
662
663         lock_map_release(&handle->h_lockdep_map);
664         handle->h_buffer_credits = nblocks;
665         ret = start_this_handle(journal, handle, gfp_mask);
666         return ret;
667 }
668 EXPORT_SYMBOL(jbd2__journal_restart);
669
670
671 int jbd2_journal_restart(handle_t *handle, int nblocks)
672 {
673         return jbd2__journal_restart(handle, nblocks, GFP_NOFS);
674 }
675 EXPORT_SYMBOL(jbd2_journal_restart);
676
677 /**
678  * void jbd2_journal_lock_updates () - establish a transaction barrier.
679  * @journal:  Journal to establish a barrier on.
680  *
681  * This locks out any further updates from being started, and blocks
682  * until all existing updates have completed, returning only once the
683  * journal is in a quiescent state with no updates running.
684  *
685  * The journal lock should not be held on entry.
686  */
687 void jbd2_journal_lock_updates(journal_t *journal)
688 {
689         DEFINE_WAIT(wait);
690
691         write_lock(&journal->j_state_lock);
692         ++journal->j_barrier_count;
693
694         /* Wait until there are no reserved handles */
695         if (atomic_read(&journal->j_reserved_credits)) {
696                 write_unlock(&journal->j_state_lock);
697                 wait_event(journal->j_wait_reserved,
698                            atomic_read(&journal->j_reserved_credits) == 0);
699                 write_lock(&journal->j_state_lock);
700         }
701
702         /* Wait until there are no running updates */
703         while (1) {
704                 transaction_t *transaction = journal->j_running_transaction;
705
706                 if (!transaction)
707                         break;
708
709                 spin_lock(&transaction->t_handle_lock);
710                 prepare_to_wait(&journal->j_wait_updates, &wait,
711                                 TASK_UNINTERRUPTIBLE);
712                 if (!atomic_read(&transaction->t_updates)) {
713                         spin_unlock(&transaction->t_handle_lock);
714                         finish_wait(&journal->j_wait_updates, &wait);
715                         break;
716                 }
717                 spin_unlock(&transaction->t_handle_lock);
718                 write_unlock(&journal->j_state_lock);
719                 schedule();
720                 finish_wait(&journal->j_wait_updates, &wait);
721                 write_lock(&journal->j_state_lock);
722         }
723         write_unlock(&journal->j_state_lock);
724
725         /*
726          * We have now established a barrier against other normal updates, but
727          * we also need to barrier against other jbd2_journal_lock_updates() calls
728          * to make sure that we serialise special journal-locked operations
729          * too.
730          */
731         mutex_lock(&journal->j_barrier);
732 }
733
734 /**
735  * void jbd2_journal_unlock_updates (journal_t* journal) - release barrier
736  * @journal:  Journal to release the barrier on.
737  *
738  * Release a transaction barrier obtained with jbd2_journal_lock_updates().
739  *
740  * Should be called without the journal lock held.
741  */
742 void jbd2_journal_unlock_updates (journal_t *journal)
743 {
744         J_ASSERT(journal->j_barrier_count != 0);
745
746         mutex_unlock(&journal->j_barrier);
747         write_lock(&journal->j_state_lock);
748         --journal->j_barrier_count;
749         write_unlock(&journal->j_state_lock);
750         wake_up(&journal->j_wait_transaction_locked);
751 }
752
753 static void warn_dirty_buffer(struct buffer_head *bh)
754 {
755         char b[BDEVNAME_SIZE];
756
757         printk(KERN_WARNING
758                "JBD2: Spotted dirty metadata buffer (dev = %s, blocknr = %llu). "
759                "There's a risk of filesystem corruption in case of system "
760                "crash.\n",
761                bdevname(bh->b_bdev, b), (unsigned long long)bh->b_blocknr);
762 }
763
764 /*
765  * If the buffer is already part of the current transaction, then there
766  * is nothing we need to do.  If it is already part of a prior
767  * transaction which we are still committing to disk, then we need to
768  * make sure that we do not overwrite the old copy: we do copy-out to
769  * preserve the copy going to disk.  We also account the buffer against
770  * the handle's metadata buffer credits (unless the buffer is already
771  * part of the transaction, that is).
772  *
773  */
774 static int
775 do_get_write_access(handle_t *handle, struct journal_head *jh,
776                         int force_copy)
777 {
778         struct buffer_head *bh;
779         transaction_t *transaction = handle->h_transaction;
780         journal_t *journal;
781         int error;
782         char *frozen_buffer = NULL;
783         int need_copy = 0;
784         unsigned long start_lock, time_lock;
785
786         if (is_handle_aborted(handle))
787                 return -EROFS;
788         journal = transaction->t_journal;
789
790         jbd_debug(5, "journal_head %p, force_copy %d\n", jh, force_copy);
791
792         JBUFFER_TRACE(jh, "entry");
793 repeat:
794         bh = jh2bh(jh);
795
796         /* @@@ Need to check for errors here at some point. */
797
798         start_lock = jiffies;
799         lock_buffer(bh);
800         jbd_lock_bh_state(bh);
801
802         /* If it takes too long to lock the buffer, trace it */
803         time_lock = jbd2_time_diff(start_lock, jiffies);
804         if (time_lock > HZ/10)
805                 trace_jbd2_lock_buffer_stall(bh->b_bdev->bd_dev,
806                         jiffies_to_msecs(time_lock));
807
808         /* We now hold the buffer lock so it is safe to query the buffer
809          * state.  Is the buffer dirty?
810          *
811          * If so, there are two possibilities.  The buffer may be
812          * non-journaled, and undergoing a quite legitimate writeback.
813          * Otherwise, it is journaled, and we don't expect dirty buffers
814          * in that state (the buffers should be marked JBD_Dirty
815          * instead.)  So either the IO is being done under our own
816          * control and this is a bug, or it's a third party IO such as
817          * dump(8) (which may leave the buffer scheduled for read ---
818          * ie. locked but not dirty) or tune2fs (which may actually have
819          * the buffer dirtied, ugh.)  */
820
821         if (buffer_dirty(bh)) {
822                 /*
823                  * First question: is this buffer already part of the current
824                  * transaction or the existing committing transaction?
825                  */
826                 if (jh->b_transaction) {
827                         J_ASSERT_JH(jh,
828                                 jh->b_transaction == transaction ||
829                                 jh->b_transaction ==
830                                         journal->j_committing_transaction);
831                         if (jh->b_next_transaction)
832                                 J_ASSERT_JH(jh, jh->b_next_transaction ==
833                                                         transaction);
834                         warn_dirty_buffer(bh);
835                 }
836                 /*
837                  * In any case we need to clean the dirty flag and we must
838                  * do it under the buffer lock to be sure we don't race
839                  * with running write-out.
840                  */
841                 JBUFFER_TRACE(jh, "Journalling dirty buffer");
842                 clear_buffer_dirty(bh);
843                 set_buffer_jbddirty(bh);
844         }
845
846         unlock_buffer(bh);
847
848         error = -EROFS;
849         if (is_handle_aborted(handle)) {
850                 jbd_unlock_bh_state(bh);
851                 goto out;
852         }
853         error = 0;
854
855         /*
856          * The buffer is already part of this transaction if b_transaction or
857          * b_next_transaction points to it
858          */
859         if (jh->b_transaction == transaction ||
860             jh->b_next_transaction == transaction)
861                 goto done;
862
863         /*
864          * this is the first time this transaction is touching this buffer,
865          * reset the modified flag
866          */
867        jh->b_modified = 0;
868
869         /*
870          * If there is already a copy-out version of this buffer, then we don't
871          * need to make another one
872          */
873         if (jh->b_frozen_data) {
874                 JBUFFER_TRACE(jh, "has frozen data");
875                 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
876                 jh->b_next_transaction = transaction;
877                 goto done;
878         }
879
880         /* Is there data here we need to preserve? */
881
882         if (jh->b_transaction && jh->b_transaction != transaction) {
883                 JBUFFER_TRACE(jh, "owned by older transaction");
884                 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
885                 J_ASSERT_JH(jh, jh->b_transaction ==
886                                         journal->j_committing_transaction);
887
888                 /* There is one case we have to be very careful about.
889                  * If the committing transaction is currently writing
890                  * this buffer out to disk and has NOT made a copy-out,
891                  * then we cannot modify the buffer contents at all
892                  * right now.  The essence of copy-out is that it is the
893                  * extra copy, not the primary copy, which gets
894                  * journaled.  If the primary copy is already going to
895                  * disk then we cannot do copy-out here. */
896
897                 if (buffer_shadow(bh)) {
898                         JBUFFER_TRACE(jh, "on shadow: sleep");
899                         jbd_unlock_bh_state(bh);
900                         wait_on_bit_io(&bh->b_state, BH_Shadow,
901                                        TASK_UNINTERRUPTIBLE);
902                         goto repeat;
903                 }
904
905                 /*
906                  * Only do the copy if the currently-owning transaction still
907                  * needs it. If buffer isn't on BJ_Metadata list, the
908                  * committing transaction is past that stage (here we use the
909                  * fact that BH_Shadow is set under bh_state lock together with
910                  * refiling to BJ_Shadow list and at this point we know the
911                  * buffer doesn't have BH_Shadow set).
912                  *
913                  * Subtle point, though: if this is a get_undo_access,
914                  * then we will be relying on the frozen_data to contain
915                  * the new value of the committed_data record after the
916                  * transaction, so we HAVE to force the frozen_data copy
917                  * in that case.
918                  */
919                 if (jh->b_jlist == BJ_Metadata || force_copy) {
920                         JBUFFER_TRACE(jh, "generate frozen data");
921                         if (!frozen_buffer) {
922                                 JBUFFER_TRACE(jh, "allocate memory for buffer");
923                                 jbd_unlock_bh_state(bh);
924                                 frozen_buffer =
925                                         jbd2_alloc(jh2bh(jh)->b_size,
926                                                          GFP_NOFS);
927                                 if (!frozen_buffer) {
928                                         printk(KERN_ERR
929                                                "%s: OOM for frozen_buffer\n",
930                                                __func__);
931                                         JBUFFER_TRACE(jh, "oom!");
932                                         error = -ENOMEM;
933                                         jbd_lock_bh_state(bh);
934                                         goto done;
935                                 }
936                                 goto repeat;
937                         }
938                         jh->b_frozen_data = frozen_buffer;
939                         frozen_buffer = NULL;
940                         need_copy = 1;
941                 }
942                 jh->b_next_transaction = transaction;
943         }
944
945
946         /*
947          * Finally, if the buffer is not journaled right now, we need to make
948          * sure it doesn't get written to disk before the caller actually
949          * commits the new data
950          */
951         if (!jh->b_transaction) {
952                 JBUFFER_TRACE(jh, "no transaction");
953                 J_ASSERT_JH(jh, !jh->b_next_transaction);
954                 JBUFFER_TRACE(jh, "file as BJ_Reserved");
955                 spin_lock(&journal->j_list_lock);
956                 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
957                 spin_unlock(&journal->j_list_lock);
958         }
959
960 done:
961         if (need_copy) {
962                 struct page *page;
963                 int offset;
964                 char *source;
965
966                 J_EXPECT_JH(jh, buffer_uptodate(jh2bh(jh)),
967                             "Possible IO failure.\n");
968                 page = jh2bh(jh)->b_page;
969                 offset = offset_in_page(jh2bh(jh)->b_data);
970                 source = kmap_atomic(page);
971                 /* Fire data frozen trigger just before we copy the data */
972                 jbd2_buffer_frozen_trigger(jh, source + offset,
973                                            jh->b_triggers);
974                 memcpy(jh->b_frozen_data, source+offset, jh2bh(jh)->b_size);
975                 kunmap_atomic(source);
976
977                 /*
978                  * Now that the frozen data is saved off, we need to store
979                  * any matching triggers.
980                  */
981                 jh->b_frozen_triggers = jh->b_triggers;
982         }
983         jbd_unlock_bh_state(bh);
984
985         /*
986          * If we are about to journal a buffer, then any revoke pending on it is
987          * no longer valid
988          */
989         jbd2_journal_cancel_revoke(handle, jh);
990
991 out:
992         if (unlikely(frozen_buffer))    /* It's usually NULL */
993                 jbd2_free(frozen_buffer, bh->b_size);
994
995         JBUFFER_TRACE(jh, "exit");
996         return error;
997 }
998
999 /**
1000  * int jbd2_journal_get_write_access() - notify intent to modify a buffer for metadata (not data) update.
1001  * @handle: transaction to add buffer modifications to
1002  * @bh:     bh to be used for metadata writes
1003  *
1004  * Returns an error code or 0 on success.
1005  *
1006  * In full data journalling mode the buffer may be of type BJ_AsyncData,
1007  * because we're write()ing a buffer which is also part of a shared mapping.
1008  */
1009
1010 int jbd2_journal_get_write_access(handle_t *handle, struct buffer_head *bh)
1011 {
1012         struct journal_head *jh = jbd2_journal_add_journal_head(bh);
1013         int rc;
1014
1015         /* We do not want to get caught playing with fields which the
1016          * log thread also manipulates.  Make sure that the buffer
1017          * completes any outstanding IO before proceeding. */
1018         rc = do_get_write_access(handle, jh, 0);
1019         jbd2_journal_put_journal_head(jh);
1020         return rc;
1021 }
1022
1023
1024 /*
1025  * When the user wants to journal a newly created buffer_head
1026  * (ie. getblk() returned a new buffer and we are going to populate it
1027  * manually rather than reading off disk), then we need to keep the
1028  * buffer_head locked until it has been completely filled with new
1029  * data.  In this case, we should be able to make the assertion that
1030  * the bh is not already part of an existing transaction.
1031  *
1032  * The buffer should already be locked by the caller by this point.
1033  * There is no lock ranking violation: it was a newly created,
1034  * unlocked buffer beforehand. */
1035
1036 /**
1037  * int jbd2_journal_get_create_access () - notify intent to use newly created bh
1038  * @handle: transaction to new buffer to
1039  * @bh: new buffer.
1040  *
1041  * Call this if you create a new bh.
1042  */
1043 int jbd2_journal_get_create_access(handle_t *handle, struct buffer_head *bh)
1044 {
1045         transaction_t *transaction = handle->h_transaction;
1046         journal_t *journal;
1047         struct journal_head *jh = jbd2_journal_add_journal_head(bh);
1048         int err;
1049
1050         jbd_debug(5, "journal_head %p\n", jh);
1051         err = -EROFS;
1052         if (is_handle_aborted(handle))
1053                 goto out;
1054         journal = transaction->t_journal;
1055         err = 0;
1056
1057         JBUFFER_TRACE(jh, "entry");
1058         /*
1059          * The buffer may already belong to this transaction due to pre-zeroing
1060          * in the filesystem's new_block code.  It may also be on the previous,
1061          * committing transaction's lists, but it HAS to be in Forget state in
1062          * that case: the transaction must have deleted the buffer for it to be
1063          * reused here.
1064          */
1065         jbd_lock_bh_state(bh);
1066         J_ASSERT_JH(jh, (jh->b_transaction == transaction ||
1067                 jh->b_transaction == NULL ||
1068                 (jh->b_transaction == journal->j_committing_transaction &&
1069                           jh->b_jlist == BJ_Forget)));
1070
1071         J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
1072         J_ASSERT_JH(jh, buffer_locked(jh2bh(jh)));
1073
1074         if (jh->b_transaction == NULL) {
1075                 /*
1076                  * Previous jbd2_journal_forget() could have left the buffer
1077                  * with jbddirty bit set because it was being committed. When
1078                  * the commit finished, we've filed the buffer for
1079                  * checkpointing and marked it dirty. Now we are reallocating
1080                  * the buffer so the transaction freeing it must have
1081                  * committed and so it's safe to clear the dirty bit.
1082                  */
1083                 clear_buffer_dirty(jh2bh(jh));
1084                 /* first access by this transaction */
1085                 jh->b_modified = 0;
1086
1087                 JBUFFER_TRACE(jh, "file as BJ_Reserved");
1088                 spin_lock(&journal->j_list_lock);
1089                 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
1090         } else if (jh->b_transaction == journal->j_committing_transaction) {
1091                 /* first access by this transaction */
1092                 jh->b_modified = 0;
1093
1094                 JBUFFER_TRACE(jh, "set next transaction");
1095                 spin_lock(&journal->j_list_lock);
1096                 jh->b_next_transaction = transaction;
1097         }
1098         spin_unlock(&journal->j_list_lock);
1099         jbd_unlock_bh_state(bh);
1100
1101         /*
1102          * akpm: I added this.  ext3_alloc_branch can pick up new indirect
1103          * blocks which contain freed but then revoked metadata.  We need
1104          * to cancel the revoke in case we end up freeing it yet again
1105          * and the reallocating as data - this would cause a second revoke,
1106          * which hits an assertion error.
1107          */
1108         JBUFFER_TRACE(jh, "cancelling revoke");
1109         jbd2_journal_cancel_revoke(handle, jh);
1110 out:
1111         jbd2_journal_put_journal_head(jh);
1112         return err;
1113 }
1114
1115 /**
1116  * int jbd2_journal_get_undo_access() -  Notify intent to modify metadata with
1117  *     non-rewindable consequences
1118  * @handle: transaction
1119  * @bh: buffer to undo
1120  *
1121  * Sometimes there is a need to distinguish between metadata which has
1122  * been committed to disk and that which has not.  The ext3fs code uses
1123  * this for freeing and allocating space, we have to make sure that we
1124  * do not reuse freed space until the deallocation has been committed,
1125  * since if we overwrote that space we would make the delete
1126  * un-rewindable in case of a crash.
1127  *
1128  * To deal with that, jbd2_journal_get_undo_access requests write access to a
1129  * buffer for parts of non-rewindable operations such as delete
1130  * operations on the bitmaps.  The journaling code must keep a copy of
1131  * the buffer's contents prior to the undo_access call until such time
1132  * as we know that the buffer has definitely been committed to disk.
1133  *
1134  * We never need to know which transaction the committed data is part
1135  * of, buffers touched here are guaranteed to be dirtied later and so
1136  * will be committed to a new transaction in due course, at which point
1137  * we can discard the old committed data pointer.
1138  *
1139  * Returns error number or 0 on success.
1140  */
1141 int jbd2_journal_get_undo_access(handle_t *handle, struct buffer_head *bh)
1142 {
1143         int err;
1144         struct journal_head *jh = jbd2_journal_add_journal_head(bh);
1145         char *committed_data = NULL;
1146
1147         JBUFFER_TRACE(jh, "entry");
1148
1149         /*
1150          * Do this first --- it can drop the journal lock, so we want to
1151          * make sure that obtaining the committed_data is done
1152          * atomically wrt. completion of any outstanding commits.
1153          */
1154         err = do_get_write_access(handle, jh, 1);
1155         if (err)
1156                 goto out;
1157
1158 repeat:
1159         if (!jh->b_committed_data) {
1160                 committed_data = jbd2_alloc(jh2bh(jh)->b_size, GFP_NOFS);
1161                 if (!committed_data) {
1162                         printk(KERN_ERR "%s: No memory for committed data\n",
1163                                 __func__);
1164                         err = -ENOMEM;
1165                         goto out;
1166                 }
1167         }
1168
1169         jbd_lock_bh_state(bh);
1170         if (!jh->b_committed_data) {
1171                 /* Copy out the current buffer contents into the
1172                  * preserved, committed copy. */
1173                 JBUFFER_TRACE(jh, "generate b_committed data");
1174                 if (!committed_data) {
1175                         jbd_unlock_bh_state(bh);
1176                         goto repeat;
1177                 }
1178
1179                 jh->b_committed_data = committed_data;
1180                 committed_data = NULL;
1181                 memcpy(jh->b_committed_data, bh->b_data, bh->b_size);
1182         }
1183         jbd_unlock_bh_state(bh);
1184 out:
1185         jbd2_journal_put_journal_head(jh);
1186         if (unlikely(committed_data))
1187                 jbd2_free(committed_data, bh->b_size);
1188         return err;
1189 }
1190
1191 /**
1192  * void jbd2_journal_set_triggers() - Add triggers for commit writeout
1193  * @bh: buffer to trigger on
1194  * @type: struct jbd2_buffer_trigger_type containing the trigger(s).
1195  *
1196  * Set any triggers on this journal_head.  This is always safe, because
1197  * triggers for a committing buffer will be saved off, and triggers for
1198  * a running transaction will match the buffer in that transaction.
1199  *
1200  * Call with NULL to clear the triggers.
1201  */
1202 void jbd2_journal_set_triggers(struct buffer_head *bh,
1203                                struct jbd2_buffer_trigger_type *type)
1204 {
1205         struct journal_head *jh = jbd2_journal_grab_journal_head(bh);
1206
1207         if (WARN_ON(!jh))
1208                 return;
1209         jh->b_triggers = type;
1210         jbd2_journal_put_journal_head(jh);
1211 }
1212
1213 void jbd2_buffer_frozen_trigger(struct journal_head *jh, void *mapped_data,
1214                                 struct jbd2_buffer_trigger_type *triggers)
1215 {
1216         struct buffer_head *bh = jh2bh(jh);
1217
1218         if (!triggers || !triggers->t_frozen)
1219                 return;
1220
1221         triggers->t_frozen(triggers, bh, mapped_data, bh->b_size);
1222 }
1223
1224 void jbd2_buffer_abort_trigger(struct journal_head *jh,
1225                                struct jbd2_buffer_trigger_type *triggers)
1226 {
1227         if (!triggers || !triggers->t_abort)
1228                 return;
1229
1230         triggers->t_abort(triggers, jh2bh(jh));
1231 }
1232
1233
1234
1235 /**
1236  * int jbd2_journal_dirty_metadata() -  mark a buffer as containing dirty metadata
1237  * @handle: transaction to add buffer to.
1238  * @bh: buffer to mark
1239  *
1240  * mark dirty metadata which needs to be journaled as part of the current
1241  * transaction.
1242  *
1243  * The buffer must have previously had jbd2_journal_get_write_access()
1244  * called so that it has a valid journal_head attached to the buffer
1245  * head.
1246  *
1247  * The buffer is placed on the transaction's metadata list and is marked
1248  * as belonging to the transaction.
1249  *
1250  * Returns error number or 0 on success.
1251  *
1252  * Special care needs to be taken if the buffer already belongs to the
1253  * current committing transaction (in which case we should have frozen
1254  * data present for that commit).  In that case, we don't relink the
1255  * buffer: that only gets done when the old transaction finally
1256  * completes its commit.
1257  */
1258 int jbd2_journal_dirty_metadata(handle_t *handle, struct buffer_head *bh)
1259 {
1260         transaction_t *transaction = handle->h_transaction;
1261         journal_t *journal;
1262         struct journal_head *jh;
1263         int ret = 0;
1264
1265         if (is_handle_aborted(handle))
1266                 return -EROFS;
1267         journal = transaction->t_journal;
1268         jh = jbd2_journal_grab_journal_head(bh);
1269         if (!jh) {
1270                 ret = -EUCLEAN;
1271                 goto out;
1272         }
1273         jbd_debug(5, "journal_head %p\n", jh);
1274         JBUFFER_TRACE(jh, "entry");
1275
1276         jbd_lock_bh_state(bh);
1277
1278         if (jh->b_modified == 0) {
1279                 /*
1280                  * This buffer's got modified and becoming part
1281                  * of the transaction. This needs to be done
1282                  * once a transaction -bzzz
1283                  */
1284                 jh->b_modified = 1;
1285                 if (handle->h_buffer_credits <= 0) {
1286                         ret = -ENOSPC;
1287                         goto out_unlock_bh;
1288                 }
1289                 handle->h_buffer_credits--;
1290         }
1291
1292         /*
1293          * fastpath, to avoid expensive locking.  If this buffer is already
1294          * on the running transaction's metadata list there is nothing to do.
1295          * Nobody can take it off again because there is a handle open.
1296          * I _think_ we're OK here with SMP barriers - a mistaken decision will
1297          * result in this test being false, so we go in and take the locks.
1298          */
1299         if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) {
1300                 JBUFFER_TRACE(jh, "fastpath");
1301                 if (unlikely(jh->b_transaction !=
1302                              journal->j_running_transaction)) {
1303                         printk(KERN_ERR "JBD2: %s: "
1304                                "jh->b_transaction (%llu, %p, %u) != "
1305                                "journal->j_running_transaction (%p, %u)\n",
1306                                journal->j_devname,
1307                                (unsigned long long) bh->b_blocknr,
1308                                jh->b_transaction,
1309                                jh->b_transaction ? jh->b_transaction->t_tid : 0,
1310                                journal->j_running_transaction,
1311                                journal->j_running_transaction ?
1312                                journal->j_running_transaction->t_tid : 0);
1313                         ret = -EINVAL;
1314                 }
1315                 goto out_unlock_bh;
1316         }
1317
1318         set_buffer_jbddirty(bh);
1319
1320         /*
1321          * Metadata already on the current transaction list doesn't
1322          * need to be filed.  Metadata on another transaction's list must
1323          * be committing, and will be refiled once the commit completes:
1324          * leave it alone for now.
1325          */
1326         if (jh->b_transaction != transaction) {
1327                 JBUFFER_TRACE(jh, "already on other transaction");
1328                 if (unlikely(((jh->b_transaction !=
1329                                journal->j_committing_transaction)) ||
1330                              (jh->b_next_transaction != transaction))) {
1331                         printk(KERN_ERR "jbd2_journal_dirty_metadata: %s: "
1332                                "bad jh for block %llu: "
1333                                "transaction (%p, %u), "
1334                                "jh->b_transaction (%p, %u), "
1335                                "jh->b_next_transaction (%p, %u), jlist %u\n",
1336                                journal->j_devname,
1337                                (unsigned long long) bh->b_blocknr,
1338                                transaction, transaction->t_tid,
1339                                jh->b_transaction,
1340                                jh->b_transaction ?
1341                                jh->b_transaction->t_tid : 0,
1342                                jh->b_next_transaction,
1343                                jh->b_next_transaction ?
1344                                jh->b_next_transaction->t_tid : 0,
1345                                jh->b_jlist);
1346                         WARN_ON(1);
1347                         ret = -EINVAL;
1348                 }
1349                 /* And this case is illegal: we can't reuse another
1350                  * transaction's data buffer, ever. */
1351                 goto out_unlock_bh;
1352         }
1353
1354         /* That test should have eliminated the following case: */
1355         J_ASSERT_JH(jh, jh->b_frozen_data == NULL);
1356
1357         JBUFFER_TRACE(jh, "file as BJ_Metadata");
1358         spin_lock(&journal->j_list_lock);
1359         __jbd2_journal_file_buffer(jh, transaction, BJ_Metadata);
1360         spin_unlock(&journal->j_list_lock);
1361 out_unlock_bh:
1362         jbd_unlock_bh_state(bh);
1363         jbd2_journal_put_journal_head(jh);
1364 out:
1365         JBUFFER_TRACE(jh, "exit");
1366         return ret;
1367 }
1368
1369 /**
1370  * void jbd2_journal_forget() - bforget() for potentially-journaled buffers.
1371  * @handle: transaction handle
1372  * @bh:     bh to 'forget'
1373  *
1374  * We can only do the bforget if there are no commits pending against the
1375  * buffer.  If the buffer is dirty in the current running transaction we
1376  * can safely unlink it.
1377  *
1378  * bh may not be a journalled buffer at all - it may be a non-JBD
1379  * buffer which came off the hashtable.  Check for this.
1380  *
1381  * Decrements bh->b_count by one.
1382  *
1383  * Allow this call even if the handle has aborted --- it may be part of
1384  * the caller's cleanup after an abort.
1385  */
1386 int jbd2_journal_forget (handle_t *handle, struct buffer_head *bh)
1387 {
1388         transaction_t *transaction = handle->h_transaction;
1389         journal_t *journal;
1390         struct journal_head *jh;
1391         int drop_reserve = 0;
1392         int err = 0;
1393         int was_modified = 0;
1394
1395         if (is_handle_aborted(handle))
1396                 return -EROFS;
1397         journal = transaction->t_journal;
1398
1399         BUFFER_TRACE(bh, "entry");
1400
1401         jbd_lock_bh_state(bh);
1402
1403         if (!buffer_jbd(bh))
1404                 goto not_jbd;
1405         jh = bh2jh(bh);
1406
1407         /* Critical error: attempting to delete a bitmap buffer, maybe?
1408          * Don't do any jbd operations, and return an error. */
1409         if (!J_EXPECT_JH(jh, !jh->b_committed_data,
1410                          "inconsistent data on disk")) {
1411                 err = -EIO;
1412                 goto not_jbd;
1413         }
1414
1415         /* keep track of whether or not this transaction modified us */
1416         was_modified = jh->b_modified;
1417
1418         /*
1419          * The buffer's going from the transaction, we must drop
1420          * all references -bzzz
1421          */
1422         jh->b_modified = 0;
1423
1424         if (jh->b_transaction == transaction) {
1425                 J_ASSERT_JH(jh, !jh->b_frozen_data);
1426
1427                 /* If we are forgetting a buffer which is already part
1428                  * of this transaction, then we can just drop it from
1429                  * the transaction immediately. */
1430                 clear_buffer_dirty(bh);
1431                 clear_buffer_jbddirty(bh);
1432
1433                 JBUFFER_TRACE(jh, "belongs to current transaction: unfile");
1434
1435                 /*
1436                  * we only want to drop a reference if this transaction
1437                  * modified the buffer
1438                  */
1439                 if (was_modified)
1440                         drop_reserve = 1;
1441
1442                 /*
1443                  * We are no longer going to journal this buffer.
1444                  * However, the commit of this transaction is still
1445                  * important to the buffer: the delete that we are now
1446                  * processing might obsolete an old log entry, so by
1447                  * committing, we can satisfy the buffer's checkpoint.
1448                  *
1449                  * So, if we have a checkpoint on the buffer, we should
1450                  * now refile the buffer on our BJ_Forget list so that
1451                  * we know to remove the checkpoint after we commit.
1452                  */
1453
1454                 spin_lock(&journal->j_list_lock);
1455                 if (jh->b_cp_transaction) {
1456                         __jbd2_journal_temp_unlink_buffer(jh);
1457                         __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
1458                 } else {
1459                         __jbd2_journal_unfile_buffer(jh);
1460                         if (!buffer_jbd(bh)) {
1461                                 spin_unlock(&journal->j_list_lock);
1462                                 jbd_unlock_bh_state(bh);
1463                                 __bforget(bh);
1464                                 goto drop;
1465                         }
1466                 }
1467                 spin_unlock(&journal->j_list_lock);
1468         } else if (jh->b_transaction) {
1469                 J_ASSERT_JH(jh, (jh->b_transaction ==
1470                                  journal->j_committing_transaction));
1471                 /* However, if the buffer is still owned by a prior
1472                  * (committing) transaction, we can't drop it yet... */
1473                 JBUFFER_TRACE(jh, "belongs to older transaction");
1474                 /* ... but we CAN drop it from the new transaction if we
1475                  * have also modified it since the original commit. */
1476
1477                 if (jh->b_next_transaction) {
1478                         J_ASSERT(jh->b_next_transaction == transaction);
1479                         spin_lock(&journal->j_list_lock);
1480                         jh->b_next_transaction = NULL;
1481                         spin_unlock(&journal->j_list_lock);
1482
1483                         /*
1484                          * only drop a reference if this transaction modified
1485                          * the buffer
1486                          */
1487                         if (was_modified)
1488                                 drop_reserve = 1;
1489                 }
1490         }
1491
1492 not_jbd:
1493         jbd_unlock_bh_state(bh);
1494         __brelse(bh);
1495 drop:
1496         if (drop_reserve) {
1497                 /* no need to reserve log space for this block -bzzz */
1498                 handle->h_buffer_credits++;
1499         }
1500         return err;
1501 }
1502
1503 /**
1504  * int jbd2_journal_stop() - complete a transaction
1505  * @handle: tranaction to complete.
1506  *
1507  * All done for a particular handle.
1508  *
1509  * There is not much action needed here.  We just return any remaining
1510  * buffer credits to the transaction and remove the handle.  The only
1511  * complication is that we need to start a commit operation if the
1512  * filesystem is marked for synchronous update.
1513  *
1514  * jbd2_journal_stop itself will not usually return an error, but it may
1515  * do so in unusual circumstances.  In particular, expect it to
1516  * return -EIO if a jbd2_journal_abort has been executed since the
1517  * transaction began.
1518  */
1519 int jbd2_journal_stop(handle_t *handle)
1520 {
1521         transaction_t *transaction = handle->h_transaction;
1522         journal_t *journal;
1523         int err = 0, wait_for_commit = 0;
1524         tid_t tid;
1525         pid_t pid;
1526
1527         if (!transaction) {
1528                 /*
1529                  * Handle is already detached from the transaction so
1530                  * there is nothing to do other than decrease a refcount,
1531                  * or free the handle if refcount drops to zero
1532                  */
1533                 if (--handle->h_ref > 0) {
1534                         jbd_debug(4, "h_ref %d -> %d\n", handle->h_ref + 1,
1535                                                          handle->h_ref);
1536                         return err;
1537                 } else {
1538                         if (handle->h_rsv_handle)
1539                                 jbd2_free_handle(handle->h_rsv_handle);
1540                         goto free_and_exit;
1541                 }
1542         }
1543         journal = transaction->t_journal;
1544
1545         J_ASSERT(journal_current_handle() == handle);
1546
1547         if (is_handle_aborted(handle))
1548                 err = -EIO;
1549         else
1550                 J_ASSERT(atomic_read(&transaction->t_updates) > 0);
1551
1552         if (--handle->h_ref > 0) {
1553                 jbd_debug(4, "h_ref %d -> %d\n", handle->h_ref + 1,
1554                           handle->h_ref);
1555                 return err;
1556         }
1557
1558         jbd_debug(4, "Handle %p going down\n", handle);
1559         trace_jbd2_handle_stats(journal->j_fs_dev->bd_dev,
1560                                 transaction->t_tid,
1561                                 handle->h_type, handle->h_line_no,
1562                                 jiffies - handle->h_start_jiffies,
1563                                 handle->h_sync, handle->h_requested_credits,
1564                                 (handle->h_requested_credits -
1565                                  handle->h_buffer_credits));
1566
1567         /*
1568          * Implement synchronous transaction batching.  If the handle
1569          * was synchronous, don't force a commit immediately.  Let's
1570          * yield and let another thread piggyback onto this
1571          * transaction.  Keep doing that while new threads continue to
1572          * arrive.  It doesn't cost much - we're about to run a commit
1573          * and sleep on IO anyway.  Speeds up many-threaded, many-dir
1574          * operations by 30x or more...
1575          *
1576          * We try and optimize the sleep time against what the
1577          * underlying disk can do, instead of having a static sleep
1578          * time.  This is useful for the case where our storage is so
1579          * fast that it is more optimal to go ahead and force a flush
1580          * and wait for the transaction to be committed than it is to
1581          * wait for an arbitrary amount of time for new writers to
1582          * join the transaction.  We achieve this by measuring how
1583          * long it takes to commit a transaction, and compare it with
1584          * how long this transaction has been running, and if run time
1585          * < commit time then we sleep for the delta and commit.  This
1586          * greatly helps super fast disks that would see slowdowns as
1587          * more threads started doing fsyncs.
1588          *
1589          * But don't do this if this process was the most recent one
1590          * to perform a synchronous write.  We do this to detect the
1591          * case where a single process is doing a stream of sync
1592          * writes.  No point in waiting for joiners in that case.
1593          *
1594          * Setting max_batch_time to 0 disables this completely.
1595          */
1596         pid = current->pid;
1597         if (handle->h_sync && journal->j_last_sync_writer != pid &&
1598             journal->j_max_batch_time) {
1599                 u64 commit_time, trans_time;
1600
1601                 journal->j_last_sync_writer = pid;
1602
1603                 read_lock(&journal->j_state_lock);
1604                 commit_time = journal->j_average_commit_time;
1605                 read_unlock(&journal->j_state_lock);
1606
1607                 trans_time = ktime_to_ns(ktime_sub(ktime_get(),
1608                                                    transaction->t_start_time));
1609
1610                 commit_time = max_t(u64, commit_time,
1611                                     1000*journal->j_min_batch_time);
1612                 commit_time = min_t(u64, commit_time,
1613                                     1000*journal->j_max_batch_time);
1614
1615                 if (trans_time < commit_time) {
1616                         ktime_t expires = ktime_add_ns(ktime_get(),
1617                                                        commit_time);
1618                         set_current_state(TASK_UNINTERRUPTIBLE);
1619                         schedule_hrtimeout(&expires, HRTIMER_MODE_ABS);
1620                 }
1621         }
1622
1623         if (handle->h_sync)
1624                 transaction->t_synchronous_commit = 1;
1625         current->journal_info = NULL;
1626         atomic_sub(handle->h_buffer_credits,
1627                    &transaction->t_outstanding_credits);
1628
1629         /*
1630          * If the handle is marked SYNC, we need to set another commit
1631          * going!  We also want to force a commit if the current
1632          * transaction is occupying too much of the log, or if the
1633          * transaction is too old now.
1634          */
1635         if (handle->h_sync ||
1636             (atomic_read(&transaction->t_outstanding_credits) >
1637              journal->j_max_transaction_buffers) ||
1638             time_after_eq(jiffies, transaction->t_expires)) {
1639                 /* Do this even for aborted journals: an abort still
1640                  * completes the commit thread, it just doesn't write
1641                  * anything to disk. */
1642
1643                 jbd_debug(2, "transaction too old, requesting commit for "
1644                                         "handle %p\n", handle);
1645                 /* This is non-blocking */
1646                 jbd2_log_start_commit(journal, transaction->t_tid);
1647
1648                 /*
1649                  * Special case: JBD2_SYNC synchronous updates require us
1650                  * to wait for the commit to complete.
1651                  */
1652                 if (handle->h_sync && !(current->flags & PF_MEMALLOC))
1653                         wait_for_commit = 1;
1654         }
1655
1656         /*
1657          * Once we drop t_updates, if it goes to zero the transaction
1658          * could start committing on us and eventually disappear.  So
1659          * once we do this, we must not dereference transaction
1660          * pointer again.
1661          */
1662         tid = transaction->t_tid;
1663         if (atomic_dec_and_test(&transaction->t_updates)) {
1664                 wake_up(&journal->j_wait_updates);
1665                 if (journal->j_barrier_count)
1666                         wake_up(&journal->j_wait_transaction_locked);
1667         }
1668
1669         if (wait_for_commit)
1670                 err = jbd2_log_wait_commit(journal, tid);
1671
1672         lock_map_release(&handle->h_lockdep_map);
1673
1674         if (handle->h_rsv_handle)
1675                 jbd2_journal_free_reserved(handle->h_rsv_handle);
1676 free_and_exit:
1677         jbd2_free_handle(handle);
1678         return err;
1679 }
1680
1681 /*
1682  *
1683  * List management code snippets: various functions for manipulating the
1684  * transaction buffer lists.
1685  *
1686  */
1687
1688 /*
1689  * Append a buffer to a transaction list, given the transaction's list head
1690  * pointer.
1691  *
1692  * j_list_lock is held.
1693  *
1694  * jbd_lock_bh_state(jh2bh(jh)) is held.
1695  */
1696
1697 static inline void
1698 __blist_add_buffer(struct journal_head **list, struct journal_head *jh)
1699 {
1700         if (!*list) {
1701                 jh->b_tnext = jh->b_tprev = jh;
1702                 *list = jh;
1703         } else {
1704                 /* Insert at the tail of the list to preserve order */
1705                 struct journal_head *first = *list, *last = first->b_tprev;
1706                 jh->b_tprev = last;
1707                 jh->b_tnext = first;
1708                 last->b_tnext = first->b_tprev = jh;
1709         }
1710 }
1711
1712 /*
1713  * Remove a buffer from a transaction list, given the transaction's list
1714  * head pointer.
1715  *
1716  * Called with j_list_lock held, and the journal may not be locked.
1717  *
1718  * jbd_lock_bh_state(jh2bh(jh)) is held.
1719  */
1720
1721 static inline void
1722 __blist_del_buffer(struct journal_head **list, struct journal_head *jh)
1723 {
1724         if (*list == jh) {
1725                 *list = jh->b_tnext;
1726                 if (*list == jh)
1727                         *list = NULL;
1728         }
1729         jh->b_tprev->b_tnext = jh->b_tnext;
1730         jh->b_tnext->b_tprev = jh->b_tprev;
1731 }
1732
1733 /*
1734  * Remove a buffer from the appropriate transaction list.
1735  *
1736  * Note that this function can *change* the value of
1737  * bh->b_transaction->t_buffers, t_forget, t_shadow_list, t_log_list or
1738  * t_reserved_list.  If the caller is holding onto a copy of one of these
1739  * pointers, it could go bad.  Generally the caller needs to re-read the
1740  * pointer from the transaction_t.
1741  *
1742  * Called under j_list_lock.
1743  */
1744 static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh)
1745 {
1746         struct journal_head **list = NULL;
1747         transaction_t *transaction;
1748         struct buffer_head *bh = jh2bh(jh);
1749
1750         J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh));
1751         transaction = jh->b_transaction;
1752         if (transaction)
1753                 assert_spin_locked(&transaction->t_journal->j_list_lock);
1754
1755         J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
1756         if (jh->b_jlist != BJ_None)
1757                 J_ASSERT_JH(jh, transaction != NULL);
1758
1759         switch (jh->b_jlist) {
1760         case BJ_None:
1761                 return;
1762         case BJ_Metadata:
1763                 transaction->t_nr_buffers--;
1764                 J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0);
1765                 list = &transaction->t_buffers;
1766                 break;
1767         case BJ_Forget:
1768                 list = &transaction->t_forget;
1769                 break;
1770         case BJ_Shadow:
1771                 list = &transaction->t_shadow_list;
1772                 break;
1773         case BJ_Reserved:
1774                 list = &transaction->t_reserved_list;
1775                 break;
1776         }
1777
1778         __blist_del_buffer(list, jh);
1779         jh->b_jlist = BJ_None;
1780         if (test_clear_buffer_jbddirty(bh))
1781                 mark_buffer_dirty(bh);  /* Expose it to the VM */
1782 }
1783
1784 /*
1785  * Remove buffer from all transactions.
1786  *
1787  * Called with bh_state lock and j_list_lock
1788  *
1789  * jh and bh may be already freed when this function returns.
1790  */
1791 static void __jbd2_journal_unfile_buffer(struct journal_head *jh)
1792 {
1793         __jbd2_journal_temp_unlink_buffer(jh);
1794         jh->b_transaction = NULL;
1795         jbd2_journal_put_journal_head(jh);
1796 }
1797
1798 void jbd2_journal_unfile_buffer(journal_t *journal, struct journal_head *jh)
1799 {
1800         struct buffer_head *bh = jh2bh(jh);
1801
1802         /* Get reference so that buffer cannot be freed before we unlock it */
1803         get_bh(bh);
1804         jbd_lock_bh_state(bh);
1805         spin_lock(&journal->j_list_lock);
1806         __jbd2_journal_unfile_buffer(jh);
1807         spin_unlock(&journal->j_list_lock);
1808         jbd_unlock_bh_state(bh);
1809         __brelse(bh);
1810 }
1811
1812 /*
1813  * Called from jbd2_journal_try_to_free_buffers().
1814  *
1815  * Called under jbd_lock_bh_state(bh)
1816  */
1817 static void
1818 __journal_try_to_free_buffer(journal_t *journal, struct buffer_head *bh)
1819 {
1820         struct journal_head *jh;
1821
1822         jh = bh2jh(bh);
1823
1824         if (buffer_locked(bh) || buffer_dirty(bh))
1825                 goto out;
1826
1827         if (jh->b_next_transaction != NULL || jh->b_transaction != NULL)
1828                 goto out;
1829
1830         spin_lock(&journal->j_list_lock);
1831         if (jh->b_cp_transaction != NULL) {
1832                 /* written-back checkpointed metadata buffer */
1833                 JBUFFER_TRACE(jh, "remove from checkpoint list");
1834                 __jbd2_journal_remove_checkpoint(jh);
1835         }
1836         spin_unlock(&journal->j_list_lock);
1837 out:
1838         return;
1839 }
1840
1841 /**
1842  * int jbd2_journal_try_to_free_buffers() - try to free page buffers.
1843  * @journal: journal for operation
1844  * @page: to try and free
1845  * @gfp_mask: we use the mask to detect how hard should we try to release
1846  * buffers. If __GFP_WAIT and __GFP_FS is set, we wait for commit code to
1847  * release the buffers.
1848  *
1849  *
1850  * For all the buffers on this page,
1851  * if they are fully written out ordered data, move them onto BUF_CLEAN
1852  * so try_to_free_buffers() can reap them.
1853  *
1854  * This function returns non-zero if we wish try_to_free_buffers()
1855  * to be called. We do this if the page is releasable by try_to_free_buffers().
1856  * We also do it if the page has locked or dirty buffers and the caller wants
1857  * us to perform sync or async writeout.
1858  *
1859  * This complicates JBD locking somewhat.  We aren't protected by the
1860  * BKL here.  We wish to remove the buffer from its committing or
1861  * running transaction's ->t_datalist via __jbd2_journal_unfile_buffer.
1862  *
1863  * This may *change* the value of transaction_t->t_datalist, so anyone
1864  * who looks at t_datalist needs to lock against this function.
1865  *
1866  * Even worse, someone may be doing a jbd2_journal_dirty_data on this
1867  * buffer.  So we need to lock against that.  jbd2_journal_dirty_data()
1868  * will come out of the lock with the buffer dirty, which makes it
1869  * ineligible for release here.
1870  *
1871  * Who else is affected by this?  hmm...  Really the only contender
1872  * is do_get_write_access() - it could be looking at the buffer while
1873  * journal_try_to_free_buffer() is changing its state.  But that
1874  * cannot happen because we never reallocate freed data as metadata
1875  * while the data is part of a transaction.  Yes?
1876  *
1877  * Return 0 on failure, 1 on success
1878  */
1879 int jbd2_journal_try_to_free_buffers(journal_t *journal,
1880                                 struct page *page, gfp_t gfp_mask)
1881 {
1882         struct buffer_head *head;
1883         struct buffer_head *bh;
1884         int ret = 0;
1885
1886         J_ASSERT(PageLocked(page));
1887
1888         head = page_buffers(page);
1889         bh = head;
1890         do {
1891                 struct journal_head *jh;
1892
1893                 /*
1894                  * We take our own ref against the journal_head here to avoid
1895                  * having to add tons of locking around each instance of
1896                  * jbd2_journal_put_journal_head().
1897                  */
1898                 jh = jbd2_journal_grab_journal_head(bh);
1899                 if (!jh)
1900                         continue;
1901
1902                 jbd_lock_bh_state(bh);
1903                 __journal_try_to_free_buffer(journal, bh);
1904                 jbd2_journal_put_journal_head(jh);
1905                 jbd_unlock_bh_state(bh);
1906                 if (buffer_jbd(bh))
1907                         goto busy;
1908         } while ((bh = bh->b_this_page) != head);
1909
1910         ret = try_to_free_buffers(page);
1911
1912 busy:
1913         return ret;
1914 }
1915
1916 /*
1917  * This buffer is no longer needed.  If it is on an older transaction's
1918  * checkpoint list we need to record it on this transaction's forget list
1919  * to pin this buffer (and hence its checkpointing transaction) down until
1920  * this transaction commits.  If the buffer isn't on a checkpoint list, we
1921  * release it.
1922  * Returns non-zero if JBD no longer has an interest in the buffer.
1923  *
1924  * Called under j_list_lock.
1925  *
1926  * Called under jbd_lock_bh_state(bh).
1927  */
1928 static int __dispose_buffer(struct journal_head *jh, transaction_t *transaction)
1929 {
1930         int may_free = 1;
1931         struct buffer_head *bh = jh2bh(jh);
1932
1933         if (jh->b_cp_transaction) {
1934                 JBUFFER_TRACE(jh, "on running+cp transaction");
1935                 __jbd2_journal_temp_unlink_buffer(jh);
1936                 /*
1937                  * We don't want to write the buffer anymore, clear the
1938                  * bit so that we don't confuse checks in
1939                  * __journal_file_buffer
1940                  */
1941                 clear_buffer_dirty(bh);
1942                 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
1943                 may_free = 0;
1944         } else {
1945                 JBUFFER_TRACE(jh, "on running transaction");
1946                 __jbd2_journal_unfile_buffer(jh);
1947         }
1948         return may_free;
1949 }
1950
1951 /*
1952  * jbd2_journal_invalidatepage
1953  *
1954  * This code is tricky.  It has a number of cases to deal with.
1955  *
1956  * There are two invariants which this code relies on:
1957  *
1958  * i_size must be updated on disk before we start calling invalidatepage on the
1959  * data.
1960  *
1961  *  This is done in ext3 by defining an ext3_setattr method which
1962  *  updates i_size before truncate gets going.  By maintaining this
1963  *  invariant, we can be sure that it is safe to throw away any buffers
1964  *  attached to the current transaction: once the transaction commits,
1965  *  we know that the data will not be needed.
1966  *
1967  *  Note however that we can *not* throw away data belonging to the
1968  *  previous, committing transaction!
1969  *
1970  * Any disk blocks which *are* part of the previous, committing
1971  * transaction (and which therefore cannot be discarded immediately) are
1972  * not going to be reused in the new running transaction
1973  *
1974  *  The bitmap committed_data images guarantee this: any block which is
1975  *  allocated in one transaction and removed in the next will be marked
1976  *  as in-use in the committed_data bitmap, so cannot be reused until
1977  *  the next transaction to delete the block commits.  This means that
1978  *  leaving committing buffers dirty is quite safe: the disk blocks
1979  *  cannot be reallocated to a different file and so buffer aliasing is
1980  *  not possible.
1981  *
1982  *
1983  * The above applies mainly to ordered data mode.  In writeback mode we
1984  * don't make guarantees about the order in which data hits disk --- in
1985  * particular we don't guarantee that new dirty data is flushed before
1986  * transaction commit --- so it is always safe just to discard data
1987  * immediately in that mode.  --sct
1988  */
1989
1990 /*
1991  * The journal_unmap_buffer helper function returns zero if the buffer
1992  * concerned remains pinned as an anonymous buffer belonging to an older
1993  * transaction.
1994  *
1995  * We're outside-transaction here.  Either or both of j_running_transaction
1996  * and j_committing_transaction may be NULL.
1997  */
1998 static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh,
1999                                 int partial_page)
2000 {
2001         transaction_t *transaction;
2002         struct journal_head *jh;
2003         int may_free = 1;
2004
2005         BUFFER_TRACE(bh, "entry");
2006
2007         /*
2008          * It is safe to proceed here without the j_list_lock because the
2009          * buffers cannot be stolen by try_to_free_buffers as long as we are
2010          * holding the page lock. --sct
2011          */
2012
2013         if (!buffer_jbd(bh))
2014                 goto zap_buffer_unlocked;
2015
2016         /* OK, we have data buffer in journaled mode */
2017         write_lock(&journal->j_state_lock);
2018         jbd_lock_bh_state(bh);
2019         spin_lock(&journal->j_list_lock);
2020
2021         jh = jbd2_journal_grab_journal_head(bh);
2022         if (!jh)
2023                 goto zap_buffer_no_jh;
2024
2025         /*
2026          * We cannot remove the buffer from checkpoint lists until the
2027          * transaction adding inode to orphan list (let's call it T)
2028          * is committed.  Otherwise if the transaction changing the
2029          * buffer would be cleaned from the journal before T is
2030          * committed, a crash will cause that the correct contents of
2031          * the buffer will be lost.  On the other hand we have to
2032          * clear the buffer dirty bit at latest at the moment when the
2033          * transaction marking the buffer as freed in the filesystem
2034          * structures is committed because from that moment on the
2035          * block can be reallocated and used by a different page.
2036          * Since the block hasn't been freed yet but the inode has
2037          * already been added to orphan list, it is safe for us to add
2038          * the buffer to BJ_Forget list of the newest transaction.
2039          *
2040          * Also we have to clear buffer_mapped flag of a truncated buffer
2041          * because the buffer_head may be attached to the page straddling
2042          * i_size (can happen only when blocksize < pagesize) and thus the
2043          * buffer_head can be reused when the file is extended again. So we end
2044          * up keeping around invalidated buffers attached to transactions'
2045          * BJ_Forget list just to stop checkpointing code from cleaning up
2046          * the transaction this buffer was modified in.
2047          */
2048         transaction = jh->b_transaction;
2049         if (transaction == NULL) {
2050                 /* First case: not on any transaction.  If it
2051                  * has no checkpoint link, then we can zap it:
2052                  * it's a writeback-mode buffer so we don't care
2053                  * if it hits disk safely. */
2054                 if (!jh->b_cp_transaction) {
2055                         JBUFFER_TRACE(jh, "not on any transaction: zap");
2056                         goto zap_buffer;
2057                 }
2058
2059                 if (!buffer_dirty(bh)) {
2060                         /* bdflush has written it.  We can drop it now */
2061                         goto zap_buffer;
2062                 }
2063
2064                 /* OK, it must be in the journal but still not
2065                  * written fully to disk: it's metadata or
2066                  * journaled data... */
2067
2068                 if (journal->j_running_transaction) {
2069                         /* ... and once the current transaction has
2070                          * committed, the buffer won't be needed any
2071                          * longer. */
2072                         JBUFFER_TRACE(jh, "checkpointed: add to BJ_Forget");
2073                         may_free = __dispose_buffer(jh,
2074                                         journal->j_running_transaction);
2075                         goto zap_buffer;
2076                 } else {
2077                         /* There is no currently-running transaction. So the
2078                          * orphan record which we wrote for this file must have
2079                          * passed into commit.  We must attach this buffer to
2080                          * the committing transaction, if it exists. */
2081                         if (journal->j_committing_transaction) {
2082                                 JBUFFER_TRACE(jh, "give to committing trans");
2083                                 may_free = __dispose_buffer(jh,
2084                                         journal->j_committing_transaction);
2085                                 goto zap_buffer;
2086                         } else {
2087                                 /* The orphan record's transaction has
2088                                  * committed.  We can cleanse this buffer */
2089                                 clear_buffer_jbddirty(bh);
2090                                 goto zap_buffer;
2091                         }
2092                 }
2093         } else if (transaction == journal->j_committing_transaction) {
2094                 JBUFFER_TRACE(jh, "on committing transaction");
2095                 /*
2096                  * The buffer is committing, we simply cannot touch
2097                  * it. If the page is straddling i_size we have to wait
2098                  * for commit and try again.
2099                  */
2100                 if (partial_page) {
2101                         jbd2_journal_put_journal_head(jh);
2102                         spin_unlock(&journal->j_list_lock);
2103                         jbd_unlock_bh_state(bh);
2104                         write_unlock(&journal->j_state_lock);
2105                         return -EBUSY;
2106                 }
2107                 /*
2108                  * OK, buffer won't be reachable after truncate. We just set
2109                  * j_next_transaction to the running transaction (if there is
2110                  * one) and mark buffer as freed so that commit code knows it
2111                  * should clear dirty bits when it is done with the buffer.
2112                  */
2113                 set_buffer_freed(bh);
2114                 if (journal->j_running_transaction && buffer_jbddirty(bh))
2115                         jh->b_next_transaction = journal->j_running_transaction;
2116                 jbd2_journal_put_journal_head(jh);
2117                 spin_unlock(&journal->j_list_lock);
2118                 jbd_unlock_bh_state(bh);
2119                 write_unlock(&journal->j_state_lock);
2120                 return 0;
2121         } else {
2122                 /* Good, the buffer belongs to the running transaction.
2123                  * We are writing our own transaction's data, not any
2124                  * previous one's, so it is safe to throw it away
2125                  * (remember that we expect the filesystem to have set
2126                  * i_size already for this truncate so recovery will not
2127                  * expose the disk blocks we are discarding here.) */
2128                 J_ASSERT_JH(jh, transaction == journal->j_running_transaction);
2129                 JBUFFER_TRACE(jh, "on running transaction");
2130                 may_free = __dispose_buffer(jh, transaction);
2131         }
2132
2133 zap_buffer:
2134         /*
2135          * This is tricky. Although the buffer is truncated, it may be reused
2136          * if blocksize < pagesize and it is attached to the page straddling
2137          * EOF. Since the buffer might have been added to BJ_Forget list of the
2138          * running transaction, journal_get_write_access() won't clear
2139          * b_modified and credit accounting gets confused. So clear b_modified
2140          * here.
2141          */
2142         jh->b_modified = 0;
2143         jbd2_journal_put_journal_head(jh);
2144 zap_buffer_no_jh:
2145         spin_unlock(&journal->j_list_lock);
2146         jbd_unlock_bh_state(bh);
2147         write_unlock(&journal->j_state_lock);
2148 zap_buffer_unlocked:
2149         clear_buffer_dirty(bh);
2150         J_ASSERT_BH(bh, !buffer_jbddirty(bh));
2151         clear_buffer_mapped(bh);
2152         clear_buffer_req(bh);
2153         clear_buffer_new(bh);
2154         clear_buffer_delay(bh);
2155         clear_buffer_unwritten(bh);
2156         bh->b_bdev = NULL;
2157         return may_free;
2158 }
2159
2160 /**
2161  * void jbd2_journal_invalidatepage()
2162  * @journal: journal to use for flush...
2163  * @page:    page to flush
2164  * @offset:  start of the range to invalidate
2165  * @length:  length of the range to invalidate
2166  *
2167  * Reap page buffers containing data after in the specified range in page.
2168  * Can return -EBUSY if buffers are part of the committing transaction and
2169  * the page is straddling i_size. Caller then has to wait for current commit
2170  * and try again.
2171  */
2172 int jbd2_journal_invalidatepage(journal_t *journal,
2173                                 struct page *page,
2174                                 unsigned int offset,
2175                                 unsigned int length)
2176 {
2177         struct buffer_head *head, *bh, *next;
2178         unsigned int stop = offset + length;
2179         unsigned int curr_off = 0;
2180         int partial_page = (offset || length < PAGE_CACHE_SIZE);
2181         int may_free = 1;
2182         int ret = 0;
2183
2184         if (!PageLocked(page))
2185                 BUG();
2186         if (!page_has_buffers(page))
2187                 return 0;
2188
2189         BUG_ON(stop > PAGE_CACHE_SIZE || stop < length);
2190
2191         /* We will potentially be playing with lists other than just the
2192          * data lists (especially for journaled data mode), so be
2193          * cautious in our locking. */
2194
2195         head = bh = page_buffers(page);
2196         do {
2197                 unsigned int next_off = curr_off + bh->b_size;
2198                 next = bh->b_this_page;
2199
2200                 if (next_off > stop)
2201                         return 0;
2202
2203                 if (offset <= curr_off) {
2204                         /* This block is wholly outside the truncation point */
2205                         lock_buffer(bh);
2206                         ret = journal_unmap_buffer(journal, bh, partial_page);
2207                         unlock_buffer(bh);
2208                         if (ret < 0)
2209                                 return ret;
2210                         may_free &= ret;
2211                 }
2212                 curr_off = next_off;
2213                 bh = next;
2214
2215         } while (bh != head);
2216
2217         if (!partial_page) {
2218                 if (may_free && try_to_free_buffers(page))
2219                         J_ASSERT(!page_has_buffers(page));
2220         }
2221         return 0;
2222 }
2223
2224 /*
2225  * File a buffer on the given transaction list.
2226  */
2227 void __jbd2_journal_file_buffer(struct journal_head *jh,
2228                         transaction_t *transaction, int jlist)
2229 {
2230         struct journal_head **list = NULL;
2231         int was_dirty = 0;
2232         struct buffer_head *bh = jh2bh(jh);
2233
2234         J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh));
2235         assert_spin_locked(&transaction->t_journal->j_list_lock);
2236
2237         J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
2238         J_ASSERT_JH(jh, jh->b_transaction == transaction ||
2239                                 jh->b_transaction == NULL);
2240
2241         if (jh->b_transaction && jh->b_jlist == jlist)
2242                 return;
2243
2244         if (jlist == BJ_Metadata || jlist == BJ_Reserved ||
2245             jlist == BJ_Shadow || jlist == BJ_Forget) {
2246                 /*
2247                  * For metadata buffers, we track dirty bit in buffer_jbddirty
2248                  * instead of buffer_dirty. We should not see a dirty bit set
2249                  * here because we clear it in do_get_write_access but e.g.
2250                  * tune2fs can modify the sb and set the dirty bit at any time
2251                  * so we try to gracefully handle that.
2252                  */
2253                 if (buffer_dirty(bh))
2254                         warn_dirty_buffer(bh);
2255                 if (test_clear_buffer_dirty(bh) ||
2256                     test_clear_buffer_jbddirty(bh))
2257                         was_dirty = 1;
2258         }
2259
2260         if (jh->b_transaction)
2261                 __jbd2_journal_temp_unlink_buffer(jh);
2262         else
2263                 jbd2_journal_grab_journal_head(bh);
2264         jh->b_transaction = transaction;
2265
2266         switch (jlist) {
2267         case BJ_None:
2268                 J_ASSERT_JH(jh, !jh->b_committed_data);
2269                 J_ASSERT_JH(jh, !jh->b_frozen_data);
2270                 return;
2271         case BJ_Metadata:
2272                 transaction->t_nr_buffers++;
2273                 list = &transaction->t_buffers;
2274                 break;
2275         case BJ_Forget:
2276                 list = &transaction->t_forget;
2277                 break;
2278         case BJ_Shadow:
2279                 list = &transaction->t_shadow_list;
2280                 break;
2281         case BJ_Reserved:
2282                 list = &transaction->t_reserved_list;
2283                 break;
2284         }
2285
2286         __blist_add_buffer(list, jh);
2287         jh->b_jlist = jlist;
2288
2289         if (was_dirty)
2290                 set_buffer_jbddirty(bh);
2291 }
2292
2293 void jbd2_journal_file_buffer(struct journal_head *jh,
2294                                 transaction_t *transaction, int jlist)
2295 {
2296         jbd_lock_bh_state(jh2bh(jh));
2297         spin_lock(&transaction->t_journal->j_list_lock);
2298         __jbd2_journal_file_buffer(jh, transaction, jlist);
2299         spin_unlock(&transaction->t_journal->j_list_lock);
2300         jbd_unlock_bh_state(jh2bh(jh));
2301 }
2302
2303 /*
2304  * Remove a buffer from its current buffer list in preparation for
2305  * dropping it from its current transaction entirely.  If the buffer has
2306  * already started to be used by a subsequent transaction, refile the
2307  * buffer on that transaction's metadata list.
2308  *
2309  * Called under j_list_lock
2310  * Called under jbd_lock_bh_state(jh2bh(jh))
2311  *
2312  * jh and bh may be already free when this function returns
2313  */
2314 void __jbd2_journal_refile_buffer(struct journal_head *jh)
2315 {
2316         int was_dirty, jlist;
2317         struct buffer_head *bh = jh2bh(jh);
2318
2319         J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh));
2320         if (jh->b_transaction)
2321                 assert_spin_locked(&jh->b_transaction->t_journal->j_list_lock);
2322
2323         /* If the buffer is now unused, just drop it. */
2324         if (jh->b_next_transaction == NULL) {
2325                 __jbd2_journal_unfile_buffer(jh);
2326                 return;
2327         }
2328
2329         /*
2330          * It has been modified by a later transaction: add it to the new
2331          * transaction's metadata list.
2332          */
2333
2334         was_dirty = test_clear_buffer_jbddirty(bh);
2335         __jbd2_journal_temp_unlink_buffer(jh);
2336         /*
2337          * We set b_transaction here because b_next_transaction will inherit
2338          * our jh reference and thus __jbd2_journal_file_buffer() must not
2339          * take a new one.
2340          */
2341         jh->b_transaction = jh->b_next_transaction;
2342         jh->b_next_transaction = NULL;
2343         if (buffer_freed(bh))
2344                 jlist = BJ_Forget;
2345         else if (jh->b_modified)
2346                 jlist = BJ_Metadata;
2347         else
2348                 jlist = BJ_Reserved;
2349         __jbd2_journal_file_buffer(jh, jh->b_transaction, jlist);
2350         J_ASSERT_JH(jh, jh->b_transaction->t_state == T_RUNNING);
2351
2352         if (was_dirty)
2353                 set_buffer_jbddirty(bh);
2354 }
2355
2356 /*
2357  * __jbd2_journal_refile_buffer() with necessary locking added. We take our
2358  * bh reference so that we can safely unlock bh.
2359  *
2360  * The jh and bh may be freed by this call.
2361  */
2362 void jbd2_journal_refile_buffer(journal_t *journal, struct journal_head *jh)
2363 {
2364         struct buffer_head *bh = jh2bh(jh);
2365
2366         /* Get reference so that buffer cannot be freed before we unlock it */
2367         get_bh(bh);
2368         jbd_lock_bh_state(bh);
2369         spin_lock(&journal->j_list_lock);
2370         __jbd2_journal_refile_buffer(jh);
2371         jbd_unlock_bh_state(bh);
2372         spin_unlock(&journal->j_list_lock);
2373         __brelse(bh);
2374 }
2375
2376 /*
2377  * File inode in the inode list of the handle's transaction
2378  */
2379 int jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *jinode)
2380 {
2381         transaction_t *transaction = handle->h_transaction;
2382         journal_t *journal;
2383
2384         if (is_handle_aborted(handle))
2385                 return -EROFS;
2386         journal = transaction->t_journal;
2387
2388         jbd_debug(4, "Adding inode %lu, tid:%d\n", jinode->i_vfs_inode->i_ino,
2389                         transaction->t_tid);
2390
2391         /*
2392          * First check whether inode isn't already on the transaction's
2393          * lists without taking the lock. Note that this check is safe
2394          * without the lock as we cannot race with somebody removing inode
2395          * from the transaction. The reason is that we remove inode from the
2396          * transaction only in journal_release_jbd_inode() and when we commit
2397          * the transaction. We are guarded from the first case by holding
2398          * a reference to the inode. We are safe against the second case
2399          * because if jinode->i_transaction == transaction, commit code
2400          * cannot touch the transaction because we hold reference to it,
2401          * and if jinode->i_next_transaction == transaction, commit code
2402          * will only file the inode where we want it.
2403          */
2404         if (jinode->i_transaction == transaction ||
2405             jinode->i_next_transaction == transaction)
2406                 return 0;
2407
2408         spin_lock(&journal->j_list_lock);
2409
2410         if (jinode->i_transaction == transaction ||
2411             jinode->i_next_transaction == transaction)
2412                 goto done;
2413
2414         /*
2415          * We only ever set this variable to 1 so the test is safe. Since
2416          * t_need_data_flush is likely to be set, we do the test to save some
2417          * cacheline bouncing
2418          */
2419         if (!transaction->t_need_data_flush)
2420                 transaction->t_need_data_flush = 1;
2421         /* On some different transaction's list - should be
2422          * the committing one */
2423         if (jinode->i_transaction) {
2424                 J_ASSERT(jinode->i_next_transaction == NULL);
2425                 J_ASSERT(jinode->i_transaction ==
2426                                         journal->j_committing_transaction);
2427                 jinode->i_next_transaction = transaction;
2428                 goto done;
2429         }
2430         /* Not on any transaction list... */
2431         J_ASSERT(!jinode->i_next_transaction);
2432         jinode->i_transaction = transaction;
2433         list_add(&jinode->i_list, &transaction->t_inode_list);
2434 done:
2435         spin_unlock(&journal->j_list_lock);
2436
2437         return 0;
2438 }
2439
2440 /*
2441  * File truncate and transaction commit interact with each other in a
2442  * non-trivial way.  If a transaction writing data block A is
2443  * committing, we cannot discard the data by truncate until we have
2444  * written them.  Otherwise if we crashed after the transaction with
2445  * write has committed but before the transaction with truncate has
2446  * committed, we could see stale data in block A.  This function is a
2447  * helper to solve this problem.  It starts writeout of the truncated
2448  * part in case it is in the committing transaction.
2449  *
2450  * Filesystem code must call this function when inode is journaled in
2451  * ordered mode before truncation happens and after the inode has been
2452  * placed on orphan list with the new inode size. The second condition
2453  * avoids the race that someone writes new data and we start
2454  * committing the transaction after this function has been called but
2455  * before a transaction for truncate is started (and furthermore it
2456  * allows us to optimize the case where the addition to orphan list
2457  * happens in the same transaction as write --- we don't have to write
2458  * any data in such case).
2459  */
2460 int jbd2_journal_begin_ordered_truncate(journal_t *journal,
2461                                         struct jbd2_inode *jinode,
2462                                         loff_t new_size)
2463 {
2464         transaction_t *inode_trans, *commit_trans;
2465         int ret = 0;
2466
2467         /* This is a quick check to avoid locking if not necessary */
2468         if (!jinode->i_transaction)
2469                 goto out;
2470         /* Locks are here just to force reading of recent values, it is
2471          * enough that the transaction was not committing before we started
2472          * a transaction adding the inode to orphan list */
2473         read_lock(&journal->j_state_lock);
2474         commit_trans = journal->j_committing_transaction;
2475         read_unlock(&journal->j_state_lock);
2476         spin_lock(&journal->j_list_lock);
2477         inode_trans = jinode->i_transaction;
2478         spin_unlock(&journal->j_list_lock);
2479         if (inode_trans == commit_trans) {
2480                 ret = filemap_fdatawrite_range(jinode->i_vfs_inode->i_mapping,
2481                         new_size, LLONG_MAX);
2482                 if (ret)
2483                         jbd2_journal_abort(journal, ret);
2484         }
2485 out:
2486         return ret;
2487 }