[net-next-2.6.git] / fs / ocfs2 / slot_map.c

/* -*- mode: c; c-basic-offset: 8; -*-
 * vim: noexpandtab sw=8 ts=8 sts=0:
 *
 * slot_map.c
 *
 *
 *
 * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */

#include <linux/types.h>
#include <linux/slab.h>
#include <linux/highmem.h>

#define MLOG_MASK_PREFIX ML_SUPER
#include <cluster/masklog.h>

#include "ocfs2.h"

#include "dlmglue.h"
#include "extent_map.h"
#include "heartbeat.h"
#include "inode.h"
#include "slot_map.h"
#include "super.h"
#include "sysfile.h"

#include "buffer_head_io.h"


struct ocfs2_slot {
	int sl_valid;
	unsigned int sl_node_num;
};

struct ocfs2_slot_info {
	int si_extended;
	int si_slots_per_block;
	struct inode *si_inode;
	unsigned int si_blocks;
	struct buffer_head **si_bh;
	unsigned int si_num_slots;
	struct ocfs2_slot *si_slots;
};


static int __ocfs2_node_num_to_slot(struct ocfs2_slot_info *si,
				    unsigned int node_num);

static void ocfs2_invalidate_slot(struct ocfs2_slot_info *si,
				  int slot_num)
{
	BUG_ON((slot_num < 0) || (slot_num >= si->si_num_slots));
	si->si_slots[slot_num].sl_valid = 0;
}

static void ocfs2_set_slot(struct ocfs2_slot_info *si,
			   int slot_num, unsigned int node_num)
{
	BUG_ON((slot_num < 0) || (slot_num >= si->si_num_slots));

	si->si_slots[slot_num].sl_valid = 1;
	si->si_slots[slot_num].sl_node_num = node_num;
}

/* This version is for the extended slot map */
static void ocfs2_update_slot_info_extended(struct ocfs2_slot_info *si)
{
	int b, i, slotno;
	struct ocfs2_slot_map_extended *se;

	slotno = 0;
	for (b = 0; b < si->si_blocks; b++) {
		se = (struct ocfs2_slot_map_extended *)si->si_bh[b]->b_data;
		for (i = 0;
		     (i < si->si_slots_per_block) &&
		     (slotno < si->si_num_slots);
		     i++, slotno++) {
			if (se->se_slots[i].es_valid)
				ocfs2_set_slot(si, slotno,
					       le32_to_cpu(se->se_slots[i].es_node_num));
			else
				ocfs2_invalidate_slot(si, slotno);
		}
	}
}

/*
 * Post the slot information on disk into our slot_info struct.
 * Must be protected by osb_lock.
 */
static void ocfs2_update_slot_info_old(struct ocfs2_slot_info *si)
{
	int i;
	struct ocfs2_slot_map *sm;

	sm = (struct ocfs2_slot_map *)si->si_bh[0]->b_data;

	for (i = 0; i < si->si_num_slots; i++) {
		if (le16_to_cpu(sm->sm_slots[i]) == (u16)OCFS2_INVALID_SLOT)
			ocfs2_invalidate_slot(si, i);
		else
			ocfs2_set_slot(si, i, le16_to_cpu(sm->sm_slots[i]));
	}
}

static void ocfs2_update_slot_info(struct ocfs2_slot_info *si)
{
	/*
	 * The slot data will have been refreshed when ocfs2_super_lock
	 * was taken.
	 */
	if (si->si_extended)
		ocfs2_update_slot_info_extended(si);
	else
		ocfs2_update_slot_info_old(si);
}

int ocfs2_refresh_slot_info(struct ocfs2_super *osb)
{
	int ret;
	struct ocfs2_slot_info *si = osb->slot_info;

	if (si == NULL)
		return 0;

	BUG_ON(si->si_blocks == 0);
	BUG_ON(si->si_bh == NULL);

	mlog(0, "Refreshing slot map, reading %u block(s)\n",
	     si->si_blocks);

	/*
	 * We pass -1 as blocknr because we expect all of si->si_bh to
	 * be !NULL.  Thus, ocfs2_read_blocks() will ignore blocknr.  If
	 * this is not true, the read of -1 (UINT64_MAX) will fail.
	 */
	ret = ocfs2_read_blocks(INODE_CACHE(si->si_inode), -1, si->si_blocks,
				si->si_bh, OCFS2_BH_IGNORE_CACHE, NULL);
	if (ret == 0) {
		spin_lock(&osb->osb_lock);
		ocfs2_update_slot_info(si);
		spin_unlock(&osb->osb_lock);
	}

	return ret;
}

/* post the our slot info stuff into it's destination bh and write it
 * out. */
static void ocfs2_update_disk_slot_extended(struct ocfs2_slot_info *si,
					    int slot_num,
					    struct buffer_head **bh)
{
	int blkind = slot_num / si->si_slots_per_block;
	int slotno = slot_num % si->si_slots_per_block;
	struct ocfs2_slot_map_extended *se;

