17336d0e6SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2b3b94faaSDavid Teigland /* 3b3b94faaSDavid Teigland * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 4da6dd40dSBob Peterson * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved. 5b3b94faaSDavid Teigland */ 6b3b94faaSDavid Teigland 7b3b94faaSDavid Teigland #include <linux/sched.h> 8b3b94faaSDavid Teigland #include <linux/slab.h> 9b3b94faaSDavid Teigland #include <linux/spinlock.h> 10b3b94faaSDavid Teigland #include <linux/completion.h> 11b3b94faaSDavid Teigland #include <linux/buffer_head.h> 125c676f6dSSteven Whitehouse #include <linux/gfs2_ondisk.h> 1371b86f56SSteven Whitehouse #include <linux/crc32.h> 14c1696fb8SBob Peterson #include <linux/crc32c.h> 15a25311c8SSteven Whitehouse #include <linux/delay.h> 16ec69b188SSteven Whitehouse #include <linux/kthread.h> 17ec69b188SSteven Whitehouse #include <linux/freezer.h> 18254db57fSSteven Whitehouse #include <linux/bio.h> 19885bcecaSSteven Whitehouse #include <linux/blkdev.h> 204667a0ecSSteven Whitehouse #include <linux/writeback.h> 214a36d08dSBob Peterson #include <linux/list_sort.h> 22b3b94faaSDavid Teigland 23b3b94faaSDavid Teigland #include "gfs2.h" 245c676f6dSSteven Whitehouse #include "incore.h" 25b3b94faaSDavid Teigland #include "bmap.h" 26b3b94faaSDavid Teigland #include "glock.h" 27b3b94faaSDavid Teigland #include "log.h" 28b3b94faaSDavid Teigland #include "lops.h" 29b3b94faaSDavid Teigland #include "meta_io.h" 305c676f6dSSteven Whitehouse #include "util.h" 3171b86f56SSteven Whitehouse #include "dir.h" 3263997775SSteven Whitehouse #include "trace_gfs2.h" 33b839dadaSBob Peterson #include "trans.h" 34b3b94faaSDavid Teigland 35feed98a8SBob Peterson static void gfs2_log_shutdown(struct gfs2_sbd *sdp); 36feed98a8SBob Peterson 37b3b94faaSDavid Teigland /** 38b3b94faaSDavid Teigland * gfs2_struct2blk - compute stuff 39b3b94faaSDavid Teigland * @sdp: the filesystem 40b3b94faaSDavid Teigland * @nstruct: the number of structures 41b3b94faaSDavid Teigland * 42b3b94faaSDavid Teigland * Compute the number of log descriptor blocks needed to hold a certain number 43b3b94faaSDavid Teigland * of structures of a certain size. 44b3b94faaSDavid Teigland * 45b3b94faaSDavid Teigland * Returns: the number of blocks needed (minimum is always 1) 46b3b94faaSDavid Teigland */ 47b3b94faaSDavid Teigland 482e9eeaa1SBob Peterson unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct) 49b3b94faaSDavid Teigland { 50b3b94faaSDavid Teigland unsigned int blks; 51b3b94faaSDavid Teigland unsigned int first, second; 52b3b94faaSDavid Teigland 536188e877SAndreas Gruenbacher /* The initial struct gfs2_log_descriptor block */ 54b3b94faaSDavid Teigland blks = 1; 552e9eeaa1SBob Peterson first = sdp->sd_ldptrs; 56b3b94faaSDavid Teigland 57b3b94faaSDavid Teigland if (nstruct > first) { 586188e877SAndreas Gruenbacher /* Subsequent struct gfs2_meta_header blocks */ 592e9eeaa1SBob Peterson second = sdp->sd_inptrs; 605c676f6dSSteven Whitehouse blks += DIV_ROUND_UP(nstruct - first, second); 61b3b94faaSDavid Teigland } 62b3b94faaSDavid Teigland 63b3b94faaSDavid Teigland return blks; 64b3b94faaSDavid Teigland } 65b3b94faaSDavid Teigland 66ddacfaf7SSteven Whitehouse /** 671e1a3d03SSteven Whitehouse * gfs2_remove_from_ail - Remove an entry from the ail lists, updating counters 681e1a3d03SSteven Whitehouse * @mapping: The associated mapping (maybe NULL) 691e1a3d03SSteven Whitehouse * @bd: The gfs2_bufdata to remove 701e1a3d03SSteven Whitehouse * 71c618e87aSSteven Whitehouse * The ail lock _must_ be held when calling this function 721e1a3d03SSteven Whitehouse * 731e1a3d03SSteven Whitehouse */ 741e1a3d03SSteven Whitehouse 7568942870SBob Peterson void gfs2_remove_from_ail(struct gfs2_bufdata *bd) 761e1a3d03SSteven Whitehouse { 7716ca9412SBenjamin Marzinski bd->bd_tr = NULL; 781ad38c43SSteven Whitehouse list_del_init(&bd->bd_ail_st_list); 791ad38c43SSteven Whitehouse list_del_init(&bd->bd_ail_gl_list); 801e1a3d03SSteven Whitehouse atomic_dec(&bd->bd_gl->gl_ail_count); 811e1a3d03SSteven Whitehouse brelse(bd->bd_bh); 821e1a3d03SSteven Whitehouse } 831e1a3d03SSteven Whitehouse 841e1a3d03SSteven Whitehouse /** 85ddacfaf7SSteven Whitehouse * gfs2_ail1_start_one - Start I/O on a part of the AIL 86ddacfaf7SSteven Whitehouse * @sdp: the filesystem 874667a0ecSSteven Whitehouse * @wbc: The writeback control structure 884667a0ecSSteven Whitehouse * @ai: The ail structure 89ddacfaf7SSteven Whitehouse * 90ddacfaf7SSteven Whitehouse */ 91ddacfaf7SSteven Whitehouse 924f1de018SSteven Whitehouse static int gfs2_ail1_start_one(struct gfs2_sbd *sdp, 934667a0ecSSteven Whitehouse struct writeback_control *wbc, 9469511080SBob Peterson struct gfs2_trans *tr) 95d6a079e8SDave Chinner __releases(&sdp->sd_ail_lock) 96d6a079e8SDave Chinner __acquires(&sdp->sd_ail_lock) 97ddacfaf7SSteven Whitehouse { 985ac048bbSSteven Whitehouse struct gfs2_glock *gl = NULL; 994667a0ecSSteven Whitehouse struct address_space *mapping; 100ddacfaf7SSteven Whitehouse struct gfs2_bufdata *bd, *s; 101ddacfaf7SSteven Whitehouse struct buffer_head *bh; 102b1676cbbSBob Peterson int ret = 0; 103ddacfaf7SSteven Whitehouse 10416ca9412SBenjamin Marzinski list_for_each_entry_safe_reverse(bd, s, &tr->tr_ail1_list, bd_ail_st_list) { 105ddacfaf7SSteven Whitehouse bh = bd->bd_bh; 106ddacfaf7SSteven Whitehouse 10716ca9412SBenjamin Marzinski gfs2_assert(sdp, bd->bd_tr == tr); 108ddacfaf7SSteven Whitehouse 109ddacfaf7SSteven Whitehouse if (!buffer_busy(bh)) { 11030fe70a8SBob Peterson if (buffer_uptodate(bh)) { 11130fe70a8SBob Peterson list_move(&bd->bd_ail_st_list, 11230fe70a8SBob Peterson &tr->tr_ail2_list); 11330fe70a8SBob Peterson continue; 11430fe70a8SBob Peterson } 115036330c9SBob Peterson if (!cmpxchg(&sdp->sd_log_error, 0, -EIO)) { 116ddacfaf7SSteven Whitehouse gfs2_io_error_bh(sdp, bh); 11769511080SBob Peterson gfs2_withdraw_delayed(sdp); 1189e1a9ecdSAndreas Gruenbacher } 119ddacfaf7SSteven Whitehouse } 120ddacfaf7SSteven Whitehouse 12130fe70a8SBob Peterson if (gfs2_withdrawn(sdp)) { 12230fe70a8SBob Peterson gfs2_remove_from_ail(bd); 12330fe70a8SBob Peterson continue; 12430fe70a8SBob Peterson } 125ddacfaf7SSteven Whitehouse if (!buffer_dirty(bh)) 126ddacfaf7SSteven Whitehouse continue; 1275ac048bbSSteven Whitehouse if (gl == bd->bd_gl) 1285ac048bbSSteven Whitehouse continue; 1295ac048bbSSteven Whitehouse gl = bd->bd_gl; 13016ca9412SBenjamin Marzinski list_move(&bd->bd_ail_st_list, &tr->tr_ail1_list); 1314667a0ecSSteven Whitehouse mapping = bh->b_page->mapping; 1324f1de018SSteven Whitehouse if (!mapping) 1334f1de018SSteven Whitehouse continue; 134d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 135b1676cbbSBob Peterson ret = generic_writepages(mapping, wbc); 136d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 1374e79e3f0SBob Peterson if (ret == -ENODATA) /* if a jdata write into a new hole */ 1384e79e3f0SBob Peterson ret = 0; /* ignore it */ 139b1676cbbSBob Peterson if (ret || wbc->nr_to_write <= 0) 140ddacfaf7SSteven Whitehouse break; 141b1676cbbSBob Peterson return -EBUSY; 142ddacfaf7SSteven Whitehouse } 1434f1de018SSteven Whitehouse 144b1676cbbSBob Peterson return ret; 1454667a0ecSSteven Whitehouse } 1464667a0ecSSteven Whitehouse 1479592ea80SBob Peterson static void dump_ail_list(struct gfs2_sbd *sdp) 1489592ea80SBob Peterson { 1499592ea80SBob Peterson struct gfs2_trans *tr; 1509592ea80SBob Peterson struct gfs2_bufdata *bd; 1519592ea80SBob Peterson struct buffer_head *bh; 1529592ea80SBob Peterson 1539592ea80SBob Peterson list_for_each_entry_reverse(tr, &sdp->sd_ail1_list, tr_list) { 1549592ea80SBob Peterson list_for_each_entry_reverse(bd, &tr->tr_ail1_list, 1559592ea80SBob Peterson bd_ail_st_list) { 1569592ea80SBob Peterson bh = bd->bd_bh; 1579592ea80SBob Peterson fs_err(sdp, "bd %p: blk:0x%llx bh=%p ", bd, 1589592ea80SBob Peterson (unsigned long long)bd->bd_blkno, bh); 1599592ea80SBob Peterson if (!bh) { 1609592ea80SBob Peterson fs_err(sdp, "\n"); 1619592ea80SBob Peterson continue; 1629592ea80SBob Peterson } 1639592ea80SBob Peterson fs_err(sdp, "0x%llx up2:%d dirt:%d lkd:%d req:%d " 1649592ea80SBob Peterson "map:%d new:%d ar:%d aw:%d delay:%d " 1659592ea80SBob Peterson "io err:%d unwritten:%d dfr:%d pin:%d esc:%d\n", 1669592ea80SBob Peterson (unsigned long long)bh->b_blocknr, 1679592ea80SBob Peterson buffer_uptodate(bh), buffer_dirty(bh), 1689592ea80SBob Peterson buffer_locked(bh), buffer_req(bh), 1699592ea80SBob Peterson buffer_mapped(bh), buffer_new(bh), 1709592ea80SBob Peterson buffer_async_read(bh), buffer_async_write(bh), 1719592ea80SBob Peterson buffer_delay(bh), buffer_write_io_error(bh), 1729592ea80SBob Peterson buffer_unwritten(bh), 1739592ea80SBob Peterson buffer_defer_completion(bh), 1749592ea80SBob Peterson buffer_pinned(bh), buffer_escaped(bh)); 1759592ea80SBob Peterson } 1769592ea80SBob Peterson } 1779592ea80SBob Peterson } 1784667a0ecSSteven Whitehouse 1794667a0ecSSteven Whitehouse /** 1804667a0ecSSteven Whitehouse * gfs2_ail1_flush - start writeback of some ail1 entries 1814667a0ecSSteven Whitehouse * @sdp: The super block 1824667a0ecSSteven Whitehouse * @wbc: The writeback control structure 1834667a0ecSSteven Whitehouse * 1844667a0ecSSteven Whitehouse * Writes back some ail1 entries, according to the limits in the 1854667a0ecSSteven Whitehouse * writeback control structure 1864667a0ecSSteven Whitehouse */ 1874667a0ecSSteven Whitehouse 1884667a0ecSSteven Whitehouse void gfs2_ail1_flush(struct gfs2_sbd *sdp, struct writeback_control *wbc) 1894667a0ecSSteven Whitehouse { 1904667a0ecSSteven Whitehouse struct list_head *head = &sdp->sd_ail1_list; 19116ca9412SBenjamin Marzinski struct gfs2_trans *tr; 192885bcecaSSteven Whitehouse struct blk_plug plug; 19375b46c43SBob Peterson int ret; 1949592ea80SBob Peterson unsigned long flush_start = jiffies; 1954667a0ecSSteven Whitehouse 196c83ae9caSSteven Whitehouse trace_gfs2_ail_flush(sdp, wbc, 1); 197885bcecaSSteven Whitehouse blk_start_plug(&plug); 1984667a0ecSSteven Whitehouse spin_lock(&sdp->sd_ail_lock); 1994f1de018SSteven Whitehouse restart: 20075b46c43SBob Peterson ret = 0; 2019592ea80SBob Peterson if (time_after(jiffies, flush_start + (HZ * 600))) { 202d5dc3d96SBob Peterson fs_err(sdp, "Error: In %s for ten minutes! t=%d\n", 203d5dc3d96SBob Peterson __func__, current->journal_info ? 1 : 0); 2049592ea80SBob Peterson dump_ail_list(sdp); 2059592ea80SBob Peterson goto out; 2069592ea80SBob Peterson } 20716ca9412SBenjamin Marzinski list_for_each_entry_reverse(tr, head, tr_list) { 2084667a0ecSSteven Whitehouse if (wbc->nr_to_write <= 0) 2094667a0ecSSteven Whitehouse break; 210b1676cbbSBob Peterson ret = gfs2_ail1_start_one(sdp, wbc, tr); 211b1676cbbSBob Peterson if (ret) { 212b1676cbbSBob Peterson if (ret == -EBUSY) 2134f1de018SSteven Whitehouse goto restart; 214b1676cbbSBob Peterson break; 215b1676cbbSBob Peterson } 2164667a0ecSSteven Whitehouse } 2179592ea80SBob Peterson out: 2184667a0ecSSteven Whitehouse spin_unlock(&sdp->sd_ail_lock); 219885bcecaSSteven Whitehouse blk_finish_plug(&plug); 22049003128SBob Peterson if (ret) { 22149003128SBob Peterson gfs2_lm(sdp, "gfs2_ail1_start_one (generic_writepages) " 22249003128SBob Peterson "returned: %d\n", ret); 223badb55ecSAndreas Gruenbacher gfs2_withdraw(sdp); 22449003128SBob Peterson } 225c83ae9caSSteven Whitehouse trace_gfs2_ail_flush(sdp, wbc, 0); 2264667a0ecSSteven Whitehouse } 2274667a0ecSSteven Whitehouse 2284667a0ecSSteven Whitehouse /** 2294667a0ecSSteven Whitehouse * gfs2_ail1_start - start writeback of all ail1 entries 2304667a0ecSSteven Whitehouse * @sdp: The superblock 2314667a0ecSSteven Whitehouse */ 2324667a0ecSSteven Whitehouse 2334667a0ecSSteven Whitehouse static void gfs2_ail1_start(struct gfs2_sbd *sdp) 2344667a0ecSSteven Whitehouse { 2354667a0ecSSteven Whitehouse struct writeback_control wbc = { 2364667a0ecSSteven Whitehouse .sync_mode = WB_SYNC_NONE, 2374667a0ecSSteven Whitehouse .nr_to_write = LONG_MAX, 2384667a0ecSSteven Whitehouse .range_start = 0, 2394667a0ecSSteven Whitehouse .range_end = LLONG_MAX, 2404667a0ecSSteven Whitehouse }; 2414667a0ecSSteven Whitehouse 2424667a0ecSSteven Whitehouse return gfs2_ail1_flush(sdp, &wbc); 243ddacfaf7SSteven Whitehouse } 244ddacfaf7SSteven Whitehouse 245ddacfaf7SSteven Whitehouse /** 246ddacfaf7SSteven Whitehouse * gfs2_ail1_empty_one - Check whether or not a trans in the AIL has been synced 247ddacfaf7SSteven Whitehouse * @sdp: the filesystem 2485e4c7632SBob Peterson * @tr: the transaction 2495e4c7632SBob Peterson * @max_revokes: If nonzero, issue revokes for the bd items for written buffers 250ddacfaf7SSteven Whitehouse * 25136c78309SBob Peterson * returns: the transaction's count of remaining active items 252ddacfaf7SSteven Whitehouse */ 253ddacfaf7SSteven Whitehouse 25436c78309SBob Peterson static int gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_trans *tr, 2555e4c7632SBob Peterson int *max_revokes) 256ddacfaf7SSteven Whitehouse { 257ddacfaf7SSteven Whitehouse struct gfs2_bufdata *bd, *s; 258ddacfaf7SSteven Whitehouse struct buffer_head *bh; 25936c78309SBob Peterson int active_count = 0; 260ddacfaf7SSteven Whitehouse 26116ca9412SBenjamin Marzinski list_for_each_entry_safe_reverse(bd, s, &tr->tr_ail1_list, 262ddacfaf7SSteven Whitehouse bd_ail_st_list) { 263ddacfaf7SSteven Whitehouse bh = bd->bd_bh; 26416ca9412SBenjamin Marzinski gfs2_assert(sdp, bd->bd_tr == tr); 265036330c9SBob Peterson /* 266036330c9SBob Peterson * If another process flagged an io error, e.g. writing to the 267036330c9SBob Peterson * journal, error all other bhs and move them off the ail1 to 268036330c9SBob Peterson * prevent a tight loop when unmount tries to flush ail1, 269036330c9SBob Peterson * regardless of whether they're still busy. If no outside 270036330c9SBob Peterson * errors were found and the buffer is busy, move to the next. 271036330c9SBob Peterson * If the ail buffer is not busy and caught an error, flag it 272036330c9SBob Peterson * for others. 273036330c9SBob Peterson */ 27436c78309SBob Peterson if (!sdp->sd_log_error && buffer_busy(bh)) { 27536c78309SBob Peterson active_count++; 276ddacfaf7SSteven Whitehouse continue; 27736c78309SBob Peterson } 278b524abccSBob Peterson if (!buffer_uptodate(bh) && 279036330c9SBob Peterson !cmpxchg(&sdp->sd_log_error, 0, -EIO)) { 280ddacfaf7SSteven Whitehouse gfs2_io_error_bh(sdp, bh); 28169511080SBob Peterson gfs2_withdraw_delayed(sdp); 2829e1a9ecdSAndreas Gruenbacher } 2835e4c7632SBob Peterson /* 2845e4c7632SBob Peterson * If we have space for revokes and the bd is no longer on any 2855e4c7632SBob Peterson * buf list, we can just add a revoke for it immediately and 2865e4c7632SBob Peterson * avoid having to put it on the ail2 list, where it would need 2875e4c7632SBob Peterson * to be revoked later. 2885e4c7632SBob Peterson */ 2895e4c7632SBob Peterson if (*max_revokes && list_empty(&bd->bd_list)) { 2905e4c7632SBob Peterson gfs2_add_revoke(sdp, bd); 2915e4c7632SBob Peterson (*max_revokes)--; 2925e4c7632SBob Peterson continue; 2935e4c7632SBob Peterson } 29416ca9412SBenjamin Marzinski list_move(&bd->bd_ail_st_list, &tr->tr_ail2_list); 295ddacfaf7SSteven Whitehouse } 29636c78309SBob Peterson return active_count; 297ddacfaf7SSteven Whitehouse } 298ddacfaf7SSteven Whitehouse 2994667a0ecSSteven Whitehouse /** 3004667a0ecSSteven Whitehouse * gfs2_ail1_empty - Try to empty the ail1 lists 3014667a0ecSSteven Whitehouse * @sdp: The superblock 3025e4c7632SBob Peterson * @max_revokes: If non-zero, add revokes where appropriate 3034667a0ecSSteven Whitehouse * 3044667a0ecSSteven Whitehouse * Tries to empty the ail1 lists, starting with the oldest first 3054667a0ecSSteven Whitehouse */ 306b3b94faaSDavid Teigland 3075e4c7632SBob Peterson static int gfs2_ail1_empty(struct gfs2_sbd *sdp, int max_revokes) 308b3b94faaSDavid Teigland { 30916ca9412SBenjamin Marzinski struct gfs2_trans *tr, *s; 3105d054964SBenjamin Marzinski int oldest_tr = 1; 311b3b94faaSDavid Teigland int ret; 312b3b94faaSDavid Teigland 313d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 31416ca9412SBenjamin Marzinski list_for_each_entry_safe_reverse(tr, s, &sdp->sd_ail1_list, tr_list) { 31536c78309SBob Peterson if (!gfs2_ail1_empty_one(sdp, tr, &max_revokes) && oldest_tr) 31616ca9412SBenjamin Marzinski list_move(&tr->tr_list, &sdp->sd_ail2_list); 3174667a0ecSSteven Whitehouse else 3185d054964SBenjamin Marzinski oldest_tr = 0; 319b3b94faaSDavid Teigland } 320b3b94faaSDavid Teigland ret = list_empty(&sdp->sd_ail1_list); 321d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 322b3b94faaSDavid Teigland 32369511080SBob Peterson if (test_bit(SDF_WITHDRAWING, &sdp->sd_flags)) { 324badb55ecSAndreas Gruenbacher gfs2_lm(sdp, "fatal: I/O error(s)\n"); 325badb55ecSAndreas Gruenbacher gfs2_withdraw(sdp); 326badb55ecSAndreas Gruenbacher } 3279e1a9ecdSAndreas Gruenbacher 328b3b94faaSDavid Teigland return ret; 329b3b94faaSDavid Teigland } 330b3b94faaSDavid Teigland 33126b06a69SSteven Whitehouse static void gfs2_ail1_wait(struct gfs2_sbd *sdp) 33226b06a69SSteven Whitehouse { 33316ca9412SBenjamin Marzinski struct gfs2_trans *tr; 33426b06a69SSteven Whitehouse struct gfs2_bufdata *bd; 33526b06a69SSteven Whitehouse struct buffer_head *bh; 33626b06a69SSteven Whitehouse 33726b06a69SSteven Whitehouse spin_lock(&sdp->sd_ail_lock); 33816ca9412SBenjamin Marzinski list_for_each_entry_reverse(tr, &sdp->sd_ail1_list, tr_list) { 33916ca9412SBenjamin Marzinski list_for_each_entry(bd, &tr->tr_ail1_list, bd_ail_st_list) { 34026b06a69SSteven Whitehouse bh = bd->bd_bh; 34126b06a69SSteven Whitehouse if (!buffer_locked(bh)) 34226b06a69SSteven Whitehouse continue; 34326b06a69SSteven Whitehouse get_bh(bh); 34426b06a69SSteven Whitehouse spin_unlock(&sdp->sd_ail_lock); 34526b06a69SSteven Whitehouse wait_on_buffer(bh); 34626b06a69SSteven Whitehouse brelse(bh); 34726b06a69SSteven Whitehouse return; 34826b06a69SSteven Whitehouse } 34926b06a69SSteven Whitehouse } 35026b06a69SSteven Whitehouse spin_unlock(&sdp->sd_ail_lock); 35126b06a69SSteven Whitehouse } 352ddacfaf7SSteven Whitehouse 353ddacfaf7SSteven Whitehouse /** 3542ca0c2fbSBob Peterson * gfs2_ail_empty_tr - empty one of the ail lists for a transaction 355ddacfaf7SSteven Whitehouse */ 356ddacfaf7SSteven Whitehouse 3572ca0c2fbSBob Peterson static void gfs2_ail_empty_tr(struct gfs2_sbd *sdp, struct gfs2_trans *tr, 3582ca0c2fbSBob Peterson struct list_head *head) 359ddacfaf7SSteven Whitehouse { 360ddacfaf7SSteven Whitehouse struct gfs2_bufdata *bd; 361ddacfaf7SSteven Whitehouse 362ddacfaf7SSteven Whitehouse while (!list_empty(head)) { 3632ca0c2fbSBob Peterson bd = list_first_entry(head, struct gfs2_bufdata, 364ddacfaf7SSteven Whitehouse bd_ail_st_list); 36516ca9412SBenjamin Marzinski gfs2_assert(sdp, bd->bd_tr == tr); 366f91a0d3eSSteven Whitehouse gfs2_remove_from_ail(bd); 367ddacfaf7SSteven Whitehouse } 368ddacfaf7SSteven Whitehouse } 369ddacfaf7SSteven Whitehouse 3706e80674aSAndreas Gruenbacher static void __ail2_empty(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 371b3b94faaSDavid Teigland { 3722ca0c2fbSBob Peterson gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list); 37316ca9412SBenjamin Marzinski list_del(&tr->tr_list); 37416ca9412SBenjamin Marzinski gfs2_assert_warn(sdp, list_empty(&tr->tr_ail1_list)); 37516ca9412SBenjamin Marzinski gfs2_assert_warn(sdp, list_empty(&tr->tr_ail2_list)); 376b839dadaSBob Peterson gfs2_trans_free(sdp, tr); 377b3b94faaSDavid Teigland } 378b3b94faaSDavid Teigland 3796e80674aSAndreas Gruenbacher static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail) 3806e80674aSAndreas Gruenbacher { 3816e80674aSAndreas Gruenbacher struct list_head *ail2_list = &sdp->sd_ail2_list; 3826e80674aSAndreas Gruenbacher unsigned int old_tail = sdp->sd_log_tail; 3836e80674aSAndreas Gruenbacher struct gfs2_trans *tr, *safe; 3846e80674aSAndreas Gruenbacher 3856e80674aSAndreas Gruenbacher spin_lock(&sdp->sd_ail_lock); 3866e80674aSAndreas Gruenbacher if (old_tail <= new_tail) { 3876e80674aSAndreas Gruenbacher list_for_each_entry_safe(tr, safe, ail2_list, tr_list) { 3886e80674aSAndreas Gruenbacher if (old_tail <= tr->tr_first && tr->tr_first < new_tail) 3896e80674aSAndreas Gruenbacher __ail2_empty(sdp, tr); 3906e80674aSAndreas Gruenbacher } 3916e80674aSAndreas Gruenbacher } else { 3926e80674aSAndreas Gruenbacher list_for_each_entry_safe(tr, safe, ail2_list, tr_list) { 3936e80674aSAndreas Gruenbacher if (old_tail <= tr->tr_first || tr->tr_first < new_tail) 3946e80674aSAndreas Gruenbacher __ail2_empty(sdp, tr); 3956e80674aSAndreas Gruenbacher } 3966e80674aSAndreas Gruenbacher } 397d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 398b3b94faaSDavid Teigland } 399b3b94faaSDavid Teigland 400b3b94faaSDavid Teigland /** 401f3708fb5SAndreas Gruenbacher * gfs2_log_is_empty - Check if the log is empty 402f3708fb5SAndreas Gruenbacher * @sdp: The GFS2 superblock 403f3708fb5SAndreas Gruenbacher */ 404f3708fb5SAndreas Gruenbacher 405f3708fb5SAndreas Gruenbacher bool gfs2_log_is_empty(struct gfs2_sbd *sdp) { 406f3708fb5SAndreas Gruenbacher return atomic_read(&sdp->sd_log_blks_free) == sdp->sd_jdesc->jd_blocks; 407f3708fb5SAndreas Gruenbacher } 408f3708fb5SAndreas Gruenbacher 409f3708fb5SAndreas Gruenbacher /** 41024972557SBenjamin Marzinski * gfs2_log_release - Release a given number of log blocks 41124972557SBenjamin Marzinski * @sdp: The GFS2 superblock 41224972557SBenjamin Marzinski * @blks: The number of blocks 41324972557SBenjamin Marzinski * 41424972557SBenjamin Marzinski */ 41524972557SBenjamin Marzinski 41624972557SBenjamin Marzinski void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks) 41724972557SBenjamin Marzinski { 41824972557SBenjamin Marzinski atomic_add(blks, &sdp->sd_log_blks_free); 41924972557SBenjamin Marzinski trace_gfs2_log_blocks(sdp, blks); 42024972557SBenjamin Marzinski gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <= 42124972557SBenjamin Marzinski sdp->sd_jdesc->jd_blocks); 422*5ae8fff8SAndreas Gruenbacher if (atomic_read(&sdp->sd_log_blks_needed)) 423*5ae8fff8SAndreas Gruenbacher wake_up(&sdp->sd_log_waitq); 42424972557SBenjamin Marzinski } 42524972557SBenjamin Marzinski 42624972557SBenjamin Marzinski /** 427b3b94faaSDavid Teigland * gfs2_log_reserve - Make a log reservation 428b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 429b3b94faaSDavid Teigland * @blks: The number of blocks to reserve 430b3b94faaSDavid Teigland * 43189918647SSteven Whitehouse * Note that we never give out the last few blocks of the journal. Thats 4322332c443SRobert Peterson * due to the fact that there is a small number of header blocks 433b004157aSSteven Whitehouse * associated with each log flush. The exact number can't be known until 434b004157aSSteven Whitehouse * flush time, so we ensure that we have just enough free blocks at all 435b004157aSSteven Whitehouse * times to avoid running out during a log flush. 436b004157aSSteven Whitehouse * 4375e687eacSBenjamin Marzinski * We no longer flush the log here, instead we wake up logd to do that 4385e687eacSBenjamin Marzinski * for us. To avoid the thundering herd and to ensure that we deal fairly 4395e687eacSBenjamin Marzinski * with queued waiters, we use an exclusive wait. This means that when we 4405e687eacSBenjamin Marzinski * get woken with enough journal space to get our reservation, we need to 4415e687eacSBenjamin Marzinski * wake the next waiter on the list. 442b3b94faaSDavid Teigland */ 443b3b94faaSDavid Teigland 444c1eba1b0SAndreas Gruenbacher void gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks) 445b3b94faaSDavid Teigland { 4465d054964SBenjamin Marzinski unsigned reserved_blks = 7 * (4096 / sdp->sd_vfs->s_blocksize); 4475e687eacSBenjamin Marzinski unsigned wanted = blks + reserved_blks; 4485e687eacSBenjamin Marzinski unsigned int free_blocks; 449b3b94faaSDavid Teigland 4505e687eacSBenjamin Marzinski free_blocks = atomic_read(&sdp->sd_log_blks_free); 451*5ae8fff8SAndreas Gruenbacher while (free_blocks >= wanted) { 452*5ae8fff8SAndreas Gruenbacher if (atomic_try_cmpxchg(&sdp->sd_log_blks_free, &free_blocks, 453*5ae8fff8SAndreas Gruenbacher free_blocks - blks)) 454*5ae8fff8SAndreas Gruenbacher return; 455b3b94faaSDavid Teigland } 4565e687eacSBenjamin Marzinski 457*5ae8fff8SAndreas Gruenbacher atomic_add(blks, &sdp->sd_log_blks_needed); 458*5ae8fff8SAndreas Gruenbacher for (;;) { 459*5ae8fff8SAndreas Gruenbacher if (current != sdp->sd_logd_process) 460*5ae8fff8SAndreas Gruenbacher wake_up(&sdp->sd_logd_waitq); 461*5ae8fff8SAndreas Gruenbacher io_wait_event(sdp->sd_log_waitq, 462*5ae8fff8SAndreas Gruenbacher (free_blocks = atomic_read(&sdp->sd_log_blks_free), 463*5ae8fff8SAndreas Gruenbacher free_blocks >= wanted)); 464*5ae8fff8SAndreas Gruenbacher do { 465*5ae8fff8SAndreas Gruenbacher if (atomic_try_cmpxchg(&sdp->sd_log_blks_free, 466*5ae8fff8SAndreas Gruenbacher &free_blocks, 467*5ae8fff8SAndreas Gruenbacher free_blocks - blks)) 468*5ae8fff8SAndreas Gruenbacher goto reserved; 469*5ae8fff8SAndreas Gruenbacher } while (free_blocks >= wanted); 470*5ae8fff8SAndreas Gruenbacher } 471*5ae8fff8SAndreas Gruenbacher 472*5ae8fff8SAndreas Gruenbacher reserved: 473*5ae8fff8SAndreas Gruenbacher trace_gfs2_log_blocks(sdp, -blks); 474*5ae8fff8SAndreas Gruenbacher if (atomic_sub_return(blks, &sdp->sd_log_blks_needed)) 4755e687eacSBenjamin Marzinski wake_up(&sdp->sd_log_waitq); 476b3b94faaSDavid Teigland } 477b3b94faaSDavid Teigland 478b3b94faaSDavid Teigland /** 479b3b94faaSDavid Teigland * log_distance - Compute distance between two journal blocks 480b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 481b3b94faaSDavid Teigland * @newer: The most recent journal block of the pair 482b3b94faaSDavid Teigland * @older: The older journal block of the pair 483b3b94faaSDavid Teigland * 484b3b94faaSDavid Teigland * Compute the distance (in the journal direction) between two 485b3b94faaSDavid Teigland * blocks in the journal 486b3b94faaSDavid Teigland * 487b3b94faaSDavid Teigland * Returns: the distance in blocks 488b3b94faaSDavid Teigland */ 489b3b94faaSDavid Teigland 490faa31ce8SSteven Whitehouse static inline unsigned int log_distance(struct gfs2_sbd *sdp, unsigned int newer, 491b3b94faaSDavid Teigland unsigned int older) 492b3b94faaSDavid Teigland { 493b3b94faaSDavid Teigland int dist; 494b3b94faaSDavid Teigland 495b3b94faaSDavid Teigland dist = newer - older; 496b3b94faaSDavid Teigland if (dist < 0) 497b3b94faaSDavid Teigland dist += sdp->sd_jdesc->jd_blocks; 498b3b94faaSDavid Teigland 499b3b94faaSDavid Teigland return dist; 500b3b94faaSDavid Teigland } 501b3b94faaSDavid Teigland 5022332c443SRobert Peterson /** 5036188e877SAndreas Gruenbacher * calc_reserved - Calculate the number of blocks to keep reserved 5042332c443SRobert Peterson * @sdp: The GFS2 superblock 5052332c443SRobert Peterson * 5062332c443SRobert Peterson * This is complex. We need to reserve room for all our currently used 5076188e877SAndreas Gruenbacher * metadata blocks (e.g. normal file I/O rewriting file time stamps) and 5086188e877SAndreas Gruenbacher * all our journaled data blocks for journaled files (e.g. files in the 5092332c443SRobert Peterson * meta_fs like rindex, or files for which chattr +j was done.) 5106188e877SAndreas Gruenbacher * If we don't reserve enough space, corruption will follow. 5112332c443SRobert Peterson * 5126188e877SAndreas Gruenbacher * We can have metadata blocks and jdata blocks in the same journal. Each 5136188e877SAndreas Gruenbacher * type gets its own log descriptor, for which we need to reserve a block. 5146188e877SAndreas Gruenbacher * In fact, each type has the potential for needing more than one log descriptor 5156188e877SAndreas Gruenbacher * in cases where we have more blocks than will fit in a log descriptor. 5162332c443SRobert Peterson * Metadata journal entries take up half the space of journaled buffer entries. 5172332c443SRobert Peterson * 5182332c443SRobert Peterson * Also, we need to reserve blocks for revoke journal entries and one for an 5192332c443SRobert Peterson * overall header for the lot. 5202332c443SRobert Peterson * 5212332c443SRobert Peterson * Returns: the number of blocks reserved 5222332c443SRobert Peterson */ 5232332c443SRobert Peterson static unsigned int calc_reserved(struct gfs2_sbd *sdp) 5242332c443SRobert Peterson { 5252332c443SRobert Peterson unsigned int reserved = 0; 526022ef4feSSteven Whitehouse unsigned int mbuf; 527022ef4feSSteven Whitehouse unsigned int dbuf; 528022ef4feSSteven Whitehouse struct gfs2_trans *tr = sdp->sd_log_tr; 5292332c443SRobert Peterson 530022ef4feSSteven Whitehouse if (tr) { 531022ef4feSSteven Whitehouse mbuf = tr->tr_num_buf_new - tr->tr_num_buf_rm; 532022ef4feSSteven Whitehouse dbuf = tr->tr_num_databuf_new - tr->tr_num_databuf_rm; 533022ef4feSSteven Whitehouse reserved = mbuf + dbuf; 534022ef4feSSteven Whitehouse /* Account for header blocks */ 535022ef4feSSteven Whitehouse reserved += DIV_ROUND_UP(mbuf, buf_limit(sdp)); 536022ef4feSSteven Whitehouse reserved += DIV_ROUND_UP(dbuf, databuf_limit(sdp)); 537022ef4feSSteven Whitehouse } 5382332c443SRobert Peterson 5395d439758SAndreas Gruenbacher if (sdp->sd_log_committed_revoke > 0) 5405d439758SAndreas Gruenbacher reserved += gfs2_struct2blk(sdp, sdp->sd_log_committed_revoke); 5412332c443SRobert Peterson /* One for the overall header */ 5422332c443SRobert Peterson if (reserved) 5432332c443SRobert Peterson reserved++; 5442332c443SRobert Peterson return reserved; 5452332c443SRobert Peterson } 5462332c443SRobert Peterson 547b3b94faaSDavid Teigland static unsigned int current_tail(struct gfs2_sbd *sdp) 548b3b94faaSDavid Teigland { 54916ca9412SBenjamin Marzinski struct gfs2_trans *tr; 550b3b94faaSDavid Teigland unsigned int tail; 551b3b94faaSDavid Teigland 552d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 553b3b94faaSDavid Teigland 554faa31ce8SSteven Whitehouse if (list_empty(&sdp->sd_ail1_list)) { 555b3b94faaSDavid Teigland tail = sdp->sd_log_head; 556faa31ce8SSteven Whitehouse } else { 557969183bcSAndreas Gruenbacher tr = list_last_entry(&sdp->sd_ail1_list, struct gfs2_trans, 55816ca9412SBenjamin Marzinski tr_list); 55916ca9412SBenjamin Marzinski tail = tr->tr_first; 560b3b94faaSDavid Teigland } 561b3b94faaSDavid Teigland 562d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 563b3b94faaSDavid Teigland 564b3b94faaSDavid Teigland return tail; 565b3b94faaSDavid Teigland } 566b3b94faaSDavid Teigland 5672332c443SRobert Peterson static void log_pull_tail(struct gfs2_sbd *sdp, unsigned int new_tail) 568b3b94faaSDavid Teigland { 569b3b94faaSDavid Teigland unsigned int dist = log_distance(sdp, new_tail, sdp->sd_log_tail); 570b3b94faaSDavid Teigland 571b3b94faaSDavid Teigland ail2_empty(sdp, new_tail); 572c1eba1b0SAndreas Gruenbacher gfs2_log_release(sdp, dist); 573b3b94faaSDavid Teigland sdp->sd_log_tail = new_tail; 574b3b94faaSDavid Teigland } 575b3b94faaSDavid Teigland 576b3b94faaSDavid Teigland 5779ff78289SBob Peterson void log_flush_wait(struct gfs2_sbd *sdp) 578b3b94faaSDavid Teigland { 57916615be1SSteven Whitehouse DEFINE_WAIT(wait); 580b3b94faaSDavid Teigland 58116615be1SSteven Whitehouse if (atomic_read(&sdp->sd_log_in_flight)) { 58216615be1SSteven Whitehouse do { 58316615be1SSteven Whitehouse prepare_to_wait(&sdp->sd_log_flush_wait, &wait, 58416615be1SSteven Whitehouse TASK_UNINTERRUPTIBLE); 58516615be1SSteven Whitehouse if (atomic_read(&sdp->sd_log_in_flight)) 58616615be1SSteven Whitehouse io_schedule(); 58716615be1SSteven Whitehouse } while(atomic_read(&sdp->sd_log_in_flight)); 58816615be1SSteven Whitehouse finish_wait(&sdp->sd_log_flush_wait, &wait); 589b3b94faaSDavid Teigland } 590b3b94faaSDavid Teigland } 591b3b94faaSDavid Teigland 59245138990SSteven Whitehouse static int ip_cmp(void *priv, struct list_head *a, struct list_head *b) 5934a36d08dSBob Peterson { 59445138990SSteven Whitehouse struct gfs2_inode *ipa, *ipb; 5954a36d08dSBob Peterson 59645138990SSteven Whitehouse ipa = list_entry(a, struct gfs2_inode, i_ordered); 59745138990SSteven Whitehouse ipb = list_entry(b, struct gfs2_inode, i_ordered); 5984a36d08dSBob Peterson 59945138990SSteven Whitehouse if (ipa->i_no_addr < ipb->i_no_addr) 6004a36d08dSBob Peterson return -1; 60145138990SSteven Whitehouse if (ipa->i_no_addr > ipb->i_no_addr) 6024a36d08dSBob Peterson return 1; 6034a36d08dSBob Peterson return 0; 6044a36d08dSBob Peterson } 6054a36d08dSBob Peterson 6067542486bSBob Peterson static void __ordered_del_inode(struct gfs2_inode *ip) 6077542486bSBob Peterson { 6087542486bSBob Peterson if (!list_empty(&ip->i_ordered)) 6097542486bSBob Peterson list_del_init(&ip->i_ordered); 6107542486bSBob Peterson } 6117542486bSBob Peterson 612d7b616e2SSteven Whitehouse static void gfs2_ordered_write(struct gfs2_sbd *sdp) 613d7b616e2SSteven Whitehouse { 61445138990SSteven Whitehouse struct gfs2_inode *ip; 615d7b616e2SSteven Whitehouse LIST_HEAD(written); 616d7b616e2SSteven Whitehouse 61745138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 618a5b1d3fcSAndreas Gruenbacher list_sort(NULL, &sdp->sd_log_ordered, &ip_cmp); 619a5b1d3fcSAndreas Gruenbacher while (!list_empty(&sdp->sd_log_ordered)) { 620969183bcSAndreas Gruenbacher ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered); 6211f23bc78SAbhi Das if (ip->i_inode.i_mapping->nrpages == 0) { 6227542486bSBob Peterson __ordered_del_inode(ip); 623d7b616e2SSteven Whitehouse continue; 6241f23bc78SAbhi Das } 6251f23bc78SAbhi Das list_move(&ip->i_ordered, &written); 62645138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 62745138990SSteven Whitehouse filemap_fdatawrite(ip->i_inode.i_mapping); 62845138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 629d7b616e2SSteven Whitehouse } 630a5b1d3fcSAndreas Gruenbacher list_splice(&written, &sdp->sd_log_ordered); 63145138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 632d7b616e2SSteven Whitehouse } 633d7b616e2SSteven Whitehouse 634d7b616e2SSteven Whitehouse static void gfs2_ordered_wait(struct gfs2_sbd *sdp) 635d7b616e2SSteven Whitehouse { 63645138990SSteven Whitehouse struct gfs2_inode *ip; 637d7b616e2SSteven Whitehouse 63845138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 639a5b1d3fcSAndreas Gruenbacher while (!list_empty(&sdp->sd_log_ordered)) { 640969183bcSAndreas Gruenbacher ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered); 6417542486bSBob Peterson __ordered_del_inode(ip); 64245138990SSteven Whitehouse if (ip->i_inode.i_mapping->nrpages == 0) 643d7b616e2SSteven Whitehouse continue; 64445138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 64545138990SSteven Whitehouse filemap_fdatawait(ip->i_inode.i_mapping); 64645138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 647d7b616e2SSteven Whitehouse } 64845138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 649d7b616e2SSteven Whitehouse } 65045138990SSteven Whitehouse 65145138990SSteven Whitehouse void gfs2_ordered_del_inode(struct gfs2_inode *ip) 65245138990SSteven Whitehouse { 65345138990SSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 65445138990SSteven Whitehouse 65545138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 6567542486bSBob Peterson __ordered_del_inode(ip); 65745138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 658d7b616e2SSteven Whitehouse } 659d7b616e2SSteven Whitehouse 6605d054964SBenjamin Marzinski void gfs2_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd) 6615d054964SBenjamin Marzinski { 6625d054964SBenjamin Marzinski struct buffer_head *bh = bd->bd_bh; 6635d054964SBenjamin Marzinski struct gfs2_glock *gl = bd->bd_gl; 6645d054964SBenjamin Marzinski 665f4e2f5e1SAndreas Gruenbacher sdp->sd_log_num_revoke++; 666f4e2f5e1SAndreas Gruenbacher if (atomic_inc_return(&gl->gl_revokes) == 1) 667f4e2f5e1SAndreas Gruenbacher gfs2_glock_hold(gl); 6685d054964SBenjamin Marzinski bh->b_private = NULL; 6695d054964SBenjamin Marzinski bd->bd_blkno = bh->b_blocknr; 6709290a9a7SBob Peterson gfs2_remove_from_ail(bd); /* drops ref on bh */ 6719290a9a7SBob Peterson bd->bd_bh = NULL; 6725d054964SBenjamin Marzinski set_bit(GLF_LFLUSH, &gl->gl_flags); 673a5b1d3fcSAndreas Gruenbacher list_add(&bd->bd_list, &sdp->sd_log_revokes); 6745d054964SBenjamin Marzinski } 6755d054964SBenjamin Marzinski 676fe5e7ba1SBob Peterson void gfs2_glock_remove_revoke(struct gfs2_glock *gl) 677fe5e7ba1SBob Peterson { 678fe5e7ba1SBob Peterson if (atomic_dec_return(&gl->gl_revokes) == 0) { 679fe5e7ba1SBob Peterson clear_bit(GLF_LFLUSH, &gl->gl_flags); 680fe5e7ba1SBob Peterson gfs2_glock_queue_put(gl); 681fe5e7ba1SBob Peterson } 682fe5e7ba1SBob Peterson } 683fe5e7ba1SBob Peterson 6845e4c7632SBob Peterson /** 685e7501bf8SAndreas Gruenbacher * gfs2_flush_revokes - Add as many revokes to the system transaction as we can 6865e4c7632SBob Peterson * @sdp: The GFS2 superblock 6875e4c7632SBob Peterson * 6885e4c7632SBob Peterson * Our usual strategy is to defer writing revokes as much as we can in the hope 6895e4c7632SBob Peterson * that we'll eventually overwrite the journal, which will make those revokes 6905e4c7632SBob Peterson * go away. This changes when we flush the log: at that point, there will 6915e4c7632SBob Peterson * likely be some left-over space in the last revoke block of that transaction. 6925e4c7632SBob Peterson * We can fill that space with additional revokes for blocks that have already 6935e4c7632SBob Peterson * been written back. This will basically come at no cost now, and will save 6945e4c7632SBob Peterson * us from having to keep track of those blocks on the AIL2 list later. 6955e4c7632SBob Peterson */ 696e7501bf8SAndreas Gruenbacher void gfs2_flush_revokes(struct gfs2_sbd *sdp) 6975d054964SBenjamin Marzinski { 6985e4c7632SBob Peterson /* number of revokes we still have room for */ 6995a4e9c60SAndreas Gruenbacher unsigned int max_revokes; 7005d054964SBenjamin Marzinski 7015e4c7632SBob Peterson gfs2_log_lock(sdp); 7025a4e9c60SAndreas Gruenbacher max_revokes = sdp->sd_ldptrs; 7035a4e9c60SAndreas Gruenbacher if (sdp->sd_log_num_revoke > sdp->sd_ldptrs) 7045a4e9c60SAndreas Gruenbacher max_revokes += roundup(sdp->sd_log_num_revoke - sdp->sd_ldptrs, 7055a4e9c60SAndreas Gruenbacher sdp->sd_inptrs); 7065d054964SBenjamin Marzinski max_revokes -= sdp->sd_log_num_revoke; 7075d054964SBenjamin Marzinski if (!sdp->sd_log_num_revoke) { 7085d054964SBenjamin Marzinski atomic_dec(&sdp->sd_log_blks_free); 7095d054964SBenjamin Marzinski /* If no blocks have been reserved, we need to also 7105d054964SBenjamin Marzinski * reserve a block for the header */ 71177650bdbSBob Peterson if (!sdp->sd_log_blks_reserved) { 7125d054964SBenjamin Marzinski atomic_dec(&sdp->sd_log_blks_free); 71377650bdbSBob Peterson trace_gfs2_log_blocks(sdp, -2); 71477650bdbSBob Peterson } else { 71577650bdbSBob Peterson trace_gfs2_log_blocks(sdp, -1); 71677650bdbSBob Peterson } 7175d054964SBenjamin Marzinski } 7185e4c7632SBob Peterson gfs2_ail1_empty(sdp, max_revokes); 7195d054964SBenjamin Marzinski gfs2_log_unlock(sdp); 7205d054964SBenjamin Marzinski 7215d054964SBenjamin Marzinski if (!sdp->sd_log_num_revoke) { 7225d054964SBenjamin Marzinski atomic_inc(&sdp->sd_log_blks_free); 72377650bdbSBob Peterson if (!sdp->sd_log_blks_reserved) { 7245d054964SBenjamin Marzinski atomic_inc(&sdp->sd_log_blks_free); 72577650bdbSBob Peterson trace_gfs2_log_blocks(sdp, 2); 72677650bdbSBob Peterson } else { 72777650bdbSBob Peterson trace_gfs2_log_blocks(sdp, 1); 72877650bdbSBob Peterson } 7295d054964SBenjamin Marzinski } 7305d054964SBenjamin Marzinski } 7315d054964SBenjamin Marzinski 732b3b94faaSDavid Teigland /** 7337c70b896SBob Peterson * gfs2_write_log_header - Write a journal log header buffer at lblock 734588bff95SBob Peterson * @sdp: The GFS2 superblock 735c1696fb8SBob Peterson * @jd: journal descriptor of the journal to which we are writing 736588bff95SBob Peterson * @seq: sequence number 737588bff95SBob Peterson * @tail: tail of the log 7387c70b896SBob Peterson * @lblock: value for lh_blkno (block number relative to start of journal) 739c1696fb8SBob Peterson * @flags: log header flags GFS2_LOG_HEAD_* 740588bff95SBob Peterson * @op_flags: flags to pass to the bio 741588bff95SBob Peterson * 742588bff95SBob Peterson * Returns: the initialized log buffer descriptor 743588bff95SBob Peterson */ 744588bff95SBob Peterson 745c1696fb8SBob Peterson void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd, 7467c70b896SBob Peterson u64 seq, u32 tail, u32 lblock, u32 flags, 7477c70b896SBob Peterson int op_flags) 748588bff95SBob Peterson { 749588bff95SBob Peterson struct gfs2_log_header *lh; 750c1696fb8SBob Peterson u32 hash, crc; 751ade48088SBob Peterson struct page *page; 752c1696fb8SBob Peterson struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 753c1696fb8SBob Peterson struct timespec64 tv; 754c1696fb8SBob Peterson struct super_block *sb = sdp->sd_vfs; 7557c70b896SBob Peterson u64 dblock; 756588bff95SBob Peterson 757ade48088SBob Peterson if (gfs2_withdrawn(sdp)) 7584a3d049dSAndreas Gruenbacher return; 759ade48088SBob Peterson 760ade48088SBob Peterson page = mempool_alloc(gfs2_page_pool, GFP_NOIO); 761588bff95SBob Peterson lh = page_address(page); 762588bff95SBob Peterson clear_page(lh); 763588bff95SBob Peterson 764588bff95SBob Peterson lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 765588bff95SBob Peterson lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH); 766588bff95SBob Peterson lh->lh_header.__pad0 = cpu_to_be64(0); 767588bff95SBob Peterson lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH); 768588bff95SBob Peterson lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid); 769588bff95SBob Peterson lh->lh_sequence = cpu_to_be64(seq); 770588bff95SBob Peterson lh->lh_flags = cpu_to_be32(flags); 771588bff95SBob Peterson lh->lh_tail = cpu_to_be32(tail); 7727c70b896SBob Peterson lh->lh_blkno = cpu_to_be32(lblock); 773c1696fb8SBob Peterson hash = ~crc32(~0, lh, LH_V1_SIZE); 774588bff95SBob Peterson lh->lh_hash = cpu_to_be32(hash); 775588bff95SBob Peterson 776ee9c7f9aSArnd Bergmann ktime_get_coarse_real_ts64(&tv); 777c1696fb8SBob Peterson lh->lh_nsec = cpu_to_be32(tv.tv_nsec); 778c1696fb8SBob Peterson lh->lh_sec = cpu_to_be64(tv.tv_sec); 7797c70b896SBob Peterson if (!list_empty(&jd->extent_list)) 78019ebc050SAndreas Gruenbacher dblock = gfs2_log_bmap(jd, lblock); 7817c70b896SBob Peterson else { 7827c70b896SBob Peterson int ret = gfs2_lblk_to_dblk(jd->jd_inode, lblock, &dblock); 7837c70b896SBob Peterson if (gfs2_assert_withdraw(sdp, ret == 0)) 7847c70b896SBob Peterson return; 7857c70b896SBob Peterson } 7867c70b896SBob Peterson lh->lh_addr = cpu_to_be64(dblock); 787c1696fb8SBob Peterson lh->lh_jinode = cpu_to_be64(GFS2_I(jd->jd_inode)->i_no_addr); 788c1696fb8SBob Peterson 789c1696fb8SBob Peterson /* We may only write local statfs, quota, etc., when writing to our 790c1696fb8SBob Peterson own journal. The values are left 0 when recovering a journal 791c1696fb8SBob Peterson different from our own. */ 792c1696fb8SBob Peterson if (!(flags & GFS2_LOG_HEAD_RECOVERY)) { 793c1696fb8SBob Peterson lh->lh_statfs_addr = 794c1696fb8SBob Peterson cpu_to_be64(GFS2_I(sdp->sd_sc_inode)->i_no_addr); 795c1696fb8SBob Peterson lh->lh_quota_addr = 796c1696fb8SBob Peterson cpu_to_be64(GFS2_I(sdp->sd_qc_inode)->i_no_addr); 797c1696fb8SBob Peterson 798c1696fb8SBob Peterson spin_lock(&sdp->sd_statfs_spin); 799c1696fb8SBob Peterson lh->lh_local_total = cpu_to_be64(l_sc->sc_total); 800c1696fb8SBob Peterson lh->lh_local_free = cpu_to_be64(l_sc->sc_free); 801c1696fb8SBob Peterson lh->lh_local_dinodes = cpu_to_be64(l_sc->sc_dinodes); 802c1696fb8SBob Peterson spin_unlock(&sdp->sd_statfs_spin); 803c1696fb8SBob Peterson } 804c1696fb8SBob Peterson 805c1696fb8SBob Peterson BUILD_BUG_ON(offsetof(struct gfs2_log_header, lh_crc) != LH_V1_SIZE); 806c1696fb8SBob Peterson 807c1696fb8SBob Peterson crc = crc32c(~0, (void *)lh + LH_V1_SIZE + 4, 808c1696fb8SBob Peterson sb->s_blocksize - LH_V1_SIZE - 4); 809c1696fb8SBob Peterson lh->lh_crc = cpu_to_be32(crc); 810c1696fb8SBob Peterson 8117c70b896SBob Peterson gfs2_log_write(sdp, page, sb->s_blocksize, 0, dblock); 812f4686c26SAbhi Das gfs2_log_submit_bio(&sdp->sd_log_bio, REQ_OP_WRITE | op_flags); 813588bff95SBob Peterson } 814588bff95SBob Peterson 815588bff95SBob Peterson /** 81634cc1781SSteven Whitehouse * log_write_header - Get and initialize a journal header buffer 81734cc1781SSteven Whitehouse * @sdp: The GFS2 superblock 818c1696fb8SBob Peterson * @flags: The log header flags, including log header origin 81934cc1781SSteven Whitehouse * 82034cc1781SSteven Whitehouse * Returns: the initialized log buffer descriptor 82134cc1781SSteven Whitehouse */ 82234cc1781SSteven Whitehouse 823fdb76a42SSteven Whitehouse static void log_write_header(struct gfs2_sbd *sdp, u32 flags) 82434cc1781SSteven Whitehouse { 82534cc1781SSteven Whitehouse unsigned int tail; 8260f0b9b63SJan Kara int op_flags = REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC; 8272e60d768SBenjamin Marzinski enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state); 82834cc1781SSteven Whitehouse 8292e60d768SBenjamin Marzinski gfs2_assert_withdraw(sdp, (state != SFS_FROZEN)); 83034cc1781SSteven Whitehouse tail = current_tail(sdp); 83134cc1781SSteven Whitehouse 83234cc1781SSteven Whitehouse if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags)) { 83334cc1781SSteven Whitehouse gfs2_ordered_wait(sdp); 83434cc1781SSteven Whitehouse log_flush_wait(sdp); 83570fd7614SChristoph Hellwig op_flags = REQ_SYNC | REQ_META | REQ_PRIO; 83634cc1781SSteven Whitehouse } 837e8c92ed7SSteven Whitehouse sdp->sd_log_idle = (tail == sdp->sd_log_flush_head); 838c1696fb8SBob Peterson gfs2_write_log_header(sdp, sdp->sd_jdesc, sdp->sd_log_sequence++, tail, 8397c70b896SBob Peterson sdp->sd_log_flush_head, flags, op_flags); 84019ebc050SAndreas Gruenbacher gfs2_log_incr_head(sdp); 8414a3d049dSAndreas Gruenbacher log_flush_wait(sdp); 84234cc1781SSteven Whitehouse 84334cc1781SSteven Whitehouse if (sdp->sd_log_tail != tail) 84434cc1781SSteven Whitehouse log_pull_tail(sdp, tail); 84534cc1781SSteven Whitehouse } 84634cc1781SSteven Whitehouse 84734cc1781SSteven Whitehouse /** 8482ca0c2fbSBob Peterson * ail_drain - drain the ail lists after a withdraw 8492ca0c2fbSBob Peterson * @sdp: Pointer to GFS2 superblock 8502ca0c2fbSBob Peterson */ 8512ca0c2fbSBob Peterson static void ail_drain(struct gfs2_sbd *sdp) 8522ca0c2fbSBob Peterson { 8532ca0c2fbSBob Peterson struct gfs2_trans *tr; 8542ca0c2fbSBob Peterson 8552ca0c2fbSBob Peterson spin_lock(&sdp->sd_ail_lock); 8562ca0c2fbSBob Peterson /* 8572ca0c2fbSBob Peterson * For transactions on the sd_ail1_list we need to drain both the 8582ca0c2fbSBob Peterson * ail1 and ail2 lists. That's because function gfs2_ail1_start_one 8592ca0c2fbSBob Peterson * (temporarily) moves items from its tr_ail1 list to tr_ail2 list 8602ca0c2fbSBob Peterson * before revokes are sent for that block. Items on the sd_ail2_list 8612ca0c2fbSBob Peterson * should have already gotten beyond that point, so no need. 8622ca0c2fbSBob Peterson */ 8632ca0c2fbSBob Peterson while (!list_empty(&sdp->sd_ail1_list)) { 8642ca0c2fbSBob Peterson tr = list_first_entry(&sdp->sd_ail1_list, struct gfs2_trans, 8652ca0c2fbSBob Peterson tr_list); 8662ca0c2fbSBob Peterson gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail1_list); 8672ca0c2fbSBob Peterson gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list); 8682ca0c2fbSBob Peterson list_del(&tr->tr_list); 869b839dadaSBob Peterson gfs2_trans_free(sdp, tr); 8702ca0c2fbSBob Peterson } 8712ca0c2fbSBob Peterson while (!list_empty(&sdp->sd_ail2_list)) { 8722ca0c2fbSBob Peterson tr = list_first_entry(&sdp->sd_ail2_list, struct gfs2_trans, 8732ca0c2fbSBob Peterson tr_list); 8742ca0c2fbSBob Peterson gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list); 8752ca0c2fbSBob Peterson list_del(&tr->tr_list); 876b839dadaSBob Peterson gfs2_trans_free(sdp, tr); 8772ca0c2fbSBob Peterson } 8782ca0c2fbSBob Peterson spin_unlock(&sdp->sd_ail_lock); 8792ca0c2fbSBob Peterson } 8802ca0c2fbSBob Peterson 8812ca0c2fbSBob Peterson /** 882d5dc3d96SBob Peterson * empty_ail1_list - try to start IO and empty the ail1 list 883d5dc3d96SBob Peterson * @sdp: Pointer to GFS2 superblock 884d5dc3d96SBob Peterson */ 885d5dc3d96SBob Peterson static void empty_ail1_list(struct gfs2_sbd *sdp) 886d5dc3d96SBob Peterson { 887d5dc3d96SBob Peterson unsigned long start = jiffies; 888d5dc3d96SBob Peterson 889d5dc3d96SBob Peterson for (;;) { 890d5dc3d96SBob Peterson if (time_after(jiffies, start + (HZ * 600))) { 891d5dc3d96SBob Peterson fs_err(sdp, "Error: In %s for 10 minutes! t=%d\n", 892d5dc3d96SBob Peterson __func__, current->journal_info ? 1 : 0); 893d5dc3d96SBob Peterson dump_ail_list(sdp); 894d5dc3d96SBob Peterson return; 895d5dc3d96SBob Peterson } 896d5dc3d96SBob Peterson gfs2_ail1_start(sdp); 897d5dc3d96SBob Peterson gfs2_ail1_wait(sdp); 898d5dc3d96SBob Peterson if (gfs2_ail1_empty(sdp, 0)) 899d5dc3d96SBob Peterson return; 900d5dc3d96SBob Peterson } 901d5dc3d96SBob Peterson } 902d5dc3d96SBob Peterson 903d5dc3d96SBob Peterson /** 904521031faSBob Peterson * trans_drain - drain the buf and databuf queue for a failed transaction 905462582b9SBob Peterson * @tr: the transaction to drain 906462582b9SBob Peterson * 907462582b9SBob Peterson * When this is called, we're taking an error exit for a log write that failed 908462582b9SBob Peterson * but since we bypassed the after_commit functions, we need to remove the 909462582b9SBob Peterson * items from the buf and databuf queue. 910462582b9SBob Peterson */ 911462582b9SBob Peterson static void trans_drain(struct gfs2_trans *tr) 912462582b9SBob Peterson { 913462582b9SBob Peterson struct gfs2_bufdata *bd; 914462582b9SBob Peterson struct list_head *head; 915462582b9SBob Peterson 916462582b9SBob Peterson if (!tr) 917462582b9SBob Peterson return; 918462582b9SBob Peterson 919462582b9SBob Peterson head = &tr->tr_buf; 920462582b9SBob Peterson while (!list_empty(head)) { 921462582b9SBob Peterson bd = list_first_entry(head, struct gfs2_bufdata, bd_list); 922462582b9SBob Peterson list_del_init(&bd->bd_list); 923462582b9SBob Peterson kmem_cache_free(gfs2_bufdata_cachep, bd); 924462582b9SBob Peterson } 925462582b9SBob Peterson head = &tr->tr_databuf; 926462582b9SBob Peterson while (!list_empty(head)) { 927462582b9SBob Peterson bd = list_first_entry(head, struct gfs2_bufdata, bd_list); 928462582b9SBob Peterson list_del_init(&bd->bd_list); 929462582b9SBob Peterson kmem_cache_free(gfs2_bufdata_cachep, bd); 930462582b9SBob Peterson } 931462582b9SBob Peterson } 932462582b9SBob Peterson 933462582b9SBob Peterson /** 934b09e593dSSteven Whitehouse * gfs2_log_flush - flush incore transaction(s) 935b3b94faaSDavid Teigland * @sdp: the filesystem 936b3b94faaSDavid Teigland * @gl: The glock structure to flush. If NULL, flush the whole incore log 937805c0907SBob Peterson * @flags: The log header flags: GFS2_LOG_HEAD_FLUSH_* and debug flags 938b3b94faaSDavid Teigland * 939b3b94faaSDavid Teigland */ 940b3b94faaSDavid Teigland 941c1696fb8SBob Peterson void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl, u32 flags) 942b3b94faaSDavid Teigland { 9432ca0c2fbSBob Peterson struct gfs2_trans *tr = NULL; 9442e60d768SBenjamin Marzinski enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state); 945b3b94faaSDavid Teigland 946484adff8SSteven Whitehouse down_write(&sdp->sd_log_flush_lock); 947f55ab26aSSteven Whitehouse 9482ca0c2fbSBob Peterson /* 9492ca0c2fbSBob Peterson * Do this check while holding the log_flush_lock to prevent new 9502ca0c2fbSBob Peterson * buffers from being added to the ail via gfs2_pin() 9512ca0c2fbSBob Peterson */ 9522ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 9532ca0c2fbSBob Peterson goto out; 9542ca0c2fbSBob Peterson 9552bcd610dSSteven Whitehouse /* Log might have been flushed while we waited for the flush lock */ 9565a61ae14SAndreas Gruenbacher if (gl && !test_bit(GLF_LFLUSH, &gl->gl_flags)) 9575a61ae14SAndreas Gruenbacher goto out; 958805c0907SBob Peterson trace_gfs2_log_flush(sdp, 1, flags); 959f55ab26aSSteven Whitehouse 960c1696fb8SBob Peterson if (flags & GFS2_LOG_HEAD_FLUSH_SHUTDOWN) 961400ac52eSBenjamin Marzinski clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags); 962400ac52eSBenjamin Marzinski 963b1ab1e44SSteven Whitehouse sdp->sd_log_flush_head = sdp->sd_log_head; 96416ca9412SBenjamin Marzinski tr = sdp->sd_log_tr; 96516ca9412SBenjamin Marzinski if (tr) { 96616ca9412SBenjamin Marzinski sdp->sd_log_tr = NULL; 967b1ab1e44SSteven Whitehouse tr->tr_first = sdp->sd_log_flush_head; 9682e60d768SBenjamin Marzinski if (unlikely (state == SFS_FROZEN)) 969ca399c96SBob Peterson if (gfs2_assert_withdraw_delayed(sdp, 970ca399c96SBob Peterson !tr->tr_num_buf_new && !tr->tr_num_databuf_new)) 9715a61ae14SAndreas Gruenbacher goto out_withdraw; 97216ca9412SBenjamin Marzinski } 973b3b94faaSDavid Teigland 9742e60d768SBenjamin Marzinski if (unlikely(state == SFS_FROZEN)) 975ca399c96SBob Peterson if (gfs2_assert_withdraw_delayed(sdp, !sdp->sd_log_num_revoke)) 9765a61ae14SAndreas Gruenbacher goto out_withdraw; 977ca399c96SBob Peterson if (gfs2_assert_withdraw_delayed(sdp, 978ca399c96SBob Peterson sdp->sd_log_num_revoke == sdp->sd_log_committed_revoke)) 9795a61ae14SAndreas Gruenbacher goto out_withdraw; 980b3b94faaSDavid Teigland 981d7b616e2SSteven Whitehouse gfs2_ordered_write(sdp); 9822ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 9835a61ae14SAndreas Gruenbacher goto out_withdraw; 984d69a3c65SSteven Whitehouse lops_before_commit(sdp, tr); 9852ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 9865a61ae14SAndreas Gruenbacher goto out_withdraw; 987f4686c26SAbhi Das gfs2_log_submit_bio(&sdp->sd_log_bio, REQ_OP_WRITE); 9882ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 9895a61ae14SAndreas Gruenbacher goto out_withdraw; 990d7b616e2SSteven Whitehouse 99134cc1781SSteven Whitehouse if (sdp->sd_log_head != sdp->sd_log_flush_head) { 992428fd95dSBob Peterson log_flush_wait(sdp); 993c1696fb8SBob Peterson log_write_header(sdp, flags); 99434cc1781SSteven Whitehouse } else if (sdp->sd_log_tail != current_tail(sdp) && !sdp->sd_log_idle) { 995fd041f0bSSteven Whitehouse atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */ 99663997775SSteven Whitehouse trace_gfs2_log_blocks(sdp, -1); 997c1696fb8SBob Peterson log_write_header(sdp, flags); 9982332c443SRobert Peterson } 9992ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 10005a61ae14SAndreas Gruenbacher goto out_withdraw; 100116ca9412SBenjamin Marzinski lops_after_commit(sdp, tr); 1002fe1a698fSSteven Whitehouse 1003fe1a698fSSteven Whitehouse gfs2_log_lock(sdp); 1004b3b94faaSDavid Teigland sdp->sd_log_head = sdp->sd_log_flush_head; 1005faa31ce8SSteven Whitehouse sdp->sd_log_blks_reserved = 0; 10065d439758SAndreas Gruenbacher sdp->sd_log_committed_revoke = 0; 1007b3b94faaSDavid Teigland 1008d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 100916ca9412SBenjamin Marzinski if (tr && !list_empty(&tr->tr_ail1_list)) { 101016ca9412SBenjamin Marzinski list_add(&tr->tr_list, &sdp->sd_ail1_list); 101116ca9412SBenjamin Marzinski tr = NULL; 1012b3b94faaSDavid Teigland } 1013d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 1014b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 101524972557SBenjamin Marzinski 1016c1696fb8SBob Peterson if (!(flags & GFS2_LOG_HEAD_FLUSH_NORMAL)) { 101724972557SBenjamin Marzinski if (!sdp->sd_log_idle) { 1018d5dc3d96SBob Peterson empty_ail1_list(sdp); 101930fe70a8SBob Peterson if (gfs2_withdrawn(sdp)) 10205a61ae14SAndreas Gruenbacher goto out_withdraw; 102124972557SBenjamin Marzinski atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */ 102224972557SBenjamin Marzinski trace_gfs2_log_blocks(sdp, -1); 1023c1696fb8SBob Peterson log_write_header(sdp, flags); 102424972557SBenjamin Marzinski sdp->sd_log_head = sdp->sd_log_flush_head; 102524972557SBenjamin Marzinski } 1026c1696fb8SBob Peterson if (flags & (GFS2_LOG_HEAD_FLUSH_SHUTDOWN | 1027c1696fb8SBob Peterson GFS2_LOG_HEAD_FLUSH_FREEZE)) 102824972557SBenjamin Marzinski gfs2_log_shutdown(sdp); 1029c1696fb8SBob Peterson if (flags & GFS2_LOG_HEAD_FLUSH_FREEZE) 10302e60d768SBenjamin Marzinski atomic_set(&sdp->sd_freeze_state, SFS_FROZEN); 103124972557SBenjamin Marzinski } 103224972557SBenjamin Marzinski 10335a61ae14SAndreas Gruenbacher out_end: 10345a61ae14SAndreas Gruenbacher trace_gfs2_log_flush(sdp, 0, flags); 103530fe70a8SBob Peterson out: 10365a61ae14SAndreas Gruenbacher up_write(&sdp->sd_log_flush_lock); 10375a61ae14SAndreas Gruenbacher gfs2_trans_free(sdp, tr); 10385a61ae14SAndreas Gruenbacher if (gfs2_withdrawing(sdp)) 10395a61ae14SAndreas Gruenbacher gfs2_withdraw(sdp); 10405a61ae14SAndreas Gruenbacher return; 10415a61ae14SAndreas Gruenbacher 10425a61ae14SAndreas Gruenbacher out_withdraw: 1043462582b9SBob Peterson trans_drain(tr); 104458e08e8dSBob Peterson /** 104558e08e8dSBob Peterson * If the tr_list is empty, we're withdrawing during a log 104658e08e8dSBob Peterson * flush that targets a transaction, but the transaction was 104758e08e8dSBob Peterson * never queued onto any of the ail lists. Here we add it to 104858e08e8dSBob Peterson * ail1 just so that ail_drain() will find and free it. 104958e08e8dSBob Peterson */ 105058e08e8dSBob Peterson spin_lock(&sdp->sd_ail_lock); 105158e08e8dSBob Peterson if (tr && list_empty(&tr->tr_list)) 105258e08e8dSBob Peterson list_add(&tr->tr_list, &sdp->sd_ail1_list); 105358e08e8dSBob Peterson spin_unlock(&sdp->sd_ail_lock); 10542ca0c2fbSBob Peterson ail_drain(sdp); /* frees all transactions */ 10552ca0c2fbSBob Peterson tr = NULL; 10565a61ae14SAndreas Gruenbacher goto out_end; 1057b3b94faaSDavid Teigland } 1058b3b94faaSDavid Teigland 1059d69a3c65SSteven Whitehouse /** 1060d69a3c65SSteven Whitehouse * gfs2_merge_trans - Merge a new transaction into a cached transaction 1061d69a3c65SSteven Whitehouse * @old: Original transaction to be expanded 1062d69a3c65SSteven Whitehouse * @new: New transaction to be merged 1063d69a3c65SSteven Whitehouse */ 1064d69a3c65SSteven Whitehouse 106583d060caSBob Peterson static void gfs2_merge_trans(struct gfs2_sbd *sdp, struct gfs2_trans *new) 1066d69a3c65SSteven Whitehouse { 106783d060caSBob Peterson struct gfs2_trans *old = sdp->sd_log_tr; 106883d060caSBob Peterson 10699862ca05SBob Peterson WARN_ON_ONCE(!test_bit(TR_ATTACHED, &old->tr_flags)); 1070d69a3c65SSteven Whitehouse 1071d69a3c65SSteven Whitehouse old->tr_num_buf_new += new->tr_num_buf_new; 1072d69a3c65SSteven Whitehouse old->tr_num_databuf_new += new->tr_num_databuf_new; 1073d69a3c65SSteven Whitehouse old->tr_num_buf_rm += new->tr_num_buf_rm; 1074d69a3c65SSteven Whitehouse old->tr_num_databuf_rm += new->tr_num_databuf_rm; 1075d69a3c65SSteven Whitehouse old->tr_num_revoke += new->tr_num_revoke; 1076a31b4ec5SBob Peterson old->tr_num_revoke_rm += new->tr_num_revoke_rm; 1077d69a3c65SSteven Whitehouse 1078d69a3c65SSteven Whitehouse list_splice_tail_init(&new->tr_databuf, &old->tr_databuf); 1079d69a3c65SSteven Whitehouse list_splice_tail_init(&new->tr_buf, &old->tr_buf); 108083d060caSBob Peterson 108183d060caSBob Peterson spin_lock(&sdp->sd_ail_lock); 108283d060caSBob Peterson list_splice_tail_init(&new->tr_ail1_list, &old->tr_ail1_list); 108383d060caSBob Peterson list_splice_tail_init(&new->tr_ail2_list, &old->tr_ail2_list); 108483d060caSBob Peterson spin_unlock(&sdp->sd_ail_lock); 1085d69a3c65SSteven Whitehouse } 1086d69a3c65SSteven Whitehouse 1087b3b94faaSDavid Teigland static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 1088b3b94faaSDavid Teigland { 10892332c443SRobert Peterson unsigned int reserved; 1090ac39aaddSSteven Whitehouse unsigned int unused; 1091022ef4feSSteven Whitehouse unsigned int maxres; 1092b3b94faaSDavid Teigland 1093b3b94faaSDavid Teigland gfs2_log_lock(sdp); 1094b3b94faaSDavid Teigland 1095d69a3c65SSteven Whitehouse if (sdp->sd_log_tr) { 109683d060caSBob Peterson gfs2_merge_trans(sdp, tr); 1097d69a3c65SSteven Whitehouse } else if (tr->tr_num_buf_new || tr->tr_num_databuf_new) { 1098c968f578SAndreas Gruenbacher gfs2_assert_withdraw(sdp, !test_bit(TR_ONSTACK, &tr->tr_flags)); 109916ca9412SBenjamin Marzinski sdp->sd_log_tr = tr; 11009862ca05SBob Peterson set_bit(TR_ATTACHED, &tr->tr_flags); 110116ca9412SBenjamin Marzinski } 1102022ef4feSSteven Whitehouse 1103a31b4ec5SBob Peterson sdp->sd_log_committed_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm; 1104022ef4feSSteven Whitehouse reserved = calc_reserved(sdp); 1105022ef4feSSteven Whitehouse maxres = sdp->sd_log_blks_reserved + tr->tr_reserved; 1106022ef4feSSteven Whitehouse gfs2_assert_withdraw(sdp, maxres >= reserved); 1107022ef4feSSteven Whitehouse unused = maxres - reserved; 1108*5ae8fff8SAndreas Gruenbacher if (unused) 1109c1eba1b0SAndreas Gruenbacher gfs2_log_release(sdp, unused); 1110022ef4feSSteven Whitehouse sdp->sd_log_blks_reserved = reserved; 1111022ef4feSSteven Whitehouse 1112b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 1113b3b94faaSDavid Teigland } 1114b3b94faaSDavid Teigland 1115b3b94faaSDavid Teigland /** 1116b3b94faaSDavid Teigland * gfs2_log_commit - Commit a transaction to the log 1117b3b94faaSDavid Teigland * @sdp: the filesystem 1118b3b94faaSDavid Teigland * @tr: the transaction 1119b3b94faaSDavid Teigland * 11205e687eacSBenjamin Marzinski * We wake up gfs2_logd if the number of pinned blocks exceed thresh1 11215e687eacSBenjamin Marzinski * or the total number of used blocks (pinned blocks plus AIL blocks) 11225e687eacSBenjamin Marzinski * is greater than thresh2. 11235e687eacSBenjamin Marzinski * 1124b57bc0fbSBob Peterson * At mount time thresh1 is 2/5ths of journal size, thresh2 is 4/5ths of 11255e687eacSBenjamin Marzinski * journal size. 11265e687eacSBenjamin Marzinski * 1127b3b94faaSDavid Teigland * Returns: errno 1128b3b94faaSDavid Teigland */ 1129b3b94faaSDavid Teigland 1130b3b94faaSDavid Teigland void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 1131b3b94faaSDavid Teigland { 1132b3b94faaSDavid Teigland log_refund(sdp, tr); 1133b3b94faaSDavid Teigland 11345e687eacSBenjamin Marzinski if (atomic_read(&sdp->sd_log_pinned) > atomic_read(&sdp->sd_log_thresh1) || 11355e687eacSBenjamin Marzinski ((sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free)) > 11365e687eacSBenjamin Marzinski atomic_read(&sdp->sd_log_thresh2))) 11375e687eacSBenjamin Marzinski wake_up(&sdp->sd_logd_waitq); 1138faa31ce8SSteven Whitehouse } 1139b3b94faaSDavid Teigland 1140b3b94faaSDavid Teigland /** 1141b3b94faaSDavid Teigland * gfs2_log_shutdown - write a shutdown header into a journal 1142b3b94faaSDavid Teigland * @sdp: the filesystem 1143b3b94faaSDavid Teigland * 1144b3b94faaSDavid Teigland */ 1145b3b94faaSDavid Teigland 1146feed98a8SBob Peterson static void gfs2_log_shutdown(struct gfs2_sbd *sdp) 1147b3b94faaSDavid Teigland { 1148b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved); 1149b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke); 1150b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list)); 1151b3b94faaSDavid Teigland 1152b3b94faaSDavid Teigland sdp->sd_log_flush_head = sdp->sd_log_head; 1153b3b94faaSDavid Teigland 1154805c0907SBob Peterson log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT | GFS2_LFC_SHUTDOWN); 1155b3b94faaSDavid Teigland 1156a74604beSSteven Whitehouse gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail); 1157a74604beSSteven Whitehouse gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list)); 1158b3b94faaSDavid Teigland 1159b3b94faaSDavid Teigland sdp->sd_log_head = sdp->sd_log_flush_head; 1160b3b94faaSDavid Teigland sdp->sd_log_tail = sdp->sd_log_head; 1161a25311c8SSteven Whitehouse } 1162a25311c8SSteven Whitehouse 11635e687eacSBenjamin Marzinski static inline int gfs2_jrnl_flush_reqd(struct gfs2_sbd *sdp) 11645e687eacSBenjamin Marzinski { 1165f07b3520SBob Peterson return (atomic_read(&sdp->sd_log_pinned) + 1166f07b3520SBob Peterson atomic_read(&sdp->sd_log_blks_needed) >= 1167f07b3520SBob Peterson atomic_read(&sdp->sd_log_thresh1)); 11685e687eacSBenjamin Marzinski } 11695e687eacSBenjamin Marzinski 11705e687eacSBenjamin Marzinski static inline int gfs2_ail_flush_reqd(struct gfs2_sbd *sdp) 11715e687eacSBenjamin Marzinski { 11725e687eacSBenjamin Marzinski unsigned int used_blocks = sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free); 1173b066a4eeSAbhi Das 1174b066a4eeSAbhi Das if (test_and_clear_bit(SDF_FORCE_AIL_FLUSH, &sdp->sd_flags)) 1175b066a4eeSAbhi Das return 1; 1176b066a4eeSAbhi Das 1177f07b3520SBob Peterson return used_blocks + atomic_read(&sdp->sd_log_blks_needed) >= 1178f07b3520SBob Peterson atomic_read(&sdp->sd_log_thresh2); 11795e687eacSBenjamin Marzinski } 1180ec69b188SSteven Whitehouse 1181ec69b188SSteven Whitehouse /** 1182ec69b188SSteven Whitehouse * gfs2_logd - Update log tail as Active Items get flushed to in-place blocks 1183ec69b188SSteven Whitehouse * @sdp: Pointer to GFS2 superblock 1184ec69b188SSteven Whitehouse * 1185ec69b188SSteven Whitehouse * Also, periodically check to make sure that we're using the most recent 1186ec69b188SSteven Whitehouse * journal index. 1187ec69b188SSteven Whitehouse */ 1188ec69b188SSteven Whitehouse 1189ec69b188SSteven Whitehouse int gfs2_logd(void *data) 1190ec69b188SSteven Whitehouse { 1191ec69b188SSteven Whitehouse struct gfs2_sbd *sdp = data; 11925e687eacSBenjamin Marzinski unsigned long t = 1; 11935e687eacSBenjamin Marzinski DEFINE_WAIT(wait); 1194ec69b188SSteven Whitehouse 1195ec69b188SSteven Whitehouse while (!kthread_should_stop()) { 1196ec69b188SSteven Whitehouse 1197d22f69a0SBob Peterson if (gfs2_withdrawn(sdp)) { 1198d22f69a0SBob Peterson msleep_interruptible(HZ); 1199d22f69a0SBob Peterson continue; 1200d22f69a0SBob Peterson } 1201942b0cddSBob Peterson /* Check for errors writing to the journal */ 1202942b0cddSBob Peterson if (sdp->sd_log_error) { 1203badb55ecSAndreas Gruenbacher gfs2_lm(sdp, 1204942b0cddSBob Peterson "GFS2: fsid=%s: error %d: " 1205942b0cddSBob Peterson "withdrawing the file system to " 1206942b0cddSBob Peterson "prevent further damage.\n", 1207942b0cddSBob Peterson sdp->sd_fsname, sdp->sd_log_error); 1208badb55ecSAndreas Gruenbacher gfs2_withdraw(sdp); 1209d22f69a0SBob Peterson continue; 1210942b0cddSBob Peterson } 1211942b0cddSBob Peterson 12125e687eacSBenjamin Marzinski if (gfs2_jrnl_flush_reqd(sdp) || t == 0) { 12135e4c7632SBob Peterson gfs2_ail1_empty(sdp, 0); 1214805c0907SBob Peterson gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL | 1215805c0907SBob Peterson GFS2_LFC_LOGD_JFLUSH_REQD); 1216ec69b188SSteven Whitehouse } 1217ec69b188SSteven Whitehouse 12185e687eacSBenjamin Marzinski if (gfs2_ail_flush_reqd(sdp)) { 12195e687eacSBenjamin Marzinski gfs2_ail1_start(sdp); 122026b06a69SSteven Whitehouse gfs2_ail1_wait(sdp); 12215e4c7632SBob Peterson gfs2_ail1_empty(sdp, 0); 1222805c0907SBob Peterson gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL | 1223805c0907SBob Peterson GFS2_LFC_LOGD_AIL_FLUSH_REQD); 12245e687eacSBenjamin Marzinski } 12255e687eacSBenjamin Marzinski 1226ec69b188SSteven Whitehouse t = gfs2_tune_get(sdp, gt_logd_secs) * HZ; 1227a0acae0eSTejun Heo 1228a0acae0eSTejun Heo try_to_freeze(); 12295e687eacSBenjamin Marzinski 12305e687eacSBenjamin Marzinski do { 12315e687eacSBenjamin Marzinski prepare_to_wait(&sdp->sd_logd_waitq, &wait, 12325f487490SSteven Whitehouse TASK_INTERRUPTIBLE); 12335e687eacSBenjamin Marzinski if (!gfs2_ail_flush_reqd(sdp) && 12345e687eacSBenjamin Marzinski !gfs2_jrnl_flush_reqd(sdp) && 12355e687eacSBenjamin Marzinski !kthread_should_stop()) 12365e687eacSBenjamin Marzinski t = schedule_timeout(t); 12375e687eacSBenjamin Marzinski } while(t && !gfs2_ail_flush_reqd(sdp) && 12385e687eacSBenjamin Marzinski !gfs2_jrnl_flush_reqd(sdp) && 12395e687eacSBenjamin Marzinski !kthread_should_stop()); 12405e687eacSBenjamin Marzinski finish_wait(&sdp->sd_logd_waitq, &wait); 1241ec69b188SSteven Whitehouse } 1242ec69b188SSteven Whitehouse 1243ec69b188SSteven Whitehouse return 0; 1244ec69b188SSteven Whitehouse } 1245ec69b188SSteven Whitehouse 1246