1b3b94faaSDavid Teigland /* 2b3b94faaSDavid Teigland * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 3b3b94faaSDavid Teigland * Copyright (C) 2004-2005 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 7b3b94faaSDavid Teigland * of the GNU General Public License v.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> 15b3b94faaSDavid Teigland #include <asm/semaphore.h> 16b3b94faaSDavid Teigland 17b3b94faaSDavid Teigland #include "gfs2.h" 18b3b94faaSDavid Teigland #include "bmap.h" 19b3b94faaSDavid Teigland #include "glock.h" 20b3b94faaSDavid Teigland #include "log.h" 21b3b94faaSDavid Teigland #include "lops.h" 22b3b94faaSDavid Teigland #include "meta_io.h" 23b3b94faaSDavid Teigland 24b3b94faaSDavid Teigland #define PULL 1 25b3b94faaSDavid Teigland 26b3b94faaSDavid Teigland static void do_lock_wait(struct gfs2_sbd *sdp, wait_queue_head_t *wq, 27b3b94faaSDavid Teigland atomic_t *a) 28b3b94faaSDavid Teigland { 29*f55ab26aSSteven Whitehouse wait_event(*wq, atomic_read(a) ? 0 : 1); 30b3b94faaSDavid Teigland } 31b3b94faaSDavid Teigland 32b3b94faaSDavid Teigland static void lock_for_trans(struct gfs2_sbd *sdp) 33b3b94faaSDavid Teigland { 34b3b94faaSDavid Teigland do_lock_wait(sdp, &sdp->sd_log_trans_wq, &sdp->sd_log_flush_count); 35b3b94faaSDavid Teigland atomic_inc(&sdp->sd_log_trans_count); 36b3b94faaSDavid Teigland } 37b3b94faaSDavid Teigland 38b3b94faaSDavid Teigland static void unlock_from_trans(struct gfs2_sbd *sdp) 39b3b94faaSDavid Teigland { 40b3b94faaSDavid Teigland gfs2_assert_warn(sdp, atomic_read(&sdp->sd_log_trans_count)); 41b3b94faaSDavid Teigland if (atomic_dec_and_test(&sdp->sd_log_trans_count)) 42b3b94faaSDavid Teigland wake_up(&sdp->sd_log_flush_wq); 43b3b94faaSDavid Teigland } 44b3b94faaSDavid Teigland 45*f55ab26aSSteven Whitehouse static void gfs2_lock_for_flush(struct gfs2_sbd *sdp) 46b3b94faaSDavid Teigland { 47b3b94faaSDavid Teigland atomic_inc(&sdp->sd_log_flush_count); 48b3b94faaSDavid Teigland do_lock_wait(sdp, &sdp->sd_log_flush_wq, &sdp->sd_log_trans_count); 49b3b94faaSDavid Teigland } 50b3b94faaSDavid Teigland 51*f55ab26aSSteven Whitehouse static void gfs2_unlock_from_flush(struct gfs2_sbd *sdp) 52b3b94faaSDavid Teigland { 53b3b94faaSDavid Teigland gfs2_assert_warn(sdp, atomic_read(&sdp->sd_log_flush_count)); 54b3b94faaSDavid Teigland if (atomic_dec_and_test(&sdp->sd_log_flush_count)) 55b3b94faaSDavid Teigland wake_up(&sdp->sd_log_trans_wq); 56b3b94faaSDavid Teigland } 57b3b94faaSDavid Teigland 58b3b94faaSDavid Teigland /** 59b3b94faaSDavid Teigland * gfs2_struct2blk - compute stuff 60b3b94faaSDavid Teigland * @sdp: the filesystem 61b3b94faaSDavid Teigland * @nstruct: the number of structures 62b3b94faaSDavid Teigland * @ssize: the size of the structures 63b3b94faaSDavid Teigland * 64b3b94faaSDavid Teigland * Compute the number of log descriptor blocks needed to hold a certain number 65b3b94faaSDavid Teigland * of structures of a certain size. 66b3b94faaSDavid Teigland * 67b3b94faaSDavid Teigland * Returns: the number of blocks needed (minimum is always 1) 68b3b94faaSDavid Teigland */ 69b3b94faaSDavid Teigland 70b3b94faaSDavid Teigland unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct, 71b3b94faaSDavid Teigland unsigned int ssize) 72b3b94faaSDavid Teigland { 73b3b94faaSDavid Teigland unsigned int blks; 74b3b94faaSDavid Teigland unsigned int first, second; 75b3b94faaSDavid Teigland 76b3b94faaSDavid Teigland blks = 1; 77b3b94faaSDavid Teigland first = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_log_descriptor)) / ssize; 78b3b94faaSDavid Teigland 79b3b94faaSDavid Teigland if (nstruct > first) { 80b3b94faaSDavid Teigland second = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header)) / ssize; 81b3b94faaSDavid Teigland blks += DIV_RU(nstruct - first, second); 82b3b94faaSDavid Teigland } 83b3b94faaSDavid Teigland 84b3b94faaSDavid Teigland return blks; 85b3b94faaSDavid Teigland } 86b3b94faaSDavid Teigland 87b3b94faaSDavid Teigland void gfs2_ail1_start(struct gfs2_sbd *sdp, int flags) 88b3b94faaSDavid Teigland { 89b3b94faaSDavid Teigland struct list_head *head = &sdp->sd_ail1_list; 90b3b94faaSDavid Teigland uint64_t sync_gen; 91b3b94faaSDavid Teigland struct list_head *first, *tmp; 92b3b94faaSDavid Teigland struct gfs2_ail *first_ai, *ai; 93b3b94faaSDavid Teigland 94b3b94faaSDavid Teigland gfs2_log_lock(sdp); 95b3b94faaSDavid Teigland if (list_empty(head)) { 96b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 97b3b94faaSDavid Teigland return; 98b3b94faaSDavid Teigland } 99b3b94faaSDavid Teigland sync_gen = sdp->sd_ail_sync_gen++; 100b3b94faaSDavid Teigland 101b3b94faaSDavid Teigland first = head->prev; 102b3b94faaSDavid Teigland first_ai = list_entry(first, struct gfs2_ail, ai_list); 103b3b94faaSDavid Teigland first_ai->ai_sync_gen = sync_gen; 104b3b94faaSDavid Teigland gfs2_ail1_start_one(sdp, first_ai); 105b3b94faaSDavid Teigland 106b3b94faaSDavid Teigland if (flags & DIO_ALL) 107b3b94faaSDavid Teigland first = NULL; 108b3b94faaSDavid Teigland 109b3b94faaSDavid Teigland for (;;) { 110b3b94faaSDavid Teigland if (first && 111b3b94faaSDavid Teigland (head->prev != first || 112b3b94faaSDavid Teigland gfs2_ail1_empty_one(sdp, first_ai, 0))) 113b3b94faaSDavid Teigland break; 114b3b94faaSDavid Teigland 115b3b94faaSDavid Teigland for (tmp = head->prev; tmp != head; tmp = tmp->prev) { 116b3b94faaSDavid Teigland ai = list_entry(tmp, struct gfs2_ail, ai_list); 117b3b94faaSDavid Teigland if (ai->ai_sync_gen >= sync_gen) 118b3b94faaSDavid Teigland continue; 119b3b94faaSDavid Teigland ai->ai_sync_gen = sync_gen; 120b3b94faaSDavid Teigland gfs2_ail1_start_one(sdp, ai); 121b3b94faaSDavid Teigland break; 122b3b94faaSDavid Teigland } 123b3b94faaSDavid Teigland 124b3b94faaSDavid Teigland if (tmp == head) 125b3b94faaSDavid Teigland break; 126b3b94faaSDavid Teigland } 127b3b94faaSDavid Teigland 128b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 129b3b94faaSDavid Teigland } 130b3b94faaSDavid Teigland 131b3b94faaSDavid Teigland int gfs2_ail1_empty(struct gfs2_sbd *sdp, int flags) 132b3b94faaSDavid Teigland { 133b3b94faaSDavid Teigland struct gfs2_ail *ai, *s; 134b3b94faaSDavid Teigland int ret; 135b3b94faaSDavid Teigland 136b3b94faaSDavid Teigland gfs2_log_lock(sdp); 137b3b94faaSDavid Teigland 138b3b94faaSDavid Teigland list_for_each_entry_safe_reverse(ai, s, &sdp->sd_ail1_list, ai_list) { 139b3b94faaSDavid Teigland if (gfs2_ail1_empty_one(sdp, ai, flags)) 140b3b94faaSDavid Teigland list_move(&ai->ai_list, &sdp->sd_ail2_list); 141b3b94faaSDavid Teigland else if (!(flags & DIO_ALL)) 142b3b94faaSDavid Teigland break; 143b3b94faaSDavid Teigland } 144b3b94faaSDavid Teigland 145b3b94faaSDavid Teigland ret = list_empty(&sdp->sd_ail1_list); 146b3b94faaSDavid Teigland 147b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 148b3b94faaSDavid Teigland 149b3b94faaSDavid Teigland return ret; 150b3b94faaSDavid Teigland } 151b3b94faaSDavid Teigland 152b3b94faaSDavid Teigland static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail) 153b3b94faaSDavid Teigland { 154b3b94faaSDavid Teigland struct gfs2_ail *ai, *safe; 155b3b94faaSDavid Teigland unsigned int old_tail = sdp->sd_log_tail; 156b3b94faaSDavid Teigland int wrap = (new_tail < old_tail); 157b3b94faaSDavid Teigland int a, b, rm; 158b3b94faaSDavid Teigland 159b3b94faaSDavid Teigland gfs2_log_lock(sdp); 160b3b94faaSDavid Teigland 161b3b94faaSDavid Teigland list_for_each_entry_safe(ai, safe, &sdp->sd_ail2_list, ai_list) { 162b3b94faaSDavid Teigland a = (old_tail <= ai->ai_first); 163b3b94faaSDavid Teigland b = (ai->ai_first < new_tail); 164b3b94faaSDavid Teigland rm = (wrap) ? (a || b) : (a && b); 165b3b94faaSDavid Teigland if (!rm) 166b3b94faaSDavid Teigland continue; 167b3b94faaSDavid Teigland 168b3b94faaSDavid Teigland gfs2_ail2_empty_one(sdp, ai); 169b3b94faaSDavid Teigland list_del(&ai->ai_list); 170b3b94faaSDavid Teigland gfs2_assert_warn(sdp, list_empty(&ai->ai_ail1_list)); 171b3b94faaSDavid Teigland gfs2_assert_warn(sdp, list_empty(&ai->ai_ail2_list)); 172b3b94faaSDavid Teigland kfree(ai); 173b3b94faaSDavid Teigland } 174b3b94faaSDavid Teigland 175b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 176b3b94faaSDavid Teigland } 177b3b94faaSDavid Teigland 178b3b94faaSDavid Teigland /** 179b3b94faaSDavid Teigland * gfs2_log_reserve - Make a log reservation 180b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 181b3b94faaSDavid Teigland * @blks: The number of blocks to reserve 182b3b94faaSDavid Teigland * 183b3b94faaSDavid Teigland * Returns: errno 184b3b94faaSDavid Teigland */ 185b3b94faaSDavid Teigland 186b3b94faaSDavid Teigland int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks) 187b3b94faaSDavid Teigland { 188b3b94faaSDavid Teigland LIST_HEAD(list); 189b3b94faaSDavid Teigland unsigned int try = 0; 190b3b94faaSDavid Teigland 191b3b94faaSDavid Teigland if (gfs2_assert_warn(sdp, blks) || 192b3b94faaSDavid Teigland gfs2_assert_warn(sdp, blks <= sdp->sd_jdesc->jd_blocks)) 193b3b94faaSDavid Teigland return -EINVAL; 194b3b94faaSDavid Teigland 195b3b94faaSDavid Teigland for (;;) { 196b3b94faaSDavid Teigland gfs2_log_lock(sdp); 197b3b94faaSDavid Teigland if (list_empty(&list)) { 198b3b94faaSDavid Teigland list_add_tail(&list, &sdp->sd_log_blks_list); 199b3b94faaSDavid Teigland while (sdp->sd_log_blks_list.next != &list) { 200b3b94faaSDavid Teigland DECLARE_WAITQUEUE(__wait_chan, current); 201b3b94faaSDavid Teigland set_current_state(TASK_UNINTERRUPTIBLE); 202b3b94faaSDavid Teigland add_wait_queue(&sdp->sd_log_blks_wait, 203b3b94faaSDavid Teigland &__wait_chan); 204b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 205b3b94faaSDavid Teigland schedule(); 206b3b94faaSDavid Teigland gfs2_log_lock(sdp); 207b3b94faaSDavid Teigland remove_wait_queue(&sdp->sd_log_blks_wait, 208b3b94faaSDavid Teigland &__wait_chan); 209b3b94faaSDavid Teigland set_current_state(TASK_RUNNING); 210b3b94faaSDavid Teigland } 211b3b94faaSDavid Teigland } 212b3b94faaSDavid Teigland /* Never give away the last block so we can 213b3b94faaSDavid Teigland always pull the tail if we need to. */ 214b3b94faaSDavid Teigland if (sdp->sd_log_blks_free > blks) { 215b3b94faaSDavid Teigland sdp->sd_log_blks_free -= blks; 216b3b94faaSDavid Teigland list_del(&list); 217b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 218b3b94faaSDavid Teigland wake_up(&sdp->sd_log_blks_wait); 219b3b94faaSDavid Teigland break; 220b3b94faaSDavid Teigland } 221b3b94faaSDavid Teigland 222b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 223b3b94faaSDavid Teigland gfs2_ail1_empty(sdp, 0); 224b3b94faaSDavid Teigland gfs2_log_flush(sdp); 225b3b94faaSDavid Teigland 226b3b94faaSDavid Teigland if (try++) 227b3b94faaSDavid Teigland gfs2_ail1_start(sdp, 0); 228b3b94faaSDavid Teigland } 229b3b94faaSDavid Teigland lock_for_trans(sdp); 230b3b94faaSDavid Teigland 231b3b94faaSDavid Teigland return 0; 232b3b94faaSDavid Teigland } 233b3b94faaSDavid Teigland 234b3b94faaSDavid Teigland /** 235b3b94faaSDavid Teigland * gfs2_log_release - Release a given number of log blocks 236b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 237b3b94faaSDavid Teigland * @blks: The number of blocks 238b3b94faaSDavid Teigland * 239b3b94faaSDavid Teigland */ 240b3b94faaSDavid Teigland 241b3b94faaSDavid Teigland void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks) 242b3b94faaSDavid Teigland { 243b3b94faaSDavid Teigland unlock_from_trans(sdp); 244b3b94faaSDavid Teigland 245b3b94faaSDavid Teigland gfs2_log_lock(sdp); 246b3b94faaSDavid Teigland sdp->sd_log_blks_free += blks; 247b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, 248b3b94faaSDavid Teigland sdp->sd_log_blks_free <= sdp->sd_jdesc->jd_blocks); 249b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 250b3b94faaSDavid Teigland } 251b3b94faaSDavid Teigland 252b3b94faaSDavid Teigland static uint64_t log_bmap(struct gfs2_sbd *sdp, unsigned int lbn) 253b3b94faaSDavid Teigland { 254b3b94faaSDavid Teigland int new = 0; 255b3b94faaSDavid Teigland uint64_t dbn; 256b3b94faaSDavid Teigland int error; 257b3b94faaSDavid Teigland 2587359a19cSSteven Whitehouse error = gfs2_block_map(get_v2ip(sdp->sd_jdesc->jd_inode), lbn, &new, &dbn, NULL); 259b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !error && dbn); 260b3b94faaSDavid Teigland 261b3b94faaSDavid Teigland return dbn; 262b3b94faaSDavid Teigland } 263b3b94faaSDavid Teigland 264b3b94faaSDavid Teigland /** 265b3b94faaSDavid Teigland * log_distance - Compute distance between two journal blocks 266b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 267b3b94faaSDavid Teigland * @newer: The most recent journal block of the pair 268b3b94faaSDavid Teigland * @older: The older journal block of the pair 269b3b94faaSDavid Teigland * 270b3b94faaSDavid Teigland * Compute the distance (in the journal direction) between two 271b3b94faaSDavid Teigland * blocks in the journal 272b3b94faaSDavid Teigland * 273b3b94faaSDavid Teigland * Returns: the distance in blocks 274b3b94faaSDavid Teigland */ 275b3b94faaSDavid Teigland 276b3b94faaSDavid Teigland static inline unsigned int log_distance(struct gfs2_sbd *sdp, 277b3b94faaSDavid Teigland unsigned int newer, 278b3b94faaSDavid Teigland unsigned int older) 279b3b94faaSDavid Teigland { 280b3b94faaSDavid Teigland int dist; 281b3b94faaSDavid Teigland 282b3b94faaSDavid Teigland dist = newer - older; 283b3b94faaSDavid Teigland if (dist < 0) 284b3b94faaSDavid Teigland dist += sdp->sd_jdesc->jd_blocks; 285b3b94faaSDavid Teigland 286b3b94faaSDavid Teigland return dist; 287b3b94faaSDavid Teigland } 288b3b94faaSDavid Teigland 289b3b94faaSDavid Teigland static unsigned int current_tail(struct gfs2_sbd *sdp) 290b3b94faaSDavid Teigland { 291b3b94faaSDavid Teigland struct gfs2_ail *ai; 292b3b94faaSDavid Teigland unsigned int tail; 293b3b94faaSDavid Teigland 294b3b94faaSDavid Teigland gfs2_log_lock(sdp); 295b3b94faaSDavid Teigland 296b3b94faaSDavid Teigland if (list_empty(&sdp->sd_ail1_list)) 297b3b94faaSDavid Teigland tail = sdp->sd_log_head; 298b3b94faaSDavid Teigland else { 299b3b94faaSDavid Teigland ai = list_entry(sdp->sd_ail1_list.prev, 300b3b94faaSDavid Teigland struct gfs2_ail, ai_list); 301b3b94faaSDavid Teigland tail = ai->ai_first; 302b3b94faaSDavid Teigland } 303b3b94faaSDavid Teigland 304b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 305b3b94faaSDavid Teigland 306b3b94faaSDavid Teigland return tail; 307b3b94faaSDavid Teigland } 308b3b94faaSDavid Teigland 309b3b94faaSDavid Teigland static inline void log_incr_head(struct gfs2_sbd *sdp) 310b3b94faaSDavid Teigland { 311b3b94faaSDavid Teigland if (sdp->sd_log_flush_head == sdp->sd_log_tail) 312b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, 313b3b94faaSDavid Teigland sdp->sd_log_flush_head == sdp->sd_log_head); 314b3b94faaSDavid Teigland 315b3b94faaSDavid Teigland if (++sdp->sd_log_flush_head == sdp->sd_jdesc->jd_blocks) { 316b3b94faaSDavid Teigland sdp->sd_log_flush_head = 0; 317b3b94faaSDavid Teigland sdp->sd_log_flush_wrapped = 1; 318b3b94faaSDavid Teigland } 319b3b94faaSDavid Teigland } 320b3b94faaSDavid Teigland 321b3b94faaSDavid Teigland /** 322b3b94faaSDavid Teigland * gfs2_log_get_buf - Get and initialize a buffer to use for log control data 323b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 324b3b94faaSDavid Teigland * 325b3b94faaSDavid Teigland * Returns: the buffer_head 326b3b94faaSDavid Teigland */ 327b3b94faaSDavid Teigland 328b3b94faaSDavid Teigland struct buffer_head *gfs2_log_get_buf(struct gfs2_sbd *sdp) 329b3b94faaSDavid Teigland { 330b3b94faaSDavid Teigland uint64_t blkno = log_bmap(sdp, sdp->sd_log_flush_head); 331b3b94faaSDavid Teigland struct gfs2_log_buf *lb; 332b3b94faaSDavid Teigland struct buffer_head *bh; 333b3b94faaSDavid Teigland 3344f3df041SSteven Whitehouse lb = kzalloc(sizeof(struct gfs2_log_buf), GFP_NOFS | __GFP_NOFAIL); 335b3b94faaSDavid Teigland list_add(&lb->lb_list, &sdp->sd_log_flush_list); 336b3b94faaSDavid Teigland 337b3b94faaSDavid Teigland bh = lb->lb_bh = sb_getblk(sdp->sd_vfs, blkno); 338b3b94faaSDavid Teigland lock_buffer(bh); 339b3b94faaSDavid Teigland memset(bh->b_data, 0, bh->b_size); 340b3b94faaSDavid Teigland set_buffer_uptodate(bh); 341b3b94faaSDavid Teigland clear_buffer_dirty(bh); 342b3b94faaSDavid Teigland unlock_buffer(bh); 343b3b94faaSDavid Teigland 344b3b94faaSDavid Teigland log_incr_head(sdp); 345b3b94faaSDavid Teigland 346b3b94faaSDavid Teigland return bh; 347b3b94faaSDavid Teigland } 348b3b94faaSDavid Teigland 349b3b94faaSDavid Teigland /** 350b3b94faaSDavid Teigland * gfs2_log_fake_buf - Build a fake buffer head to write metadata buffer to log 351b3b94faaSDavid Teigland * @sdp: the filesystem 352b3b94faaSDavid Teigland * @data: the data the buffer_head should point to 353b3b94faaSDavid Teigland * 354b3b94faaSDavid Teigland * Returns: the log buffer descriptor 355b3b94faaSDavid Teigland */ 356b3b94faaSDavid Teigland 357b3b94faaSDavid Teigland struct buffer_head *gfs2_log_fake_buf(struct gfs2_sbd *sdp, 358b3b94faaSDavid Teigland struct buffer_head *real) 359b3b94faaSDavid Teigland { 360b3b94faaSDavid Teigland uint64_t blkno = log_bmap(sdp, sdp->sd_log_flush_head); 361b3b94faaSDavid Teigland struct gfs2_log_buf *lb; 362b3b94faaSDavid Teigland struct buffer_head *bh; 363b3b94faaSDavid Teigland 3644f3df041SSteven Whitehouse lb = kzalloc(sizeof(struct gfs2_log_buf), GFP_NOFS | __GFP_NOFAIL); 365b3b94faaSDavid Teigland list_add(&lb->lb_list, &sdp->sd_log_flush_list); 366b3b94faaSDavid Teigland lb->lb_real = real; 367b3b94faaSDavid Teigland 368b3b94faaSDavid Teigland bh = lb->lb_bh = alloc_buffer_head(GFP_NOFS | __GFP_NOFAIL); 369b3b94faaSDavid Teigland atomic_set(&bh->b_count, 1); 370b3b94faaSDavid Teigland bh->b_state = (1 << BH_Mapped) | (1 << BH_Uptodate); 37118ec7d5cSSteven Whitehouse set_bh_page(bh, real->b_page, bh_offset(real)); 372b3b94faaSDavid Teigland bh->b_blocknr = blkno; 373b3b94faaSDavid Teigland bh->b_size = sdp->sd_sb.sb_bsize; 374b3b94faaSDavid Teigland bh->b_bdev = sdp->sd_vfs->s_bdev; 375b3b94faaSDavid Teigland 376b3b94faaSDavid Teigland log_incr_head(sdp); 377b3b94faaSDavid Teigland 378b3b94faaSDavid Teigland return bh; 379b3b94faaSDavid Teigland } 380b3b94faaSDavid Teigland 381b3b94faaSDavid Teigland static void log_pull_tail(struct gfs2_sbd *sdp, unsigned int new_tail, int pull) 382b3b94faaSDavid Teigland { 383b3b94faaSDavid Teigland unsigned int dist = log_distance(sdp, new_tail, sdp->sd_log_tail); 384b3b94faaSDavid Teigland 385b3b94faaSDavid Teigland ail2_empty(sdp, new_tail); 386b3b94faaSDavid Teigland 387b3b94faaSDavid Teigland gfs2_log_lock(sdp); 388b3b94faaSDavid Teigland sdp->sd_log_blks_free += dist - ((pull) ? 1 : 0); 389b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, 390b3b94faaSDavid Teigland sdp->sd_log_blks_free <= sdp->sd_jdesc->jd_blocks); 391b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 392b3b94faaSDavid Teigland 393b3b94faaSDavid Teigland sdp->sd_log_tail = new_tail; 394b3b94faaSDavid Teigland } 395b3b94faaSDavid Teigland 396b3b94faaSDavid Teigland /** 397b3b94faaSDavid Teigland * log_write_header - Get and initialize a journal header buffer 398b3b94faaSDavid Teigland * @sdp: The GFS2 superblock 399b3b94faaSDavid Teigland * 400b3b94faaSDavid Teigland * Returns: the initialized log buffer descriptor 401b3b94faaSDavid Teigland */ 402b3b94faaSDavid Teigland 403b3b94faaSDavid Teigland static void log_write_header(struct gfs2_sbd *sdp, uint32_t flags, int pull) 404b3b94faaSDavid Teigland { 405b3b94faaSDavid Teigland uint64_t blkno = log_bmap(sdp, sdp->sd_log_flush_head); 406b3b94faaSDavid Teigland struct buffer_head *bh; 407b3b94faaSDavid Teigland struct gfs2_log_header *lh; 408b3b94faaSDavid Teigland unsigned int tail; 409b3b94faaSDavid Teigland uint32_t hash; 410b3b94faaSDavid Teigland 411b3b94faaSDavid Teigland atomic_inc(&sdp->sd_log_flush_ondisk); 412b3b94faaSDavid Teigland 413b3b94faaSDavid Teigland bh = sb_getblk(sdp->sd_vfs, blkno); 414b3b94faaSDavid Teigland lock_buffer(bh); 415b3b94faaSDavid Teigland memset(bh->b_data, 0, bh->b_size); 416b3b94faaSDavid Teigland set_buffer_uptodate(bh); 417b3b94faaSDavid Teigland clear_buffer_dirty(bh); 418b3b94faaSDavid Teigland unlock_buffer(bh); 419b3b94faaSDavid Teigland 420b3b94faaSDavid Teigland gfs2_ail1_empty(sdp, 0); 421b3b94faaSDavid Teigland tail = current_tail(sdp); 422b3b94faaSDavid Teigland 423b3b94faaSDavid Teigland lh = (struct gfs2_log_header *)bh->b_data; 424b3b94faaSDavid Teigland memset(lh, 0, sizeof(struct gfs2_log_header)); 425b3b94faaSDavid Teigland lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 426b3b94faaSDavid Teigland lh->lh_header.mh_type = cpu_to_be16(GFS2_METATYPE_LH); 427b3b94faaSDavid Teigland lh->lh_header.mh_format = cpu_to_be16(GFS2_FORMAT_LH); 428b3b94faaSDavid Teigland lh->lh_sequence = be64_to_cpu(sdp->sd_log_sequence++); 429b3b94faaSDavid Teigland lh->lh_flags = be32_to_cpu(flags); 430b3b94faaSDavid Teigland lh->lh_tail = be32_to_cpu(tail); 431b3b94faaSDavid Teigland lh->lh_blkno = be32_to_cpu(sdp->sd_log_flush_head); 432b3b94faaSDavid Teigland hash = gfs2_disk_hash(bh->b_data, sizeof(struct gfs2_log_header)); 433b3b94faaSDavid Teigland lh->lh_hash = cpu_to_be32(hash); 434b3b94faaSDavid Teigland 435b3b94faaSDavid Teigland set_buffer_dirty(bh); 436b3b94faaSDavid Teigland if (sync_dirty_buffer(bh)) 437b3b94faaSDavid Teigland gfs2_io_error_bh(sdp, bh); 438b3b94faaSDavid Teigland brelse(bh); 439b3b94faaSDavid Teigland 440b3b94faaSDavid Teigland if (sdp->sd_log_tail != tail) 441b3b94faaSDavid Teigland log_pull_tail(sdp, tail, pull); 442b3b94faaSDavid Teigland else 443b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !pull); 444b3b94faaSDavid Teigland 445b3b94faaSDavid Teigland sdp->sd_log_idle = (tail == sdp->sd_log_flush_head); 446b3b94faaSDavid Teigland log_incr_head(sdp); 447b3b94faaSDavid Teigland } 448b3b94faaSDavid Teigland 449b3b94faaSDavid Teigland static void log_flush_commit(struct gfs2_sbd *sdp) 450b3b94faaSDavid Teigland { 451b3b94faaSDavid Teigland struct list_head *head = &sdp->sd_log_flush_list; 452b3b94faaSDavid Teigland struct gfs2_log_buf *lb; 453b3b94faaSDavid Teigland struct buffer_head *bh; 454b3b94faaSDavid Teigland unsigned int d; 455b3b94faaSDavid Teigland 456b3b94faaSDavid Teigland d = log_distance(sdp, sdp->sd_log_flush_head, sdp->sd_log_head); 457b3b94faaSDavid Teigland 458b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, d + 1 == sdp->sd_log_blks_reserved); 459b3b94faaSDavid Teigland 460b3b94faaSDavid Teigland while (!list_empty(head)) { 461b3b94faaSDavid Teigland lb = list_entry(head->next, struct gfs2_log_buf, lb_list); 462b3b94faaSDavid Teigland list_del(&lb->lb_list); 463b3b94faaSDavid Teigland bh = lb->lb_bh; 464b3b94faaSDavid Teigland 465b3b94faaSDavid Teigland wait_on_buffer(bh); 466b3b94faaSDavid Teigland if (!buffer_uptodate(bh)) 467b3b94faaSDavid Teigland gfs2_io_error_bh(sdp, bh); 468b3b94faaSDavid Teigland if (lb->lb_real) { 469b3b94faaSDavid Teigland while (atomic_read(&bh->b_count) != 1) /* Grrrr... */ 470b3b94faaSDavid Teigland schedule(); 471b3b94faaSDavid Teigland free_buffer_head(bh); 472b3b94faaSDavid Teigland } else 473b3b94faaSDavid Teigland brelse(bh); 474b3b94faaSDavid Teigland kfree(lb); 475b3b94faaSDavid Teigland } 476b3b94faaSDavid Teigland 477b3b94faaSDavid Teigland log_write_header(sdp, 0, 0); 478b3b94faaSDavid Teigland } 479b3b94faaSDavid Teigland 480b3b94faaSDavid Teigland /** 481b3b94faaSDavid Teigland * gfs2_log_flush_i - flush incore transaction(s) 482b3b94faaSDavid Teigland * @sdp: the filesystem 483b3b94faaSDavid Teigland * @gl: The glock structure to flush. If NULL, flush the whole incore log 484b3b94faaSDavid Teigland * 485b3b94faaSDavid Teigland */ 486b3b94faaSDavid Teigland 487b3b94faaSDavid Teigland void gfs2_log_flush_i(struct gfs2_sbd *sdp, struct gfs2_glock *gl) 488b3b94faaSDavid Teigland { 489b3b94faaSDavid Teigland struct gfs2_ail *ai; 490b3b94faaSDavid Teigland 491b3b94faaSDavid Teigland atomic_inc(&sdp->sd_log_flush_incore); 492b3b94faaSDavid Teigland 4934f3df041SSteven Whitehouse ai = kzalloc(sizeof(struct gfs2_ail), GFP_NOFS | __GFP_NOFAIL); 494b3b94faaSDavid Teigland INIT_LIST_HEAD(&ai->ai_ail1_list); 495b3b94faaSDavid Teigland INIT_LIST_HEAD(&ai->ai_ail2_list); 496b3b94faaSDavid Teigland gfs2_lock_for_flush(sdp); 497*f55ab26aSSteven Whitehouse 498*f55ab26aSSteven Whitehouse if (gl) { 499*f55ab26aSSteven Whitehouse gfs2_log_lock(sdp); 500*f55ab26aSSteven Whitehouse if (list_empty(&gl->gl_le.le_list)) { 501*f55ab26aSSteven Whitehouse gfs2_log_unlock(sdp); 502*f55ab26aSSteven Whitehouse gfs2_unlock_from_flush(sdp); 503*f55ab26aSSteven Whitehouse kfree(ai); 504*f55ab26aSSteven Whitehouse return; 505*f55ab26aSSteven Whitehouse } 506*f55ab26aSSteven Whitehouse gfs2_log_unlock(sdp); 507*f55ab26aSSteven Whitehouse } 508*f55ab26aSSteven Whitehouse 509*f55ab26aSSteven Whitehouse mutex_lock(&sdp->sd_log_flush_lock); 510b3b94faaSDavid Teigland 511b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, 512b3b94faaSDavid Teigland sdp->sd_log_num_buf == sdp->sd_log_commited_buf); 513b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, 514b3b94faaSDavid Teigland sdp->sd_log_num_revoke == sdp->sd_log_commited_revoke); 515b3b94faaSDavid Teigland 516b3b94faaSDavid Teigland sdp->sd_log_flush_head = sdp->sd_log_head; 517b3b94faaSDavid Teigland sdp->sd_log_flush_wrapped = 0; 518b3b94faaSDavid Teigland ai->ai_first = sdp->sd_log_flush_head; 519b3b94faaSDavid Teigland 520b3b94faaSDavid Teigland lops_before_commit(sdp); 521b3b94faaSDavid Teigland if (!list_empty(&sdp->sd_log_flush_list)) 522b3b94faaSDavid Teigland log_flush_commit(sdp); 523b3b94faaSDavid Teigland else if (sdp->sd_log_tail != current_tail(sdp) && !sdp->sd_log_idle) 524b3b94faaSDavid Teigland log_write_header(sdp, 0, PULL); 525b3b94faaSDavid Teigland lops_after_commit(sdp, ai); 526b3b94faaSDavid Teigland sdp->sd_log_head = sdp->sd_log_flush_head; 527b3b94faaSDavid Teigland if (sdp->sd_log_flush_wrapped) 528b3b94faaSDavid Teigland sdp->sd_log_wraps++; 529b3b94faaSDavid Teigland 530b3b94faaSDavid Teigland sdp->sd_log_blks_reserved = 531b3b94faaSDavid Teigland sdp->sd_log_commited_buf = 532b3b94faaSDavid Teigland sdp->sd_log_commited_revoke = 0; 533b3b94faaSDavid Teigland 534b3b94faaSDavid Teigland gfs2_log_lock(sdp); 535b3b94faaSDavid Teigland if (!list_empty(&ai->ai_ail1_list)) { 536b3b94faaSDavid Teigland list_add(&ai->ai_list, &sdp->sd_ail1_list); 537b3b94faaSDavid Teigland ai = NULL; 538b3b94faaSDavid Teigland } 539b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 540b3b94faaSDavid Teigland 541*f55ab26aSSteven Whitehouse mutex_unlock(&sdp->sd_log_flush_lock); 542b3b94faaSDavid Teigland sdp->sd_vfs->s_dirt = 0; 543b3b94faaSDavid Teigland gfs2_unlock_from_flush(sdp); 544b3b94faaSDavid Teigland 545b3b94faaSDavid Teigland kfree(ai); 546b3b94faaSDavid Teigland } 547b3b94faaSDavid Teigland 548b3b94faaSDavid Teigland static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 549b3b94faaSDavid Teigland { 550b3b94faaSDavid Teigland unsigned int reserved = 1; 551b3b94faaSDavid Teigland unsigned int old; 552b3b94faaSDavid Teigland 553b3b94faaSDavid Teigland gfs2_log_lock(sdp); 554b3b94faaSDavid Teigland 555b3b94faaSDavid Teigland sdp->sd_log_commited_buf += tr->tr_num_buf_new - tr->tr_num_buf_rm; 556b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, ((int)sdp->sd_log_commited_buf) >= 0); 557b3b94faaSDavid Teigland sdp->sd_log_commited_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm; 558b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, ((int)sdp->sd_log_commited_revoke) >= 0); 559b3b94faaSDavid Teigland 560b3b94faaSDavid Teigland if (sdp->sd_log_commited_buf) 561b3b94faaSDavid Teigland reserved += 1 + sdp->sd_log_commited_buf + sdp->sd_log_commited_buf/503; 562b3b94faaSDavid Teigland if (sdp->sd_log_commited_revoke) 563b3b94faaSDavid Teigland reserved += gfs2_struct2blk(sdp, sdp->sd_log_commited_revoke, 564b3b94faaSDavid Teigland sizeof(uint64_t)); 565b3b94faaSDavid Teigland 566b3b94faaSDavid Teigland old = sdp->sd_log_blks_free; 567b3b94faaSDavid Teigland sdp->sd_log_blks_free += tr->tr_reserved - 568b3b94faaSDavid Teigland (reserved - sdp->sd_log_blks_reserved); 569b3b94faaSDavid Teigland 570b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, 571b3b94faaSDavid Teigland sdp->sd_log_blks_free >= old); 572b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, 573b3b94faaSDavid Teigland sdp->sd_log_blks_free <= sdp->sd_jdesc->jd_blocks); 574b3b94faaSDavid Teigland 575b3b94faaSDavid Teigland sdp->sd_log_blks_reserved = reserved; 576b3b94faaSDavid Teigland 577b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 578b3b94faaSDavid Teigland } 579b3b94faaSDavid Teigland 580b3b94faaSDavid Teigland /** 581b3b94faaSDavid Teigland * gfs2_log_commit - Commit a transaction to the log 582b3b94faaSDavid Teigland * @sdp: the filesystem 583b3b94faaSDavid Teigland * @tr: the transaction 584b3b94faaSDavid Teigland * 585b3b94faaSDavid Teigland * Returns: errno 586b3b94faaSDavid Teigland */ 587b3b94faaSDavid Teigland 588b3b94faaSDavid Teigland void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr) 589b3b94faaSDavid Teigland { 590b3b94faaSDavid Teigland log_refund(sdp, tr); 591b3b94faaSDavid Teigland lops_incore_commit(sdp, tr); 592b3b94faaSDavid Teigland 593b3b94faaSDavid Teigland sdp->sd_vfs->s_dirt = 1; 594b3b94faaSDavid Teigland unlock_from_trans(sdp); 595b3b94faaSDavid Teigland 596b3b94faaSDavid Teigland kfree(tr); 597b3b94faaSDavid Teigland 598b3b94faaSDavid Teigland gfs2_log_lock(sdp); 599b3b94faaSDavid Teigland if (sdp->sd_log_num_buf > gfs2_tune_get(sdp, gt_incore_log_blocks)) { 600b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 601b3b94faaSDavid Teigland gfs2_log_flush(sdp); 602b3b94faaSDavid Teigland } else 603b3b94faaSDavid Teigland gfs2_log_unlock(sdp); 604b3b94faaSDavid Teigland } 605b3b94faaSDavid Teigland 606b3b94faaSDavid Teigland /** 607b3b94faaSDavid Teigland * gfs2_log_shutdown - write a shutdown header into a journal 608b3b94faaSDavid Teigland * @sdp: the filesystem 609b3b94faaSDavid Teigland * 610b3b94faaSDavid Teigland */ 611b3b94faaSDavid Teigland 612b3b94faaSDavid Teigland void gfs2_log_shutdown(struct gfs2_sbd *sdp) 613b3b94faaSDavid Teigland { 614*f55ab26aSSteven Whitehouse mutex_lock(&sdp->sd_log_flush_lock); 615b3b94faaSDavid Teigland 616b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !atomic_read(&sdp->sd_log_trans_count)); 617b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved); 618b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_gl); 619b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_buf); 62018ec7d5cSSteven Whitehouse gfs2_assert_withdraw(sdp, !sdp->sd_log_num_jdata); 621b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke); 622b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_rg); 623b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, !sdp->sd_log_num_databuf); 624b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list)); 625b3b94faaSDavid Teigland 626b3b94faaSDavid Teigland sdp->sd_log_flush_head = sdp->sd_log_head; 627b3b94faaSDavid Teigland sdp->sd_log_flush_wrapped = 0; 628b3b94faaSDavid Teigland 629b3b94faaSDavid Teigland log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT, 0); 630b3b94faaSDavid Teigland 631b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, sdp->sd_log_blks_free == 632b3b94faaSDavid Teigland sdp->sd_jdesc->jd_blocks); 633b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, sdp->sd_log_head == sdp->sd_log_tail); 634b3b94faaSDavid Teigland gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail2_list)); 635b3b94faaSDavid Teigland 636b3b94faaSDavid Teigland sdp->sd_log_head = sdp->sd_log_flush_head; 637b3b94faaSDavid Teigland if (sdp->sd_log_flush_wrapped) 638b3b94faaSDavid Teigland sdp->sd_log_wraps++; 639b3b94faaSDavid Teigland sdp->sd_log_tail = sdp->sd_log_head; 640b3b94faaSDavid Teigland 641*f55ab26aSSteven Whitehouse mutex_unlock(&sdp->sd_log_flush_lock); 642b3b94faaSDavid Teigland } 643b3b94faaSDavid Teigland 644