	BUG_ON(blkind >= si->si_blocks);

	se = (struct ocfs2_slot_map_extended *)si->si_bh[blkind]->b_data;
	se->se_slots[slotno].es_valid = si->si_slots[slot_num].sl_valid;
	if (si->si_slots[slot_num].sl_valid)
		se->se_slots[slotno].es_node_num =
			cpu_to_le32(si->si_slots[slot_num].sl_node_num);
	*bh = si->si_bh[blkind];
}

static void ocfs2_update_disk_slot_old(struct ocfs2_slot_info *si,
				       int slot_num,
				       struct buffer_head **bh)
{
	int i;
	struct ocfs2_slot_map *sm;

	sm = (struct ocfs2_slot_map *)si->si_bh[0]->b_data;
	for (i = 0; i < si->si_num_slots; i++) {
		if (si->si_slots[i].sl_valid)
			sm->sm_slots[i] =
				cpu_to_le16(si->si_slots[i].sl_node_num);
		else
			sm->sm_slots[i] = cpu_to_le16(OCFS2_INVALID_SLOT);
	}
	*bh = si->si_bh[0];
}

static int ocfs2_update_disk_slot(struct ocfs2_super *osb,
				  struct ocfs2_slot_info *si,
				  int slot_num)
{
	int status;
	struct buffer_head *bh;

	spin_lock(&osb->osb_lock);
	if (si->si_extended)
		ocfs2_update_disk_slot_extended(si, slot_num, &bh);
	else
		ocfs2_update_disk_slot_old(si, slot_num, &bh);
	spin_unlock(&osb->osb_lock);

	status = ocfs2_write_block(osb, bh, INODE_CACHE(si->si_inode));
	if (status < 0)
		mlog_errno(status);

	return status;
}

/*
 * Calculate how many bytes are needed by the slot map.  Returns
 * an error if the slot map file is too small.
 */
static int ocfs2_slot_map_physical_size(struct ocfs2_super *osb,
					struct inode *inode,
					unsigned long long *bytes)
{
	unsigned long long bytes_needed;

	if (ocfs2_uses_extended_slot_map(osb)) {
		bytes_needed = osb->max_slots *
			sizeof(struct ocfs2_extended_slot);
	} else {
		bytes_needed = osb->max_slots * sizeof(__le16);
	}
	if (bytes_needed > i_size_read(inode)) {
		mlog(ML_ERROR,
		     "Slot map file is too small!  (size %llu, needed %llu)\n",
		     i_size_read(inode), bytes_needed);
		return -ENOSPC;
	}

	*bytes = bytes_needed;
	return 0;
}

/* try to find global node in the slot info. Returns -ENOENT
 * if nothing is found. */
static int __ocfs2_node_num_to_slot(struct ocfs2_slot_info *si,
				    unsigned int node_num)
{
	int i, ret = -ENOENT;

	for(i = 0; i < si->si_num_slots; i++) {
		if (si->si_slots[i].sl_valid &&
		    (node_num == si->si_slots[i].sl_node_num)) {
			ret = i;
			break;
		}
	}

	return ret;
}

static int __ocfs2_find_empty_slot(struct ocfs2_slot_info *si,
				   int preferred)
{
	int i, ret = -ENOSPC;

	if ((preferred >= 0) && (preferred < si->si_num_slots)) {
		if (!si->si_slots[preferred].sl_valid) {
			ret = preferred;
			goto out;
		}
	}

	for(i = 0; i < si->si_num_slots; i++) {
		if (!si->si_slots[i].sl_valid) {
			ret = i;
			break;
		}
	}
out:
	return ret;
}

int ocfs2_node_num_to_slot(struct ocfs2_super *osb, unsigned int node_num)
{
	int slot;
	struct ocfs2_slot_info *si = osb->slot_info;

	spin_lock(&osb->osb_lock);
	slot = __ocfs2_node_num_to_slot(si, node_num);
	spin_unlock(&osb->osb_lock);

	return slot;
}

int ocfs2_slot_to_node_num_locked(struct ocfs2_super *osb, int slot_num,
				  unsigned int *node_num)
{
	struct ocfs2_slot_info *si = osb->slot_info;

	assert_spin_locked(&osb->osb_lock);

	BUG_ON(slot_num < 0);
	BUG_ON(slot_num > osb->max_slots);

	if (!si->si_slots[slot_num].sl_valid)
		return -ENOENT;

	*node_num = si->si_slots[slot_num].sl_node_num;
	return 0;
}

static void __ocfs2_free_slot_info(struct ocfs2_slot_info *si)
{
	unsigned int i;

	if (si == NULL)
		return;

	if (si->si_inode)
		iput(si->si_inode);
	if (si->si_bh) {
		for (i = 0; i < si->si_blocks; i++) {
			if (si->si_bh[i]) {
				brelse(si->si_bh[i]);
				si->si_bh[i] = NULL;
			}
		}
		kfree(si->si_bh);
	}

	kfree(si);
}

