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