[net-next-2.6.git] / fs / gfs2 / log.c

/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
 * of the GNU General Public License version 2.
 */

#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/gfs2_ondisk.h>
#include <linux/crc32.h>
#include <linux/lm_interface.h>
#include <linux/delay.h>

#include "gfs2.h"
#include "incore.h"
#include "bmap.h"
#include "glock.h"
#include "log.h"
#include "lops.h"
#include "meta_io.h"
#include "util.h"
#include "dir.h"

#define PULL 1

/**
 * gfs2_struct2blk - compute stuff
 * @sdp: the filesystem
 * @nstruct: the number of structures
 * @ssize: the size of the structures
 *
 * Compute the number of log descriptor blocks needed to hold a certain number
 * of structures of a certain size.
 *
 * Returns: the number of blocks needed (minimum is always 1)
 */

unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct,
			     unsigned int ssize)
{
	unsigned int blks;
	unsigned int first, second;

	blks = 1;
	first = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_log_descriptor)) / ssize;

	if (nstruct > first) {
		second = (sdp->sd_sb.sb_bsize -
			  sizeof(struct gfs2_meta_header)) / ssize;
		blks += DIV_ROUND_UP(nstruct - first, second);
	}

	return blks;
}

/**
 * gfs2_ail1_start_one - Start I/O on a part of the AIL
 * @sdp: the filesystem
 * @tr: the part of the AIL
 *
 */

static void gfs2_ail1_start_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai)
{
	struct gfs2_bufdata *bd, *s;
	struct buffer_head *bh;
	int retry;

	BUG_ON(!spin_is_locked(&sdp->sd_log_lock));

	do {
		retry = 0;

		list_for_each_entry_safe_reverse(bd, s, &ai->ai_ail1_list,
						 bd_ail_st_list) {
			bh = bd->bd_bh;

			gfs2_assert(sdp, bd->bd_ail == ai);

			if (!bh){
				list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list);
                                continue;
                        }

			if (!buffer_busy(bh)) {
				if (!buffer_uptodate(bh)) {
					gfs2_log_unlock(sdp);
					gfs2_io_error_bh(sdp, bh);
					gfs2_log_lock(sdp);
				}
				list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list);
				continue;
			}

			if (!buffer_dirty(bh))
				continue;

			list_move(&bd->bd_ail_st_list, &ai->ai_ail1_list);

			gfs2_log_unlock(sdp);
			wait_on_buffer(bh);
			ll_rw_block(WRITE, 1, &bh);
			gfs2_log_lock(sdp);

			retry = 1;
			break;
		}
	} while (retry);
}

/**
 * gfs2_ail1_empty_one - Check whether or not a trans in the AIL has been synced
 * @sdp: the filesystem
 * @ai: the AIL entry
 *
 */

static int gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai, int flags)
{
	struct gfs2_bufdata *bd, *s;
	struct buffer_head *bh;

	list_for_each_entry_safe_reverse(bd, s, &ai->ai_ail1_list,
					 bd_ail_st_list) {
		bh = bd->bd_bh;

		if (!bh){
			list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list);
			continue;
		}

		gfs2_assert(sdp, bd->bd_ail == ai);

		if (buffer_busy(bh)) {
			if (flags & DIO_ALL)
				continue;
			else
				break;
		}

		if (!buffer_uptodate(bh))
			gfs2_io_error_bh(sdp, bh);

		list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list);
	}

	return list_empty(&ai->ai_ail1_list);
}

static void gfs2_ail1_start(struct gfs2_sbd *sdp, int flags)
{
	struct list_head *head = &sdp->sd_ail1_list;
	u64 sync_gen;
	struct list_head *first;
	struct gfs2_ail *first_ai, *ai, *tmp;
	int done = 0;

	gfs2_log_lock(sdp);
	if (list_empty(head)) {
		gfs2_log_unlock(sdp);
		return;
	}
	sync_gen = sdp->sd_ail_sync_gen++;

	first = head->prev;
	first_ai = list_entry(first, struct gfs2_ail, ai_list);
	first_ai->ai_sync_gen = sync_gen;
	gfs2_ail1_start_one(sdp, first_ai); /* This may drop log lock */

	if (flags & DIO_ALL)
		first = NULL;

	while(!done) {
		if (first && (head->prev != first ||
			      gfs2_ail1_empty_one(sdp, first_ai, 0)))
			break;

		done = 1;
		list_for_each_entry_safe_reverse(ai, tmp, head, ai_list) {
			if (ai->ai_sync_gen >= sync_gen)
				continue;
			ai->ai_sync_gen = sync_gen;
			gfs2_ail1_start_one(sdp, ai); /* This may drop log lock */
			done = 0;
			break;
		}
	}

	gfs2_log_unlock(sdp);
}

int gfs2_ail1_empty(struct gfs2_sbd *sdp, int flags)
{
	struct gfs2_ail *ai, *s;
	int ret;

	gfs2_log_lock(sdp);

	list_for_each_entry_safe_reverse(ai, s, &sdp->sd_ail1_list, ai_list) {
		if (gfs2_ail1_empty_one(sdp, ai, flags))
			list_move(&ai->ai_list, &sdp->sd_ail2_list);
		else if (!(flags & DIO_ALL))
			break;
	}

	ret = list_empty(&sdp->sd_ail1_list);

	gfs2_log_unlock(sdp);

	return ret;
}


/**
 * gfs2_ail2_empty_one - Check whether or not a trans in the AIL has been synced
 * @sdp: the filesystem
 * @ai: the AIL entry
 *
 */

static void gfs2_ail2_empty_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai)
{
	struct list_head *head = &ai->ai_ail2_list;
	struct gfs2_bufdata *bd;

	while (!list_empty(head)) {
		bd = list_entry(head->prev, struct gfs2_bufdata,
				bd_ail_st_list);
		gfs2_assert(sdp, bd->bd_ail == ai);
		bd->bd_ail = NULL;
		list_del(&bd->bd_ail_st_list);
		list_del(&bd->bd_ail_gl_list);
		atomic_dec(&bd->bd_gl->gl_ail_count);
		if (bd->bd_bh)
			brelse(bd->bd_bh);
		else
			kmem_cache_free(gfs2_bufdata_cachep, bd);
	}
}

