[linux.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 DEFINE_SPINLOCK(bitmap_lock);

/*
 * bitmap consists of blocks filled with 16bit words
 * bit set == busy, bit clear == free
 * endianness is a mess, but for counting zero bits it really doesn't matter...
 */
static __u32 count_free(struct buffer_head *map[], unsigned blocksize, __u32 numbits)
{
	__u32 sum = 0;
	unsigned blocks = DIV_ROUND_UP(numbits, blocksize * 8);

	while (blocks--) {
		unsigned words = blocksize / 2;
		__u16 *p = (__u16 *)(*map++)->b_data;
		while (words--)
			sum += 16 - hweight16(*p++);
	}

	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 super_block *sb)
{
	struct minix_sb_info *sbi = minix_sb(sb);
	u32 bits = sbi->s_nzones - sbi->s_firstdatazone + 1;

	return (count_free(sbi->s_zmap, sb->s_blocksize, bits)
		<< 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");
		return;
	}
	bit = ino & ((1<<k) - 1);
	ino >>= k;
	if (ino >= sbi->s_imap_blocks) {
		printk("minix_free_inode: nonexistent imap in superblock\n");
		return;
	}

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

struct inode *minix_new_inode(const struct inode *dir, umode_t mode, 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_init_owner(inode, dir, mode);
	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 super_block *sb)
{
	struct minix_sb_info *sbi = minix_sb(sb);
	u32 bits = sbi->s_ninodes + 1;

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