[linux-2.6-block.git] / fs / minix / bitmap.c

/*
 *  linux/fs/minix/bitmap.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

/*
 * Modified for 680x0 by Hamish Macdonald
 * Fixed for 680x0 by Andreas Schwab
 */

/* bitmap.c contains the code that handles the inode and block bitmaps */

#include "minix.h"
#include <linux/buffer_head.h>
#include <linux/bitops.h>
#include <linux/sched.h>

static const int nibblemap[] = { 4,3,3,2,3,2,2,1,3,2,2,1,2,1,1,0 };

static DEFINE_SPINLOCK(bitmap_lock);

static unsigned long count_free(struct buffer_head *map[], unsigned numblocks, __u32 numbits)
{
	unsigned i, j, sum = 0;
	struct buffer_head *bh;
  
	for (i=0; i<numblocks-1; i++) {
		if (!(bh=map[i])) 
			return(0);
		for (j=0; j<bh->b_size; j++)
			sum += nibblemap[bh->b_data[j] & 0xf]
				+ nibblemap[(bh->b_data[j]>>4) & 0xf];
	}

	if (numblocks==0 || !(bh=map[numblocks-1]))
		return(0);
	i = ((numbits - (numblocks-1) * bh->b_size * 8) / 16) * 2;
	for (j=0; j<i; j++) {
		sum += nibblemap[bh->b_data[j] & 0xf]
			+ nibblemap[(bh->b_data[j]>>4) & 0xf];
	}

	i = numbits%16;
	if (i!=0) {
		i = *(__u16 *)(&bh->b_data[j]) | ~((1<<i) - 1);
		sum += nibblemap[i & 0xf] + nibblemap[(i>>4) & 0xf];
		sum += nibblemap[(i>>8) & 0xf] + nibblemap[(i>>12) & 0xf];
	}
	return(sum);
}

void minix_free_block(struct inode *inode, unsigned long block)
{
	struct super_block *sb = inode->i_sb;
	struct minix_sb_info *sbi = minix_sb(sb);
	struct buffer_head *bh;
	int k = sb->s_blocksize_bits + 3;
	unsigned long bit, zone;

	if (block < sbi->s_firstdatazone || block >= sbi->s_nzones) {
		printk("Trying to free block not in datazone\n");
		return;
	}
	zone = block - sbi->s_firstdatazone + 1;
	bit = zone & ((1<<k) - 1);
	zone >>= k;
	if (zone >= sbi->s_zmap_blocks) {
		printk("minix_free_block: nonexistent bitmap buffer\n");
		return;
	}
	bh = sbi->s_zmap[zone];
	spin_lock(&bitmap_lock);
	if (!minix_test_and_clear_bit(bit, bh->b_data))
		printk("minix_free_block (%s:%lu): bit already cleared\n",
		       sb->s_id, block);
	spin_unlock(&bitmap_lock);
	mark_buffer_dirty(bh);
	return;
}

int minix_new_block(struct inode * inode)
{
	struct minix_sb_info *sbi = minix_sb(inode->i_sb);
	int bits_per_zone = 8 * inode->i_sb->s_blocksize;
	int i;

	for (i = 0; i < sbi->s_zmap_blocks; i++) {
		struct buffer_head *bh = sbi->s_zmap[i];
		int j;

		spin_lock(&bitmap_lock);
		j = minix_find_first_zero_bit(bh->b_data, bits_per_zone);
		if (j < bits_per_zone) {
			minix_set_bit(j, bh->b_data);
			spin_unlock(&bitmap_lock);
			mark_buffer_dirty(bh);
			j += i * bits_per_zone + sbi->s_firstdatazone-1;
			if (j < sbi->s_firstdatazone || j >= sbi->s_nzones)
				break;
			return j;
		}
		spin_unlock(&bitmap_lock);
	}
	return 0;
}

unsigned long minix_count_free_blocks(struct minix_sb_info *sbi)
{
	return (count_free(sbi->s_zmap, sbi->s_zmap_blocks,
		sbi->s_nzones - sbi->s_firstdatazone + 1)
		<< sbi->s_log_zone_size);
}

