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 /** 495b3b94faaSDavid Teigland * log_write_header - Get and initialize a journal header buffer 496b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 497b3b94faaSDavid Teigland * 498b3b94faaSDavid Teigland * Returns: the initialized log buffer descriptor 499b3b94faaSDavid Teigland */ 500b3b94faaSDavid Teigland 501cd915493SSteven Whitehouse static void log_write_header(struct gfs2_sbd *sdp, u32 flags, int pull) 502b3b94faaSDavid Teigland { 50347ac5537SSteven Whitehouse u64 blkno = gfs2_log_bmap(sdp, sdp->sd_log_flush_head); 504b3b94faaSDavid Teigland struct buffer_head *bh; 505b3b94faaSDavid Teigland struct gfs2_log_header *lh; 506b3b94faaSDavid Teigland unsigned int tail; 507cd915493SSteven Whitehouse u32 hash; 508b3b94faaSDavid Teigland 509b3b94faaSDavid Teigland bh = sb_getblk(sdp->sd_vfs, blkno); 510b3b94faaSDavid Teigland lock_buffer(bh); 511b3b94faaSDavid Teigland memset(bh->b_data, 0, bh->b_size); 512b3b94faaSDavid Teigland set_buffer_uptodate(bh); 513b3b94faaSDavid Teigland clear_buffer_dirty(bh); 514b3b94faaSDavid Teigland 5154667a0ecSSteven Whitehouse gfs2_ail1_empty(sdp); 516b3b94faaSDavid Teigland tail = current_tail(sdp); 517b3b94faaSDavid Teigland 518b3b94faaSDavid Teigland lh = (struct gfs2_log_header *)bh->b_data; 519b3b94faaSDavid Teigland memset(lh, 0, sizeof(struct gfs2_log_header)); 520b3b94faaSDavid Teigland lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 521e3167dedSSteven Whitehouse lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH); 5220ab7d13fSSteven Whitehouse lh->lh_header.__pad0 = cpu_to_be64(0); 523e3167dedSSteven Whitehouse lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH); 5240ab7d13fSSteven Whitehouse lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid); 525e0f2bf78SSteven Whitehouse lh->lh_sequence = cpu_to_be64(sdp->sd_log_sequence++); 526e0f2bf78SSteven Whitehouse lh->lh_flags = cpu_to_be32(flags); 527e0f2bf78SSteven Whitehouse lh->lh_tail = cpu_to_be32(tail); 528e0f2bf78SSteven Whitehouse lh->lh_blkno = cpu_to_be32(sdp->sd_log_flush_head); 529b3b94faaSDavid Teigland hash = gfs2_disk_hash(bh->b_data, sizeof(struct gfs2_log_header)); 530b3b94faaSDavid Teigland lh->lh_hash = cpu_to_be32(hash); 531b3b94faaSDavid Teigland 532254db57fSSteven Whitehouse bh->b_end_io = end_buffer_write_sync; 533f1e4d518SChristoph Hellwig get_bh(bh); 534254db57fSSteven Whitehouse if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags)) 53565299a3bSChristoph Hellwig submit_bh(WRITE_SYNC | REQ_META | REQ_PRIO, bh); 536f1e4d518SChristoph Hellwig else 53720ed0535SSteven Whitehouse submit_bh(WRITE_FLUSH_FUA | REQ_META, bh); 538254db57fSSteven Whitehouse wait_on_buffer(bh); 539f1e4d518SChristoph Hellwig 540254db57fSSteven Whitehouse if (!buffer_uptodate(bh)) 541b3b94faaSDavid Teigland gfs2_io_error_bh(sdp, bh); 542b3b94faaSDavid Teigland brelse(bh); 543b3b94faaSDavid Teigland 544b3b94faaSDavid Teigland if (sdp->sd_log_tail != tail) 5452332c443SRobert Peterson log_pull_tail(sdp, tail); 546b3b94faaSDavid Teigland else 547b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !pull); 548b3b94faaSDavid Teigland 549b3b94faaSDavid Teigland sdp->sd_log_idle = (tail == sdp->sd_log_flush_head); 55016615be1SSteven Whitehouse gfs2_log_incr_head(sdp); 551b3b94faaSDavid Teigland } 552b3b94faaSDavid Teigland 553b3b94faaSDavid Teigland static void log_flush_commit(struct gfs2_sbd *sdp) 554b3b94faaSDavid Teigland { 55516615be1SSteven Whitehouse DEFINE_WAIT(wait); 556b3b94faaSDavid Teigland 55716615be1SSteven Whitehouse if (atomic_read(&sdp->sd_log_in_flight)) { 55816615be1SSteven Whitehouse do { 55916615be1SSteven Whitehouse prepare_to_wait(&sdp->sd_log_flush_wait, &wait, 56016615be1SSteven Whitehouse TASK_UNINTERRUPTIBLE); 56116615be1SSteven Whitehouse if (atomic_read(&sdp->sd_log_in_flight)) 56216615be1SSteven Whitehouse io_schedule(); 56316615be1SSteven Whitehouse } while(atomic_read(&sdp->sd_log_in_flight)); 56416615be1SSteven Whitehouse finish_wait(&sdp->sd_log_flush_wait, &wait); 565b3b94faaSDavid Teigland } 566b3b94faaSDavid Teigland 567b3b94faaSDavid Teigland log_write_header(sdp, 0, 0); 568b3b94faaSDavid Teigland } 569b3b94faaSDavid Teigland 5704a36d08dSBob Peterson int bd_cmp(void *priv, struct list_head *a, struct list_head *b) 5714a36d08dSBob Peterson { 5724a36d08dSBob Peterson struct gfs2_bufdata *bda, *bdb; 5734a36d08dSBob Peterson 5744a36d08dSBob Peterson bda = list_entry(a, struct gfs2_bufdata, bd_le.le_list); 5754a36d08dSBob Peterson bdb = list_entry(b, struct gfs2_bufdata, bd_le.le_list); 5764a36d08dSBob Peterson 5774a36d08dSBob Peterson if (bda->bd_bh->b_blocknr < bdb->bd_bh->b_blocknr) 5784a36d08dSBob Peterson return -1; 5794a36d08dSBob Peterson if (bda->bd_bh->b_blocknr > bdb->bd_bh->b_blocknr) 5804a36d08dSBob Peterson return 1; 5814a36d08dSBob Peterson return 0; 5824a36d08dSBob Peterson } 5834a36d08dSBob Peterson 584d7b616e2SSteven Whitehouse static void gfs2_ordered_write(struct gfs2_sbd *sdp) 585d7b616e2SSteven Whitehouse { 586d7b616e2SSteven Whitehouse struct gfs2_bufdata *bd; 587d7b616e2SSteven Whitehouse struct buffer_head *bh; 588d7b616e2SSteven Whitehouse LIST_HEAD(written); 589d7b616e2SSteven Whitehouse 590d7b616e2SSteven Whitehouse gfs2_log_lock(sdp); 5914a36d08dSBob Peterson list_sort(NULL, &sdp->sd_log_le_ordered, &bd_cmp); 592d7b616e2SSteven Whitehouse while (!list_empty(&sdp->sd_log_le_ordered)) { 593d7b616e2SSteven Whitehouse bd = list_entry(sdp->sd_log_le_ordered.next, struct gfs2_bufdata, bd_le.le_list); 594d7b616e2SSteven Whitehouse list_move(&bd->bd_le.le_list, &written); 595d7b616e2SSteven Whitehouse bh = bd->bd_bh; 596d7b616e2SSteven Whitehouse if (!buffer_dirty(bh)) 597d7b616e2SSteven Whitehouse continue; 598d7b616e2SSteven Whitehouse get_bh(bh); 599d7b616e2SSteven Whitehouse gfs2_log_unlock(sdp); 600d7b616e2SSteven Whitehouse lock_buffer(bh); 601b8e7cbb6SSteven Whitehouse if (buffer_mapped(bh) && test_clear_buffer_dirty(bh)) { 602d7b616e2SSteven Whitehouse bh->b_end_io = end_buffer_write_sync; 603721a9602SJens Axboe submit_bh(WRITE_SYNC, bh); 604d7b616e2SSteven Whitehouse } else { 605d7b616e2SSteven Whitehouse unlock_buffer(bh); 606d7b616e2SSteven Whitehouse brelse(bh); 607d7b616e2SSteven Whitehouse } 608d7b616e2SSteven Whitehouse gfs2_log_lock(sdp); 609d7b616e2SSteven Whitehouse } 610d7b616e2SSteven Whitehouse list_splice(&written, &sdp->sd_log_le_ordered); 611d7b616e2SSteven Whitehouse gfs2_log_unlock(sdp); 612d7b616e2SSteven Whitehouse } 613d7b616e2SSteven Whitehouse 614d7b616e2SSteven Whitehouse static void gfs2_ordered_wait(struct gfs2_sbd *sdp) 615d7b616e2SSteven Whitehouse { 616d7b616e2SSteven Whitehouse struct gfs2_bufdata *bd; 617d7b616e2SSteven Whitehouse struct buffer_head *bh; 618d7b616e2SSteven Whitehouse 619d7b616e2SSteven Whitehouse gfs2_log_lock(sdp); 620d7b616e2SSteven Whitehouse while (!list_empty(&sdp->sd_log_le_ordered)) { 621d7b616e2SSteven Whitehouse bd = list_entry(sdp->sd_log_le_ordered.prev, struct gfs2_bufdata, bd_le.le_list); 622d7b616e2SSteven Whitehouse bh = bd->bd_bh; 623d7b616e2SSteven Whitehouse if (buffer_locked(bh)) { 624d7b616e2SSteven Whitehouse get_bh(bh); 625d7b616e2SSteven Whitehouse gfs2_log_unlock(sdp); 626d7b616e2SSteven Whitehouse wait_on_buffer(bh); 627d7b616e2SSteven Whitehouse brelse(bh); 628d7b616e2SSteven Whitehouse gfs2_log_lock(sdp); 629d7b616e2SSteven Whitehouse continue; 630d7b616e2SSteven Whitehouse } 631d7b616e2SSteven Whitehouse list_del_init(&bd->bd_le.le_list); 632d7b616e2SSteven Whitehouse } 633d7b616e2SSteven Whitehouse gfs2_log_unlock(sdp); 634d7b616e2SSteven Whitehouse } 635d7b616e2SSteven Whitehouse 636b3b94faaSDavid Teigland /** 637b09e593dSSteven Whitehouse * gfs2_log_flush - flush incore transaction(s) 638b3b94faaSDavid Teigland * @sdp: the filesystem 639b3b94faaSDavid Teigland * @gl: The glock structure to flush. If NULL, flush the whole incore log 640b3b94faaSDavid Teigland * 641b3b94faaSDavid Teigland */ 642b3b94faaSDavid Teigland 643ed4878e8SBob Peterson void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl) 644b3b94faaSDavid Teigland { 645b3b94faaSDavid Teigland struct gfs2_ail *ai; 646b3b94faaSDavid Teigland 647484adff8SSteven Whitehouse down_write(&sdp->sd_log_flush_lock); 648f55ab26aSSteven Whitehouse 6492bcd610dSSteven Whitehouse /* Log might have been flushed while we waited for the flush lock */ 6502bcd610dSSteven Whitehouse if (gl && !test_bit(GLF_LFLUSH, &gl->gl_flags)) { 651484adff8SSteven Whitehouse up_write(&sdp->sd_log_flush_lock); 652f55ab26aSSteven Whitehouse return; 653f55ab26aSSteven Whitehouse } 65463997775SSteven Whitehouse trace_gfs2_log_flush(sdp, 1); 655f55ab26aSSteven Whitehouse 656b09e593dSSteven Whitehouse ai = kzalloc(sizeof(struct gfs2_ail), GFP_NOFS | __GFP_NOFAIL); 657b09e593dSSteven Whitehouse INIT_LIST_HEAD(&ai->ai_ail1_list); 658b09e593dSSteven Whitehouse INIT_LIST_HEAD(&ai->ai_ail2_list); 659b3b94faaSDavid Teigland 66016615be1SSteven Whitehouse if (sdp->sd_log_num_buf != sdp->sd_log_commited_buf) { 66116615be1SSteven Whitehouse printk(KERN_INFO "GFS2: log buf %u %u\n", sdp->sd_log_num_buf, 66216615be1SSteven Whitehouse sdp->sd_log_commited_buf); 66316615be1SSteven Whitehouse gfs2_assert_withdraw(sdp, 0); 66416615be1SSteven Whitehouse } 66516615be1SSteven Whitehouse if (sdp->sd_log_num_databuf != sdp->sd_log_commited_databuf) { 66616615be1SSteven Whitehouse printk(KERN_INFO "GFS2: log databuf %u %u\n", 66716615be1SSteven Whitehouse sdp->sd_log_num_databuf, sdp->sd_log_commited_databuf); 66816615be1SSteven Whitehouse gfs2_assert_withdraw(sdp, 0); 66916615be1SSteven Whitehouse } 670b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, 671b3b94faaSDavid Teigland sdp->sd_log_num_revoke == sdp->sd_log_commited_revoke); 672b3b94faaSDavid Teigland 673b3b94faaSDavid Teigland sdp->sd_log_flush_head = sdp->sd_log_head; 674b3b94faaSDavid Teigland sdp->sd_log_flush_wrapped = 0; 675b3b94faaSDavid Teigland ai->ai_first = sdp->sd_log_flush_head; 676b3b94faaSDavid Teigland 677d7b616e2SSteven Whitehouse gfs2_ordered_write(sdp); 678b3b94faaSDavid Teigland lops_before_commit(sdp); 679d7b616e2SSteven Whitehouse gfs2_ordered_wait(sdp); 680d7b616e2SSteven Whitehouse 68116615be1SSteven Whitehouse if (sdp->sd_log_head != sdp->sd_log_flush_head) 682b3b94faaSDavid Teigland log_flush_commit(sdp); 6832332c443SRobert Peterson else if (sdp->sd_log_tail != current_tail(sdp) && !sdp->sd_log_idle){ 6842332c443SRobert Peterson gfs2_log_lock(sdp); 685fd041f0bSSteven Whitehouse atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */ 68663997775SSteven Whitehouse trace_gfs2_log_blocks(sdp, -1); 6872332c443SRobert Peterson gfs2_log_unlock(sdp); 688b3b94faaSDavid Teigland log_write_header(sdp, 0, PULL); 6892332c443SRobert Peterson } 690b3b94faaSDavid Teigland lops_after_commit(sdp, ai); 691fe1a698fSSteven Whitehouse 692fe1a698fSSteven Whitehouse gfs2_log_lock(sdp); 693b3b94faaSDavid Teigland sdp->sd_log_head = sdp->sd_log_flush_head; 694faa31ce8SSteven Whitehouse sdp->sd_log_blks_reserved = 0; 695faa31ce8SSteven Whitehouse sdp->sd_log_commited_buf = 0; 6962332c443SRobert Peterson sdp->sd_log_commited_databuf = 0; 697b3b94faaSDavid Teigland sdp->sd_log_commited_revoke = 0; 698b3b94faaSDavid Teigland 699d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 700b3b94faaSDavid Teigland if (!list_empty(&ai->ai_ail1_list)) { 701b3b94faaSDavid Teigland list_add(&ai->ai_list, &sdp->sd_ail1_list); 702b3b94faaSDavid Teigland ai = NULL; 703b3b94faaSDavid Teigland } 704d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 705b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 70663997775SSteven Whitehouse trace_gfs2_log_flush(sdp, 0); 707484adff8SSteven Whitehouse up_write(&sdp->sd_log_flush_lock); 708b3b94faaSDavid Teigland 709b3b94faaSDavid Teigland kfree(ai); 710b3b94faaSDavid Teigland } 711b3b94faaSDavid Teigland 712b3b94faaSDavid Teigland static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 713b3b94faaSDavid Teigland { 7142332c443SRobert Peterson unsigned int reserved; 715ac39aaddSSteven Whitehouse unsigned int unused; 716b3b94faaSDavid Teigland 717b3b94faaSDavid Teigland gfs2_log_lock(sdp); 718b3b94faaSDavid Teigland 719b3b94faaSDavid Teigland sdp->sd_log_commited_buf += tr->tr_num_buf_new - tr->tr_num_buf_rm; 7202332c443SRobert Peterson sdp->sd_log_commited_databuf += tr->tr_num_databuf_new - 7212332c443SRobert Peterson tr->tr_num_databuf_rm; 7222332c443SRobert Peterson gfs2_assert_withdraw(sdp, (((int)sdp->sd_log_commited_buf) >= 0) || 7232332c443SRobert Peterson (((int)sdp->sd_log_commited_databuf) >= 0)); 724b3b94faaSDavid Teigland sdp->sd_log_commited_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm; 7252332c443SRobert Peterson reserved = calc_reserved(sdp); 72662be1f71SRoel Kluin gfs2_assert_withdraw(sdp, sdp->sd_log_blks_reserved + tr->tr_reserved >= reserved); 727ac39aaddSSteven Whitehouse unused = sdp->sd_log_blks_reserved - reserved + tr->tr_reserved; 728ac39aaddSSteven Whitehouse atomic_add(unused, &sdp->sd_log_blks_free); 72963997775SSteven Whitehouse trace_gfs2_log_blocks(sdp, unused); 730fd041f0bSSteven Whitehouse gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <= 7312332c443SRobert Peterson sdp->sd_jdesc->jd_blocks); 732b3b94faaSDavid Teigland sdp->sd_log_blks_reserved = reserved; 733b3b94faaSDavid Teigland 734b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 735b3b94faaSDavid Teigland } 736b3b94faaSDavid Teigland 737d0109bfaSBob Peterson static void buf_lo_incore_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 738d0109bfaSBob Peterson { 739d0109bfaSBob Peterson struct list_head *head = &tr->tr_list_buf; 740d0109bfaSBob Peterson struct gfs2_bufdata *bd; 741d0109bfaSBob Peterson 742d0109bfaSBob Peterson gfs2_log_lock(sdp); 743d0109bfaSBob Peterson while (!list_empty(head)) { 744d0109bfaSBob Peterson bd = list_entry(head->next, struct gfs2_bufdata, bd_list_tr); 745d0109bfaSBob Peterson list_del_init(&bd->bd_list_tr); 746d0109bfaSBob Peterson tr->tr_num_buf--; 747d0109bfaSBob Peterson } 748d0109bfaSBob Peterson gfs2_log_unlock(sdp); 749d0109bfaSBob Peterson gfs2_assert_warn(sdp, !tr->tr_num_buf); 750d0109bfaSBob Peterson } 751d0109bfaSBob Peterson 752b3b94faaSDavid Teigland /** 753b3b94faaSDavid Teigland * gfs2_log_commit - Commit a transaction to the log 754b3b94faaSDavid Teigland * @sdp: the filesystem 755b3b94faaSDavid Teigland * @tr: the transaction 756b3b94faaSDavid Teigland * 7575e687eacSBenjamin Marzinski * We wake up gfs2_logd if the number of pinned blocks exceed thresh1 7585e687eacSBenjamin Marzinski * or the total number of used blocks (pinned blocks plus AIL blocks) 7595e687eacSBenjamin Marzinski * is greater than thresh2. 7605e687eacSBenjamin Marzinski * 7615e687eacSBenjamin Marzinski * At mount time thresh1 is 1/3rd of journal size, thresh2 is 2/3rd of 7625e687eacSBenjamin Marzinski * journal size. 7635e687eacSBenjamin Marzinski * 764b3b94faaSDavid Teigland * Returns: errno 765b3b94faaSDavid Teigland */ 766b3b94faaSDavid Teigland 767b3b94faaSDavid Teigland void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 768b3b94faaSDavid Teigland { 769b3b94faaSDavid Teigland log_refund(sdp, tr); 770d0109bfaSBob Peterson buf_lo_incore_commit(sdp, tr); 771b3b94faaSDavid Teigland 772484adff8SSteven Whitehouse up_read(&sdp->sd_log_flush_lock); 773b3b94faaSDavid Teigland 7745e687eacSBenjamin Marzinski if (atomic_read(&sdp->sd_log_pinned) > atomic_read(&sdp->sd_log_thresh1) || 7755e687eacSBenjamin Marzinski ((sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free)) > 7765e687eacSBenjamin Marzinski atomic_read(&sdp->sd_log_thresh2))) 7775e687eacSBenjamin Marzinski wake_up(&sdp->sd_logd_waitq); 778faa31ce8SSteven Whitehouse } 779b3b94faaSDavid Teigland 780b3b94faaSDavid Teigland /** 781b3b94faaSDavid Teigland * gfs2_log_shutdown - write a shutdown header into a journal 782b3b94faaSDavid Teigland * @sdp: the filesystem 783b3b94faaSDavid Teigland * 784b3b94faaSDavid Teigland */ 785b3b94faaSDavid Teigland 786b3b94faaSDavid Teigland void gfs2_log_shutdown(struct gfs2_sbd *sdp) 787b3b94faaSDavid Teigland { 788484adff8SSteven Whitehouse down_write(&sdp->sd_log_flush_lock); 789b3b94faaSDavid Teigland 790b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved); 791b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_buf); 792b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke); 793b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_rg); 794b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_databuf); 795b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list)); 796b3b94faaSDavid Teigland 797b3b94faaSDavid Teigland sdp->sd_log_flush_head = sdp->sd_log_head; 798b3b94faaSDavid Teigland sdp->sd_log_flush_wrapped = 0; 799b3b94faaSDavid Teigland 8002332c443SRobert Peterson log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT, 8012332c443SRobert Peterson (sdp->sd_log_tail == current_tail(sdp)) ? 0 : PULL); 802b3b94faaSDavid Teigland 803fd041f0bSSteven Whitehouse gfs2_assert_warn(sdp, atomic_read(&sdp->sd_log_blks_free) == sdp->sd_jdesc->jd_blocks); 804a74604beSSteven Whitehouse gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail); 805a74604beSSteven Whitehouse gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list)); 806b3b94faaSDavid Teigland 807b3b94faaSDavid Teigland sdp->sd_log_head = sdp->sd_log_flush_head; 808b3b94faaSDavid Teigland sdp->sd_log_tail = sdp->sd_log_head; 809b3b94faaSDavid Teigland 810484adff8SSteven Whitehouse up_write(&sdp->sd_log_flush_lock); 811b3b94faaSDavid Teigland } 812b3b94faaSDavid Teigland 813a25311c8SSteven Whitehouse 814a25311c8SSteven Whitehouse /** 815a25311c8SSteven Whitehouse * gfs2_meta_syncfs - sync all the buffers in a filesystem 816a25311c8SSteven Whitehouse * @sdp: the filesystem 817a25311c8SSteven Whitehouse * 818a25311c8SSteven Whitehouse */ 819a25311c8SSteven Whitehouse 820a25311c8SSteven Whitehouse void gfs2_meta_syncfs(struct gfs2_sbd *sdp) 821a25311c8SSteven Whitehouse { 822a25311c8SSteven Whitehouse gfs2_log_flush(sdp, NULL); 823a25311c8SSteven Whitehouse for (;;) { 8245e687eacSBenjamin Marzinski gfs2_ail1_start(sdp); 82526b06a69SSteven Whitehouse gfs2_ail1_wait(sdp); 8264667a0ecSSteven Whitehouse if (gfs2_ail1_empty(sdp)) 827a25311c8SSteven Whitehouse break; 828a25311c8SSteven Whitehouse } 829380f7c65SSteven Whitehouse gfs2_log_flush(sdp, NULL); 830a25311c8SSteven Whitehouse } 831a25311c8SSteven Whitehouse 8325e687eacSBenjamin Marzinski static inline int gfs2_jrnl_flush_reqd(struct gfs2_sbd *sdp) 8335e687eacSBenjamin Marzinski { 8345e687eacSBenjamin Marzinski return (atomic_read(&sdp->sd_log_pinned) >= atomic_read(&sdp->sd_log_thresh1)); 8355e687eacSBenjamin Marzinski } 8365e687eacSBenjamin Marzinski 8375e687eacSBenjamin Marzinski static inline int gfs2_ail_flush_reqd(struct gfs2_sbd *sdp) 8385e687eacSBenjamin Marzinski { 8395e687eacSBenjamin Marzinski unsigned int used_blocks = sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free); 8405e687eacSBenjamin Marzinski return used_blocks >= atomic_read(&sdp->sd_log_thresh2); 8415e687eacSBenjamin Marzinski } 842ec69b188SSteven Whitehouse 843ec69b188SSteven Whitehouse /** 844ec69b188SSteven Whitehouse * gfs2_logd - Update log tail as Active Items get flushed to in-place blocks 845ec69b188SSteven Whitehouse * @sdp: Pointer to GFS2 superblock 846ec69b188SSteven Whitehouse * 847ec69b188SSteven Whitehouse * Also, periodically check to make sure that we're using the most recent 848ec69b188SSteven Whitehouse * journal index. 849ec69b188SSteven Whitehouse */ 850ec69b188SSteven Whitehouse 851ec69b188SSteven Whitehouse int gfs2_logd(void *data) 852ec69b188SSteven Whitehouse { 853ec69b188SSteven Whitehouse struct gfs2_sbd *sdp = data; 8545e687eacSBenjamin Marzinski unsigned long t = 1; 8555e687eacSBenjamin Marzinski DEFINE_WAIT(wait); 8565e687eacSBenjamin Marzinski unsigned preflush; 857ec69b188SSteven Whitehouse 858ec69b188SSteven Whitehouse while (!kthread_should_stop()) { 859ec69b188SSteven Whitehouse 8605e687eacSBenjamin Marzinski preflush = atomic_read(&sdp->sd_log_pinned); 8615e687eacSBenjamin Marzinski if (gfs2_jrnl_flush_reqd(sdp) || t == 0) { 8624667a0ecSSteven Whitehouse gfs2_ail1_empty(sdp); 863ec69b188SSteven Whitehouse gfs2_log_flush(sdp, NULL); 864ec69b188SSteven Whitehouse } 865ec69b188SSteven Whitehouse 8665e687eacSBenjamin Marzinski if (gfs2_ail_flush_reqd(sdp)) { 8675e687eacSBenjamin Marzinski gfs2_ail1_start(sdp); 86826b06a69SSteven Whitehouse gfs2_ail1_wait(sdp); 8694667a0ecSSteven Whitehouse gfs2_ail1_empty(sdp); 8705e687eacSBenjamin Marzinski gfs2_log_flush(sdp, NULL); 8715e687eacSBenjamin Marzinski } 8725e687eacSBenjamin Marzinski 87326b06a69SSteven Whitehouse if (!gfs2_ail_flush_reqd(sdp)) 8745e687eacSBenjamin Marzinski wake_up(&sdp->sd_log_waitq); 87526b06a69SSteven Whitehouse 876ec69b188SSteven Whitehouse t = gfs2_tune_get(sdp, gt_logd_secs) * HZ; 877a0acae0eSTejun Heo 878a0acae0eSTejun Heo try_to_freeze(); 8795e687eacSBenjamin Marzinski 8805e687eacSBenjamin Marzinski do { 8815e687eacSBenjamin Marzinski prepare_to_wait(&sdp->sd_logd_waitq, &wait, 8825f487490SSteven Whitehouse TASK_INTERRUPTIBLE); 8835e687eacSBenjamin Marzinski if (!gfs2_ail_flush_reqd(sdp) && 8845e687eacSBenjamin Marzinski !gfs2_jrnl_flush_reqd(sdp) && 8855e687eacSBenjamin Marzinski !kthread_should_stop()) 8865e687eacSBenjamin Marzinski t = schedule_timeout(t); 8875e687eacSBenjamin Marzinski } while(t && !gfs2_ail_flush_reqd(sdp) && 8885e687eacSBenjamin Marzinski !gfs2_jrnl_flush_reqd(sdp) && 8895e687eacSBenjamin Marzinski !kthread_should_stop()); 8905e687eacSBenjamin Marzinski finish_wait(&sdp->sd_logd_waitq, &wait); 891ec69b188SSteven Whitehouse } 892ec69b188SSteven Whitehouse 893ec69b188SSteven Whitehouse return 0; 894ec69b188SSteven Whitehouse } 895ec69b188SSteven Whitehouse 896