int ocfs2_clear_slot(struct ocfs2_super *osb, int slot_num)
{
	struct ocfs2_slot_info *si = osb->slot_info;

	if (si == NULL)
		return 0;

	spin_lock(&osb->osb_lock);
	ocfs2_invalidate_slot(si, slot_num);
	spin_unlock(&osb->osb_lock);

	return ocfs2_update_disk_slot(osb, osb->slot_info, slot_num);
}

static int ocfs2_map_slot_buffers(struct ocfs2_super *osb,
				  struct ocfs2_slot_info *si)
{
	int status = 0;
	u64 blkno;
	unsigned long long blocks, bytes = 0;
	unsigned int i;
	struct buffer_head *bh;

	status = ocfs2_slot_map_physical_size(osb, si->si_inode, &bytes);
	if (status)
		goto bail;

	blocks = ocfs2_blocks_for_bytes(si->si_inode->i_sb, bytes);
	BUG_ON(blocks > UINT_MAX);
	si->si_blocks = blocks;
	if (!si->si_blocks)
		goto bail;

	if (si->si_extended)
		si->si_slots_per_block =
			(osb->sb->s_blocksize /
			 sizeof(struct ocfs2_extended_slot));
	else
		si->si_slots_per_block = osb->sb->s_blocksize / sizeof(__le16);

	/* The size checks above should ensure this */
	BUG_ON((osb->max_slots / si->si_slots_per_block) > blocks);

	mlog(0, "Slot map needs %u buffers for %llu bytes\n",
	     si->si_blocks, bytes);

	si->si_bh = kzalloc(sizeof(struct buffer_head *) * si->si_blocks,
			    GFP_KERNEL);
	if (!si->si_bh) {
		status = -ENOMEM;
		mlog_errno(status);
		goto bail;
	}

	for (i = 0; i < si->si_blocks; i++) {
		status = ocfs2_extent_map_get_blocks(si->si_inode, i,
						     &blkno, NULL, NULL);
		if (status < 0) {
			mlog_errno(status);
			goto bail;
		}

		mlog(0, "Reading slot map block %u at %llu\n", i,
		     (unsigned long long)blkno);

		bh = NULL;  /* Acquire a fresh bh */
		status = ocfs2_read_blocks(INODE_CACHE(si->si_inode), blkno,
					   1, &bh, OCFS2_BH_IGNORE_CACHE, NULL);
		if (status < 0) {
			mlog_errno(status);
			goto bail;
		}

		si->si_bh[i] = bh;
	}

bail:
	return status;
}

int ocfs2_init_slot_info(struct ocfs2_super *osb)
{
	int status;
	struct inode *inode = NULL;
	struct ocfs2_slot_info *si;

	si = kzalloc(sizeof(struct ocfs2_slot_info) +
		     (sizeof(struct ocfs2_slot) * osb->max_slots),
		     GFP_KERNEL);
	if (!si) {
		status = -ENOMEM;
		mlog_errno(status);
		goto bail;
	}

	si->si_extended = ocfs2_uses_extended_slot_map(osb);
	si->si_num_slots = osb->max_slots;
	si->si_slots = (struct ocfs2_slot *)((char *)si +
					     sizeof(struct ocfs2_slot_info));

	inode = ocfs2_get_system_file_inode(osb, SLOT_MAP_SYSTEM_INODE,
					    OCFS2_INVALID_SLOT);
	if (!inode) {
		status = -EINVAL;
		mlog_errno(status);
		goto bail;
	}

	si->si_inode = inode;
	status = ocfs2_map_slot_buffers(osb, si);
	if (status < 0) {
		mlog_errno(status);
		goto bail;
	}

	osb->slot_info = (struct ocfs2_slot_info *)si;
bail:
	if (status < 0 && si)
		__ocfs2_free_slot_info(si);

	return status;
}

void ocfs2_free_slot_info(struct ocfs2_super *osb)
{
	struct ocfs2_slot_info *si = osb->slot_info;

	osb->slot_info = NULL;
	__ocfs2_free_slot_info(si);
}

int ocfs2_find_slot(struct ocfs2_super *osb)
{
	int status;
	int slot;
	struct ocfs2_slot_info *si;

	mlog_entry_void();

	si = osb->slot_info;

	spin_lock(&osb->osb_lock);
	ocfs2_update_slot_info(si);

	/* search for ourselves first and take the slot if it already
	 * exists. Perhaps we need to mark this in a variable for our
	 * own journal recovery? Possibly not, though we certainly
	 * need to warn to the user */
	slot = __ocfs2_node_num_to_slot(si, osb->node_num);
	if (slot < 0) {
		/* if no slot yet, then just take 1st available
		 * one. */
		slot = __ocfs2_find_empty_slot(si, osb->preferred_slot);
		if (slot < 0) {
			spin_unlock(&osb->osb_lock);
			mlog(ML_ERROR, "no free slots available!\n");
			status = -EINVAL;
			goto bail;
		}
	} else
		mlog(ML_NOTICE, "slot %d is already allocated to this node!\n",
		     slot);

	ocfs2_set_slot(si, slot, osb->node_num);
	osb->slot_num = slot;
	spin_unlock(&osb->osb_lock);

	mlog(0, "taking node slot %d\n", osb->slot_num);

	status = ocfs2_update_disk_slot(osb, si, osb->slot_num);
	if (status < 0)
		mlog_errno(status);

bail:
	mlog_exit(status);
	return status;
}

