1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
4 * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
5 */
6
7#include <linux/sched.h>
8#include <linux/slab.h>
9#include <linux/spinlock.h>
10#include <linux/completion.h>
11#include <linux/buffer_head.h>
12#include <linux/gfs2_ondisk.h>
13#include <linux/crc32.h>
14#include <linux/crc32c.h>
15#include <linux/delay.h>
16#include <linux/kthread.h>
17#include <linux/freezer.h>
18#include <linux/bio.h>
19#include <linux/blkdev.h>
20#include <linux/writeback.h>
21#include <linux/list_sort.h>
22
23#include "gfs2.h"
24#include "incore.h"
25#include "bmap.h"
26#include "glock.h"
27#include "log.h"
28#include "lops.h"
29#include "meta_io.h"
30#include "util.h"
31#include "dir.h"
32#include "trace_gfs2.h"
33#include "trans.h"
34#include "aops.h"
35
36static void gfs2_log_shutdown(struct gfs2_sbd *sdp);
37
38/**
39 * gfs2_struct2blk - compute stuff
40 * @sdp: the filesystem
41 * @nstruct: the number of structures
42 *
43 * Compute the number of log descriptor blocks needed to hold a certain number
44 * of structures of a certain size.
45 *
46 * Returns: the number of blocks needed (minimum is always 1)
47 */
48
49unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct)
50{
51 unsigned int blks;
52 unsigned int first, second;
53
54 /* The initial struct gfs2_log_descriptor block */
55 blks = 1;
56 first = sdp->sd_ldptrs;
57
58 if (nstruct > first) {
59 /* Subsequent struct gfs2_meta_header blocks */
60 second = sdp->sd_inptrs;
61 blks += DIV_ROUND_UP(nstruct - first, second);
62 }
63
64 return blks;
65}
66
67/**
68 * gfs2_remove_from_ail - Remove an entry from the ail lists, updating counters
69 * @bd: The gfs2_bufdata to remove
70 *
71 * The ail lock _must_ be held when calling this function
72 *
73 */
74
75void gfs2_remove_from_ail(struct gfs2_bufdata *bd)
76{
77 bd->bd_tr = NULL;
78 list_del_init(entry: &bd->bd_ail_st_list);
79 list_del_init(entry: &bd->bd_ail_gl_list);
80 atomic_dec(v: &bd->bd_gl->gl_ail_count);
81 brelse(bh: bd->bd_bh);
82}
83
84/**
85 * gfs2_ail1_start_one - Start I/O on a transaction
86 * @sdp: The superblock
87 * @wbc: The writeback control structure
88 * @tr: The transaction to start I/O on
89 * @plug: The block plug currently active
90 */
91
92static int gfs2_ail1_start_one(struct gfs2_sbd *sdp,
93 struct writeback_control *wbc,
94 struct gfs2_trans *tr, struct blk_plug *plug)
95__releases(&sdp->sd_ail_lock)
96__acquires(&sdp->sd_ail_lock)
97{
98 struct gfs2_glock *gl = NULL;
99 struct address_space *mapping;
100 struct gfs2_bufdata *bd, *s;
101 struct buffer_head *bh;
102 int ret = 0;
103
104 list_for_each_entry_safe_reverse(bd, s, &tr->tr_ail1_list, bd_ail_st_list) {
105 bh = bd->bd_bh;
106
107 gfs2_assert(sdp, bd->bd_tr == tr);
108
109 if (!buffer_busy(bh)) {
110 if (buffer_uptodate(bh)) {
111 list_move(list: &bd->bd_ail_st_list,
112 head: &tr->tr_ail2_list);
113 continue;
114 }
115 if (!cmpxchg(&sdp->sd_log_error, 0, -EIO))
116 gfs2_io_error_bh(sdp, bh);
117 }
118
119 if (gfs2_withdrawn(sdp)) {
120 gfs2_remove_from_ail(bd);
121 continue;
122 }
123 if (!buffer_dirty(bh))
124 continue;
125 if (gl == bd->bd_gl)
126 continue;
127 gl = bd->bd_gl;
128 list_move(list: &bd->bd_ail_st_list, head: &tr->tr_ail1_list);
129 mapping = bh->b_folio->mapping;
130 if (!mapping)
131 continue;
132 spin_unlock(lock: &sdp->sd_ail_lock);
133 BUG_ON(GFS2_SB(mapping->host) != sdp);
134 if (gfs2_is_jdata(ip: GFS2_I(inode: mapping->host)))
135 ret = gfs2_jdata_writeback(mapping, wbc);
136 else
137 ret = mapping->a_ops->writepages(mapping, wbc);
138 if (need_resched()) {
139 blk_finish_plug(plug);
140 cond_resched();
141 blk_start_plug(plug);
142 }
143 spin_lock(lock: &sdp->sd_ail_lock);
144 if (ret == -ENODATA) /* if a jdata write into a new hole */
145 ret = 0; /* ignore it */
146 mapping_set_error(mapping, error: ret);
147 if (ret || wbc->nr_to_write <= 0)
148 break;
149 return -EBUSY;
150 }
151
152 return ret;
153}
154
155static void dump_ail_list(struct gfs2_sbd *sdp)
156{
157 struct gfs2_trans *tr;
158 struct gfs2_bufdata *bd;
159 struct buffer_head *bh;
160
161 list_for_each_entry_reverse(tr, &sdp->sd_ail1_list, tr_list) {
162 list_for_each_entry_reverse(bd, &tr->tr_ail1_list,
163 bd_ail_st_list) {
164 bh = bd->bd_bh;
165 fs_err(sdp, "bd %p: blk:0x%llx bh=%p ", bd,
166 (unsigned long long)bd->bd_blkno, bh);
167 if (!bh) {
168 fs_err(sdp, "\n");
169 continue;
170 }
171 fs_err(sdp, "0x%llx up2:%d dirt:%d lkd:%d req:%d "
172 "map:%d new:%d ar:%d aw:%d delay:%d "
173 "io err:%d unwritten:%d dfr:%d pin:%d esc:%d\n",
174 (unsigned long long)bh->b_blocknr,
175 buffer_uptodate(bh), buffer_dirty(bh),
176 buffer_locked(bh), buffer_req(bh),
177 buffer_mapped(bh), buffer_new(bh),
178 buffer_async_read(bh), buffer_async_write(bh),
179 buffer_delay(bh), buffer_write_io_error(bh),
180 buffer_unwritten(bh),
181 buffer_defer_completion(bh),
182 buffer_pinned(bh), buffer_escaped(bh));
183 }
184 }
185}
186
187/**
188 * gfs2_ail1_flush - start writeback of some ail1 entries
189 * @sdp: The super block
190 * @wbc: The writeback control structure
191 *
192 * Writes back some ail1 entries, according to the limits in the
193 * writeback control structure
194 */
195
196void gfs2_ail1_flush(struct gfs2_sbd *sdp, struct writeback_control *wbc)
197{
198 struct list_head *head = &sdp->sd_ail1_list;
199 struct gfs2_trans *tr;
200 struct blk_plug plug;
201 int ret;
202 unsigned long flush_start = jiffies;
203
204 trace_gfs2_ail_flush(sdp, wbc, start: 1);
205 blk_start_plug(&plug);
206 spin_lock(lock: &sdp->sd_ail_lock);
207restart:
208 ret = 0;
209 if (time_after(jiffies, flush_start + (HZ * 600))) {
210 fs_err(sdp, "Error: In %s for ten minutes! t=%d\n",
211 __func__, current->journal_info ? 1 : 0);
212 dump_ail_list(sdp);
213 goto out;
214 }
215 list_for_each_entry_reverse(tr, head, tr_list) {
216 if (wbc->nr_to_write <= 0)
217 break;
218 ret = gfs2_ail1_start_one(sdp, wbc, tr, plug: &plug);
219 if (ret) {
220 if (ret == -EBUSY)
221 goto restart;
222 break;
223 }
224 }
225out:
226 spin_unlock(lock: &sdp->sd_ail_lock);
227 blk_finish_plug(&plug);
228 if (ret) {
229 gfs2_lm(sdp, fmt: "gfs2_ail1_start_one returned: %d\n", ret);
230 gfs2_withdraw(sdp);
231 }
232 trace_gfs2_ail_flush(sdp, wbc, start: 0);
233}
234
235/**
236 * gfs2_ail1_start - start writeback of all ail1 entries
237 * @sdp: The superblock
238 */
239
240static void gfs2_ail1_start(struct gfs2_sbd *sdp)
241{
242 struct writeback_control wbc = {
243 .sync_mode = WB_SYNC_NONE,
244 .nr_to_write = LONG_MAX,
245 .range_start = 0,
246 .range_end = LLONG_MAX,
247 };
248
249 return gfs2_ail1_flush(sdp, wbc: &wbc);
250}
251
252static void gfs2_log_update_flush_tail(struct gfs2_sbd *sdp)
253{
254 unsigned int new_flush_tail = sdp->sd_log_head;
255 struct gfs2_trans *tr;
256
257 if (!list_empty(head: &sdp->sd_ail1_list)) {
258 tr = list_last_entry(&sdp->sd_ail1_list,
259 struct gfs2_trans, tr_list);
260 new_flush_tail = tr->tr_first;
261 }
262 sdp->sd_log_flush_tail = new_flush_tail;
263}
264
265static void gfs2_log_update_head(struct gfs2_sbd *sdp)
266{
267 unsigned int new_head = sdp->sd_log_flush_head;
268
269 if (sdp->sd_log_flush_tail == sdp->sd_log_head)
270 sdp->sd_log_flush_tail = new_head;
271 sdp->sd_log_head = new_head;
272}
273
274/*
275 * gfs2_ail_empty_tr - empty one of the ail lists of a transaction
276 */
277
278static void gfs2_ail_empty_tr(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
279 struct list_head *head)
280{
281 struct gfs2_bufdata *bd;
282
283 while (!list_empty(head)) {
284 bd = list_first_entry(head, struct gfs2_bufdata,
285 bd_ail_st_list);
286 gfs2_assert(sdp, bd->bd_tr == tr);
287 gfs2_remove_from_ail(bd);
288 }
289}
290
291/**
292 * gfs2_ail1_empty_one - Check whether or not a trans in the AIL has been synced
293 * @sdp: the filesystem
294 * @tr: the transaction
295 * @max_revokes: If nonzero, issue revokes for the bd items for written buffers
296 *
297 * returns: the transaction's count of remaining active items
298 */
299
300static int gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
301 int *max_revokes)
302{
303 struct gfs2_bufdata *bd, *s;
304 struct buffer_head *bh;
305 int active_count = 0;
306
307 list_for_each_entry_safe_reverse(bd, s, &tr->tr_ail1_list,
308 bd_ail_st_list) {
309 bh = bd->bd_bh;
310 gfs2_assert(sdp, bd->bd_tr == tr);
311 /*
312 * If another process flagged an io error, e.g. writing to the
313 * journal, error all other bhs and move them off the ail1 to
314 * prevent a tight loop when unmount tries to flush ail1,
315 * regardless of whether they're still busy. If no outside
316 * errors were found and the buffer is busy, move to the next.
317 * If the ail buffer is not busy and caught an error, flag it
318 * for others.
319 */
320 if (!sdp->sd_log_error && buffer_busy(bh)) {
321 active_count++;
322 continue;
323 }
324 if (!buffer_uptodate(bh) &&
325 !cmpxchg(&sdp->sd_log_error, 0, -EIO))
326 gfs2_io_error_bh(sdp, bh);
327 /*
328 * If we have space for revokes and the bd is no longer on any
329 * buf list, we can just add a revoke for it immediately and
330 * avoid having to put it on the ail2 list, where it would need
331 * to be revoked later.
332 */
333 if (*max_revokes && list_empty(head: &bd->bd_list)) {
334 gfs2_add_revoke(sdp, bd);
335 (*max_revokes)--;
336 continue;
337 }
338 list_move(list: &bd->bd_ail_st_list, head: &tr->tr_ail2_list);
339 }
340 return active_count;
341}
342
343/**
344 * gfs2_ail1_empty - Try to empty the ail1 lists
345 * @sdp: The superblock
346 * @max_revokes: If non-zero, add revokes where appropriate
347 *
348 * Tries to empty the ail1 lists, starting with the oldest first.
349 * Returns %true if the ail1 list is now empty.
350 */
351
352static bool gfs2_ail1_empty(struct gfs2_sbd *sdp, int max_revokes)
353{
354 struct gfs2_trans *tr, *s;
355 int oldest_tr = 1;
356 bool empty;
357
358 spin_lock(lock: &sdp->sd_ail_lock);
359 list_for_each_entry_safe_reverse(tr, s, &sdp->sd_ail1_list, tr_list) {
360 if (!gfs2_ail1_empty_one(sdp, tr, max_revokes: &max_revokes) && oldest_tr)
361 list_move(list: &tr->tr_list, head: &sdp->sd_ail2_list);
362 else
363 oldest_tr = 0;
364 }
365 gfs2_log_update_flush_tail(sdp);
366 empty = list_empty(head: &sdp->sd_ail1_list);
367 spin_unlock(lock: &sdp->sd_ail_lock);
368
369 return empty;
370}
371
372static void gfs2_ail1_wait(struct gfs2_sbd *sdp)
373{
374 struct gfs2_trans *tr;
375 struct gfs2_bufdata *bd;
376 struct buffer_head *bh;
377
378 spin_lock(lock: &sdp->sd_ail_lock);
379 list_for_each_entry_reverse(tr, &sdp->sd_ail1_list, tr_list) {
380 list_for_each_entry(bd, &tr->tr_ail1_list, bd_ail_st_list) {
381 bh = bd->bd_bh;
382 if (!buffer_locked(bh))
383 continue;
384 get_bh(bh);
385 spin_unlock(lock: &sdp->sd_ail_lock);
386 wait_on_buffer(bh);
387 brelse(bh);
388 return;
389 }
390 }
391 spin_unlock(lock: &sdp->sd_ail_lock);
392}
393
394static void __ail2_empty(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
395{
396 gfs2_ail_empty_tr(sdp, tr, head: &tr->tr_ail2_list);
397 list_del(entry: &tr->tr_list);
398 gfs2_assert_warn(sdp, list_empty(&tr->tr_ail1_list));
399 gfs2_assert_warn(sdp, list_empty(&tr->tr_ail2_list));
400 gfs2_trans_free(sdp, tr);
401}
402
403static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail)
404{
405 struct list_head *ail2_list = &sdp->sd_ail2_list;
406 unsigned int old_tail = sdp->sd_log_tail;
407 struct gfs2_trans *tr, *safe;
408
409 spin_lock(lock: &sdp->sd_ail_lock);
410 if (old_tail <= new_tail) {
411 list_for_each_entry_safe(tr, safe, ail2_list, tr_list) {
412 if (old_tail <= tr->tr_first && tr->tr_first < new_tail)
413 __ail2_empty(sdp, tr);
414 }
415 } else {
416 list_for_each_entry_safe(tr, safe, ail2_list, tr_list) {
417 if (old_tail <= tr->tr_first || tr->tr_first < new_tail)
418 __ail2_empty(sdp, tr);
419 }
420 }
421 spin_unlock(lock: &sdp->sd_ail_lock);
422}
423
424/**
425 * gfs2_log_is_empty - Check if the log is empty
426 * @sdp: The GFS2 superblock
427 */
428
429bool gfs2_log_is_empty(struct gfs2_sbd *sdp) {
430 return atomic_read(v: &sdp->sd_log_blks_free) == sdp->sd_jdesc->jd_blocks;
431}
432
433static bool __gfs2_log_try_reserve_revokes(struct gfs2_sbd *sdp, unsigned int revokes)
434{
435 unsigned int available;
436
437 available = atomic_read(v: &sdp->sd_log_revokes_available);
438 while (available >= revokes) {
439 if (atomic_try_cmpxchg(v: &sdp->sd_log_revokes_available,
440 old: &available, new: available - revokes))
441 return true;
442 }
443 return false;
444}
445
446/**
447 * gfs2_log_release_revokes - Release a given number of revokes
448 * @sdp: The GFS2 superblock
449 * @revokes: The number of revokes to release
450 *
451 * sdp->sd_log_flush_lock must be held.
452 */
453void gfs2_log_release_revokes(struct gfs2_sbd *sdp, unsigned int revokes)
454{
455 if (revokes)
456 atomic_add(i: revokes, v: &sdp->sd_log_revokes_available);
457}
458
459/**
460 * gfs2_log_release - Release a given number of log blocks
461 * @sdp: The GFS2 superblock
462 * @blks: The number of blocks
463 *
464 */
465
466void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks)
467{
468 atomic_add(i: blks, v: &sdp->sd_log_blks_free);
469 trace_gfs2_log_blocks(sdp, blocks: blks);
470 gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <=
471 sdp->sd_jdesc->jd_blocks);
472 if (atomic_read(v: &sdp->sd_log_blks_needed))
473 wake_up(&sdp->sd_log_waitq);
474}
475
476/**
477 * __gfs2_log_try_reserve - Try to make a log reservation
478 * @sdp: The GFS2 superblock
479 * @blks: The number of blocks to reserve
480 * @taboo_blks: The number of blocks to leave free
481 *
482 * Try to do the same as __gfs2_log_reserve(), but fail if no more log
483 * space is immediately available.
484 */
485static bool __gfs2_log_try_reserve(struct gfs2_sbd *sdp, unsigned int blks,
486 unsigned int taboo_blks)
487{
488 unsigned wanted = blks + taboo_blks;
489 unsigned int free_blocks;
490
491 free_blocks = atomic_read(v: &sdp->sd_log_blks_free);
492 while (free_blocks >= wanted) {
493 if (atomic_try_cmpxchg(v: &sdp->sd_log_blks_free, old: &free_blocks,
494 new: free_blocks - blks)) {
495 trace_gfs2_log_blocks(sdp, blocks: -blks);
496 return true;
497 }
498 }
499 return false;
500}
501
502/**
503 * __gfs2_log_reserve - Make a log reservation
504 * @sdp: The GFS2 superblock
505 * @blks: The number of blocks to reserve
506 * @taboo_blks: The number of blocks to leave free
507 *
508 * @taboo_blks is set to 0 for logd, and to GFS2_LOG_FLUSH_MIN_BLOCKS
509 * for all other processes. This ensures that when the log is almost full,
510 * logd will still be able to call gfs2_log_flush one more time without
511 * blocking, which will advance the tail and make some more log space
512 * available.
513 *
514 * We no longer flush the log here, instead we wake up logd to do that
515 * for us. To avoid the thundering herd and to ensure that we deal fairly
516 * with queued waiters, we use an exclusive wait. This means that when we
517 * get woken with enough journal space to get our reservation, we need to
518 * wake the next waiter on the list.
519 */
520
521static void __gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks,
522 unsigned int taboo_blks)
523{
524 unsigned wanted = blks + taboo_blks;
525 unsigned int free_blocks;
526
527 atomic_add(i: blks, v: &sdp->sd_log_blks_needed);
528 for (;;) {
529 if (current != sdp->sd_logd_process)
530 wake_up(&sdp->sd_logd_waitq);
531 io_wait_event(sdp->sd_log_waitq,
532 (free_blocks = atomic_read(&sdp->sd_log_blks_free),
533 free_blocks >= wanted));
534 do {
535 if (atomic_try_cmpxchg(v: &sdp->sd_log_blks_free,
536 old: &free_blocks,
537 new: free_blocks - blks))
538 goto reserved;
539 } while (free_blocks >= wanted);
540 }
541
542reserved:
543 trace_gfs2_log_blocks(sdp, blocks: -blks);
544 if (atomic_sub_return(i: blks, v: &sdp->sd_log_blks_needed))
545 wake_up(&sdp->sd_log_waitq);
546}
547
548/**
549 * gfs2_log_try_reserve - Try to make a log reservation
550 * @sdp: The GFS2 superblock
551 * @tr: The transaction
552 * @extra_revokes: The number of additional revokes reserved (output)
553 *
554 * This is similar to gfs2_log_reserve, but sdp->sd_log_flush_lock must be
555 * held for correct revoke accounting.
556 */
557
558bool gfs2_log_try_reserve(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
559 unsigned int *extra_revokes)
560{
561 unsigned int blks = tr->tr_reserved;
562 unsigned int revokes = tr->tr_revokes;
563 unsigned int revoke_blks = 0;
564
565 *extra_revokes = 0;
566 if (revokes && !__gfs2_log_try_reserve_revokes(sdp, revokes)) {
567 revoke_blks = DIV_ROUND_UP(revokes, sdp->sd_inptrs);
568 *extra_revokes = revoke_blks * sdp->sd_inptrs - revokes;
569 blks += revoke_blks;
570 }
571 if (!blks)
572 return true;
573 if (__gfs2_log_try_reserve(sdp, blks, GFS2_LOG_FLUSH_MIN_BLOCKS))
574 return true;
575 if (!revoke_blks)
576 gfs2_log_release_revokes(sdp, revokes);
577 return false;
578}
579
580/**
581 * gfs2_log_reserve - Make a log reservation
582 * @sdp: The GFS2 superblock
583 * @tr: The transaction
584 * @extra_revokes: The number of additional revokes reserved (output)
585 *
586 * sdp->sd_log_flush_lock must not be held.
587 */
588
589void gfs2_log_reserve(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
590 unsigned int *extra_revokes)
591{
592 unsigned int blks = tr->tr_reserved;
593 unsigned int revokes = tr->tr_revokes;
594 unsigned int revoke_blks;
595
596 *extra_revokes = 0;
597 if (revokes) {
598 revoke_blks = DIV_ROUND_UP(revokes, sdp->sd_inptrs);
599 *extra_revokes = revoke_blks * sdp->sd_inptrs - revokes;
600 blks += revoke_blks;
601 }
602 __gfs2_log_reserve(sdp, blks, GFS2_LOG_FLUSH_MIN_BLOCKS);
603}
604
605/**
606 * log_distance - Compute distance between two journal blocks
607 * @sdp: The GFS2 superblock
608 * @newer: The most recent journal block of the pair
609 * @older: The older journal block of the pair
610 *
611 * Compute the distance (in the journal direction) between two
612 * blocks in the journal
613 *
614 * Returns: the distance in blocks
615 */
616
617static inline unsigned int log_distance(struct gfs2_sbd *sdp, unsigned int newer,
618 unsigned int older)
619{
620 int dist;
621
622 dist = newer - older;
623 if (dist < 0)
624 dist += sdp->sd_jdesc->jd_blocks;
625
626 return dist;
627}
628
629/**
630 * calc_reserved - Calculate the number of blocks to keep reserved
631 * @sdp: The GFS2 superblock
632 *
633 * This is complex. We need to reserve room for all our currently used
634 * metadata blocks (e.g. normal file I/O rewriting file time stamps) and
635 * all our journaled data blocks for journaled files (e.g. files in the
636 * meta_fs like rindex, or files for which chattr +j was done.)
637 * If we don't reserve enough space, corruption will follow.
638 *
639 * We can have metadata blocks and jdata blocks in the same journal. Each
640 * type gets its own log descriptor, for which we need to reserve a block.
641 * In fact, each type has the potential for needing more than one log descriptor
642 * in cases where we have more blocks than will fit in a log descriptor.
643 * Metadata journal entries take up half the space of journaled buffer entries.
644 *
645 * Also, we need to reserve blocks for revoke journal entries and one for an
646 * overall header for the lot.
647 *
648 * Returns: the number of blocks reserved
649 */
650static unsigned int calc_reserved(struct gfs2_sbd *sdp)
651{
652 unsigned int reserved = GFS2_LOG_FLUSH_MIN_BLOCKS;
653 unsigned int blocks;
654 struct gfs2_trans *tr = sdp->sd_log_tr;
655
656 if (tr) {
657 blocks = tr->tr_num_buf_new - tr->tr_num_buf_rm;
658 reserved += blocks + DIV_ROUND_UP(blocks, buf_limit(sdp));
659 blocks = tr->tr_num_databuf_new - tr->tr_num_databuf_rm;
660 reserved += blocks + DIV_ROUND_UP(blocks, databuf_limit(sdp));
661 }
662 return reserved;
663}
664
665static void log_pull_tail(struct gfs2_sbd *sdp)
666{
667 unsigned int new_tail = sdp->sd_log_flush_tail;
668 unsigned int dist;
669
670 if (new_tail == sdp->sd_log_tail)
671 return;
672 dist = log_distance(sdp, newer: new_tail, older: sdp->sd_log_tail);
673 ail2_empty(sdp, new_tail);
674 gfs2_log_release(sdp, blks: dist);
675 sdp->sd_log_tail = new_tail;
676}
677
678
679void log_flush_wait(struct gfs2_sbd *sdp)
680{
681 DEFINE_WAIT(wait);
682
683 if (atomic_read(v: &sdp->sd_log_in_flight)) {
684 do {
685 prepare_to_wait(wq_head: &sdp->sd_log_flush_wait, wq_entry: &wait,
686 TASK_UNINTERRUPTIBLE);
687 if (atomic_read(v: &sdp->sd_log_in_flight))
688 io_schedule();
689 } while(atomic_read(v: &sdp->sd_log_in_flight));
690 finish_wait(wq_head: &sdp->sd_log_flush_wait, wq_entry: &wait);
691 }
692}
693
694static int ip_cmp(void *priv, const struct list_head *a, const struct list_head *b)
695{
696 struct gfs2_inode *ipa, *ipb;
697
698 ipa = list_entry(a, struct gfs2_inode, i_ordered);
699 ipb = list_entry(b, struct gfs2_inode, i_ordered);
700
701 if (ipa->i_no_addr < ipb->i_no_addr)
702 return -1;
703 if (ipa->i_no_addr > ipb->i_no_addr)
704 return 1;
705 return 0;
706}
707
708static void __ordered_del_inode(struct gfs2_inode *ip)
709{
710 if (!list_empty(head: &ip->i_ordered))
711 list_del_init(entry: &ip->i_ordered);
712}
713
714static void gfs2_ordered_write(struct gfs2_sbd *sdp)
715{
716 struct gfs2_inode *ip;
717 LIST_HEAD(written);
718
719 spin_lock(lock: &sdp->sd_ordered_lock);
720 list_sort(NULL, head: &sdp->sd_log_ordered, cmp: &ip_cmp);
721 while (!list_empty(head: &sdp->sd_log_ordered)) {
722 ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered);
723 if (ip->i_inode.i_mapping->nrpages == 0) {
724 __ordered_del_inode(ip);
725 continue;
726 }
727 list_move(list: &ip->i_ordered, head: &written);
728 spin_unlock(lock: &sdp->sd_ordered_lock);
729 filemap_fdatawrite(ip->i_inode.i_mapping);
730 spin_lock(lock: &sdp->sd_ordered_lock);
731 }
732 list_splice(list: &written, head: &sdp->sd_log_ordered);
733 spin_unlock(lock: &sdp->sd_ordered_lock);
734}
735
736static void gfs2_ordered_wait(struct gfs2_sbd *sdp)
737{
738 struct gfs2_inode *ip;
739
740 spin_lock(lock: &sdp->sd_ordered_lock);
741 while (!list_empty(head: &sdp->sd_log_ordered)) {
742 ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered);
743 __ordered_del_inode(ip);
744 if (ip->i_inode.i_mapping->nrpages == 0)
745 continue;
746 spin_unlock(lock: &sdp->sd_ordered_lock);
747 filemap_fdatawait(mapping: ip->i_inode.i_mapping);
748 spin_lock(lock: &sdp->sd_ordered_lock);
749 }
750 spin_unlock(lock: &sdp->sd_ordered_lock);
751}
752
753void gfs2_ordered_del_inode(struct gfs2_inode *ip)
754{
755 struct gfs2_sbd *sdp = GFS2_SB(inode: &ip->i_inode);
756
757 spin_lock(lock: &sdp->sd_ordered_lock);
758 __ordered_del_inode(ip);
759 spin_unlock(lock: &sdp->sd_ordered_lock);
760}
761
762void gfs2_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
763{
764 struct buffer_head *bh = bd->bd_bh;
765 struct gfs2_glock *gl = bd->bd_gl;
766
767 sdp->sd_log_num_revoke++;
768 if (atomic_inc_return(v: &gl->gl_revokes) == 1)
769 gfs2_glock_hold(gl);
770 bh->b_private = NULL;
771 bd->bd_blkno = bh->b_blocknr;
772 gfs2_remove_from_ail(bd); /* drops ref on bh */
773 bd->bd_bh = NULL;
774 set_bit(nr: GLF_LFLUSH, addr: &gl->gl_flags);
775 list_add(new: &bd->bd_list, head: &sdp->sd_log_revokes);
776}
777
778void gfs2_glock_remove_revoke(struct gfs2_glock *gl)
779{
780 if (atomic_dec_return(v: &gl->gl_revokes) == 0) {
781 clear_bit(nr: GLF_LFLUSH, addr: &gl->gl_flags);
782 gfs2_glock_put_async(gl);
783 }
784}
785
786/**
787 * gfs2_flush_revokes - Add as many revokes to the system transaction as we can
788 * @sdp: The GFS2 superblock
789 *
790 * Our usual strategy is to defer writing revokes as much as we can in the hope
791 * that we'll eventually overwrite the journal, which will make those revokes
792 * go away. This changes when we flush the log: at that point, there will
793 * likely be some left-over space in the last revoke block of that transaction.
794 * We can fill that space with additional revokes for blocks that have already
795 * been written back. This will basically come at no cost now, and will save
796 * us from having to keep track of those blocks on the AIL2 list later.
797 */
798void gfs2_flush_revokes(struct gfs2_sbd *sdp)
799{
800 /* number of revokes we still have room for */
801 unsigned int max_revokes = atomic_read(v: &sdp->sd_log_revokes_available);
802
803 gfs2_log_lock(sdp);
804 gfs2_ail1_empty(sdp, max_revokes);
805 gfs2_log_unlock(sdp);
806}
807
808/**
809 * gfs2_write_log_header - Write a journal log header buffer at lblock
810 * @sdp: The GFS2 superblock
811 * @jd: journal descriptor of the journal to which we are writing
812 * @seq: sequence number
813 * @tail: tail of the log
814 * @lblock: value for lh_blkno (block number relative to start of journal)
815 * @flags: log header flags GFS2_LOG_HEAD_*
816 * @op_flags: flags to pass to the bio
817 *
818 * Returns: the initialized log buffer descriptor
819 */
820
821void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
822 u64 seq, u32 tail, u32 lblock, u32 flags,
823 blk_opf_t op_flags)
824{
825 struct gfs2_log_header *lh;
826 u32 hash, crc;
827 struct page *page;
828 struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
829 struct timespec64 tv;
830 struct super_block *sb = sdp->sd_vfs;
831 u64 dblock;
832
833 if (gfs2_withdrawn(sdp))
834 return;
835
836 page = mempool_alloc(gfs2_page_pool, GFP_NOIO);
837 lh = page_address(page);
838 clear_page(page: lh);
839
840 lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
841 lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
842 lh->lh_header.__pad0 = cpu_to_be64(0);
843 lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
844 lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid);
845 lh->lh_sequence = cpu_to_be64(seq);
846 lh->lh_flags = cpu_to_be32(flags);
847 lh->lh_tail = cpu_to_be32(tail);
848 lh->lh_blkno = cpu_to_be32(lblock);
849 hash = ~crc32(crc: ~0, p: lh, LH_V1_SIZE);
850 lh->lh_hash = cpu_to_be32(hash);
851
852 ktime_get_coarse_real_ts64(ts: &tv);
853 lh->lh_nsec = cpu_to_be32(tv.tv_nsec);
854 lh->lh_sec = cpu_to_be64(tv.tv_sec);
855 if (!list_empty(head: &jd->extent_list))
856 dblock = gfs2_log_bmap(jd, lbn: lblock);
857 else {
858 unsigned int extlen;
859 int ret;
860
861 extlen = 1;
862 ret = gfs2_get_extent(inode: jd->jd_inode, lblock, dblock: &dblock, extlen: &extlen);
863 if (gfs2_assert_withdraw(sdp, ret == 0))
864 return;
865 }
866 lh->lh_addr = cpu_to_be64(dblock);
867 lh->lh_jinode = cpu_to_be64(GFS2_I(jd->jd_inode)->i_no_addr);
868
869 /* We may only write local statfs, quota, etc., when writing to our
870 own journal. The values are left 0 when recovering a journal
871 different from our own. */
872 if (!(flags & GFS2_LOG_HEAD_RECOVERY)) {
873 lh->lh_statfs_addr =
874 cpu_to_be64(GFS2_I(sdp->sd_sc_inode)->i_no_addr);
875 lh->lh_quota_addr =
876 cpu_to_be64(GFS2_I(sdp->sd_qc_inode)->i_no_addr);
877
878 spin_lock(lock: &sdp->sd_statfs_spin);
879 lh->lh_local_total = cpu_to_be64(l_sc->sc_total);
880 lh->lh_local_free = cpu_to_be64(l_sc->sc_free);
881 lh->lh_local_dinodes = cpu_to_be64(l_sc->sc_dinodes);
882 spin_unlock(lock: &sdp->sd_statfs_spin);
883 }
884
885 BUILD_BUG_ON(offsetof(struct gfs2_log_header, lh_crc) != LH_V1_SIZE);
886
887 crc = crc32c(crc: ~0, p: (void *)lh + LH_V1_SIZE + 4,
888 len: sb->s_blocksize - LH_V1_SIZE - 4);
889 lh->lh_crc = cpu_to_be32(crc);
890
891 gfs2_log_write(sdp, jd, page, size: sb->s_blocksize, offset: 0, blkno: dblock);
892 gfs2_log_submit_bio(biop: &jd->jd_log_bio, opf: REQ_OP_WRITE | op_flags);
893}
894
895/**
896 * log_write_header - Get and initialize a journal header buffer
897 * @sdp: The GFS2 superblock
898 * @flags: The log header flags, including log header origin
899 *
900 * Returns: the initialized log buffer descriptor
901 */
902
903static void log_write_header(struct gfs2_sbd *sdp, u32 flags)
904{
905 blk_opf_t op_flags = REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC;
906 struct super_block *sb = sdp->sd_vfs;
907
908 gfs2_assert_withdraw(sdp, sb->s_writers.frozen != SB_FREEZE_COMPLETE);
909
910 if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags)) {
911 gfs2_ordered_wait(sdp);
912 log_flush_wait(sdp);
913 op_flags = REQ_SYNC | REQ_META | REQ_PRIO;
914 }
915 sdp->sd_log_idle = (sdp->sd_log_flush_tail == sdp->sd_log_flush_head);
916 gfs2_write_log_header(sdp, jd: sdp->sd_jdesc, seq: sdp->sd_log_sequence++,
917 tail: sdp->sd_log_flush_tail, lblock: sdp->sd_log_flush_head,
918 flags, op_flags);
919 gfs2_log_incr_head(sdp);
920 log_flush_wait(sdp);
921 log_pull_tail(sdp);
922 gfs2_log_update_head(sdp);
923}
924
925/**
926 * gfs2_ail_drain - drain the ail lists after a withdraw
927 * @sdp: Pointer to GFS2 superblock
928 */
929void gfs2_ail_drain(struct gfs2_sbd *sdp)
930{
931 struct gfs2_trans *tr;
932
933 spin_lock(lock: &sdp->sd_ail_lock);
934 /*
935 * For transactions on the sd_ail1_list we need to drain both the
936 * ail1 and ail2 lists. That's because function gfs2_ail1_start_one
937 * (temporarily) moves items from its tr_ail1 list to tr_ail2 list
938 * before revokes are sent for that block. Items on the sd_ail2_list
939 * should have already gotten beyond that point, so no need.
940 */
941 while (!list_empty(head: &sdp->sd_ail1_list)) {
942 tr = list_first_entry(&sdp->sd_ail1_list, struct gfs2_trans,
943 tr_list);
944 gfs2_ail_empty_tr(sdp, tr, head: &tr->tr_ail1_list);
945 gfs2_ail_empty_tr(sdp, tr, head: &tr->tr_ail2_list);
946 list_del(entry: &tr->tr_list);
947 gfs2_trans_free(sdp, tr);
948 }
949 while (!list_empty(head: &sdp->sd_ail2_list)) {
950 tr = list_first_entry(&sdp->sd_ail2_list, struct gfs2_trans,
951 tr_list);
952 gfs2_ail_empty_tr(sdp, tr, head: &tr->tr_ail2_list);
953 list_del(entry: &tr->tr_list);
954 gfs2_trans_free(sdp, tr);
955 }
956 gfs2_drain_revokes(sdp);
957 spin_unlock(lock: &sdp->sd_ail_lock);
958}
959
960/**
961 * empty_ail1_list - try to start IO and empty the ail1 list
962 * @sdp: Pointer to GFS2 superblock
963 */
964static void empty_ail1_list(struct gfs2_sbd *sdp)
965{
966 unsigned long start = jiffies;
967 bool empty = false;
968
969 while (!empty) {
970 if (time_after(jiffies, start + (HZ * 600))) {
971 fs_err(sdp, "Error: In %s for 10 minutes! t=%d\n",
972 __func__, current->journal_info ? 1 : 0);
973 dump_ail_list(sdp);
974 return;
975 }
976 gfs2_ail1_start(sdp);
977 gfs2_ail1_wait(sdp);
978 empty = gfs2_ail1_empty(sdp, max_revokes: 0);
979
980 if (gfs2_withdrawn(sdp))
981 break;
982 }
983}
984
985/**
986 * trans_drain - drain the buf and databuf queue for a failed transaction
987 * @tr: the transaction to drain
988 *
989 * When this is called, we're taking an error exit for a log write that failed
990 * but since we bypassed the after_commit functions, we need to remove the
991 * items from the buf and databuf queue.
992 */
993static void trans_drain(struct gfs2_trans *tr)
994{
995 struct gfs2_bufdata *bd;
996 struct list_head *head;
997
998 if (!tr)
999 return;
1000
1001 head = &tr->tr_buf;
1002 while (!list_empty(head)) {
1003 bd = list_first_entry(head, struct gfs2_bufdata, bd_list);
1004 list_del_init(entry: &bd->bd_list);
1005 if (!list_empty(head: &bd->bd_ail_st_list))
1006 gfs2_remove_from_ail(bd);
1007 kmem_cache_free(s: gfs2_bufdata_cachep, objp: bd);
1008 }
1009 head = &tr->tr_databuf;
1010 while (!list_empty(head)) {
1011 bd = list_first_entry(head, struct gfs2_bufdata, bd_list);
1012 list_del_init(entry: &bd->bd_list);
1013 if (!list_empty(head: &bd->bd_ail_st_list))
1014 gfs2_remove_from_ail(bd);
1015 kmem_cache_free(s: gfs2_bufdata_cachep, objp: bd);
1016 }
1017}
1018
1019/**
1020 * gfs2_log_flush - flush incore transaction(s)
1021 * @sdp: The filesystem
1022 * @gl: The glock structure to flush. If NULL, flush the whole incore log
1023 * @flags: The log header flags: GFS2_LOG_HEAD_FLUSH_* and debug flags
1024 *
1025 */
1026
1027void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl, u32 flags)
1028{
1029 struct gfs2_trans *tr = NULL;
1030 unsigned int reserved_blocks = 0, used_blocks = 0;
1031 bool frozen = test_bit(SDF_FROZEN, &sdp->sd_flags);
1032 unsigned int first_log_head;
1033 unsigned int reserved_revokes = 0;
1034
1035 down_write(sem: &sdp->sd_log_flush_lock);
1036 trace_gfs2_log_flush(sdp, start: 1, flags);
1037
1038repeat:
1039 /*
1040 * Do this check while holding the log_flush_lock to prevent new
1041 * buffers from being added to the ail via gfs2_pin()
1042 */
1043 if (gfs2_withdrawn(sdp) ||
1044 !test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
1045 goto out;
1046
1047 /* Log might have been flushed while we waited for the flush lock */
1048 if (gl && !test_bit(GLF_LFLUSH, &gl->gl_flags))
1049 goto out;
1050
1051 first_log_head = sdp->sd_log_head;
1052 sdp->sd_log_flush_head = first_log_head;
1053
1054 tr = sdp->sd_log_tr;
1055 if (tr || sdp->sd_log_num_revoke) {
1056 if (reserved_blocks)
1057 gfs2_log_release(sdp, blks: reserved_blocks);
1058 reserved_blocks = sdp->sd_log_blks_reserved;
1059 reserved_revokes = sdp->sd_log_num_revoke;
1060 if (tr) {
1061 sdp->sd_log_tr = NULL;
1062 tr->tr_first = first_log_head;
1063 if (unlikely(frozen)) {
1064 if (gfs2_assert_withdraw(sdp,
1065 !tr->tr_num_buf_new && !tr->tr_num_databuf_new))
1066 goto out_withdraw;
1067 }
1068 }
1069 } else if (!reserved_blocks) {
1070 unsigned int taboo_blocks = GFS2_LOG_FLUSH_MIN_BLOCKS;
1071
1072 reserved_blocks = GFS2_LOG_FLUSH_MIN_BLOCKS;
1073 if (current == sdp->sd_logd_process)
1074 taboo_blocks = 0;
1075
1076 if (!__gfs2_log_try_reserve(sdp, blks: reserved_blocks, taboo_blks: taboo_blocks)) {
1077 up_write(sem: &sdp->sd_log_flush_lock);
1078 __gfs2_log_reserve(sdp, blks: reserved_blocks, taboo_blks: taboo_blocks);
1079 down_write(sem: &sdp->sd_log_flush_lock);
1080 goto repeat;
1081 }
1082 BUG_ON(sdp->sd_log_num_revoke);
1083 }
1084
1085 if (flags & GFS2_LOG_HEAD_FLUSH_SHUTDOWN)
1086 clear_bit(nr: SDF_JOURNAL_LIVE, addr: &sdp->sd_flags);
1087
1088 if (unlikely(frozen))
1089 if (gfs2_assert_withdraw(sdp, !reserved_revokes))
1090 goto out_withdraw;
1091
1092 gfs2_ordered_write(sdp);
1093 if (gfs2_withdrawn(sdp))
1094 goto out_withdraw;
1095 lops_before_commit(sdp, tr);
1096 if (gfs2_withdrawn(sdp))
1097 goto out_withdraw;
1098 if (sdp->sd_jdesc)
1099 gfs2_log_submit_bio(biop: &sdp->sd_jdesc->jd_log_bio, opf: REQ_OP_WRITE);
1100 if (gfs2_withdrawn(sdp))
1101 goto out_withdraw;
1102
1103 if (sdp->sd_log_head != sdp->sd_log_flush_head) {
1104 log_write_header(sdp, flags);
1105 } else if (sdp->sd_log_tail != sdp->sd_log_flush_tail && !sdp->sd_log_idle) {
1106 log_write_header(sdp, flags);
1107 }
1108 if (gfs2_withdrawn(sdp))
1109 goto out_withdraw;
1110 lops_after_commit(sdp, tr);
1111
1112 gfs2_log_lock(sdp);
1113 sdp->sd_log_blks_reserved = 0;
1114
1115 spin_lock(lock: &sdp->sd_ail_lock);
1116 if (tr && !list_empty(head: &tr->tr_ail1_list)) {
1117 list_add(new: &tr->tr_list, head: &sdp->sd_ail1_list);
1118 tr = NULL;
1119 }
1120 spin_unlock(lock: &sdp->sd_ail_lock);
1121 gfs2_log_unlock(sdp);
1122
1123 if (!(flags & GFS2_LOG_HEAD_FLUSH_NORMAL)) {
1124 if (!sdp->sd_log_idle) {
1125 empty_ail1_list(sdp);
1126 if (gfs2_withdrawn(sdp))
1127 goto out_withdraw;
1128 log_write_header(sdp, flags);
1129 }
1130 if (flags & (GFS2_LOG_HEAD_FLUSH_SHUTDOWN |
1131 GFS2_LOG_HEAD_FLUSH_FREEZE))
1132 gfs2_log_shutdown(sdp);
1133 }
1134
1135out_end:
1136 used_blocks = log_distance(sdp, newer: sdp->sd_log_flush_head, older: first_log_head);
1137 reserved_revokes += atomic_read(v: &sdp->sd_log_revokes_available);
1138 atomic_set(v: &sdp->sd_log_revokes_available, i: sdp->sd_ldptrs);
1139 gfs2_assert_withdraw(sdp, reserved_revokes % sdp->sd_inptrs == sdp->sd_ldptrs);
1140 if (reserved_revokes > sdp->sd_ldptrs)
1141 reserved_blocks += (reserved_revokes - sdp->sd_ldptrs) / sdp->sd_inptrs;
1142out:
1143 if (used_blocks != reserved_blocks) {
1144 gfs2_assert_withdraw(sdp, used_blocks < reserved_blocks);
1145 gfs2_log_release(sdp, blks: reserved_blocks - used_blocks);
1146 }
1147 up_write(sem: &sdp->sd_log_flush_lock);
1148 gfs2_trans_free(sdp, tr);
1149 trace_gfs2_log_flush(sdp, start: 0, flags);
1150 return;
1151
1152out_withdraw:
1153 trans_drain(tr);
1154 /**
1155 * If the tr_list is empty, we're withdrawing during a log
1156 * flush that targets a transaction, but the transaction was
1157 * never queued onto any of the ail lists. Here we add it to
1158 * ail1 just so that ail_drain() will find and free it.
1159 */
1160 spin_lock(lock: &sdp->sd_ail_lock);
1161 if (tr && list_empty(head: &tr->tr_list))
1162 list_add(new: &tr->tr_list, head: &sdp->sd_ail1_list);
1163 spin_unlock(lock: &sdp->sd_ail_lock);
1164 tr = NULL;
1165 goto out_end;
1166}
1167
1168/**
1169 * gfs2_merge_trans - Merge a new transaction into a cached transaction
1170 * @sdp: the filesystem
1171 * @new: New transaction to be merged
1172 */
1173
1174static void gfs2_merge_trans(struct gfs2_sbd *sdp, struct gfs2_trans *new)
1175{
1176 struct gfs2_trans *old = sdp->sd_log_tr;
1177
1178 WARN_ON_ONCE(!test_bit(TR_ATTACHED, &old->tr_flags));
1179
1180 old->tr_num_buf_new += new->tr_num_buf_new;
1181 old->tr_num_databuf_new += new->tr_num_databuf_new;
1182 old->tr_num_buf_rm += new->tr_num_buf_rm;
1183 old->tr_num_databuf_rm += new->tr_num_databuf_rm;
1184 old->tr_revokes += new->tr_revokes;
1185 old->tr_num_revoke += new->tr_num_revoke;
1186
1187 list_splice_tail_init(list: &new->tr_databuf, head: &old->tr_databuf);
1188 list_splice_tail_init(list: &new->tr_buf, head: &old->tr_buf);
1189
1190 spin_lock(lock: &sdp->sd_ail_lock);
1191 list_splice_tail_init(list: &new->tr_ail1_list, head: &old->tr_ail1_list);
1192 list_splice_tail_init(list: &new->tr_ail2_list, head: &old->tr_ail2_list);
1193 spin_unlock(lock: &sdp->sd_ail_lock);
1194}
1195
1196static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
1197{
1198 unsigned int reserved;
1199 unsigned int unused;
1200 unsigned int maxres;
1201
1202 gfs2_log_lock(sdp);
1203
1204 if (sdp->sd_log_tr) {
1205 gfs2_merge_trans(sdp, new: tr);
1206 } else if (tr->tr_num_buf_new || tr->tr_num_databuf_new) {
1207 gfs2_assert_withdraw(sdp, !test_bit(TR_ONSTACK, &tr->tr_flags));
1208 sdp->sd_log_tr = tr;
1209 set_bit(nr: TR_ATTACHED, addr: &tr->tr_flags);
1210 }
1211
1212 reserved = calc_reserved(sdp);
1213 maxres = sdp->sd_log_blks_reserved + tr->tr_reserved;
1214 gfs2_assert_withdraw(sdp, maxres >= reserved);
1215 unused = maxres - reserved;
1216 if (unused)
1217 gfs2_log_release(sdp, blks: unused);
1218 sdp->sd_log_blks_reserved = reserved;
1219
1220 gfs2_log_unlock(sdp);
1221}
1222
1223static inline int gfs2_jrnl_flush_reqd(struct gfs2_sbd *sdp)
1224{
1225 return atomic_read(v: &sdp->sd_log_pinned) +
1226 atomic_read(v: &sdp->sd_log_blks_needed) >=
1227 atomic_read(v: &sdp->sd_log_thresh1);
1228}
1229
1230static inline int gfs2_ail_flush_reqd(struct gfs2_sbd *sdp)
1231{
1232 return sdp->sd_jdesc->jd_blocks -
1233 atomic_read(v: &sdp->sd_log_blks_free) +
1234 atomic_read(v: &sdp->sd_log_blks_needed) >=
1235 atomic_read(v: &sdp->sd_log_thresh2);
1236}
1237
1238/**
1239 * gfs2_log_commit - Commit a transaction to the log
1240 * @sdp: the filesystem
1241 * @tr: the transaction
1242 *
1243 * We wake up gfs2_logd if the number of pinned blocks exceed thresh1
1244 * or the total number of used blocks (pinned blocks plus AIL blocks)
1245 * is greater than thresh2.
1246 *
1247 * At mount time thresh1 is 2/5ths of journal size, thresh2 is 4/5ths of
1248 * journal size.
1249 *
1250 * Returns: errno
1251 */
1252
1253void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
1254{
1255 log_refund(sdp, tr);
1256
1257 if (gfs2_ail_flush_reqd(sdp) || gfs2_jrnl_flush_reqd(sdp))
1258 wake_up(&sdp->sd_logd_waitq);
1259}
1260
1261/**
1262 * gfs2_log_shutdown - write a shutdown header into a journal
1263 * @sdp: the filesystem
1264 *
1265 */
1266
1267static void gfs2_log_shutdown(struct gfs2_sbd *sdp)
1268{
1269 gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved);
1270 gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
1271 gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list));
1272
1273 log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT | GFS2_LFC_SHUTDOWN);
1274 log_pull_tail(sdp);
1275
1276 gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail);
1277 gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list));
1278}
1279
1280/**
1281 * gfs2_logd - Update log tail as Active Items get flushed to in-place blocks
1282 * @data: Pointer to GFS2 superblock
1283 *
1284 * Also, periodically check to make sure that we're using the most recent
1285 * journal index.
1286 */
1287
1288int gfs2_logd(void *data)
1289{
1290 struct gfs2_sbd *sdp = data;
1291 unsigned long t = 1;
1292
1293 set_freezable();
1294 while (!kthread_should_stop()) {
1295 if (gfs2_withdrawn(sdp))
1296 break;
1297
1298 if (gfs2_jrnl_flush_reqd(sdp) || t == 0) {
1299 gfs2_ail1_empty(sdp, max_revokes: 0);
1300 gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL |
1301 GFS2_LFC_LOGD_JFLUSH_REQD);
1302 }
1303
1304 if (test_bit(SDF_FORCE_AIL_FLUSH, &sdp->sd_flags) ||
1305 gfs2_ail_flush_reqd(sdp)) {
1306 clear_bit(nr: SDF_FORCE_AIL_FLUSH, addr: &sdp->sd_flags);
1307 gfs2_ail1_start(sdp);
1308 gfs2_ail1_wait(sdp);
1309 gfs2_ail1_empty(sdp, max_revokes: 0);
1310 gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL |
1311 GFS2_LFC_LOGD_AIL_FLUSH_REQD);
1312 }
1313
1314 t = gfs2_tune_get(sdp, gt_logd_secs) * HZ;
1315
1316 t = wait_event_freezable_timeout(sdp->sd_logd_waitq,
1317 test_bit(SDF_FORCE_AIL_FLUSH, &sdp->sd_flags) ||
1318 gfs2_ail_flush_reqd(sdp) ||
1319 gfs2_jrnl_flush_reqd(sdp) ||
1320 gfs2_withdrawn(sdp) ||
1321 kthread_should_stop(),
1322 t);
1323 }
1324
1325 return 0;
1326}
1327
1328

source code of linux/fs/gfs2/log.c