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