struct minix_inode *
minix_V1_raw_inode(struct super_block *sb, ino_t ino, struct buffer_head **bh)
{
	int block;
	struct minix_sb_info *sbi = minix_sb(sb);
	struct minix_inode *p;

	if (!ino || ino > sbi->s_ninodes) {
		printk("Bad inode number on dev %s: %ld is out of range\n",
		       sb->s_id, (long)ino);
		return NULL;
	}
	ino--;
	block = 2 + sbi->s_imap_blocks + sbi->s_zmap_blocks +
		 ino / MINIX_INODES_PER_BLOCK;
	*bh = sb_bread(sb, block);
	if (!*bh) {
		printk("Unable to read inode block\n");
		return NULL;
	}
	p = (void *)(*bh)->b_data;
	return p + ino % MINIX_INODES_PER_BLOCK;
}

struct minix2_inode *
minix_V2_raw_inode(struct super_block *sb, ino_t ino, struct buffer_head **bh)
{
	int block;
	struct minix_sb_info *sbi = minix_sb(sb);
	struct minix2_inode *p;
	int minix2_inodes_per_block = sb->s_blocksize / sizeof(struct minix2_inode);

	*bh = NULL;
	if (!ino || ino > sbi->s_ninodes) {
		printk("Bad inode number on dev %s: %ld is out of range\n",
		       sb->s_id, (long)ino);
		return NULL;
	}
	ino--;
	block = 2 + sbi->s_imap_blocks + sbi->s_zmap_blocks +
		 ino / minix2_inodes_per_block;
	*bh = sb_bread(sb, block);
	if (!*bh) {
		printk("Unable to read inode block\n");
		return NULL;
	}
	p = (void *)(*bh)->b_data;
	return p + ino % minix2_inodes_per_block;
}

/* Clear the link count and mode of a deleted inode on disk. */

static void minix_clear_inode(struct inode *inode)
{
	struct buffer_head *bh = NULL;

	if (INODE_VERSION(inode) == MINIX_V1) {
		struct minix_inode *raw_inode;
		raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
		if (raw_inode) {
			raw_inode->i_nlinks = 0;
			raw_inode->i_mode = 0;
		}
	} else {
		struct minix2_inode *raw_inode;
		raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
		if (raw_inode) {
			raw_inode->i_nlinks = 0;
			raw_inode->i_mode = 0;
		}
	}
	if (bh) {
		mark_buffer_dirty(bh);
		brelse (bh);
	}
}

void minix_free_inode(struct inode * inode)
{
	struct super_block *sb = inode->i_sb;
	struct minix_sb_info *sbi = minix_sb(inode->i_sb);
	struct buffer_head *bh;
	int k = sb->s_blocksize_bits + 3;
	unsigned long ino, bit;

	ino = inode->i_ino;
	if (ino < 1 || ino > sbi->s_ninodes) {
		printk("minix_free_inode: inode 0 or nonexistent inode\n");
		goto out;
	}
	bit = ino & ((1<<k) - 1);
	ino >>= k;
	if (ino >= sbi->s_imap_blocks) {
		printk("minix_free_inode: nonexistent imap in superblock\n");
		goto out;
	}

	minix_clear_inode(inode);	/* clear on-disk copy */

	bh = sbi->s_imap[ino];
	spin_lock(&bitmap_lock);
	if (!minix_test_and_clear_bit(bit, bh->b_data))
		printk("minix_free_inode: bit %lu already cleared\n", bit);
	spin_unlock(&bitmap_lock);
	mark_buffer_dirty(bh);
 out:
	clear_inode(inode);		/* clear in-memory copy */
}

struct inode * minix_new_inode(const struct inode * dir, int * error)
{
	struct super_block *sb = dir->i_sb;
	struct minix_sb_info *sbi = minix_sb(sb);
	struct inode *inode = new_inode(sb);
	struct buffer_head * bh;
	int bits_per_zone = 8 * sb->s_blocksize;
	unsigned long j;
	int i;

	if (!inode) {
		*error = -ENOMEM;
		return NULL;
	}
	j = bits_per_zone;
	bh = NULL;
	*error = -ENOSPC;
	spin_lock(&bitmap_lock);
	for (i = 0; i < sbi->s_imap_blocks; i++) {
		bh = sbi->s_imap[i];
		j = minix_find_first_zero_bit(bh->b_data, bits_per_zone);
		if (j < bits_per_zone)
			break;
	}
	if (!bh || j >= bits_per_zone) {
		spin_unlock(&bitmap_lock);
		iput(inode);
		return NULL;
	}
	if (minix_test_and_set_bit(j, bh->b_data)) {	/* shouldn't happen */
		spin_unlock(&bitmap_lock);
		printk("minix_new_inode: bit already set\n");
		iput(inode);
		return NULL;
	}
	spin_unlock(&bitmap_lock);
	mark_buffer_dirty(bh);
	j += i * bits_per_zone;
	if (!j || j > sbi->s_ninodes) {
		iput(inode);
		return NULL;
	}
	inode->i_uid = current_fsuid();
	inode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current_fsgid();
	inode->i_ino = j;
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
	inode->i_blocks = 0;
	memset(&minix_i(inode)->u, 0, sizeof(minix_i(inode)->u));
	insert_inode_hash(inode);
	mark_inode_dirty(inode);

