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 2455cb738b5SAndreas Gruenbacher static void gfs2_log_update_flush_tail(struct gfs2_sbd *sdp) 2465cb738b5SAndreas Gruenbacher { 2475cb738b5SAndreas Gruenbacher unsigned int new_flush_tail = sdp->sd_log_head; 2485cb738b5SAndreas Gruenbacher struct gfs2_trans *tr; 2495cb738b5SAndreas Gruenbacher 2505cb738b5SAndreas Gruenbacher if (!list_empty(&sdp->sd_ail1_list)) { 2515cb738b5SAndreas Gruenbacher tr = list_last_entry(&sdp->sd_ail1_list, 2525cb738b5SAndreas Gruenbacher struct gfs2_trans, tr_list); 2535cb738b5SAndreas Gruenbacher new_flush_tail = tr->tr_first; 2545cb738b5SAndreas Gruenbacher } 2555cb738b5SAndreas Gruenbacher sdp->sd_log_flush_tail = new_flush_tail; 2565cb738b5SAndreas Gruenbacher } 2575cb738b5SAndreas Gruenbacher 2585cb738b5SAndreas Gruenbacher static void gfs2_log_update_head(struct gfs2_sbd *sdp) 2595cb738b5SAndreas Gruenbacher { 2605cb738b5SAndreas Gruenbacher unsigned int new_head = sdp->sd_log_flush_head; 2615cb738b5SAndreas Gruenbacher 2625cb738b5SAndreas Gruenbacher if (sdp->sd_log_flush_tail == sdp->sd_log_head) 2635cb738b5SAndreas Gruenbacher sdp->sd_log_flush_tail = new_head; 2645cb738b5SAndreas Gruenbacher sdp->sd_log_head = new_head; 2655cb738b5SAndreas Gruenbacher } 2665cb738b5SAndreas Gruenbacher 267ddacfaf7SSteven Whitehouse /** 26876fce654SAndreas Gruenbacher * gfs2_ail_empty_tr - empty one of the ail lists of a transaction 26976fce654SAndreas Gruenbacher */ 27076fce654SAndreas Gruenbacher 27176fce654SAndreas Gruenbacher static void gfs2_ail_empty_tr(struct gfs2_sbd *sdp, struct gfs2_trans *tr, 27276fce654SAndreas Gruenbacher struct list_head *head) 27376fce654SAndreas Gruenbacher { 27476fce654SAndreas Gruenbacher struct gfs2_bufdata *bd; 27576fce654SAndreas Gruenbacher 27676fce654SAndreas Gruenbacher while (!list_empty(head)) { 27776fce654SAndreas Gruenbacher bd = list_first_entry(head, struct gfs2_bufdata, 27876fce654SAndreas Gruenbacher bd_ail_st_list); 27976fce654SAndreas Gruenbacher gfs2_assert(sdp, bd->bd_tr == tr); 28076fce654SAndreas Gruenbacher gfs2_remove_from_ail(bd); 28176fce654SAndreas Gruenbacher } 28276fce654SAndreas Gruenbacher } 28376fce654SAndreas Gruenbacher 28476fce654SAndreas Gruenbacher /** 285ddacfaf7SSteven Whitehouse * gfs2_ail1_empty_one - Check whether or not a trans in the AIL has been synced 286ddacfaf7SSteven Whitehouse * @sdp: the filesystem 2875e4c7632SBob Peterson * @tr: the transaction 2885e4c7632SBob Peterson * @max_revokes: If nonzero, issue revokes for the bd items for written buffers 289ddacfaf7SSteven Whitehouse * 29036c78309SBob Peterson * returns: the transaction's count of remaining active items 291ddacfaf7SSteven Whitehouse */ 292ddacfaf7SSteven Whitehouse 29336c78309SBob Peterson static int gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_trans *tr, 2945e4c7632SBob Peterson int *max_revokes) 295ddacfaf7SSteven Whitehouse { 296ddacfaf7SSteven Whitehouse struct gfs2_bufdata *bd, *s; 297ddacfaf7SSteven Whitehouse struct buffer_head *bh; 29836c78309SBob Peterson int active_count = 0; 299ddacfaf7SSteven Whitehouse 30016ca9412SBenjamin Marzinski list_for_each_entry_safe_reverse(bd, s, &tr->tr_ail1_list, 301ddacfaf7SSteven Whitehouse bd_ail_st_list) { 302ddacfaf7SSteven Whitehouse bh = bd->bd_bh; 30316ca9412SBenjamin Marzinski gfs2_assert(sdp, bd->bd_tr == tr); 304036330c9SBob Peterson /* 305036330c9SBob Peterson * If another process flagged an io error, e.g. writing to the 306036330c9SBob Peterson * journal, error all other bhs and move them off the ail1 to 307036330c9SBob Peterson * prevent a tight loop when unmount tries to flush ail1, 308036330c9SBob Peterson * regardless of whether they're still busy. If no outside 309036330c9SBob Peterson * errors were found and the buffer is busy, move to the next. 310036330c9SBob Peterson * If the ail buffer is not busy and caught an error, flag it 311036330c9SBob Peterson * for others. 312036330c9SBob Peterson */ 31336c78309SBob Peterson if (!sdp->sd_log_error && buffer_busy(bh)) { 31436c78309SBob Peterson active_count++; 315ddacfaf7SSteven Whitehouse continue; 31636c78309SBob Peterson } 317b524abccSBob Peterson if (!buffer_uptodate(bh) && 318036330c9SBob Peterson !cmpxchg(&sdp->sd_log_error, 0, -EIO)) { 319ddacfaf7SSteven Whitehouse gfs2_io_error_bh(sdp, bh); 32069511080SBob Peterson gfs2_withdraw_delayed(sdp); 3219e1a9ecdSAndreas Gruenbacher } 3225e4c7632SBob Peterson /* 3235e4c7632SBob Peterson * If we have space for revokes and the bd is no longer on any 3245e4c7632SBob Peterson * buf list, we can just add a revoke for it immediately and 3255e4c7632SBob Peterson * avoid having to put it on the ail2 list, where it would need 3265e4c7632SBob Peterson * to be revoked later. 3275e4c7632SBob Peterson */ 3285e4c7632SBob Peterson if (*max_revokes && list_empty(&bd->bd_list)) { 3295e4c7632SBob Peterson gfs2_add_revoke(sdp, bd); 3305e4c7632SBob Peterson (*max_revokes)--; 3315e4c7632SBob Peterson continue; 3325e4c7632SBob Peterson } 33316ca9412SBenjamin Marzinski list_move(&bd->bd_ail_st_list, &tr->tr_ail2_list); 334ddacfaf7SSteven Whitehouse } 33536c78309SBob Peterson return active_count; 336ddacfaf7SSteven Whitehouse } 337ddacfaf7SSteven Whitehouse 3384667a0ecSSteven Whitehouse /** 3394667a0ecSSteven Whitehouse * gfs2_ail1_empty - Try to empty the ail1 lists 3404667a0ecSSteven Whitehouse * @sdp: The superblock 3415e4c7632SBob Peterson * @max_revokes: If non-zero, add revokes where appropriate 3424667a0ecSSteven Whitehouse * 3434667a0ecSSteven Whitehouse * Tries to empty the ail1 lists, starting with the oldest first 3444667a0ecSSteven Whitehouse */ 345b3b94faaSDavid Teigland 3465e4c7632SBob Peterson static int gfs2_ail1_empty(struct gfs2_sbd *sdp, int max_revokes) 347b3b94faaSDavid Teigland { 34816ca9412SBenjamin Marzinski struct gfs2_trans *tr, *s; 3495d054964SBenjamin Marzinski int oldest_tr = 1; 350b3b94faaSDavid Teigland int ret; 351b3b94faaSDavid Teigland 352d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 35316ca9412SBenjamin Marzinski list_for_each_entry_safe_reverse(tr, s, &sdp->sd_ail1_list, tr_list) { 35436c78309SBob Peterson if (!gfs2_ail1_empty_one(sdp, tr, &max_revokes) && oldest_tr) 35516ca9412SBenjamin Marzinski list_move(&tr->tr_list, &sdp->sd_ail2_list); 3564667a0ecSSteven Whitehouse else 3575d054964SBenjamin Marzinski oldest_tr = 0; 358b3b94faaSDavid Teigland } 3595cb738b5SAndreas Gruenbacher gfs2_log_update_flush_tail(sdp); 360b3b94faaSDavid Teigland ret = list_empty(&sdp->sd_ail1_list); 361d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 362b3b94faaSDavid Teigland 36369511080SBob Peterson if (test_bit(SDF_WITHDRAWING, &sdp->sd_flags)) { 364badb55ecSAndreas Gruenbacher gfs2_lm(sdp, "fatal: I/O error(s)\n"); 365badb55ecSAndreas Gruenbacher gfs2_withdraw(sdp); 366badb55ecSAndreas Gruenbacher } 3679e1a9ecdSAndreas Gruenbacher 368b3b94faaSDavid Teigland return ret; 369b3b94faaSDavid Teigland } 370b3b94faaSDavid Teigland 37126b06a69SSteven Whitehouse static void gfs2_ail1_wait(struct gfs2_sbd *sdp) 37226b06a69SSteven Whitehouse { 37316ca9412SBenjamin Marzinski struct gfs2_trans *tr; 37426b06a69SSteven Whitehouse struct gfs2_bufdata *bd; 37526b06a69SSteven Whitehouse struct buffer_head *bh; 37626b06a69SSteven Whitehouse 37726b06a69SSteven Whitehouse spin_lock(&sdp->sd_ail_lock); 37816ca9412SBenjamin Marzinski list_for_each_entry_reverse(tr, &sdp->sd_ail1_list, tr_list) { 37916ca9412SBenjamin Marzinski list_for_each_entry(bd, &tr->tr_ail1_list, bd_ail_st_list) { 38026b06a69SSteven Whitehouse bh = bd->bd_bh; 38126b06a69SSteven Whitehouse if (!buffer_locked(bh)) 38226b06a69SSteven Whitehouse continue; 38326b06a69SSteven Whitehouse get_bh(bh); 38426b06a69SSteven Whitehouse spin_unlock(&sdp->sd_ail_lock); 38526b06a69SSteven Whitehouse wait_on_buffer(bh); 38626b06a69SSteven Whitehouse brelse(bh); 38726b06a69SSteven Whitehouse return; 38826b06a69SSteven Whitehouse } 38926b06a69SSteven Whitehouse } 39026b06a69SSteven Whitehouse spin_unlock(&sdp->sd_ail_lock); 39126b06a69SSteven Whitehouse } 392ddacfaf7SSteven Whitehouse 3936e80674aSAndreas Gruenbacher static void __ail2_empty(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 394b3b94faaSDavid Teigland { 3952ca0c2fbSBob Peterson gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list); 39616ca9412SBenjamin Marzinski list_del(&tr->tr_list); 39716ca9412SBenjamin Marzinski gfs2_assert_warn(sdp, list_empty(&tr->tr_ail1_list)); 39816ca9412SBenjamin Marzinski gfs2_assert_warn(sdp, list_empty(&tr->tr_ail2_list)); 399b839dadaSBob Peterson gfs2_trans_free(sdp, tr); 400b3b94faaSDavid Teigland } 401b3b94faaSDavid Teigland 4026e80674aSAndreas Gruenbacher static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail) 4036e80674aSAndreas Gruenbacher { 4046e80674aSAndreas Gruenbacher struct list_head *ail2_list = &sdp->sd_ail2_list; 4056e80674aSAndreas Gruenbacher unsigned int old_tail = sdp->sd_log_tail; 4066e80674aSAndreas Gruenbacher struct gfs2_trans *tr, *safe; 4076e80674aSAndreas Gruenbacher 4086e80674aSAndreas Gruenbacher spin_lock(&sdp->sd_ail_lock); 4096e80674aSAndreas Gruenbacher if (old_tail <= new_tail) { 4106e80674aSAndreas Gruenbacher list_for_each_entry_safe(tr, safe, ail2_list, tr_list) { 4116e80674aSAndreas Gruenbacher if (old_tail <= tr->tr_first && tr->tr_first < new_tail) 4126e80674aSAndreas Gruenbacher __ail2_empty(sdp, tr); 4136e80674aSAndreas Gruenbacher } 4146e80674aSAndreas Gruenbacher } else { 4156e80674aSAndreas Gruenbacher list_for_each_entry_safe(tr, safe, ail2_list, tr_list) { 4166e80674aSAndreas Gruenbacher if (old_tail <= tr->tr_first || tr->tr_first < new_tail) 4176e80674aSAndreas Gruenbacher __ail2_empty(sdp, tr); 4186e80674aSAndreas Gruenbacher } 4196e80674aSAndreas Gruenbacher } 420d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 421b3b94faaSDavid Teigland } 422b3b94faaSDavid Teigland 423b3b94faaSDavid Teigland /** 424f3708fb5SAndreas Gruenbacher * gfs2_log_is_empty - Check if the log is empty 425f3708fb5SAndreas Gruenbacher * @sdp: The GFS2 superblock 426f3708fb5SAndreas Gruenbacher */ 427f3708fb5SAndreas Gruenbacher 428f3708fb5SAndreas Gruenbacher bool gfs2_log_is_empty(struct gfs2_sbd *sdp) { 429f3708fb5SAndreas Gruenbacher return atomic_read(&sdp->sd_log_blks_free) == sdp->sd_jdesc->jd_blocks; 430f3708fb5SAndreas Gruenbacher } 431f3708fb5SAndreas Gruenbacher 432f3708fb5SAndreas Gruenbacher /** 43324972557SBenjamin Marzinski * gfs2_log_release - Release a given number of log blocks 43424972557SBenjamin Marzinski * @sdp: The GFS2 superblock 43524972557SBenjamin Marzinski * @blks: The number of blocks 43624972557SBenjamin Marzinski * 43724972557SBenjamin Marzinski */ 43824972557SBenjamin Marzinski 43924972557SBenjamin Marzinski void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks) 44024972557SBenjamin Marzinski { 44124972557SBenjamin Marzinski atomic_add(blks, &sdp->sd_log_blks_free); 44224972557SBenjamin Marzinski trace_gfs2_log_blocks(sdp, blks); 44324972557SBenjamin Marzinski gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <= 44424972557SBenjamin Marzinski sdp->sd_jdesc->jd_blocks); 4455ae8fff8SAndreas Gruenbacher if (atomic_read(&sdp->sd_log_blks_needed)) 4465ae8fff8SAndreas Gruenbacher wake_up(&sdp->sd_log_waitq); 44724972557SBenjamin Marzinski } 44824972557SBenjamin Marzinski 44924972557SBenjamin Marzinski /** 450b3b94faaSDavid Teigland * gfs2_log_reserve - Make a log reservation 451b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 452b3b94faaSDavid Teigland * @blks: The number of blocks to reserve 453b3b94faaSDavid Teigland * 45489918647SSteven Whitehouse * Note that we never give out the last few blocks of the journal. Thats 4552332c443SRobert Peterson * due to the fact that there is a small number of header blocks 456b004157aSSteven Whitehouse * associated with each log flush. The exact number can't be known until 457b004157aSSteven Whitehouse * flush time, so we ensure that we have just enough free blocks at all 458b004157aSSteven Whitehouse * times to avoid running out during a log flush. 459b004157aSSteven Whitehouse * 4605e687eacSBenjamin Marzinski * We no longer flush the log here, instead we wake up logd to do that 4615e687eacSBenjamin Marzinski * for us. To avoid the thundering herd and to ensure that we deal fairly 4625e687eacSBenjamin Marzinski * with queued waiters, we use an exclusive wait. This means that when we 4635e687eacSBenjamin Marzinski * get woken with enough journal space to get our reservation, we need to 4645e687eacSBenjamin Marzinski * wake the next waiter on the list. 465b3b94faaSDavid Teigland */ 466b3b94faaSDavid Teigland 467c1eba1b0SAndreas Gruenbacher void gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks) 468b3b94faaSDavid Teigland { 4695d054964SBenjamin Marzinski unsigned reserved_blks = 7 * (4096 / sdp->sd_vfs->s_blocksize); 4705e687eacSBenjamin Marzinski unsigned wanted = blks + reserved_blks; 4715e687eacSBenjamin Marzinski unsigned int free_blocks; 472b3b94faaSDavid Teigland 4735e687eacSBenjamin Marzinski free_blocks = atomic_read(&sdp->sd_log_blks_free); 4745ae8fff8SAndreas Gruenbacher while (free_blocks >= wanted) { 4755ae8fff8SAndreas Gruenbacher if (atomic_try_cmpxchg(&sdp->sd_log_blks_free, &free_blocks, 4765ae8fff8SAndreas Gruenbacher free_blocks - blks)) 4775ae8fff8SAndreas Gruenbacher return; 478b3b94faaSDavid Teigland } 4795e687eacSBenjamin Marzinski 4805ae8fff8SAndreas Gruenbacher atomic_add(blks, &sdp->sd_log_blks_needed); 4815ae8fff8SAndreas Gruenbacher for (;;) { 4825ae8fff8SAndreas Gruenbacher if (current != sdp->sd_logd_process) 4835ae8fff8SAndreas Gruenbacher wake_up(&sdp->sd_logd_waitq); 4845ae8fff8SAndreas Gruenbacher io_wait_event(sdp->sd_log_waitq, 4855ae8fff8SAndreas Gruenbacher (free_blocks = atomic_read(&sdp->sd_log_blks_free), 4865ae8fff8SAndreas Gruenbacher free_blocks >= wanted)); 4875ae8fff8SAndreas Gruenbacher do { 4885ae8fff8SAndreas Gruenbacher if (atomic_try_cmpxchg(&sdp->sd_log_blks_free, 4895ae8fff8SAndreas Gruenbacher &free_blocks, 4905ae8fff8SAndreas Gruenbacher free_blocks - blks)) 4915ae8fff8SAndreas Gruenbacher goto reserved; 4925ae8fff8SAndreas Gruenbacher } while (free_blocks >= wanted); 4935ae8fff8SAndreas Gruenbacher } 4945ae8fff8SAndreas Gruenbacher 4955ae8fff8SAndreas Gruenbacher reserved: 4965ae8fff8SAndreas Gruenbacher trace_gfs2_log_blocks(sdp, -blks); 4975ae8fff8SAndreas Gruenbacher if (atomic_sub_return(blks, &sdp->sd_log_blks_needed)) 4985e687eacSBenjamin Marzinski wake_up(&sdp->sd_log_waitq); 499b3b94faaSDavid Teigland } 500b3b94faaSDavid Teigland 501b3b94faaSDavid Teigland /** 502b3b94faaSDavid Teigland * log_distance - Compute distance between two journal blocks 503b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 504b3b94faaSDavid Teigland * @newer: The most recent journal block of the pair 505b3b94faaSDavid Teigland * @older: The older journal block of the pair 506b3b94faaSDavid Teigland * 507b3b94faaSDavid Teigland * Compute the distance (in the journal direction) between two 508b3b94faaSDavid Teigland * blocks in the journal 509b3b94faaSDavid Teigland * 510b3b94faaSDavid Teigland * Returns: the distance in blocks 511b3b94faaSDavid Teigland */ 512b3b94faaSDavid Teigland 513faa31ce8SSteven Whitehouse static inline unsigned int log_distance(struct gfs2_sbd *sdp, unsigned int newer, 514b3b94faaSDavid Teigland unsigned int older) 515b3b94faaSDavid Teigland { 516b3b94faaSDavid Teigland int dist; 517b3b94faaSDavid Teigland 518b3b94faaSDavid Teigland dist = newer - older; 519b3b94faaSDavid Teigland if (dist < 0) 520b3b94faaSDavid Teigland dist += sdp->sd_jdesc->jd_blocks; 521b3b94faaSDavid Teigland 522b3b94faaSDavid Teigland return dist; 523b3b94faaSDavid Teigland } 524b3b94faaSDavid Teigland 5252332c443SRobert Peterson /** 5266188e877SAndreas Gruenbacher * calc_reserved - Calculate the number of blocks to keep reserved 5272332c443SRobert Peterson * @sdp: The GFS2 superblock 5282332c443SRobert Peterson * 5292332c443SRobert Peterson * This is complex. We need to reserve room for all our currently used 5306188e877SAndreas Gruenbacher * metadata blocks (e.g. normal file I/O rewriting file time stamps) and 5316188e877SAndreas Gruenbacher * all our journaled data blocks for journaled files (e.g. files in the 5322332c443SRobert Peterson * meta_fs like rindex, or files for which chattr +j was done.) 5336188e877SAndreas Gruenbacher * If we don't reserve enough space, corruption will follow. 5342332c443SRobert Peterson * 5356188e877SAndreas Gruenbacher * We can have metadata blocks and jdata blocks in the same journal. Each 5366188e877SAndreas Gruenbacher * type gets its own log descriptor, for which we need to reserve a block. 5376188e877SAndreas Gruenbacher * In fact, each type has the potential for needing more than one log descriptor 5386188e877SAndreas Gruenbacher * in cases where we have more blocks than will fit in a log descriptor. 5392332c443SRobert Peterson * Metadata journal entries take up half the space of journaled buffer entries. 5402332c443SRobert Peterson * 5412332c443SRobert Peterson * Also, we need to reserve blocks for revoke journal entries and one for an 5422332c443SRobert Peterson * overall header for the lot. 5432332c443SRobert Peterson * 5442332c443SRobert Peterson * Returns: the number of blocks reserved 5452332c443SRobert Peterson */ 5462332c443SRobert Peterson static unsigned int calc_reserved(struct gfs2_sbd *sdp) 5472332c443SRobert Peterson { 5482332c443SRobert Peterson unsigned int reserved = 0; 549*71b219f4SAndreas Gruenbacher unsigned int blocks; 550022ef4feSSteven Whitehouse struct gfs2_trans *tr = sdp->sd_log_tr; 5512332c443SRobert Peterson 552022ef4feSSteven Whitehouse if (tr) { 553*71b219f4SAndreas Gruenbacher blocks = tr->tr_num_buf_new - tr->tr_num_buf_rm; 554*71b219f4SAndreas Gruenbacher reserved += blocks + DIV_ROUND_UP(blocks, buf_limit(sdp)); 555*71b219f4SAndreas Gruenbacher blocks = tr->tr_num_databuf_new - tr->tr_num_databuf_rm; 556*71b219f4SAndreas Gruenbacher reserved += blocks + DIV_ROUND_UP(blocks, databuf_limit(sdp)); 557022ef4feSSteven Whitehouse } 5582332c443SRobert Peterson 5595d439758SAndreas Gruenbacher if (sdp->sd_log_committed_revoke > 0) 5605d439758SAndreas Gruenbacher reserved += gfs2_struct2blk(sdp, sdp->sd_log_committed_revoke); 5612332c443SRobert Peterson /* One for the overall header */ 5622332c443SRobert Peterson if (reserved) 5632332c443SRobert Peterson reserved++; 5642332c443SRobert Peterson return reserved; 5652332c443SRobert Peterson } 5662332c443SRobert Peterson 5675cb738b5SAndreas Gruenbacher static void log_pull_tail(struct gfs2_sbd *sdp) 568b3b94faaSDavid Teigland { 5695cb738b5SAndreas Gruenbacher unsigned int new_tail = sdp->sd_log_flush_tail; 5705cb738b5SAndreas Gruenbacher unsigned int dist; 571b3b94faaSDavid Teigland 5725cb738b5SAndreas Gruenbacher if (new_tail == sdp->sd_log_tail) 5735cb738b5SAndreas Gruenbacher return; 5745cb738b5SAndreas Gruenbacher dist = log_distance(sdp, new_tail, sdp->sd_log_tail); 575b3b94faaSDavid Teigland ail2_empty(sdp, new_tail); 576c1eba1b0SAndreas Gruenbacher gfs2_log_release(sdp, dist); 577b3b94faaSDavid Teigland sdp->sd_log_tail = new_tail; 578b3b94faaSDavid Teigland } 579b3b94faaSDavid Teigland 580b3b94faaSDavid Teigland 5819ff78289SBob Peterson void log_flush_wait(struct gfs2_sbd *sdp) 582b3b94faaSDavid Teigland { 58316615be1SSteven Whitehouse DEFINE_WAIT(wait); 584b3b94faaSDavid Teigland 58516615be1SSteven Whitehouse if (atomic_read(&sdp->sd_log_in_flight)) { 58616615be1SSteven Whitehouse do { 58716615be1SSteven Whitehouse prepare_to_wait(&sdp->sd_log_flush_wait, &wait, 58816615be1SSteven Whitehouse TASK_UNINTERRUPTIBLE); 58916615be1SSteven Whitehouse if (atomic_read(&sdp->sd_log_in_flight)) 59016615be1SSteven Whitehouse io_schedule(); 59116615be1SSteven Whitehouse } while(atomic_read(&sdp->sd_log_in_flight)); 59216615be1SSteven Whitehouse finish_wait(&sdp->sd_log_flush_wait, &wait); 593b3b94faaSDavid Teigland } 594b3b94faaSDavid Teigland } 595b3b94faaSDavid Teigland 59645138990SSteven Whitehouse static int ip_cmp(void *priv, struct list_head *a, struct list_head *b) 5974a36d08dSBob Peterson { 59845138990SSteven Whitehouse struct gfs2_inode *ipa, *ipb; 5994a36d08dSBob Peterson 60045138990SSteven Whitehouse ipa = list_entry(a, struct gfs2_inode, i_ordered); 60145138990SSteven Whitehouse ipb = list_entry(b, struct gfs2_inode, i_ordered); 6024a36d08dSBob Peterson 60345138990SSteven Whitehouse if (ipa->i_no_addr < ipb->i_no_addr) 6044a36d08dSBob Peterson return -1; 60545138990SSteven Whitehouse if (ipa->i_no_addr > ipb->i_no_addr) 6064a36d08dSBob Peterson return 1; 6074a36d08dSBob Peterson return 0; 6084a36d08dSBob Peterson } 6094a36d08dSBob Peterson 6107542486bSBob Peterson static void __ordered_del_inode(struct gfs2_inode *ip) 6117542486bSBob Peterson { 6127542486bSBob Peterson if (!list_empty(&ip->i_ordered)) 6137542486bSBob Peterson list_del_init(&ip->i_ordered); 6147542486bSBob Peterson } 6157542486bSBob Peterson 616d7b616e2SSteven Whitehouse static void gfs2_ordered_write(struct gfs2_sbd *sdp) 617d7b616e2SSteven Whitehouse { 61845138990SSteven Whitehouse struct gfs2_inode *ip; 619d7b616e2SSteven Whitehouse LIST_HEAD(written); 620d7b616e2SSteven Whitehouse 62145138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 622a5b1d3fcSAndreas Gruenbacher list_sort(NULL, &sdp->sd_log_ordered, &ip_cmp); 623a5b1d3fcSAndreas Gruenbacher while (!list_empty(&sdp->sd_log_ordered)) { 624969183bcSAndreas Gruenbacher ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered); 6251f23bc78SAbhi Das if (ip->i_inode.i_mapping->nrpages == 0) { 6267542486bSBob Peterson __ordered_del_inode(ip); 627d7b616e2SSteven Whitehouse continue; 6281f23bc78SAbhi Das } 6291f23bc78SAbhi Das list_move(&ip->i_ordered, &written); 63045138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 63145138990SSteven Whitehouse filemap_fdatawrite(ip->i_inode.i_mapping); 63245138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 633d7b616e2SSteven Whitehouse } 634a5b1d3fcSAndreas Gruenbacher list_splice(&written, &sdp->sd_log_ordered); 63545138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 636d7b616e2SSteven Whitehouse } 637d7b616e2SSteven Whitehouse 638d7b616e2SSteven Whitehouse static void gfs2_ordered_wait(struct gfs2_sbd *sdp) 639d7b616e2SSteven Whitehouse { 64045138990SSteven Whitehouse struct gfs2_inode *ip; 641d7b616e2SSteven Whitehouse 64245138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 643a5b1d3fcSAndreas Gruenbacher while (!list_empty(&sdp->sd_log_ordered)) { 644969183bcSAndreas Gruenbacher ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered); 6457542486bSBob Peterson __ordered_del_inode(ip); 64645138990SSteven Whitehouse if (ip->i_inode.i_mapping->nrpages == 0) 647d7b616e2SSteven Whitehouse continue; 64845138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 64945138990SSteven Whitehouse filemap_fdatawait(ip->i_inode.i_mapping); 65045138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 651d7b616e2SSteven Whitehouse } 65245138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 653d7b616e2SSteven Whitehouse } 65445138990SSteven Whitehouse 65545138990SSteven Whitehouse void gfs2_ordered_del_inode(struct gfs2_inode *ip) 65645138990SSteven Whitehouse { 65745138990SSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 65845138990SSteven Whitehouse 65945138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 6607542486bSBob Peterson __ordered_del_inode(ip); 66145138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 662d7b616e2SSteven Whitehouse } 663d7b616e2SSteven Whitehouse 6645d054964SBenjamin Marzinski void gfs2_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd) 6655d054964SBenjamin Marzinski { 6665d054964SBenjamin Marzinski struct buffer_head *bh = bd->bd_bh; 6675d054964SBenjamin Marzinski struct gfs2_glock *gl = bd->bd_gl; 6685d054964SBenjamin Marzinski 669f4e2f5e1SAndreas Gruenbacher sdp->sd_log_num_revoke++; 670f4e2f5e1SAndreas Gruenbacher if (atomic_inc_return(&gl->gl_revokes) == 1) 671f4e2f5e1SAndreas Gruenbacher gfs2_glock_hold(gl); 6725d054964SBenjamin Marzinski bh->b_private = NULL; 6735d054964SBenjamin Marzinski bd->bd_blkno = bh->b_blocknr; 6749290a9a7SBob Peterson gfs2_remove_from_ail(bd); /* drops ref on bh */ 6759290a9a7SBob Peterson bd->bd_bh = NULL; 6765d054964SBenjamin Marzinski set_bit(GLF_LFLUSH, &gl->gl_flags); 677a5b1d3fcSAndreas Gruenbacher list_add(&bd->bd_list, &sdp->sd_log_revokes); 6785d054964SBenjamin Marzinski } 6795d054964SBenjamin Marzinski 680fe5e7ba1SBob Peterson void gfs2_glock_remove_revoke(struct gfs2_glock *gl) 681fe5e7ba1SBob Peterson { 682fe5e7ba1SBob Peterson if (atomic_dec_return(&gl->gl_revokes) == 0) { 683fe5e7ba1SBob Peterson clear_bit(GLF_LFLUSH, &gl->gl_flags); 684fe5e7ba1SBob Peterson gfs2_glock_queue_put(gl); 685fe5e7ba1SBob Peterson } 686fe5e7ba1SBob Peterson } 687fe5e7ba1SBob Peterson 6885e4c7632SBob Peterson /** 689e7501bf8SAndreas Gruenbacher * gfs2_flush_revokes - Add as many revokes to the system transaction as we can 6905e4c7632SBob Peterson * @sdp: The GFS2 superblock 6915e4c7632SBob Peterson * 6925e4c7632SBob Peterson * Our usual strategy is to defer writing revokes as much as we can in the hope 6935e4c7632SBob Peterson * that we'll eventually overwrite the journal, which will make those revokes 6945e4c7632SBob Peterson * go away. This changes when we flush the log: at that point, there will 6955e4c7632SBob Peterson * likely be some left-over space in the last revoke block of that transaction. 6965e4c7632SBob Peterson * We can fill that space with additional revokes for blocks that have already 6975e4c7632SBob Peterson * been written back. This will basically come at no cost now, and will save 6985e4c7632SBob Peterson * us from having to keep track of those blocks on the AIL2 list later. 6995e4c7632SBob Peterson */ 700e7501bf8SAndreas Gruenbacher void gfs2_flush_revokes(struct gfs2_sbd *sdp) 7015d054964SBenjamin Marzinski { 7025e4c7632SBob Peterson /* number of revokes we still have room for */ 7035a4e9c60SAndreas Gruenbacher unsigned int max_revokes; 7045d054964SBenjamin Marzinski 7055e4c7632SBob Peterson gfs2_log_lock(sdp); 7065a4e9c60SAndreas Gruenbacher max_revokes = sdp->sd_ldptrs; 7075a4e9c60SAndreas Gruenbacher if (sdp->sd_log_num_revoke > sdp->sd_ldptrs) 7085a4e9c60SAndreas Gruenbacher max_revokes += roundup(sdp->sd_log_num_revoke - sdp->sd_ldptrs, 7095a4e9c60SAndreas Gruenbacher sdp->sd_inptrs); 7105d054964SBenjamin Marzinski max_revokes -= sdp->sd_log_num_revoke; 7115d054964SBenjamin Marzinski if (!sdp->sd_log_num_revoke) { 7125d054964SBenjamin Marzinski atomic_dec(&sdp->sd_log_blks_free); 7135d054964SBenjamin Marzinski /* If no blocks have been reserved, we need to also 7145d054964SBenjamin Marzinski * reserve a block for the header */ 71577650bdbSBob Peterson if (!sdp->sd_log_blks_reserved) { 7165d054964SBenjamin Marzinski atomic_dec(&sdp->sd_log_blks_free); 71777650bdbSBob Peterson trace_gfs2_log_blocks(sdp, -2); 71877650bdbSBob Peterson } else { 71977650bdbSBob Peterson trace_gfs2_log_blocks(sdp, -1); 72077650bdbSBob Peterson } 7215d054964SBenjamin Marzinski } 7225e4c7632SBob Peterson gfs2_ail1_empty(sdp, max_revokes); 7235d054964SBenjamin Marzinski gfs2_log_unlock(sdp); 7245d054964SBenjamin Marzinski 7255d054964SBenjamin Marzinski if (!sdp->sd_log_num_revoke) { 7265d054964SBenjamin Marzinski atomic_inc(&sdp->sd_log_blks_free); 72777650bdbSBob Peterson if (!sdp->sd_log_blks_reserved) { 7285d054964SBenjamin Marzinski atomic_inc(&sdp->sd_log_blks_free); 72977650bdbSBob Peterson trace_gfs2_log_blocks(sdp, 2); 73077650bdbSBob Peterson } else { 73177650bdbSBob Peterson trace_gfs2_log_blocks(sdp, 1); 73277650bdbSBob Peterson } 7335d054964SBenjamin Marzinski } 7345d054964SBenjamin Marzinski } 7355d054964SBenjamin Marzinski 736b3b94faaSDavid Teigland /** 7377c70b896SBob Peterson * gfs2_write_log_header - Write a journal log header buffer at lblock 738588bff95SBob Peterson * @sdp: The GFS2 superblock 739c1696fb8SBob Peterson * @jd: journal descriptor of the journal to which we are writing 740588bff95SBob Peterson * @seq: sequence number 741588bff95SBob Peterson * @tail: tail of the log 7427c70b896SBob Peterson * @lblock: value for lh_blkno (block number relative to start of journal) 743c1696fb8SBob Peterson * @flags: log header flags GFS2_LOG_HEAD_* 744588bff95SBob Peterson * @op_flags: flags to pass to the bio 745588bff95SBob Peterson * 746588bff95SBob Peterson * Returns: the initialized log buffer descriptor 747588bff95SBob Peterson */ 748588bff95SBob Peterson 749c1696fb8SBob Peterson void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd, 7507c70b896SBob Peterson u64 seq, u32 tail, u32 lblock, u32 flags, 7517c70b896SBob Peterson int op_flags) 752588bff95SBob Peterson { 753588bff95SBob Peterson struct gfs2_log_header *lh; 754c1696fb8SBob Peterson u32 hash, crc; 755ade48088SBob Peterson struct page *page; 756c1696fb8SBob Peterson struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 757c1696fb8SBob Peterson struct timespec64 tv; 758c1696fb8SBob Peterson struct super_block *sb = sdp->sd_vfs; 7597c70b896SBob Peterson u64 dblock; 760588bff95SBob Peterson 761ade48088SBob Peterson if (gfs2_withdrawn(sdp)) 7624a3d049dSAndreas Gruenbacher return; 763ade48088SBob Peterson 764ade48088SBob Peterson page = mempool_alloc(gfs2_page_pool, GFP_NOIO); 765588bff95SBob Peterson lh = page_address(page); 766588bff95SBob Peterson clear_page(lh); 767588bff95SBob Peterson 768588bff95SBob Peterson lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 769588bff95SBob Peterson lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH); 770588bff95SBob Peterson lh->lh_header.__pad0 = cpu_to_be64(0); 771588bff95SBob Peterson lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH); 772588bff95SBob Peterson lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid); 773588bff95SBob Peterson lh->lh_sequence = cpu_to_be64(seq); 774588bff95SBob Peterson lh->lh_flags = cpu_to_be32(flags); 775588bff95SBob Peterson lh->lh_tail = cpu_to_be32(tail); 7767c70b896SBob Peterson lh->lh_blkno = cpu_to_be32(lblock); 777c1696fb8SBob Peterson hash = ~crc32(~0, lh, LH_V1_SIZE); 778588bff95SBob Peterson lh->lh_hash = cpu_to_be32(hash); 779588bff95SBob Peterson 780ee9c7f9aSArnd Bergmann ktime_get_coarse_real_ts64(&tv); 781c1696fb8SBob Peterson lh->lh_nsec = cpu_to_be32(tv.tv_nsec); 782c1696fb8SBob Peterson lh->lh_sec = cpu_to_be64(tv.tv_sec); 7837c70b896SBob Peterson if (!list_empty(&jd->extent_list)) 78419ebc050SAndreas Gruenbacher dblock = gfs2_log_bmap(jd, lblock); 7857c70b896SBob Peterson else { 7867c70b896SBob Peterson int ret = gfs2_lblk_to_dblk(jd->jd_inode, lblock, &dblock); 7877c70b896SBob Peterson if (gfs2_assert_withdraw(sdp, ret == 0)) 7887c70b896SBob Peterson return; 7897c70b896SBob Peterson } 7907c70b896SBob Peterson lh->lh_addr = cpu_to_be64(dblock); 791c1696fb8SBob Peterson lh->lh_jinode = cpu_to_be64(GFS2_I(jd->jd_inode)->i_no_addr); 792c1696fb8SBob Peterson 793c1696fb8SBob Peterson /* We may only write local statfs, quota, etc., when writing to our 794c1696fb8SBob Peterson own journal. The values are left 0 when recovering a journal 795c1696fb8SBob Peterson different from our own. */ 796c1696fb8SBob Peterson if (!(flags & GFS2_LOG_HEAD_RECOVERY)) { 797c1696fb8SBob Peterson lh->lh_statfs_addr = 798c1696fb8SBob Peterson cpu_to_be64(GFS2_I(sdp->sd_sc_inode)->i_no_addr); 799c1696fb8SBob Peterson lh->lh_quota_addr = 800c1696fb8SBob Peterson cpu_to_be64(GFS2_I(sdp->sd_qc_inode)->i_no_addr); 801c1696fb8SBob Peterson 802c1696fb8SBob Peterson spin_lock(&sdp->sd_statfs_spin); 803c1696fb8SBob Peterson lh->lh_local_total = cpu_to_be64(l_sc->sc_total); 804c1696fb8SBob Peterson lh->lh_local_free = cpu_to_be64(l_sc->sc_free); 805c1696fb8SBob Peterson lh->lh_local_dinodes = cpu_to_be64(l_sc->sc_dinodes); 806c1696fb8SBob Peterson spin_unlock(&sdp->sd_statfs_spin); 807c1696fb8SBob Peterson } 808c1696fb8SBob Peterson 809c1696fb8SBob Peterson BUILD_BUG_ON(offsetof(struct gfs2_log_header, lh_crc) != LH_V1_SIZE); 810c1696fb8SBob Peterson 811c1696fb8SBob Peterson crc = crc32c(~0, (void *)lh + LH_V1_SIZE + 4, 812c1696fb8SBob Peterson sb->s_blocksize - LH_V1_SIZE - 4); 813c1696fb8SBob Peterson lh->lh_crc = cpu_to_be32(crc); 814c1696fb8SBob Peterson 8157c70b896SBob Peterson gfs2_log_write(sdp, page, sb->s_blocksize, 0, dblock); 816f4686c26SAbhi Das gfs2_log_submit_bio(&sdp->sd_log_bio, REQ_OP_WRITE | op_flags); 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 { 8290f0b9b63SJan Kara int op_flags = REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC; 8302e60d768SBenjamin Marzinski enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state); 83134cc1781SSteven Whitehouse 8322e60d768SBenjamin Marzinski gfs2_assert_withdraw(sdp, (state != SFS_FROZEN)); 83334cc1781SSteven Whitehouse 83434cc1781SSteven Whitehouse if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags)) { 83534cc1781SSteven Whitehouse gfs2_ordered_wait(sdp); 83634cc1781SSteven Whitehouse log_flush_wait(sdp); 83770fd7614SChristoph Hellwig op_flags = REQ_SYNC | REQ_META | REQ_PRIO; 83834cc1781SSteven Whitehouse } 8395cb738b5SAndreas Gruenbacher sdp->sd_log_idle = (sdp->sd_log_flush_tail == sdp->sd_log_flush_head); 8405cb738b5SAndreas Gruenbacher gfs2_write_log_header(sdp, sdp->sd_jdesc, sdp->sd_log_sequence++, 8415cb738b5SAndreas Gruenbacher sdp->sd_log_flush_tail, sdp->sd_log_flush_head, 8425cb738b5SAndreas Gruenbacher flags, op_flags); 84319ebc050SAndreas Gruenbacher gfs2_log_incr_head(sdp); 8444a3d049dSAndreas Gruenbacher log_flush_wait(sdp); 8455cb738b5SAndreas Gruenbacher log_pull_tail(sdp); 84634cc1781SSteven Whitehouse } 84734cc1781SSteven Whitehouse 84834cc1781SSteven Whitehouse /** 8492ca0c2fbSBob Peterson * ail_drain - drain the ail lists after a withdraw 8502ca0c2fbSBob Peterson * @sdp: Pointer to GFS2 superblock 8512ca0c2fbSBob Peterson */ 8522ca0c2fbSBob Peterson static void ail_drain(struct gfs2_sbd *sdp) 8532ca0c2fbSBob Peterson { 8542ca0c2fbSBob Peterson struct gfs2_trans *tr; 8552ca0c2fbSBob Peterson 8562ca0c2fbSBob Peterson spin_lock(&sdp->sd_ail_lock); 8572ca0c2fbSBob Peterson /* 8582ca0c2fbSBob Peterson * For transactions on the sd_ail1_list we need to drain both the 8592ca0c2fbSBob Peterson * ail1 and ail2 lists. That's because function gfs2_ail1_start_one 8602ca0c2fbSBob Peterson * (temporarily) moves items from its tr_ail1 list to tr_ail2 list 8612ca0c2fbSBob Peterson * before revokes are sent for that block. Items on the sd_ail2_list 8622ca0c2fbSBob Peterson * should have already gotten beyond that point, so no need. 8632ca0c2fbSBob Peterson */ 8642ca0c2fbSBob Peterson while (!list_empty(&sdp->sd_ail1_list)) { 8652ca0c2fbSBob Peterson tr = list_first_entry(&sdp->sd_ail1_list, struct gfs2_trans, 8662ca0c2fbSBob Peterson tr_list); 8672ca0c2fbSBob Peterson gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail1_list); 8682ca0c2fbSBob Peterson gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list); 8692ca0c2fbSBob Peterson list_del(&tr->tr_list); 870b839dadaSBob Peterson gfs2_trans_free(sdp, tr); 8712ca0c2fbSBob Peterson } 8722ca0c2fbSBob Peterson while (!list_empty(&sdp->sd_ail2_list)) { 8732ca0c2fbSBob Peterson tr = list_first_entry(&sdp->sd_ail2_list, struct gfs2_trans, 8742ca0c2fbSBob Peterson tr_list); 8752ca0c2fbSBob Peterson gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list); 8762ca0c2fbSBob Peterson list_del(&tr->tr_list); 877b839dadaSBob Peterson gfs2_trans_free(sdp, tr); 8782ca0c2fbSBob Peterson } 8792ca0c2fbSBob Peterson spin_unlock(&sdp->sd_ail_lock); 8802ca0c2fbSBob Peterson } 8812ca0c2fbSBob Peterson 8822ca0c2fbSBob Peterson /** 883d5dc3d96SBob Peterson * empty_ail1_list - try to start IO and empty the ail1 list 884d5dc3d96SBob Peterson * @sdp: Pointer to GFS2 superblock 885d5dc3d96SBob Peterson */ 886d5dc3d96SBob Peterson static void empty_ail1_list(struct gfs2_sbd *sdp) 887d5dc3d96SBob Peterson { 888d5dc3d96SBob Peterson unsigned long start = jiffies; 889d5dc3d96SBob Peterson 890d5dc3d96SBob Peterson for (;;) { 891d5dc3d96SBob Peterson if (time_after(jiffies, start + (HZ * 600))) { 892d5dc3d96SBob Peterson fs_err(sdp, "Error: In %s for 10 minutes! t=%d\n", 893d5dc3d96SBob Peterson __func__, current->journal_info ? 1 : 0); 894d5dc3d96SBob Peterson dump_ail_list(sdp); 895d5dc3d96SBob Peterson return; 896d5dc3d96SBob Peterson } 897d5dc3d96SBob Peterson gfs2_ail1_start(sdp); 898d5dc3d96SBob Peterson gfs2_ail1_wait(sdp); 899d5dc3d96SBob Peterson if (gfs2_ail1_empty(sdp, 0)) 900d5dc3d96SBob Peterson return; 901d5dc3d96SBob Peterson } 902d5dc3d96SBob Peterson } 903d5dc3d96SBob Peterson 904d5dc3d96SBob Peterson /** 905521031faSBob Peterson * trans_drain - drain the buf and databuf queue for a failed transaction 906462582b9SBob Peterson * @tr: the transaction to drain 907462582b9SBob Peterson * 908462582b9SBob Peterson * When this is called, we're taking an error exit for a log write that failed 909462582b9SBob Peterson * but since we bypassed the after_commit functions, we need to remove the 910462582b9SBob Peterson * items from the buf and databuf queue. 911462582b9SBob Peterson */ 912462582b9SBob Peterson static void trans_drain(struct gfs2_trans *tr) 913462582b9SBob Peterson { 914462582b9SBob Peterson struct gfs2_bufdata *bd; 915462582b9SBob Peterson struct list_head *head; 916462582b9SBob Peterson 917462582b9SBob Peterson if (!tr) 918462582b9SBob Peterson return; 919462582b9SBob Peterson 920462582b9SBob Peterson head = &tr->tr_buf; 921462582b9SBob Peterson while (!list_empty(head)) { 922462582b9SBob Peterson bd = list_first_entry(head, struct gfs2_bufdata, bd_list); 923462582b9SBob Peterson list_del_init(&bd->bd_list); 924462582b9SBob Peterson kmem_cache_free(gfs2_bufdata_cachep, bd); 925462582b9SBob Peterson } 926462582b9SBob Peterson head = &tr->tr_databuf; 927462582b9SBob Peterson while (!list_empty(head)) { 928462582b9SBob Peterson bd = list_first_entry(head, struct gfs2_bufdata, bd_list); 929462582b9SBob Peterson list_del_init(&bd->bd_list); 930462582b9SBob Peterson kmem_cache_free(gfs2_bufdata_cachep, bd); 931462582b9SBob Peterson } 932462582b9SBob Peterson } 933462582b9SBob Peterson 934462582b9SBob Peterson /** 935b09e593dSSteven Whitehouse * gfs2_log_flush - flush incore transaction(s) 936b3b94faaSDavid Teigland * @sdp: the filesystem 937b3b94faaSDavid Teigland * @gl: The glock structure to flush. If NULL, flush the whole incore log 938805c0907SBob Peterson * @flags: The log header flags: GFS2_LOG_HEAD_FLUSH_* and debug flags 939b3b94faaSDavid Teigland * 940b3b94faaSDavid Teigland */ 941b3b94faaSDavid Teigland 942c1696fb8SBob Peterson void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl, u32 flags) 943b3b94faaSDavid Teigland { 9442ca0c2fbSBob Peterson struct gfs2_trans *tr = NULL; 9452e60d768SBenjamin Marzinski enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state); 946b3b94faaSDavid Teigland 947484adff8SSteven Whitehouse down_write(&sdp->sd_log_flush_lock); 948f55ab26aSSteven Whitehouse 9492ca0c2fbSBob Peterson /* 9502ca0c2fbSBob Peterson * Do this check while holding the log_flush_lock to prevent new 9512ca0c2fbSBob Peterson * buffers from being added to the ail via gfs2_pin() 9522ca0c2fbSBob Peterson */ 9532ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 9542ca0c2fbSBob Peterson goto out; 9552ca0c2fbSBob Peterson 9562bcd610dSSteven Whitehouse /* Log might have been flushed while we waited for the flush lock */ 9575a61ae14SAndreas Gruenbacher if (gl && !test_bit(GLF_LFLUSH, &gl->gl_flags)) 9585a61ae14SAndreas Gruenbacher goto out; 959805c0907SBob Peterson trace_gfs2_log_flush(sdp, 1, flags); 960f55ab26aSSteven Whitehouse 961c1696fb8SBob Peterson if (flags & GFS2_LOG_HEAD_FLUSH_SHUTDOWN) 962400ac52eSBenjamin Marzinski clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags); 963400ac52eSBenjamin Marzinski 964b1ab1e44SSteven Whitehouse sdp->sd_log_flush_head = sdp->sd_log_head; 96516ca9412SBenjamin Marzinski tr = sdp->sd_log_tr; 96616ca9412SBenjamin Marzinski if (tr) { 96716ca9412SBenjamin Marzinski sdp->sd_log_tr = NULL; 968b1ab1e44SSteven Whitehouse tr->tr_first = sdp->sd_log_flush_head; 9692e60d768SBenjamin Marzinski if (unlikely (state == SFS_FROZEN)) 970ca399c96SBob Peterson if (gfs2_assert_withdraw_delayed(sdp, 971ca399c96SBob Peterson !tr->tr_num_buf_new && !tr->tr_num_databuf_new)) 9725a61ae14SAndreas Gruenbacher goto out_withdraw; 97316ca9412SBenjamin Marzinski } 974b3b94faaSDavid Teigland 9752e60d768SBenjamin Marzinski if (unlikely(state == SFS_FROZEN)) 976ca399c96SBob Peterson if (gfs2_assert_withdraw_delayed(sdp, !sdp->sd_log_num_revoke)) 9775a61ae14SAndreas Gruenbacher goto out_withdraw; 978ca399c96SBob Peterson if (gfs2_assert_withdraw_delayed(sdp, 979ca399c96SBob Peterson sdp->sd_log_num_revoke == sdp->sd_log_committed_revoke)) 9805a61ae14SAndreas Gruenbacher goto out_withdraw; 981b3b94faaSDavid Teigland 982d7b616e2SSteven Whitehouse gfs2_ordered_write(sdp); 9832ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 9845a61ae14SAndreas Gruenbacher goto out_withdraw; 985d69a3c65SSteven Whitehouse lops_before_commit(sdp, tr); 9862ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 9875a61ae14SAndreas Gruenbacher goto out_withdraw; 988f4686c26SAbhi Das gfs2_log_submit_bio(&sdp->sd_log_bio, REQ_OP_WRITE); 9892ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 9905a61ae14SAndreas Gruenbacher goto out_withdraw; 991d7b616e2SSteven Whitehouse 99234cc1781SSteven Whitehouse if (sdp->sd_log_head != sdp->sd_log_flush_head) { 993428fd95dSBob Peterson log_flush_wait(sdp); 994c1696fb8SBob Peterson log_write_header(sdp, flags); 9955cb738b5SAndreas Gruenbacher } else if (sdp->sd_log_tail != sdp->sd_log_flush_tail && !sdp->sd_log_idle) { 996fd041f0bSSteven Whitehouse atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */ 99763997775SSteven Whitehouse trace_gfs2_log_blocks(sdp, -1); 998c1696fb8SBob Peterson log_write_header(sdp, flags); 9992332c443SRobert Peterson } 10002ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 10015a61ae14SAndreas Gruenbacher goto out_withdraw; 100216ca9412SBenjamin Marzinski lops_after_commit(sdp, tr); 1003fe1a698fSSteven Whitehouse 1004fe1a698fSSteven Whitehouse gfs2_log_lock(sdp); 10055cb738b5SAndreas Gruenbacher gfs2_log_update_head(sdp); 1006faa31ce8SSteven Whitehouse sdp->sd_log_blks_reserved = 0; 10075d439758SAndreas Gruenbacher sdp->sd_log_committed_revoke = 0; 1008b3b94faaSDavid Teigland 1009d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 101016ca9412SBenjamin Marzinski if (tr && !list_empty(&tr->tr_ail1_list)) { 101116ca9412SBenjamin Marzinski list_add(&tr->tr_list, &sdp->sd_ail1_list); 101216ca9412SBenjamin Marzinski tr = NULL; 1013b3b94faaSDavid Teigland } 1014d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 1015b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 101624972557SBenjamin Marzinski 1017c1696fb8SBob Peterson if (!(flags & GFS2_LOG_HEAD_FLUSH_NORMAL)) { 101824972557SBenjamin Marzinski if (!sdp->sd_log_idle) { 1019d5dc3d96SBob Peterson empty_ail1_list(sdp); 102030fe70a8SBob Peterson if (gfs2_withdrawn(sdp)) 10215a61ae14SAndreas Gruenbacher goto out_withdraw; 102224972557SBenjamin Marzinski atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */ 102324972557SBenjamin Marzinski trace_gfs2_log_blocks(sdp, -1); 1024c1696fb8SBob Peterson log_write_header(sdp, flags); 10255cb738b5SAndreas Gruenbacher gfs2_log_update_head(sdp); 102624972557SBenjamin Marzinski } 1027c1696fb8SBob Peterson if (flags & (GFS2_LOG_HEAD_FLUSH_SHUTDOWN | 1028c1696fb8SBob Peterson GFS2_LOG_HEAD_FLUSH_FREEZE)) 102924972557SBenjamin Marzinski gfs2_log_shutdown(sdp); 1030c1696fb8SBob Peterson if (flags & GFS2_LOG_HEAD_FLUSH_FREEZE) 10312e60d768SBenjamin Marzinski atomic_set(&sdp->sd_freeze_state, SFS_FROZEN); 103224972557SBenjamin Marzinski } 103324972557SBenjamin Marzinski 10345a61ae14SAndreas Gruenbacher out_end: 10355a61ae14SAndreas Gruenbacher trace_gfs2_log_flush(sdp, 0, flags); 103630fe70a8SBob Peterson out: 10375a61ae14SAndreas Gruenbacher up_write(&sdp->sd_log_flush_lock); 10385a61ae14SAndreas Gruenbacher gfs2_trans_free(sdp, tr); 10395a61ae14SAndreas Gruenbacher if (gfs2_withdrawing(sdp)) 10405a61ae14SAndreas Gruenbacher gfs2_withdraw(sdp); 10415a61ae14SAndreas Gruenbacher return; 10425a61ae14SAndreas Gruenbacher 10435a61ae14SAndreas Gruenbacher out_withdraw: 1044462582b9SBob Peterson trans_drain(tr); 104558e08e8dSBob Peterson /** 104658e08e8dSBob Peterson * If the tr_list is empty, we're withdrawing during a log 104758e08e8dSBob Peterson * flush that targets a transaction, but the transaction was 104858e08e8dSBob Peterson * never queued onto any of the ail lists. Here we add it to 104958e08e8dSBob Peterson * ail1 just so that ail_drain() will find and free it. 105058e08e8dSBob Peterson */ 105158e08e8dSBob Peterson spin_lock(&sdp->sd_ail_lock); 105258e08e8dSBob Peterson if (tr && list_empty(&tr->tr_list)) 105358e08e8dSBob Peterson list_add(&tr->tr_list, &sdp->sd_ail1_list); 105458e08e8dSBob Peterson spin_unlock(&sdp->sd_ail_lock); 10552ca0c2fbSBob Peterson ail_drain(sdp); /* frees all transactions */ 10562ca0c2fbSBob Peterson tr = NULL; 10575a61ae14SAndreas Gruenbacher goto out_end; 1058b3b94faaSDavid Teigland } 1059b3b94faaSDavid Teigland 1060d69a3c65SSteven Whitehouse /** 1061d69a3c65SSteven Whitehouse * gfs2_merge_trans - Merge a new transaction into a cached transaction 1062d69a3c65SSteven Whitehouse * @old: Original transaction to be expanded 1063d69a3c65SSteven Whitehouse * @new: New transaction to be merged 1064d69a3c65SSteven Whitehouse */ 1065d69a3c65SSteven Whitehouse 106683d060caSBob Peterson static void gfs2_merge_trans(struct gfs2_sbd *sdp, struct gfs2_trans *new) 1067d69a3c65SSteven Whitehouse { 106883d060caSBob Peterson struct gfs2_trans *old = sdp->sd_log_tr; 106983d060caSBob Peterson 10709862ca05SBob Peterson WARN_ON_ONCE(!test_bit(TR_ATTACHED, &old->tr_flags)); 1071d69a3c65SSteven Whitehouse 1072d69a3c65SSteven Whitehouse old->tr_num_buf_new += new->tr_num_buf_new; 1073d69a3c65SSteven Whitehouse old->tr_num_databuf_new += new->tr_num_databuf_new; 1074d69a3c65SSteven Whitehouse old->tr_num_buf_rm += new->tr_num_buf_rm; 1075d69a3c65SSteven Whitehouse old->tr_num_databuf_rm += new->tr_num_databuf_rm; 1076d69a3c65SSteven Whitehouse old->tr_num_revoke += new->tr_num_revoke; 1077a31b4ec5SBob Peterson old->tr_num_revoke_rm += new->tr_num_revoke_rm; 1078d69a3c65SSteven Whitehouse 1079d69a3c65SSteven Whitehouse list_splice_tail_init(&new->tr_databuf, &old->tr_databuf); 1080d69a3c65SSteven Whitehouse list_splice_tail_init(&new->tr_buf, &old->tr_buf); 108183d060caSBob Peterson 108283d060caSBob Peterson spin_lock(&sdp->sd_ail_lock); 108383d060caSBob Peterson list_splice_tail_init(&new->tr_ail1_list, &old->tr_ail1_list); 108483d060caSBob Peterson list_splice_tail_init(&new->tr_ail2_list, &old->tr_ail2_list); 108583d060caSBob Peterson spin_unlock(&sdp->sd_ail_lock); 1086d69a3c65SSteven Whitehouse } 1087d69a3c65SSteven Whitehouse 1088b3b94faaSDavid Teigland static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 1089b3b94faaSDavid Teigland { 10902332c443SRobert Peterson unsigned int reserved; 1091ac39aaddSSteven Whitehouse unsigned int unused; 1092022ef4feSSteven Whitehouse unsigned int maxres; 1093b3b94faaSDavid Teigland 1094b3b94faaSDavid Teigland gfs2_log_lock(sdp); 1095b3b94faaSDavid Teigland 1096d69a3c65SSteven Whitehouse if (sdp->sd_log_tr) { 109783d060caSBob Peterson gfs2_merge_trans(sdp, tr); 1098d69a3c65SSteven Whitehouse } else if (tr->tr_num_buf_new || tr->tr_num_databuf_new) { 1099c968f578SAndreas Gruenbacher gfs2_assert_withdraw(sdp, !test_bit(TR_ONSTACK, &tr->tr_flags)); 110016ca9412SBenjamin Marzinski sdp->sd_log_tr = tr; 11019862ca05SBob Peterson set_bit(TR_ATTACHED, &tr->tr_flags); 110216ca9412SBenjamin Marzinski } 1103022ef4feSSteven Whitehouse 1104a31b4ec5SBob Peterson sdp->sd_log_committed_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm; 1105022ef4feSSteven Whitehouse reserved = calc_reserved(sdp); 1106022ef4feSSteven Whitehouse maxres = sdp->sd_log_blks_reserved + tr->tr_reserved; 1107022ef4feSSteven Whitehouse gfs2_assert_withdraw(sdp, maxres >= reserved); 1108022ef4feSSteven Whitehouse unused = maxres - reserved; 11095ae8fff8SAndreas Gruenbacher if (unused) 1110c1eba1b0SAndreas Gruenbacher gfs2_log_release(sdp, unused); 1111022ef4feSSteven Whitehouse sdp->sd_log_blks_reserved = reserved; 1112022ef4feSSteven Whitehouse 1113b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 1114b3b94faaSDavid Teigland } 1115b3b94faaSDavid Teigland 1116b3b94faaSDavid Teigland /** 1117b3b94faaSDavid Teigland * gfs2_log_commit - Commit a transaction to the log 1118b3b94faaSDavid Teigland * @sdp: the filesystem 1119b3b94faaSDavid Teigland * @tr: the transaction 1120b3b94faaSDavid Teigland * 11215e687eacSBenjamin Marzinski * We wake up gfs2_logd if the number of pinned blocks exceed thresh1 11225e687eacSBenjamin Marzinski * or the total number of used blocks (pinned blocks plus AIL blocks) 11235e687eacSBenjamin Marzinski * is greater than thresh2. 11245e687eacSBenjamin Marzinski * 1125b57bc0fbSBob Peterson * At mount time thresh1 is 2/5ths of journal size, thresh2 is 4/5ths of 11265e687eacSBenjamin Marzinski * journal size. 11275e687eacSBenjamin Marzinski * 1128b3b94faaSDavid Teigland * Returns: errno 1129b3b94faaSDavid Teigland */ 1130b3b94faaSDavid Teigland 1131b3b94faaSDavid Teigland void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 1132b3b94faaSDavid Teigland { 1133b3b94faaSDavid Teigland log_refund(sdp, tr); 1134b3b94faaSDavid Teigland 11355e687eacSBenjamin Marzinski if (atomic_read(&sdp->sd_log_pinned) > atomic_read(&sdp->sd_log_thresh1) || 11365e687eacSBenjamin Marzinski ((sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free)) > 11375e687eacSBenjamin Marzinski atomic_read(&sdp->sd_log_thresh2))) 11385e687eacSBenjamin Marzinski wake_up(&sdp->sd_logd_waitq); 1139faa31ce8SSteven Whitehouse } 1140b3b94faaSDavid Teigland 1141b3b94faaSDavid Teigland /** 1142b3b94faaSDavid Teigland * gfs2_log_shutdown - write a shutdown header into a journal 1143b3b94faaSDavid Teigland * @sdp: the filesystem 1144b3b94faaSDavid Teigland * 1145b3b94faaSDavid Teigland */ 1146b3b94faaSDavid Teigland 1147feed98a8SBob Peterson static void gfs2_log_shutdown(struct gfs2_sbd *sdp) 1148b3b94faaSDavid Teigland { 1149b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved); 1150b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke); 1151b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list)); 1152b3b94faaSDavid Teigland 1153b3b94faaSDavid Teigland sdp->sd_log_flush_head = sdp->sd_log_head; 1154b3b94faaSDavid Teigland 1155805c0907SBob Peterson log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT | GFS2_LFC_SHUTDOWN); 1156b3b94faaSDavid Teigland 1157a74604beSSteven Whitehouse gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail); 1158a74604beSSteven Whitehouse gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list)); 1159b3b94faaSDavid Teigland 11605cb738b5SAndreas Gruenbacher gfs2_log_update_head(sdp); 1161b3b94faaSDavid Teigland sdp->sd_log_tail = sdp->sd_log_head; 1162a25311c8SSteven Whitehouse } 1163a25311c8SSteven Whitehouse 11645e687eacSBenjamin Marzinski static inline int gfs2_jrnl_flush_reqd(struct gfs2_sbd *sdp) 11655e687eacSBenjamin Marzinski { 1166f07b3520SBob Peterson return (atomic_read(&sdp->sd_log_pinned) + 1167f07b3520SBob Peterson atomic_read(&sdp->sd_log_blks_needed) >= 1168f07b3520SBob Peterson atomic_read(&sdp->sd_log_thresh1)); 11695e687eacSBenjamin Marzinski } 11705e687eacSBenjamin Marzinski 11715e687eacSBenjamin Marzinski static inline int gfs2_ail_flush_reqd(struct gfs2_sbd *sdp) 11725e687eacSBenjamin Marzinski { 11735e687eacSBenjamin Marzinski unsigned int used_blocks = sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free); 1174b066a4eeSAbhi Das 1175b066a4eeSAbhi Das if (test_and_clear_bit(SDF_FORCE_AIL_FLUSH, &sdp->sd_flags)) 1176b066a4eeSAbhi Das return 1; 1177b066a4eeSAbhi Das 1178f07b3520SBob Peterson return used_blocks + atomic_read(&sdp->sd_log_blks_needed) >= 1179f07b3520SBob Peterson atomic_read(&sdp->sd_log_thresh2); 11805e687eacSBenjamin Marzinski } 1181ec69b188SSteven Whitehouse 1182ec69b188SSteven Whitehouse /** 1183ec69b188SSteven Whitehouse * gfs2_logd - Update log tail as Active Items get flushed to in-place blocks 1184ec69b188SSteven Whitehouse * @sdp: Pointer to GFS2 superblock 1185ec69b188SSteven Whitehouse * 1186ec69b188SSteven Whitehouse * Also, periodically check to make sure that we're using the most recent 1187ec69b188SSteven Whitehouse * journal index. 1188ec69b188SSteven Whitehouse */ 1189ec69b188SSteven Whitehouse 1190ec69b188SSteven Whitehouse int gfs2_logd(void *data) 1191ec69b188SSteven Whitehouse { 1192ec69b188SSteven Whitehouse struct gfs2_sbd *sdp = data; 11935e687eacSBenjamin Marzinski unsigned long t = 1; 11945e687eacSBenjamin Marzinski DEFINE_WAIT(wait); 1195ec69b188SSteven Whitehouse 1196ec69b188SSteven Whitehouse while (!kthread_should_stop()) { 1197ec69b188SSteven Whitehouse 1198d22f69a0SBob Peterson if (gfs2_withdrawn(sdp)) { 1199d22f69a0SBob Peterson msleep_interruptible(HZ); 1200d22f69a0SBob Peterson continue; 1201d22f69a0SBob Peterson } 1202942b0cddSBob Peterson /* Check for errors writing to the journal */ 1203942b0cddSBob Peterson if (sdp->sd_log_error) { 1204badb55ecSAndreas Gruenbacher gfs2_lm(sdp, 1205942b0cddSBob Peterson "GFS2: fsid=%s: error %d: " 1206942b0cddSBob Peterson "withdrawing the file system to " 1207942b0cddSBob Peterson "prevent further damage.\n", 1208942b0cddSBob Peterson sdp->sd_fsname, sdp->sd_log_error); 1209badb55ecSAndreas Gruenbacher gfs2_withdraw(sdp); 1210d22f69a0SBob Peterson continue; 1211942b0cddSBob Peterson } 1212942b0cddSBob Peterson 12135e687eacSBenjamin Marzinski if (gfs2_jrnl_flush_reqd(sdp) || t == 0) { 12145e4c7632SBob Peterson gfs2_ail1_empty(sdp, 0); 1215805c0907SBob Peterson gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL | 1216805c0907SBob Peterson GFS2_LFC_LOGD_JFLUSH_REQD); 1217ec69b188SSteven Whitehouse } 1218ec69b188SSteven Whitehouse 12195e687eacSBenjamin Marzinski if (gfs2_ail_flush_reqd(sdp)) { 12205e687eacSBenjamin Marzinski gfs2_ail1_start(sdp); 122126b06a69SSteven Whitehouse gfs2_ail1_wait(sdp); 12225e4c7632SBob Peterson gfs2_ail1_empty(sdp, 0); 1223805c0907SBob Peterson gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL | 1224805c0907SBob Peterson GFS2_LFC_LOGD_AIL_FLUSH_REQD); 12255e687eacSBenjamin Marzinski } 12265e687eacSBenjamin Marzinski 1227ec69b188SSteven Whitehouse t = gfs2_tune_get(sdp, gt_logd_secs) * HZ; 1228a0acae0eSTejun Heo 1229a0acae0eSTejun Heo try_to_freeze(); 12305e687eacSBenjamin Marzinski 12315e687eacSBenjamin Marzinski do { 12325e687eacSBenjamin Marzinski prepare_to_wait(&sdp->sd_logd_waitq, &wait, 12335f487490SSteven Whitehouse TASK_INTERRUPTIBLE); 12345e687eacSBenjamin Marzinski if (!gfs2_ail_flush_reqd(sdp) && 12355e687eacSBenjamin Marzinski !gfs2_jrnl_flush_reqd(sdp) && 12365e687eacSBenjamin Marzinski !kthread_should_stop()) 12375e687eacSBenjamin Marzinski t = schedule_timeout(t); 12385e687eacSBenjamin Marzinski } while(t && !gfs2_ail_flush_reqd(sdp) && 12395e687eacSBenjamin Marzinski !gfs2_jrnl_flush_reqd(sdp) && 12405e687eacSBenjamin Marzinski !kthread_should_stop()); 12415e687eacSBenjamin Marzinski finish_wait(&sdp->sd_logd_waitq, &wait); 1242ec69b188SSteven Whitehouse } 1243ec69b188SSteven Whitehouse 1244ec69b188SSteven Whitehouse return 0; 1245ec69b188SSteven Whitehouse } 1246ec69b188SSteven Whitehouse 1247