[linux.git] / fs / sysv / ialloc.c

// SPDX-License-Identifier: GPL-2.0
/*
 *  linux/fs/sysv/ialloc.c
 *
 *  minix/bitmap.c
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  ext/freelists.c
 *  Copyright (C) 1992  Remy Card ([email protected])
 *
 *  xenix/alloc.c
 *  Copyright (C) 1992  Doug Evans
 *
 *  coh/alloc.c
 *  Copyright (C) 1993  Pascal Haible, Bruno Haible
 *
 *  sysv/ialloc.c
 *  Copyright (C) 1993  Bruno Haible
 *
 *  This file contains code for allocating/freeing inodes.
 */

#include <linux/kernel.h>
#include <linux/stddef.h>
#include <linux/sched.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/buffer_head.h>
#include <linux/writeback.h>
#include "sysv.h"

/* We don't trust the value of
   sb->sv_sbd2->s_tinode = *sb->sv_sb_total_free_inodes
   but we nevertheless keep it up to date. */

/* An inode on disk is considered free if both i_mode == 0 and i_nlink == 0. */

/* return &sb->sv_sb_fic_inodes[i] = &sbd->s_inode[i]; */
static inline sysv_ino_t *
sv_sb_fic_inode(struct super_block * sb, unsigned int i)
{
	struct sysv_sb_info *sbi = SYSV_SB(sb);

	if (sbi->s_bh1 == sbi->s_bh2)
		return &sbi->s_sb_fic_inodes[i];
	else {
		/* 512 byte Xenix FS */
		unsigned int offset = offsetof(struct xenix_super_block, s_inode[i]);
		if (offset < 512)
			return (sysv_ino_t*)(sbi->s_sbd1 + offset);
		else
			return (sysv_ino_t*)(sbi->s_sbd2 + offset);
	}
}

struct sysv_inode *
sysv_raw_inode(struct super_block *sb, unsigned ino, struct buffer_head **bh)
{
	struct sysv_sb_info *sbi = SYSV_SB(sb);
	struct sysv_inode *res;
	int block = sbi->s_firstinodezone + sbi->s_block_base;

	block += (ino-1) >> sbi->s_inodes_per_block_bits;
	*bh = sb_bread(sb, block);
	if (!*bh)
		return NULL;
	res = (struct sysv_inode *)(*bh)->b_data;
	return res + ((ino-1) & sbi->s_inodes_per_block_1);
}

static int refill_free_cache(struct super_block *sb)
{
	struct sysv_sb_info *sbi = SYSV_SB(sb);
	struct buffer_head * bh;
	struct sysv_inode * raw_inode;
	int i = 0, ino;

	ino = SYSV_ROOT_INO+1;
	raw_inode = sysv_raw_inode(sb, ino, &bh);
	if (!raw_inode)
		goto out;
	while (ino <= sbi->s_ninodes) {
		if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0) {
			*sv_sb_fic_inode(sb,i++) = cpu_to_fs16(SYSV_SB(sb), ino);
			if (i == sbi->s_fic_size)
				break;
		}
		if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
			brelse(bh);
			raw_inode = sysv_raw_inode(sb, ino, &bh);
			if (!raw_inode)
				goto out;
		} else
			raw_inode++;
	}
	brelse(bh);
out:
	return i;
}

void sysv_free_inode(struct inode * inode)
{
	struct super_block *sb = inode->i_sb;
	struct sysv_sb_info *sbi = SYSV_SB(sb);
	unsigned int ino;
	struct buffer_head * bh;
	struct sysv_inode * raw_inode;
	unsigned count;

	sb = inode->i_sb;
	ino = inode->i_ino;
	if (ino <= SYSV_ROOT_INO || ino > sbi->s_ninodes) {
		printk("sysv_free_inode: inode 0,1,2 or nonexistent inode\n");
		return;
	}
	raw_inode = sysv_raw_inode(sb, ino, &bh);
	if (!raw_inode) {
		printk("sysv_free_inode: unable to read inode block on device "
		       "%s\n", inode->i_sb->s_id);
		return;
	}
	mutex_lock(&sbi->s_lock);
	count = fs16_to_cpu(sbi, *sbi->s_sb_fic_count);
	if (count < sbi->s_fic_size) {
		*sv_sb_fic_inode(sb,count++) = cpu_to_fs16(sbi, ino);
		*sbi->s_sb_fic_count = cpu_to_fs16(sbi, count);
	}
	fs16_add(sbi, sbi->s_sb_total_free_inodes, 1);
	dirty_sb(sb);
	memset(raw_inode, 0, sizeof(struct sysv_inode));
	mark_buffer_dirty(bh);
	mutex_unlock(&sbi->s_lock);
	brelse(bh);
}

