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

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