Skip to content
Snippets Groups Projects
Commit 958c5180 authored by Wang Di's avatar Wang Di
Browse files

update smfs 1)some fix in cache mount 2)some fix in lookup and touch, create

parent b799e13b
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
lustre/smfs/cache.c
+ 166
− 42
View file @ 958c5180
......@@ -74,41 +74,12 @@ void cleanup_smfs_cache()
return;
}
static void setup_sm_symlink_ops(struct inode *cache_inode,
struct inode *inode,
struct inode_operations *cache_sym_iops,
struct file_operations *cache_sym_fops)
{
return;
}
static void setup_sm_file_ops(struct inode *cache_inode,
struct inode *inode,
struct inode_operations *cache_iops,
struct file_operations *cache_fops,
struct address_space_operations *cache_aops)
static void setup_iops(struct inode *cache_inode,
struct inode_operations *iops,
struct inode_operations *cache_iops)
{
struct smfs_super_info *smb;
struct inode_operations *iops;
struct file_operations *fops;
struct address_space_operations *aops;
smb = S2SMI(inode->i_sb);
if (smb->ops_check & FILE_OPS_CHECK)
return;
smb->ops_check |= FILE_OPS_CHECK;
iops = cache_fiops(&smfs_operations);
fops = cache_ffops(&smfs_operations);
aops = cache_faops(&smfs_operations);
memset(iops , 0 , sizeof (struct inode_operations));
memset(fops , 0 , sizeof (struct file_operations));
memset(aops , 0 , sizeof (struct address_space_operations));
if (cache_inode->i_op) {
if (cache_inode->i_op && cache_iops && iops) {
if (cache_inode->i_op->create)
iops->create = cache_iops->create;
if (cache_inode->i_op->create_it)
......@@ -174,12 +145,163 @@ static void setup_sm_file_ops(struct inode *cache_inode,
if (cache_inode->i_op->removexattr)
iops->removexattr = cache_iops->removexattr;
}
if (cache_inode->i_fop) {
}
static void setup_fops(struct inode *cache_inode,
struct file_operations *fops,
struct file_operations *cache_fops)
{
if (cache_inode->i_fop && cache_fops && fops) {
if (cache_inode->i_fop->llseek)
fops->llseek = cache_fops->llseek;
if (cache_inode->i_fop->read)
fops->read = cache_fops->read;
if (cache_inode->i_fop->write)
fops->write = cache_fops->write;
if (cache_inode->i_fop->readdir)
fops->readdir = cache_fops->readdir;
if (cache_inode->i_fop->poll)
fops->poll = cache_fops->poll;
if (cache_inode->i_fop->ioctl)
fops->ioctl = cache_fops->ioctl;
if (cache_inode->i_fop->mmap)
fops->mmap = cache_fops->mmap;
if (cache_inode->i_fop->open)
fops->open = cache_fops->open;
if (cache_inode->i_fop->flush)
fops->flush = cache_fops->flush;
if (cache_inode->i_fop->release)
fops->release = cache_fops->release;
if (cache_inode->i_fop->fsync)
fops->fsync = cache_fops->fsync;
if (cache_inode->i_fop->fasync)
fops->fasync = cache_fops->fasync;
if (cache_inode->i_fop->lock)
fops->lock = cache_fops->lock;
if (cache_inode->i_fop->readv)
fops->readv = cache_fops->readv;
if (cache_inode->i_fop->writev)
fops->writev = cache_fops->writev;
if (cache_inode->i_fop->sendpage)
fops->sendpage = cache_fops->sendpage;
if (cache_inode->i_fop->get_unmapped_area)
fops->get_unmapped_area = cache_fops->get_unmapped_area;
}
}
static void setup_aops(struct inode *cache_inode,
struct address_space_operations *aops,
struct address_space_operations *cache_aops)
{
if (cache_inode && cache_inode->i_mapping &&
aops && cache_aops) {
struct address_space_operations *caops = cache_inode->i_mapping->a_ops;
if (caops->writepage)
aops->writepage = cache_aops->writepage;
if (caops->readpage)
aops->readpage = cache_aops->readpage;
if (caops->sync_page)
aops->sync_page = cache_aops->sync_page;
if (caops->prepare_write)
aops->prepare_write = cache_aops->prepare_write;
if (caops->commit_write)
aops->commit_write = cache_aops->commit_write;
if (caops->bmap)
aops->bmap = cache_aops->bmap;
if (caops->flushpage)
aops->flushpage = cache_aops->flushpage;
if (caops->releasepage)
aops->releasepage = cache_aops->releasepage;
if (caops->direct_IO)
aops->direct_IO = cache_aops->direct_IO;
if (caops->removepage)
aops->removepage = cache_aops->removepage;
}
};
static void setup_sm_file_ops(struct inode *cache_inode,
struct inode *inode,
struct inode_operations *cache_iops,
struct file_operations *cache_fops,
struct address_space_operations *cache_aops)
{
}
if (cache_inode->i_mapping && cache_inode->i_mapping->a_ops) {
struct smfs_super_info *smb;
struct inode_operations *iops;
struct file_operations *fops;
struct address_space_operations *aops;
smb = S2SMI(inode->i_sb);
}
if (smb->ops_check & FILE_OPS_CHECK)
return;
smb->ops_check |= FILE_OPS_CHECK;
iops = cache_fiops(&smfs_operations);
fops = cache_ffops(&smfs_operations);
aops = cache_faops(&smfs_operations);
memset(iops , 0 , sizeof (struct inode_operations));
memset(fops , 0 , sizeof (struct file_operations));
memset(aops , 0 , sizeof (struct address_space_operations));
setup_iops(cache_inode, iops, cache_iops);
setup_fops(cache_inode, fops, cache_fops);
setup_aops(cache_inode, aops, cache_aops);
return;
}
static void setup_sm_dir_ops(struct inode *cache_inode,
struct inode *inode,
struct inode_operations *cache_dir_iops,
struct file_operations *cache_dir_fops)
{
struct smfs_super_info *smb;
struct inode_operations *iops;
struct file_operations *fops;
smb = S2SMI(inode->i_sb);
if (smb->ops_check & DIR_OPS_CHECK)
return;
smb->ops_check |= DIR_OPS_CHECK;
iops = cache_diops(&smfs_operations);
fops = cache_dfops(&smfs_operations);
memset(iops, 0, sizeof (struct inode_operations));
memset(fops, 0, sizeof (struct file_operations));
setup_iops(cache_inode, iops, cache_dir_iops);
setup_fops(cache_inode, fops, cache_dir_fops);
return;
}
static void setup_sm_symlink_ops(struct inode *cache_inode,
struct inode *inode,
struct inode_operations *cache_sym_iops,
struct file_operations *cache_sym_fops)
{
struct smfs_super_info *smb;
struct inode_operations *iops;
struct file_operations *fops;
smb = S2SMI(inode->i_sb);
if (smb->ops_check & SYMLINK_OPS_CHECK)
return;
smb->ops_check |= SYMLINK_OPS_CHECK;
iops = cache_siops(&smfs_operations);
fops = cache_sfops(&smfs_operations);
memset(iops , 0 , sizeof (struct inode_operations));
memset(fops , 0 , sizeof (struct file_operations));
setup_iops(cache_inode, iops, cache_sym_iops);
setup_fops(cache_inode, fops, cache_sym_fops);
return;
}
......@@ -236,14 +358,17 @@ static void setup_sm_sb_ops(struct super_block *cache_sb,
if (cache_sb->s_op->show_options)
sops->show_options = smfs_sops->show_options;
}
return;
}
void sm_set_inode_ops(struct inode *cache_inode, struct inode *inode)
{
/* XXX now set the correct snap_{file,dir,sym}_iops */
if (S_ISDIR(inode->i_mode)) {
inode->i_op = cache_diops(&smfs_operations);
setup_sm_dir_ops(cache_inode, inode,
&smfs_dir_iops,
&smfs_dir_fops);
inode->i_op = cache_diops(&smfs_operations);
inode->i_fop = cache_dfops(&smfs_operations);
} else if (S_ISREG(inode->i_mode)) {
setup_sm_file_ops(cache_inode, inode,
......@@ -256,9 +381,8 @@ void sm_set_inode_ops(struct inode *cache_inode, struct inode *inode)
inode->i_op = cache_fiops(&smfs_operations);
if (inode->i_mapping)
inode->i_mapping->a_ops = cache_faops(&smfs_operations);
}
else if (S_ISLNK(inode->i_mode)) {
} else if (S_ISLNK(inode->i_mode)) {
setup_sm_symlink_ops(cache_inode, inode,
&smfs_sym_iops,
&smfs_sym_fops);
......
lustre/smfs/dir.c
+ 43
− 3
View file @ 958c5180
......@@ -90,8 +90,48 @@ exit:
d_unalloc(cache_dentry);
RETURN(rc);
}
static struct dentry *smfs_lookup(struct inode *dir,
struct dentry *dentry)
{
struct inode *cache_dir;
struct inode *cache_inode, *inode;
struct dentry tmp;
struct dentry *cache_dentry;
struct dentry *rc = NULL;
ENTRY;
cache_dir = I2CI(dir);
if (!cache_dir)
RETURN(ERR_PTR(-ENOENT));
prepare_parent_dentry(&tmp, cache_dir);
cache_dentry = d_alloc(&tmp, &dentry->d_name);
if (!cache_dentry)
RETURN(ERR_PTR(-ENOENT));
struct inode_operations smfs_dir_fops = {
create: smfs_create,
};
if(cache_dir && cache_dir->i_op->lookup)
rc = cache_dir->i_op->lookup(cache_dir, cache_dentry);
if (rc || !cache_dentry->d_inode ||
is_bad_inode(cache_dentry->d_inode) ||
IS_ERR(cache_dentry->d_inode)) {
GOTO(exit, rc);
}
cache_inode = cache_dentry->d_inode;
inode = iget(dir->i_sb, cache_inode->i_ino);
d_add(dentry, inode);
exit:
d_unalloc(cache_dentry);
RETURN(rc);
}
struct inode_operations smfs_dir_iops = {
create: smfs_create,
lookup: smfs_lookup,
};
struct file_operations smfs_dir_fops = {
};
lustre/smfs/inode.c
+ 1
− 3
View file @ 958c5180
......@@ -50,15 +50,13 @@ static void smfs_read_inode(struct inode *inode)
if(cache_sb && cache_sb->s_op->read_inode)
cache_sb->s_op->read_inode(cache_inode);
CDEBUG(D_INODE, "read_inode ino %lu icount %d \n",
inode->i_ino, atomic_read(&inode->i_count));
duplicate_inode(cache_inode, inode);
sm_set_inode_ops(cache_inode, inode);
CDEBUG(D_INODE, "read_inode ino %lu icount %d \n",
inode->i_ino, atomic_read(&inode->i_count));
iput(cache_inode);
return;
}
/* Although some filesystem(such as ext3) do not have
......
lustre/smfs/super.c
+ 15
− 17
View file @ 958c5180
......@@ -190,6 +190,14 @@ static char *parse_path2dev(struct super_block *sb, char *dev_path)
memcpy(name, dev_path, strlen(dev_path) + 1);
RETURN(name);
}
static void duplicate_sb(struct super_block *csb,
struct super_block *sb)
{
sb->s_blocksize = csb->s_blocksize;
sb->s_magic = csb->s_magic;
sb->s_blocksize_bits = csb->s_blocksize_bits;
sb->s_maxbytes = csb->s_maxbytes;
}
extern struct super_operations smfs_super_ops;
static int sm_mount_cache(struct super_block *sb,
......@@ -222,6 +230,8 @@ static int sm_mount_cache(struct super_block *sb,
smb = S2SMI(sb);
smb->smsi_sb = mnt->mnt_sb;
smb->smsi_mnt = mnt;
duplicate_sb(mnt->mnt_sb, sb);
sm_set_sb_ops(mnt->mnt_sb, sb);
err_out:
if (dev_name)
......@@ -234,6 +244,7 @@ static int sm_umount_cache(struct super_block *sb)
struct smfs_super_info *smb = S2SMI(sb);
mntput(smb->smsi_mnt);
return 0;
}
void smfs_put_super(struct super_block *sb)
......@@ -249,8 +260,6 @@ smfs_read_super(
void *data,
int silent)
{
struct smfs_inode_info *smi;
struct dentry *bottom_root;
struct inode *root_inode = NULL;
char *devstr = NULL, *typestr = NULL;
char *cache_data;
......@@ -278,19 +287,10 @@ smfs_read_super(
CERROR("Can not mount %s as %s\n", devstr, typestr);
GOTO(out_err, 0);
}
/* set up the super block */
bottom_root = dget(S2SMI(sb)->smsi_sb->s_root);
if (!bottom_root) {
CERROR("bottom not mounted\n");
GOTO(out_err, err=-ENOENT);
}
root_ino = bottom_root->d_inode->i_ino;
root_ino = S2CSB(sb)->s_root->d_inode->i_ino;
root_inode = iget(sb, root_ino);
smi = I2SMI(root_inode);
/*FIXME Intialize smi here*/
CDEBUG(D_SUPER, "readinode %p, root ino %ld, root inode at %p\n",
sb->s_op->read_inode, root_ino, root_inode);
......@@ -299,13 +299,11 @@ smfs_read_super(
if (!sb->s_root) {
GOTO(out_err, err=-EINVAL);
}
CDEBUG(D_SUPER, "sb %lx, &sb->u.generic_sbp: %lx\n",
(ulong) sb, (ulong) &sb->u.generic_sbp);
out_err:
if (root_inode)
iput(root_inode);
out_err:
cleanup_option();
if (err)
return NULL;
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

https://git.gsi.de is provided by CIT→Linux&Web | GSI Helmholtzzentrum fuer Schwerionenforschung GmbH | Imprint (in German) | Privacy policy