static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail)
{
	struct gfs2_ail *ai, *safe;
	unsigned int old_tail = sdp->sd_log_tail;
	int wrap = (new_tail < old_tail);
	int a, b, rm;

	gfs2_log_lock(sdp);

	list_for_each_entry_safe(ai, safe, &sdp->sd_ail2_list, ai_list) {
		a = (old_tail <= ai->ai_first);
		b = (ai->ai_first < new_tail);
		rm = (wrap) ? (a || b) : (a && b);
		if (!rm)
			continue;

		gfs2_ail2_empty_one(sdp, ai);
		list_del(&ai->ai_list);
		gfs2_assert_warn(sdp, list_empty(&ai->ai_ail1_list));
		gfs2_assert_warn(sdp, list_empty(&ai->ai_ail2_list));
		kfree(ai);
	}

	gfs2_log_unlock(sdp);
}

/**
 * gfs2_log_reserve - Make a log reservation
 * @sdp: The GFS2 superblock
 * @blks: The number of blocks to reserve
 *
 * Note that we never give out the last few blocks of the journal. Thats
 * due to the fact that there is are a small number of header blocks
 * associated with each log flush. The exact number can't be known until
 * flush time, so we ensure that we have just enough free blocks at all
 * times to avoid running out during a log flush.
 *
 * Returns: errno
 */

int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks)
{
	unsigned int try = 0;
	unsigned reserved_blks = 6 * (4096 / sdp->sd_vfs->s_blocksize);

	if (gfs2_assert_warn(sdp, blks) ||
	    gfs2_assert_warn(sdp, blks <= sdp->sd_jdesc->jd_blocks))
		return -EINVAL;

	mutex_lock(&sdp->sd_log_reserve_mutex);
	gfs2_log_lock(sdp);
	while(sdp->sd_log_blks_free <= (blks + reserved_blks)) {
		gfs2_log_unlock(sdp);
		gfs2_ail1_empty(sdp, 0);
		gfs2_log_flush(sdp, NULL);

		if (try++)
			gfs2_ail1_start(sdp, 0);
		gfs2_log_lock(sdp);
	}
	sdp->sd_log_blks_free -= blks;
	gfs2_log_unlock(sdp);
	mutex_unlock(&sdp->sd_log_reserve_mutex);

	down_read(&sdp->sd_log_flush_lock);

	return 0;
}

/**
 * gfs2_log_release - Release a given number of log blocks
 * @sdp: The GFS2 superblock
 * @blks: The number of blocks
 *
 */

void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks)
{

	gfs2_log_lock(sdp);
	sdp->sd_log_blks_free += blks;
	gfs2_assert_withdraw(sdp,
			     sdp->sd_log_blks_free <= sdp->sd_jdesc->jd_blocks);
	gfs2_log_unlock(sdp);
	up_read(&sdp->sd_log_flush_lock);
}

static u64 log_bmap(struct gfs2_sbd *sdp, unsigned int lbn)
{
	struct inode *inode = sdp->sd_jdesc->jd_inode;
	int error;
	struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };

	bh_map.b_size = 1 << inode->i_blkbits;
	error = gfs2_block_map(inode, lbn, 0, &bh_map);
	if (error || !bh_map.b_blocknr)
		printk(KERN_INFO "error=%d, dbn=%llu lbn=%u", error,
		       (unsigned long long)bh_map.b_blocknr, lbn);
	gfs2_assert_withdraw(sdp, !error && bh_map.b_blocknr);

	return bh_map.b_blocknr;
}

/**
 * log_distance - Compute distance between two journal blocks
 * @sdp: The GFS2 superblock
 * @newer: The most recent journal block of the pair
 * @older: The older journal block of the pair
 *
 *   Compute the distance (in the journal direction) between two
 *   blocks in the journal
 *
 * Returns: the distance in blocks
 */

static inline unsigned int log_distance(struct gfs2_sbd *sdp, unsigned int newer,
					unsigned int older)
{
	int dist;

	dist = newer - older;
	if (dist < 0)
		dist += sdp->sd_jdesc->jd_blocks;

	return dist;
}

static unsigned int current_tail(struct gfs2_sbd *sdp)
{
	struct gfs2_ail *ai;
	unsigned int tail;

	gfs2_log_lock(sdp);

	if (list_empty(&sdp->sd_ail1_list)) {
		tail = sdp->sd_log_head;
	} else {
		ai = list_entry(sdp->sd_ail1_list.prev, struct gfs2_ail, ai_list);
		tail = ai->ai_first;
	}

	gfs2_log_unlock(sdp);

	return tail;
}

static inline void log_incr_head(struct gfs2_sbd *sdp)
{
	if (sdp->sd_log_flush_head == sdp->sd_log_tail)
		gfs2_assert_withdraw(sdp, sdp->sd_log_flush_head == sdp->sd_log_head);

	if (++sdp->sd_log_flush_head == sdp->sd_jdesc->jd_blocks) {
		sdp->sd_log_flush_head = 0;
		sdp->sd_log_flush_wrapped = 1;
	}
}

/**
 * gfs2_log_get_buf - Get and initialize a buffer to use for log control data
 * @sdp: The GFS2 superblock
 *
 * Returns: the buffer_head
 */

struct buffer_head *gfs2_log_get_buf(struct gfs2_sbd *sdp)
{
	u64 blkno = log_bmap(sdp, sdp->sd_log_flush_head);
	struct gfs2_log_buf *lb;
	struct buffer_head *bh;

	lb = kzalloc(sizeof(struct gfs2_log_buf), GFP_NOFS | __GFP_NOFAIL);
	list_add(&lb->lb_list, &sdp->sd_log_flush_list);

	bh = lb->lb_bh = sb_getblk(sdp->sd_vfs, blkno);
	lock_buffer(bh);
	memset(bh->b_data, 0, bh->b_size);
	set_buffer_uptodate(bh);
	clear_buffer_dirty(bh);
	unlock_buffer(bh);

	log_incr_head(sdp);

	return bh;
}

/**
 * gfs2_log_fake_buf - Build a fake buffer head to write metadata buffer to log
 * @sdp: the filesystem
 * @data: the data the buffer_head should point to
 *
 * Returns: the log buffer descriptor
 */

struct buffer_head *gfs2_log_fake_buf(struct gfs2_sbd *sdp,
				      struct buffer_head *real)
{
	u64 blkno = log_bmap(sdp, sdp->sd_log_flush_head);
	struct gfs2_log_buf *lb;
	struct buffer_head *bh;

	lb = kzalloc(sizeof(struct gfs2_log_buf), GFP_NOFS | __GFP_NOFAIL);
	list_add(&lb->lb_list, &sdp->sd_log_flush_list);
	lb->lb_real = real;

