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 41924972557SBenjamin Marzinski atomic_add(blks, &sdp->sd_log_blks_free); 42024972557SBenjamin Marzinski trace_gfs2_log_blocks(sdp, blks); 42124972557SBenjamin Marzinski gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <= 42224972557SBenjamin Marzinski sdp->sd_jdesc->jd_blocks); 42324972557SBenjamin Marzinski } 42424972557SBenjamin Marzinski 42524972557SBenjamin Marzinski /** 426b3b94faaSDavid Teigland * gfs2_log_reserve - Make a log reservation 427b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 428b3b94faaSDavid Teigland * @blks: The number of blocks to reserve 429b3b94faaSDavid Teigland * 43089918647SSteven Whitehouse * Note that we never give out the last few blocks of the journal. Thats 4312332c443SRobert Peterson * due to the fact that there is a small number of header blocks 432b004157aSSteven Whitehouse * associated with each log flush. The exact number can't be known until 433b004157aSSteven Whitehouse * flush time, so we ensure that we have just enough free blocks at all 434b004157aSSteven Whitehouse * times to avoid running out during a log flush. 435b004157aSSteven Whitehouse * 4365e687eacSBenjamin Marzinski * We no longer flush the log here, instead we wake up logd to do that 4375e687eacSBenjamin Marzinski * for us. To avoid the thundering herd and to ensure that we deal fairly 4385e687eacSBenjamin Marzinski * with queued waiters, we use an exclusive wait. This means that when we 4395e687eacSBenjamin Marzinski * get woken with enough journal space to get our reservation, we need to 4405e687eacSBenjamin Marzinski * wake the next waiter on the list. 441b3b94faaSDavid Teigland */ 442b3b94faaSDavid Teigland 443*c1eba1b0SAndreas Gruenbacher void gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks) 444b3b94faaSDavid Teigland { 4455d054964SBenjamin Marzinski unsigned reserved_blks = 7 * (4096 / sdp->sd_vfs->s_blocksize); 4465e687eacSBenjamin Marzinski unsigned wanted = blks + reserved_blks; 4475e687eacSBenjamin Marzinski DEFINE_WAIT(wait); 4485e687eacSBenjamin Marzinski int did_wait = 0; 4495e687eacSBenjamin Marzinski unsigned int free_blocks; 450b3b94faaSDavid Teigland 451f07b3520SBob Peterson atomic_add(blks, &sdp->sd_log_blks_needed); 4525e687eacSBenjamin Marzinski retry: 4535e687eacSBenjamin Marzinski free_blocks = atomic_read(&sdp->sd_log_blks_free); 4545e687eacSBenjamin Marzinski if (unlikely(free_blocks <= wanted)) { 4555e687eacSBenjamin Marzinski do { 4565e687eacSBenjamin Marzinski prepare_to_wait_exclusive(&sdp->sd_log_waitq, &wait, 4575e687eacSBenjamin Marzinski TASK_UNINTERRUPTIBLE); 4585e687eacSBenjamin Marzinski wake_up(&sdp->sd_logd_waitq); 4595e687eacSBenjamin Marzinski did_wait = 1; 4605e687eacSBenjamin Marzinski if (atomic_read(&sdp->sd_log_blks_free) <= wanted) 4615e687eacSBenjamin Marzinski io_schedule(); 4625e687eacSBenjamin Marzinski free_blocks = atomic_read(&sdp->sd_log_blks_free); 4635e687eacSBenjamin Marzinski } while(free_blocks <= wanted); 4645e687eacSBenjamin Marzinski finish_wait(&sdp->sd_log_waitq, &wait); 465b3b94faaSDavid Teigland } 4665e687eacSBenjamin Marzinski if (atomic_cmpxchg(&sdp->sd_log_blks_free, free_blocks, 467f3708fb5SAndreas Gruenbacher free_blocks - blks) != free_blocks) 4685e687eacSBenjamin Marzinski goto retry; 469f07b3520SBob Peterson atomic_sub(blks, &sdp->sd_log_blks_needed); 47063997775SSteven Whitehouse trace_gfs2_log_blocks(sdp, -blks); 4715e687eacSBenjamin Marzinski 4725e687eacSBenjamin Marzinski /* 4735e687eacSBenjamin Marzinski * If we waited, then so might others, wake them up _after_ we get 4745e687eacSBenjamin Marzinski * our share of the log. 4755e687eacSBenjamin Marzinski */ 4765e687eacSBenjamin Marzinski if (unlikely(did_wait)) 4775e687eacSBenjamin Marzinski wake_up(&sdp->sd_log_waitq); 478b3b94faaSDavid Teigland } 479b3b94faaSDavid Teigland 480b3b94faaSDavid Teigland /** 481b3b94faaSDavid Teigland * log_distance - Compute distance between two journal blocks 482b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 483b3b94faaSDavid Teigland * @newer: The most recent journal block of the pair 484b3b94faaSDavid Teigland * @older: The older journal block of the pair 485b3b94faaSDavid Teigland * 486b3b94faaSDavid Teigland * Compute the distance (in the journal direction) between two 487b3b94faaSDavid Teigland * blocks in the journal 488b3b94faaSDavid Teigland * 489b3b94faaSDavid Teigland * Returns: the distance in blocks 490b3b94faaSDavid Teigland */ 491b3b94faaSDavid Teigland 492faa31ce8SSteven Whitehouse static inline unsigned int log_distance(struct gfs2_sbd *sdp, unsigned int newer, 493b3b94faaSDavid Teigland unsigned int older) 494b3b94faaSDavid Teigland { 495b3b94faaSDavid Teigland int dist; 496b3b94faaSDavid Teigland 497b3b94faaSDavid Teigland dist = newer - older; 498b3b94faaSDavid Teigland if (dist < 0) 499b3b94faaSDavid Teigland dist += sdp->sd_jdesc->jd_blocks; 500b3b94faaSDavid Teigland 501b3b94faaSDavid Teigland return dist; 502b3b94faaSDavid Teigland } 503b3b94faaSDavid Teigland 5042332c443SRobert Peterson /** 5056188e877SAndreas Gruenbacher * calc_reserved - Calculate the number of blocks to keep reserved 5062332c443SRobert Peterson * @sdp: The GFS2 superblock 5072332c443SRobert Peterson * 5082332c443SRobert Peterson * This is complex. We need to reserve room for all our currently used 5096188e877SAndreas Gruenbacher * metadata blocks (e.g. normal file I/O rewriting file time stamps) and 5106188e877SAndreas Gruenbacher * all our journaled data blocks for journaled files (e.g. files in the 5112332c443SRobert Peterson * meta_fs like rindex, or files for which chattr +j was done.) 5126188e877SAndreas Gruenbacher * If we don't reserve enough space, corruption will follow. 5132332c443SRobert Peterson * 5146188e877SAndreas Gruenbacher * We can have metadata blocks and jdata blocks in the same journal. Each 5156188e877SAndreas Gruenbacher * type gets its own log descriptor, for which we need to reserve a block. 5166188e877SAndreas Gruenbacher * In fact, each type has the potential for needing more than one log descriptor 5176188e877SAndreas Gruenbacher * in cases where we have more blocks than will fit in a log descriptor. 5182332c443SRobert Peterson * Metadata journal entries take up half the space of journaled buffer entries. 5192332c443SRobert Peterson * 5202332c443SRobert Peterson * Also, we need to reserve blocks for revoke journal entries and one for an 5212332c443SRobert Peterson * overall header for the lot. 5222332c443SRobert Peterson * 5232332c443SRobert Peterson * Returns: the number of blocks reserved 5242332c443SRobert Peterson */ 5252332c443SRobert Peterson static unsigned int calc_reserved(struct gfs2_sbd *sdp) 5262332c443SRobert Peterson { 5272332c443SRobert Peterson unsigned int reserved = 0; 528022ef4feSSteven Whitehouse unsigned int mbuf; 529022ef4feSSteven Whitehouse unsigned int dbuf; 530022ef4feSSteven Whitehouse struct gfs2_trans *tr = sdp->sd_log_tr; 5312332c443SRobert Peterson 532022ef4feSSteven Whitehouse if (tr) { 533022ef4feSSteven Whitehouse mbuf = tr->tr_num_buf_new - tr->tr_num_buf_rm; 534022ef4feSSteven Whitehouse dbuf = tr->tr_num_databuf_new - tr->tr_num_databuf_rm; 535022ef4feSSteven Whitehouse reserved = mbuf + dbuf; 536022ef4feSSteven Whitehouse /* Account for header blocks */ 537022ef4feSSteven Whitehouse reserved += DIV_ROUND_UP(mbuf, buf_limit(sdp)); 538022ef4feSSteven Whitehouse reserved += DIV_ROUND_UP(dbuf, databuf_limit(sdp)); 539022ef4feSSteven Whitehouse } 5402332c443SRobert Peterson 5415d439758SAndreas Gruenbacher if (sdp->sd_log_committed_revoke > 0) 5425d439758SAndreas Gruenbacher reserved += gfs2_struct2blk(sdp, sdp->sd_log_committed_revoke); 5432332c443SRobert Peterson /* One for the overall header */ 5442332c443SRobert Peterson if (reserved) 5452332c443SRobert Peterson reserved++; 5462332c443SRobert Peterson return reserved; 5472332c443SRobert Peterson } 5482332c443SRobert Peterson 549b3b94faaSDavid Teigland static unsigned int current_tail(struct gfs2_sbd *sdp) 550b3b94faaSDavid Teigland { 55116ca9412SBenjamin Marzinski struct gfs2_trans *tr; 552b3b94faaSDavid Teigland unsigned int tail; 553b3b94faaSDavid Teigland 554d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 555b3b94faaSDavid Teigland 556faa31ce8SSteven Whitehouse if (list_empty(&sdp->sd_ail1_list)) { 557b3b94faaSDavid Teigland tail = sdp->sd_log_head; 558faa31ce8SSteven Whitehouse } else { 559969183bcSAndreas Gruenbacher tr = list_last_entry(&sdp->sd_ail1_list, struct gfs2_trans, 56016ca9412SBenjamin Marzinski tr_list); 56116ca9412SBenjamin Marzinski tail = tr->tr_first; 562b3b94faaSDavid Teigland } 563b3b94faaSDavid Teigland 564d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 565b3b94faaSDavid Teigland 566b3b94faaSDavid Teigland return tail; 567b3b94faaSDavid Teigland } 568b3b94faaSDavid Teigland 5692332c443SRobert Peterson static void log_pull_tail(struct gfs2_sbd *sdp, unsigned int new_tail) 570b3b94faaSDavid Teigland { 571b3b94faaSDavid Teigland unsigned int dist = log_distance(sdp, new_tail, sdp->sd_log_tail); 572b3b94faaSDavid Teigland 573b3b94faaSDavid Teigland ail2_empty(sdp, new_tail); 574*c1eba1b0SAndreas Gruenbacher gfs2_log_release(sdp, dist); 575b3b94faaSDavid Teigland sdp->sd_log_tail = new_tail; 576b3b94faaSDavid Teigland } 577b3b94faaSDavid Teigland 578b3b94faaSDavid Teigland 5799ff78289SBob Peterson void log_flush_wait(struct gfs2_sbd *sdp) 580b3b94faaSDavid Teigland { 58116615be1SSteven Whitehouse DEFINE_WAIT(wait); 582b3b94faaSDavid Teigland 58316615be1SSteven Whitehouse if (atomic_read(&sdp->sd_log_in_flight)) { 58416615be1SSteven Whitehouse do { 58516615be1SSteven Whitehouse prepare_to_wait(&sdp->sd_log_flush_wait, &wait, 58616615be1SSteven Whitehouse TASK_UNINTERRUPTIBLE); 58716615be1SSteven Whitehouse if (atomic_read(&sdp->sd_log_in_flight)) 58816615be1SSteven Whitehouse io_schedule(); 58916615be1SSteven Whitehouse } while(atomic_read(&sdp->sd_log_in_flight)); 59016615be1SSteven Whitehouse finish_wait(&sdp->sd_log_flush_wait, &wait); 591b3b94faaSDavid Teigland } 592b3b94faaSDavid Teigland } 593b3b94faaSDavid Teigland 59445138990SSteven Whitehouse static int ip_cmp(void *priv, struct list_head *a, struct list_head *b) 5954a36d08dSBob Peterson { 59645138990SSteven Whitehouse struct gfs2_inode *ipa, *ipb; 5974a36d08dSBob Peterson 59845138990SSteven Whitehouse ipa = list_entry(a, struct gfs2_inode, i_ordered); 59945138990SSteven Whitehouse ipb = list_entry(b, struct gfs2_inode, i_ordered); 6004a36d08dSBob Peterson 60145138990SSteven Whitehouse if (ipa->i_no_addr < ipb->i_no_addr) 6024a36d08dSBob Peterson return -1; 60345138990SSteven Whitehouse if (ipa->i_no_addr > ipb->i_no_addr) 6044a36d08dSBob Peterson return 1; 6054a36d08dSBob Peterson return 0; 6064a36d08dSBob Peterson } 6074a36d08dSBob Peterson 6087542486bSBob Peterson static void __ordered_del_inode(struct gfs2_inode *ip) 6097542486bSBob Peterson { 6107542486bSBob Peterson if (!list_empty(&ip->i_ordered)) 6117542486bSBob Peterson list_del_init(&ip->i_ordered); 6127542486bSBob Peterson } 6137542486bSBob Peterson 614d7b616e2SSteven Whitehouse static void gfs2_ordered_write(struct gfs2_sbd *sdp) 615d7b616e2SSteven Whitehouse { 61645138990SSteven Whitehouse struct gfs2_inode *ip; 617d7b616e2SSteven Whitehouse LIST_HEAD(written); 618d7b616e2SSteven Whitehouse 61945138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 620a5b1d3fcSAndreas Gruenbacher list_sort(NULL, &sdp->sd_log_ordered, &ip_cmp); 621a5b1d3fcSAndreas Gruenbacher while (!list_empty(&sdp->sd_log_ordered)) { 622969183bcSAndreas Gruenbacher ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered); 6231f23bc78SAbhi Das if (ip->i_inode.i_mapping->nrpages == 0) { 6247542486bSBob Peterson __ordered_del_inode(ip); 625d7b616e2SSteven Whitehouse continue; 6261f23bc78SAbhi Das } 6271f23bc78SAbhi Das list_move(&ip->i_ordered, &written); 62845138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 62945138990SSteven Whitehouse filemap_fdatawrite(ip->i_inode.i_mapping); 63045138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 631d7b616e2SSteven Whitehouse } 632a5b1d3fcSAndreas Gruenbacher list_splice(&written, &sdp->sd_log_ordered); 63345138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 634d7b616e2SSteven Whitehouse } 635d7b616e2SSteven Whitehouse 636d7b616e2SSteven Whitehouse static void gfs2_ordered_wait(struct gfs2_sbd *sdp) 637d7b616e2SSteven Whitehouse { 63845138990SSteven Whitehouse struct gfs2_inode *ip; 639d7b616e2SSteven Whitehouse 64045138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 641a5b1d3fcSAndreas Gruenbacher while (!list_empty(&sdp->sd_log_ordered)) { 642969183bcSAndreas Gruenbacher ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered); 6437542486bSBob Peterson __ordered_del_inode(ip); 64445138990SSteven Whitehouse if (ip->i_inode.i_mapping->nrpages == 0) 645d7b616e2SSteven Whitehouse continue; 64645138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 64745138990SSteven Whitehouse filemap_fdatawait(ip->i_inode.i_mapping); 64845138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 649d7b616e2SSteven Whitehouse } 65045138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 651d7b616e2SSteven Whitehouse } 65245138990SSteven Whitehouse 65345138990SSteven Whitehouse void gfs2_ordered_del_inode(struct gfs2_inode *ip) 65445138990SSteven Whitehouse { 65545138990SSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 65645138990SSteven Whitehouse 65745138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 6587542486bSBob Peterson __ordered_del_inode(ip); 65945138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 660d7b616e2SSteven Whitehouse } 661d7b616e2SSteven Whitehouse 6625d054964SBenjamin Marzinski void gfs2_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd) 6635d054964SBenjamin Marzinski { 6645d054964SBenjamin Marzinski struct buffer_head *bh = bd->bd_bh; 6655d054964SBenjamin Marzinski struct gfs2_glock *gl = bd->bd_gl; 6665d054964SBenjamin Marzinski 667f4e2f5e1SAndreas Gruenbacher sdp->sd_log_num_revoke++; 668f4e2f5e1SAndreas Gruenbacher if (atomic_inc_return(&gl->gl_revokes) == 1) 669f4e2f5e1SAndreas Gruenbacher gfs2_glock_hold(gl); 6705d054964SBenjamin Marzinski bh->b_private = NULL; 6715d054964SBenjamin Marzinski bd->bd_blkno = bh->b_blocknr; 6729290a9a7SBob Peterson gfs2_remove_from_ail(bd); /* drops ref on bh */ 6739290a9a7SBob Peterson bd->bd_bh = NULL; 6745d054964SBenjamin Marzinski set_bit(GLF_LFLUSH, &gl->gl_flags); 675a5b1d3fcSAndreas Gruenbacher list_add(&bd->bd_list, &sdp->sd_log_revokes); 6765d054964SBenjamin Marzinski } 6775d054964SBenjamin Marzinski 678fe5e7ba1SBob Peterson void gfs2_glock_remove_revoke(struct gfs2_glock *gl) 679fe5e7ba1SBob Peterson { 680fe5e7ba1SBob Peterson if (atomic_dec_return(&gl->gl_revokes) == 0) { 681fe5e7ba1SBob Peterson clear_bit(GLF_LFLUSH, &gl->gl_flags); 682fe5e7ba1SBob Peterson gfs2_glock_queue_put(gl); 683fe5e7ba1SBob Peterson } 684fe5e7ba1SBob Peterson } 685fe5e7ba1SBob Peterson 6865e4c7632SBob Peterson /** 687e7501bf8SAndreas Gruenbacher * gfs2_flush_revokes - Add as many revokes to the system transaction as we can 6885e4c7632SBob Peterson * @sdp: The GFS2 superblock 6895e4c7632SBob Peterson * 6905e4c7632SBob Peterson * Our usual strategy is to defer writing revokes as much as we can in the hope 6915e4c7632SBob Peterson * that we'll eventually overwrite the journal, which will make those revokes 6925e4c7632SBob Peterson * go away. This changes when we flush the log: at that point, there will 6935e4c7632SBob Peterson * likely be some left-over space in the last revoke block of that transaction. 6945e4c7632SBob Peterson * We can fill that space with additional revokes for blocks that have already 6955e4c7632SBob Peterson * been written back. This will basically come at no cost now, and will save 6965e4c7632SBob Peterson * us from having to keep track of those blocks on the AIL2 list later. 6975e4c7632SBob Peterson */ 698e7501bf8SAndreas Gruenbacher void gfs2_flush_revokes(struct gfs2_sbd *sdp) 6995d054964SBenjamin Marzinski { 7005e4c7632SBob Peterson /* number of revokes we still have room for */ 7015a4e9c60SAndreas Gruenbacher unsigned int max_revokes; 7025d054964SBenjamin Marzinski 7035e4c7632SBob Peterson gfs2_log_lock(sdp); 7045a4e9c60SAndreas Gruenbacher max_revokes = sdp->sd_ldptrs; 7055a4e9c60SAndreas Gruenbacher if (sdp->sd_log_num_revoke > sdp->sd_ldptrs) 7065a4e9c60SAndreas Gruenbacher max_revokes += roundup(sdp->sd_log_num_revoke - sdp->sd_ldptrs, 7075a4e9c60SAndreas Gruenbacher sdp->sd_inptrs); 7085d054964SBenjamin Marzinski max_revokes -= sdp->sd_log_num_revoke; 7095d054964SBenjamin Marzinski if (!sdp->sd_log_num_revoke) { 7105d054964SBenjamin Marzinski atomic_dec(&sdp->sd_log_blks_free); 7115d054964SBenjamin Marzinski /* If no blocks have been reserved, we need to also 7125d054964SBenjamin Marzinski * reserve a block for the header */ 71377650bdbSBob Peterson if (!sdp->sd_log_blks_reserved) { 7145d054964SBenjamin Marzinski atomic_dec(&sdp->sd_log_blks_free); 71577650bdbSBob Peterson trace_gfs2_log_blocks(sdp, -2); 71677650bdbSBob Peterson } else { 71777650bdbSBob Peterson trace_gfs2_log_blocks(sdp, -1); 71877650bdbSBob Peterson } 7195d054964SBenjamin Marzinski } 7205e4c7632SBob Peterson gfs2_ail1_empty(sdp, max_revokes); 7215d054964SBenjamin Marzinski gfs2_log_unlock(sdp); 7225d054964SBenjamin Marzinski 7235d054964SBenjamin Marzinski if (!sdp->sd_log_num_revoke) { 7245d054964SBenjamin Marzinski atomic_inc(&sdp->sd_log_blks_free); 72577650bdbSBob Peterson if (!sdp->sd_log_blks_reserved) { 7265d054964SBenjamin Marzinski atomic_inc(&sdp->sd_log_blks_free); 72777650bdbSBob Peterson trace_gfs2_log_blocks(sdp, 2); 72877650bdbSBob Peterson } else { 72977650bdbSBob Peterson trace_gfs2_log_blocks(sdp, 1); 73077650bdbSBob Peterson } 7315d054964SBenjamin Marzinski } 7325d054964SBenjamin Marzinski } 7335d054964SBenjamin Marzinski 734b3b94faaSDavid Teigland /** 7357c70b896SBob Peterson * gfs2_write_log_header - Write a journal log header buffer at lblock 736588bff95SBob Peterson * @sdp: The GFS2 superblock 737c1696fb8SBob Peterson * @jd: journal descriptor of the journal to which we are writing 738588bff95SBob Peterson * @seq: sequence number 739588bff95SBob Peterson * @tail: tail of the log 7407c70b896SBob Peterson * @lblock: value for lh_blkno (block number relative to start of journal) 741c1696fb8SBob Peterson * @flags: log header flags GFS2_LOG_HEAD_* 742588bff95SBob Peterson * @op_flags: flags to pass to the bio 743588bff95SBob Peterson * 744588bff95SBob Peterson * Returns: the initialized log buffer descriptor 745588bff95SBob Peterson */ 746588bff95SBob Peterson 747c1696fb8SBob Peterson void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd, 7487c70b896SBob Peterson u64 seq, u32 tail, u32 lblock, u32 flags, 7497c70b896SBob Peterson int op_flags) 750588bff95SBob Peterson { 751588bff95SBob Peterson struct gfs2_log_header *lh; 752c1696fb8SBob Peterson u32 hash, crc; 753ade48088SBob Peterson struct page *page; 754c1696fb8SBob Peterson struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 755c1696fb8SBob Peterson struct timespec64 tv; 756c1696fb8SBob Peterson struct super_block *sb = sdp->sd_vfs; 7577c70b896SBob Peterson u64 dblock; 758588bff95SBob Peterson 759ade48088SBob Peterson if (gfs2_withdrawn(sdp)) 760ade48088SBob Peterson goto out; 761ade48088SBob Peterson 762ade48088SBob Peterson page = mempool_alloc(gfs2_page_pool, GFP_NOIO); 763588bff95SBob Peterson lh = page_address(page); 764588bff95SBob Peterson clear_page(lh); 765588bff95SBob Peterson 766588bff95SBob Peterson lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 767588bff95SBob Peterson lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH); 768588bff95SBob Peterson lh->lh_header.__pad0 = cpu_to_be64(0); 769588bff95SBob Peterson lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH); 770588bff95SBob Peterson lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid); 771588bff95SBob Peterson lh->lh_sequence = cpu_to_be64(seq); 772588bff95SBob Peterson lh->lh_flags = cpu_to_be32(flags); 773588bff95SBob Peterson lh->lh_tail = cpu_to_be32(tail); 7747c70b896SBob Peterson lh->lh_blkno = cpu_to_be32(lblock); 775c1696fb8SBob Peterson hash = ~crc32(~0, lh, LH_V1_SIZE); 776588bff95SBob Peterson lh->lh_hash = cpu_to_be32(hash); 777588bff95SBob Peterson 778ee9c7f9aSArnd Bergmann ktime_get_coarse_real_ts64(&tv); 779c1696fb8SBob Peterson lh->lh_nsec = cpu_to_be32(tv.tv_nsec); 780c1696fb8SBob Peterson lh->lh_sec = cpu_to_be64(tv.tv_sec); 7817c70b896SBob Peterson if (!list_empty(&jd->extent_list)) 78219ebc050SAndreas Gruenbacher dblock = gfs2_log_bmap(jd, lblock); 7837c70b896SBob Peterson else { 7847c70b896SBob Peterson int ret = gfs2_lblk_to_dblk(jd->jd_inode, lblock, &dblock); 7857c70b896SBob Peterson if (gfs2_assert_withdraw(sdp, ret == 0)) 7867c70b896SBob Peterson return; 7877c70b896SBob Peterson } 7887c70b896SBob Peterson lh->lh_addr = cpu_to_be64(dblock); 789c1696fb8SBob Peterson lh->lh_jinode = cpu_to_be64(GFS2_I(jd->jd_inode)->i_no_addr); 790c1696fb8SBob Peterson 791c1696fb8SBob Peterson /* We may only write local statfs, quota, etc., when writing to our 792c1696fb8SBob Peterson own journal. The values are left 0 when recovering a journal 793c1696fb8SBob Peterson different from our own. */ 794c1696fb8SBob Peterson if (!(flags & GFS2_LOG_HEAD_RECOVERY)) { 795c1696fb8SBob Peterson lh->lh_statfs_addr = 796c1696fb8SBob Peterson cpu_to_be64(GFS2_I(sdp->sd_sc_inode)->i_no_addr); 797c1696fb8SBob Peterson lh->lh_quota_addr = 798c1696fb8SBob Peterson cpu_to_be64(GFS2_I(sdp->sd_qc_inode)->i_no_addr); 799c1696fb8SBob Peterson 800c1696fb8SBob Peterson spin_lock(&sdp->sd_statfs_spin); 801c1696fb8SBob Peterson lh->lh_local_total = cpu_to_be64(l_sc->sc_total); 802c1696fb8SBob Peterson lh->lh_local_free = cpu_to_be64(l_sc->sc_free); 803c1696fb8SBob Peterson lh->lh_local_dinodes = cpu_to_be64(l_sc->sc_dinodes); 804c1696fb8SBob Peterson spin_unlock(&sdp->sd_statfs_spin); 805c1696fb8SBob Peterson } 806c1696fb8SBob Peterson 807c1696fb8SBob Peterson BUILD_BUG_ON(offsetof(struct gfs2_log_header, lh_crc) != LH_V1_SIZE); 808c1696fb8SBob Peterson 809c1696fb8SBob Peterson crc = crc32c(~0, (void *)lh + LH_V1_SIZE + 4, 810c1696fb8SBob Peterson sb->s_blocksize - LH_V1_SIZE - 4); 811c1696fb8SBob Peterson lh->lh_crc = cpu_to_be32(crc); 812c1696fb8SBob Peterson 8137c70b896SBob Peterson gfs2_log_write(sdp, page, sb->s_blocksize, 0, dblock); 814f4686c26SAbhi Das gfs2_log_submit_bio(&sdp->sd_log_bio, REQ_OP_WRITE | op_flags); 815ade48088SBob Peterson out: 816588bff95SBob Peterson log_flush_wait(sdp); 817588bff95SBob Peterson } 818588bff95SBob Peterson 819588bff95SBob Peterson /** 82034cc1781SSteven Whitehouse * log_write_header - Get and initialize a journal header buffer 82134cc1781SSteven Whitehouse * @sdp: The GFS2 superblock 822c1696fb8SBob Peterson * @flags: The log header flags, including log header origin 82334cc1781SSteven Whitehouse * 82434cc1781SSteven Whitehouse * Returns: the initialized log buffer descriptor 82534cc1781SSteven Whitehouse */ 82634cc1781SSteven Whitehouse 827fdb76a42SSteven Whitehouse static void log_write_header(struct gfs2_sbd *sdp, u32 flags) 82834cc1781SSteven Whitehouse { 82934cc1781SSteven Whitehouse unsigned int tail; 8300f0b9b63SJan Kara int op_flags = REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC; 8312e60d768SBenjamin Marzinski enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state); 83234cc1781SSteven Whitehouse 8332e60d768SBenjamin Marzinski gfs2_assert_withdraw(sdp, (state != SFS_FROZEN)); 83434cc1781SSteven Whitehouse tail = current_tail(sdp); 83534cc1781SSteven Whitehouse 83634cc1781SSteven Whitehouse if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags)) { 83734cc1781SSteven Whitehouse gfs2_ordered_wait(sdp); 83834cc1781SSteven Whitehouse log_flush_wait(sdp); 83970fd7614SChristoph Hellwig op_flags = REQ_SYNC | REQ_META | REQ_PRIO; 84034cc1781SSteven Whitehouse } 841e8c92ed7SSteven Whitehouse sdp->sd_log_idle = (tail == sdp->sd_log_flush_head); 842c1696fb8SBob Peterson gfs2_write_log_header(sdp, sdp->sd_jdesc, sdp->sd_log_sequence++, tail, 8437c70b896SBob Peterson sdp->sd_log_flush_head, flags, op_flags); 84419ebc050SAndreas Gruenbacher gfs2_log_incr_head(sdp); 84534cc1781SSteven Whitehouse 84634cc1781SSteven Whitehouse if (sdp->sd_log_tail != tail) 84734cc1781SSteven Whitehouse log_pull_tail(sdp, tail); 84834cc1781SSteven Whitehouse } 84934cc1781SSteven Whitehouse 85034cc1781SSteven Whitehouse /** 8512ca0c2fbSBob Peterson * ail_drain - drain the ail lists after a withdraw 8522ca0c2fbSBob Peterson * @sdp: Pointer to GFS2 superblock 8532ca0c2fbSBob Peterson */ 8542ca0c2fbSBob Peterson static void ail_drain(struct gfs2_sbd *sdp) 8552ca0c2fbSBob Peterson { 8562ca0c2fbSBob Peterson struct gfs2_trans *tr; 8572ca0c2fbSBob Peterson 8582ca0c2fbSBob Peterson spin_lock(&sdp->sd_ail_lock); 8592ca0c2fbSBob Peterson /* 8602ca0c2fbSBob Peterson * For transactions on the sd_ail1_list we need to drain both the 8612ca0c2fbSBob Peterson * ail1 and ail2 lists. That's because function gfs2_ail1_start_one 8622ca0c2fbSBob Peterson * (temporarily) moves items from its tr_ail1 list to tr_ail2 list 8632ca0c2fbSBob Peterson * before revokes are sent for that block. Items on the sd_ail2_list 8642ca0c2fbSBob Peterson * should have already gotten beyond that point, so no need. 8652ca0c2fbSBob Peterson */ 8662ca0c2fbSBob Peterson while (!list_empty(&sdp->sd_ail1_list)) { 8672ca0c2fbSBob Peterson tr = list_first_entry(&sdp->sd_ail1_list, struct gfs2_trans, 8682ca0c2fbSBob Peterson tr_list); 8692ca0c2fbSBob Peterson gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail1_list); 8702ca0c2fbSBob Peterson gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list); 8712ca0c2fbSBob Peterson list_del(&tr->tr_list); 872b839dadaSBob Peterson gfs2_trans_free(sdp, tr); 8732ca0c2fbSBob Peterson } 8742ca0c2fbSBob Peterson while (!list_empty(&sdp->sd_ail2_list)) { 8752ca0c2fbSBob Peterson tr = list_first_entry(&sdp->sd_ail2_list, struct gfs2_trans, 8762ca0c2fbSBob Peterson tr_list); 8772ca0c2fbSBob Peterson gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list); 8782ca0c2fbSBob Peterson list_del(&tr->tr_list); 879b839dadaSBob Peterson gfs2_trans_free(sdp, tr); 8802ca0c2fbSBob Peterson } 8812ca0c2fbSBob Peterson spin_unlock(&sdp->sd_ail_lock); 8822ca0c2fbSBob Peterson } 8832ca0c2fbSBob Peterson 8842ca0c2fbSBob Peterson /** 885d5dc3d96SBob Peterson * empty_ail1_list - try to start IO and empty the ail1 list 886d5dc3d96SBob Peterson * @sdp: Pointer to GFS2 superblock 887d5dc3d96SBob Peterson */ 888d5dc3d96SBob Peterson static void empty_ail1_list(struct gfs2_sbd *sdp) 889d5dc3d96SBob Peterson { 890d5dc3d96SBob Peterson unsigned long start = jiffies; 891d5dc3d96SBob Peterson 892d5dc3d96SBob Peterson for (;;) { 893d5dc3d96SBob Peterson if (time_after(jiffies, start + (HZ * 600))) { 894d5dc3d96SBob Peterson fs_err(sdp, "Error: In %s for 10 minutes! t=%d\n", 895d5dc3d96SBob Peterson __func__, current->journal_info ? 1 : 0); 896d5dc3d96SBob Peterson dump_ail_list(sdp); 897d5dc3d96SBob Peterson return; 898d5dc3d96SBob Peterson } 899d5dc3d96SBob Peterson gfs2_ail1_start(sdp); 900d5dc3d96SBob Peterson gfs2_ail1_wait(sdp); 901d5dc3d96SBob Peterson if (gfs2_ail1_empty(sdp, 0)) 902d5dc3d96SBob Peterson return; 903d5dc3d96SBob Peterson } 904d5dc3d96SBob Peterson } 905d5dc3d96SBob Peterson 906d5dc3d96SBob Peterson /** 907521031faSBob Peterson * trans_drain - drain the buf and databuf queue for a failed transaction 908462582b9SBob Peterson * @tr: the transaction to drain 909462582b9SBob Peterson * 910462582b9SBob Peterson * When this is called, we're taking an error exit for a log write that failed 911462582b9SBob Peterson * but since we bypassed the after_commit functions, we need to remove the 912462582b9SBob Peterson * items from the buf and databuf queue. 913462582b9SBob Peterson */ 914462582b9SBob Peterson static void trans_drain(struct gfs2_trans *tr) 915462582b9SBob Peterson { 916462582b9SBob Peterson struct gfs2_bufdata *bd; 917462582b9SBob Peterson struct list_head *head; 918462582b9SBob Peterson 919462582b9SBob Peterson if (!tr) 920462582b9SBob Peterson return; 921462582b9SBob Peterson 922462582b9SBob Peterson head = &tr->tr_buf; 923462582b9SBob Peterson while (!list_empty(head)) { 924462582b9SBob Peterson bd = list_first_entry(head, struct gfs2_bufdata, bd_list); 925462582b9SBob Peterson list_del_init(&bd->bd_list); 926462582b9SBob Peterson kmem_cache_free(gfs2_bufdata_cachep, bd); 927462582b9SBob Peterson } 928462582b9SBob Peterson head = &tr->tr_databuf; 929462582b9SBob Peterson while (!list_empty(head)) { 930462582b9SBob Peterson bd = list_first_entry(head, struct gfs2_bufdata, bd_list); 931462582b9SBob Peterson list_del_init(&bd->bd_list); 932462582b9SBob Peterson kmem_cache_free(gfs2_bufdata_cachep, bd); 933462582b9SBob Peterson } 934462582b9SBob Peterson } 935462582b9SBob Peterson 936462582b9SBob Peterson /** 937b09e593dSSteven Whitehouse * gfs2_log_flush - flush incore transaction(s) 938b3b94faaSDavid Teigland * @sdp: the filesystem 939b3b94faaSDavid Teigland * @gl: The glock structure to flush. If NULL, flush the whole incore log 940805c0907SBob Peterson * @flags: The log header flags: GFS2_LOG_HEAD_FLUSH_* and debug flags 941b3b94faaSDavid Teigland * 942b3b94faaSDavid Teigland */ 943b3b94faaSDavid Teigland 944c1696fb8SBob Peterson void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl, u32 flags) 945b3b94faaSDavid Teigland { 9462ca0c2fbSBob Peterson struct gfs2_trans *tr = NULL; 9472e60d768SBenjamin Marzinski enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state); 948b3b94faaSDavid Teigland 949484adff8SSteven Whitehouse down_write(&sdp->sd_log_flush_lock); 950f55ab26aSSteven Whitehouse 9512ca0c2fbSBob Peterson /* 9522ca0c2fbSBob Peterson * Do this check while holding the log_flush_lock to prevent new 9532ca0c2fbSBob Peterson * buffers from being added to the ail via gfs2_pin() 9542ca0c2fbSBob Peterson */ 9552ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 9562ca0c2fbSBob Peterson goto out; 9572ca0c2fbSBob Peterson 9582bcd610dSSteven Whitehouse /* Log might have been flushed while we waited for the flush lock */ 9595a61ae14SAndreas Gruenbacher if (gl && !test_bit(GLF_LFLUSH, &gl->gl_flags)) 9605a61ae14SAndreas Gruenbacher goto out; 961805c0907SBob Peterson trace_gfs2_log_flush(sdp, 1, flags); 962f55ab26aSSteven Whitehouse 963c1696fb8SBob Peterson if (flags & GFS2_LOG_HEAD_FLUSH_SHUTDOWN) 964400ac52eSBenjamin Marzinski clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags); 965400ac52eSBenjamin Marzinski 966b1ab1e44SSteven Whitehouse sdp->sd_log_flush_head = sdp->sd_log_head; 96716ca9412SBenjamin Marzinski tr = sdp->sd_log_tr; 96816ca9412SBenjamin Marzinski if (tr) { 96916ca9412SBenjamin Marzinski sdp->sd_log_tr = NULL; 970b1ab1e44SSteven Whitehouse tr->tr_first = sdp->sd_log_flush_head; 9712e60d768SBenjamin Marzinski if (unlikely (state == SFS_FROZEN)) 972ca399c96SBob Peterson if (gfs2_assert_withdraw_delayed(sdp, 973ca399c96SBob Peterson !tr->tr_num_buf_new && !tr->tr_num_databuf_new)) 9745a61ae14SAndreas Gruenbacher goto out_withdraw; 97516ca9412SBenjamin Marzinski } 976b3b94faaSDavid Teigland 9772e60d768SBenjamin Marzinski if (unlikely(state == SFS_FROZEN)) 978ca399c96SBob Peterson if (gfs2_assert_withdraw_delayed(sdp, !sdp->sd_log_num_revoke)) 9795a61ae14SAndreas Gruenbacher goto out_withdraw; 980ca399c96SBob Peterson if (gfs2_assert_withdraw_delayed(sdp, 981ca399c96SBob Peterson sdp->sd_log_num_revoke == sdp->sd_log_committed_revoke)) 9825a61ae14SAndreas Gruenbacher goto out_withdraw; 983b3b94faaSDavid Teigland 984d7b616e2SSteven Whitehouse gfs2_ordered_write(sdp); 9852ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 9865a61ae14SAndreas Gruenbacher goto out_withdraw; 987d69a3c65SSteven Whitehouse lops_before_commit(sdp, tr); 9882ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 9895a61ae14SAndreas Gruenbacher goto out_withdraw; 990f4686c26SAbhi Das gfs2_log_submit_bio(&sdp->sd_log_bio, REQ_OP_WRITE); 9912ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 9925a61ae14SAndreas Gruenbacher goto out_withdraw; 993d7b616e2SSteven Whitehouse 99434cc1781SSteven Whitehouse if (sdp->sd_log_head != sdp->sd_log_flush_head) { 995428fd95dSBob Peterson log_flush_wait(sdp); 996c1696fb8SBob Peterson log_write_header(sdp, flags); 99734cc1781SSteven Whitehouse } else if (sdp->sd_log_tail != current_tail(sdp) && !sdp->sd_log_idle) { 998fd041f0bSSteven Whitehouse atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */ 99963997775SSteven Whitehouse trace_gfs2_log_blocks(sdp, -1); 1000c1696fb8SBob Peterson log_write_header(sdp, flags); 10012332c443SRobert Peterson } 10022ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 10035a61ae14SAndreas Gruenbacher goto out_withdraw; 100416ca9412SBenjamin Marzinski lops_after_commit(sdp, tr); 1005fe1a698fSSteven Whitehouse 1006fe1a698fSSteven Whitehouse gfs2_log_lock(sdp); 1007b3b94faaSDavid Teigland sdp->sd_log_head = sdp->sd_log_flush_head; 1008faa31ce8SSteven Whitehouse sdp->sd_log_blks_reserved = 0; 10095d439758SAndreas Gruenbacher sdp->sd_log_committed_revoke = 0; 1010b3b94faaSDavid Teigland 1011d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 101216ca9412SBenjamin Marzinski if (tr && !list_empty(&tr->tr_ail1_list)) { 101316ca9412SBenjamin Marzinski list_add(&tr->tr_list, &sdp->sd_ail1_list); 101416ca9412SBenjamin Marzinski tr = NULL; 1015b3b94faaSDavid Teigland } 1016d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 1017b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 101824972557SBenjamin Marzinski 1019c1696fb8SBob Peterson if (!(flags & GFS2_LOG_HEAD_FLUSH_NORMAL)) { 102024972557SBenjamin Marzinski if (!sdp->sd_log_idle) { 1021d5dc3d96SBob Peterson empty_ail1_list(sdp); 102230fe70a8SBob Peterson if (gfs2_withdrawn(sdp)) 10235a61ae14SAndreas Gruenbacher goto out_withdraw; 102424972557SBenjamin Marzinski atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */ 102524972557SBenjamin Marzinski trace_gfs2_log_blocks(sdp, -1); 1026c1696fb8SBob Peterson log_write_header(sdp, flags); 102724972557SBenjamin Marzinski sdp->sd_log_head = sdp->sd_log_flush_head; 102824972557SBenjamin Marzinski } 1029c1696fb8SBob Peterson if (flags & (GFS2_LOG_HEAD_FLUSH_SHUTDOWN | 1030c1696fb8SBob Peterson GFS2_LOG_HEAD_FLUSH_FREEZE)) 103124972557SBenjamin Marzinski gfs2_log_shutdown(sdp); 1032c1696fb8SBob Peterson if (flags & GFS2_LOG_HEAD_FLUSH_FREEZE) 10332e60d768SBenjamin Marzinski atomic_set(&sdp->sd_freeze_state, SFS_FROZEN); 103424972557SBenjamin Marzinski } 103524972557SBenjamin Marzinski 10365a61ae14SAndreas Gruenbacher out_end: 10375a61ae14SAndreas Gruenbacher trace_gfs2_log_flush(sdp, 0, flags); 103830fe70a8SBob Peterson out: 10395a61ae14SAndreas Gruenbacher up_write(&sdp->sd_log_flush_lock); 10405a61ae14SAndreas Gruenbacher gfs2_trans_free(sdp, tr); 10415a61ae14SAndreas Gruenbacher if (gfs2_withdrawing(sdp)) 10425a61ae14SAndreas Gruenbacher gfs2_withdraw(sdp); 10435a61ae14SAndreas Gruenbacher return; 10445a61ae14SAndreas Gruenbacher 10455a61ae14SAndreas Gruenbacher out_withdraw: 1046462582b9SBob Peterson trans_drain(tr); 104758e08e8dSBob Peterson /** 104858e08e8dSBob Peterson * If the tr_list is empty, we're withdrawing during a log 104958e08e8dSBob Peterson * flush that targets a transaction, but the transaction was 105058e08e8dSBob Peterson * never queued onto any of the ail lists. Here we add it to 105158e08e8dSBob Peterson * ail1 just so that ail_drain() will find and free it. 105258e08e8dSBob Peterson */ 105358e08e8dSBob Peterson spin_lock(&sdp->sd_ail_lock); 105458e08e8dSBob Peterson if (tr && list_empty(&tr->tr_list)) 105558e08e8dSBob Peterson list_add(&tr->tr_list, &sdp->sd_ail1_list); 105658e08e8dSBob Peterson spin_unlock(&sdp->sd_ail_lock); 10572ca0c2fbSBob Peterson ail_drain(sdp); /* frees all transactions */ 10582ca0c2fbSBob Peterson tr = NULL; 10595a61ae14SAndreas Gruenbacher goto out_end; 1060b3b94faaSDavid Teigland } 1061b3b94faaSDavid Teigland 1062d69a3c65SSteven Whitehouse /** 1063d69a3c65SSteven Whitehouse * gfs2_merge_trans - Merge a new transaction into a cached transaction 1064d69a3c65SSteven Whitehouse * @old: Original transaction to be expanded 1065d69a3c65SSteven Whitehouse * @new: New transaction to be merged 1066d69a3c65SSteven Whitehouse */ 1067d69a3c65SSteven Whitehouse 106883d060caSBob Peterson static void gfs2_merge_trans(struct gfs2_sbd *sdp, struct gfs2_trans *new) 1069d69a3c65SSteven Whitehouse { 107083d060caSBob Peterson struct gfs2_trans *old = sdp->sd_log_tr; 107183d060caSBob Peterson 10729862ca05SBob Peterson WARN_ON_ONCE(!test_bit(TR_ATTACHED, &old->tr_flags)); 1073d69a3c65SSteven Whitehouse 1074d69a3c65SSteven Whitehouse old->tr_num_buf_new += new->tr_num_buf_new; 1075d69a3c65SSteven Whitehouse old->tr_num_databuf_new += new->tr_num_databuf_new; 1076d69a3c65SSteven Whitehouse old->tr_num_buf_rm += new->tr_num_buf_rm; 1077d69a3c65SSteven Whitehouse old->tr_num_databuf_rm += new->tr_num_databuf_rm; 1078d69a3c65SSteven Whitehouse old->tr_num_revoke += new->tr_num_revoke; 1079a31b4ec5SBob Peterson old->tr_num_revoke_rm += new->tr_num_revoke_rm; 1080d69a3c65SSteven Whitehouse 1081d69a3c65SSteven Whitehouse list_splice_tail_init(&new->tr_databuf, &old->tr_databuf); 1082d69a3c65SSteven Whitehouse list_splice_tail_init(&new->tr_buf, &old->tr_buf); 108383d060caSBob Peterson 108483d060caSBob Peterson spin_lock(&sdp->sd_ail_lock); 108583d060caSBob Peterson list_splice_tail_init(&new->tr_ail1_list, &old->tr_ail1_list); 108683d060caSBob Peterson list_splice_tail_init(&new->tr_ail2_list, &old->tr_ail2_list); 108783d060caSBob Peterson spin_unlock(&sdp->sd_ail_lock); 1088d69a3c65SSteven Whitehouse } 1089d69a3c65SSteven Whitehouse 1090b3b94faaSDavid Teigland static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 1091b3b94faaSDavid Teigland { 10922332c443SRobert Peterson unsigned int reserved; 1093ac39aaddSSteven Whitehouse unsigned int unused; 1094022ef4feSSteven Whitehouse unsigned int maxres; 1095b3b94faaSDavid Teigland 1096b3b94faaSDavid Teigland gfs2_log_lock(sdp); 1097b3b94faaSDavid Teigland 1098d69a3c65SSteven Whitehouse if (sdp->sd_log_tr) { 109983d060caSBob Peterson gfs2_merge_trans(sdp, tr); 1100d69a3c65SSteven Whitehouse } else if (tr->tr_num_buf_new || tr->tr_num_databuf_new) { 1101c968f578SAndreas Gruenbacher gfs2_assert_withdraw(sdp, !test_bit(TR_ONSTACK, &tr->tr_flags)); 110216ca9412SBenjamin Marzinski sdp->sd_log_tr = tr; 11039862ca05SBob Peterson set_bit(TR_ATTACHED, &tr->tr_flags); 110416ca9412SBenjamin Marzinski } 1105022ef4feSSteven Whitehouse 1106a31b4ec5SBob Peterson sdp->sd_log_committed_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm; 1107022ef4feSSteven Whitehouse reserved = calc_reserved(sdp); 1108022ef4feSSteven Whitehouse maxres = sdp->sd_log_blks_reserved + tr->tr_reserved; 1109022ef4feSSteven Whitehouse gfs2_assert_withdraw(sdp, maxres >= reserved); 1110022ef4feSSteven Whitehouse unused = maxres - reserved; 1111*c1eba1b0SAndreas Gruenbacher gfs2_log_release(sdp, unused); 1112022ef4feSSteven Whitehouse sdp->sd_log_blks_reserved = reserved; 1113022ef4feSSteven Whitehouse 1114b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 1115b3b94faaSDavid Teigland } 1116b3b94faaSDavid Teigland 1117b3b94faaSDavid Teigland /** 1118b3b94faaSDavid Teigland * gfs2_log_commit - Commit a transaction to the log 1119b3b94faaSDavid Teigland * @sdp: the filesystem 1120b3b94faaSDavid Teigland * @tr: the transaction 1121b3b94faaSDavid Teigland * 11225e687eacSBenjamin Marzinski * We wake up gfs2_logd if the number of pinned blocks exceed thresh1 11235e687eacSBenjamin Marzinski * or the total number of used blocks (pinned blocks plus AIL blocks) 11245e687eacSBenjamin Marzinski * is greater than thresh2. 11255e687eacSBenjamin Marzinski * 1126b57bc0fbSBob Peterson * At mount time thresh1 is 2/5ths of journal size, thresh2 is 4/5ths of 11275e687eacSBenjamin Marzinski * journal size. 11285e687eacSBenjamin Marzinski * 1129b3b94faaSDavid Teigland * Returns: errno 1130b3b94faaSDavid Teigland */ 1131b3b94faaSDavid Teigland 1132b3b94faaSDavid Teigland void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 1133b3b94faaSDavid Teigland { 1134b3b94faaSDavid Teigland log_refund(sdp, tr); 1135b3b94faaSDavid Teigland 11365e687eacSBenjamin Marzinski if (atomic_read(&sdp->sd_log_pinned) > atomic_read(&sdp->sd_log_thresh1) || 11375e687eacSBenjamin Marzinski ((sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free)) > 11385e687eacSBenjamin Marzinski atomic_read(&sdp->sd_log_thresh2))) 11395e687eacSBenjamin Marzinski wake_up(&sdp->sd_logd_waitq); 1140faa31ce8SSteven Whitehouse } 1141b3b94faaSDavid Teigland 1142b3b94faaSDavid Teigland /** 1143b3b94faaSDavid Teigland * gfs2_log_shutdown - write a shutdown header into a journal 1144b3b94faaSDavid Teigland * @sdp: the filesystem 1145b3b94faaSDavid Teigland * 1146b3b94faaSDavid Teigland */ 1147b3b94faaSDavid Teigland 1148feed98a8SBob Peterson static void gfs2_log_shutdown(struct gfs2_sbd *sdp) 1149b3b94faaSDavid Teigland { 1150b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved); 1151b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke); 1152b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list)); 1153b3b94faaSDavid Teigland 1154b3b94faaSDavid Teigland sdp->sd_log_flush_head = sdp->sd_log_head; 1155b3b94faaSDavid Teigland 1156805c0907SBob Peterson log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT | GFS2_LFC_SHUTDOWN); 1157b3b94faaSDavid Teigland 1158a74604beSSteven Whitehouse gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail); 1159a74604beSSteven Whitehouse gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list)); 1160b3b94faaSDavid Teigland 1161b3b94faaSDavid Teigland sdp->sd_log_head = sdp->sd_log_flush_head; 1162b3b94faaSDavid Teigland sdp->sd_log_tail = sdp->sd_log_head; 1163a25311c8SSteven Whitehouse } 1164a25311c8SSteven Whitehouse 11655e687eacSBenjamin Marzinski static inline int gfs2_jrnl_flush_reqd(struct gfs2_sbd *sdp) 11665e687eacSBenjamin Marzinski { 1167f07b3520SBob Peterson return (atomic_read(&sdp->sd_log_pinned) + 1168f07b3520SBob Peterson atomic_read(&sdp->sd_log_blks_needed) >= 1169f07b3520SBob Peterson atomic_read(&sdp->sd_log_thresh1)); 11705e687eacSBenjamin Marzinski } 11715e687eacSBenjamin Marzinski 11725e687eacSBenjamin Marzinski static inline int gfs2_ail_flush_reqd(struct gfs2_sbd *sdp) 11735e687eacSBenjamin Marzinski { 11745e687eacSBenjamin Marzinski unsigned int used_blocks = sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free); 1175b066a4eeSAbhi Das 1176b066a4eeSAbhi Das if (test_and_clear_bit(SDF_FORCE_AIL_FLUSH, &sdp->sd_flags)) 1177b066a4eeSAbhi Das return 1; 1178b066a4eeSAbhi Das 1179f07b3520SBob Peterson return used_blocks + atomic_read(&sdp->sd_log_blks_needed) >= 1180f07b3520SBob Peterson atomic_read(&sdp->sd_log_thresh2); 11815e687eacSBenjamin Marzinski } 1182ec69b188SSteven Whitehouse 1183ec69b188SSteven Whitehouse /** 1184ec69b188SSteven Whitehouse * gfs2_logd - Update log tail as Active Items get flushed to in-place blocks 1185ec69b188SSteven Whitehouse * @sdp: Pointer to GFS2 superblock 1186ec69b188SSteven Whitehouse * 1187ec69b188SSteven Whitehouse * Also, periodically check to make sure that we're using the most recent 1188ec69b188SSteven Whitehouse * journal index. 1189ec69b188SSteven Whitehouse */ 1190ec69b188SSteven Whitehouse 1191ec69b188SSteven Whitehouse int gfs2_logd(void *data) 1192ec69b188SSteven Whitehouse { 1193ec69b188SSteven Whitehouse struct gfs2_sbd *sdp = data; 11945e687eacSBenjamin Marzinski unsigned long t = 1; 11955e687eacSBenjamin Marzinski DEFINE_WAIT(wait); 1196b63f5e84SBob Peterson bool did_flush; 1197ec69b188SSteven Whitehouse 1198ec69b188SSteven Whitehouse while (!kthread_should_stop()) { 1199ec69b188SSteven Whitehouse 1200d22f69a0SBob Peterson if (gfs2_withdrawn(sdp)) { 1201d22f69a0SBob Peterson msleep_interruptible(HZ); 1202d22f69a0SBob Peterson continue; 1203d22f69a0SBob Peterson } 1204942b0cddSBob Peterson /* Check for errors writing to the journal */ 1205942b0cddSBob Peterson if (sdp->sd_log_error) { 1206badb55ecSAndreas Gruenbacher gfs2_lm(sdp, 1207942b0cddSBob Peterson "GFS2: fsid=%s: error %d: " 1208942b0cddSBob Peterson "withdrawing the file system to " 1209942b0cddSBob Peterson "prevent further damage.\n", 1210942b0cddSBob Peterson sdp->sd_fsname, sdp->sd_log_error); 1211badb55ecSAndreas Gruenbacher gfs2_withdraw(sdp); 1212d22f69a0SBob Peterson continue; 1213942b0cddSBob Peterson } 1214942b0cddSBob Peterson 1215b63f5e84SBob Peterson did_flush = false; 12165e687eacSBenjamin Marzinski if (gfs2_jrnl_flush_reqd(sdp) || t == 0) { 12175e4c7632SBob Peterson gfs2_ail1_empty(sdp, 0); 1218805c0907SBob Peterson gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL | 1219805c0907SBob Peterson GFS2_LFC_LOGD_JFLUSH_REQD); 1220b63f5e84SBob Peterson did_flush = true; 1221ec69b188SSteven Whitehouse } 1222ec69b188SSteven Whitehouse 12235e687eacSBenjamin Marzinski if (gfs2_ail_flush_reqd(sdp)) { 12245e687eacSBenjamin Marzinski gfs2_ail1_start(sdp); 122526b06a69SSteven Whitehouse gfs2_ail1_wait(sdp); 12265e4c7632SBob Peterson gfs2_ail1_empty(sdp, 0); 1227805c0907SBob Peterson gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL | 1228805c0907SBob Peterson GFS2_LFC_LOGD_AIL_FLUSH_REQD); 1229b63f5e84SBob Peterson did_flush = true; 12305e687eacSBenjamin Marzinski } 12315e687eacSBenjamin Marzinski 1232b63f5e84SBob Peterson if (!gfs2_ail_flush_reqd(sdp) || did_flush) 12335e687eacSBenjamin Marzinski wake_up(&sdp->sd_log_waitq); 123426b06a69SSteven Whitehouse 1235ec69b188SSteven Whitehouse t = gfs2_tune_get(sdp, gt_logd_secs) * HZ; 1236a0acae0eSTejun Heo 1237a0acae0eSTejun Heo try_to_freeze(); 12385e687eacSBenjamin Marzinski 12395e687eacSBenjamin Marzinski do { 12405e687eacSBenjamin Marzinski prepare_to_wait(&sdp->sd_logd_waitq, &wait, 12415f487490SSteven Whitehouse TASK_INTERRUPTIBLE); 12425e687eacSBenjamin Marzinski if (!gfs2_ail_flush_reqd(sdp) && 12435e687eacSBenjamin Marzinski !gfs2_jrnl_flush_reqd(sdp) && 12445e687eacSBenjamin Marzinski !kthread_should_stop()) 12455e687eacSBenjamin Marzinski t = schedule_timeout(t); 12465e687eacSBenjamin Marzinski } while(t && !gfs2_ail_flush_reqd(sdp) && 12475e687eacSBenjamin Marzinski !gfs2_jrnl_flush_reqd(sdp) && 12485e687eacSBenjamin Marzinski !kthread_should_stop()); 12495e687eacSBenjamin Marzinski finish_wait(&sdp->sd_logd_waitq, &wait); 1250ec69b188SSteven Whitehouse } 1251ec69b188SSteven Whitehouse 1252ec69b188SSteven Whitehouse return 0; 1253ec69b188SSteven Whitehouse } 1254ec69b188SSteven Whitehouse 1255