struct inode * sysv_new_inode(const struct inode * dir, umode_t mode)
{
	struct super_block *sb = dir->i_sb;
	struct sysv_sb_info *sbi = SYSV_SB(sb);
	struct inode *inode;
	sysv_ino_t ino;
	unsigned count;
	struct writeback_control wbc = {
		.sync_mode = WB_SYNC_NONE
	};

	inode = new_inode(sb);
	if (!inode)
		return ERR_PTR(-ENOMEM);

	mutex_lock(&sbi->s_lock);
	count = fs16_to_cpu(sbi, *sbi->s_sb_fic_count);
	if (count == 0 || (*sv_sb_fic_inode(sb,count-1) == 0)) {
		count = refill_free_cache(sb);
		if (count == 0) {
			iput(inode);
			mutex_unlock(&sbi->s_lock);
			return ERR_PTR(-ENOSPC);
		}
	}
	/* Now count > 0. */
	ino = *sv_sb_fic_inode(sb,--count);
	*sbi->s_sb_fic_count = cpu_to_fs16(sbi, count);
	fs16_add(sbi, sbi->s_sb_total_free_inodes, -1);
	dirty_sb(sb);
	inode_init_owner(&init_user_ns, inode, dir, mode);
	inode->i_ino = fs16_to_cpu(sbi, ino);
	inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
	inode->i_blocks = 0;
	memset(SYSV_I(inode)->i_data, 0, sizeof(SYSV_I(inode)->i_data));
	SYSV_I(inode)->i_dir_start_lookup = 0;
	insert_inode_hash(inode);
	mark_inode_dirty(inode);

	sysv_write_inode(inode, &wbc);	/* ensure inode not allocated again */
	mark_inode_dirty(inode);	/* cleared by sysv_write_inode() */
	/* That's it. */
	mutex_unlock(&sbi->s_lock);
	return inode;
}

unsigned long sysv_count_free_inodes(struct super_block * sb)
{
	struct sysv_sb_info *sbi = SYSV_SB(sb);
	struct buffer_head * bh;
	struct sysv_inode * raw_inode;
	int ino, count, sb_count;

	mutex_lock(&sbi->s_lock);

	sb_count = fs16_to_cpu(sbi, *sbi->s_sb_total_free_inodes);

	if (0)
		goto trust_sb;

	/* this causes a lot of disk traffic ... */
	count = 0;
	ino = SYSV_ROOT_INO+1;
	raw_inode = sysv_raw_inode(sb, ino, &bh);
	if (!raw_inode)
		goto Eio;
	while (ino <= sbi->s_ninodes) {
		if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0)
			count++;
		if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
			brelse(bh);
			raw_inode = sysv_raw_inode(sb, ino, &bh);
			if (!raw_inode)
				goto Eio;
		} else
			raw_inode++;
	}
	brelse(bh);
	if (count != sb_count)
		goto Einval;
out:
	mutex_unlock(&sbi->s_lock);
	return count;

Einval:
	printk("sysv_count_free_inodes: "
		"free inode count was %d, correcting to %d\n",
		sb_count, count);
	if (!sb_rdonly(sb)) {
		*sbi->s_sb_total_free_inodes = cpu_to_fs16(SYSV_SB(sb), count);
		dirty_sb(sb);
	}
	goto out;

Eio:
	printk("sysv_count_free_inodes: unable to read inode table\n");
trust_sb:
	count = sb_count;
	goto out;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	2	/*
	3	* linux/fs/sysv/ialloc.c
	4	*
	5	* minix/bitmap.c
	6	* Copyright (C) 1991, 1992 Linus Torvalds
	7	*
	8	* ext/freelists.c
	9	* Copyright (C) 1992 Remy Card ([email protected])
	10	*
	11	* xenix/alloc.c
	12	* Copyright (C) 1992 Doug Evans
	13	*
	14	* coh/alloc.c
	15	* Copyright (C) 1993 Pascal Haible, Bruno Haible
	16	*
	17	* sysv/ialloc.c
	18	* Copyright (C) 1993 Bruno Haible
	19	*
	20	* This file contains code for allocating/freeing inodes.
	21	*/
	22
	23	#include <linux/kernel.h>
	24	#include <linux/stddef.h>
	25	#include <linux/sched.h>
	26	#include <linux/stat.h>
	27	#include <linux/string.h>
	28	#include <linux/buffer_head.h>