	bh = lb->lb_bh = alloc_buffer_head(GFP_NOFS | __GFP_NOFAIL);
	atomic_set(&bh->b_count, 1);
	bh->b_state = (1 << BH_Mapped) | (1 << BH_Uptodate);
	set_bh_page(bh, real->b_page, bh_offset(real));
	bh->b_blocknr = blkno;
	bh->b_size = sdp->sd_sb.sb_bsize;
	bh->b_bdev = sdp->sd_vfs->s_bdev;

	log_incr_head(sdp);

	return bh;
}

static void log_pull_tail(struct gfs2_sbd *sdp, unsigned int new_tail, int pull)
{
	unsigned int dist = log_distance(sdp, new_tail, sdp->sd_log_tail);

	ail2_empty(sdp, new_tail);

	gfs2_log_lock(sdp);
	sdp->sd_log_blks_free += dist - (pull ? 1 : 0);
	gfs2_assert_withdraw(sdp, sdp->sd_log_blks_free <= sdp->sd_jdesc->jd_blocks);
	gfs2_log_unlock(sdp);

	sdp->sd_log_tail = new_tail;
}

/**
 * log_write_header - Get and initialize a journal header buffer
 * @sdp: The GFS2 superblock
 *
 * Returns: the initialized log buffer descriptor
 */

static void log_write_header(struct gfs2_sbd *sdp, u32 flags, int pull)
{
	u64 blkno = log_bmap(sdp, sdp->sd_log_flush_head);
	struct buffer_head *bh;
	struct gfs2_log_header *lh;
	unsigned int tail;
	u32 hash;

	bh = sb_getblk(sdp->sd_vfs, blkno);
	lock_buffer(bh);
	memset(bh->b_data, 0, bh->b_size);
	set_buffer_uptodate(bh);
	clear_buffer_dirty(bh);
	unlock_buffer(bh);

	gfs2_ail1_empty(sdp, 0);
	tail = current_tail(sdp);

	lh = (struct gfs2_log_header *)bh->b_data;
	memset(lh, 0, sizeof(struct gfs2_log_header));
	lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
	lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
	lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
	lh->lh_sequence = cpu_to_be64(sdp->sd_log_sequence++);
	lh->lh_flags = cpu_to_be32(flags);
	lh->lh_tail = cpu_to_be32(tail);
	lh->lh_blkno = cpu_to_be32(sdp->sd_log_flush_head);
	hash = gfs2_disk_hash(bh->b_data, sizeof(struct gfs2_log_header));
	lh->lh_hash = cpu_to_be32(hash);

	set_buffer_dirty(bh);
	if (sync_dirty_buffer(bh))
		gfs2_io_error_bh(sdp, bh);
	brelse(bh);

	if (sdp->sd_log_tail != tail)
		log_pull_tail(sdp, tail, pull);
	else
		gfs2_assert_withdraw(sdp, !pull);

	sdp->sd_log_idle = (tail == sdp->sd_log_flush_head);
	log_incr_head(sdp);
}

static void log_flush_commit(struct gfs2_sbd *sdp)
{
	struct list_head *head = &sdp->sd_log_flush_list;
	struct gfs2_log_buf *lb;
	struct buffer_head *bh;

	while (!list_empty(head)) {
		lb = list_entry(head->next, struct gfs2_log_buf, lb_list);
		list_del(&lb->lb_list);
		bh = lb->lb_bh;

		wait_on_buffer(bh);
		if (!buffer_uptodate(bh))
			gfs2_io_error_bh(sdp, bh);
		if (lb->lb_real) {
			while (atomic_read(&bh->b_count) != 1)  /* Grrrr... */
				schedule();
			free_buffer_head(bh);
		} else
			brelse(bh);
		kfree(lb);
	}

	log_write_header(sdp, 0, 0);
}

/**
 * gfs2_log_flush - flush incore transaction(s)
 * @sdp: the filesystem
 * @gl: The glock structure to flush.  If NULL, flush the whole incore log
 *
 */

void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl)
{
	struct gfs2_ail *ai;

	down_write(&sdp->sd_log_flush_lock);

	if (gl) {
		gfs2_log_lock(sdp);
		if (list_empty(&gl->gl_le.le_list)) {
			gfs2_log_unlock(sdp);
			up_write(&sdp->sd_log_flush_lock);
			return;
		}
		gfs2_log_unlock(sdp);
	}

	ai = kzalloc(sizeof(struct gfs2_ail), GFP_NOFS | __GFP_NOFAIL);
	INIT_LIST_HEAD(&ai->ai_ail1_list);
	INIT_LIST_HEAD(&ai->ai_ail2_list);

	gfs2_assert_withdraw(sdp, sdp->sd_log_num_buf + sdp->sd_log_num_jdata == sdp->sd_log_commited_buf);
	gfs2_assert_withdraw(sdp,
			sdp->sd_log_num_revoke == sdp->sd_log_commited_revoke);

	sdp->sd_log_flush_head = sdp->sd_log_head;
	sdp->sd_log_flush_wrapped = 0;
	ai->ai_first = sdp->sd_log_flush_head;

	lops_before_commit(sdp);
	if (!list_empty(&sdp->sd_log_flush_list))
		log_flush_commit(sdp);
	else if (sdp->sd_log_tail != current_tail(sdp) && !sdp->sd_log_idle)
		log_write_header(sdp, 0, PULL);
	lops_after_commit(sdp, ai);

	gfs2_log_lock(sdp);
	sdp->sd_log_head = sdp->sd_log_flush_head;
	sdp->sd_log_blks_free -= sdp->sd_log_num_hdrs;
	sdp->sd_log_blks_reserved = 0;
	sdp->sd_log_commited_buf = 0;
	sdp->sd_log_num_hdrs = 0;
	sdp->sd_log_commited_revoke = 0;

	if (!list_empty(&ai->ai_ail1_list)) {
		list_add(&ai->ai_list, &sdp->sd_ail1_list);
		ai = NULL;
	}
	gfs2_log_unlock(sdp);

	sdp->sd_vfs->s_dirt = 0;
	up_write(&sdp->sd_log_flush_lock);

	kfree(ai);
}

static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
{
	unsigned int reserved = 0;
	unsigned int old;

	gfs2_log_lock(sdp);

	sdp->sd_log_commited_buf += tr->tr_num_buf_new - tr->tr_num_buf_rm;
	gfs2_assert_withdraw(sdp, ((int)sdp->sd_log_commited_buf) >= 0);
	sdp->sd_log_commited_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm;
	gfs2_assert_withdraw(sdp, ((int)sdp->sd_log_commited_revoke) >= 0);

	if (sdp->sd_log_commited_buf)
		reserved += sdp->sd_log_commited_buf;
	if (sdp->sd_log_commited_revoke)
		reserved += gfs2_struct2blk(sdp, sdp->sd_log_commited_revoke,
					    sizeof(u64));
	if (reserved)
		reserved++;

	old = sdp->sd_log_blks_free;
	sdp->sd_log_blks_free += tr->tr_reserved -
				 (reserved - sdp->sd_log_blks_reserved);

	gfs2_assert_withdraw(sdp, sdp->sd_log_blks_free >= old);
	gfs2_assert_withdraw(sdp,
			     sdp->sd_log_blks_free <= sdp->sd_jdesc->jd_blocks +
			     sdp->sd_log_num_hdrs);

	sdp->sd_log_blks_reserved = reserved;

	gfs2_log_unlock(sdp);
}

