1b3b94faaSDavid Teigland /* 2b3b94faaSDavid Teigland * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 3da6dd40dSBob Peterson * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved. 4b3b94faaSDavid Teigland * 5b3b94faaSDavid Teigland * This copyrighted material is made available to anyone wishing to use, 6b3b94faaSDavid Teigland * modify, copy, or redistribute it subject to the terms and conditions 7e9fc2aa0SSteven Whitehouse * of the GNU General Public License version 2. 8b3b94faaSDavid Teigland */ 9b3b94faaSDavid Teigland 10b3b94faaSDavid Teigland #include <linux/sched.h> 11b3b94faaSDavid Teigland #include <linux/slab.h> 12b3b94faaSDavid Teigland #include <linux/spinlock.h> 13b3b94faaSDavid Teigland #include <linux/completion.h> 14b3b94faaSDavid Teigland #include <linux/buffer_head.h> 155c676f6dSSteven Whitehouse #include <linux/gfs2_ondisk.h> 1671b86f56SSteven Whitehouse #include <linux/crc32.h> 17a25311c8SSteven Whitehouse #include <linux/delay.h> 18ec69b188SSteven Whitehouse #include <linux/kthread.h> 19ec69b188SSteven Whitehouse #include <linux/freezer.h> 20254db57fSSteven Whitehouse #include <linux/bio.h> 214667a0ecSSteven Whitehouse #include <linux/writeback.h> 224a36d08dSBob Peterson #include <linux/list_sort.h> 23b3b94faaSDavid Teigland 24b3b94faaSDavid Teigland #include "gfs2.h" 255c676f6dSSteven Whitehouse #include "incore.h" 26b3b94faaSDavid Teigland #include "bmap.h" 27b3b94faaSDavid Teigland #include "glock.h" 28b3b94faaSDavid Teigland #include "log.h" 29b3b94faaSDavid Teigland #include "lops.h" 30b3b94faaSDavid Teigland #include "meta_io.h" 315c676f6dSSteven Whitehouse #include "util.h" 3271b86f56SSteven Whitehouse #include "dir.h" 3363997775SSteven Whitehouse #include "trace_gfs2.h" 34b3b94faaSDavid Teigland 35b3b94faaSDavid Teigland #define PULL 1 36b3b94faaSDavid Teigland 37b3b94faaSDavid Teigland /** 38b3b94faaSDavid Teigland * gfs2_struct2blk - compute stuff 39b3b94faaSDavid Teigland * @sdp: the filesystem 40b3b94faaSDavid Teigland * @nstruct: the number of structures 41b3b94faaSDavid Teigland * @ssize: the size of the structures 42b3b94faaSDavid Teigland * 43b3b94faaSDavid Teigland * Compute the number of log descriptor blocks needed to hold a certain number 44b3b94faaSDavid Teigland * of structures of a certain size. 45b3b94faaSDavid Teigland * 46b3b94faaSDavid Teigland * Returns: the number of blocks needed (minimum is always 1) 47b3b94faaSDavid Teigland */ 48b3b94faaSDavid Teigland 49b3b94faaSDavid Teigland unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct, 50b3b94faaSDavid Teigland unsigned int ssize) 51b3b94faaSDavid Teigland { 52b3b94faaSDavid Teigland unsigned int blks; 53b3b94faaSDavid Teigland unsigned int first, second; 54b3b94faaSDavid Teigland 55b3b94faaSDavid Teigland blks = 1; 56faa31ce8SSteven Whitehouse first = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_log_descriptor)) / ssize; 57b3b94faaSDavid Teigland 58b3b94faaSDavid Teigland if (nstruct > first) { 59568f4c96SSteven Whitehouse second = (sdp->sd_sb.sb_bsize - 60568f4c96SSteven Whitehouse sizeof(struct gfs2_meta_header)) / ssize; 615c676f6dSSteven Whitehouse blks += DIV_ROUND_UP(nstruct - first, second); 62b3b94faaSDavid Teigland } 63b3b94faaSDavid Teigland 64b3b94faaSDavid Teigland return blks; 65b3b94faaSDavid Teigland } 66b3b94faaSDavid Teigland 67ddacfaf7SSteven Whitehouse /** 681e1a3d03SSteven Whitehouse * gfs2_remove_from_ail - Remove an entry from the ail lists, updating counters 691e1a3d03SSteven Whitehouse * @mapping: The associated mapping (maybe NULL) 701e1a3d03SSteven Whitehouse * @bd: The gfs2_bufdata to remove 711e1a3d03SSteven Whitehouse * 72c618e87aSSteven Whitehouse * The ail lock _must_ be held when calling this function 731e1a3d03SSteven Whitehouse * 741e1a3d03SSteven Whitehouse */ 751e1a3d03SSteven Whitehouse 76f91a0d3eSSteven Whitehouse void gfs2_remove_from_ail(struct gfs2_bufdata *bd) 771e1a3d03SSteven Whitehouse { 781e1a3d03SSteven Whitehouse bd->bd_ail = NULL; 791ad38c43SSteven Whitehouse list_del_init(&bd->bd_ail_st_list); 801ad38c43SSteven Whitehouse list_del_init(&bd->bd_ail_gl_list); 811e1a3d03SSteven Whitehouse atomic_dec(&bd->bd_gl->gl_ail_count); 821e1a3d03SSteven Whitehouse brelse(bd->bd_bh); 831e1a3d03SSteven Whitehouse } 841e1a3d03SSteven Whitehouse 851e1a3d03SSteven Whitehouse /** 86ddacfaf7SSteven Whitehouse * gfs2_ail1_start_one - Start I/O on a part of the AIL 87ddacfaf7SSteven Whitehouse * @sdp: the filesystem 884667a0ecSSteven Whitehouse * @wbc: The writeback control structure 894667a0ecSSteven Whitehouse * @ai: The ail structure 90ddacfaf7SSteven Whitehouse * 91ddacfaf7SSteven Whitehouse */ 92ddacfaf7SSteven Whitehouse 934f1de018SSteven Whitehouse static int gfs2_ail1_start_one(struct gfs2_sbd *sdp, 944667a0ecSSteven Whitehouse struct writeback_control *wbc, 954667a0ecSSteven Whitehouse struct gfs2_ail *ai) 96d6a079e8SDave Chinner __releases(&sdp->sd_ail_lock) 97d6a079e8SDave Chinner __acquires(&sdp->sd_ail_lock) 98ddacfaf7SSteven Whitehouse { 995ac048bbSSteven Whitehouse struct gfs2_glock *gl = NULL; 1004667a0ecSSteven Whitehouse struct address_space *mapping; 101ddacfaf7SSteven Whitehouse struct gfs2_bufdata *bd, *s; 102ddacfaf7SSteven Whitehouse struct buffer_head *bh; 103ddacfaf7SSteven Whitehouse 1044667a0ecSSteven Whitehouse list_for_each_entry_safe_reverse(bd, s, &ai->ai_ail1_list, bd_ail_st_list) { 105ddacfaf7SSteven Whitehouse bh = bd->bd_bh; 106ddacfaf7SSteven Whitehouse 107ddacfaf7SSteven Whitehouse gfs2_assert(sdp, bd->bd_ail == ai); 108ddacfaf7SSteven Whitehouse 109ddacfaf7SSteven Whitehouse if (!buffer_busy(bh)) { 11016615be1SSteven Whitehouse if (!buffer_uptodate(bh)) 111ddacfaf7SSteven Whitehouse gfs2_io_error_bh(sdp, bh); 112ddacfaf7SSteven Whitehouse list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list); 113ddacfaf7SSteven Whitehouse continue; 114ddacfaf7SSteven Whitehouse } 115ddacfaf7SSteven Whitehouse 116ddacfaf7SSteven Whitehouse if (!buffer_dirty(bh)) 117ddacfaf7SSteven Whitehouse continue; 1185ac048bbSSteven Whitehouse if (gl == bd->bd_gl) 1195ac048bbSSteven Whitehouse continue; 1205ac048bbSSteven Whitehouse gl = bd->bd_gl; 121ddacfaf7SSteven Whitehouse list_move(&bd->bd_ail_st_list, &ai->ai_ail1_list); 1224667a0ecSSteven Whitehouse mapping = bh->b_page->mapping; 1234f1de018SSteven Whitehouse if (!mapping) 1244f1de018SSteven Whitehouse continue; 125d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 1264667a0ecSSteven Whitehouse generic_writepages(mapping, wbc); 127d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 1284667a0ecSSteven Whitehouse if (wbc->nr_to_write <= 0) 129ddacfaf7SSteven Whitehouse break; 1304f1de018SSteven Whitehouse return 1; 131ddacfaf7SSteven Whitehouse } 1324f1de018SSteven Whitehouse 1334f1de018SSteven Whitehouse return 0; 1344667a0ecSSteven Whitehouse } 1354667a0ecSSteven Whitehouse 1364667a0ecSSteven Whitehouse 1374667a0ecSSteven Whitehouse /** 1384667a0ecSSteven Whitehouse * gfs2_ail1_flush - start writeback of some ail1 entries 1394667a0ecSSteven Whitehouse * @sdp: The super block 1404667a0ecSSteven Whitehouse * @wbc: The writeback control structure 1414667a0ecSSteven Whitehouse * 1424667a0ecSSteven Whitehouse * Writes back some ail1 entries, according to the limits in the 1434667a0ecSSteven Whitehouse * writeback control structure 1444667a0ecSSteven Whitehouse */ 1454667a0ecSSteven Whitehouse 1464667a0ecSSteven Whitehouse void gfs2_ail1_flush(struct gfs2_sbd *sdp, struct writeback_control *wbc) 1474667a0ecSSteven Whitehouse { 1484667a0ecSSteven Whitehouse struct list_head *head = &sdp->sd_ail1_list; 1494667a0ecSSteven Whitehouse struct gfs2_ail *ai; 1504667a0ecSSteven Whitehouse 151c83ae9caSSteven Whitehouse trace_gfs2_ail_flush(sdp, wbc, 1); 1524667a0ecSSteven Whitehouse spin_lock(&sdp->sd_ail_lock); 1534f1de018SSteven Whitehouse restart: 1544667a0ecSSteven Whitehouse list_for_each_entry_reverse(ai, head, ai_list) { 1554667a0ecSSteven Whitehouse if (wbc->nr_to_write <= 0) 1564667a0ecSSteven Whitehouse break; 1574f1de018SSteven Whitehouse if (gfs2_ail1_start_one(sdp, wbc, ai)) 1584f1de018SSteven Whitehouse goto restart; 1594667a0ecSSteven Whitehouse } 1604667a0ecSSteven Whitehouse spin_unlock(&sdp->sd_ail_lock); 161c83ae9caSSteven Whitehouse trace_gfs2_ail_flush(sdp, wbc, 0); 1624667a0ecSSteven Whitehouse } 1634667a0ecSSteven Whitehouse 1644667a0ecSSteven Whitehouse /** 1654667a0ecSSteven Whitehouse * gfs2_ail1_start - start writeback of all ail1 entries 1664667a0ecSSteven Whitehouse * @sdp: The superblock 1674667a0ecSSteven Whitehouse */ 1684667a0ecSSteven Whitehouse 1694667a0ecSSteven Whitehouse static void gfs2_ail1_start(struct gfs2_sbd *sdp) 1704667a0ecSSteven Whitehouse { 1714667a0ecSSteven Whitehouse struct writeback_control wbc = { 1724667a0ecSSteven Whitehouse .sync_mode = WB_SYNC_NONE, 1734667a0ecSSteven Whitehouse .nr_to_write = LONG_MAX, 1744667a0ecSSteven Whitehouse .range_start = 0, 1754667a0ecSSteven Whitehouse .range_end = LLONG_MAX, 1764667a0ecSSteven Whitehouse }; 1774667a0ecSSteven Whitehouse 1784667a0ecSSteven Whitehouse return gfs2_ail1_flush(sdp, &wbc); 179ddacfaf7SSteven Whitehouse } 180ddacfaf7SSteven Whitehouse 181ddacfaf7SSteven Whitehouse /** 182ddacfaf7SSteven Whitehouse * gfs2_ail1_empty_one - Check whether or not a trans in the AIL has been synced 183ddacfaf7SSteven Whitehouse * @sdp: the filesystem 184ddacfaf7SSteven Whitehouse * @ai: the AIL entry 185ddacfaf7SSteven Whitehouse * 186ddacfaf7SSteven Whitehouse */ 187ddacfaf7SSteven Whitehouse 1884667a0ecSSteven Whitehouse static void gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai) 189ddacfaf7SSteven Whitehouse { 190ddacfaf7SSteven Whitehouse struct gfs2_bufdata *bd, *s; 191ddacfaf7SSteven Whitehouse struct buffer_head *bh; 192ddacfaf7SSteven Whitehouse 193ddacfaf7SSteven Whitehouse list_for_each_entry_safe_reverse(bd, s, &ai->ai_ail1_list, 194ddacfaf7SSteven Whitehouse bd_ail_st_list) { 195ddacfaf7SSteven Whitehouse bh = bd->bd_bh; 196ddacfaf7SSteven Whitehouse gfs2_assert(sdp, bd->bd_ail == ai); 1974667a0ecSSteven Whitehouse if (buffer_busy(bh)) 198ddacfaf7SSteven Whitehouse continue; 199ddacfaf7SSteven Whitehouse if (!buffer_uptodate(bh)) 200ddacfaf7SSteven Whitehouse gfs2_io_error_bh(sdp, bh); 201ddacfaf7SSteven Whitehouse list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list); 202ddacfaf7SSteven Whitehouse } 203ddacfaf7SSteven Whitehouse 204ddacfaf7SSteven Whitehouse } 205ddacfaf7SSteven Whitehouse 2064667a0ecSSteven Whitehouse /** 2074667a0ecSSteven Whitehouse * gfs2_ail1_empty - Try to empty the ail1 lists 2084667a0ecSSteven Whitehouse * @sdp: The superblock 2094667a0ecSSteven Whitehouse * 2104667a0ecSSteven Whitehouse * Tries to empty the ail1 lists, starting with the oldest first 2114667a0ecSSteven Whitehouse */ 212b3b94faaSDavid Teigland 2134667a0ecSSteven Whitehouse static int gfs2_ail1_empty(struct gfs2_sbd *sdp) 214b3b94faaSDavid Teigland { 215b3b94faaSDavid Teigland struct gfs2_ail *ai, *s; 216b3b94faaSDavid Teigland int ret; 217b3b94faaSDavid Teigland 218d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 219b3b94faaSDavid Teigland list_for_each_entry_safe_reverse(ai, s, &sdp->sd_ail1_list, ai_list) { 2204667a0ecSSteven Whitehouse gfs2_ail1_empty_one(sdp, ai); 2214667a0ecSSteven Whitehouse if (list_empty(&ai->ai_ail1_list)) 222b3b94faaSDavid Teigland list_move(&ai->ai_list, &sdp->sd_ail2_list); 2234667a0ecSSteven Whitehouse else 224b3b94faaSDavid Teigland break; 225b3b94faaSDavid Teigland } 226b3b94faaSDavid Teigland ret = list_empty(&sdp->sd_ail1_list); 227d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 228b3b94faaSDavid Teigland 229b3b94faaSDavid Teigland return ret; 230b3b94faaSDavid Teigland } 231b3b94faaSDavid Teigland 23226b06a69SSteven Whitehouse static void gfs2_ail1_wait(struct gfs2_sbd *sdp) 23326b06a69SSteven Whitehouse { 23426b06a69SSteven Whitehouse struct gfs2_ail *ai; 23526b06a69SSteven Whitehouse struct gfs2_bufdata *bd; 23626b06a69SSteven Whitehouse struct buffer_head *bh; 23726b06a69SSteven Whitehouse 23826b06a69SSteven Whitehouse spin_lock(&sdp->sd_ail_lock); 23926b06a69SSteven Whitehouse list_for_each_entry_reverse(ai, &sdp->sd_ail1_list, ai_list) { 24026b06a69SSteven Whitehouse list_for_each_entry(bd, &ai->ai_ail1_list, bd_ail_st_list) { 24126b06a69SSteven Whitehouse bh = bd->bd_bh; 24226b06a69SSteven Whitehouse if (!buffer_locked(bh)) 24326b06a69SSteven Whitehouse continue; 24426b06a69SSteven Whitehouse get_bh(bh); 24526b06a69SSteven Whitehouse spin_unlock(&sdp->sd_ail_lock); 24626b06a69SSteven Whitehouse wait_on_buffer(bh); 24726b06a69SSteven Whitehouse brelse(bh); 24826b06a69SSteven Whitehouse return; 24926b06a69SSteven Whitehouse } 25026b06a69SSteven Whitehouse } 25126b06a69SSteven Whitehouse spin_unlock(&sdp->sd_ail_lock); 25226b06a69SSteven Whitehouse } 253ddacfaf7SSteven Whitehouse 254ddacfaf7SSteven Whitehouse /** 255ddacfaf7SSteven Whitehouse * gfs2_ail2_empty_one - Check whether or not a trans in the AIL has been synced 256ddacfaf7SSteven Whitehouse * @sdp: the filesystem 257ddacfaf7SSteven Whitehouse * @ai: the AIL entry 258ddacfaf7SSteven Whitehouse * 259ddacfaf7SSteven Whitehouse */ 260ddacfaf7SSteven Whitehouse 261ddacfaf7SSteven Whitehouse static void gfs2_ail2_empty_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai) 262ddacfaf7SSteven Whitehouse { 263ddacfaf7SSteven Whitehouse struct list_head *head = &ai->ai_ail2_list; 264ddacfaf7SSteven Whitehouse struct gfs2_bufdata *bd; 265ddacfaf7SSteven Whitehouse 266ddacfaf7SSteven Whitehouse while (!list_empty(head)) { 267ddacfaf7SSteven Whitehouse bd = list_entry(head->prev, struct gfs2_bufdata, 268ddacfaf7SSteven Whitehouse bd_ail_st_list); 269ddacfaf7SSteven Whitehouse gfs2_assert(sdp, bd->bd_ail == ai); 270f91a0d3eSSteven Whitehouse gfs2_remove_from_ail(bd); 271ddacfaf7SSteven Whitehouse } 272ddacfaf7SSteven Whitehouse } 273ddacfaf7SSteven Whitehouse 274b3b94faaSDavid Teigland static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail) 275b3b94faaSDavid Teigland { 276b3b94faaSDavid Teigland struct gfs2_ail *ai, *safe; 277b3b94faaSDavid Teigland unsigned int old_tail = sdp->sd_log_tail; 278b3b94faaSDavid Teigland int wrap = (new_tail < old_tail); 279b3b94faaSDavid Teigland int a, b, rm; 280b3b94faaSDavid Teigland 281d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 282b3b94faaSDavid Teigland 283b3b94faaSDavid Teigland list_for_each_entry_safe(ai, safe, &sdp->sd_ail2_list, ai_list) { 284b3b94faaSDavid Teigland a = (old_tail <= ai->ai_first); 285b3b94faaSDavid Teigland b = (ai->ai_first < new_tail); 286b3b94faaSDavid Teigland rm = (wrap) ? (a || b) : (a && b); 287b3b94faaSDavid Teigland if (!rm) 288b3b94faaSDavid Teigland continue; 289b3b94faaSDavid Teigland 290b3b94faaSDavid Teigland gfs2_ail2_empty_one(sdp, ai); 291b3b94faaSDavid Teigland list_del(&ai->ai_list); 292b3b94faaSDavid Teigland gfs2_assert_warn(sdp, list_empty(&ai->ai_ail1_list)); 293b3b94faaSDavid Teigland gfs2_assert_warn(sdp, list_empty(&ai->ai_ail2_list)); 294b3b94faaSDavid Teigland kfree(ai); 295b3b94faaSDavid Teigland } 296b3b94faaSDavid Teigland 297d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 298b3b94faaSDavid Teigland } 299b3b94faaSDavid Teigland 300b3b94faaSDavid Teigland /** 301b3b94faaSDavid Teigland * gfs2_log_reserve - Make a log reservation 302b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 303b3b94faaSDavid Teigland * @blks: The number of blocks to reserve 304b3b94faaSDavid Teigland * 30589918647SSteven Whitehouse * Note that we never give out the last few blocks of the journal. Thats 3062332c443SRobert Peterson * due to the fact that there is a small number of header blocks 307b004157aSSteven Whitehouse * associated with each log flush. The exact number can't be known until 308b004157aSSteven Whitehouse * flush time, so we ensure that we have just enough free blocks at all 309b004157aSSteven Whitehouse * times to avoid running out during a log flush. 310b004157aSSteven Whitehouse * 3115e687eacSBenjamin Marzinski * We no longer flush the log here, instead we wake up logd to do that 3125e687eacSBenjamin Marzinski * for us. To avoid the thundering herd and to ensure that we deal fairly 3135e687eacSBenjamin Marzinski * with queued waiters, we use an exclusive wait. This means that when we 3145e687eacSBenjamin Marzinski * get woken with enough journal space to get our reservation, we need to 3155e687eacSBenjamin Marzinski * wake the next waiter on the list. 3165e687eacSBenjamin Marzinski * 317b3b94faaSDavid Teigland * Returns: errno 318b3b94faaSDavid Teigland */ 319b3b94faaSDavid Teigland 320b3b94faaSDavid Teigland int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks) 321b3b94faaSDavid Teigland { 32289918647SSteven Whitehouse unsigned reserved_blks = 6 * (4096 / sdp->sd_vfs->s_blocksize); 3235e687eacSBenjamin Marzinski unsigned wanted = blks + reserved_blks; 3245e687eacSBenjamin Marzinski DEFINE_WAIT(wait); 3255e687eacSBenjamin Marzinski int did_wait = 0; 3265e687eacSBenjamin Marzinski unsigned int free_blocks; 327b3b94faaSDavid Teigland 328b3b94faaSDavid Teigland if (gfs2_assert_warn(sdp, blks) || 329b3b94faaSDavid Teigland gfs2_assert_warn(sdp, blks <= sdp->sd_jdesc->jd_blocks)) 330b3b94faaSDavid Teigland return -EINVAL; 3315e687eacSBenjamin Marzinski retry: 3325e687eacSBenjamin Marzinski free_blocks = atomic_read(&sdp->sd_log_blks_free); 3335e687eacSBenjamin Marzinski if (unlikely(free_blocks <= wanted)) { 3345e687eacSBenjamin Marzinski do { 3355e687eacSBenjamin Marzinski prepare_to_wait_exclusive(&sdp->sd_log_waitq, &wait, 3365e687eacSBenjamin Marzinski TASK_UNINTERRUPTIBLE); 3375e687eacSBenjamin Marzinski wake_up(&sdp->sd_logd_waitq); 3385e687eacSBenjamin Marzinski did_wait = 1; 3395e687eacSBenjamin Marzinski if (atomic_read(&sdp->sd_log_blks_free) <= wanted) 3405e687eacSBenjamin Marzinski io_schedule(); 3415e687eacSBenjamin Marzinski free_blocks = atomic_read(&sdp->sd_log_blks_free); 3425e687eacSBenjamin Marzinski } while(free_blocks <= wanted); 3435e687eacSBenjamin Marzinski finish_wait(&sdp->sd_log_waitq, &wait); 344b3b94faaSDavid Teigland } 3455e687eacSBenjamin Marzinski if (atomic_cmpxchg(&sdp->sd_log_blks_free, free_blocks, 3465e687eacSBenjamin Marzinski free_blocks - blks) != free_blocks) 3475e687eacSBenjamin Marzinski goto retry; 34863997775SSteven Whitehouse trace_gfs2_log_blocks(sdp, -blks); 3495e687eacSBenjamin Marzinski 3505e687eacSBenjamin Marzinski /* 3515e687eacSBenjamin Marzinski * If we waited, then so might others, wake them up _after_ we get 3525e687eacSBenjamin Marzinski * our share of the log. 3535e687eacSBenjamin Marzinski */ 3545e687eacSBenjamin Marzinski if (unlikely(did_wait)) 3555e687eacSBenjamin Marzinski wake_up(&sdp->sd_log_waitq); 356484adff8SSteven Whitehouse 357484adff8SSteven Whitehouse down_read(&sdp->sd_log_flush_lock); 358b3b94faaSDavid Teigland 359b3b94faaSDavid Teigland return 0; 360b3b94faaSDavid Teigland } 361b3b94faaSDavid Teigland 36247ac5537SSteven Whitehouse u64 gfs2_log_bmap(struct gfs2_sbd *sdp, unsigned int lbn) 363b3b94faaSDavid Teigland { 364da6dd40dSBob Peterson struct gfs2_journal_extent *je; 365b3b94faaSDavid Teigland 366da6dd40dSBob Peterson list_for_each_entry(je, &sdp->sd_jdesc->extent_list, extent_list) { 367da6dd40dSBob Peterson if (lbn >= je->lblock && lbn < je->lblock + je->blocks) 368ff91cc9bSSteven Whitehouse return je->dblock + lbn - je->lblock; 369da6dd40dSBob Peterson } 370b3b94faaSDavid Teigland 371da6dd40dSBob Peterson return -1; 372b3b94faaSDavid Teigland } 373b3b94faaSDavid Teigland 374b3b94faaSDavid Teigland /** 375b3b94faaSDavid Teigland * log_distance - Compute distance between two journal blocks 376b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 377b3b94faaSDavid Teigland * @newer: The most recent journal block of the pair 378b3b94faaSDavid Teigland * @older: The older journal block of the pair 379b3b94faaSDavid Teigland * 380b3b94faaSDavid Teigland * Compute the distance (in the journal direction) between two 381b3b94faaSDavid Teigland * blocks in the journal 382b3b94faaSDavid Teigland * 383b3b94faaSDavid Teigland * Returns: the distance in blocks 384b3b94faaSDavid Teigland */ 385b3b94faaSDavid Teigland 386faa31ce8SSteven Whitehouse static inline unsigned int log_distance(struct gfs2_sbd *sdp, unsigned int newer, 387b3b94faaSDavid Teigland unsigned int older) 388b3b94faaSDavid Teigland { 389b3b94faaSDavid Teigland int dist; 390b3b94faaSDavid Teigland 391b3b94faaSDavid Teigland dist = newer - older; 392b3b94faaSDavid Teigland if (dist < 0) 393b3b94faaSDavid Teigland dist += sdp->sd_jdesc->jd_blocks; 394b3b94faaSDavid Teigland 395b3b94faaSDavid Teigland return dist; 396b3b94faaSDavid Teigland } 397b3b94faaSDavid Teigland 3982332c443SRobert Peterson /** 3992332c443SRobert Peterson * calc_reserved - Calculate the number of blocks to reserve when 4002332c443SRobert Peterson * refunding a transaction's unused buffers. 4012332c443SRobert Peterson * @sdp: The GFS2 superblock 4022332c443SRobert Peterson * 4032332c443SRobert Peterson * This is complex. We need to reserve room for all our currently used 4042332c443SRobert Peterson * metadata buffers (e.g. normal file I/O rewriting file time stamps) and 4052332c443SRobert Peterson * all our journaled data buffers for journaled files (e.g. files in the 4062332c443SRobert Peterson * meta_fs like rindex, or files for which chattr +j was done.) 4072332c443SRobert Peterson * If we don't reserve enough space, gfs2_log_refund and gfs2_log_flush 4082332c443SRobert Peterson * will count it as free space (sd_log_blks_free) and corruption will follow. 4092332c443SRobert Peterson * 4102332c443SRobert Peterson * We can have metadata bufs and jdata bufs in the same journal. So each 4112332c443SRobert Peterson * type gets its own log header, for which we need to reserve a block. 4122332c443SRobert Peterson * In fact, each type has the potential for needing more than one header 4132332c443SRobert Peterson * in cases where we have more buffers than will fit on a journal page. 4142332c443SRobert Peterson * Metadata journal entries take up half the space of journaled buffer entries. 4152332c443SRobert Peterson * Thus, metadata entries have buf_limit (502) and journaled buffers have 4162332c443SRobert Peterson * databuf_limit (251) before they cause a wrap around. 4172332c443SRobert Peterson * 4182332c443SRobert Peterson * Also, we need to reserve blocks for revoke journal entries and one for an 4192332c443SRobert Peterson * overall header for the lot. 4202332c443SRobert Peterson * 4212332c443SRobert Peterson * Returns: the number of blocks reserved 4222332c443SRobert Peterson */ 4232332c443SRobert Peterson static unsigned int calc_reserved(struct gfs2_sbd *sdp) 4242332c443SRobert Peterson { 4252332c443SRobert Peterson unsigned int reserved = 0; 4262332c443SRobert Peterson unsigned int mbuf_limit, metabufhdrs_needed; 4272332c443SRobert Peterson unsigned int dbuf_limit, databufhdrs_needed; 4282332c443SRobert Peterson unsigned int revokes = 0; 4292332c443SRobert Peterson 4302332c443SRobert Peterson mbuf_limit = buf_limit(sdp); 4312332c443SRobert Peterson metabufhdrs_needed = (sdp->sd_log_commited_buf + 4322332c443SRobert Peterson (mbuf_limit - 1)) / mbuf_limit; 4332332c443SRobert Peterson dbuf_limit = databuf_limit(sdp); 4342332c443SRobert Peterson databufhdrs_needed = (sdp->sd_log_commited_databuf + 4352332c443SRobert Peterson (dbuf_limit - 1)) / dbuf_limit; 4362332c443SRobert Peterson 4372e95e3f6SBenjamin Marzinski if (sdp->sd_log_commited_revoke > 0) 4382332c443SRobert Peterson revokes = gfs2_struct2blk(sdp, sdp->sd_log_commited_revoke, 4392332c443SRobert Peterson sizeof(u64)); 4402332c443SRobert Peterson 4412332c443SRobert Peterson reserved = sdp->sd_log_commited_buf + metabufhdrs_needed + 4422332c443SRobert Peterson sdp->sd_log_commited_databuf + databufhdrs_needed + 4432332c443SRobert Peterson revokes; 4442332c443SRobert Peterson /* One for the overall header */ 4452332c443SRobert Peterson if (reserved) 4462332c443SRobert Peterson reserved++; 4472332c443SRobert Peterson return reserved; 4482332c443SRobert Peterson } 4492332c443SRobert Peterson 450b3b94faaSDavid Teigland static unsigned int current_tail(struct gfs2_sbd *sdp) 451b3b94faaSDavid Teigland { 452b3b94faaSDavid Teigland struct gfs2_ail *ai; 453b3b94faaSDavid Teigland unsigned int tail; 454b3b94faaSDavid Teigland 455d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 456b3b94faaSDavid Teigland 457faa31ce8SSteven Whitehouse if (list_empty(&sdp->sd_ail1_list)) { 458b3b94faaSDavid Teigland tail = sdp->sd_log_head; 459faa31ce8SSteven Whitehouse } else { 460faa31ce8SSteven Whitehouse ai = list_entry(sdp->sd_ail1_list.prev, struct gfs2_ail, ai_list); 461b3b94faaSDavid Teigland tail = ai->ai_first; 462b3b94faaSDavid Teigland } 463b3b94faaSDavid Teigland 464d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 465b3b94faaSDavid Teigland 466b3b94faaSDavid Teigland return tail; 467b3b94faaSDavid Teigland } 468b3b94faaSDavid Teigland 46916615be1SSteven Whitehouse void gfs2_log_incr_head(struct gfs2_sbd *sdp) 470b3b94faaSDavid Teigland { 47147ac5537SSteven Whitehouse BUG_ON((sdp->sd_log_flush_head == sdp->sd_log_tail) && 47247ac5537SSteven Whitehouse (sdp->sd_log_flush_head != sdp->sd_log_head)); 473b3b94faaSDavid Teigland 474b3b94faaSDavid Teigland if (++sdp->sd_log_flush_head == sdp->sd_jdesc->jd_blocks) { 475b3b94faaSDavid Teigland sdp->sd_log_flush_head = 0; 476b3b94faaSDavid Teigland sdp->sd_log_flush_wrapped = 1; 477b3b94faaSDavid Teigland } 478b3b94faaSDavid Teigland } 479b3b94faaSDavid Teigland 4802332c443SRobert Peterson static void log_pull_tail(struct gfs2_sbd *sdp, unsigned int new_tail) 481b3b94faaSDavid Teigland { 482b3b94faaSDavid Teigland unsigned int dist = log_distance(sdp, new_tail, sdp->sd_log_tail); 483b3b94faaSDavid Teigland 484b3b94faaSDavid Teigland ail2_empty(sdp, new_tail); 485b3b94faaSDavid Teigland 486fd041f0bSSteven Whitehouse atomic_add(dist, &sdp->sd_log_blks_free); 48763997775SSteven Whitehouse trace_gfs2_log_blocks(sdp, dist); 4885e687eacSBenjamin Marzinski gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <= 4895e687eacSBenjamin Marzinski sdp->sd_jdesc->jd_blocks); 490b3b94faaSDavid Teigland 491b3b94faaSDavid Teigland sdp->sd_log_tail = new_tail; 492b3b94faaSDavid Teigland } 493b3b94faaSDavid Teigland 494b3b94faaSDavid Teigland 495*34cc1781SSteven Whitehouse static void log_flush_wait(struct gfs2_sbd *sdp) 496b3b94faaSDavid Teigland { 49716615be1SSteven Whitehouse DEFINE_WAIT(wait); 498b3b94faaSDavid Teigland 49916615be1SSteven Whitehouse if (atomic_read(&sdp->sd_log_in_flight)) { 50016615be1SSteven Whitehouse do { 50116615be1SSteven Whitehouse prepare_to_wait(&sdp->sd_log_flush_wait, &wait, 50216615be1SSteven Whitehouse TASK_UNINTERRUPTIBLE); 50316615be1SSteven Whitehouse if (atomic_read(&sdp->sd_log_in_flight)) 50416615be1SSteven Whitehouse io_schedule(); 50516615be1SSteven Whitehouse } while(atomic_read(&sdp->sd_log_in_flight)); 50616615be1SSteven Whitehouse finish_wait(&sdp->sd_log_flush_wait, &wait); 507b3b94faaSDavid Teigland } 508b3b94faaSDavid Teigland } 509b3b94faaSDavid Teigland 51008728f2dSSteven Whitehouse static int bd_cmp(void *priv, struct list_head *a, struct list_head *b) 5114a36d08dSBob Peterson { 5124a36d08dSBob Peterson struct gfs2_bufdata *bda, *bdb; 5134a36d08dSBob Peterson 5144a36d08dSBob Peterson bda = list_entry(a, struct gfs2_bufdata, bd_le.le_list); 5154a36d08dSBob Peterson bdb = list_entry(b, struct gfs2_bufdata, bd_le.le_list); 5164a36d08dSBob Peterson 5174a36d08dSBob Peterson if (bda->bd_bh->b_blocknr < bdb->bd_bh->b_blocknr) 5184a36d08dSBob Peterson return -1; 5194a36d08dSBob Peterson if (bda->bd_bh->b_blocknr > bdb->bd_bh->b_blocknr) 5204a36d08dSBob Peterson return 1; 5214a36d08dSBob Peterson return 0; 5224a36d08dSBob Peterson } 5234a36d08dSBob Peterson 524d7b616e2SSteven Whitehouse static void gfs2_ordered_write(struct gfs2_sbd *sdp) 525d7b616e2SSteven Whitehouse { 526d7b616e2SSteven Whitehouse struct gfs2_bufdata *bd; 527d7b616e2SSteven Whitehouse struct buffer_head *bh; 528d7b616e2SSteven Whitehouse LIST_HEAD(written); 529d7b616e2SSteven Whitehouse 530d7b616e2SSteven Whitehouse gfs2_log_lock(sdp); 5314a36d08dSBob Peterson list_sort(NULL, &sdp->sd_log_le_ordered, &bd_cmp); 532d7b616e2SSteven Whitehouse while (!list_empty(&sdp->sd_log_le_ordered)) { 533d7b616e2SSteven Whitehouse bd = list_entry(sdp->sd_log_le_ordered.next, struct gfs2_bufdata, bd_le.le_list); 534d7b616e2SSteven Whitehouse list_move(&bd->bd_le.le_list, &written); 535d7b616e2SSteven Whitehouse bh = bd->bd_bh; 536d7b616e2SSteven Whitehouse if (!buffer_dirty(bh)) 537d7b616e2SSteven Whitehouse continue; 538d7b616e2SSteven Whitehouse get_bh(bh); 539d7b616e2SSteven Whitehouse gfs2_log_unlock(sdp); 540d7b616e2SSteven Whitehouse lock_buffer(bh); 541b8e7cbb6SSteven Whitehouse if (buffer_mapped(bh) && test_clear_buffer_dirty(bh)) { 542d7b616e2SSteven Whitehouse bh->b_end_io = end_buffer_write_sync; 543721a9602SJens Axboe submit_bh(WRITE_SYNC, bh); 544d7b616e2SSteven Whitehouse } else { 545d7b616e2SSteven Whitehouse unlock_buffer(bh); 546d7b616e2SSteven Whitehouse brelse(bh); 547d7b616e2SSteven Whitehouse } 548d7b616e2SSteven Whitehouse gfs2_log_lock(sdp); 549d7b616e2SSteven Whitehouse } 550d7b616e2SSteven Whitehouse list_splice(&written, &sdp->sd_log_le_ordered); 551d7b616e2SSteven Whitehouse gfs2_log_unlock(sdp); 552d7b616e2SSteven Whitehouse } 553d7b616e2SSteven Whitehouse 554d7b616e2SSteven Whitehouse static void gfs2_ordered_wait(struct gfs2_sbd *sdp) 555d7b616e2SSteven Whitehouse { 556d7b616e2SSteven Whitehouse struct gfs2_bufdata *bd; 557d7b616e2SSteven Whitehouse struct buffer_head *bh; 558d7b616e2SSteven Whitehouse 559d7b616e2SSteven Whitehouse gfs2_log_lock(sdp); 560d7b616e2SSteven Whitehouse while (!list_empty(&sdp->sd_log_le_ordered)) { 561d7b616e2SSteven Whitehouse bd = list_entry(sdp->sd_log_le_ordered.prev, struct gfs2_bufdata, bd_le.le_list); 562d7b616e2SSteven Whitehouse bh = bd->bd_bh; 563d7b616e2SSteven Whitehouse if (buffer_locked(bh)) { 564d7b616e2SSteven Whitehouse get_bh(bh); 565d7b616e2SSteven Whitehouse gfs2_log_unlock(sdp); 566d7b616e2SSteven Whitehouse wait_on_buffer(bh); 567d7b616e2SSteven Whitehouse brelse(bh); 568d7b616e2SSteven Whitehouse gfs2_log_lock(sdp); 569d7b616e2SSteven Whitehouse continue; 570d7b616e2SSteven Whitehouse } 571d7b616e2SSteven Whitehouse list_del_init(&bd->bd_le.le_list); 572d7b616e2SSteven Whitehouse } 573d7b616e2SSteven Whitehouse gfs2_log_unlock(sdp); 574d7b616e2SSteven Whitehouse } 575d7b616e2SSteven Whitehouse 576b3b94faaSDavid Teigland /** 577*34cc1781SSteven Whitehouse * log_write_header - Get and initialize a journal header buffer 578*34cc1781SSteven Whitehouse * @sdp: The GFS2 superblock 579*34cc1781SSteven Whitehouse * 580*34cc1781SSteven Whitehouse * Returns: the initialized log buffer descriptor 581*34cc1781SSteven Whitehouse */ 582*34cc1781SSteven Whitehouse 583*34cc1781SSteven Whitehouse static void log_write_header(struct gfs2_sbd *sdp, u32 flags, int pull) 584*34cc1781SSteven Whitehouse { 585*34cc1781SSteven Whitehouse u64 blkno = gfs2_log_bmap(sdp, sdp->sd_log_flush_head); 586*34cc1781SSteven Whitehouse struct buffer_head *bh; 587*34cc1781SSteven Whitehouse struct gfs2_log_header *lh; 588*34cc1781SSteven Whitehouse unsigned int tail; 589*34cc1781SSteven Whitehouse u32 hash; 590*34cc1781SSteven Whitehouse 591*34cc1781SSteven Whitehouse bh = sb_getblk(sdp->sd_vfs, blkno); 592*34cc1781SSteven Whitehouse lock_buffer(bh); 593*34cc1781SSteven Whitehouse memset(bh->b_data, 0, bh->b_size); 594*34cc1781SSteven Whitehouse set_buffer_uptodate(bh); 595*34cc1781SSteven Whitehouse clear_buffer_dirty(bh); 596*34cc1781SSteven Whitehouse 597*34cc1781SSteven Whitehouse gfs2_ail1_empty(sdp); 598*34cc1781SSteven Whitehouse tail = current_tail(sdp); 599*34cc1781SSteven Whitehouse 600*34cc1781SSteven Whitehouse lh = (struct gfs2_log_header *)bh->b_data; 601*34cc1781SSteven Whitehouse memset(lh, 0, sizeof(struct gfs2_log_header)); 602*34cc1781SSteven Whitehouse lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 603*34cc1781SSteven Whitehouse lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH); 604*34cc1781SSteven Whitehouse lh->lh_header.__pad0 = cpu_to_be64(0); 605*34cc1781SSteven Whitehouse lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH); 606*34cc1781SSteven Whitehouse lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid); 607*34cc1781SSteven Whitehouse lh->lh_sequence = cpu_to_be64(sdp->sd_log_sequence++); 608*34cc1781SSteven Whitehouse lh->lh_flags = cpu_to_be32(flags); 609*34cc1781SSteven Whitehouse lh->lh_tail = cpu_to_be32(tail); 610*34cc1781SSteven Whitehouse lh->lh_blkno = cpu_to_be32(sdp->sd_log_flush_head); 611*34cc1781SSteven Whitehouse hash = gfs2_disk_hash(bh->b_data, sizeof(struct gfs2_log_header)); 612*34cc1781SSteven Whitehouse lh->lh_hash = cpu_to_be32(hash); 613*34cc1781SSteven Whitehouse 614*34cc1781SSteven Whitehouse bh->b_end_io = end_buffer_write_sync; 615*34cc1781SSteven Whitehouse get_bh(bh); 616*34cc1781SSteven Whitehouse if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags)) { 617*34cc1781SSteven Whitehouse gfs2_ordered_wait(sdp); 618*34cc1781SSteven Whitehouse log_flush_wait(sdp); 619*34cc1781SSteven Whitehouse submit_bh(WRITE_SYNC | REQ_META | REQ_PRIO, bh); 620*34cc1781SSteven Whitehouse } else { 621*34cc1781SSteven Whitehouse submit_bh(WRITE_FLUSH_FUA | REQ_META, bh); 622*34cc1781SSteven Whitehouse } 623*34cc1781SSteven Whitehouse wait_on_buffer(bh); 624*34cc1781SSteven Whitehouse 625*34cc1781SSteven Whitehouse if (!buffer_uptodate(bh)) 626*34cc1781SSteven Whitehouse gfs2_io_error_bh(sdp, bh); 627*34cc1781SSteven Whitehouse brelse(bh); 628*34cc1781SSteven Whitehouse 629*34cc1781SSteven Whitehouse if (sdp->sd_log_tail != tail) 630*34cc1781SSteven Whitehouse log_pull_tail(sdp, tail); 631*34cc1781SSteven Whitehouse else 632*34cc1781SSteven Whitehouse gfs2_assert_withdraw(sdp, !pull); 633*34cc1781SSteven Whitehouse 634*34cc1781SSteven Whitehouse sdp->sd_log_idle = (tail == sdp->sd_log_flush_head); 635*34cc1781SSteven Whitehouse gfs2_log_incr_head(sdp); 636*34cc1781SSteven Whitehouse } 637*34cc1781SSteven Whitehouse 638*34cc1781SSteven Whitehouse /** 639b09e593dSSteven Whitehouse * gfs2_log_flush - flush incore transaction(s) 640b3b94faaSDavid Teigland * @sdp: the filesystem 641b3b94faaSDavid Teigland * @gl: The glock structure to flush. If NULL, flush the whole incore log 642b3b94faaSDavid Teigland * 643b3b94faaSDavid Teigland */ 644b3b94faaSDavid Teigland 645ed4878e8SBob Peterson void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl) 646b3b94faaSDavid Teigland { 647b3b94faaSDavid Teigland struct gfs2_ail *ai; 648b3b94faaSDavid Teigland 649484adff8SSteven Whitehouse down_write(&sdp->sd_log_flush_lock); 650f55ab26aSSteven Whitehouse 6512bcd610dSSteven Whitehouse /* Log might have been flushed while we waited for the flush lock */ 6522bcd610dSSteven Whitehouse if (gl && !test_bit(GLF_LFLUSH, &gl->gl_flags)) { 653484adff8SSteven Whitehouse up_write(&sdp->sd_log_flush_lock); 654f55ab26aSSteven Whitehouse return; 655f55ab26aSSteven Whitehouse } 65663997775SSteven Whitehouse trace_gfs2_log_flush(sdp, 1); 657f55ab26aSSteven Whitehouse 658b09e593dSSteven Whitehouse ai = kzalloc(sizeof(struct gfs2_ail), GFP_NOFS | __GFP_NOFAIL); 659b09e593dSSteven Whitehouse INIT_LIST_HEAD(&ai->ai_ail1_list); 660b09e593dSSteven Whitehouse INIT_LIST_HEAD(&ai->ai_ail2_list); 661b3b94faaSDavid Teigland 66216615be1SSteven Whitehouse if (sdp->sd_log_num_buf != sdp->sd_log_commited_buf) { 66316615be1SSteven Whitehouse printk(KERN_INFO "GFS2: log buf %u %u\n", sdp->sd_log_num_buf, 66416615be1SSteven Whitehouse sdp->sd_log_commited_buf); 66516615be1SSteven Whitehouse gfs2_assert_withdraw(sdp, 0); 66616615be1SSteven Whitehouse } 66716615be1SSteven Whitehouse if (sdp->sd_log_num_databuf != sdp->sd_log_commited_databuf) { 66816615be1SSteven Whitehouse printk(KERN_INFO "GFS2: log databuf %u %u\n", 66916615be1SSteven Whitehouse sdp->sd_log_num_databuf, sdp->sd_log_commited_databuf); 67016615be1SSteven Whitehouse gfs2_assert_withdraw(sdp, 0); 67116615be1SSteven Whitehouse } 672b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, 673b3b94faaSDavid Teigland sdp->sd_log_num_revoke == sdp->sd_log_commited_revoke); 674b3b94faaSDavid Teigland 675b3b94faaSDavid Teigland sdp->sd_log_flush_head = sdp->sd_log_head; 676b3b94faaSDavid Teigland sdp->sd_log_flush_wrapped = 0; 677b3b94faaSDavid Teigland ai->ai_first = sdp->sd_log_flush_head; 678b3b94faaSDavid Teigland 679d7b616e2SSteven Whitehouse gfs2_ordered_write(sdp); 680b3b94faaSDavid Teigland lops_before_commit(sdp); 681d7b616e2SSteven Whitehouse 682*34cc1781SSteven Whitehouse if (sdp->sd_log_head != sdp->sd_log_flush_head) { 683*34cc1781SSteven Whitehouse log_write_header(sdp, 0, 0); 684*34cc1781SSteven Whitehouse } else if (sdp->sd_log_tail != current_tail(sdp) && !sdp->sd_log_idle){ 6852332c443SRobert Peterson gfs2_log_lock(sdp); 686fd041f0bSSteven Whitehouse atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */ 68763997775SSteven Whitehouse trace_gfs2_log_blocks(sdp, -1); 6882332c443SRobert Peterson gfs2_log_unlock(sdp); 689b3b94faaSDavid Teigland log_write_header(sdp, 0, PULL); 6902332c443SRobert Peterson } 691b3b94faaSDavid Teigland lops_after_commit(sdp, ai); 692fe1a698fSSteven Whitehouse 693fe1a698fSSteven Whitehouse gfs2_log_lock(sdp); 694b3b94faaSDavid Teigland sdp->sd_log_head = sdp->sd_log_flush_head; 695faa31ce8SSteven Whitehouse sdp->sd_log_blks_reserved = 0; 696faa31ce8SSteven Whitehouse sdp->sd_log_commited_buf = 0; 6972332c443SRobert Peterson sdp->sd_log_commited_databuf = 0; 698b3b94faaSDavid Teigland sdp->sd_log_commited_revoke = 0; 699b3b94faaSDavid Teigland 700d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 701b3b94faaSDavid Teigland if (!list_empty(&ai->ai_ail1_list)) { 702b3b94faaSDavid Teigland list_add(&ai->ai_list, &sdp->sd_ail1_list); 703b3b94faaSDavid Teigland ai = NULL; 704b3b94faaSDavid Teigland } 705d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 706b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 70763997775SSteven Whitehouse trace_gfs2_log_flush(sdp, 0); 708484adff8SSteven Whitehouse up_write(&sdp->sd_log_flush_lock); 709b3b94faaSDavid Teigland 710b3b94faaSDavid Teigland kfree(ai); 711b3b94faaSDavid Teigland } 712b3b94faaSDavid Teigland 713b3b94faaSDavid Teigland static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 714b3b94faaSDavid Teigland { 7152332c443SRobert Peterson unsigned int reserved; 716ac39aaddSSteven Whitehouse unsigned int unused; 717b3b94faaSDavid Teigland 718b3b94faaSDavid Teigland gfs2_log_lock(sdp); 719b3b94faaSDavid Teigland 720b3b94faaSDavid Teigland sdp->sd_log_commited_buf += tr->tr_num_buf_new - tr->tr_num_buf_rm; 7212332c443SRobert Peterson sdp->sd_log_commited_databuf += tr->tr_num_databuf_new - 7222332c443SRobert Peterson tr->tr_num_databuf_rm; 7232332c443SRobert Peterson gfs2_assert_withdraw(sdp, (((int)sdp->sd_log_commited_buf) >= 0) || 7242332c443SRobert Peterson (((int)sdp->sd_log_commited_databuf) >= 0)); 725b3b94faaSDavid Teigland sdp->sd_log_commited_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm; 7262332c443SRobert Peterson reserved = calc_reserved(sdp); 72762be1f71SRoel Kluin gfs2_assert_withdraw(sdp, sdp->sd_log_blks_reserved + tr->tr_reserved >= reserved); 728ac39aaddSSteven Whitehouse unused = sdp->sd_log_blks_reserved - reserved + tr->tr_reserved; 729ac39aaddSSteven Whitehouse atomic_add(unused, &sdp->sd_log_blks_free); 73063997775SSteven Whitehouse trace_gfs2_log_blocks(sdp, unused); 731fd041f0bSSteven Whitehouse gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <= 7322332c443SRobert Peterson sdp->sd_jdesc->jd_blocks); 733b3b94faaSDavid Teigland sdp->sd_log_blks_reserved = reserved; 734b3b94faaSDavid Teigland 735b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 736b3b94faaSDavid Teigland } 737b3b94faaSDavid Teigland 738d0109bfaSBob Peterson static void buf_lo_incore_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 739d0109bfaSBob Peterson { 740d0109bfaSBob Peterson struct list_head *head = &tr->tr_list_buf; 741d0109bfaSBob Peterson struct gfs2_bufdata *bd; 742d0109bfaSBob Peterson 743d0109bfaSBob Peterson gfs2_log_lock(sdp); 744d0109bfaSBob Peterson while (!list_empty(head)) { 745d0109bfaSBob Peterson bd = list_entry(head->next, struct gfs2_bufdata, bd_list_tr); 746d0109bfaSBob Peterson list_del_init(&bd->bd_list_tr); 747d0109bfaSBob Peterson tr->tr_num_buf--; 748d0109bfaSBob Peterson } 749d0109bfaSBob Peterson gfs2_log_unlock(sdp); 750d0109bfaSBob Peterson gfs2_assert_warn(sdp, !tr->tr_num_buf); 751d0109bfaSBob Peterson } 752d0109bfaSBob Peterson 753b3b94faaSDavid Teigland /** 754b3b94faaSDavid Teigland * gfs2_log_commit - Commit a transaction to the log 755b3b94faaSDavid Teigland * @sdp: the filesystem 756b3b94faaSDavid Teigland * @tr: the transaction 757b3b94faaSDavid Teigland * 7585e687eacSBenjamin Marzinski * We wake up gfs2_logd if the number of pinned blocks exceed thresh1 7595e687eacSBenjamin Marzinski * or the total number of used blocks (pinned blocks plus AIL blocks) 7605e687eacSBenjamin Marzinski * is greater than thresh2. 7615e687eacSBenjamin Marzinski * 7625e687eacSBenjamin Marzinski * At mount time thresh1 is 1/3rd of journal size, thresh2 is 2/3rd of 7635e687eacSBenjamin Marzinski * journal size. 7645e687eacSBenjamin Marzinski * 765b3b94faaSDavid Teigland * Returns: errno 766b3b94faaSDavid Teigland */ 767b3b94faaSDavid Teigland 768b3b94faaSDavid Teigland void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 769b3b94faaSDavid Teigland { 770b3b94faaSDavid Teigland log_refund(sdp, tr); 771d0109bfaSBob Peterson buf_lo_incore_commit(sdp, tr); 772b3b94faaSDavid Teigland 773484adff8SSteven Whitehouse up_read(&sdp->sd_log_flush_lock); 774b3b94faaSDavid Teigland 7755e687eacSBenjamin Marzinski if (atomic_read(&sdp->sd_log_pinned) > atomic_read(&sdp->sd_log_thresh1) || 7765e687eacSBenjamin Marzinski ((sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free)) > 7775e687eacSBenjamin Marzinski atomic_read(&sdp->sd_log_thresh2))) 7785e687eacSBenjamin Marzinski wake_up(&sdp->sd_logd_waitq); 779faa31ce8SSteven Whitehouse } 780b3b94faaSDavid Teigland 781b3b94faaSDavid Teigland /** 782b3b94faaSDavid Teigland * gfs2_log_shutdown - write a shutdown header into a journal 783b3b94faaSDavid Teigland * @sdp: the filesystem 784b3b94faaSDavid Teigland * 785b3b94faaSDavid Teigland */ 786b3b94faaSDavid Teigland 787b3b94faaSDavid Teigland void gfs2_log_shutdown(struct gfs2_sbd *sdp) 788b3b94faaSDavid Teigland { 789484adff8SSteven Whitehouse down_write(&sdp->sd_log_flush_lock); 790b3b94faaSDavid Teigland 791b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved); 792b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_buf); 793b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke); 794b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_rg); 795b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_databuf); 796b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list)); 797b3b94faaSDavid Teigland 798b3b94faaSDavid Teigland sdp->sd_log_flush_head = sdp->sd_log_head; 799b3b94faaSDavid Teigland sdp->sd_log_flush_wrapped = 0; 800b3b94faaSDavid Teigland 8012332c443SRobert Peterson log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT, 8022332c443SRobert Peterson (sdp->sd_log_tail == current_tail(sdp)) ? 0 : PULL); 803b3b94faaSDavid Teigland 804fd041f0bSSteven Whitehouse gfs2_assert_warn(sdp, atomic_read(&sdp->sd_log_blks_free) == sdp->sd_jdesc->jd_blocks); 805a74604beSSteven Whitehouse gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail); 806a74604beSSteven Whitehouse gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list)); 807b3b94faaSDavid Teigland 808b3b94faaSDavid Teigland sdp->sd_log_head = sdp->sd_log_flush_head; 809b3b94faaSDavid Teigland sdp->sd_log_tail = sdp->sd_log_head; 810b3b94faaSDavid Teigland 811484adff8SSteven Whitehouse up_write(&sdp->sd_log_flush_lock); 812b3b94faaSDavid Teigland } 813b3b94faaSDavid Teigland 814a25311c8SSteven Whitehouse 815a25311c8SSteven Whitehouse /** 816a25311c8SSteven Whitehouse * gfs2_meta_syncfs - sync all the buffers in a filesystem 817a25311c8SSteven Whitehouse * @sdp: the filesystem 818a25311c8SSteven Whitehouse * 819a25311c8SSteven Whitehouse */ 820a25311c8SSteven Whitehouse 821a25311c8SSteven Whitehouse void gfs2_meta_syncfs(struct gfs2_sbd *sdp) 822a25311c8SSteven Whitehouse { 823a25311c8SSteven Whitehouse gfs2_log_flush(sdp, NULL); 824a25311c8SSteven Whitehouse for (;;) { 8255e687eacSBenjamin Marzinski gfs2_ail1_start(sdp); 82626b06a69SSteven Whitehouse gfs2_ail1_wait(sdp); 8274667a0ecSSteven Whitehouse if (gfs2_ail1_empty(sdp)) 828a25311c8SSteven Whitehouse break; 829a25311c8SSteven Whitehouse } 830380f7c65SSteven Whitehouse gfs2_log_flush(sdp, NULL); 831a25311c8SSteven Whitehouse } 832a25311c8SSteven Whitehouse 8335e687eacSBenjamin Marzinski static inline int gfs2_jrnl_flush_reqd(struct gfs2_sbd *sdp) 8345e687eacSBenjamin Marzinski { 8355e687eacSBenjamin Marzinski return (atomic_read(&sdp->sd_log_pinned) >= atomic_read(&sdp->sd_log_thresh1)); 8365e687eacSBenjamin Marzinski } 8375e687eacSBenjamin Marzinski 8385e687eacSBenjamin Marzinski static inline int gfs2_ail_flush_reqd(struct gfs2_sbd *sdp) 8395e687eacSBenjamin Marzinski { 8405e687eacSBenjamin Marzinski unsigned int used_blocks = sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free); 8415e687eacSBenjamin Marzinski return used_blocks >= atomic_read(&sdp->sd_log_thresh2); 8425e687eacSBenjamin Marzinski } 843ec69b188SSteven Whitehouse 844ec69b188SSteven Whitehouse /** 845ec69b188SSteven Whitehouse * gfs2_logd - Update log tail as Active Items get flushed to in-place blocks 846ec69b188SSteven Whitehouse * @sdp: Pointer to GFS2 superblock 847ec69b188SSteven Whitehouse * 848ec69b188SSteven Whitehouse * Also, periodically check to make sure that we're using the most recent 849ec69b188SSteven Whitehouse * journal index. 850ec69b188SSteven Whitehouse */ 851ec69b188SSteven Whitehouse 852ec69b188SSteven Whitehouse int gfs2_logd(void *data) 853ec69b188SSteven Whitehouse { 854ec69b188SSteven Whitehouse struct gfs2_sbd *sdp = data; 8555e687eacSBenjamin Marzinski unsigned long t = 1; 8565e687eacSBenjamin Marzinski DEFINE_WAIT(wait); 8575e687eacSBenjamin Marzinski unsigned preflush; 858ec69b188SSteven Whitehouse 859ec69b188SSteven Whitehouse while (!kthread_should_stop()) { 860ec69b188SSteven Whitehouse 8615e687eacSBenjamin Marzinski preflush = atomic_read(&sdp->sd_log_pinned); 8625e687eacSBenjamin Marzinski if (gfs2_jrnl_flush_reqd(sdp) || t == 0) { 8634667a0ecSSteven Whitehouse gfs2_ail1_empty(sdp); 864ec69b188SSteven Whitehouse gfs2_log_flush(sdp, NULL); 865ec69b188SSteven Whitehouse } 866ec69b188SSteven Whitehouse 8675e687eacSBenjamin Marzinski if (gfs2_ail_flush_reqd(sdp)) { 8685e687eacSBenjamin Marzinski gfs2_ail1_start(sdp); 86926b06a69SSteven Whitehouse gfs2_ail1_wait(sdp); 8704667a0ecSSteven Whitehouse gfs2_ail1_empty(sdp); 8715e687eacSBenjamin Marzinski gfs2_log_flush(sdp, NULL); 8725e687eacSBenjamin Marzinski } 8735e687eacSBenjamin Marzinski 87426b06a69SSteven Whitehouse if (!gfs2_ail_flush_reqd(sdp)) 8755e687eacSBenjamin Marzinski wake_up(&sdp->sd_log_waitq); 87626b06a69SSteven Whitehouse 877ec69b188SSteven Whitehouse t = gfs2_tune_get(sdp, gt_logd_secs) * HZ; 878a0acae0eSTejun Heo 879a0acae0eSTejun Heo try_to_freeze(); 8805e687eacSBenjamin Marzinski 8815e687eacSBenjamin Marzinski do { 8825e687eacSBenjamin Marzinski prepare_to_wait(&sdp->sd_logd_waitq, &wait, 8835f487490SSteven Whitehouse TASK_INTERRUPTIBLE); 8845e687eacSBenjamin Marzinski if (!gfs2_ail_flush_reqd(sdp) && 8855e687eacSBenjamin Marzinski !gfs2_jrnl_flush_reqd(sdp) && 8865e687eacSBenjamin Marzinski !kthread_should_stop()) 8875e687eacSBenjamin Marzinski t = schedule_timeout(t); 8885e687eacSBenjamin Marzinski } while(t && !gfs2_ail_flush_reqd(sdp) && 8895e687eacSBenjamin Marzinski !gfs2_jrnl_flush_reqd(sdp) && 8905e687eacSBenjamin Marzinski !kthread_should_stop()); 8915e687eacSBenjamin Marzinski finish_wait(&sdp->sd_logd_waitq, &wait); 892ec69b188SSteven Whitehouse } 893ec69b188SSteven Whitehouse 894ec69b188SSteven Whitehouse return 0; 895ec69b188SSteven Whitehouse } 896ec69b188SSteven Whitehouse 897