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> 21*4667a0ecSSteven Whitehouse #include <linux/writeback.h> 22b3b94faaSDavid Teigland 23b3b94faaSDavid Teigland #include "gfs2.h" 245c676f6dSSteven Whitehouse #include "incore.h" 25b3b94faaSDavid Teigland #include "bmap.h" 26b3b94faaSDavid Teigland #include "glock.h" 27b3b94faaSDavid Teigland #include "log.h" 28b3b94faaSDavid Teigland #include "lops.h" 29b3b94faaSDavid Teigland #include "meta_io.h" 305c676f6dSSteven Whitehouse #include "util.h" 3171b86f56SSteven Whitehouse #include "dir.h" 3263997775SSteven Whitehouse #include "trace_gfs2.h" 33b3b94faaSDavid Teigland 34b3b94faaSDavid Teigland #define PULL 1 35b3b94faaSDavid Teigland 36b3b94faaSDavid Teigland /** 37b3b94faaSDavid Teigland * gfs2_struct2blk - compute stuff 38b3b94faaSDavid Teigland * @sdp: the filesystem 39b3b94faaSDavid Teigland * @nstruct: the number of structures 40b3b94faaSDavid Teigland * @ssize: the size of the structures 41b3b94faaSDavid Teigland * 42b3b94faaSDavid Teigland * Compute the number of log descriptor blocks needed to hold a certain number 43b3b94faaSDavid Teigland * of structures of a certain size. 44b3b94faaSDavid Teigland * 45b3b94faaSDavid Teigland * Returns: the number of blocks needed (minimum is always 1) 46b3b94faaSDavid Teigland */ 47b3b94faaSDavid Teigland 48b3b94faaSDavid Teigland unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct, 49b3b94faaSDavid Teigland unsigned int ssize) 50b3b94faaSDavid Teigland { 51b3b94faaSDavid Teigland unsigned int blks; 52b3b94faaSDavid Teigland unsigned int first, second; 53b3b94faaSDavid Teigland 54b3b94faaSDavid Teigland blks = 1; 55faa31ce8SSteven Whitehouse first = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_log_descriptor)) / ssize; 56b3b94faaSDavid Teigland 57b3b94faaSDavid Teigland if (nstruct > first) { 58568f4c96SSteven Whitehouse second = (sdp->sd_sb.sb_bsize - 59568f4c96SSteven Whitehouse sizeof(struct gfs2_meta_header)) / ssize; 605c676f6dSSteven Whitehouse blks += DIV_ROUND_UP(nstruct - first, second); 61b3b94faaSDavid Teigland } 62b3b94faaSDavid Teigland 63b3b94faaSDavid Teigland return blks; 64b3b94faaSDavid Teigland } 65b3b94faaSDavid Teigland 66ddacfaf7SSteven Whitehouse /** 671e1a3d03SSteven Whitehouse * gfs2_remove_from_ail - Remove an entry from the ail lists, updating counters 681e1a3d03SSteven Whitehouse * @mapping: The associated mapping (maybe NULL) 691e1a3d03SSteven Whitehouse * @bd: The gfs2_bufdata to remove 701e1a3d03SSteven Whitehouse * 71c618e87aSSteven Whitehouse * The ail lock _must_ be held when calling this function 721e1a3d03SSteven Whitehouse * 731e1a3d03SSteven Whitehouse */ 741e1a3d03SSteven Whitehouse 75f91a0d3eSSteven Whitehouse void gfs2_remove_from_ail(struct gfs2_bufdata *bd) 761e1a3d03SSteven Whitehouse { 771e1a3d03SSteven Whitehouse bd->bd_ail = NULL; 781ad38c43SSteven Whitehouse list_del_init(&bd->bd_ail_st_list); 791ad38c43SSteven Whitehouse list_del_init(&bd->bd_ail_gl_list); 801e1a3d03SSteven Whitehouse atomic_dec(&bd->bd_gl->gl_ail_count); 811e1a3d03SSteven Whitehouse brelse(bd->bd_bh); 821e1a3d03SSteven Whitehouse } 831e1a3d03SSteven Whitehouse 841e1a3d03SSteven Whitehouse /** 85ddacfaf7SSteven Whitehouse * gfs2_ail1_start_one - Start I/O on a part of the AIL 86ddacfaf7SSteven Whitehouse * @sdp: the filesystem 87*4667a0ecSSteven Whitehouse * @wbc: The writeback control structure 88*4667a0ecSSteven Whitehouse * @ai: The ail structure 89ddacfaf7SSteven Whitehouse * 90ddacfaf7SSteven Whitehouse */ 91ddacfaf7SSteven Whitehouse 92*4667a0ecSSteven Whitehouse static void gfs2_ail1_start_one(struct gfs2_sbd *sdp, 93*4667a0ecSSteven Whitehouse struct writeback_control *wbc, 94*4667a0ecSSteven Whitehouse struct gfs2_ail *ai) 95d6a079e8SDave Chinner __releases(&sdp->sd_ail_lock) 96d6a079e8SDave Chinner __acquires(&sdp->sd_ail_lock) 97ddacfaf7SSteven Whitehouse { 985ac048bbSSteven Whitehouse struct gfs2_glock *gl = NULL; 99*4667a0ecSSteven Whitehouse struct address_space *mapping; 100ddacfaf7SSteven Whitehouse struct gfs2_bufdata *bd, *s; 101ddacfaf7SSteven Whitehouse struct buffer_head *bh; 102ddacfaf7SSteven Whitehouse 103*4667a0ecSSteven Whitehouse restart: 104*4667a0ecSSteven 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); 122*4667a0ecSSteven Whitehouse mapping = bh->b_page->mapping; 123d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 124*4667a0ecSSteven Whitehouse generic_writepages(mapping, wbc); 125d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 126*4667a0ecSSteven Whitehouse if (wbc->nr_to_write <= 0) 127ddacfaf7SSteven Whitehouse break; 128*4667a0ecSSteven Whitehouse goto restart; 129ddacfaf7SSteven Whitehouse } 130*4667a0ecSSteven Whitehouse } 131*4667a0ecSSteven Whitehouse 132*4667a0ecSSteven Whitehouse 133*4667a0ecSSteven Whitehouse /** 134*4667a0ecSSteven Whitehouse * gfs2_ail1_flush - start writeback of some ail1 entries 135*4667a0ecSSteven Whitehouse * @sdp: The super block 136*4667a0ecSSteven Whitehouse * @wbc: The writeback control structure 137*4667a0ecSSteven Whitehouse * 138*4667a0ecSSteven Whitehouse * Writes back some ail1 entries, according to the limits in the 139*4667a0ecSSteven Whitehouse * writeback control structure 140*4667a0ecSSteven Whitehouse */ 141*4667a0ecSSteven Whitehouse 142*4667a0ecSSteven Whitehouse void gfs2_ail1_flush(struct gfs2_sbd *sdp, struct writeback_control *wbc) 143*4667a0ecSSteven Whitehouse { 144*4667a0ecSSteven Whitehouse struct list_head *head = &sdp->sd_ail1_list; 145*4667a0ecSSteven Whitehouse struct gfs2_ail *ai; 146*4667a0ecSSteven Whitehouse 147*4667a0ecSSteven Whitehouse spin_lock(&sdp->sd_ail_lock); 148*4667a0ecSSteven Whitehouse list_for_each_entry_reverse(ai, head, ai_list) { 149*4667a0ecSSteven Whitehouse if (wbc->nr_to_write <= 0) 150*4667a0ecSSteven Whitehouse break; 151*4667a0ecSSteven Whitehouse gfs2_ail1_start_one(sdp, wbc, ai); /* This may drop ail lock */ 152*4667a0ecSSteven Whitehouse } 153*4667a0ecSSteven Whitehouse spin_unlock(&sdp->sd_ail_lock); 154*4667a0ecSSteven Whitehouse } 155*4667a0ecSSteven Whitehouse 156*4667a0ecSSteven Whitehouse /** 157*4667a0ecSSteven Whitehouse * gfs2_ail1_start - start writeback of all ail1 entries 158*4667a0ecSSteven Whitehouse * @sdp: The superblock 159*4667a0ecSSteven Whitehouse */ 160*4667a0ecSSteven Whitehouse 161*4667a0ecSSteven Whitehouse static void gfs2_ail1_start(struct gfs2_sbd *sdp) 162*4667a0ecSSteven Whitehouse { 163*4667a0ecSSteven Whitehouse struct writeback_control wbc = { 164*4667a0ecSSteven Whitehouse .sync_mode = WB_SYNC_NONE, 165*4667a0ecSSteven Whitehouse .nr_to_write = LONG_MAX, 166*4667a0ecSSteven Whitehouse .range_start = 0, 167*4667a0ecSSteven Whitehouse .range_end = LLONG_MAX, 168*4667a0ecSSteven Whitehouse }; 169*4667a0ecSSteven Whitehouse 170*4667a0ecSSteven Whitehouse return gfs2_ail1_flush(sdp, &wbc); 171ddacfaf7SSteven Whitehouse } 172ddacfaf7SSteven Whitehouse 173ddacfaf7SSteven Whitehouse /** 174ddacfaf7SSteven Whitehouse * gfs2_ail1_empty_one - Check whether or not a trans in the AIL has been synced 175ddacfaf7SSteven Whitehouse * @sdp: the filesystem 176ddacfaf7SSteven Whitehouse * @ai: the AIL entry 177ddacfaf7SSteven Whitehouse * 178ddacfaf7SSteven Whitehouse */ 179ddacfaf7SSteven Whitehouse 180*4667a0ecSSteven Whitehouse static void gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai) 181ddacfaf7SSteven Whitehouse { 182ddacfaf7SSteven Whitehouse struct gfs2_bufdata *bd, *s; 183ddacfaf7SSteven Whitehouse struct buffer_head *bh; 184ddacfaf7SSteven Whitehouse 185ddacfaf7SSteven Whitehouse list_for_each_entry_safe_reverse(bd, s, &ai->ai_ail1_list, 186ddacfaf7SSteven Whitehouse bd_ail_st_list) { 187ddacfaf7SSteven Whitehouse bh = bd->bd_bh; 188ddacfaf7SSteven Whitehouse gfs2_assert(sdp, bd->bd_ail == ai); 189*4667a0ecSSteven Whitehouse if (buffer_busy(bh)) 190ddacfaf7SSteven Whitehouse continue; 191ddacfaf7SSteven Whitehouse if (!buffer_uptodate(bh)) 192ddacfaf7SSteven Whitehouse gfs2_io_error_bh(sdp, bh); 193ddacfaf7SSteven Whitehouse list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list); 194ddacfaf7SSteven Whitehouse } 195ddacfaf7SSteven Whitehouse 196ddacfaf7SSteven Whitehouse } 197ddacfaf7SSteven Whitehouse 198*4667a0ecSSteven Whitehouse /** 199*4667a0ecSSteven Whitehouse * gfs2_ail1_empty - Try to empty the ail1 lists 200*4667a0ecSSteven Whitehouse * @sdp: The superblock 201*4667a0ecSSteven Whitehouse * 202*4667a0ecSSteven Whitehouse * Tries to empty the ail1 lists, starting with the oldest first 203*4667a0ecSSteven Whitehouse */ 204b3b94faaSDavid Teigland 205*4667a0ecSSteven Whitehouse static int gfs2_ail1_empty(struct gfs2_sbd *sdp) 206b3b94faaSDavid Teigland { 207b3b94faaSDavid Teigland struct gfs2_ail *ai, *s; 208b3b94faaSDavid Teigland int ret; 209b3b94faaSDavid Teigland 210d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 211b3b94faaSDavid Teigland list_for_each_entry_safe_reverse(ai, s, &sdp->sd_ail1_list, ai_list) { 212*4667a0ecSSteven Whitehouse gfs2_ail1_empty_one(sdp, ai); 213*4667a0ecSSteven Whitehouse if (list_empty(&ai->ai_ail1_list)) 214b3b94faaSDavid Teigland list_move(&ai->ai_list, &sdp->sd_ail2_list); 215*4667a0ecSSteven Whitehouse else 216b3b94faaSDavid Teigland break; 217b3b94faaSDavid Teigland } 218b3b94faaSDavid Teigland ret = list_empty(&sdp->sd_ail1_list); 219d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 220b3b94faaSDavid Teigland 221b3b94faaSDavid Teigland return ret; 222b3b94faaSDavid Teigland } 223b3b94faaSDavid Teigland 224ddacfaf7SSteven Whitehouse 225ddacfaf7SSteven Whitehouse /** 226ddacfaf7SSteven Whitehouse * gfs2_ail2_empty_one - Check whether or not a trans in the AIL has been synced 227ddacfaf7SSteven Whitehouse * @sdp: the filesystem 228ddacfaf7SSteven Whitehouse * @ai: the AIL entry 229ddacfaf7SSteven Whitehouse * 230ddacfaf7SSteven Whitehouse */ 231ddacfaf7SSteven Whitehouse 232ddacfaf7SSteven Whitehouse static void gfs2_ail2_empty_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai) 233ddacfaf7SSteven Whitehouse { 234ddacfaf7SSteven Whitehouse struct list_head *head = &ai->ai_ail2_list; 235ddacfaf7SSteven Whitehouse struct gfs2_bufdata *bd; 236ddacfaf7SSteven Whitehouse 237ddacfaf7SSteven Whitehouse while (!list_empty(head)) { 238ddacfaf7SSteven Whitehouse bd = list_entry(head->prev, struct gfs2_bufdata, 239ddacfaf7SSteven Whitehouse bd_ail_st_list); 240ddacfaf7SSteven Whitehouse gfs2_assert(sdp, bd->bd_ail == ai); 241f91a0d3eSSteven Whitehouse gfs2_remove_from_ail(bd); 242ddacfaf7SSteven Whitehouse } 243ddacfaf7SSteven Whitehouse } 244ddacfaf7SSteven Whitehouse 245b3b94faaSDavid Teigland static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail) 246b3b94faaSDavid Teigland { 247b3b94faaSDavid Teigland struct gfs2_ail *ai, *safe; 248b3b94faaSDavid Teigland unsigned int old_tail = sdp->sd_log_tail; 249b3b94faaSDavid Teigland int wrap = (new_tail < old_tail); 250b3b94faaSDavid Teigland int a, b, rm; 251b3b94faaSDavid Teigland 252d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 253b3b94faaSDavid Teigland 254b3b94faaSDavid Teigland list_for_each_entry_safe(ai, safe, &sdp->sd_ail2_list, ai_list) { 255b3b94faaSDavid Teigland a = (old_tail <= ai->ai_first); 256b3b94faaSDavid Teigland b = (ai->ai_first < new_tail); 257b3b94faaSDavid Teigland rm = (wrap) ? (a || b) : (a && b); 258b3b94faaSDavid Teigland if (!rm) 259b3b94faaSDavid Teigland continue; 260b3b94faaSDavid Teigland 261b3b94faaSDavid Teigland gfs2_ail2_empty_one(sdp, ai); 262b3b94faaSDavid Teigland list_del(&ai->ai_list); 263b3b94faaSDavid Teigland gfs2_assert_warn(sdp, list_empty(&ai->ai_ail1_list)); 264b3b94faaSDavid Teigland gfs2_assert_warn(sdp, list_empty(&ai->ai_ail2_list)); 265b3b94faaSDavid Teigland kfree(ai); 266b3b94faaSDavid Teigland } 267b3b94faaSDavid Teigland 268d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 269b3b94faaSDavid Teigland } 270b3b94faaSDavid Teigland 271b3b94faaSDavid Teigland /** 272b3b94faaSDavid Teigland * gfs2_log_reserve - Make a log reservation 273b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 274b3b94faaSDavid Teigland * @blks: The number of blocks to reserve 275b3b94faaSDavid Teigland * 27689918647SSteven Whitehouse * Note that we never give out the last few blocks of the journal. Thats 2772332c443SRobert Peterson * due to the fact that there is a small number of header blocks 278b004157aSSteven Whitehouse * associated with each log flush. The exact number can't be known until 279b004157aSSteven Whitehouse * flush time, so we ensure that we have just enough free blocks at all 280b004157aSSteven Whitehouse * times to avoid running out during a log flush. 281b004157aSSteven Whitehouse * 2825e687eacSBenjamin Marzinski * We no longer flush the log here, instead we wake up logd to do that 2835e687eacSBenjamin Marzinski * for us. To avoid the thundering herd and to ensure that we deal fairly 2845e687eacSBenjamin Marzinski * with queued waiters, we use an exclusive wait. This means that when we 2855e687eacSBenjamin Marzinski * get woken with enough journal space to get our reservation, we need to 2865e687eacSBenjamin Marzinski * wake the next waiter on the list. 2875e687eacSBenjamin Marzinski * 288b3b94faaSDavid Teigland * Returns: errno 289b3b94faaSDavid Teigland */ 290b3b94faaSDavid Teigland 291b3b94faaSDavid Teigland int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks) 292b3b94faaSDavid Teigland { 29389918647SSteven Whitehouse unsigned reserved_blks = 6 * (4096 / sdp->sd_vfs->s_blocksize); 2945e687eacSBenjamin Marzinski unsigned wanted = blks + reserved_blks; 2955e687eacSBenjamin Marzinski DEFINE_WAIT(wait); 2965e687eacSBenjamin Marzinski int did_wait = 0; 2975e687eacSBenjamin Marzinski unsigned int free_blocks; 298b3b94faaSDavid Teigland 299b3b94faaSDavid Teigland if (gfs2_assert_warn(sdp, blks) || 300b3b94faaSDavid Teigland gfs2_assert_warn(sdp, blks <= sdp->sd_jdesc->jd_blocks)) 301b3b94faaSDavid Teigland return -EINVAL; 3025e687eacSBenjamin Marzinski retry: 3035e687eacSBenjamin Marzinski free_blocks = atomic_read(&sdp->sd_log_blks_free); 3045e687eacSBenjamin Marzinski if (unlikely(free_blocks <= wanted)) { 3055e687eacSBenjamin Marzinski do { 3065e687eacSBenjamin Marzinski prepare_to_wait_exclusive(&sdp->sd_log_waitq, &wait, 3075e687eacSBenjamin Marzinski TASK_UNINTERRUPTIBLE); 3085e687eacSBenjamin Marzinski wake_up(&sdp->sd_logd_waitq); 3095e687eacSBenjamin Marzinski did_wait = 1; 3105e687eacSBenjamin Marzinski if (atomic_read(&sdp->sd_log_blks_free) <= wanted) 3115e687eacSBenjamin Marzinski io_schedule(); 3125e687eacSBenjamin Marzinski free_blocks = atomic_read(&sdp->sd_log_blks_free); 3135e687eacSBenjamin Marzinski } while(free_blocks <= wanted); 3145e687eacSBenjamin Marzinski finish_wait(&sdp->sd_log_waitq, &wait); 315b3b94faaSDavid Teigland } 3165e687eacSBenjamin Marzinski if (atomic_cmpxchg(&sdp->sd_log_blks_free, free_blocks, 3175e687eacSBenjamin Marzinski free_blocks - blks) != free_blocks) 3185e687eacSBenjamin Marzinski goto retry; 31963997775SSteven Whitehouse trace_gfs2_log_blocks(sdp, -blks); 3205e687eacSBenjamin Marzinski 3215e687eacSBenjamin Marzinski /* 3225e687eacSBenjamin Marzinski * If we waited, then so might others, wake them up _after_ we get 3235e687eacSBenjamin Marzinski * our share of the log. 3245e687eacSBenjamin Marzinski */ 3255e687eacSBenjamin Marzinski if (unlikely(did_wait)) 3265e687eacSBenjamin Marzinski wake_up(&sdp->sd_log_waitq); 327484adff8SSteven Whitehouse 328484adff8SSteven Whitehouse down_read(&sdp->sd_log_flush_lock); 329b3b94faaSDavid Teigland 330b3b94faaSDavid Teigland return 0; 331b3b94faaSDavid Teigland } 332b3b94faaSDavid Teigland 333cd915493SSteven Whitehouse static u64 log_bmap(struct gfs2_sbd *sdp, unsigned int lbn) 334b3b94faaSDavid Teigland { 335da6dd40dSBob Peterson struct gfs2_journal_extent *je; 336b3b94faaSDavid Teigland 337da6dd40dSBob Peterson list_for_each_entry(je, &sdp->sd_jdesc->extent_list, extent_list) { 338da6dd40dSBob Peterson if (lbn >= je->lblock && lbn < je->lblock + je->blocks) 339ff91cc9bSSteven Whitehouse return je->dblock + lbn - je->lblock; 340da6dd40dSBob Peterson } 341b3b94faaSDavid Teigland 342da6dd40dSBob Peterson return -1; 343b3b94faaSDavid Teigland } 344b3b94faaSDavid Teigland 345b3b94faaSDavid Teigland /** 346b3b94faaSDavid Teigland * log_distance - Compute distance between two journal blocks 347b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 348b3b94faaSDavid Teigland * @newer: The most recent journal block of the pair 349b3b94faaSDavid Teigland * @older: The older journal block of the pair 350b3b94faaSDavid Teigland * 351b3b94faaSDavid Teigland * Compute the distance (in the journal direction) between two 352b3b94faaSDavid Teigland * blocks in the journal 353b3b94faaSDavid Teigland * 354b3b94faaSDavid Teigland * Returns: the distance in blocks 355b3b94faaSDavid Teigland */ 356b3b94faaSDavid Teigland 357faa31ce8SSteven Whitehouse static inline unsigned int log_distance(struct gfs2_sbd *sdp, unsigned int newer, 358b3b94faaSDavid Teigland unsigned int older) 359b3b94faaSDavid Teigland { 360b3b94faaSDavid Teigland int dist; 361b3b94faaSDavid Teigland 362b3b94faaSDavid Teigland dist = newer - older; 363b3b94faaSDavid Teigland if (dist < 0) 364b3b94faaSDavid Teigland dist += sdp->sd_jdesc->jd_blocks; 365b3b94faaSDavid Teigland 366b3b94faaSDavid Teigland return dist; 367b3b94faaSDavid Teigland } 368b3b94faaSDavid Teigland 3692332c443SRobert Peterson /** 3702332c443SRobert Peterson * calc_reserved - Calculate the number of blocks to reserve when 3712332c443SRobert Peterson * refunding a transaction's unused buffers. 3722332c443SRobert Peterson * @sdp: The GFS2 superblock 3732332c443SRobert Peterson * 3742332c443SRobert Peterson * This is complex. We need to reserve room for all our currently used 3752332c443SRobert Peterson * metadata buffers (e.g. normal file I/O rewriting file time stamps) and 3762332c443SRobert Peterson * all our journaled data buffers for journaled files (e.g. files in the 3772332c443SRobert Peterson * meta_fs like rindex, or files for which chattr +j was done.) 3782332c443SRobert Peterson * If we don't reserve enough space, gfs2_log_refund and gfs2_log_flush 3792332c443SRobert Peterson * will count it as free space (sd_log_blks_free) and corruption will follow. 3802332c443SRobert Peterson * 3812332c443SRobert Peterson * We can have metadata bufs and jdata bufs in the same journal. So each 3822332c443SRobert Peterson * type gets its own log header, for which we need to reserve a block. 3832332c443SRobert Peterson * In fact, each type has the potential for needing more than one header 3842332c443SRobert Peterson * in cases where we have more buffers than will fit on a journal page. 3852332c443SRobert Peterson * Metadata journal entries take up half the space of journaled buffer entries. 3862332c443SRobert Peterson * Thus, metadata entries have buf_limit (502) and journaled buffers have 3872332c443SRobert Peterson * databuf_limit (251) before they cause a wrap around. 3882332c443SRobert Peterson * 3892332c443SRobert Peterson * Also, we need to reserve blocks for revoke journal entries and one for an 3902332c443SRobert Peterson * overall header for the lot. 3912332c443SRobert Peterson * 3922332c443SRobert Peterson * Returns: the number of blocks reserved 3932332c443SRobert Peterson */ 3942332c443SRobert Peterson static unsigned int calc_reserved(struct gfs2_sbd *sdp) 3952332c443SRobert Peterson { 3962332c443SRobert Peterson unsigned int reserved = 0; 3972332c443SRobert Peterson unsigned int mbuf_limit, metabufhdrs_needed; 3982332c443SRobert Peterson unsigned int dbuf_limit, databufhdrs_needed; 3992332c443SRobert Peterson unsigned int revokes = 0; 4002332c443SRobert Peterson 4012332c443SRobert Peterson mbuf_limit = buf_limit(sdp); 4022332c443SRobert Peterson metabufhdrs_needed = (sdp->sd_log_commited_buf + 4032332c443SRobert Peterson (mbuf_limit - 1)) / mbuf_limit; 4042332c443SRobert Peterson dbuf_limit = databuf_limit(sdp); 4052332c443SRobert Peterson databufhdrs_needed = (sdp->sd_log_commited_databuf + 4062332c443SRobert Peterson (dbuf_limit - 1)) / dbuf_limit; 4072332c443SRobert Peterson 4082e95e3f6SBenjamin Marzinski if (sdp->sd_log_commited_revoke > 0) 4092332c443SRobert Peterson revokes = gfs2_struct2blk(sdp, sdp->sd_log_commited_revoke, 4102332c443SRobert Peterson sizeof(u64)); 4112332c443SRobert Peterson 4122332c443SRobert Peterson reserved = sdp->sd_log_commited_buf + metabufhdrs_needed + 4132332c443SRobert Peterson sdp->sd_log_commited_databuf + databufhdrs_needed + 4142332c443SRobert Peterson revokes; 4152332c443SRobert Peterson /* One for the overall header */ 4162332c443SRobert Peterson if (reserved) 4172332c443SRobert Peterson reserved++; 4182332c443SRobert Peterson return reserved; 4192332c443SRobert Peterson } 4202332c443SRobert Peterson 421b3b94faaSDavid Teigland static unsigned int current_tail(struct gfs2_sbd *sdp) 422b3b94faaSDavid Teigland { 423b3b94faaSDavid Teigland struct gfs2_ail *ai; 424b3b94faaSDavid Teigland unsigned int tail; 425b3b94faaSDavid Teigland 426d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 427b3b94faaSDavid Teigland 428faa31ce8SSteven Whitehouse if (list_empty(&sdp->sd_ail1_list)) { 429b3b94faaSDavid Teigland tail = sdp->sd_log_head; 430faa31ce8SSteven Whitehouse } else { 431faa31ce8SSteven Whitehouse ai = list_entry(sdp->sd_ail1_list.prev, struct gfs2_ail, ai_list); 432b3b94faaSDavid Teigland tail = ai->ai_first; 433b3b94faaSDavid Teigland } 434b3b94faaSDavid Teigland 435d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 436b3b94faaSDavid Teigland 437b3b94faaSDavid Teigland return tail; 438b3b94faaSDavid Teigland } 439b3b94faaSDavid Teigland 44016615be1SSteven Whitehouse void gfs2_log_incr_head(struct gfs2_sbd *sdp) 441b3b94faaSDavid Teigland { 442b3b94faaSDavid Teigland if (sdp->sd_log_flush_head == sdp->sd_log_tail) 44316615be1SSteven Whitehouse BUG_ON(sdp->sd_log_flush_head != sdp->sd_log_head); 444b3b94faaSDavid Teigland 445b3b94faaSDavid Teigland if (++sdp->sd_log_flush_head == sdp->sd_jdesc->jd_blocks) { 446b3b94faaSDavid Teigland sdp->sd_log_flush_head = 0; 447b3b94faaSDavid Teigland sdp->sd_log_flush_wrapped = 1; 448b3b94faaSDavid Teigland } 449b3b94faaSDavid Teigland } 450b3b94faaSDavid Teigland 451b3b94faaSDavid Teigland /** 45216615be1SSteven Whitehouse * gfs2_log_write_endio - End of I/O for a log buffer 45316615be1SSteven Whitehouse * @bh: The buffer head 45416615be1SSteven Whitehouse * @uptodate: I/O Status 45516615be1SSteven Whitehouse * 45616615be1SSteven Whitehouse */ 45716615be1SSteven Whitehouse 45816615be1SSteven Whitehouse static void gfs2_log_write_endio(struct buffer_head *bh, int uptodate) 45916615be1SSteven Whitehouse { 46016615be1SSteven Whitehouse struct gfs2_sbd *sdp = bh->b_private; 46116615be1SSteven Whitehouse bh->b_private = NULL; 46216615be1SSteven Whitehouse 46316615be1SSteven Whitehouse end_buffer_write_sync(bh, uptodate); 46416615be1SSteven Whitehouse if (atomic_dec_and_test(&sdp->sd_log_in_flight)) 46516615be1SSteven Whitehouse wake_up(&sdp->sd_log_flush_wait); 46616615be1SSteven Whitehouse } 46716615be1SSteven Whitehouse 46816615be1SSteven Whitehouse /** 469b3b94faaSDavid Teigland * gfs2_log_get_buf - Get and initialize a buffer to use for log control data 470b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 471b3b94faaSDavid Teigland * 472b3b94faaSDavid Teigland * Returns: the buffer_head 473b3b94faaSDavid Teigland */ 474b3b94faaSDavid Teigland 475b3b94faaSDavid Teigland struct buffer_head *gfs2_log_get_buf(struct gfs2_sbd *sdp) 476b3b94faaSDavid Teigland { 477cd915493SSteven Whitehouse u64 blkno = log_bmap(sdp, sdp->sd_log_flush_head); 478b3b94faaSDavid Teigland struct buffer_head *bh; 479b3b94faaSDavid Teigland 48016615be1SSteven Whitehouse bh = sb_getblk(sdp->sd_vfs, blkno); 481b3b94faaSDavid Teigland lock_buffer(bh); 482b3b94faaSDavid Teigland memset(bh->b_data, 0, bh->b_size); 483b3b94faaSDavid Teigland set_buffer_uptodate(bh); 484b3b94faaSDavid Teigland clear_buffer_dirty(bh); 48516615be1SSteven Whitehouse gfs2_log_incr_head(sdp); 48616615be1SSteven Whitehouse atomic_inc(&sdp->sd_log_in_flight); 48716615be1SSteven Whitehouse bh->b_private = sdp; 48816615be1SSteven Whitehouse bh->b_end_io = gfs2_log_write_endio; 489b3b94faaSDavid Teigland 490b3b94faaSDavid Teigland return bh; 491b3b94faaSDavid Teigland } 492b3b94faaSDavid Teigland 493b3b94faaSDavid Teigland /** 49416615be1SSteven Whitehouse * gfs2_fake_write_endio - 49516615be1SSteven Whitehouse * @bh: The buffer head 49616615be1SSteven Whitehouse * @uptodate: The I/O Status 49716615be1SSteven Whitehouse * 49816615be1SSteven Whitehouse */ 49916615be1SSteven Whitehouse 50016615be1SSteven Whitehouse static void gfs2_fake_write_endio(struct buffer_head *bh, int uptodate) 50116615be1SSteven Whitehouse { 50216615be1SSteven Whitehouse struct buffer_head *real_bh = bh->b_private; 5035a60c532SSteven Whitehouse struct gfs2_bufdata *bd = real_bh->b_private; 5045a60c532SSteven Whitehouse struct gfs2_sbd *sdp = bd->bd_gl->gl_sbd; 50516615be1SSteven Whitehouse 50616615be1SSteven Whitehouse end_buffer_write_sync(bh, uptodate); 50716615be1SSteven Whitehouse free_buffer_head(bh); 50816615be1SSteven Whitehouse unlock_buffer(real_bh); 50916615be1SSteven Whitehouse brelse(real_bh); 51016615be1SSteven Whitehouse if (atomic_dec_and_test(&sdp->sd_log_in_flight)) 51116615be1SSteven Whitehouse wake_up(&sdp->sd_log_flush_wait); 51216615be1SSteven Whitehouse } 51316615be1SSteven Whitehouse 51416615be1SSteven Whitehouse /** 515b3b94faaSDavid Teigland * gfs2_log_fake_buf - Build a fake buffer head to write metadata buffer to log 516b3b94faaSDavid Teigland * @sdp: the filesystem 517b3b94faaSDavid Teigland * @data: the data the buffer_head should point to 518b3b94faaSDavid Teigland * 519b3b94faaSDavid Teigland * Returns: the log buffer descriptor 520b3b94faaSDavid Teigland */ 521b3b94faaSDavid Teigland 522b3b94faaSDavid Teigland struct buffer_head *gfs2_log_fake_buf(struct gfs2_sbd *sdp, 523b3b94faaSDavid Teigland struct buffer_head *real) 524b3b94faaSDavid Teigland { 525cd915493SSteven Whitehouse u64 blkno = log_bmap(sdp, sdp->sd_log_flush_head); 526b3b94faaSDavid Teigland struct buffer_head *bh; 527b3b94faaSDavid Teigland 52816615be1SSteven Whitehouse bh = alloc_buffer_head(GFP_NOFS | __GFP_NOFAIL); 529b3b94faaSDavid Teigland atomic_set(&bh->b_count, 1); 53016615be1SSteven Whitehouse bh->b_state = (1 << BH_Mapped) | (1 << BH_Uptodate) | (1 << BH_Lock); 53118ec7d5cSSteven Whitehouse set_bh_page(bh, real->b_page, bh_offset(real)); 532b3b94faaSDavid Teigland bh->b_blocknr = blkno; 533b3b94faaSDavid Teigland bh->b_size = sdp->sd_sb.sb_bsize; 534b3b94faaSDavid Teigland bh->b_bdev = sdp->sd_vfs->s_bdev; 53516615be1SSteven Whitehouse bh->b_private = real; 53616615be1SSteven Whitehouse bh->b_end_io = gfs2_fake_write_endio; 537b3b94faaSDavid Teigland 53816615be1SSteven Whitehouse gfs2_log_incr_head(sdp); 53916615be1SSteven Whitehouse atomic_inc(&sdp->sd_log_in_flight); 540b3b94faaSDavid Teigland 541b3b94faaSDavid Teigland return bh; 542b3b94faaSDavid Teigland } 543b3b94faaSDavid Teigland 5442332c443SRobert Peterson static void log_pull_tail(struct gfs2_sbd *sdp, unsigned int new_tail) 545b3b94faaSDavid Teigland { 546b3b94faaSDavid Teigland unsigned int dist = log_distance(sdp, new_tail, sdp->sd_log_tail); 547b3b94faaSDavid Teigland 548b3b94faaSDavid Teigland ail2_empty(sdp, new_tail); 549b3b94faaSDavid Teigland 550fd041f0bSSteven Whitehouse atomic_add(dist, &sdp->sd_log_blks_free); 55163997775SSteven Whitehouse trace_gfs2_log_blocks(sdp, dist); 5525e687eacSBenjamin Marzinski gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <= 5535e687eacSBenjamin Marzinski sdp->sd_jdesc->jd_blocks); 554b3b94faaSDavid Teigland 555b3b94faaSDavid Teigland sdp->sd_log_tail = new_tail; 556b3b94faaSDavid Teigland } 557b3b94faaSDavid Teigland 558b3b94faaSDavid Teigland /** 559b3b94faaSDavid Teigland * log_write_header - Get and initialize a journal header buffer 560b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 561b3b94faaSDavid Teigland * 562b3b94faaSDavid Teigland * Returns: the initialized log buffer descriptor 563b3b94faaSDavid Teigland */ 564b3b94faaSDavid Teigland 565cd915493SSteven Whitehouse static void log_write_header(struct gfs2_sbd *sdp, u32 flags, int pull) 566b3b94faaSDavid Teigland { 567cd915493SSteven Whitehouse u64 blkno = log_bmap(sdp, sdp->sd_log_flush_head); 568b3b94faaSDavid Teigland struct buffer_head *bh; 569b3b94faaSDavid Teigland struct gfs2_log_header *lh; 570b3b94faaSDavid Teigland unsigned int tail; 571cd915493SSteven Whitehouse u32 hash; 572b3b94faaSDavid Teigland 573b3b94faaSDavid Teigland bh = sb_getblk(sdp->sd_vfs, blkno); 574b3b94faaSDavid Teigland lock_buffer(bh); 575b3b94faaSDavid Teigland memset(bh->b_data, 0, bh->b_size); 576b3b94faaSDavid Teigland set_buffer_uptodate(bh); 577b3b94faaSDavid Teigland clear_buffer_dirty(bh); 578b3b94faaSDavid Teigland 579*4667a0ecSSteven Whitehouse gfs2_ail1_empty(sdp); 580b3b94faaSDavid Teigland tail = current_tail(sdp); 581b3b94faaSDavid Teigland 582b3b94faaSDavid Teigland lh = (struct gfs2_log_header *)bh->b_data; 583b3b94faaSDavid Teigland memset(lh, 0, sizeof(struct gfs2_log_header)); 584b3b94faaSDavid Teigland lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 585e3167dedSSteven Whitehouse lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH); 5860ab7d13fSSteven Whitehouse lh->lh_header.__pad0 = cpu_to_be64(0); 587e3167dedSSteven Whitehouse lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH); 5880ab7d13fSSteven Whitehouse lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid); 589e0f2bf78SSteven Whitehouse lh->lh_sequence = cpu_to_be64(sdp->sd_log_sequence++); 590e0f2bf78SSteven Whitehouse lh->lh_flags = cpu_to_be32(flags); 591e0f2bf78SSteven Whitehouse lh->lh_tail = cpu_to_be32(tail); 592e0f2bf78SSteven Whitehouse lh->lh_blkno = cpu_to_be32(sdp->sd_log_flush_head); 593b3b94faaSDavid Teigland hash = gfs2_disk_hash(bh->b_data, sizeof(struct gfs2_log_header)); 594b3b94faaSDavid Teigland lh->lh_hash = cpu_to_be32(hash); 595b3b94faaSDavid Teigland 596254db57fSSteven Whitehouse bh->b_end_io = end_buffer_write_sync; 597f1e4d518SChristoph Hellwig get_bh(bh); 598254db57fSSteven Whitehouse if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags)) 5997b6d91daSChristoph Hellwig submit_bh(WRITE_SYNC | REQ_META, bh); 600f1e4d518SChristoph Hellwig else 601f1e4d518SChristoph Hellwig submit_bh(WRITE_FLUSH_FUA | REQ_META, bh); 602254db57fSSteven Whitehouse wait_on_buffer(bh); 603f1e4d518SChristoph Hellwig 604254db57fSSteven Whitehouse if (!buffer_uptodate(bh)) 605b3b94faaSDavid Teigland gfs2_io_error_bh(sdp, bh); 606b3b94faaSDavid Teigland brelse(bh); 607b3b94faaSDavid Teigland 608b3b94faaSDavid Teigland if (sdp->sd_log_tail != tail) 6092332c443SRobert Peterson log_pull_tail(sdp, tail); 610b3b94faaSDavid Teigland else 611b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !pull); 612b3b94faaSDavid Teigland 613b3b94faaSDavid Teigland sdp->sd_log_idle = (tail == sdp->sd_log_flush_head); 61416615be1SSteven Whitehouse gfs2_log_incr_head(sdp); 615b3b94faaSDavid Teigland } 616b3b94faaSDavid Teigland 617b3b94faaSDavid Teigland static void log_flush_commit(struct gfs2_sbd *sdp) 618b3b94faaSDavid Teigland { 61916615be1SSteven Whitehouse DEFINE_WAIT(wait); 620b3b94faaSDavid Teigland 62116615be1SSteven Whitehouse if (atomic_read(&sdp->sd_log_in_flight)) { 62216615be1SSteven Whitehouse do { 62316615be1SSteven Whitehouse prepare_to_wait(&sdp->sd_log_flush_wait, &wait, 62416615be1SSteven Whitehouse TASK_UNINTERRUPTIBLE); 62516615be1SSteven Whitehouse if (atomic_read(&sdp->sd_log_in_flight)) 62616615be1SSteven Whitehouse io_schedule(); 62716615be1SSteven Whitehouse } while(atomic_read(&sdp->sd_log_in_flight)); 62816615be1SSteven Whitehouse finish_wait(&sdp->sd_log_flush_wait, &wait); 629b3b94faaSDavid Teigland } 630b3b94faaSDavid Teigland 631b3b94faaSDavid Teigland log_write_header(sdp, 0, 0); 632b3b94faaSDavid Teigland } 633b3b94faaSDavid Teigland 634d7b616e2SSteven Whitehouse static void gfs2_ordered_write(struct gfs2_sbd *sdp) 635d7b616e2SSteven Whitehouse { 636d7b616e2SSteven Whitehouse struct gfs2_bufdata *bd; 637d7b616e2SSteven Whitehouse struct buffer_head *bh; 638d7b616e2SSteven Whitehouse LIST_HEAD(written); 639d7b616e2SSteven Whitehouse 640d7b616e2SSteven Whitehouse gfs2_log_lock(sdp); 641d7b616e2SSteven Whitehouse while (!list_empty(&sdp->sd_log_le_ordered)) { 642d7b616e2SSteven Whitehouse bd = list_entry(sdp->sd_log_le_ordered.next, struct gfs2_bufdata, bd_le.le_list); 643d7b616e2SSteven Whitehouse list_move(&bd->bd_le.le_list, &written); 644d7b616e2SSteven Whitehouse bh = bd->bd_bh; 645d7b616e2SSteven Whitehouse if (!buffer_dirty(bh)) 646d7b616e2SSteven Whitehouse continue; 647d7b616e2SSteven Whitehouse get_bh(bh); 648d7b616e2SSteven Whitehouse gfs2_log_unlock(sdp); 649d7b616e2SSteven Whitehouse lock_buffer(bh); 650b8e7cbb6SSteven Whitehouse if (buffer_mapped(bh) && test_clear_buffer_dirty(bh)) { 651d7b616e2SSteven Whitehouse bh->b_end_io = end_buffer_write_sync; 652721a9602SJens Axboe submit_bh(WRITE_SYNC, bh); 653d7b616e2SSteven Whitehouse } else { 654d7b616e2SSteven Whitehouse unlock_buffer(bh); 655d7b616e2SSteven Whitehouse brelse(bh); 656d7b616e2SSteven Whitehouse } 657d7b616e2SSteven Whitehouse gfs2_log_lock(sdp); 658d7b616e2SSteven Whitehouse } 659d7b616e2SSteven Whitehouse list_splice(&written, &sdp->sd_log_le_ordered); 660d7b616e2SSteven Whitehouse gfs2_log_unlock(sdp); 661d7b616e2SSteven Whitehouse } 662d7b616e2SSteven Whitehouse 663d7b616e2SSteven Whitehouse static void gfs2_ordered_wait(struct gfs2_sbd *sdp) 664d7b616e2SSteven Whitehouse { 665d7b616e2SSteven Whitehouse struct gfs2_bufdata *bd; 666d7b616e2SSteven Whitehouse struct buffer_head *bh; 667d7b616e2SSteven Whitehouse 668d7b616e2SSteven Whitehouse gfs2_log_lock(sdp); 669d7b616e2SSteven Whitehouse while (!list_empty(&sdp->sd_log_le_ordered)) { 670d7b616e2SSteven Whitehouse bd = list_entry(sdp->sd_log_le_ordered.prev, struct gfs2_bufdata, bd_le.le_list); 671d7b616e2SSteven Whitehouse bh = bd->bd_bh; 672d7b616e2SSteven Whitehouse if (buffer_locked(bh)) { 673d7b616e2SSteven Whitehouse get_bh(bh); 674d7b616e2SSteven Whitehouse gfs2_log_unlock(sdp); 675d7b616e2SSteven Whitehouse wait_on_buffer(bh); 676d7b616e2SSteven Whitehouse brelse(bh); 677d7b616e2SSteven Whitehouse gfs2_log_lock(sdp); 678d7b616e2SSteven Whitehouse continue; 679d7b616e2SSteven Whitehouse } 680d7b616e2SSteven Whitehouse list_del_init(&bd->bd_le.le_list); 681d7b616e2SSteven Whitehouse } 682d7b616e2SSteven Whitehouse gfs2_log_unlock(sdp); 683d7b616e2SSteven Whitehouse } 684d7b616e2SSteven Whitehouse 685b3b94faaSDavid Teigland /** 686b09e593dSSteven Whitehouse * gfs2_log_flush - flush incore transaction(s) 687b3b94faaSDavid Teigland * @sdp: the filesystem 688b3b94faaSDavid Teigland * @gl: The glock structure to flush. If NULL, flush the whole incore log 689b3b94faaSDavid Teigland * 690b3b94faaSDavid Teigland */ 691b3b94faaSDavid Teigland 692ed4878e8SBob Peterson void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl) 693b3b94faaSDavid Teigland { 694b3b94faaSDavid Teigland struct gfs2_ail *ai; 695b3b94faaSDavid Teigland 696484adff8SSteven Whitehouse down_write(&sdp->sd_log_flush_lock); 697f55ab26aSSteven Whitehouse 6982bcd610dSSteven Whitehouse /* Log might have been flushed while we waited for the flush lock */ 6992bcd610dSSteven Whitehouse if (gl && !test_bit(GLF_LFLUSH, &gl->gl_flags)) { 700484adff8SSteven Whitehouse up_write(&sdp->sd_log_flush_lock); 701f55ab26aSSteven Whitehouse return; 702f55ab26aSSteven Whitehouse } 70363997775SSteven Whitehouse trace_gfs2_log_flush(sdp, 1); 704f55ab26aSSteven Whitehouse 705b09e593dSSteven Whitehouse ai = kzalloc(sizeof(struct gfs2_ail), GFP_NOFS | __GFP_NOFAIL); 706b09e593dSSteven Whitehouse INIT_LIST_HEAD(&ai->ai_ail1_list); 707b09e593dSSteven Whitehouse INIT_LIST_HEAD(&ai->ai_ail2_list); 708b3b94faaSDavid Teigland 70916615be1SSteven Whitehouse if (sdp->sd_log_num_buf != sdp->sd_log_commited_buf) { 71016615be1SSteven Whitehouse printk(KERN_INFO "GFS2: log buf %u %u\n", sdp->sd_log_num_buf, 71116615be1SSteven Whitehouse sdp->sd_log_commited_buf); 71216615be1SSteven Whitehouse gfs2_assert_withdraw(sdp, 0); 71316615be1SSteven Whitehouse } 71416615be1SSteven Whitehouse if (sdp->sd_log_num_databuf != sdp->sd_log_commited_databuf) { 71516615be1SSteven Whitehouse printk(KERN_INFO "GFS2: log databuf %u %u\n", 71616615be1SSteven Whitehouse sdp->sd_log_num_databuf, sdp->sd_log_commited_databuf); 71716615be1SSteven Whitehouse gfs2_assert_withdraw(sdp, 0); 71816615be1SSteven Whitehouse } 719b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, 720b3b94faaSDavid Teigland sdp->sd_log_num_revoke == sdp->sd_log_commited_revoke); 721b3b94faaSDavid Teigland 722b3b94faaSDavid Teigland sdp->sd_log_flush_head = sdp->sd_log_head; 723b3b94faaSDavid Teigland sdp->sd_log_flush_wrapped = 0; 724b3b94faaSDavid Teigland ai->ai_first = sdp->sd_log_flush_head; 725b3b94faaSDavid Teigland 726d7b616e2SSteven Whitehouse gfs2_ordered_write(sdp); 727b3b94faaSDavid Teigland lops_before_commit(sdp); 728d7b616e2SSteven Whitehouse gfs2_ordered_wait(sdp); 729d7b616e2SSteven Whitehouse 73016615be1SSteven Whitehouse if (sdp->sd_log_head != sdp->sd_log_flush_head) 731b3b94faaSDavid Teigland log_flush_commit(sdp); 7322332c443SRobert Peterson else if (sdp->sd_log_tail != current_tail(sdp) && !sdp->sd_log_idle){ 7332332c443SRobert Peterson gfs2_log_lock(sdp); 734fd041f0bSSteven Whitehouse atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */ 73563997775SSteven Whitehouse trace_gfs2_log_blocks(sdp, -1); 7362332c443SRobert Peterson gfs2_log_unlock(sdp); 737b3b94faaSDavid Teigland log_write_header(sdp, 0, PULL); 7382332c443SRobert Peterson } 739b3b94faaSDavid Teigland lops_after_commit(sdp, ai); 740fe1a698fSSteven Whitehouse 741fe1a698fSSteven Whitehouse gfs2_log_lock(sdp); 742b3b94faaSDavid Teigland sdp->sd_log_head = sdp->sd_log_flush_head; 743faa31ce8SSteven Whitehouse sdp->sd_log_blks_reserved = 0; 744faa31ce8SSteven Whitehouse sdp->sd_log_commited_buf = 0; 7452332c443SRobert Peterson sdp->sd_log_commited_databuf = 0; 746b3b94faaSDavid Teigland sdp->sd_log_commited_revoke = 0; 747b3b94faaSDavid Teigland 748d6a079e8SDave Chinner spin_lock(&sdp->sd_ail_lock); 749b3b94faaSDavid Teigland if (!list_empty(&ai->ai_ail1_list)) { 750b3b94faaSDavid Teigland list_add(&ai->ai_list, &sdp->sd_ail1_list); 751b3b94faaSDavid Teigland ai = NULL; 752b3b94faaSDavid Teigland } 753d6a079e8SDave Chinner spin_unlock(&sdp->sd_ail_lock); 754b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 75563997775SSteven Whitehouse trace_gfs2_log_flush(sdp, 0); 756484adff8SSteven Whitehouse up_write(&sdp->sd_log_flush_lock); 757b3b94faaSDavid Teigland 758b3b94faaSDavid Teigland kfree(ai); 759b3b94faaSDavid Teigland } 760b3b94faaSDavid Teigland 761b3b94faaSDavid Teigland static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 762b3b94faaSDavid Teigland { 7632332c443SRobert Peterson unsigned int reserved; 764ac39aaddSSteven Whitehouse unsigned int unused; 765b3b94faaSDavid Teigland 766b3b94faaSDavid Teigland gfs2_log_lock(sdp); 767b3b94faaSDavid Teigland 768b3b94faaSDavid Teigland sdp->sd_log_commited_buf += tr->tr_num_buf_new - tr->tr_num_buf_rm; 7692332c443SRobert Peterson sdp->sd_log_commited_databuf += tr->tr_num_databuf_new - 7702332c443SRobert Peterson tr->tr_num_databuf_rm; 7712332c443SRobert Peterson gfs2_assert_withdraw(sdp, (((int)sdp->sd_log_commited_buf) >= 0) || 7722332c443SRobert Peterson (((int)sdp->sd_log_commited_databuf) >= 0)); 773b3b94faaSDavid Teigland sdp->sd_log_commited_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm; 7742332c443SRobert Peterson reserved = calc_reserved(sdp); 77562be1f71SRoel Kluin gfs2_assert_withdraw(sdp, sdp->sd_log_blks_reserved + tr->tr_reserved >= reserved); 776ac39aaddSSteven Whitehouse unused = sdp->sd_log_blks_reserved - reserved + tr->tr_reserved; 777ac39aaddSSteven Whitehouse atomic_add(unused, &sdp->sd_log_blks_free); 77863997775SSteven Whitehouse trace_gfs2_log_blocks(sdp, unused); 779fd041f0bSSteven Whitehouse gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <= 7802332c443SRobert Peterson sdp->sd_jdesc->jd_blocks); 781b3b94faaSDavid Teigland sdp->sd_log_blks_reserved = reserved; 782b3b94faaSDavid Teigland 783b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 784b3b94faaSDavid Teigland } 785b3b94faaSDavid Teigland 786d0109bfaSBob Peterson static void buf_lo_incore_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 787d0109bfaSBob Peterson { 788d0109bfaSBob Peterson struct list_head *head = &tr->tr_list_buf; 789d0109bfaSBob Peterson struct gfs2_bufdata *bd; 790d0109bfaSBob Peterson 791d0109bfaSBob Peterson gfs2_log_lock(sdp); 792d0109bfaSBob Peterson while (!list_empty(head)) { 793d0109bfaSBob Peterson bd = list_entry(head->next, struct gfs2_bufdata, bd_list_tr); 794d0109bfaSBob Peterson list_del_init(&bd->bd_list_tr); 795d0109bfaSBob Peterson tr->tr_num_buf--; 796d0109bfaSBob Peterson } 797d0109bfaSBob Peterson gfs2_log_unlock(sdp); 798d0109bfaSBob Peterson gfs2_assert_warn(sdp, !tr->tr_num_buf); 799d0109bfaSBob Peterson } 800d0109bfaSBob Peterson 801b3b94faaSDavid Teigland /** 802b3b94faaSDavid Teigland * gfs2_log_commit - Commit a transaction to the log 803b3b94faaSDavid Teigland * @sdp: the filesystem 804b3b94faaSDavid Teigland * @tr: the transaction 805b3b94faaSDavid Teigland * 8065e687eacSBenjamin Marzinski * We wake up gfs2_logd if the number of pinned blocks exceed thresh1 8075e687eacSBenjamin Marzinski * or the total number of used blocks (pinned blocks plus AIL blocks) 8085e687eacSBenjamin Marzinski * is greater than thresh2. 8095e687eacSBenjamin Marzinski * 8105e687eacSBenjamin Marzinski * At mount time thresh1 is 1/3rd of journal size, thresh2 is 2/3rd of 8115e687eacSBenjamin Marzinski * journal size. 8125e687eacSBenjamin Marzinski * 813b3b94faaSDavid Teigland * Returns: errno 814b3b94faaSDavid Teigland */ 815b3b94faaSDavid Teigland 816b3b94faaSDavid Teigland void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 817b3b94faaSDavid Teigland { 818b3b94faaSDavid Teigland log_refund(sdp, tr); 819d0109bfaSBob Peterson buf_lo_incore_commit(sdp, tr); 820b3b94faaSDavid Teigland 821484adff8SSteven Whitehouse up_read(&sdp->sd_log_flush_lock); 822b3b94faaSDavid Teigland 8235e687eacSBenjamin Marzinski if (atomic_read(&sdp->sd_log_pinned) > atomic_read(&sdp->sd_log_thresh1) || 8245e687eacSBenjamin Marzinski ((sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free)) > 8255e687eacSBenjamin Marzinski atomic_read(&sdp->sd_log_thresh2))) 8265e687eacSBenjamin Marzinski wake_up(&sdp->sd_logd_waitq); 827faa31ce8SSteven Whitehouse } 828b3b94faaSDavid Teigland 829b3b94faaSDavid Teigland /** 830b3b94faaSDavid Teigland * gfs2_log_shutdown - write a shutdown header into a journal 831b3b94faaSDavid Teigland * @sdp: the filesystem 832b3b94faaSDavid Teigland * 833b3b94faaSDavid Teigland */ 834b3b94faaSDavid Teigland 835b3b94faaSDavid Teigland void gfs2_log_shutdown(struct gfs2_sbd *sdp) 836b3b94faaSDavid Teigland { 837484adff8SSteven Whitehouse down_write(&sdp->sd_log_flush_lock); 838b3b94faaSDavid Teigland 839b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved); 840b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_buf); 841b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke); 842b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_rg); 843b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_databuf); 844b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list)); 845b3b94faaSDavid Teigland 846b3b94faaSDavid Teigland sdp->sd_log_flush_head = sdp->sd_log_head; 847b3b94faaSDavid Teigland sdp->sd_log_flush_wrapped = 0; 848b3b94faaSDavid Teigland 8492332c443SRobert Peterson log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT, 8502332c443SRobert Peterson (sdp->sd_log_tail == current_tail(sdp)) ? 0 : PULL); 851b3b94faaSDavid Teigland 852fd041f0bSSteven Whitehouse gfs2_assert_warn(sdp, atomic_read(&sdp->sd_log_blks_free) == sdp->sd_jdesc->jd_blocks); 853a74604beSSteven Whitehouse gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail); 854a74604beSSteven Whitehouse gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list)); 855b3b94faaSDavid Teigland 856b3b94faaSDavid Teigland sdp->sd_log_head = sdp->sd_log_flush_head; 857b3b94faaSDavid Teigland sdp->sd_log_tail = sdp->sd_log_head; 858b3b94faaSDavid Teigland 859484adff8SSteven Whitehouse up_write(&sdp->sd_log_flush_lock); 860b3b94faaSDavid Teigland } 861b3b94faaSDavid Teigland 862a25311c8SSteven Whitehouse 863a25311c8SSteven Whitehouse /** 864a25311c8SSteven Whitehouse * gfs2_meta_syncfs - sync all the buffers in a filesystem 865a25311c8SSteven Whitehouse * @sdp: the filesystem 866a25311c8SSteven Whitehouse * 867a25311c8SSteven Whitehouse */ 868a25311c8SSteven Whitehouse 869a25311c8SSteven Whitehouse void gfs2_meta_syncfs(struct gfs2_sbd *sdp) 870a25311c8SSteven Whitehouse { 871a25311c8SSteven Whitehouse gfs2_log_flush(sdp, NULL); 872a25311c8SSteven Whitehouse for (;;) { 8735e687eacSBenjamin Marzinski gfs2_ail1_start(sdp); 874*4667a0ecSSteven Whitehouse if (gfs2_ail1_empty(sdp)) 875a25311c8SSteven Whitehouse break; 876a25311c8SSteven Whitehouse msleep(10); 877a25311c8SSteven Whitehouse } 878a25311c8SSteven Whitehouse } 879a25311c8SSteven Whitehouse 8805e687eacSBenjamin Marzinski static inline int gfs2_jrnl_flush_reqd(struct gfs2_sbd *sdp) 8815e687eacSBenjamin Marzinski { 8825e687eacSBenjamin Marzinski return (atomic_read(&sdp->sd_log_pinned) >= atomic_read(&sdp->sd_log_thresh1)); 8835e687eacSBenjamin Marzinski } 8845e687eacSBenjamin Marzinski 8855e687eacSBenjamin Marzinski static inline int gfs2_ail_flush_reqd(struct gfs2_sbd *sdp) 8865e687eacSBenjamin Marzinski { 8875e687eacSBenjamin Marzinski unsigned int used_blocks = sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free); 8885e687eacSBenjamin Marzinski return used_blocks >= atomic_read(&sdp->sd_log_thresh2); 8895e687eacSBenjamin Marzinski } 890ec69b188SSteven Whitehouse 891ec69b188SSteven Whitehouse /** 892ec69b188SSteven Whitehouse * gfs2_logd - Update log tail as Active Items get flushed to in-place blocks 893ec69b188SSteven Whitehouse * @sdp: Pointer to GFS2 superblock 894ec69b188SSteven Whitehouse * 895ec69b188SSteven Whitehouse * Also, periodically check to make sure that we're using the most recent 896ec69b188SSteven Whitehouse * journal index. 897ec69b188SSteven Whitehouse */ 898ec69b188SSteven Whitehouse 899ec69b188SSteven Whitehouse int gfs2_logd(void *data) 900ec69b188SSteven Whitehouse { 901ec69b188SSteven Whitehouse struct gfs2_sbd *sdp = data; 9025e687eacSBenjamin Marzinski unsigned long t = 1; 9035e687eacSBenjamin Marzinski DEFINE_WAIT(wait); 9045e687eacSBenjamin Marzinski unsigned preflush; 905ec69b188SSteven Whitehouse 906ec69b188SSteven Whitehouse while (!kthread_should_stop()) { 907ec69b188SSteven Whitehouse 9085e687eacSBenjamin Marzinski preflush = atomic_read(&sdp->sd_log_pinned); 9095e687eacSBenjamin Marzinski if (gfs2_jrnl_flush_reqd(sdp) || t == 0) { 910*4667a0ecSSteven Whitehouse gfs2_ail1_empty(sdp); 911ec69b188SSteven Whitehouse gfs2_log_flush(sdp, NULL); 912ec69b188SSteven Whitehouse } 913ec69b188SSteven Whitehouse 9145e687eacSBenjamin Marzinski if (gfs2_ail_flush_reqd(sdp)) { 9155e687eacSBenjamin Marzinski gfs2_ail1_start(sdp); 9165e687eacSBenjamin Marzinski io_schedule(); 917*4667a0ecSSteven Whitehouse gfs2_ail1_empty(sdp); 9185e687eacSBenjamin Marzinski gfs2_log_flush(sdp, NULL); 9195e687eacSBenjamin Marzinski } 9205e687eacSBenjamin Marzinski 9215e687eacSBenjamin Marzinski wake_up(&sdp->sd_log_waitq); 922ec69b188SSteven Whitehouse t = gfs2_tune_get(sdp, gt_logd_secs) * HZ; 923ec69b188SSteven Whitehouse if (freezing(current)) 924ec69b188SSteven Whitehouse refrigerator(); 9255e687eacSBenjamin Marzinski 9265e687eacSBenjamin Marzinski do { 9275e687eacSBenjamin Marzinski prepare_to_wait(&sdp->sd_logd_waitq, &wait, 9285f487490SSteven Whitehouse TASK_INTERRUPTIBLE); 9295e687eacSBenjamin Marzinski if (!gfs2_ail_flush_reqd(sdp) && 9305e687eacSBenjamin Marzinski !gfs2_jrnl_flush_reqd(sdp) && 9315e687eacSBenjamin Marzinski !kthread_should_stop()) 9325e687eacSBenjamin Marzinski t = schedule_timeout(t); 9335e687eacSBenjamin Marzinski } while(t && !gfs2_ail_flush_reqd(sdp) && 9345e687eacSBenjamin Marzinski !gfs2_jrnl_flush_reqd(sdp) && 9355e687eacSBenjamin Marzinski !kthread_should_stop()); 9365e687eacSBenjamin Marzinski finish_wait(&sdp->sd_logd_waitq, &wait); 937ec69b188SSteven Whitehouse } 938ec69b188SSteven Whitehouse 939ec69b188SSteven Whitehouse return 0; 940ec69b188SSteven Whitehouse } 941ec69b188SSteven Whitehouse 942