/**
 * gfs2_log_commit - Commit a transaction to the log
 * @sdp: the filesystem
 * @tr: the transaction
 *
 * Returns: errno
 */

void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
{
	log_refund(sdp, tr);
	lops_incore_commit(sdp, tr);

	sdp->sd_vfs->s_dirt = 1;
	up_read(&sdp->sd_log_flush_lock);

	gfs2_log_lock(sdp);
	if (sdp->sd_log_num_buf > gfs2_tune_get(sdp, gt_incore_log_blocks))
		wake_up_process(sdp->sd_logd_process);
	gfs2_log_unlock(sdp);
}

/**
 * gfs2_log_shutdown - write a shutdown header into a journal
 * @sdp: the filesystem
 *
 */

void gfs2_log_shutdown(struct gfs2_sbd *sdp)
{
	down_write(&sdp->sd_log_flush_lock);

	gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved);
	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_gl);
	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_buf);
	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_jdata);
	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_rg);
	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_databuf);
	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_hdrs);
	gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list));

	sdp->sd_log_flush_head = sdp->sd_log_head;
	sdp->sd_log_flush_wrapped = 0;

	log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT, 0);

	gfs2_assert_warn(sdp, sdp->sd_log_blks_free == sdp->sd_jdesc->jd_blocks);
	gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail);
	gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list));

	sdp->sd_log_head = sdp->sd_log_flush_head;
	sdp->sd_log_tail = sdp->sd_log_head;

	up_write(&sdp->sd_log_flush_lock);
}


/**
 * gfs2_meta_syncfs - sync all the buffers in a filesystem
 * @sdp: the filesystem
 *
 */

void gfs2_meta_syncfs(struct gfs2_sbd *sdp)
{
	gfs2_log_flush(sdp, NULL);
	for (;;) {
		gfs2_ail1_start(sdp, DIO_ALL);
		if (gfs2_ail1_empty(sdp, DIO_ALL))
			break;
		msleep(10);
	}
}
Commit	Line	Data
b3b94faa DT	1	/*
b3b94faa DT	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3a8a9a10	3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
b3b94faa DT	4	*
	5	* This copyrighted material is made available to anyone wishing to use,
	6	* modify, copy, or redistribute it subject to the terms and conditions
e9fc2aa0	7	* of the GNU General Public License version 2.
b3b94faa DT	8	*/
	9
	10	#include <linux/sched.h>
	11	#include <linux/slab.h>
	12	#include <linux/spinlock.h>
	13	#include <linux/completion.h>
	14	#include <linux/buffer_head.h>
5c676f6d	15	#include <linux/gfs2_ondisk.h>
71b86f56	16	#include <linux/crc32.h>
7d308590	17	#include <linux/lm_interface.h>
a25311c8	18	#include <linux/delay.h>
b3b94faa DT	19
b3b94faa DT	20	#include "gfs2.h"
5c676f6d	21	#include "incore.h"
b3b94faa DT	22	#include "bmap.h"
	23	#include "glock.h"
	24	#include "log.h"
	25	#include "lops.h"
	26	#include "meta_io.h"
5c676f6d	27	#include "util.h"
71b86f56	28	#include "dir.h"
b3b94faa DT	29
	30	#define PULL 1
	31
b3b94faa DT	32	/**
	33	* gfs2_struct2blk - compute stuff
	34	* @sdp: the filesystem
	35	* @nstruct: the number of structures
	36	* @ssize: the size of the structures
	37	*
	38	* Compute the number of log descriptor blocks needed to hold a certain number
	39	* of structures of a certain size.
	40	*
	41	* Returns: the number of blocks needed (minimum is always 1)
	42	*/
	43
	44	unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct,
	45	unsigned int ssize)
	46	{
	47	unsigned int blks;
	48	unsigned int first, second;
	49
	50	blks = 1;
faa31ce8	51	first = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_log_descriptor)) / ssize;
b3b94faa DT	52
b3b94faa DT	53	if (nstruct > first) {
568f4c96 SW	54	second = (sdp->sd_sb.sb_bsize -
568f4c96 SW	55	sizeof(struct gfs2_meta_header)) / ssize;
5c676f6d	56	blks += DIV_ROUND_UP(nstruct - first, second);
b3b94faa DT	57	}
	58
	59	return blks;
	60	}
	61
ddacfaf7 SW	62	/**
	63	* gfs2_ail1_start_one - Start I/O on a part of the AIL
	64	* @sdp: the filesystem
	65	* @tr: the part of the AIL
	66	*
	67	*/
	68
	69	static void gfs2_ail1_start_one(struct gfs2_sbd sdp, struct gfs2_ail ai)
	70	{
	71	struct gfs2_bufdata bd, s;
	72	struct buffer_head *bh;
	73	int retry;
	74
	75	BUG_ON(!spin_is_locked(&sdp->sd_log_lock));
	76
	77	do {
	78	retry = 0;
	79
	80	list_for_each_entry_safe_reverse(bd, s, &ai->ai_ail1_list,
	81	bd_ail_st_list) {
	82	bh = bd->bd_bh;
	83
	84	gfs2_assert(sdp, bd->bd_ail == ai);
	85
8fb68595 RP	86	if (!bh){
	87	list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list);
	88	continue;
	89	}
	90
ddacfaf7 SW	91	if (!buffer_busy(bh)) {
	92	if (!buffer_uptodate(bh)) {
	93	gfs2_log_unlock(sdp);
	94	gfs2_io_error_bh(sdp, bh);
	95	gfs2_log_lock(sdp);
	96	}
	97	list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list);
	98	continue;
	99	}
	100
	101	if (!buffer_dirty(bh))
	102	continue;
	103
	104	list_move(&bd->bd_ail_st_list, &ai->ai_ail1_list);
	105
	106	gfs2_log_unlock(sdp);
	107	wait_on_buffer(bh);
	108	ll_rw_block(WRITE, 1, &bh);
	109	gfs2_log_lock(sdp);
	110
	111	retry = 1;
	112	break;
	113	}
	114	} while (retry);
	115	}
	116
	117	/**
	118	* gfs2_ail1_empty_one - Check whether or not a trans in the AIL has been synced
	119	* @sdp: the filesystem
	120	* @ai: the AIL entry
	121	*
	122	*/
	123
	124	static int gfs2_ail1_empty_one(struct gfs2_sbd sdp, struct gfs2_ail ai, int flags)
	125	{
	126	struct gfs2_bufdata bd, s;
	127	struct buffer_head *bh;
	128
	129	list_for_each_entry_safe_reverse(bd, s, &ai->ai_ail1_list,
	130	bd_ail_st_list) {
	131	bh = bd->bd_bh;
	132
8fb68595 RP	133	if (!bh){
	134	list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list);
	135	continue;
	136	}
	137
ddacfaf7 SW	138	gfs2_assert(sdp, bd->bd_ail == ai);
	139
	140	if (buffer_busy(bh)) {
	141	if (flags & DIO_ALL)
	142	continue;
	143	else
	144	break;
	145	}
	146
	147	if (!buffer_uptodate(bh))
	148	gfs2_io_error_bh(sdp, bh);
	149
	150	list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list);
	151	}
	152
	153	return list_empty(&ai->ai_ail1_list);
	154	}
	155
