myfsinode.c

一个LINUX下一个框架文件系统,运行编译环境：RED HAT LINUX7.3

#include "common.h"
#include "mytypes.h"

extern void setup_server_ip( char* ip_addr );
extern int lookup_root( char* dirname, struct myfs_meta *meta );

extern struct inode_operations myfs_file_inode_operations;
extern struct file_operations myfs_file_operations;

extern struct inode_operations myfs_dir_inode_operations;
extern struct file_operations myfs_dir_operations;

//==============================	Fuctions Pre-Declaration	===============================
static struct super_block *myfs_read_super(struct super_block *, void *, int);
static void myfs_read_inode(struct inode *);
static void myfs_clear_inode(struct inode *);
static int myfs_statfs(struct super_block *sb, struct statfs *buf);
static void myfs_put_super(struct super_block *sb);

static struct inode *myfs_super_iget(struct super_block *sb, char *name);
struct myfs_inode *myfs_inop(struct inode *ino);
static inline struct myfs_super *myfs_sbp(struct super_block *sb);
static int myfs_meta_to_inode(struct myfs_meta *mbuf, struct inode *ibuf);

struct file_system_type myfs_fs_type = {
   "myfs", 0, myfs_read_super, NULL
};

struct super_operations myfs_super_operations =
{
	read_inode:    myfs_read_inode,
	clear_inode:   myfs_clear_inode,
	put_super:     myfs_put_super,
	statfs:        myfs_statfs,
};

//=============================================================================================
void show_super( struct super_block *sb, struct inode * root )
{
	struct myfs_super *myfs_sbp = NULL;
	struct myfs_inode *pinode;

	printk( "--------------- Now Show super block---------------\n" );
	//first of all, let's show all the atomic variables
	printk( "superblock: s_maxbytes = 0x%lx\n", sb->s_maxbytes );
	printk( "superblock: s_magic = 0x%lx\n", sb->s_magic );
	printk( "superblock: s_blocksize = %ld\n", sb->s_blocksize );
	printk( "superblock: s_blocksize_bits = %d\n", sb->s_blocksize_bits );

	//Now, show the structed data
	//struct myfs_super * sb->u.generic_sbp
	myfs_sbp = (struct myfs_super *)sb->u.generic_sbp;
	printk( "superblock->u.generic_sbp: flags = 0x%x\n", myfs_sbp->flags );
	printk( "superblock->u.generic_sbp: port = %d\n", myfs_sbp->port );
	printk( "superblock->u.generic_sbp: manager = %s\n", myfs_sbp->mgr );
	printk( "superblock->u.generic_sbp: directory = %s\n", myfs_sbp->dir );

	//struct inode	*root
	printk( "---inode *root---: i_ino(number) = 0x%lx\n", root->i_ino );
	printk( "---inode *root---: i_count = %d\n", root->i_count );
	printk( "---inode *root---: i_mode = 0x%x\n", root->i_mode );
	printk( "---inode *root---: i_uid = %d\n", root->i_uid );
	printk( "---inode *root---: i_gid = %d\n", root->i_gid );
	printk( "---inode *root---: i_size = %ld\n", root->i_size );
	printk( "---inode *root---: i_blksize = %ld\n", root->i_blksize );
	printk( "---inode *root---: i_blocks = %ld\n", root->i_blocks );
	//root->u.generic_ip
	pinode = root->u.generic_ip;
	printk( "---inode *root->u.generic_ip---: handle = 0x%lx\n", pinode->handle );
	printk( "---inode *root->u.generic_ip---: name = %s\n", pinode->name );
	
	//struct dentry	*s_root
	printk( "superblock->s_root: d_name = %s\n", sb->s_root->d_name.name );
	printk( "--------------- Show super block Finish---------------\n" );
}
void show_myfs_meta( struct myfs_meta *pmeta )
{
	printk("--------------Now Show PVFS Metadata.----------------\n");
	printk( "Field 1:handle:\t0x%lx\n", pmeta->handle );
	printk( "Field 2:isValid:\t0x%x\n", pmeta->valid );
	printk( "Field 3:ProtectionMode:\t0x%x\n", pmeta->mode );
	printk( "Field 4:uid:\t0x%x\n", pmeta->uid );
	printk( "Field 5:gid:\t0x%x\n", pmeta->gid );
	printk( "Field 6:size:\t%ld\n", pmeta->size );
	printk( "Field 10:blksize:\t%ld\n", pmeta->blksize );
	printk( "Field 11:numofblocks:\t%ld\n", pmeta->blocks );
	printk("--------------Show PVFS Metadata Finish.----------------\n");
}