void ocfs2_put_slot(struct ocfs2_super *osb)
{
	int status, slot_num;
	struct ocfs2_slot_info *si = osb->slot_info;

	if (!si)
		return;

	spin_lock(&osb->osb_lock);
	ocfs2_update_slot_info(si);

	slot_num = osb->slot_num;
	ocfs2_invalidate_slot(si, osb->slot_num);
	osb->slot_num = OCFS2_INVALID_SLOT;
	spin_unlock(&osb->osb_lock);

	status = ocfs2_update_disk_slot(osb, si, slot_num);
	if (status < 0) {
		mlog_errno(status);
		goto bail;
	}

bail:
	ocfs2_free_slot_info(osb);
}
Commit	Line	Data
ccd979bd MF	1	/* -- mode: c; c-basic-offset: 8; --
	2	* vim: noexpandtab sw=8 ts=8 sts=0:
	3	*
	4	* slot_map.c
	5	*
	6	*
	7	*
	8	* Copyright (C) 2002, 2004 Oracle. All rights reserved.
	9	*
	10	* This program is free software; you can redistribute it and/or
	11	* modify it under the terms of the GNU General Public
	12	* License as published by the Free Software Foundation; either
	13	* version 2 of the License, or (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	18	* General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public
	21	* License along with this program; if not, write to the
	22	* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	23	* Boston, MA 021110-1307, USA.
	24	*/
	25
	26	#include <linux/types.h>
	27	#include <linux/slab.h>
	28	#include <linux/highmem.h>
ccd979bd MF	29
	30	#define MLOG_MASK_PREFIX ML_SUPER
	31	#include <cluster/masklog.h>
	32
	33	#include "ocfs2.h"
	34
	35	#include "dlmglue.h"
	36	#include "extent_map.h"
	37	#include "heartbeat.h"
	38	#include "inode.h"
	39	#include "slot_map.h"
	40	#include "super.h"
	41	#include "sysfile.h"
	42
	43	#include "buffer_head_io.h"
	44
fc881fa0 JB	45
	46	struct ocfs2_slot {
	47	int sl_valid;
	48	unsigned int sl_node_num;
	49	};
	50
d85b20e4	51	struct ocfs2_slot_info {
386a2ef8 JB	52	int si_extended;
386a2ef8 JB	53	int si_slots_per_block;
d85b20e4	54	struct inode *si_inode;
1c8d9a6a JB	55	unsigned int si_blocks;
1c8d9a6a JB	56	struct buffer_head **si_bh;
d85b20e4	57	unsigned int si_num_slots;
fc881fa0	58	struct ocfs2_slot *si_slots;
d85b20e4 JB	59	};
	60
	61
fc881fa0 JB	62	static int __ocfs2_node_num_to_slot(struct ocfs2_slot_info *si,
	63	unsigned int node_num);
	64
	65	static void ocfs2_invalidate_slot(struct ocfs2_slot_info *si,
	66	int slot_num)
	67	{
	68	BUG_ON((slot_num < 0) \|\| (slot_num >= si->si_num_slots));
	69	si->si_slots[slot_num].sl_valid = 0;
	70	}
	71
	72	static void ocfs2_set_slot(struct ocfs2_slot_info *si,
	73	int slot_num, unsigned int node_num)
	74	{
	75	BUG_ON((slot_num < 0) \|\| (slot_num >= si->si_num_slots));
fc881fa0 JB	76
	77	si->si_slots[slot_num].sl_valid = 1;
	78	si->si_slots[slot_num].sl_node_num = node_num;
	79	}
ccd979bd	80
386a2ef8 JB	81	/* This version is for the extended slot map */
	82	static void ocfs2_update_slot_info_extended(struct ocfs2_slot_info *si)
	83	{
	84	int b, i, slotno;
	85	struct ocfs2_slot_map_extended *se;
	86
	87	slotno = 0;
	88	for (b = 0; b < si->si_blocks; b++) {
	89	se = (struct ocfs2_slot_map_extended *)si->si_bh[b]->b_data;
	90	for (i = 0;
	91	(i < si->si_slots_per_block) &&
	92	(slotno < si->si_num_slots);
	93	i++, slotno++) {
	94	if (se->se_slots[i].es_valid)
	95	ocfs2_set_slot(si, slotno,
	96	le32_to_cpu(se->se_slots[i].es_node_num));
	97	else
	98	ocfs2_invalidate_slot(si, slotno);
	99	}
	100	}
	101	}
	102
