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