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 /** 450*fe3e3976SAndreas Gruenbacher * __gfs2_log_try_reserve - Try to make a log reservation 451b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 452b3b94faaSDavid Teigland * @blks: The number of blocks to reserve 453*fe3e3976SAndreas Gruenbacher * @taboo_blks: The number of blocks to leave free 454b3b94faaSDavid Teigland * 455*fe3e3976SAndreas Gruenbacher * Try to do the same as __gfs2_log_reserve(), but fail if no more log 456*fe3e3976SAndreas Gruenbacher * space is immediately available. 457*fe3e3976SAndreas Gruenbacher */ 458*fe3e3976SAndreas Gruenbacher static bool __gfs2_log_try_reserve(struct gfs2_sbd *sdp, unsigned int blks, 459*fe3e3976SAndreas Gruenbacher unsigned int taboo_blks) 460*fe3e3976SAndreas Gruenbacher { 461*fe3e3976SAndreas Gruenbacher unsigned wanted = blks + taboo_blks; 462*fe3e3976SAndreas Gruenbacher unsigned int free_blocks; 463*fe3e3976SAndreas Gruenbacher 464*fe3e3976SAndreas Gruenbacher free_blocks = atomic_read(&sdp->sd_log_blks_free); 465*fe3e3976SAndreas Gruenbacher while (free_blocks >= wanted) { 466*fe3e3976SAndreas Gruenbacher if (atomic_try_cmpxchg(&sdp->sd_log_blks_free, &free_blocks, 467*fe3e3976SAndreas Gruenbacher free_blocks - blks)) { 468*fe3e3976SAndreas Gruenbacher trace_gfs2_log_blocks(sdp, -blks); 469*fe3e3976SAndreas Gruenbacher return true; 470*fe3e3976SAndreas Gruenbacher } 471*fe3e3976SAndreas Gruenbacher } 472*fe3e3976SAndreas Gruenbacher return false; 473*fe3e3976SAndreas Gruenbacher } 474*fe3e3976SAndreas Gruenbacher 475*fe3e3976SAndreas Gruenbacher /** 476*fe3e3976SAndreas Gruenbacher * __gfs2_log_reserve - Make a log reservation 477*fe3e3976SAndreas Gruenbacher * @sdp: The GFS2 superblock 478*fe3e3976SAndreas Gruenbacher * @blks: The number of blocks to reserve 479*fe3e3976SAndreas Gruenbacher * @taboo_blks: The number of blocks to leave free 480*fe3e3976SAndreas Gruenbacher * 481*fe3e3976SAndreas Gruenbacher * @taboo_blks is set to 0 for logd, and to GFS2_LOG_FLUSH_MIN_BLOCKS 482*fe3e3976SAndreas Gruenbacher * for all other processes. This ensures that when the log is almost full, 483*fe3e3976SAndreas Gruenbacher * logd will still be able to call gfs2_log_flush one more time without 484*fe3e3976SAndreas Gruenbacher * blocking, which will advance the tail and make some more log space 485*fe3e3976SAndreas Gruenbacher * available. 486b004157aSSteven Whitehouse * 4875e687eacSBenjamin Marzinski * We no longer flush the log here, instead we wake up logd to do that 4885e687eacSBenjamin Marzinski * for us. To avoid the thundering herd and to ensure that we deal fairly 4895e687eacSBenjamin Marzinski * with queued waiters, we use an exclusive wait. This means that when we 4905e687eacSBenjamin Marzinski * get woken with enough journal space to get our reservation, we need to 4915e687eacSBenjamin Marzinski * wake the next waiter on the list. 492b3b94faaSDavid Teigland */ 493b3b94faaSDavid Teigland 494*fe3e3976SAndreas Gruenbacher static void __gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks, 495*fe3e3976SAndreas Gruenbacher unsigned int taboo_blks) 496b3b94faaSDavid Teigland { 497*fe3e3976SAndreas Gruenbacher unsigned wanted = blks + taboo_blks; 4985e687eacSBenjamin Marzinski unsigned int free_blocks; 499b3b94faaSDavid Teigland 5005ae8fff8SAndreas Gruenbacher atomic_add(blks, &sdp->sd_log_blks_needed); 5015ae8fff8SAndreas Gruenbacher for (;;) { 5025ae8fff8SAndreas Gruenbacher if (current != sdp->sd_logd_process) 5035ae8fff8SAndreas Gruenbacher wake_up(&sdp->sd_logd_waitq); 5045ae8fff8SAndreas Gruenbacher io_wait_event(sdp->sd_log_waitq, 5055ae8fff8SAndreas Gruenbacher (free_blocks = atomic_read(&sdp->sd_log_blks_free), 5065ae8fff8SAndreas Gruenbacher free_blocks >= wanted)); 5075ae8fff8SAndreas Gruenbacher do { 5085ae8fff8SAndreas Gruenbacher if (atomic_try_cmpxchg(&sdp->sd_log_blks_free, 5095ae8fff8SAndreas Gruenbacher &free_blocks, 5105ae8fff8SAndreas Gruenbacher free_blocks - blks)) 5115ae8fff8SAndreas Gruenbacher goto reserved; 5125ae8fff8SAndreas Gruenbacher } while (free_blocks >= wanted); 5135ae8fff8SAndreas Gruenbacher } 5145ae8fff8SAndreas Gruenbacher 5155ae8fff8SAndreas Gruenbacher reserved: 5165ae8fff8SAndreas Gruenbacher trace_gfs2_log_blocks(sdp, -blks); 5175ae8fff8SAndreas Gruenbacher if (atomic_sub_return(blks, &sdp->sd_log_blks_needed)) 5185e687eacSBenjamin Marzinski wake_up(&sdp->sd_log_waitq); 519b3b94faaSDavid Teigland } 520b3b94faaSDavid Teigland 521b3b94faaSDavid Teigland /** 522*fe3e3976SAndreas Gruenbacher * gfs2_log_reserve - Make a log reservation 523*fe3e3976SAndreas Gruenbacher * @sdp: The GFS2 superblock 524*fe3e3976SAndreas Gruenbacher * @blks: The number of blocks to reserve 525*fe3e3976SAndreas Gruenbacher */ 526*fe3e3976SAndreas Gruenbacher 527*fe3e3976SAndreas Gruenbacher void gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks) 528*fe3e3976SAndreas Gruenbacher { 529*fe3e3976SAndreas Gruenbacher if (__gfs2_log_try_reserve(sdp, blks, GFS2_LOG_FLUSH_MIN_BLOCKS)) 530*fe3e3976SAndreas Gruenbacher return; 531*fe3e3976SAndreas Gruenbacher __gfs2_log_reserve(sdp, blks, GFS2_LOG_FLUSH_MIN_BLOCKS); 532*fe3e3976SAndreas Gruenbacher } 533*fe3e3976SAndreas Gruenbacher 534*fe3e3976SAndreas Gruenbacher /** 535b3b94faaSDavid Teigland * log_distance - Compute distance between two journal blocks 536b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 537b3b94faaSDavid Teigland * @newer: The most recent journal block of the pair 538b3b94faaSDavid Teigland * @older: The older journal block of the pair 539b3b94faaSDavid Teigland * 540b3b94faaSDavid Teigland * Compute the distance (in the journal direction) between two 541b3b94faaSDavid Teigland * blocks in the journal 542b3b94faaSDavid Teigland * 543b3b94faaSDavid Teigland * Returns: the distance in blocks 544b3b94faaSDavid Teigland */ 545b3b94faaSDavid Teigland 546faa31ce8SSteven Whitehouse static inline unsigned int log_distance(struct gfs2_sbd *sdp, unsigned int newer, 547b3b94faaSDavid Teigland unsigned int older) 548b3b94faaSDavid Teigland { 549b3b94faaSDavid Teigland int dist; 550b3b94faaSDavid Teigland 551b3b94faaSDavid Teigland dist = newer - older; 552b3b94faaSDavid Teigland if (dist < 0) 553b3b94faaSDavid Teigland dist += sdp->sd_jdesc->jd_blocks; 554b3b94faaSDavid Teigland 555b3b94faaSDavid Teigland return dist; 556b3b94faaSDavid Teigland } 557b3b94faaSDavid Teigland 5582332c443SRobert Peterson /** 5596188e877SAndreas Gruenbacher * calc_reserved - Calculate the number of blocks to keep reserved 5602332c443SRobert Peterson * @sdp: The GFS2 superblock 5612332c443SRobert Peterson * 5622332c443SRobert Peterson * This is complex. We need to reserve room for all our currently used 5636188e877SAndreas Gruenbacher * metadata blocks (e.g. normal file I/O rewriting file time stamps) and 5646188e877SAndreas Gruenbacher * all our journaled data blocks for journaled files (e.g. files in the 5652332c443SRobert Peterson * meta_fs like rindex, or files for which chattr +j was done.) 5666188e877SAndreas Gruenbacher * If we don't reserve enough space, corruption will follow. 5672332c443SRobert Peterson * 5686188e877SAndreas Gruenbacher * We can have metadata blocks and jdata blocks in the same journal. Each 5696188e877SAndreas Gruenbacher * type gets its own log descriptor, for which we need to reserve a block. 5706188e877SAndreas Gruenbacher * In fact, each type has the potential for needing more than one log descriptor 5716188e877SAndreas Gruenbacher * in cases where we have more blocks than will fit in a log descriptor. 5722332c443SRobert Peterson * Metadata journal entries take up half the space of journaled buffer entries. 5732332c443SRobert Peterson * 5742332c443SRobert Peterson * Also, we need to reserve blocks for revoke journal entries and one for an 5752332c443SRobert Peterson * overall header for the lot. 5762332c443SRobert Peterson * 5772332c443SRobert Peterson * Returns: the number of blocks reserved 5782332c443SRobert Peterson */ 5792332c443SRobert Peterson static unsigned int calc_reserved(struct gfs2_sbd *sdp) 5802332c443SRobert Peterson { 581*fe3e3976SAndreas Gruenbacher unsigned int reserved = GFS2_LOG_FLUSH_MIN_BLOCKS; 58271b219f4SAndreas Gruenbacher unsigned int blocks; 583022ef4feSSteven Whitehouse struct gfs2_trans *tr = sdp->sd_log_tr; 5842332c443SRobert Peterson 585022ef4feSSteven Whitehouse if (tr) { 58671b219f4SAndreas Gruenbacher blocks = tr->tr_num_buf_new - tr->tr_num_buf_rm; 58771b219f4SAndreas Gruenbacher reserved += blocks + DIV_ROUND_UP(blocks, buf_limit(sdp)); 58871b219f4SAndreas Gruenbacher blocks = tr->tr_num_databuf_new - tr->tr_num_databuf_rm; 58971b219f4SAndreas Gruenbacher reserved += blocks + DIV_ROUND_UP(blocks, databuf_limit(sdp)); 590022ef4feSSteven Whitehouse } 5912332c443SRobert Peterson 5925d439758SAndreas Gruenbacher if (sdp->sd_log_committed_revoke > 0) 593*fe3e3976SAndreas Gruenbacher reserved += gfs2_struct2blk(sdp, sdp->sd_log_committed_revoke) - 1; 5942332c443SRobert Peterson return reserved; 5952332c443SRobert Peterson } 5962332c443SRobert Peterson 5975cb738b5SAndreas Gruenbacher static void log_pull_tail(struct gfs2_sbd *sdp) 598b3b94faaSDavid Teigland { 5995cb738b5SAndreas Gruenbacher unsigned int new_tail = sdp->sd_log_flush_tail; 6005cb738b5SAndreas Gruenbacher unsigned int dist; 601b3b94faaSDavid Teigland 6025cb738b5SAndreas Gruenbacher if (new_tail == sdp->sd_log_tail) 6035cb738b5SAndreas Gruenbacher return; 6045cb738b5SAndreas Gruenbacher dist = log_distance(sdp, new_tail, sdp->sd_log_tail); 605b3b94faaSDavid Teigland ail2_empty(sdp, new_tail); 606c1eba1b0SAndreas Gruenbacher gfs2_log_release(sdp, dist); 607b3b94faaSDavid Teigland sdp->sd_log_tail = new_tail; 608b3b94faaSDavid Teigland } 609b3b94faaSDavid Teigland 610b3b94faaSDavid Teigland 6119ff78289SBob Peterson void log_flush_wait(struct gfs2_sbd *sdp) 612b3b94faaSDavid Teigland { 61316615be1SSteven Whitehouse DEFINE_WAIT(wait); 614b3b94faaSDavid Teigland 61516615be1SSteven Whitehouse if (atomic_read(&sdp->sd_log_in_flight)) { 61616615be1SSteven Whitehouse do { 61716615be1SSteven Whitehouse prepare_to_wait(&sdp->sd_log_flush_wait, &wait, 61816615be1SSteven Whitehouse TASK_UNINTERRUPTIBLE); 61916615be1SSteven Whitehouse if (atomic_read(&sdp->sd_log_in_flight)) 62016615be1SSteven Whitehouse io_schedule(); 62116615be1SSteven Whitehouse } while(atomic_read(&sdp->sd_log_in_flight)); 62216615be1SSteven Whitehouse finish_wait(&sdp->sd_log_flush_wait, &wait); 623b3b94faaSDavid Teigland } 624b3b94faaSDavid Teigland } 625b3b94faaSDavid Teigland 62645138990SSteven Whitehouse static int ip_cmp(void *priv, struct list_head *a, struct list_head *b) 6274a36d08dSBob Peterson { 62845138990SSteven Whitehouse struct gfs2_inode *ipa, *ipb; 6294a36d08dSBob Peterson 63045138990SSteven Whitehouse ipa = list_entry(a, struct gfs2_inode, i_ordered); 63145138990SSteven Whitehouse ipb = list_entry(b, struct gfs2_inode, i_ordered); 6324a36d08dSBob Peterson 63345138990SSteven Whitehouse if (ipa->i_no_addr < ipb->i_no_addr) 6344a36d08dSBob Peterson return -1; 63545138990SSteven Whitehouse if (ipa->i_no_addr > ipb->i_no_addr) 6364a36d08dSBob Peterson return 1; 6374a36d08dSBob Peterson return 0; 6384a36d08dSBob Peterson } 6394a36d08dSBob Peterson 6407542486bSBob Peterson static void __ordered_del_inode(struct gfs2_inode *ip) 6417542486bSBob Peterson { 6427542486bSBob Peterson if (!list_empty(&ip->i_ordered)) 6437542486bSBob Peterson list_del_init(&ip->i_ordered); 6447542486bSBob Peterson } 6457542486bSBob Peterson 646d7b616e2SSteven Whitehouse static void gfs2_ordered_write(struct gfs2_sbd *sdp) 647d7b616e2SSteven Whitehouse { 64845138990SSteven Whitehouse struct gfs2_inode *ip; 649d7b616e2SSteven Whitehouse LIST_HEAD(written); 650d7b616e2SSteven Whitehouse 65145138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 652a5b1d3fcSAndreas Gruenbacher list_sort(NULL, &sdp->sd_log_ordered, &ip_cmp); 653a5b1d3fcSAndreas Gruenbacher while (!list_empty(&sdp->sd_log_ordered)) { 654969183bcSAndreas Gruenbacher ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered); 6551f23bc78SAbhi Das if (ip->i_inode.i_mapping->nrpages == 0) { 6567542486bSBob Peterson __ordered_del_inode(ip); 657d7b616e2SSteven Whitehouse continue; 6581f23bc78SAbhi Das } 6591f23bc78SAbhi Das list_move(&ip->i_ordered, &written); 66045138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 66145138990SSteven Whitehouse filemap_fdatawrite(ip->i_inode.i_mapping); 66245138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 663d7b616e2SSteven Whitehouse } 664a5b1d3fcSAndreas Gruenbacher list_splice(&written, &sdp->sd_log_ordered); 66545138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 666d7b616e2SSteven Whitehouse } 667d7b616e2SSteven Whitehouse 668d7b616e2SSteven Whitehouse static void gfs2_ordered_wait(struct gfs2_sbd *sdp) 669d7b616e2SSteven Whitehouse { 67045138990SSteven Whitehouse struct gfs2_inode *ip; 671d7b616e2SSteven Whitehouse 67245138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 673a5b1d3fcSAndreas Gruenbacher while (!list_empty(&sdp->sd_log_ordered)) { 674969183bcSAndreas Gruenbacher ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered); 6757542486bSBob Peterson __ordered_del_inode(ip); 67645138990SSteven Whitehouse if (ip->i_inode.i_mapping->nrpages == 0) 677d7b616e2SSteven Whitehouse continue; 67845138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 67945138990SSteven Whitehouse filemap_fdatawait(ip->i_inode.i_mapping); 68045138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 681d7b616e2SSteven Whitehouse } 68245138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 683d7b616e2SSteven Whitehouse } 68445138990SSteven Whitehouse 68545138990SSteven Whitehouse void gfs2_ordered_del_inode(struct gfs2_inode *ip) 68645138990SSteven Whitehouse { 68745138990SSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 68845138990SSteven Whitehouse 68945138990SSteven Whitehouse spin_lock(&sdp->sd_ordered_lock); 6907542486bSBob Peterson __ordered_del_inode(ip); 69145138990SSteven Whitehouse spin_unlock(&sdp->sd_ordered_lock); 692d7b616e2SSteven Whitehouse } 693d7b616e2SSteven Whitehouse 6945d054964SBenjamin Marzinski void gfs2_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd) 6955d054964SBenjamin Marzinski { 6965d054964SBenjamin Marzinski struct buffer_head *bh = bd->bd_bh; 6975d054964SBenjamin Marzinski struct gfs2_glock *gl = bd->bd_gl; 6985d054964SBenjamin Marzinski 699f4e2f5e1SAndreas Gruenbacher sdp->sd_log_num_revoke++; 700f4e2f5e1SAndreas Gruenbacher if (atomic_inc_return(&gl->gl_revokes) == 1) 701f4e2f5e1SAndreas Gruenbacher gfs2_glock_hold(gl); 7025d054964SBenjamin Marzinski bh->b_private = NULL; 7035d054964SBenjamin Marzinski bd->bd_blkno = bh->b_blocknr; 7049290a9a7SBob Peterson gfs2_remove_from_ail(bd); /* drops ref on bh */ 7059290a9a7SBob Peterson bd->bd_bh = NULL; 7065d054964SBenjamin Marzinski set_bit(GLF_LFLUSH, &gl->gl_flags); 707a5b1d3fcSAndreas Gruenbacher list_add(&bd->bd_list, &sdp->sd_log_revokes); 7085d054964SBenjamin Marzinski } 7095d054964SBenjamin Marzinski 710fe5e7ba1SBob Peterson void gfs2_glock_remove_revoke(struct gfs2_glock *gl) 711fe5e7ba1SBob Peterson { 712fe5e7ba1SBob Peterson if (atomic_dec_return(&gl->gl_revokes) == 0) { 713fe5e7ba1SBob Peterson clear_bit(GLF_LFLUSH, &gl->gl_flags); 714fe5e7ba1SBob Peterson gfs2_glock_queue_put(gl); 715fe5e7ba1SBob Peterson } 716fe5e7ba1SBob Peterson } 717fe5e7ba1SBob Peterson 7185e4c7632SBob Peterson /** 719e7501bf8SAndreas Gruenbacher * gfs2_flush_revokes - Add as many revokes to the system transaction as we can 7205e4c7632SBob Peterson * @sdp: The GFS2 superblock 7215e4c7632SBob Peterson * 7225e4c7632SBob Peterson * Our usual strategy is to defer writing revokes as much as we can in the hope 7235e4c7632SBob Peterson * that we'll eventually overwrite the journal, which will make those revokes 7245e4c7632SBob Peterson * go away. This changes when we flush the log: at that point, there will 7255e4c7632SBob Peterson * likely be some left-over space in the last revoke block of that transaction. 7265e4c7632SBob Peterson * We can fill that space with additional revokes for blocks that have already 7275e4c7632SBob Peterson * been written back. This will basically come at no cost now, and will save 7285e4c7632SBob Peterson * us from having to keep track of those blocks on the AIL2 list later. 7295e4c7632SBob Peterson */ 730e7501bf8SAndreas Gruenbacher void gfs2_flush_revokes(struct gfs2_sbd *sdp) 7315d054964SBenjamin Marzinski { 7325e4c7632SBob Peterson /* number of revokes we still have room for */ 7335a4e9c60SAndreas Gruenbacher unsigned int max_revokes; 7345d054964SBenjamin Marzinski 7355e4c7632SBob Peterson gfs2_log_lock(sdp); 7365a4e9c60SAndreas Gruenbacher max_revokes = sdp->sd_ldptrs; 7375a4e9c60SAndreas Gruenbacher if (sdp->sd_log_num_revoke > sdp->sd_ldptrs) 7385a4e9c60SAndreas Gruenbacher max_revokes += roundup(sdp->sd_log_num_revoke - sdp->sd_ldptrs, 7395a4e9c60SAndreas Gruenbacher sdp->sd_inptrs); 7405d054964SBenjamin Marzinski max_revokes -= sdp->sd_log_num_revoke; 7415e4c7632SBob Peterson gfs2_ail1_empty(sdp, max_revokes); 7425d054964SBenjamin Marzinski gfs2_log_unlock(sdp); 7435d054964SBenjamin Marzinski } 7445d054964SBenjamin Marzinski 745b3b94faaSDavid Teigland /** 7467c70b896SBob Peterson * gfs2_write_log_header - Write a journal log header buffer at lblock 747588bff95SBob Peterson * @sdp: The GFS2 superblock 748c1696fb8SBob Peterson * @jd: journal descriptor of the journal to which we are writing 749588bff95SBob Peterson * @seq: sequence number 750588bff95SBob Peterson * @tail: tail of the log 7517c70b896SBob Peterson * @lblock: value for lh_blkno (block number relative to start of journal) 752c1696fb8SBob Peterson * @flags: log header flags GFS2_LOG_HEAD_* 753588bff95SBob Peterson * @op_flags: flags to pass to the bio 754588bff95SBob Peterson * 755588bff95SBob Peterson * Returns: the initialized log buffer descriptor 756588bff95SBob Peterson */ 757588bff95SBob Peterson 758c1696fb8SBob Peterson void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd, 7597c70b896SBob Peterson u64 seq, u32 tail, u32 lblock, u32 flags, 7607c70b896SBob Peterson int op_flags) 761588bff95SBob Peterson { 762588bff95SBob Peterson struct gfs2_log_header *lh; 763c1696fb8SBob Peterson u32 hash, crc; 764ade48088SBob Peterson struct page *page; 765c1696fb8SBob Peterson struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 766c1696fb8SBob Peterson struct timespec64 tv; 767c1696fb8SBob Peterson struct super_block *sb = sdp->sd_vfs; 7687c70b896SBob Peterson u64 dblock; 769588bff95SBob Peterson 770ade48088SBob Peterson if (gfs2_withdrawn(sdp)) 7714a3d049dSAndreas Gruenbacher return; 772ade48088SBob Peterson 773ade48088SBob Peterson page = mempool_alloc(gfs2_page_pool, GFP_NOIO); 774588bff95SBob Peterson lh = page_address(page); 775588bff95SBob Peterson clear_page(lh); 776588bff95SBob Peterson 777588bff95SBob Peterson lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 778588bff95SBob Peterson lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH); 779588bff95SBob Peterson lh->lh_header.__pad0 = cpu_to_be64(0); 780588bff95SBob Peterson lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH); 781588bff95SBob Peterson lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid); 782588bff95SBob Peterson lh->lh_sequence = cpu_to_be64(seq); 783588bff95SBob Peterson lh->lh_flags = cpu_to_be32(flags); 784588bff95SBob Peterson lh->lh_tail = cpu_to_be32(tail); 7857c70b896SBob Peterson lh->lh_blkno = cpu_to_be32(lblock); 786c1696fb8SBob Peterson hash = ~crc32(~0, lh, LH_V1_SIZE); 787588bff95SBob Peterson lh->lh_hash = cpu_to_be32(hash); 788588bff95SBob Peterson 789ee9c7f9aSArnd Bergmann ktime_get_coarse_real_ts64(&tv); 790c1696fb8SBob Peterson lh->lh_nsec = cpu_to_be32(tv.tv_nsec); 791c1696fb8SBob Peterson lh->lh_sec = cpu_to_be64(tv.tv_sec); 7927c70b896SBob Peterson if (!list_empty(&jd->extent_list)) 79319ebc050SAndreas Gruenbacher dblock = gfs2_log_bmap(jd, lblock); 7947c70b896SBob Peterson else { 7957c70b896SBob Peterson int ret = gfs2_lblk_to_dblk(jd->jd_inode, lblock, &dblock); 7967c70b896SBob Peterson if (gfs2_assert_withdraw(sdp, ret == 0)) 7977c70b896SBob Peterson return; 7987c70b896SBob Peterson } 7997c70b896SBob Peterson lh->lh_addr = cpu_to_be64(dblock); 800c1696fb8SBob Peterson lh->lh_jinode = cpu_to_be64(GFS2_I(jd->jd_inode)->i_no_addr); 801c1696fb8SBob Peterson 802c1696fb8SBob Peterson /* We may only write local statfs, quota, etc., when writing to our 803c1696fb8SBob Peterson own journal. The values are left 0 when recovering a journal 804c1696fb8SBob Peterson different from our own. */ 805c1696fb8SBob Peterson if (!(flags & GFS2_LOG_HEAD_RECOVERY)) { 806c1696fb8SBob Peterson lh->lh_statfs_addr = 807c1696fb8SBob Peterson cpu_to_be64(GFS2_I(sdp->sd_sc_inode)->i_no_addr); 808c1696fb8SBob Peterson lh->lh_quota_addr = 809c1696fb8SBob Peterson cpu_to_be64(GFS2_I(sdp->sd_qc_inode)->i_no_addr); 810c1696fb8SBob Peterson 811c1696fb8SBob Peterson spin_lock(&sdp->sd_statfs_spin); 812c1696fb8SBob Peterson lh->lh_local_total = cpu_to_be64(l_sc->sc_total); 813c1696fb8SBob Peterson lh->lh_local_free = cpu_to_be64(l_sc->sc_free); 814c1696fb8SBob Peterson lh->lh_local_dinodes = cpu_to_be64(l_sc->sc_dinodes); 815c1696fb8SBob Peterson spin_unlock(&sdp->sd_statfs_spin); 816c1696fb8SBob Peterson } 817c1696fb8SBob Peterson 818c1696fb8SBob Peterson BUILD_BUG_ON(offsetof(struct gfs2_log_header, lh_crc) != LH_V1_SIZE); 819c1696fb8SBob Peterson 820c1696fb8SBob Peterson crc = crc32c(~0, (void *)lh + LH_V1_SIZE + 4, 821c1696fb8SBob Peterson sb->s_blocksize - LH_V1_SIZE - 4); 822c1696fb8SBob Peterson lh->lh_crc = cpu_to_be32(crc); 823c1696fb8SBob Peterson 8247c70b896SBob Peterson gfs2_log_write(sdp, page, sb->s_blocksize, 0, dblock); 825f4686c26SAbhi Das gfs2_log_submit_bio(&sdp->sd_log_bio, REQ_OP_WRITE | op_flags); 826588bff95SBob Peterson } 827588bff95SBob Peterson 828588bff95SBob Peterson /** 82934cc1781SSteven Whitehouse * log_write_header - Get and initialize a journal header buffer 83034cc1781SSteven Whitehouse * @sdp: The GFS2 superblock 831c1696fb8SBob Peterson * @flags: The log header flags, including log header origin 83234cc1781SSteven Whitehouse * 83334cc1781SSteven Whitehouse * Returns: the initialized log buffer descriptor 83434cc1781SSteven Whitehouse */ 83534cc1781SSteven Whitehouse 836fdb76a42SSteven Whitehouse static void log_write_header(struct gfs2_sbd *sdp, u32 flags) 83734cc1781SSteven Whitehouse { 8380f0b9b63SJan Kara int op_flags = REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC; 8392e60d768SBenjamin Marzinski enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state); 84034cc1781SSteven Whitehouse 8412e60d768SBenjamin Marzinski gfs2_assert_withdraw(sdp, (state != SFS_FROZEN)); 84234cc1781SSteven Whitehouse 84334cc1781SSteven Whitehouse if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags)) { 84434cc1781SSteven Whitehouse gfs2_ordered_wait(sdp); 84534cc1781SSteven Whitehouse log_flush_wait(sdp); 84670fd7614SChristoph Hellwig op_flags = REQ_SYNC | REQ_META | REQ_PRIO; 84734cc1781SSteven Whitehouse } 8485cb738b5SAndreas Gruenbacher sdp->sd_log_idle = (sdp->sd_log_flush_tail == sdp->sd_log_flush_head); 8495cb738b5SAndreas Gruenbacher gfs2_write_log_header(sdp, sdp->sd_jdesc, sdp->sd_log_sequence++, 8505cb738b5SAndreas Gruenbacher sdp->sd_log_flush_tail, sdp->sd_log_flush_head, 8515cb738b5SAndreas Gruenbacher flags, op_flags); 85219ebc050SAndreas Gruenbacher gfs2_log_incr_head(sdp); 8534a3d049dSAndreas Gruenbacher log_flush_wait(sdp); 8545cb738b5SAndreas Gruenbacher log_pull_tail(sdp); 855*fe3e3976SAndreas Gruenbacher gfs2_log_update_head(sdp); 85634cc1781SSteven Whitehouse } 85734cc1781SSteven Whitehouse 85834cc1781SSteven Whitehouse /** 8592ca0c2fbSBob Peterson * ail_drain - drain the ail lists after a withdraw 8602ca0c2fbSBob Peterson * @sdp: Pointer to GFS2 superblock 8612ca0c2fbSBob Peterson */ 8622ca0c2fbSBob Peterson static void ail_drain(struct gfs2_sbd *sdp) 8632ca0c2fbSBob Peterson { 8642ca0c2fbSBob Peterson struct gfs2_trans *tr; 8652ca0c2fbSBob Peterson 8662ca0c2fbSBob Peterson spin_lock(&sdp->sd_ail_lock); 8672ca0c2fbSBob Peterson /* 8682ca0c2fbSBob Peterson * For transactions on the sd_ail1_list we need to drain both the 8692ca0c2fbSBob Peterson * ail1 and ail2 lists. That's because function gfs2_ail1_start_one 8702ca0c2fbSBob Peterson * (temporarily) moves items from its tr_ail1 list to tr_ail2 list 8712ca0c2fbSBob Peterson * before revokes are sent for that block. Items on the sd_ail2_list 8722ca0c2fbSBob Peterson * should have already gotten beyond that point, so no need. 8732ca0c2fbSBob Peterson */ 8742ca0c2fbSBob Peterson while (!list_empty(&sdp->sd_ail1_list)) { 8752ca0c2fbSBob Peterson tr = list_first_entry(&sdp->sd_ail1_list, struct gfs2_trans, 8762ca0c2fbSBob Peterson tr_list); 8772ca0c2fbSBob Peterson gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail1_list); 8782ca0c2fbSBob Peterson gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list); 8792ca0c2fbSBob Peterson list_del(&tr->tr_list); 880b839dadaSBob Peterson gfs2_trans_free(sdp, tr); 8812ca0c2fbSBob Peterson } 8822ca0c2fbSBob Peterson while (!list_empty(&sdp->sd_ail2_list)) { 8832ca0c2fbSBob Peterson tr = list_first_entry(&sdp->sd_ail2_list, struct gfs2_trans, 8842ca0c2fbSBob Peterson tr_list); 8852ca0c2fbSBob Peterson gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list); 8862ca0c2fbSBob Peterson list_del(&tr->tr_list); 887b839dadaSBob Peterson gfs2_trans_free(sdp, tr); 8882ca0c2fbSBob Peterson } 8892ca0c2fbSBob Peterson spin_unlock(&sdp->sd_ail_lock); 8902ca0c2fbSBob Peterson } 8912ca0c2fbSBob Peterson 8922ca0c2fbSBob Peterson /** 893d5dc3d96SBob Peterson * empty_ail1_list - try to start IO and empty the ail1 list 894d5dc3d96SBob Peterson * @sdp: Pointer to GFS2 superblock 895d5dc3d96SBob Peterson */ 896d5dc3d96SBob Peterson static void empty_ail1_list(struct gfs2_sbd *sdp) 897d5dc3d96SBob Peterson { 898d5dc3d96SBob Peterson unsigned long start = jiffies; 899d5dc3d96SBob Peterson 900d5dc3d96SBob Peterson for (;;) { 901d5dc3d96SBob Peterson if (time_after(jiffies, start + (HZ * 600))) { 902d5dc3d96SBob Peterson fs_err(sdp, "Error: In %s for 10 minutes! t=%d\n", 903d5dc3d96SBob Peterson __func__, current->journal_info ? 1 : 0); 904d5dc3d96SBob Peterson dump_ail_list(sdp); 905d5dc3d96SBob Peterson return; 906d5dc3d96SBob Peterson } 907d5dc3d96SBob Peterson gfs2_ail1_start(sdp); 908d5dc3d96SBob Peterson gfs2_ail1_wait(sdp); 909d5dc3d96SBob Peterson if (gfs2_ail1_empty(sdp, 0)) 910d5dc3d96SBob Peterson return; 911d5dc3d96SBob Peterson } 912d5dc3d96SBob Peterson } 913d5dc3d96SBob Peterson 914d5dc3d96SBob Peterson /** 915521031faSBob Peterson * trans_drain - drain the buf and databuf queue for a failed transaction 916462582b9SBob Peterson * @tr: the transaction to drain 917462582b9SBob Peterson * 918462582b9SBob Peterson * When this is called, we're taking an error exit for a log write that failed 919462582b9SBob Peterson * but since we bypassed the after_commit functions, we need to remove the 920462582b9SBob Peterson * items from the buf and databuf queue. 921462582b9SBob Peterson */ 922462582b9SBob Peterson static void trans_drain(struct gfs2_trans *tr) 923462582b9SBob Peterson { 924462582b9SBob Peterson struct gfs2_bufdata *bd; 925462582b9SBob Peterson struct list_head *head; 926462582b9SBob Peterson 927462582b9SBob Peterson if (!tr) 928462582b9SBob Peterson return; 929462582b9SBob Peterson 930462582b9SBob Peterson head = &tr->tr_buf; 931462582b9SBob Peterson while (!list_empty(head)) { 932462582b9SBob Peterson bd = list_first_entry(head, struct gfs2_bufdata, bd_list); 933462582b9SBob Peterson list_del_init(&bd->bd_list); 934462582b9SBob Peterson kmem_cache_free(gfs2_bufdata_cachep, bd); 935462582b9SBob Peterson } 936462582b9SBob Peterson head = &tr->tr_databuf; 937462582b9SBob Peterson while (!list_empty(head)) { 938462582b9SBob Peterson bd = list_first_entry(head, struct gfs2_bufdata, bd_list); 939462582b9SBob Peterson list_del_init(&bd->bd_list); 940462582b9SBob Peterson kmem_cache_free(gfs2_bufdata_cachep, bd); 941462582b9SBob Peterson } 942462582b9SBob Peterson } 943462582b9SBob Peterson 944462582b9SBob Peterson /** 945b09e593dSSteven Whitehouse * gfs2_log_flush - flush incore transaction(s) 946b3b94faaSDavid Teigland * @sdp: the filesystem 947b3b94faaSDavid Teigland * @gl: The glock structure to flush. If NULL, flush the whole incore log 948805c0907SBob Peterson * @flags: The log header flags: GFS2_LOG_HEAD_FLUSH_* and debug flags 949b3b94faaSDavid Teigland * 950b3b94faaSDavid Teigland */ 951b3b94faaSDavid Teigland 952c1696fb8SBob Peterson void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl, u32 flags) 953b3b94faaSDavid Teigland { 9542ca0c2fbSBob Peterson struct gfs2_trans *tr = NULL; 955*fe3e3976SAndreas Gruenbacher unsigned int reserved_blocks = 0, used_blocks = 0; 9562e60d768SBenjamin Marzinski enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state); 957*fe3e3976SAndreas Gruenbacher unsigned int first_log_head; 958b3b94faaSDavid Teigland 959484adff8SSteven Whitehouse down_write(&sdp->sd_log_flush_lock); 960*fe3e3976SAndreas Gruenbacher trace_gfs2_log_flush(sdp, 1, flags); 961f55ab26aSSteven Whitehouse 962*fe3e3976SAndreas Gruenbacher repeat: 9632ca0c2fbSBob Peterson /* 9642ca0c2fbSBob Peterson * Do this check while holding the log_flush_lock to prevent new 9652ca0c2fbSBob Peterson * buffers from being added to the ail via gfs2_pin() 9662ca0c2fbSBob Peterson */ 9672ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 9682ca0c2fbSBob Peterson goto out; 9692ca0c2fbSBob Peterson 9702bcd610dSSteven Whitehouse /* Log might have been flushed while we waited for the flush lock */ 9715a61ae14SAndreas Gruenbacher if (gl && !test_bit(GLF_LFLUSH, &gl->gl_flags)) 9725a61ae14SAndreas Gruenbacher goto out; 973f55ab26aSSteven Whitehouse 974*fe3e3976SAndreas Gruenbacher first_log_head = sdp->sd_log_head; 975*fe3e3976SAndreas Gruenbacher sdp->sd_log_flush_head = first_log_head; 976400ac52eSBenjamin Marzinski 97716ca9412SBenjamin Marzinski tr = sdp->sd_log_tr; 978*fe3e3976SAndreas Gruenbacher if (tr || sdp->sd_log_num_revoke) { 979*fe3e3976SAndreas Gruenbacher if (reserved_blocks) 980*fe3e3976SAndreas Gruenbacher gfs2_log_release(sdp, reserved_blocks); 981*fe3e3976SAndreas Gruenbacher reserved_blocks = sdp->sd_log_blks_reserved; 98216ca9412SBenjamin Marzinski if (tr) { 98316ca9412SBenjamin Marzinski sdp->sd_log_tr = NULL; 984*fe3e3976SAndreas Gruenbacher tr->tr_first = first_log_head; 9852e60d768SBenjamin Marzinski if (unlikely (state == SFS_FROZEN)) 986ca399c96SBob Peterson if (gfs2_assert_withdraw_delayed(sdp, 987ca399c96SBob Peterson !tr->tr_num_buf_new && !tr->tr_num_databuf_new)) 9885a61ae14SAndreas Gruenbacher goto out_withdraw; 98916ca9412SBenjamin Marzinski } 990*fe3e3976SAndreas Gruenbacher } else if (!reserved_blocks) { 991*fe3e3976SAndreas Gruenbacher unsigned int taboo_blocks = GFS2_LOG_FLUSH_MIN_BLOCKS; 992*fe3e3976SAndreas Gruenbacher 993*fe3e3976SAndreas Gruenbacher reserved_blocks = GFS2_LOG_FLUSH_MIN_BLOCKS; 994*fe3e3976SAndreas Gruenbacher if (current == sdp->sd_logd_process) 995*fe3e3976SAndreas Gruenbacher taboo_blocks = 0; 996*fe3e3976SAndreas Gruenbacher 997*fe3e3976SAndreas Gruenbacher if (!__gfs2_log_try_reserve(sdp, reserved_blocks, taboo_blocks)) { 998*fe3e3976SAndreas Gruenbacher up_write(&sdp->sd_log_flush_lock); 999*fe3e3976SAndreas Gruenbacher __gfs2_log_reserve(sdp, reserved_blocks, taboo_blocks); 1000*fe3e3976SAndreas Gruenbacher down_write(&sdp->sd_log_flush_lock); 1001*fe3e3976SAndreas Gruenbacher goto repeat; 1002*fe3e3976SAndreas Gruenbacher } 1003*fe3e3976SAndreas Gruenbacher } 1004*fe3e3976SAndreas Gruenbacher 1005*fe3e3976SAndreas Gruenbacher if (flags & GFS2_LOG_HEAD_FLUSH_SHUTDOWN) 1006*fe3e3976SAndreas Gruenbacher clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags); 1007b3b94faaSDavid Teigland 10082e60d768SBenjamin Marzinski if (unlikely(state == SFS_FROZEN)) 1009ca399c96SBob Peterson if (gfs2_assert_withdraw_delayed(sdp, !sdp->sd_log_num_revoke)) 10105a61ae14SAndreas Gruenbacher goto out_withdraw; 1011ca399c96SBob Peterson if (gfs2_assert_withdraw_delayed(sdp, 1012ca399c96SBob Peterson sdp->sd_log_num_revoke == sdp->sd_log_committed_revoke)) 10135a61ae14SAndreas Gruenbacher goto out_withdraw; 1014b3b94faaSDavid Teigland 1015d7b616e2SSteven Whitehouse gfs2_ordered_write(sdp); 10162ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 10175a61ae14SAndreas Gruenbacher goto out_withdraw; 1018d69a3c65SSteven Whitehouse lops_before_commit(sdp, tr); 10192ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 10205a61ae14SAndreas Gruenbacher goto out_withdraw; 1021f4686c26SAbhi Das gfs2_log_submit_bio(&sdp->sd_log_bio, REQ_OP_WRITE); 10222ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 10235a61ae14SAndreas Gruenbacher goto out_withdraw; 1024d7b616e2SSteven Whitehouse 102534cc1781SSteven Whitehouse if (sdp->sd_log_head != sdp->sd_log_flush_head) { 1026428fd95dSBob Peterson log_flush_wait(sdp); 1027c1696fb8SBob Peterson log_write_header(sdp, flags); 10285cb738b5SAndreas Gruenbacher } else if (sdp->sd_log_tail != sdp->sd_log_flush_tail && !sdp->sd_log_idle) { 1029c1696fb8SBob Peterson log_write_header(sdp, flags); 10302332c443SRobert Peterson } 10312ca0c2fbSBob Peterson if (gfs2_withdrawn(sdp)) 10325a61ae14SAndreas Gruenbacher goto out_withdraw; 103316ca9412SBenjamin Marzinski lops_after_commit(sdp, tr); 1034fe1a698fSSteven Whitehouse 1035fe1a698fSSteven Whitehouse gfs2_log_lock(sdp); 1036faa31ce8SSteven Whitehouse sdp->sd_log_blks_reserved = 0; 10375d439758SAndreas Gruenbacher sdp->sd_log_committed_revoke = 0; 1038b3b94faaSDavid Teigland 1039d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 104016ca9412SBenjamin Marzinski if (tr && !list_empty(&tr->tr_ail1_list)) { 104116ca9412SBenjamin Marzinski list_add(&tr->tr_list, &sdp->sd_ail1_list); 104216ca9412SBenjamin Marzinski tr = NULL; 1043b3b94faaSDavid Teigland } 1044d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 1045b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 104624972557SBenjamin Marzinski 1047c1696fb8SBob Peterson if (!(flags & GFS2_LOG_HEAD_FLUSH_NORMAL)) { 104824972557SBenjamin Marzinski if (!sdp->sd_log_idle) { 1049d5dc3d96SBob Peterson empty_ail1_list(sdp); 105030fe70a8SBob Peterson if (gfs2_withdrawn(sdp)) 10515a61ae14SAndreas Gruenbacher goto out_withdraw; 1052c1696fb8SBob Peterson log_write_header(sdp, flags); 105324972557SBenjamin Marzinski } 1054c1696fb8SBob Peterson if (flags & (GFS2_LOG_HEAD_FLUSH_SHUTDOWN | 1055c1696fb8SBob Peterson GFS2_LOG_HEAD_FLUSH_FREEZE)) 105624972557SBenjamin Marzinski gfs2_log_shutdown(sdp); 1057c1696fb8SBob Peterson if (flags & GFS2_LOG_HEAD_FLUSH_FREEZE) 10582e60d768SBenjamin Marzinski atomic_set(&sdp->sd_freeze_state, SFS_FROZEN); 105924972557SBenjamin Marzinski } 106024972557SBenjamin Marzinski 10615a61ae14SAndreas Gruenbacher out_end: 1062*fe3e3976SAndreas Gruenbacher used_blocks = log_distance(sdp, sdp->sd_log_flush_head, first_log_head); 1063*fe3e3976SAndreas Gruenbacher if (gfs2_assert_withdraw_delayed(sdp, used_blocks <= reserved_blocks)) 1064*fe3e3976SAndreas Gruenbacher goto out; 106530fe70a8SBob Peterson out: 1066*fe3e3976SAndreas Gruenbacher if (used_blocks != reserved_blocks) 1067*fe3e3976SAndreas Gruenbacher gfs2_log_release(sdp, reserved_blocks - used_blocks); 10685a61ae14SAndreas Gruenbacher up_write(&sdp->sd_log_flush_lock); 10695a61ae14SAndreas Gruenbacher gfs2_trans_free(sdp, tr); 10705a61ae14SAndreas Gruenbacher if (gfs2_withdrawing(sdp)) 10715a61ae14SAndreas Gruenbacher gfs2_withdraw(sdp); 1072*fe3e3976SAndreas Gruenbacher trace_gfs2_log_flush(sdp, 0, flags); 10735a61ae14SAndreas Gruenbacher return; 10745a61ae14SAndreas Gruenbacher 10755a61ae14SAndreas Gruenbacher out_withdraw: 1076462582b9SBob Peterson trans_drain(tr); 107758e08e8dSBob Peterson /** 107858e08e8dSBob Peterson * If the tr_list is empty, we're withdrawing during a log 107958e08e8dSBob Peterson * flush that targets a transaction, but the transaction was 108058e08e8dSBob Peterson * never queued onto any of the ail lists. Here we add it to 108158e08e8dSBob Peterson * ail1 just so that ail_drain() will find and free it. 108258e08e8dSBob Peterson */ 108358e08e8dSBob Peterson spin_lock(&sdp->sd_ail_lock); 108458e08e8dSBob Peterson if (tr && list_empty(&tr->tr_list)) 108558e08e8dSBob Peterson list_add(&tr->tr_list, &sdp->sd_ail1_list); 108658e08e8dSBob Peterson spin_unlock(&sdp->sd_ail_lock); 10872ca0c2fbSBob Peterson ail_drain(sdp); /* frees all transactions */ 10882ca0c2fbSBob Peterson tr = NULL; 10895a61ae14SAndreas Gruenbacher goto out_end; 1090b3b94faaSDavid Teigland } 1091b3b94faaSDavid Teigland 1092d69a3c65SSteven Whitehouse /** 1093d69a3c65SSteven Whitehouse * gfs2_merge_trans - Merge a new transaction into a cached transaction 1094d69a3c65SSteven Whitehouse * @old: Original transaction to be expanded 1095d69a3c65SSteven Whitehouse * @new: New transaction to be merged 1096d69a3c65SSteven Whitehouse */ 1097d69a3c65SSteven Whitehouse 109883d060caSBob Peterson static void gfs2_merge_trans(struct gfs2_sbd *sdp, struct gfs2_trans *new) 1099d69a3c65SSteven Whitehouse { 110083d060caSBob Peterson struct gfs2_trans *old = sdp->sd_log_tr; 110183d060caSBob Peterson 11029862ca05SBob Peterson WARN_ON_ONCE(!test_bit(TR_ATTACHED, &old->tr_flags)); 1103d69a3c65SSteven Whitehouse 1104d69a3c65SSteven Whitehouse old->tr_num_buf_new += new->tr_num_buf_new; 1105d69a3c65SSteven Whitehouse old->tr_num_databuf_new += new->tr_num_databuf_new; 1106d69a3c65SSteven Whitehouse old->tr_num_buf_rm += new->tr_num_buf_rm; 1107d69a3c65SSteven Whitehouse old->tr_num_databuf_rm += new->tr_num_databuf_rm; 1108d69a3c65SSteven Whitehouse old->tr_num_revoke += new->tr_num_revoke; 1109a31b4ec5SBob Peterson old->tr_num_revoke_rm += new->tr_num_revoke_rm; 1110d69a3c65SSteven Whitehouse 1111d69a3c65SSteven Whitehouse list_splice_tail_init(&new->tr_databuf, &old->tr_databuf); 1112d69a3c65SSteven Whitehouse list_splice_tail_init(&new->tr_buf, &old->tr_buf); 111383d060caSBob Peterson 111483d060caSBob Peterson spin_lock(&sdp->sd_ail_lock); 111583d060caSBob Peterson list_splice_tail_init(&new->tr_ail1_list, &old->tr_ail1_list); 111683d060caSBob Peterson list_splice_tail_init(&new->tr_ail2_list, &old->tr_ail2_list); 111783d060caSBob Peterson spin_unlock(&sdp->sd_ail_lock); 1118d69a3c65SSteven Whitehouse } 1119d69a3c65SSteven Whitehouse 1120b3b94faaSDavid Teigland static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 1121b3b94faaSDavid Teigland { 11222332c443SRobert Peterson unsigned int reserved; 1123ac39aaddSSteven Whitehouse unsigned int unused; 1124022ef4feSSteven Whitehouse unsigned int maxres; 1125b3b94faaSDavid Teigland 1126b3b94faaSDavid Teigland gfs2_log_lock(sdp); 1127b3b94faaSDavid Teigland 1128d69a3c65SSteven Whitehouse if (sdp->sd_log_tr) { 112983d060caSBob Peterson gfs2_merge_trans(sdp, tr); 1130d69a3c65SSteven Whitehouse } else if (tr->tr_num_buf_new || tr->tr_num_databuf_new) { 1131c968f578SAndreas Gruenbacher gfs2_assert_withdraw(sdp, !test_bit(TR_ONSTACK, &tr->tr_flags)); 113216ca9412SBenjamin Marzinski sdp->sd_log_tr = tr; 11339862ca05SBob Peterson set_bit(TR_ATTACHED, &tr->tr_flags); 113416ca9412SBenjamin Marzinski } 1135022ef4feSSteven Whitehouse 1136a31b4ec5SBob Peterson sdp->sd_log_committed_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm; 1137022ef4feSSteven Whitehouse reserved = calc_reserved(sdp); 1138022ef4feSSteven Whitehouse maxres = sdp->sd_log_blks_reserved + tr->tr_reserved; 1139022ef4feSSteven Whitehouse gfs2_assert_withdraw(sdp, maxres >= reserved); 1140022ef4feSSteven Whitehouse unused = maxres - reserved; 11415ae8fff8SAndreas Gruenbacher if (unused) 1142c1eba1b0SAndreas Gruenbacher gfs2_log_release(sdp, unused); 1143022ef4feSSteven Whitehouse sdp->sd_log_blks_reserved = reserved; 1144022ef4feSSteven Whitehouse 1145b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 1146b3b94faaSDavid Teigland } 1147b3b94faaSDavid Teigland 1148b3b94faaSDavid Teigland /** 1149b3b94faaSDavid Teigland * gfs2_log_commit - Commit a transaction to the log 1150b3b94faaSDavid Teigland * @sdp: the filesystem 1151b3b94faaSDavid Teigland * @tr: the transaction 1152b3b94faaSDavid Teigland * 11535e687eacSBenjamin Marzinski * We wake up gfs2_logd if the number of pinned blocks exceed thresh1 11545e687eacSBenjamin Marzinski * or the total number of used blocks (pinned blocks plus AIL blocks) 11555e687eacSBenjamin Marzinski * is greater than thresh2. 11565e687eacSBenjamin Marzinski * 1157b57bc0fbSBob Peterson * At mount time thresh1 is 2/5ths of journal size, thresh2 is 4/5ths of 11585e687eacSBenjamin Marzinski * journal size. 11595e687eacSBenjamin Marzinski * 1160b3b94faaSDavid Teigland * Returns: errno 1161b3b94faaSDavid Teigland */ 1162b3b94faaSDavid Teigland 1163b3b94faaSDavid Teigland void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 1164b3b94faaSDavid Teigland { 1165b3b94faaSDavid Teigland log_refund(sdp, tr); 1166b3b94faaSDavid Teigland 11675e687eacSBenjamin Marzinski if (atomic_read(&sdp->sd_log_pinned) > atomic_read(&sdp->sd_log_thresh1) || 11685e687eacSBenjamin Marzinski ((sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free)) > 11695e687eacSBenjamin Marzinski atomic_read(&sdp->sd_log_thresh2))) 11705e687eacSBenjamin Marzinski wake_up(&sdp->sd_logd_waitq); 1171faa31ce8SSteven Whitehouse } 1172b3b94faaSDavid Teigland 1173b3b94faaSDavid Teigland /** 1174b3b94faaSDavid Teigland * gfs2_log_shutdown - write a shutdown header into a journal 1175b3b94faaSDavid Teigland * @sdp: the filesystem 1176b3b94faaSDavid Teigland * 1177b3b94faaSDavid Teigland */ 1178b3b94faaSDavid Teigland 1179feed98a8SBob Peterson static void gfs2_log_shutdown(struct gfs2_sbd *sdp) 1180b3b94faaSDavid Teigland { 1181b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved); 1182b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke); 1183b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list)); 1184b3b94faaSDavid Teigland 1185805c0907SBob Peterson log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT | GFS2_LFC_SHUTDOWN); 1186*fe3e3976SAndreas Gruenbacher log_pull_tail(sdp); 1187b3b94faaSDavid Teigland 1188a74604beSSteven Whitehouse gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail); 1189a74604beSSteven Whitehouse gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list)); 1190a25311c8SSteven Whitehouse } 1191a25311c8SSteven Whitehouse 11925e687eacSBenjamin Marzinski static inline int gfs2_jrnl_flush_reqd(struct gfs2_sbd *sdp) 11935e687eacSBenjamin Marzinski { 1194f07b3520SBob Peterson return (atomic_read(&sdp->sd_log_pinned) + 1195f07b3520SBob Peterson atomic_read(&sdp->sd_log_blks_needed) >= 1196f07b3520SBob Peterson atomic_read(&sdp->sd_log_thresh1)); 11975e687eacSBenjamin Marzinski } 11985e687eacSBenjamin Marzinski 11995e687eacSBenjamin Marzinski static inline int gfs2_ail_flush_reqd(struct gfs2_sbd *sdp) 12005e687eacSBenjamin Marzinski { 12015e687eacSBenjamin Marzinski unsigned int used_blocks = sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free); 1202b066a4eeSAbhi Das 1203b066a4eeSAbhi Das if (test_and_clear_bit(SDF_FORCE_AIL_FLUSH, &sdp->sd_flags)) 1204b066a4eeSAbhi Das return 1; 1205b066a4eeSAbhi Das 1206f07b3520SBob Peterson return used_blocks + atomic_read(&sdp->sd_log_blks_needed) >= 1207f07b3520SBob Peterson atomic_read(&sdp->sd_log_thresh2); 12085e687eacSBenjamin Marzinski } 1209ec69b188SSteven Whitehouse 1210ec69b188SSteven Whitehouse /** 1211ec69b188SSteven Whitehouse * gfs2_logd - Update log tail as Active Items get flushed to in-place blocks 1212ec69b188SSteven Whitehouse * @sdp: Pointer to GFS2 superblock 1213ec69b188SSteven Whitehouse * 1214ec69b188SSteven Whitehouse * Also, periodically check to make sure that we're using the most recent 1215ec69b188SSteven Whitehouse * journal index. 1216ec69b188SSteven Whitehouse */ 1217ec69b188SSteven Whitehouse 1218ec69b188SSteven Whitehouse int gfs2_logd(void *data) 1219ec69b188SSteven Whitehouse { 1220ec69b188SSteven Whitehouse struct gfs2_sbd *sdp = data; 12215e687eacSBenjamin Marzinski unsigned long t = 1; 12225e687eacSBenjamin Marzinski DEFINE_WAIT(wait); 1223ec69b188SSteven Whitehouse 1224ec69b188SSteven Whitehouse while (!kthread_should_stop()) { 1225ec69b188SSteven Whitehouse 1226d22f69a0SBob Peterson if (gfs2_withdrawn(sdp)) { 1227d22f69a0SBob Peterson msleep_interruptible(HZ); 1228d22f69a0SBob Peterson continue; 1229d22f69a0SBob Peterson } 1230942b0cddSBob Peterson /* Check for errors writing to the journal */ 1231942b0cddSBob Peterson if (sdp->sd_log_error) { 1232badb55ecSAndreas Gruenbacher gfs2_lm(sdp, 1233942b0cddSBob Peterson "GFS2: fsid=%s: error %d: " 1234942b0cddSBob Peterson "withdrawing the file system to " 1235942b0cddSBob Peterson "prevent further damage.\n", 1236942b0cddSBob Peterson sdp->sd_fsname, sdp->sd_log_error); 1237badb55ecSAndreas Gruenbacher gfs2_withdraw(sdp); 1238d22f69a0SBob Peterson continue; 1239942b0cddSBob Peterson } 1240942b0cddSBob Peterson 12415e687eacSBenjamin Marzinski if (gfs2_jrnl_flush_reqd(sdp) || t == 0) { 12425e4c7632SBob Peterson gfs2_ail1_empty(sdp, 0); 1243805c0907SBob Peterson gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL | 1244805c0907SBob Peterson GFS2_LFC_LOGD_JFLUSH_REQD); 1245ec69b188SSteven Whitehouse } 1246ec69b188SSteven Whitehouse 12475e687eacSBenjamin Marzinski if (gfs2_ail_flush_reqd(sdp)) { 12485e687eacSBenjamin Marzinski gfs2_ail1_start(sdp); 124926b06a69SSteven Whitehouse gfs2_ail1_wait(sdp); 12505e4c7632SBob Peterson gfs2_ail1_empty(sdp, 0); 1251805c0907SBob Peterson gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL | 1252805c0907SBob Peterson GFS2_LFC_LOGD_AIL_FLUSH_REQD); 12535e687eacSBenjamin Marzinski } 12545e687eacSBenjamin Marzinski 1255ec69b188SSteven Whitehouse t = gfs2_tune_get(sdp, gt_logd_secs) * HZ; 1256a0acae0eSTejun Heo 1257a0acae0eSTejun Heo try_to_freeze(); 12585e687eacSBenjamin Marzinski 12595e687eacSBenjamin Marzinski do { 12605e687eacSBenjamin Marzinski prepare_to_wait(&sdp->sd_logd_waitq, &wait, 12615f487490SSteven Whitehouse TASK_INTERRUPTIBLE); 12625e687eacSBenjamin Marzinski if (!gfs2_ail_flush_reqd(sdp) && 12635e687eacSBenjamin Marzinski !gfs2_jrnl_flush_reqd(sdp) && 12645e687eacSBenjamin Marzinski !kthread_should_stop()) 12655e687eacSBenjamin Marzinski t = schedule_timeout(t); 12665e687eacSBenjamin Marzinski } while(t && !gfs2_ail_flush_reqd(sdp) && 12675e687eacSBenjamin Marzinski !gfs2_jrnl_flush_reqd(sdp) && 12685e687eacSBenjamin Marzinski !kthread_should_stop()); 12695e687eacSBenjamin Marzinski finish_wait(&sdp->sd_logd_waitq, &wait); 1270ec69b188SSteven Whitehouse } 1271ec69b188SSteven Whitehouse 1272ec69b188SSteven Whitehouse return 0; 1273ec69b188SSteven Whitehouse } 1274ec69b188SSteven Whitehouse 1275