[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 "gfs2.h"
#include "lm_interface.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;
}

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

	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);

	if (flags & DIO_ALL)
		first = NULL;

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

		for (tmp = head->prev; tmp != head; tmp = tmp->prev) {
			ai = list_entry(tmp, struct gfs2_ail, ai_list);
			if (ai->ai_sync_gen >= sync_gen)
				continue;
			ai->ai_sync_gen = sync_gen;
			gfs2_ail1_start_one(sdp, ai);
			break;
		}

		if (tmp == head)
			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;
}

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
 *
 * Returns: errno
 */

int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks)
{
	unsigned int try = 0;

	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) {
		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;
	/* printk(KERN_INFO "reserved %u blocks (%u left)\n", blks, sdp->sd_log_blks_free); */
	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;
	/* printk(KERN_INFO "released %u blocks (%u left)\n", blks, sdp->sd_log_blks_free); */
	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 uint64_t log_bmap(struct gfs2_sbd *sdp, unsigned int lbn)
{
	int new = 0;
	uint64_t dbn;
	int error;
	int bdy;

	error = gfs2_block_map(sdp->sd_jdesc->jd_inode, lbn, &new, &dbn, &bdy);
	if (!(!error && dbn)) {
		printk(KERN_INFO "error=%d, dbn=%llu lbn=%u", error, (unsigned long long)dbn, lbn);
	}
	gfs2_assert_withdraw(sdp, !error && dbn);

	return dbn;
}

/**
 * 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)
{
	uint64_t 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)
{
	uint64_t 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);
	/* printk(KERN_INFO "pull tail refunding %u blocks (%u left) pull=%d\n", dist - ((pull) ? 1 : 0), sdp->sd_log_blks_free, pull); */
	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, uint32_t flags, int pull)
{
	uint64_t blkno = log_bmap(sdp, sdp->sd_log_flush_head);
	struct buffer_head *bh;
	struct gfs2_log_header *lh;
	unsigned int tail;
	uint32_t hash;

	/* printk(KERN_INFO "log write header start (flags=%08x, pull=%d)\n", flags, pull); */

	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);

	/* printk(KERN_INFO "log write header out\n"); */
}

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;
#if 0
	unsigned int d;

	d = log_distance(sdp, sdp->sd_log_flush_head, sdp->sd_log_head);

	gfs2_assert_withdraw(sdp, d + 1 == sdp->sd_log_blks_reserved);
#endif

	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_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);
	sdp->sd_log_head = sdp->sd_log_flush_head;

	/* printk(KERN_INFO "sd_log_num_hdrs %u\n", sdp->sd_log_num_hdrs); */
	sdp->sd_log_blks_free -= sdp->sd_log_num_hdrs;

	sdp->sd_log_blks_reserved =
		sdp->sd_log_commited_buf =
		sdp->sd_log_num_hdrs = 
		sdp->sd_log_commited_revoke = 0;

	gfs2_log_lock(sdp);
	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(uint64_t));
	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)) {
		gfs2_log_unlock(sdp);
		gfs2_log_flush(sdp, NULL);
	} else
		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);

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