46c23d7f	29	#include <linux/writeback.h>
1da177e4 LT	30	#include "sysv.h"
	31
	32	/* We don't trust the value of
	33	sb->sv_sbd2->s_tinode = *sb->sv_sb_total_free_inodes
	34	but we nevertheless keep it up to date. */
	35
	36	/* An inode on disk is considered free if both i_mode == 0 and i_nlink == 0. */
	37
	38	/* return &sb->sv_sb_fic_inodes[i] = &sbd->s_inode[i]; */
	39	static inline sysv_ino_t *
	40	sv_sb_fic_inode(struct super_block * sb, unsigned int i)
	41	{
	42	struct sysv_sb_info *sbi = SYSV_SB(sb);
	43
	44	if (sbi->s_bh1 == sbi->s_bh2)
	45	return &sbi->s_sb_fic_inodes[i];
	46	else {
	47	/* 512 byte Xenix FS */
	48	unsigned int offset = offsetof(struct xenix_super_block, s_inode[i]);
	49	if (offset < 512)
	50	return (sysv_ino_t*)(sbi->s_sbd1 + offset);
	51	else
	52	return (sysv_ino_t*)(sbi->s_sbd2 + offset);
	53	}
	54	}
	55
	56	struct sysv_inode *
	57	sysv_raw_inode(struct super_block sb, unsigned ino, struct buffer_head *bh)
	58	{
	59	struct sysv_sb_info *sbi = SYSV_SB(sb);
	60	struct sysv_inode *res;
	61	int block = sbi->s_firstinodezone + sbi->s_block_base;
	62
	63	block += (ino-1) >> sbi->s_inodes_per_block_bits;
	64	*bh = sb_bread(sb, block);
	65	if (!*bh)
	66	return NULL;
	67	res = (struct sysv_inode )(bh)->b_data;
	68	return res + ((ino-1) & sbi->s_inodes_per_block_1);
	69	}
	70
	71	static int refill_free_cache(struct super_block *sb)
	72	{
	73	struct sysv_sb_info *sbi = SYSV_SB(sb);
	74	struct buffer_head * bh;
	75	struct sysv_inode * raw_inode;
	76	int i = 0, ino;
	77
	78	ino = SYSV_ROOT_INO+1;
	79	raw_inode = sysv_raw_inode(sb, ino, &bh);
	80	if (!raw_inode)
	81	goto out;
	82	while (ino <= sbi->s_ninodes) {
	83	if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0) {
	84	*sv_sb_fic_inode(sb,i++) = cpu_to_fs16(SYSV_SB(sb), ino);
	85	if (i == sbi->s_fic_size)
	86	break;
	87	}
	88	if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
	89	brelse(bh);
	90	raw_inode = sysv_raw_inode(sb, ino, &bh);
	91	if (!raw_inode)
	92	goto out;
	93	} else
94	raw_inode++;
95	}
96	brelse(bh);
97	out:
98	return i;
99	}
100
101	void sysv_free_inode(struct inode * inode)
102	{
103	struct super_block *sb = inode->i_sb;
104	struct sysv_sb_info *sbi = SYSV_SB(sb);
105	unsigned int ino;
106	struct buffer_head * bh;
107	struct sysv_inode * raw_inode;
108	unsigned count;
109
110	sb = inode->i_sb;
111	ino = inode->i_ino;
112	if (ino <= SYSV_ROOT_INO \|\| ino > sbi->s_ninodes) {
113	printk("sysv_free_inode: inode 0,1,2 or nonexistent inode\n");
114	return;
115	}
116	raw_inode = sysv_raw_inode(sb, ino, &bh);
1da177e4 LT	117	if (!raw_inode) {
	118	printk("sysv_free_inode: unable to read inode block on device "
	119	"%s\n", inode->i_sb->s_id);
	120	return;
	121	}
c07cb01c	122	mutex_lock(&sbi->s_lock);
1da177e4 LT	123	count = fs16_to_cpu(sbi, *sbi->s_sb_fic_count);
	124	if (count < sbi->s_fic_size) {
	125	*sv_sb_fic_inode(sb,count++) = cpu_to_fs16(sbi, ino);
	126	*sbi->s_sb_fic_count = cpu_to_fs16(sbi, count);
	127	}
	128	fs16_add(sbi, sbi->s_sb_total_free_inodes, 1);
	129	dirty_sb(sb);
	130	memset(raw_inode, 0, sizeof(struct sysv_inode));
	131	mark_buffer_dirty(bh);
c07cb01c	132	mutex_unlock(&sbi->s_lock);
1da177e4 LT	133	brelse(bh);
	134	}
	135