d85b20e4 JB	103	/*
	104	* Post the slot information on disk into our slot_info struct.
	105	* Must be protected by osb_lock.
	106	*/
386a2ef8	107	static void ocfs2_update_slot_info_old(struct ocfs2_slot_info *si)
ccd979bd MF	108	{
ccd979bd MF	109	int i;
fb86b1f0	110	struct ocfs2_slot_map *sm;
ccd979bd	111
fb86b1f0	112	sm = (struct ocfs2_slot_map *)si->si_bh[0]->b_data;
ccd979bd	113
fc881fa0	114	for (i = 0; i < si->si_num_slots; i++) {
fb86b1f0	115	if (le16_to_cpu(sm->sm_slots[i]) == (u16)OCFS2_INVALID_SLOT)
fc881fa0 JB	116	ocfs2_invalidate_slot(si, i);
fc881fa0 JB	117	else
fb86b1f0	118	ocfs2_set_slot(si, i, le16_to_cpu(sm->sm_slots[i]));
fc881fa0	119	}
ccd979bd MF	120	}
ccd979bd MF	121
386a2ef8 JB	122	static void ocfs2_update_slot_info(struct ocfs2_slot_info *si)
	123	{
	124	/*
	125	* The slot data will have been refreshed when ocfs2_super_lock
	126	* was taken.
	127	*/
	128	if (si->si_extended)
	129	ocfs2_update_slot_info_extended(si);
	130	else
	131	ocfs2_update_slot_info_old(si);
	132	}
	133
8e8a4603 MF	134	int ocfs2_refresh_slot_info(struct ocfs2_super *osb)
	135	{
	136	int ret;
	137	struct ocfs2_slot_info *si = osb->slot_info;
8e8a4603 MF	138
	139	if (si == NULL)
	140	return 0;
	141
1c8d9a6a JB	142	BUG_ON(si->si_blocks == 0);
	143	BUG_ON(si->si_bh == NULL);
	144
	145	mlog(0, "Refreshing slot map, reading %u block(s)\n",
	146	si->si_blocks);
	147
	148	/*
	149	* We pass -1 as blocknr because we expect all of si->si_bh to
	150	* be !NULL. Thus, ocfs2_read_blocks() will ignore blocknr. If
	151	* this is not true, the read of -1 (UINT64_MAX) will fail.
	152	*/
8cb471e8 JB	153	ret = ocfs2_read_blocks(INODE_CACHE(si->si_inode), -1, si->si_blocks,
8cb471e8 JB	154	si->si_bh, OCFS2_BH_IGNORE_CACHE, NULL);
d85b20e4 JB	155	if (ret == 0) {
d85b20e4 JB	156	spin_lock(&osb->osb_lock);
8e8a4603	157	ocfs2_update_slot_info(si);
d85b20e4 JB	158	spin_unlock(&osb->osb_lock);
d85b20e4 JB	159	}
8e8a4603 MF	160
	161	return ret;
	162	}
	163
ccd979bd MF	164	/* post the our slot info stuff into it's destination bh and write it
ccd979bd MF	165	* out. */
386a2ef8 JB	166	static void ocfs2_update_disk_slot_extended(struct ocfs2_slot_info *si,
	167	int slot_num,
	168	struct buffer_head **bh)
	169	{
	170	int blkind = slot_num / si->si_slots_per_block;
	171	int slotno = slot_num % si->si_slots_per_block;
	172	struct ocfs2_slot_map_extended *se;
	173
	174	BUG_ON(blkind >= si->si_blocks);
	175
	176	se = (struct ocfs2_slot_map_extended *)si->si_bh[blkind]->b_data;
	177	se->se_slots[slotno].es_valid = si->si_slots[slot_num].sl_valid;
	178	if (si->si_slots[slot_num].sl_valid)
	179	se->se_slots[slotno].es_node_num =
	180	cpu_to_le32(si->si_slots[slot_num].sl_node_num);
	181	*bh = si->si_bh[blkind];
	182	}
	183
	184	static void ocfs2_update_disk_slot_old(struct ocfs2_slot_info *si,
	185	int slot_num,
	186	struct buffer_head **bh)