//==============================	MyFs Read Super	===========================================
static struct super_block * myfs_read_super(struct super_block *sb, 
					    void *data, int silent)
{
	struct myfs_super *myfs_sbp = NULL;
	struct inode *root;
	struct fs_mount_data *mntdata = (struct fs_mount_data *)data;

	printk("myfs_read_super called.\n");

	if (data == NULL) {
		if (!silent) printk("myfs_read_super: no data parameter!\n");
		goto myfs_read_super_abort;
	}

	if ((myfs_sbp = (struct myfs_super *) kmalloc(sizeof(struct
		myfs_super), GFP_KERNEL)) == NULL)
	{
		if (!silent) printk("myfs_read_super: kmalloc failed!\n");
		goto myfs_read_super_abort;
	}

//	show_mnt_data( data );
	/* data has already been copied in... */
	myfs_sbp->flags = mntdata->flags;
	myfs_sbp->port = mntdata->port;
	strcpy(myfs_sbp->mgr, mntdata->mgr);
	strcpy(myfs_sbp->dir, mntdata->dir);

	setup_server_ip( mntdata->mgr );

	/* modify the superblock */
	sb->s_maxbytes = ~0ULL;	/* Whoohoo, unlimited file size! */
	sb->s_magic = MYFS_SUPER_MAGIC;
	sb->s_blocksize = 4096;
	sb->s_blocksize_bits = 12;
	sb->s_op = &myfs_super_operations;
	sb->u.generic_sbp = myfs_sbp;

	/* set up root inode info */
	root = myfs_super_iget(sb, myfs_sbp->dir);
	if (root == NULL) goto myfs_read_super_abort;

	sb->s_root = d_alloc_root(root);

	show_super( sb, root );
	return sb;

myfs_read_super_abort:
	printk("myfs_read_super aborting!\n");
	sb->s_dev = 0;
	if (myfs_sbp != NULL) kfree(myfs_sbp);

	return NULL;
}
//=============================================================================================

//===================================	MyFs Special Routines	===============================
static struct inode *myfs_super_iget(struct super_block *sb, char *name)
{
	struct myfs_meta meta;
	struct myfs_inode *pinode;
	struct inode *inode;

	if (lookup_root( name, &meta) < 0) {
		printk("myfs_super_iget crapped out at lookup_root\n");
		return NULL;
	}
	show_myfs_meta( &meta );

	if ((inode = iget(sb, meta.handle)) == NULL) {
		printk("myfs_super_iget crapped out at iget\n");
		return NULL;
	}

	/* allocate and fill in the inode structure... */
	if ((pinode = (struct myfs_inode *) kmalloc(sizeof(struct myfs_inode)
	+ sizeof(name) + 1, GFP_KERNEL)) == NULL)
	{
		iput(inode);
		return NULL;
	}
	
	pinode->handle = meta.handle;
	myfs_meta_to_inode(&meta, inode);
	pinode->name = (int8_t *)pinode + sizeof(struct myfs_inode);
	strcpy(pinode->name, name);
	pinode->super = myfs_sbp(sb);
	inode->u.generic_ip = pinode;

	if (S_ISDIR(inode->i_mode)) {
		printk( "This inode is a directory! i_mode:0x%x\n", inode->i_mode );
		inode->i_op = &myfs_dir_inode_operations;
		inode->i_fop = &myfs_dir_operations;
	}
   else if (S_ISREG(inode->i_mode)) {
		printk( "This inode is a REG! i_mode:0x%x\n", inode->i_mode );
		inode->i_op = NULL;
		inode->i_fop = NULL;
	}
   else {
		printk( "This inode is a 'else' types! i_mode:0x%x\n", inode->i_mode );
		inode->i_op = NULL;
		inode->i_fop = NULL;
	}

	return inode;
}

struct myfs_inode *myfs_inop(struct inode *ino)
{
	return ino->u.generic_ip;
}

static inline struct myfs_super *myfs_sbp(struct super_block *sb)
{
	return sb->u.generic_sbp;
}

static int myfs_meta_to_inode(struct myfs_meta *mbuf, struct inode *ibuf)
{
	ibuf->i_mode = mbuf->mode;
	ibuf->i_uid = mbuf->uid;
	ibuf->i_gid = mbuf->gid;
	ibuf->i_size = mbuf->size;
	ibuf->i_atime = mbuf->atime;
	ibuf->i_mtime = mbuf->mtime;
	ibuf->i_ctime = mbuf->ctime;
	ibuf->i_blksize = mbuf->blksize;
	ibuf->i_blocks = mbuf->blocks;

	return 0;
}
//=============================================================================================
//===================================	MyFs Read Inode	=======================================
static void myfs_read_inode(struct inode *inode)
{
	printk("myfs_read_inode() called (does nothing).\n");
	return;
}
//=============================================================================================

//===================================	MyFs Clear Inode	===================================
static void myfs_clear_inode(struct inode *inode)
{
	struct myfs_inode *pinode;

	pinode = myfs_inop(inode);
	kfree(pinode);
	inode->u.generic_ip = NULL;

	printk("myfs_clear_inode() called.\n");
	return;
}
//=============================================================================================

//===================================	MyFs put super	===================================
static void myfs_put_super(struct super_block *sb)
{
	printk( "myfs_put_super called.\n");
	kfree(sb->u.generic_sbp);
	return;
}

//===================================	MyFs Stats Inode	===================================
static int myfs_statfs(struct super_block *sb, struct statfs *buf)
{
	printk("myfs_statfs() called (does nothing).\n");
	return 1;
}
//=============================================================================================