balloc.c

嵌入式linux下基于SRAM的内存文件系统

/*
 * FILE NAME fs/pramfs/balloc.c
 *
 * BRIEF MODULE DESCRIPTION
 *
 * The blocks allocation and deallocation routines.
 *
 * Author: Steve Longerbeam <[e-mail], or [e-mail]>
 *
 * Copyright 2003 Sony Corporation
 * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
 * 2003-2004 (c) MontaVista Software, Inc. This file is licensed under
 * the terms of the GNU General Public License version 2. This program
 * is licensed "as is" without any warranty of any kind, whether express
 * or implied.
 */

#include <linux/fs.h>
#include <linux/pram_fs.h>
#include <linux/quotaops.h>
#include <asm/bitops.h>


/*
 * This just marks in-use the blocks that make up the bitmap.
 * The bitmap must be writeable before calling.
 */
void pram_init_bitmap(struct super_block * sb)
{
	struct pram_super_block * ps = pram_get_super(sb);
	u32* bitmap = pram_get_bitmap(sb);
	int blocks = ps->s_bitmap_blocks;

	memset(bitmap, 0, blocks<<sb->s_blocksize_bits);

	while (blocks >= 32) {
		*bitmap++ = 0xffffffff;
		blocks -= 32;
	}

	if (blocks)
		*bitmap = (1<<blocks) - 1;
}


/* Free absolute blocknr */
void pram_free_block (struct super_block * sb, int blocknr)
{
	struct pram_super_block * ps;
	pram_off_t bitmap_block;
	int bitmap_bnr;
	void* bitmap;
	void* bp;

	lock_super (sb);

	bitmap = pram_get_bitmap(sb);
	/*
	 * find the block within the bitmap that contains the inuse bit
	 * for the block we need to free. We need to unlock this bitmap
	 * block to clear the inuse bit.
	 */
	bitmap_bnr = blocknr >> (3 + sb->s_blocksize_bits);
	bitmap_block = pram_get_block_off(sb, bitmap_bnr);
	bp = pram_get_block(sb, bitmap_block);

	pram_lock_block(sb, bp);
	clear_bit(blocknr, bitmap); // mark the block free
	pram_unlock_block(sb, bp);

	ps = pram_get_super(sb);
	pram_lock_super(sb);
	if (blocknr < pram_get_free_blocknr_hint(sb))
		pram_set_free_blocknr_hint(sb, blocknr);
	pram_inc_free_blocks_count(sb);
	pram_unlock_super(sb);

	unlock_super (sb);
}


/*
 * allocate a block and return it's absolute blocknr. Zeroes out the
 * block if zero set.
 */
int pram_new_block (struct super_block * sb, int* blocknr, int zero)
{
	struct pram_super_block * ps;
	pram_off_t bitmap_block;
	int bnr, bitmap_bnr, errval;
	void* bitmap;
	void* bp;

	lock_super (sb);
	ps = pram_get_super(sb);
	bitmap = pram_get_bitmap(sb);

	if (pram_get_free_blocks_count(sb)) {
		/* find the oldest unused block */
		bnr = find_next_zero_bit(bitmap,
					 ps->s_blocks_count,
					 pram_get_free_blocknr_hint(sb));

		if (bnr < ps->s_bitmap_blocks || bnr >= ps->s_blocks_count) {
			pram_err("no free blocks found!\n");
			errval = -ENOSPC;
			goto fail;
		}

		pram_dbg ("allocating blocknr %d\n", bnr);
		pram_lock_super(sb);
		pram_dec_free_blocks_count(sb);
		pram_set_free_blocknr_hint(sb, (bnr < ps->s_blocks_count-1) ? bnr+1 : 0);
		pram_unlock_super(sb);
	} else {
		pram_err("all blocks allocated\n");
		errval = -ENOSPC;
		goto fail;
	}

	/*
	 * find the block within the bitmap that contains the inuse bit
	 * for the unused block we just found. We need to unlock it to
	 * set the inuse bit.
	 */
	bitmap_bnr = bnr >> (3 + sb->s_blocksize_bits);
	bitmap_block = pram_get_block_off(sb, bitmap_bnr);
	bp = pram_get_block(sb, bitmap_block);

	/* no need to backup */
	pram_lock_block(sb, bp);
	set_bit(bnr, bitmap); // mark the new block in use
	pram_unlock_block(sb, bp);

	if (zero) {
		bp = pram_get_block(sb, pram_get_block_off(sb, bnr));
		/* no need to backup */
		pram_lock_block(sb, bp);
		memset(bp, 0, sb->s_blocksize);
		pram_unlock_block(sb, bp);
	}

	*blocknr = bnr;
	errval = 0;
 fail:
	unlock_super (sb);
	return errval;
}