ccd979bd	187	{
386a2ef8	188	int i;
fb86b1f0	189	struct ocfs2_slot_map *sm;
ccd979bd	190
fb86b1f0	191	sm = (struct ocfs2_slot_map *)si->si_bh[0]->b_data;
fc881fa0 JB	192	for (i = 0; i < si->si_num_slots; i++) {
fc881fa0 JB	193	if (si->si_slots[i].sl_valid)
fb86b1f0	194	sm->sm_slots[i] =
fc881fa0 JB	195	cpu_to_le16(si->si_slots[i].sl_node_num);
fc881fa0 JB	196	else
fb86b1f0	197	sm->sm_slots[i] = cpu_to_le16(OCFS2_INVALID_SLOT);
fc881fa0	198	}
386a2ef8 JB	199	*bh = si->si_bh[0];
	200	}
	201
	202	static int ocfs2_update_disk_slot(struct ocfs2_super *osb,
	203	struct ocfs2_slot_info *si,
	204	int slot_num)
	205	{
	206	int status;
	207	struct buffer_head *bh;
	208
	209	spin_lock(&osb->osb_lock);
	210	if (si->si_extended)
	211	ocfs2_update_disk_slot_extended(si, slot_num, &bh);
	212	else
	213	ocfs2_update_disk_slot_old(si, slot_num, &bh);
d85b20e4	214	spin_unlock(&osb->osb_lock);
ccd979bd	215
8cb471e8	216	status = ocfs2_write_block(osb, bh, INODE_CACHE(si->si_inode));
ccd979bd MF	217	if (status < 0)
	218	mlog_errno(status);
	219
	220	return status;
	221	}
	222
1c8d9a6a JB	223	/*
	224	* Calculate how many bytes are needed by the slot map. Returns
	225	* an error if the slot map file is too small.
	226	*/
	227	static int ocfs2_slot_map_physical_size(struct ocfs2_super *osb,
	228	struct inode *inode,
	229	unsigned long long *bytes)
	230	{
	231	unsigned long long bytes_needed;
	232
386a2ef8 JB	233	if (ocfs2_uses_extended_slot_map(osb)) {
	234	bytes_needed = osb->max_slots *
	235	sizeof(struct ocfs2_extended_slot);
	236	} else {
	237	bytes_needed = osb->max_slots * sizeof(__le16);
	238	}
1c8d9a6a JB	239	if (bytes_needed > i_size_read(inode)) {
	240	mlog(ML_ERROR,
	241	"Slot map file is too small! (size %llu, needed %llu)\n",
	242	i_size_read(inode), bytes_needed);
	243	return -ENOSPC;
	244	}
	245
	246	*bytes = bytes_needed;
	247	return 0;
	248	}
	249
fc881fa0 JB	250	/* try to find global node in the slot info. Returns -ENOENT
	251	* if nothing is found. */
	252	static int __ocfs2_node_num_to_slot(struct ocfs2_slot_info *si,
	253	unsigned int node_num)
ccd979bd	254	{
fc881fa0	255	int i, ret = -ENOENT;
ccd979bd MF	256
ccd979bd MF	257	for(i = 0; i < si->si_num_slots; i++) {
fc881fa0 JB	258	if (si->si_slots[i].sl_valid &&
	259	(node_num == si->si_slots[i].sl_node_num)) {
	260	ret = i;
ccd979bd MF	261	break;
	262	}
	263	}
fc881fa0	264
ccd979bd MF	265	return ret;
	266	}
	267
fc881fa0 JB	268	static int __ocfs2_find_empty_slot(struct ocfs2_slot_info *si,
fc881fa0 JB	269	int preferred)
ccd979bd	270	{
fc881fa0	271	int i, ret = -ENOSPC;
ccd979bd	272
fc881fa0 JB	273	if ((preferred >= 0) && (preferred < si->si_num_slots)) {
fc881fa0 JB	274	if (!si->si_slots[preferred].sl_valid) {
baf4661a SM	275	ret = preferred;
	276	goto out;
	277	}
	278	}
	279
ccd979bd	280	for(i = 0; i < si->si_num_slots; i++) {
fc881fa0 JB	281	if (!si->si_slots[i].sl_valid) {
fc881fa0 JB	282	ret = i;
ccd979bd MF	283	break;
	284	}
	285	}
baf4661a	286	out:
ccd979bd MF	287	return ret;
	288	}
	289
