嵌入式Linux

开发平台：
Unix_Linux

ialloc.c：源码内容
							/*
 *  linux/fs/sysv/ialloc.c
 *
 *  minix/bitmap.c
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  ext/freelists.c
 *  Copyright (C) 1992  Remy Card (card@masi.ibp.fr)
 *
 *  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/fs.h>
#include <linux/sysv_fs.h>
#include <linux/stddef.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/locks.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)
{
	if (sb->sv_bh1 == sb->sv_bh2)
		return &sb->sv_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*)(sb->sv_sbd1 + offset);
		else
			return (sysv_ino_t*)(sb->sv_sbd2 + offset);
	}
}
struct sysv_inode *
sysv_raw_inode(struct super_block *sb, unsigned ino, struct buffer_head **bh)
{
	struct sysv_inode *res;
	int block = sb->sv_firstinodezone + sb->sv_block_base;
	block += (ino-1) >> sb->sv_inodes_per_block_bits;
	*bh = sb_bread(sb, block);
	if (!*bh)
		return NULL;
	res = (struct sysv_inode *) (*bh)->b_data;
	return res + ((ino-1) & sb->sv_inodes_per_block_1);
}
static int refill_free_cache(struct super_block *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 <= sb->sv_ninodes) {
		if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0) {
			*sv_sb_fic_inode(sb,i++) = cpu_to_fs16(sb, ino);
			if (i == sb->sv_fic_size)
				break;
		}
		if ((ino++ & sb->sv_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;
	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 > sb->sv_ninodes) {
		printk("sysv_free_inode: inode 0,1,2 or nonexistent inoden");
		return;
	}
	raw_inode = sysv_raw_inode(sb, ino, &bh);
	clear_inode(inode);
	if (!raw_inode) {
		printk("sysv_free_inode: unable to read inode block on device "
		       "%sn", bdevname(inode->i_dev));
		return;
	}
	lock_super(sb);
	count = fs16_to_cpu(sb, *sb->sv_sb_fic_count);
	if (count < sb->sv_fic_size) {
		*sv_sb_fic_inode(sb,count++) = cpu_to_fs16(sb, ino);
		*sb->sv_sb_fic_count = cpu_to_fs16(sb, count);
	}
	fs16_add(sb, sb->sv_sb_total_free_inodes, 1);
	dirty_sb(sb);
	memset(raw_inode, 0, sizeof(struct sysv_inode));
	mark_buffer_dirty(bh);
	unlock_super(sb);
	brelse(bh);
}
struct inode * sysv_new_inode(const struct inode * dir, mode_t mode)
{
	struct inode * inode;
	struct super_block * sb;
	u16 ino;
	unsigned count;
	sb = dir->i_sb;
	inode = new_inode(sb);
	if (!inode)
		return ERR_PTR(-ENOMEM);
	lock_super(sb);
	count = fs16_to_cpu(sb, *sb->sv_sb_fic_count);
	if (count == 0 || (*sv_sb_fic_inode(sb,count-1) == 0)) {
		count = refill_free_cache(sb);
		if (count == 0) {
			iput(inode);
			unlock_super(sb);
			return ERR_PTR(-ENOSPC);
		}
	}
	/* Now count > 0. */
	ino = *sv_sb_fic_inode(sb,--count);
	*sb->sv_sb_fic_count = cpu_to_fs16(sb, count);
	fs16_add(sb, sb->sv_sb_total_free_inodes, -1);
	dirty_sb(sb);
	
	if (dir->i_mode & S_ISGID) {
		inode->i_gid = dir->i_gid;
		if (S_ISDIR(mode))
			mode |= S_ISGID;
	} else
		inode->i_gid = current->fsgid;
	inode->i_uid = current->fsuid;
	inode->i_ino = fs16_to_cpu(sb, ino);
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	inode->i_blocks = inode->i_blksize = 0;
	inode->u.sysv_i.i_dir_start_lookup = 0;
	insert_inode_hash(inode);
	mark_inode_dirty(inode);
	inode->i_mode = mode;		/* for sysv_write_inode() */
	sysv_write_inode(inode, 0);	/* ensure inode not allocated again */
	mark_inode_dirty(inode);	/* cleared by sysv_write_inode() */
	/* That's it. */
	unlock_super(sb);
	return inode;
}
unsigned long sysv_count_free_inodes(struct super_block * sb)
{
	struct buffer_head * bh;
	struct sysv_inode * raw_inode;
	int ino, count, sb_count;
	lock_super(sb);
	sb_count = fs16_to_cpu(sb, *sb->sv_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 <= sb->sv_ninodes) {
		if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0)
			count++;
		if ((ino++ & sb->sv_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:
	unlock_super(sb);
	return count;
Einval:
	printk("sysv_count_free_inodes: "
		"free inode count was %d, correcting to %dn",
		sb_count, count);
	if (!(sb->s_flags & MS_RDONLY)) {
		*sb->sv_sb_total_free_inodes = cpu_to_fs16(sb, count);
		dirty_sb(sb);
	}
	goto out;
Eio:
	printk("sysv_count_free_inodes: unable to read inode tablen");
trust_sb:
	count = sb_count;
	goto out;
}

						