a25311c8	156	static void gfs2_ail1_start(struct gfs2_sbd *sdp, int flags)
b3b94faa DT	157	{
b3b94faa DT	158	struct list_head *head = &sdp->sd_ail1_list;
cd915493	159	u64 sync_gen;
74669416 SW	160	struct list_head *first;
	161	struct gfs2_ail first_ai, ai, *tmp;
	162	int done = 0;
b3b94faa DT	163
	164	gfs2_log_lock(sdp);
	165	if (list_empty(head)) {
	166	gfs2_log_unlock(sdp);
	167	return;
	168	}
	169	sync_gen = sdp->sd_ail_sync_gen++;
	170
	171	first = head->prev;
	172	first_ai = list_entry(first, struct gfs2_ail, ai_list);
	173	first_ai->ai_sync_gen = sync_gen;
74669416	174	gfs2_ail1_start_one(sdp, first_ai); /* This may drop log lock */
b3b94faa DT	175
	176	if (flags & DIO_ALL)
	177	first = NULL;
	178
74669416	179	while(!done) {
484adff8 SW	180	if (first && (head->prev != first \|\|
484adff8 SW	181	gfs2_ail1_empty_one(sdp, first_ai, 0)))
b3b94faa DT	182	break;
b3b94faa DT	183
74669416 SW	184	done = 1;
74669416 SW	185	list_for_each_entry_safe_reverse(ai, tmp, head, ai_list) {
b3b94faa DT	186	if (ai->ai_sync_gen >= sync_gen)
	187	continue;
	188	ai->ai_sync_gen = sync_gen;
74669416 SW	189	gfs2_ail1_start_one(sdp, ai); /* This may drop log lock */
74669416 SW	190	done = 0;
b3b94faa DT	191	break;
b3b94faa DT	192	}
b3b94faa DT	193	}
	194
	195	gfs2_log_unlock(sdp);
	196	}
	197
	198	int gfs2_ail1_empty(struct gfs2_sbd *sdp, int flags)
	199	{
	200	struct gfs2_ail ai, s;
	201	int ret;
	202
	203	gfs2_log_lock(sdp);
	204
	205	list_for_each_entry_safe_reverse(ai, s, &sdp->sd_ail1_list, ai_list) {
	206	if (gfs2_ail1_empty_one(sdp, ai, flags))
	207	list_move(&ai->ai_list, &sdp->sd_ail2_list);
	208	else if (!(flags & DIO_ALL))
	209	break;
	210	}
	211
	212	ret = list_empty(&sdp->sd_ail1_list);
	213
	214	gfs2_log_unlock(sdp);
	215
	216	return ret;
	217	}
	218
ddacfaf7 SW	219
	220	/**
	221	* gfs2_ail2_empty_one - Check whether or not a trans in the AIL has been synced
	222	* @sdp: the filesystem
	223	* @ai: the AIL entry
	224	*
	225	*/
	226
	227	static void gfs2_ail2_empty_one(struct gfs2_sbd sdp, struct gfs2_ail ai)
	228	{
	229	struct list_head *head = &ai->ai_ail2_list;
	230	struct gfs2_bufdata *bd;
	231
	232	while (!list_empty(head)) {
	233	bd = list_entry(head->prev, struct gfs2_bufdata,
	234	bd_ail_st_list);
	235	gfs2_assert(sdp, bd->bd_ail == ai);
	236	bd->bd_ail = NULL;
	237	list_del(&bd->bd_ail_st_list);
	238	list_del(&bd->bd_ail_gl_list);
	239	atomic_dec(&bd->bd_gl->gl_ail_count);
8fb68595 RP	240	if (bd->bd_bh)
	241	brelse(bd->bd_bh);
	242	else
	243	kmem_cache_free(gfs2_bufdata_cachep, bd);
ddacfaf7 SW	244	}
	245	}
	246