d85b20e4	290	int ocfs2_node_num_to_slot(struct ocfs2_super *osb, unsigned int node_num)
ccd979bd	291	{
fc881fa0	292	int slot;
d85b20e4	293	struct ocfs2_slot_info *si = osb->slot_info;
ccd979bd	294
d85b20e4 JB	295	spin_lock(&osb->osb_lock);
	296	slot = __ocfs2_node_num_to_slot(si, node_num);
	297	spin_unlock(&osb->osb_lock);
	298
d85b20e4 JB	299	return slot;
	300	}
	301
	302	int ocfs2_slot_to_node_num_locked(struct ocfs2_super *osb, int slot_num,
	303	unsigned int *node_num)
	304	{
	305	struct ocfs2_slot_info *si = osb->slot_info;
	306
	307	assert_spin_locked(&osb->osb_lock);
	308
	309	BUG_ON(slot_num < 0);
	310	BUG_ON(slot_num > osb->max_slots);
	311
fc881fa0	312	if (!si->si_slots[slot_num].sl_valid)
d85b20e4 JB	313	return -ENOENT;
d85b20e4 JB	314
fc881fa0	315	*node_num = si->si_slots[slot_num].sl_node_num;
d85b20e4	316	return 0;
ccd979bd MF	317	}
ccd979bd MF	318
8e8a4603 MF	319	static void __ocfs2_free_slot_info(struct ocfs2_slot_info *si)
8e8a4603 MF	320	{
1c8d9a6a JB	321	unsigned int i;
1c8d9a6a JB	322
8e8a4603 MF	323	if (si == NULL)
	324	return;
	325
	326	if (si->si_inode)
	327	iput(si->si_inode);
1c8d9a6a JB	328	if (si->si_bh) {
	329	for (i = 0; i < si->si_blocks; i++) {
	330	if (si->si_bh[i]) {
	331	brelse(si->si_bh[i]);
	332	si->si_bh[i] = NULL;
	333	}
	334	}
	335	kfree(si->si_bh);
	336	}
8e8a4603 MF	337
	338	kfree(si);
	339	}
	340
fc881fa0	341	int ocfs2_clear_slot(struct ocfs2_super *osb, int slot_num)
ccd979bd	342	{
8e8a4603 MF	343	struct ocfs2_slot_info *si = osb->slot_info;
	344
	345	if (si == NULL)
	346	return 0;
	347
d85b20e4	348	spin_lock(&osb->osb_lock);
fc881fa0	349	ocfs2_invalidate_slot(si, slot_num);
d85b20e4	350	spin_unlock(&osb->osb_lock);
8e8a4603	351
386a2ef8	352	return ocfs2_update_disk_slot(osb, osb->slot_info, slot_num);
ccd979bd MF	353	}
ccd979bd MF	354
1c8d9a6a JB	355	static int ocfs2_map_slot_buffers(struct ocfs2_super *osb,
	356	struct ocfs2_slot_info *si)
	357	{
	358	int status = 0;
	359	u64 blkno;
f30d44f3	360	unsigned long long blocks, bytes = 0;
1c8d9a6a JB	361	unsigned int i;
	362	struct buffer_head *bh;
	363
	364	status = ocfs2_slot_map_physical_size(osb, si->si_inode, &bytes);
	365	if (status)
	366	goto bail;
	367
	368	blocks = ocfs2_blocks_for_bytes(si->si_inode->i_sb, bytes);
	369	BUG_ON(blocks > UINT_MAX);
	370	si->si_blocks = blocks;
	371	if (!si->si_blocks)
	372	goto bail;
	373
386a2ef8 JB	374	if (si->si_extended)
	375	si->si_slots_per_block =
	376	(osb->sb->s_blocksize /
	377	sizeof(struct ocfs2_extended_slot));
	378	else
	379	si->si_slots_per_block = osb->sb->s_blocksize / sizeof(__le16);
	380
	381	/* The size checks above should ensure this */
	382	BUG_ON((osb->max_slots / si->si_slots_per_block) > blocks);
	383
1c8d9a6a JB	384	mlog(0, "Slot map needs %u buffers for %llu bytes\n",
	385	si->si_blocks, bytes);
	386
	387	si->si_bh = kzalloc(sizeof(struct buffer_head ) si->si_blocks,
	388	GFP_KERNEL);
	389	if (!si->si_bh) {
	390	status = -ENOMEM;
	391	mlog_errno(status);
	392	goto bail;
	393	}
	394
	395	for (i = 0; i < si->si_blocks; i++) {
	396	status = ocfs2_extent_map_get_blocks(si->si_inode, i,
	397	&blkno, NULL, NULL);
	398	if (status < 0) {
	399	mlog_errno(status);
	400	goto bail;
	401	}
	402
	403	mlog(0, "Reading slot map block %u at %llu\n", i,
	404	(unsigned long long)blkno);
	405
	406	bh = NULL; /* Acquire a fresh bh */
8cb471e8 JB	407	status = ocfs2_read_blocks(INODE_CACHE(si->si_inode), blkno,
8cb471e8 JB	408	1, &bh, OCFS2_BH_IGNORE_CACHE, NULL);
1c8d9a6a JB	409	if (status < 0) {
	410	mlog_errno(status);
	411	goto bail;
	412	}
	413
	414	si->si_bh[i] = bh;
	415	}
	416
	417	bail:
	418	return status;
	419	}
	420