	*error = 0;
	return inode;
}

unsigned long minix_count_free_inodes(struct minix_sb_info *sbi)
{
	return count_free(sbi->s_imap, sbi->s_imap_blocks, sbi->s_ninodes + 1);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/minix/bitmap.c
	3	*
	4	* Copyright (C) 1991, 1992 Linus Torvalds
	5	*/
	6
	7	/*
	8	* Modified for 680x0 by Hamish Macdonald
	9	* Fixed for 680x0 by Andreas Schwab
	10	*/
	11
	12	/* bitmap.c contains the code that handles the inode and block bitmaps */
	13
	14	#include "minix.h"
1da177e4 LT	15	#include <linux/buffer_head.h>
1da177e4 LT	16	#include <linux/bitops.h>
e8edc6e0	17	#include <linux/sched.h>
1da177e4	18
febfcf91	19	static const int nibblemap[] = { 4,3,3,2,3,2,2,1,3,2,2,1,2,1,1,0 };
1da177e4	20
cc46759a AV	21	static DEFINE_SPINLOCK(bitmap_lock);
cc46759a AV	22
1da177e4 LT	23	static unsigned long count_free(struct buffer_head *map[], unsigned numblocks, __u32 numbits)
	24	{
	25	unsigned i, j, sum = 0;
	26	struct buffer_head *bh;
	27
	28	for (i=0; i<numblocks-1; i++) {
	29	if (!(bh=map[i]))
	30	return(0);
939b00df	31	for (j=0; j<bh->b_size; j++)
1da177e4 LT	32	sum += nibblemap[bh->b_data[j] & 0xf]
	33	+ nibblemap[(bh->b_data[j]>>4) & 0xf];
	34	}
	35
	36	if (numblocks==0 \|\| !(bh=map[numblocks-1]))
	37	return(0);
939b00df	38	i = ((numbits - (numblocks-1) * bh->b_size * 8) / 16) * 2;
1da177e4 LT	39	for (j=0; j<i; j++) {
	40	sum += nibblemap[bh->b_data[j] & 0xf]
	41	+ nibblemap[(bh->b_data[j]>>4) & 0xf];
	42	}
	43
	44	i = numbits%16;
	45	if (i!=0) {
	46	i = (__u16 )(&bh->b_data[j]) \| ~((1<<i) - 1);
	47	sum += nibblemap[i & 0xf] + nibblemap[(i>>4) & 0xf];
	48	sum += nibblemap[(i>>8) & 0xf] + nibblemap[(i>>12) & 0xf];
	49	}
	50	return(sum);
	51	}
	52
939b00df	53	void minix_free_block(struct inode *inode, unsigned long block)
1da177e4	54	{
939b00df AB	55	struct super_block *sb = inode->i_sb;
	56	struct minix_sb_info *sbi = minix_sb(sb);
	57	struct buffer_head *bh;
	58	int k = sb->s_blocksize_bits + 3;
	59	unsigned long bit, zone;
1da177e4 LT	60
1da177e4 LT	61	if (block < sbi->s_firstdatazone \|\| block >= sbi->s_nzones) {
11b84487	62	printk("Trying to free block not in datazone\n");
1da177e4 LT	63	return;
	64	}
	65	zone = block - sbi->s_firstdatazone + 1;
939b00df AB	66	bit = zone & ((1<<k) - 1);
939b00df AB	67	zone >>= k;
1da177e4 LT	68	if (zone >= sbi->s_zmap_blocks) {
	69	printk("minix_free_block: nonexistent bitmap buffer\n");
	70	return;
	71	}
	72	bh = sbi->s_zmap[zone];
cc46759a	73	spin_lock(&bitmap_lock);
939b00df AB	74	if (!minix_test_and_clear_bit(bit, bh->b_data))
939b00df AB	75	printk("minix_free_block (%s:%lu): bit already cleared\n",
1da177e4	76	sb->s_id, block);
cc46759a	77	spin_unlock(&bitmap_lock);
1da177e4 LT	78	mark_buffer_dirty(bh);
	79	return;
	80	}
	81
	82	int minix_new_block(struct inode * inode)
	83	{
	84	struct minix_sb_info *sbi = minix_sb(inode->i_sb);
939b00df	85	int bits_per_zone = 8 * inode->i_sb->s_blocksize;
1da177e4 LT	86	int i;
	87
	88	for (i = 0; i < sbi->s_zmap_blocks; i++) {
	89	struct buffer_head *bh = sbi->s_zmap[i];
	90	int j;
	91
cc46759a	92	spin_lock(&bitmap_lock);
939b00df AB	93	j = minix_find_first_zero_bit(bh->b_data, bits_per_zone);
	94	if (j < bits_per_zone) {
	95	minix_set_bit(j, bh->b_data);
cc46759a	96	spin_unlock(&bitmap_lock);
1da177e4	97	mark_buffer_dirty(bh);
939b00df	98	j += i * bits_per_zone + sbi->s_firstdatazone-1;
1da177e4 LT	99	if (j < sbi->s_firstdatazone \|\| j >= sbi->s_nzones)
	100	break;
	101	return j;
	102	}
cc46759a	103	spin_unlock(&bitmap_lock);
1da177e4 LT	104	}
	105	return 0;
	106	}
	107
	108	unsigned long minix_count_free_blocks(struct minix_sb_info *sbi)
	109	{
	110	return (count_free(sbi->s_zmap, sbi->s_zmap_blocks,
	111	sbi->s_nzones - sbi->s_firstdatazone + 1)
	112	<< sbi->s_log_zone_size);
	113	}
	114
	115	struct minix_inode *
	116	minix_V1_raw_inode(struct super_block sb, ino_t ino, struct buffer_head *bh)
	117	{
	118	int block;
	119	struct minix_sb_info *sbi = minix_sb(sb);
	120	struct minix_inode *p;
	121
	122	if (!ino \|\| ino > sbi->s_ninodes) {
	123	printk("Bad inode number on dev %s: %ld is out of range\n",
	124	sb->s_id, (long)ino);
	125	return NULL;
	126	}
	127	ino--;
	128	block = 2 + sbi->s_imap_blocks + sbi->s_zmap_blocks +
	129	ino / MINIX_INODES_PER_BLOCK;
	130	*bh = sb_bread(sb, block);
	131	if (!*bh) {
11b84487	132	printk("Unable to read inode block\n");
1da177e4 LT	133	return NULL;
	134	}
	135	p = (void )(bh)->b_data;
	136	return p + ino % MINIX_INODES_PER_BLOCK;
	137	}
	138
	139	struct minix2_inode *
	140	minix_V2_raw_inode(struct super_block sb, ino_t ino, struct buffer_head *bh)
	141	{
	142	int block;
	143	struct minix_sb_info *sbi = minix_sb(sb);
	144	struct minix2_inode *p;
939b00df	145	int minix2_inodes_per_block = sb->s_blocksize / sizeof(struct minix2_inode);
1da177e4 LT	146
	147	*bh = NULL;
	148	if (!ino \|\| ino > sbi->s_ninodes) {
	149	printk("Bad inode number on dev %s: %ld is out of range\n",
	150	sb->s_id, (long)ino);
	151	return NULL;
	152	}
	153	ino--;
	154	block = 2 + sbi->s_imap_blocks + sbi->s_zmap_blocks +
939b00df	155	ino / minix2_inodes_per_block;
1da177e4 LT	156	*bh = sb_bread(sb, block);
1da177e4 LT	157	if (!*bh) {
11b84487	158	printk("Unable to read inode block\n");
1da177e4 LT	159	return NULL;
	160	}
	161	p = (void )(bh)->b_data;
939b00df	162	return p + ino % minix2_inodes_per_block;
1da177e4 LT	163	}
	164
	165	/* Clear the link count and mode of a deleted inode on disk. */
	166
	167	static void minix_clear_inode(struct inode *inode)
	168	{
	169	struct buffer_head *bh = NULL;
	170
	171	if (INODE_VERSION(inode) == MINIX_V1) {
	172	struct minix_inode *raw_inode;
	173	raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
	174	if (raw_inode) {
	175	raw_inode->i_nlinks = 0;
	176	raw_inode->i_mode = 0;
	177	}
	178	} else {
	179	struct minix2_inode *raw_inode;
	180	raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
	181	if (raw_inode) {
	182	raw_inode->i_nlinks = 0;
	183	raw_inode->i_mode = 0;
	184	}
	185	}
	186	if (bh) {
	187	mark_buffer_dirty(bh);
	188	brelse (bh);
	189	}
	190	}
	191
	192	void minix_free_inode(struct inode * inode)
	193	{
939b00df	194	struct super_block *sb = inode->i_sb;
1da177e4	195	struct minix_sb_info *sbi = minix_sb(inode->i_sb);
939b00df AB	196	struct buffer_head *bh;
	197	int k = sb->s_blocksize_bits + 3;
	198	unsigned long ino, bit;
1da177e4 LT	199
	200	ino = inode->i_ino;
	201	if (ino < 1 \|\| ino > sbi->s_ninodes) {
	202	printk("minix_free_inode: inode 0 or nonexistent inode\n");
	203	goto out;
	204	}
939b00df AB	205	bit = ino & ((1<<k) - 1);
	206	ino >>= k;
	207	if (ino >= sbi->s_imap_blocks) {
1da177e4 LT	208	printk("minix_free_inode: nonexistent imap in superblock\n");
	209	goto out;
	210	}
	211
	212	minix_clear_inode(inode); /* clear on-disk copy */
	213
939b00df	214	bh = sbi->s_imap[ino];
cc46759a	215	spin_lock(&bitmap_lock);
939b00df AB	216	if (!minix_test_and_clear_bit(bit, bh->b_data))
939b00df AB	217	printk("minix_free_inode: bit %lu already cleared\n", bit);
cc46759a	218	spin_unlock(&bitmap_lock);
1da177e4 LT	219	mark_buffer_dirty(bh);
	220	out:
	221	clear_inode(inode); /* clear in-memory copy */
	222	}
	223
	224	struct inode * minix_new_inode(const struct inode * dir, int * error)
	225	{
	226	struct super_block *sb = dir->i_sb;
	227	struct minix_sb_info *sbi = minix_sb(sb);
	228	struct inode *inode = new_inode(sb);
	229	struct buffer_head * bh;
939b00df AB	230	int bits_per_zone = 8 * sb->s_blocksize;
	231	unsigned long j;
	232	int i;
1da177e4 LT	233
	234	if (!inode) {
	235	*error = -ENOMEM;
	236	return NULL;
	237	}
939b00df	238	j = bits_per_zone;
1da177e4 LT	239	bh = NULL;
1da177e4 LT	240	*error = -ENOSPC;
cc46759a	241	spin_lock(&bitmap_lock);
1da177e4 LT	242	for (i = 0; i < sbi->s_imap_blocks; i++) {
1da177e4 LT	243	bh = sbi->s_imap[i];
939b00df AB	244	j = minix_find_first_zero_bit(bh->b_data, bits_per_zone);
939b00df AB	245	if (j < bits_per_zone)
1da177e4 LT	246	break;
1da177e4 LT	247	}
939b00df	248	if (!bh \|\| j >= bits_per_zone) {
cc46759a	249	spin_unlock(&bitmap_lock);
1da177e4 LT	250	iput(inode);
	251	return NULL;
	252	}
939b00df	253	if (minix_test_and_set_bit(j, bh->b_data)) { /* shouldn't happen */
cc46759a	254	spin_unlock(&bitmap_lock);
939b00df	255	printk("minix_new_inode: bit already set\n");
1da177e4 LT	256	iput(inode);
	257	return NULL;
	258	}
cc46759a	259	spin_unlock(&bitmap_lock);
1da177e4	260	mark_buffer_dirty(bh);
939b00df	261	j += i * bits_per_zone;
1da177e4 LT	262	if (!j \|\| j > sbi->s_ninodes) {
	263	iput(inode);
	264	return NULL;
	265	}
922c030f DH	266	inode->i_uid = current_fsuid();
922c030f DH	267	inode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current_fsgid();
1da177e4 LT	268	inode->i_ino = j;
1da177e4 LT	269	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
ba52de12	270	inode->i_blocks = 0;
1da177e4 LT	271	memset(&minix_i(inode)->u, 0, sizeof(minix_i(inode)->u));
	272	insert_inode_hash(inode);
	273	mark_inode_dirty(inode);
	274
	275	*error = 0;
	276	return inode;
	277	}
	278
	279	unsigned long minix_count_free_inodes(struct minix_sb_info *sbi)
	280	{
	281	return count_free(sbi->s_imap, sbi->s_imap_blocks, sbi->s_ninodes + 1);
	282	}