dd716e64	136	struct inode * sysv_new_inode(const struct inode * dir, umode_t mode)
1da177e4 LT	137	{
	138	struct super_block *sb = dir->i_sb;
	139	struct sysv_sb_info *sbi = SYSV_SB(sb);
	140	struct inode *inode;
	141	sysv_ino_t ino;
	142	unsigned count;
46c23d7f LR	143	struct writeback_control wbc = {
	144	.sync_mode = WB_SYNC_NONE
	145	};
1da177e4 LT	146
	147	inode = new_inode(sb);
	148	if (!inode)
	149	return ERR_PTR(-ENOMEM);
	150
c07cb01c	151	mutex_lock(&sbi->s_lock);
1da177e4 LT	152	count = fs16_to_cpu(sbi, *sbi->s_sb_fic_count);
	153	if (count == 0 \|\| (*sv_sb_fic_inode(sb,count-1) == 0)) {
	154	count = refill_free_cache(sb);
	155	if (count == 0) {
	156	iput(inode);
c07cb01c	157	mutex_unlock(&sbi->s_lock);
1da177e4 LT	158	return ERR_PTR(-ENOSPC);
	159	}
	160	}
	161	/* Now count > 0. */
	162	ino = *sv_sb_fic_inode(sb,--count);
	163	*sbi->s_sb_fic_count = cpu_to_fs16(sbi, count);
	164	fs16_add(sbi, sbi->s_sb_total_free_inodes, -1);
	165	dirty_sb(sb);
21cb47be	166	inode_init_owner(&init_user_ns, inode, dir, mode);
1da177e4	167	inode->i_ino = fs16_to_cpu(sbi, ino);
02027d42	168	inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
ba52de12	169	inode->i_blocks = 0;
1da177e4 LT	170	memset(SYSV_I(inode)->i_data, 0, sizeof(SYSV_I(inode)->i_data));
	171	SYSV_I(inode)->i_dir_start_lookup = 0;
	172	insert_inode_hash(inode);
	173	mark_inode_dirty(inode);
	174
46c23d7f	175	sysv_write_inode(inode, &wbc); /* ensure inode not allocated again */
1da177e4 LT	176	mark_inode_dirty(inode); /* cleared by sysv_write_inode() */
1da177e4 LT	177	/* That's it. */
c07cb01c	178	mutex_unlock(&sbi->s_lock);
1da177e4 LT	179	return inode;
	180	}
	181
	182	unsigned long sysv_count_free_inodes(struct super_block * sb)
	183	{
	184	struct sysv_sb_info *sbi = SYSV_SB(sb);
	185	struct buffer_head * bh;
	186	struct sysv_inode * raw_inode;
	187	int ino, count, sb_count;
	188
c07cb01c	189	mutex_lock(&sbi->s_lock);
1da177e4 LT	190
	191	sb_count = fs16_to_cpu(sbi, *sbi->s_sb_total_free_inodes);
	192
	193	if (0)
	194	goto trust_sb;
	195
	196	/* this causes a lot of disk traffic ... */
	197	count = 0;
	198	ino = SYSV_ROOT_INO+1;
	199	raw_inode = sysv_raw_inode(sb, ino, &bh);
	200	if (!raw_inode)
	201	goto Eio;
	202	while (ino <= sbi->s_ninodes) {
	203	if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0)
	204	count++;
	205	if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
	206	brelse(bh);
	207	raw_inode = sysv_raw_inode(sb, ino, &bh);
	208	if (!raw_inode)
	209	goto Eio;
	210	} else
	211	raw_inode++;
	212	}
	213	brelse(bh);
	214	if (count != sb_count)
	215	goto Einval;
	216	out:
c07cb01c	217	mutex_unlock(&sbi->s_lock);
1da177e4 LT	218	return count;
	219
	220	Einval:
	221	printk("sysv_count_free_inodes: "
	222	"free inode count was %d, correcting to %d\n",
	223	sb_count, count);
bc98a42c	224	if (!sb_rdonly(sb)) {
1da177e4 LT	225	*sbi->s_sb_total_free_inodes = cpu_to_fs16(SYSV_SB(sb), count);
	226	dirty_sb(sb);
	227	}
	228	goto out;
	229
	230	Eio:
	231	printk("sysv_count_free_inodes: unable to read inode table\n");
	232	trust_sb:
	233	count = sb_count;
	234	goto out;
	235	}