b3b94faa DT	247	static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail)
	248	{
	249	struct gfs2_ail ai, safe;
	250	unsigned int old_tail = sdp->sd_log_tail;
	251	int wrap = (new_tail < old_tail);
	252	int a, b, rm;
	253
	254	gfs2_log_lock(sdp);
	255
	256	list_for_each_entry_safe(ai, safe, &sdp->sd_ail2_list, ai_list) {
	257	a = (old_tail <= ai->ai_first);
	258	b = (ai->ai_first < new_tail);
	259	rm = (wrap) ? (a \|\| b) : (a && b);
	260	if (!rm)
	261	continue;
	262
	263	gfs2_ail2_empty_one(sdp, ai);
	264	list_del(&ai->ai_list);
	265	gfs2_assert_warn(sdp, list_empty(&ai->ai_ail1_list));
	266	gfs2_assert_warn(sdp, list_empty(&ai->ai_ail2_list));
	267	kfree(ai);
	268	}
	269
	270	gfs2_log_unlock(sdp);
	271	}
	272
	273	/**
	274	* gfs2_log_reserve - Make a log reservation
	275	* @sdp: The GFS2 superblock
	276	* @blks: The number of blocks to reserve
	277	*
89918647	278	* Note that we never give out the last few blocks of the journal. Thats
b004157a SW	279	* due to the fact that there is are a small number of header blocks
	280	* associated with each log flush. The exact number can't be known until
	281	* flush time, so we ensure that we have just enough free blocks at all
	282	* times to avoid running out during a log flush.
	283	*
b3b94faa DT	284	* Returns: errno
	285	*/
	286
	287	int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks)
	288	{
b3b94faa	289	unsigned int try = 0;
89918647	290	unsigned reserved_blks = 6 * (4096 / sdp->sd_vfs->s_blocksize);
b3b94faa DT	291
	292	if (gfs2_assert_warn(sdp, blks) \|\|
	293	gfs2_assert_warn(sdp, blks <= sdp->sd_jdesc->jd_blocks))
	294	return -EINVAL;
	295
71b86f56	296	mutex_lock(&sdp->sd_log_reserve_mutex);
484adff8	297	gfs2_log_lock(sdp);
89918647	298	while(sdp->sd_log_blks_free <= (blks + reserved_blks)) {
b3b94faa	299	gfs2_log_unlock(sdp);
b3b94faa	300	gfs2_ail1_empty(sdp, 0);
b09e593d	301	gfs2_log_flush(sdp, NULL);
b3b94faa DT	302
	303	if (try++)
	304	gfs2_ail1_start(sdp, 0);
484adff8	305	gfs2_log_lock(sdp);
b3b94faa	306	}
484adff8 SW	307	sdp->sd_log_blks_free -= blks;
	308	gfs2_log_unlock(sdp);
	309	mutex_unlock(&sdp->sd_log_reserve_mutex);
	310
	311	down_read(&sdp->sd_log_flush_lock);
b3b94faa DT	312
	313	return 0;
	314	}
	315
	316	/**
	317	* gfs2_log_release - Release a given number of log blocks
	318	* @sdp: The GFS2 superblock
	319	* @blks: The number of blocks
	320	*
	321	*/
	322
	323	void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks)
	324	{
b3b94faa DT	325
	326	gfs2_log_lock(sdp);
	327	sdp->sd_log_blks_free += blks;
	328	gfs2_assert_withdraw(sdp,
	329	sdp->sd_log_blks_free <= sdp->sd_jdesc->jd_blocks);
	330	gfs2_log_unlock(sdp);
ed386507	331	up_read(&sdp->sd_log_flush_lock);
b3b94faa DT	332	}
b3b94faa DT	333
cd915493	334	static u64 log_bmap(struct gfs2_sbd *sdp, unsigned int lbn)
b3b94faa	335	{
23591256	336	struct inode *inode = sdp->sd_jdesc->jd_inode;
b3b94faa	337	int error;
23591256	338	struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
b3b94faa	339
23591256 SW	340	bh_map.b_size = 1 << inode->i_blkbits;
23591256 SW	341	error = gfs2_block_map(inode, lbn, 0, &bh_map);
7a6bbacb	342	if (error \|\| !bh_map.b_blocknr)
aed3255f RK	343	printk(KERN_INFO "error=%d, dbn=%llu lbn=%u", error,
aed3255f RK	344	(unsigned long long)bh_map.b_blocknr, lbn);
7a6bbacb	345	gfs2_assert_withdraw(sdp, !error && bh_map.b_blocknr);
b3b94faa	346
7a6bbacb	347	return bh_map.b_blocknr;
b3b94faa DT	348	}
	349
	350	/**
	351	* log_distance - Compute distance between two journal blocks
	352	* @sdp: The GFS2 superblock
	353	* @newer: The most recent journal block of the pair
	354	* @older: The older journal block of the pair
	355	*
	356	* Compute the distance (in the journal direction) between two
	357	* blocks in the journal
	358	*
	359	* Returns: the distance in blocks
	360	*/
	361
faa31ce8	362	static inline unsigned int log_distance(struct gfs2_sbd *sdp, unsigned int newer,
b3b94faa DT	363	unsigned int older)
	364	{
	365	int dist;
	366
	367	dist = newer - older;
	368	if (dist < 0)
	369	dist += sdp->sd_jdesc->jd_blocks;
	370
	371	return dist;
	372	}
	373
	374	static unsigned int current_tail(struct gfs2_sbd *sdp)
	375	{
	376	struct gfs2_ail *ai;
	377	unsigned int tail;
	378
	379	gfs2_log_lock(sdp);
	380
faa31ce8	381	if (list_empty(&sdp->sd_ail1_list)) {
b3b94faa	382	tail = sdp->sd_log_head;
faa31ce8 SW	383	} else {
faa31ce8 SW	384	ai = list_entry(sdp->sd_ail1_list.prev, struct gfs2_ail, ai_list);
b3b94faa DT	385	tail = ai->ai_first;
	386	}
	387
	388	gfs2_log_unlock(sdp);
	389
	390	return tail;
	391	}
	392
	393	static inline void log_incr_head(struct gfs2_sbd *sdp)
	394	{
	395	if (sdp->sd_log_flush_head == sdp->sd_log_tail)
faa31ce8	396	gfs2_assert_withdraw(sdp, sdp->sd_log_flush_head == sdp->sd_log_head);
b3b94faa DT	397
	398	if (++sdp->sd_log_flush_head == sdp->sd_jdesc->jd_blocks) {
	399	sdp->sd_log_flush_head = 0;
	400	sdp->sd_log_flush_wrapped = 1;
	401	}
	402	}
	403
	404	/**
	405	* gfs2_log_get_buf - Get and initialize a buffer to use for log control data
	406	* @sdp: The GFS2 superblock
	407	*
	408	* Returns: the buffer_head
	409	*/
	410
	411	struct buffer_head gfs2_log_get_buf(struct gfs2_sbd sdp)
	412	{
cd915493	413	u64 blkno = log_bmap(sdp, sdp->sd_log_flush_head);
b3b94faa DT	414	struct gfs2_log_buf *lb;
	415	struct buffer_head *bh;
	416
4f3df041	417	lb = kzalloc(sizeof(struct gfs2_log_buf), GFP_NOFS \| __GFP_NOFAIL);
b3b94faa DT	418	list_add(&lb->lb_list, &sdp->sd_log_flush_list);
	419
	420	bh = lb->lb_bh = sb_getblk(sdp->sd_vfs, blkno);
	421	lock_buffer(bh);
	422	memset(bh->b_data, 0, bh->b_size);
	423	set_buffer_uptodate(bh);
	424	clear_buffer_dirty(bh);
	425	unlock_buffer(bh);
	426
	427	log_incr_head(sdp);
	428
	429	return bh;
	430	}
	431
	432	/**
	433	* gfs2_log_fake_buf - Build a fake buffer head to write metadata buffer to log
	434	* @sdp: the filesystem
	435	* @data: the data the buffer_head should point to
	436	*
	437	* Returns: the log buffer descriptor
	438	*/
	439
	440	struct buffer_head gfs2_log_fake_buf(struct gfs2_sbd sdp,
	441	struct buffer_head *real)
	442	{
cd915493	443	u64 blkno = log_bmap(sdp, sdp->sd_log_flush_head);
b3b94faa DT	444	struct gfs2_log_buf *lb;
	445	struct buffer_head *bh;
	446
4f3df041	447	lb = kzalloc(sizeof(struct gfs2_log_buf), GFP_NOFS \| __GFP_NOFAIL);
b3b94faa DT	448	list_add(&lb->lb_list, &sdp->sd_log_flush_list);
	449	lb->lb_real = real;
	450
	451	bh = lb->lb_bh = alloc_buffer_head(GFP_NOFS \| __GFP_NOFAIL);
	452	atomic_set(&bh->b_count, 1);
	453	bh->b_state = (1 << BH_Mapped) \| (1 << BH_Uptodate);
18ec7d5c	454	set_bh_page(bh, real->b_page, bh_offset(real));
b3b94faa DT	455	bh->b_blocknr = blkno;
	456	bh->b_size = sdp->sd_sb.sb_bsize;
	457	bh->b_bdev = sdp->sd_vfs->s_bdev;
	458
	459	log_incr_head(sdp);
	460
	461	return bh;
	462	}
	463
	464	static void log_pull_tail(struct gfs2_sbd *sdp, unsigned int new_tail, int pull)
	465	{
	466	unsigned int dist = log_distance(sdp, new_tail, sdp->sd_log_tail);
	467
	468	ail2_empty(sdp, new_tail);
	469
	470	gfs2_log_lock(sdp);
c5392124	471	sdp->sd_log_blks_free += dist - (pull ? 1 : 0);
faa31ce8	472	gfs2_assert_withdraw(sdp, sdp->sd_log_blks_free <= sdp->sd_jdesc->jd_blocks);
b3b94faa DT	473	gfs2_log_unlock(sdp);
	474
	475	sdp->sd_log_tail = new_tail;
	476	}
	477
	478	/**
	479	* log_write_header - Get and initialize a journal header buffer
	480	* @sdp: The GFS2 superblock
	481	*
	482	* Returns: the initialized log buffer descriptor
	483	*/
	484