ccd979bd MF	421	int ocfs2_init_slot_info(struct ocfs2_super *osb)
ccd979bd MF	422	{
fc881fa0	423	int status;
ccd979bd	424	struct inode *inode = NULL;
ccd979bd MF	425	struct ocfs2_slot_info *si;
ccd979bd MF	426
fc881fa0 JB	427	si = kzalloc(sizeof(struct ocfs2_slot_info) +
	428	(sizeof(struct ocfs2_slot) * osb->max_slots),
	429	GFP_KERNEL);
ccd979bd MF	430	if (!si) {
	431	status = -ENOMEM;
	432	mlog_errno(status);
	433	goto bail;
	434	}
	435
386a2ef8	436	si->si_extended = ocfs2_uses_extended_slot_map(osb);
ccd979bd	437	si->si_num_slots = osb->max_slots;
fc881fa0 JB	438	si->si_slots = (struct ocfs2_slot )((char )si +
fc881fa0 JB	439	sizeof(struct ocfs2_slot_info));
ccd979bd MF	440
	441	inode = ocfs2_get_system_file_inode(osb, SLOT_MAP_SYSTEM_INODE,
	442	OCFS2_INVALID_SLOT);
	443	if (!inode) {
	444	status = -EINVAL;
	445	mlog_errno(status);
	446	goto bail;
	447	}
	448
1c8d9a6a JB	449	si->si_inode = inode;
1c8d9a6a JB	450	status = ocfs2_map_slot_buffers(osb, si);
ccd979bd MF	451	if (status < 0) {
	452	mlog_errno(status);
	453	goto bail;
	454	}
	455
d85b20e4	456	osb->slot_info = (struct ocfs2_slot_info *)si;
ccd979bd MF	457	bail:
ccd979bd MF	458	if (status < 0 && si)
8e8a4603	459	__ocfs2_free_slot_info(si);
ccd979bd MF	460
	461	return status;
	462	}
	463
8e8a4603	464	void ocfs2_free_slot_info(struct ocfs2_super *osb)
ccd979bd	465	{
8e8a4603 MF	466	struct ocfs2_slot_info *si = osb->slot_info;
	467
	468	osb->slot_info = NULL;
	469	__ocfs2_free_slot_info(si);
ccd979bd MF	470	}
	471
	472	int ocfs2_find_slot(struct ocfs2_super *osb)
	473	{
	474	int status;
fc881fa0	475	int slot;
ccd979bd MF	476	struct ocfs2_slot_info *si;
	477
	478	mlog_entry_void();
	479
	480	si = osb->slot_info;
	481
d85b20e4	482	spin_lock(&osb->osb_lock);
ccd979bd MF	483	ocfs2_update_slot_info(si);
ccd979bd MF	484
ccd979bd MF	485	/* search for ourselves first and take the slot if it already
	486	* exists. Perhaps we need to mark this in a variable for our
	487	* own journal recovery? Possibly not, though we certainly
	488	* need to warn to the user */
	489	slot = __ocfs2_node_num_to_slot(si, osb->node_num);
fc881fa0	490	if (slot < 0) {
ccd979bd MF	491	/* if no slot yet, then just take 1st available
ccd979bd MF	492	* one. */
baf4661a	493	slot = __ocfs2_find_empty_slot(si, osb->preferred_slot);
fc881fa0	494	if (slot < 0) {
d85b20e4	495	spin_unlock(&osb->osb_lock);
ccd979bd MF	496	mlog(ML_ERROR, "no free slots available!\n");
	497	status = -EINVAL;
	498	goto bail;
	499	}
	500	} else
	501	mlog(ML_NOTICE, "slot %d is already allocated to this node!\n",
	502	slot);
	503
fc881fa0	504	ocfs2_set_slot(si, slot, osb->node_num);
ccd979bd	505	osb->slot_num = slot;
d85b20e4	506	spin_unlock(&osb->osb_lock);
ccd979bd	507
e7607ab3	508	mlog(0, "taking node slot %d\n", osb->slot_num);
ccd979bd	509
386a2ef8	510	status = ocfs2_update_disk_slot(osb, si, osb->slot_num);
ccd979bd MF	511	if (status < 0)
	512	mlog_errno(status);
	513
	514	bail:
	515	mlog_exit(status);
	516	return status;
	517	}
	518
	519	void ocfs2_put_slot(struct ocfs2_super *osb)
	520	{
386a2ef8	521	int status, slot_num;
ccd979bd MF	522	struct ocfs2_slot_info *si = osb->slot_info;
	523
	524	if (!si)
	525	return;
	526
d85b20e4	527	spin_lock(&osb->osb_lock);
ccd979bd MF	528	ocfs2_update_slot_info(si);
ccd979bd MF	529
386a2ef8	530	slot_num = osb->slot_num;
fc881fa0	531	ocfs2_invalidate_slot(si, osb->slot_num);
ccd979bd	532	osb->slot_num = OCFS2_INVALID_SLOT;
d85b20e4	533	spin_unlock(&osb->osb_lock);
ccd979bd	534
386a2ef8	535	status = ocfs2_update_disk_slot(osb, si, slot_num);
ccd979bd MF	536	if (status < 0) {
	537	mlog_errno(status);
	538	goto bail;
	539	}
	540
	541	bail:
8e8a4603	542	ocfs2_free_slot_info(osb);
ccd979bd MF	543	}
ccd979bd MF	544