cd915493	485	static void log_write_header(struct gfs2_sbd *sdp, u32 flags, int pull)
b3b94faa	486	{
cd915493	487	u64 blkno = log_bmap(sdp, sdp->sd_log_flush_head);
b3b94faa DT	488	struct buffer_head *bh;
	489	struct gfs2_log_header *lh;
	490	unsigned int tail;
cd915493	491	u32 hash;
b3b94faa	492
b3b94faa DT	493	bh = sb_getblk(sdp->sd_vfs, blkno);
	494	lock_buffer(bh);
	495	memset(bh->b_data, 0, bh->b_size);
	496	set_buffer_uptodate(bh);
	497	clear_buffer_dirty(bh);
	498	unlock_buffer(bh);
	499
	500	gfs2_ail1_empty(sdp, 0);
	501	tail = current_tail(sdp);
	502
	503	lh = (struct gfs2_log_header *)bh->b_data;
	504	memset(lh, 0, sizeof(struct gfs2_log_header));
	505	lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
e3167ded SW	506	lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
e3167ded SW	507	lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
e0f2bf78 SW	508	lh->lh_sequence = cpu_to_be64(sdp->sd_log_sequence++);
	509	lh->lh_flags = cpu_to_be32(flags);
	510	lh->lh_tail = cpu_to_be32(tail);
	511	lh->lh_blkno = cpu_to_be32(sdp->sd_log_flush_head);
b3b94faa DT	512	hash = gfs2_disk_hash(bh->b_data, sizeof(struct gfs2_log_header));
	513	lh->lh_hash = cpu_to_be32(hash);
	514
	515	set_buffer_dirty(bh);
	516	if (sync_dirty_buffer(bh))
	517	gfs2_io_error_bh(sdp, bh);
	518	brelse(bh);
	519
	520	if (sdp->sd_log_tail != tail)
	521	log_pull_tail(sdp, tail, pull);
	522	else
	523	gfs2_assert_withdraw(sdp, !pull);
	524
	525	sdp->sd_log_idle = (tail == sdp->sd_log_flush_head);
	526	log_incr_head(sdp);
	527	}
	528
	529	static void log_flush_commit(struct gfs2_sbd *sdp)
	530	{
	531	struct list_head *head = &sdp->sd_log_flush_list;
	532	struct gfs2_log_buf *lb;
	533	struct buffer_head *bh;
b3b94faa DT	534
	535	while (!list_empty(head)) {
	536	lb = list_entry(head->next, struct gfs2_log_buf, lb_list);
	537	list_del(&lb->lb_list);
	538	bh = lb->lb_bh;
	539
	540	wait_on_buffer(bh);
	541	if (!buffer_uptodate(bh))
	542	gfs2_io_error_bh(sdp, bh);
	543	if (lb->lb_real) {
	544	while (atomic_read(&bh->b_count) != 1) /* Grrrr... */
	545	schedule();
	546	free_buffer_head(bh);
	547	} else
	548	brelse(bh);
	549	kfree(lb);
	550	}
	551
	552	log_write_header(sdp, 0, 0);
	553	}
	554
	555	/**
b09e593d	556	* gfs2_log_flush - flush incore transaction(s)
b3b94faa DT	557	* @sdp: the filesystem
	558	* @gl: The glock structure to flush. If NULL, flush the whole incore log
	559	*
	560	*/
	561
b09e593d	562	void gfs2_log_flush(struct gfs2_sbd sdp, struct gfs2_glock gl)
b3b94faa DT	563	{
	564	struct gfs2_ail *ai;
	565
484adff8	566	down_write(&sdp->sd_log_flush_lock);
f55ab26a SW	567
	568	if (gl) {
	569	gfs2_log_lock(sdp);
	570	if (list_empty(&gl->gl_le.le_list)) {
	571	gfs2_log_unlock(sdp);
484adff8	572	up_write(&sdp->sd_log_flush_lock);
f55ab26a SW	573	return;
	574	}
	575	gfs2_log_unlock(sdp);
	576	}
	577
b09e593d SW	578	ai = kzalloc(sizeof(struct gfs2_ail), GFP_NOFS \| __GFP_NOFAIL);
	579	INIT_LIST_HEAD(&ai->ai_ail1_list);
	580	INIT_LIST_HEAD(&ai->ai_ail2_list);
b3b94faa	581
ddf4b426	582	gfs2_assert_withdraw(sdp, sdp->sd_log_num_buf + sdp->sd_log_num_jdata == sdp->sd_log_commited_buf);
b3b94faa DT	583	gfs2_assert_withdraw(sdp,
	584	sdp->sd_log_num_revoke == sdp->sd_log_commited_revoke);
	585
b3b94faa DT	586	sdp->sd_log_flush_head = sdp->sd_log_head;
	587	sdp->sd_log_flush_wrapped = 0;
	588	ai->ai_first = sdp->sd_log_flush_head;
	589
	590	lops_before_commit(sdp);
	591	if (!list_empty(&sdp->sd_log_flush_list))
	592	log_flush_commit(sdp);
	593	else if (sdp->sd_log_tail != current_tail(sdp) && !sdp->sd_log_idle)
	594	log_write_header(sdp, 0, PULL);
	595	lops_after_commit(sdp, ai);
b09e593d	596
fe1a698f SW	597	gfs2_log_lock(sdp);
fe1a698f SW	598	sdp->sd_log_head = sdp->sd_log_flush_head;
f4154ea0	599	sdp->sd_log_blks_free -= sdp->sd_log_num_hdrs;
faa31ce8 SW	600	sdp->sd_log_blks_reserved = 0;
	601	sdp->sd_log_commited_buf = 0;
	602	sdp->sd_log_num_hdrs = 0;
	603	sdp->sd_log_commited_revoke = 0;
b3b94faa	604
b3b94faa DT	605	if (!list_empty(&ai->ai_ail1_list)) {
	606	list_add(&ai->ai_list, &sdp->sd_ail1_list);
	607	ai = NULL;
	608	}
	609	gfs2_log_unlock(sdp);
	610
b3b94faa	611	sdp->sd_vfs->s_dirt = 0;
484adff8	612	up_write(&sdp->sd_log_flush_lock);
b3b94faa DT	613
	614	kfree(ai);
	615	}
	616
	617	static void log_refund(struct gfs2_sbd sdp, struct gfs2_trans tr)
	618	{
5dc39fe6	619	unsigned int reserved = 0;
b3b94faa DT	620	unsigned int old;
	621
	622	gfs2_log_lock(sdp);
	623
	624	sdp->sd_log_commited_buf += tr->tr_num_buf_new - tr->tr_num_buf_rm;
	625	gfs2_assert_withdraw(sdp, ((int)sdp->sd_log_commited_buf) >= 0);
	626	sdp->sd_log_commited_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm;
	627	gfs2_assert_withdraw(sdp, ((int)sdp->sd_log_commited_revoke) >= 0);
	628
	629	if (sdp->sd_log_commited_buf)
f4154ea0	630	reserved += sdp->sd_log_commited_buf;
b3b94faa DT	631	if (sdp->sd_log_commited_revoke)
b3b94faa DT	632	reserved += gfs2_struct2blk(sdp, sdp->sd_log_commited_revoke,
cd915493	633	sizeof(u64));
5dc39fe6 BM	634	if (reserved)
5dc39fe6 BM	635	reserved++;
b3b94faa DT	636
	637	old = sdp->sd_log_blks_free;
	638	sdp->sd_log_blks_free += tr->tr_reserved -
	639	(reserved - sdp->sd_log_blks_reserved);
	640
b09e593d	641	gfs2_assert_withdraw(sdp, sdp->sd_log_blks_free >= old);
b3b94faa	642	gfs2_assert_withdraw(sdp,
f4154ea0 SW	643	sdp->sd_log_blks_free <= sdp->sd_jdesc->jd_blocks +
f4154ea0 SW	644	sdp->sd_log_num_hdrs);
b3b94faa DT	645
	646	sdp->sd_log_blks_reserved = reserved;
	647
	648	gfs2_log_unlock(sdp);
	649	}
	650
	651	/**
	652	* gfs2_log_commit - Commit a transaction to the log
	653	* @sdp: the filesystem
	654	* @tr: the transaction
	655	*
	656	* Returns: errno
	657	*/
	658
	659	void gfs2_log_commit(struct gfs2_sbd sdp, struct gfs2_trans tr)
	660	{
	661	log_refund(sdp, tr);
	662	lops_incore_commit(sdp, tr);
	663
	664	sdp->sd_vfs->s_dirt = 1;
484adff8	665	up_read(&sdp->sd_log_flush_lock);
b3b94faa	666
b3b94faa	667	gfs2_log_lock(sdp);
b004157a SW	668	if (sdp->sd_log_num_buf > gfs2_tune_get(sdp, gt_incore_log_blocks))
	669	wake_up_process(sdp->sd_logd_process);
	670	gfs2_log_unlock(sdp);
b3b94faa DT	671	}
	672
	673	/**
	674	* gfs2_log_shutdown - write a shutdown header into a journal
	675	* @sdp: the filesystem
	676	*
	677	*/
	678
	679	void gfs2_log_shutdown(struct gfs2_sbd *sdp)
	680	{
484adff8	681	down_write(&sdp->sd_log_flush_lock);
b3b94faa	682
b3b94faa DT	683	gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved);
	684	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_gl);
	685	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_buf);
18ec7d5c	686	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_jdata);
b3b94faa DT	687	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
	688	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_rg);
	689	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_databuf);
190562bd	690	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_hdrs);
b3b94faa DT	691	gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list));
	692
	693	sdp->sd_log_flush_head = sdp->sd_log_head;
	694	sdp->sd_log_flush_wrapped = 0;
	695
	696	log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT, 0);
	697
a74604be SW	698	gfs2_assert_warn(sdp, sdp->sd_log_blks_free == sdp->sd_jdesc->jd_blocks);
	699	gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail);
	700	gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list));
b3b94faa DT	701
b3b94faa DT	702	sdp->sd_log_head = sdp->sd_log_flush_head;
b3b94faa DT	703	sdp->sd_log_tail = sdp->sd_log_head;
b3b94faa DT	704
484adff8	705	up_write(&sdp->sd_log_flush_lock);
b3b94faa DT	706	}
b3b94faa DT	707
a25311c8 SW	708
	709	/**
	710	* gfs2_meta_syncfs - sync all the buffers in a filesystem
	711	* @sdp: the filesystem
	712	*
	713	*/
	714
	715	void gfs2_meta_syncfs(struct gfs2_sbd *sdp)
	716	{
	717	gfs2_log_flush(sdp, NULL);
	718	for (;;) {
	719	gfs2_ail1_start(sdp, DIO_ALL);
	720	if (gfs2_ail1_empty(sdp, DIO_ALL))
	721	break;
	722	msleep(10);
	723	}
	724	}
	725