diff --git a/lustre/smfs/cache.c b/lustre/smfs/cache.c
index 400da0ab3cad0341ca461c21aaecc2e7b6c08094..e154bb60233e49ce3180f5025070617f80097b19 100644
--- a/lustre/smfs/cache.c
+++ b/lustre/smfs/cache.c
@@ -221,31 +221,56 @@ static void setup_sm_symlink_ops(struct inode *cache_inode, struct inode *inode,
unlock_kernel();
}
-static void setup_sm_sb_ops(struct super_block *cache_sb, struct super_block *sb,
- struct super_operations *smfs_sops)
+
+void sm_set_inode_ops(struct inode *cache_inode, struct inode *inode)
{
- struct smfs_super_info *smb;
- struct super_operations *sops;
+ struct smfs_super_info *smb = S2SMI(inode->i_sb);
- ENTRY;
+ /* XXX now set the correct sm_{file,dir,sym}_iops */
+ if (S_ISDIR(inode->i_mode)) {
+ setup_sm_dir_ops(cache_inode, inode,
+ &smfs_dir_iops,
+ &smfs_dir_fops);
+ inode->i_op = cache_diops(smb);
+ inode->i_fop = cache_dfops(smb);
+ } else if (S_ISREG(inode->i_mode)) {
+ setup_sm_file_ops(cache_inode, inode,
+ &smfs_file_iops,
+ &smfs_file_fops);
+ CDEBUG(D_INODE, "inode %lu, i_op at %p\n",
+ inode->i_ino, inode->i_op);
+ inode->i_fop = cache_ffops(smb);
+ inode->i_op = cache_fiops(smb);
- smb = S2SMI(sb);
+ } else if (S_ISLNK(inode->i_mode)) {
+ setup_sm_symlink_ops(cache_inode, inode,
+ &smfs_sym_iops,
+ &smfs_sym_fops);
+ inode->i_op = cache_siops(smb);
+ inode->i_fop = cache_sfops(smb);
+ CDEBUG(D_INODE, "inode %lu, i_op at %p\n",
+ inode->i_ino, inode->i_op);
+ }
+}
+
+
+void sm_set_sb_ops(struct super_block *cache_sb, struct super_block *sb)
+{
+ struct smfs_super_info *smb = S2SMI(sb);
+ struct super_operations *sops = &smb->sm_ops->sm_sb_ops;
+ struct super_operations *smfs_sops = &smfs_super_ops;
+ ENTRY;
if (smb->smsi_ops_check & SB_OPS_CHECK)
return;
-
- sops = cache_sops(smb);
+
+ //set up only operations exist in backfs
memset(sops, 0, sizeof (struct super_operations));
-
if (cache_sb->s_op) {
if (cache_sb->s_op->dirty_inode)
sops->dirty_inode = smfs_sops->dirty_inode;
if (cache_sb->s_op->write_inode)
sops->write_inode = smfs_sops->write_inode;
- if (cache_sb->s_op->put_inode)
- sops->put_inode = smfs_sops->put_inode;
- if (cache_sb->s_op->delete_inode)
- sops->delete_inode = smfs_sops->delete_inode;
if (cache_sb->s_op->put_super)
sops->put_super = smfs_sops->put_super;
if (cache_sb->s_op->write_super)
@@ -258,8 +283,8 @@ static void setup_sm_sb_ops(struct super_block *cache_sb, struct super_block *sb
sops->statfs = smfs_sops->statfs;
if (cache_sb->s_op->remount_fs)
sops->remount_fs = smfs_sops->remount_fs;
- if (cache_sb->s_op->umount_begin)
- sops->umount_begin = smfs_sops->umount_begin;
+ //if (cache_sb->s_op->umount_begin)
+ // sops->umount_begin = smfs_sops->umount_begin;
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
if (cache_sb->s_op->fh_to_dentry)
@@ -268,58 +293,20 @@ static void setup_sm_sb_ops(struct super_block *cache_sb, struct super_block *sb
sops->dentry_to_fh = smfs_sops->dentry_to_fh;
if (cache_sb->s_op->show_options)
sops->show_options = smfs_sops->show_options;
+
sops->read_inode2 = smfs_sops->read_inode2;
#endif
- /* FIXME-WANGDI we need this method to clear the cache inode. */
+ /* these ops are needed always */
sops->clear_inode = smfs_sops->clear_inode;
+ sops->delete_inode = smfs_sops->delete_inode;
+
}
lock_kernel();
smb->smsi_ops_check |= SB_OPS_CHECK;
unlock_kernel();
+ sb->s_op = sops;
return;
}
-void sm_set_inode_ops(struct inode *cache_inode, struct inode *inode)
-{
- struct smfs_super_info *smb = S2SMI(inode->i_sb);
-
- /* XXX now set the correct sm_{file,dir,sym}_iops */
- if (S_ISDIR(inode->i_mode)) {
- setup_sm_dir_ops(cache_inode, inode,
- &smfs_dir_iops,
- &smfs_dir_fops);
- inode->i_op = cache_diops(smb);
- inode->i_fop = cache_dfops(smb);
- } else if (S_ISREG(inode->i_mode)) {
- setup_sm_file_ops(cache_inode, inode,
- &smfs_file_iops,
- &smfs_file_fops);
- CDEBUG(D_INODE, "inode %lu, i_op at %p\n",
- inode->i_ino, inode->i_op);
- inode->i_fop = cache_ffops(smb);
- inode->i_op = cache_fiops(smb);
-
- } else if (S_ISLNK(inode->i_mode)) {
- setup_sm_symlink_ops(cache_inode, inode,
- &smfs_sym_iops,
- &smfs_sym_fops);
- inode->i_op = cache_siops(smb);
- inode->i_fop = cache_sfops(smb);
- CDEBUG(D_INODE, "inode %lu, i_op at %p\n",
- inode->i_ino, inode->i_op);
- }
-}
-
-void sm_set_sb_ops(struct super_block *cache_sb, struct super_block *sb)
-{
- struct smfs_super_info *smb;
-
- smb = S2SMI(sb);
-
- setup_sm_sb_ops(cache_sb, sb, &smfs_super_ops);
-
- sb->s_op = cache_sops(smb);
- return;
-}
diff --git a/lustre/smfs/dir.c b/lustre/smfs/dir.c
index 774bde8ffca041410638acaf224b14cf374b0ca5..b26cca98081d257e584baf0d6a4497ea84cf436a 100644
--- a/lustre/smfs/dir.c
+++ b/lustre/smfs/dir.c
@@ -54,54 +54,58 @@ static int smfs_create(struct inode *dir, struct dentry *dentry,
struct dentry *cache_dentry = NULL;
struct dentry *cache_parent = NULL;
void *handle = NULL;
- struct inode *cache_inode = NULL;
+ struct hook_msg msg = {
+ .dir = dir,
+ .dentry = dentry,
+ };
int rc = 0;
-
+
ENTRY;
cache_dir = I2CI(dir);
- LASSERT(cache_dir && cache_dir->i_op->create);
+ LASSERT(cache_dir);
+ LASSERT(cache_dir->i_op->create);
//lock_kernel();
cache_parent = pre_smfs_dentry(NULL, cache_dir, dentry);
cache_dentry = pre_smfs_dentry(cache_parent, NULL, dentry);
-
- if (!cache_dentry || !cache_parent)
- GOTO(exit, rc = -ENOMEM);
+ if (!cache_dentry || !cache_parent) {
+ rc = -ENOMEM;
+ goto exit;
+ }
- pre_smfs_inode(dir, cache_dir);
-
handle = smfs_trans_start(dir, FSFILT_OP_CREATE, NULL);
- if (IS_ERR(handle))
- GOTO(exit, rc = -ENOSPC);
-
- SMFS_HOOK(dir, dentry, NULL, NULL, HOOK_CREATE, handle,
- PRE_HOOK, rc, exit);
+ if (IS_ERR(handle)) {
+ rc = -ENOSPC;
+ goto exit;
+ }
+ SMFS_PRE_HOOK(dir->i_sb, HOOK_CREATE, &msg);
+
+ pre_smfs_inode(dir, cache_dir);
+
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
rc = cache_dir->i_op->create(cache_dir, cache_dentry, mode);
#else
rc = cache_dir->i_op->create(cache_dir, cache_dentry, mode, nd);
#endif
- cache_inode = cache_dentry->d_inode;
-
- if (rc)
- GOTO(exit, rc);
+ if (!rc) {
+ inode = smfs_get_inode(dir->i_sb, cache_dentry->d_inode->i_ino, dir, 0);
+ if (inode)
+ d_instantiate(dentry, inode);
+ else
+ rc = -ENOENT;
+ }
- SMFS_IGET(dir, cache_inode->i_ino, inode, rc, exit);
-
- d_instantiate(dentry, inode);
-
- SMFS_HOOK(dir, dentry, NULL, NULL, HOOK_CREATE, handle,
- POST_HOOK, rc, exit);
+ SMFS_POST_HOOK(dir->i_sb, HOOK_CREATE, &msg, rc);
post_smfs_inode(dir, cache_dir);
+ smfs_trans_commit(dir, handle, 0);
exit:
//unlock_kernel();
post_smfs_dentry(cache_dentry);
post_smfs_dentry(cache_parent);
- smfs_trans_commit(dir, handle, 0);
RETURN(rc);
}
@@ -113,28 +117,32 @@ static struct dentry *smfs_lookup(struct inode *dir, struct dentry *dentry,
#endif
{
struct inode *cache_dir;
- struct inode *cache_inode;
struct inode *inode = NULL;
+ struct inode * cache_inode = NULL;
struct dentry *cache_dentry = NULL;
struct dentry *cache_parent = NULL;
struct dentry *rdentry = NULL;
int rc = 0;
+ struct hook_msg msg = {
+ .dir = dir,
+ .dentry = dentry,
+ };
ENTRY;
-
+
cache_dir = I2CI(dir);
- if (!cache_dir || !cache_dir->i_op->lookup)
+ if (!cache_dir)
RETURN(ERR_PTR(-ENOENT));
+ LASSERT(cache_dir->i_op->lookup);
+
/* preparing artificial backing fs dentries. */
cache_parent = pre_smfs_dentry(NULL, cache_dir, dentry->d_parent);
cache_dentry = pre_smfs_dentry(cache_parent, NULL, dentry);
-
- if (!cache_dentry || !cache_parent)
- RETURN (ERR_PTR(-ENOMEM));
-
- SMFS_HOOK(dir, dentry, NULL, NULL, HOOK_LOOKUP, NULL,
- PRE_HOOK, rc, exit);
+ if (!cache_dentry || !cache_parent)
+ RETURN(ERR_PTR(-ENOMEM));
+
+ SMFS_PRE_HOOK(dir->i_sb, HOOK_LOOKUP, &msg);
/* perform lookup in backing fs. */
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
@@ -142,31 +150,31 @@ static struct dentry *smfs_lookup(struct inode *dir, struct dentry *dentry,
#else
rdentry = cache_dir->i_op->lookup(cache_dir, cache_dentry, nd);
#endif
- cache_inode = cache_dentry->d_inode;
-
if (rdentry) {
if (IS_ERR(rdentry))
- GOTO(exit, rdentry);
-
- cache_inode = rdentry->d_inode;
- dput(rdentry);
- rdentry = NULL;
+ rc = PTR_ERR(rdentry);
+ else {
+ cache_inode = rdentry->d_inode;
+ dput(rdentry);
+ }
+ } else {
+ cache_inode = cache_dentry->d_inode;
}
- if (cache_inode)
- SMFS_IGET(dir, cache_inode->i_ino, inode, rc, exit);
-
-
- //rdentry = d_splice_alias(inode, dentry);
- d_add(dentry, inode);
- //CDEBUG(D_INODE, "dir %p (inode %p)\n", dir, cache_dir);
+ if (cache_inode) {
+ inode = smfs_get_inode(dir->i_sb, cache_inode->i_ino, dir,0);
+ if (!inode)
+ rc = -ENOENT;
+ }
- SMFS_HOOK(dir, dentry, NULL, NULL, HOOK_LOOKUP, NULL, POST_HOOK, rc,
- exit);
-exit:
+ if (!rc)
+ d_add(dentry, inode);
+
+ SMFS_POST_HOOK(dir->i_sb, HOOK_LOOKUP, &msg, rc);
+exit:
post_smfs_dentry(cache_dentry);
post_smfs_dentry(cache_parent);
- return rdentry;
+ RETURN(ERR_PTR(rc));
}
static int smfs_link(struct dentry *old_dentry,
@@ -180,63 +188,65 @@ static int smfs_link(struct dentry *old_dentry,
struct dentry *cache_parent = NULL;
void *handle = NULL;
int rc = 0;
+ struct hook_msg msg = {
+ .dir = dir,
+ .dentry = old_dentry,
+ };
ENTRY;
cache_dir = I2CI(dir);
- if (!cache_dir || !cache_dir->i_op->link)
- GOTO(exit, rc = -ENOENT);
+ if (!cache_dir)
+ RETURN(-ENOENT);
old_inode = old_dentry->d_inode;
cache_old_inode = I2CI(old_inode);
if (!cache_old_inode)
- GOTO(exit, rc = -ENOENT);
+ RETURN(-ENOENT);
cache_parent = pre_smfs_dentry(NULL, cache_dir, dentry);
cache_dentry = pre_smfs_dentry(cache_parent, NULL, dentry);
- if (!cache_parent || !cache_dentry)
- GOTO(exit, rc = -ENOMEM);
-
- cache_old_dentry = pre_smfs_dentry(NULL, cache_old_inode,
- old_dentry);
- if (!cache_old_dentry)
- GOTO(exit, rc = -ENOMEM);
+ cache_old_dentry = pre_smfs_dentry(NULL, cache_old_inode, old_dentry);
+ if (!cache_old_dentry || !cache_dentry || !cache_parent) {
+ rc = -ENOMEM;
+ goto exit;
+ }
+ handle = smfs_trans_start(dir, FSFILT_OP_LINK, NULL);
+ if (IS_ERR(handle)) {
+ rc = -ENOSPC;
+ goto exit;
+ }
+
pre_smfs_inode(dir, cache_dir);
pre_smfs_inode(old_inode, cache_old_inode);
- handle = smfs_trans_start(dir, FSFILT_OP_LINK, NULL);
- if (IS_ERR(handle))
- GOTO(exit, rc = -ENOSPC);
-
//lock_kernel();
- SMFS_HOOK(dir, old_dentry, NULL, NULL, HOOK_LINK, handle,
- PRE_HOOK, rc, exit);
-
- rc = cache_dir->i_op->link(cache_old_dentry, cache_dir,
- cache_dentry);
- if (rc)
- GOTO(exit, rc);
+ SMFS_PRE_HOOK(dir->i_sb, HOOK_LINK, &msg);
- atomic_inc(&old_inode->i_count);
- d_instantiate(dentry, old_inode);
+ rc = cache_dir->i_op->link(cache_old_dentry, cache_dir, cache_dentry);
+ if (!rc) {
+ atomic_inc(&old_inode->i_count);
+ d_instantiate(dentry, old_inode);
+ }
+ SMFS_POST_HOOK(dir->i_sb, HOOK_LINK, &msg, rc);
+
post_smfs_inode(old_inode, cache_old_inode);
post_smfs_inode(dir, cache_dir);
- SMFS_HOOK(dir, old_dentry, dentry, NULL, HOOK_LINK, handle,
- POST_HOOK, rc, exit);
+ smfs_trans_commit(dir, handle, 0);
+
exit:
//unlock_kernel();
post_smfs_dentry(cache_dentry);
post_smfs_dentry(cache_parent);
post_smfs_dentry(cache_old_dentry);
- smfs_trans_commit(dir, handle, 0);
+
RETURN(rc);
}
-static int smfs_unlink(struct inode * dir,
- struct dentry *dentry)
+static int smfs_unlink(struct inode * dir, struct dentry *dentry)
{
struct inode *cache_dir = I2CI(dir);
struct inode *cache_inode = I2CI(dentry->d_inode);
@@ -244,7 +254,12 @@ static int smfs_unlink(struct inode * dir,
struct dentry *cache_parent;
void *handle = NULL;
int rc = 0;
- int mode = 0;
+ //int mode = 0;
+ struct hook_unlink_msg msg = {
+ .dir = dir,
+ .dentry = dentry,
+ .mode = 0
+ };
ENTRY;
@@ -253,33 +268,33 @@ static int smfs_unlink(struct inode * dir,
cache_parent = pre_smfs_dentry(NULL, cache_dir, dentry);
cache_dentry = pre_smfs_dentry(cache_parent, cache_inode, dentry);
-
- if (!cache_parent || !cache_dentry)
- GOTO(exit, rc = -ENOMEM);
+ if (!cache_dentry || !cache_parent) {
+ rc = -ENOMEM;
+ goto exit;
+ }
//lock_kernel();
+ handle = smfs_trans_start(dir, FSFILT_OP_UNLINK, NULL);
+ if (IS_ERR(handle)) {
+ rc = -ENOSPC;
+ goto exit;
+ }
+
pre_smfs_inode(dir, cache_dir);
pre_smfs_inode(dentry->d_inode, cache_inode);
- handle = smfs_trans_start(dir, FSFILT_OP_UNLINK, NULL);
- if (IS_ERR(handle))
- GOTO(exit, rc = -ENOSPC);
-
- SMFS_HOOK(dir, dentry, NULL, NULL, HOOK_UNLINK, handle, PRE_HOOK, rc,
- exit);
+ SMFS_PRE_HOOK(dir->i_sb, HOOK_UNLINK, &msg);
rc = cache_dir->i_op->unlink(cache_dir, cache_dentry);
- if (rc)
- GOTO(exit, rc);
-
+
+ SMFS_POST_HOOK(dir->i_sb, HOOK_UNLINK, &msg, rc);
+
post_smfs_inode(dentry->d_inode, cache_dentry->d_inode);
post_smfs_inode(dir, cache_dir);
//unlock_kernel();
- SMFS_HOOK(dir, dentry, &mode, NULL, HOOK_UNLINK, handle, POST_HOOK,
- rc, exit);
-exit:
smfs_trans_commit(dir, handle, 0);
+exit:
post_smfs_dentry(cache_dentry);
post_smfs_dentry(cache_parent);
RETURN(rc);
@@ -293,7 +308,13 @@ static int smfs_symlink(struct inode *dir, struct dentry *dentry,
struct dentry *cache_dentry;
struct dentry *cache_parent;
void *handle = NULL;
- int rc = 0, tgt_len;
+ int rc = 0;
+ struct hook_symlink_msg msg = {
+ .dir = dir,
+ .dentry = dentry,
+ .tgt_len = strlen(symname) + 1,
+ .symname = (char*)symname
+ };
ENTRY;
@@ -302,36 +323,39 @@ static int smfs_symlink(struct inode *dir, struct dentry *dentry,
cache_parent = pre_smfs_dentry(NULL, cache_dir, dentry);
cache_dentry = pre_smfs_dentry(cache_parent, NULL, dentry);
-
- if (!cache_parent || !cache_dentry)
- GOTO(exit, rc = -ENOMEM);
+ if (!cache_parent || !cache_dentry) {
+ rc = -ENOMEM;
+ goto exit;
+ }
- pre_smfs_inode(dir, cache_dir);
-
handle = smfs_trans_start(dir, FSFILT_OP_SYMLINK, NULL);
- if (IS_ERR(handle))
- GOTO(exit, rc = -ENOSPC);
+ if (IS_ERR(handle)) {
+ rc = -ENOSPC;
+ goto exit;
+ }
//lock_kernel();
- SMFS_HOOK(dir, dentry, NULL, NULL, HOOK_SYMLINK, handle, PRE_HOOK, rc,
- exit);
+ pre_smfs_inode(dir, cache_dir);
+
+ SMFS_PRE_HOOK(dir->i_sb, HOOK_SYMLINK, &msg);
rc = cache_dir->i_op->symlink(cache_dir, cache_dentry, symname);
- if (rc)
- GOTO(exit, rc);
+ if (!rc) {
+ inode = smfs_get_inode(dir->i_sb, cache_dentry->d_inode->i_ino,
+ dir, 0);
+ if (inode)
+ d_instantiate(dentry, inode);
+ else
+ rc = -ENOENT;
+ }
- SMFS_IGET(dir, cache_dentry->d_inode->i_ino, inode, rc, exit);
+ SMFS_POST_HOOK(dir->i_sb, HOOK_SYMLINK, &msg, rc);
- d_instantiate(dentry, inode);
post_smfs_inode(dir, cache_dir);
-
- tgt_len = strlen(symname) + 1;
- SMFS_HOOK(dir, dentry, (char *)symname, &tgt_len, HOOK_SYMLINK, handle,
- POST_HOOK, rc, exit);
-
+ smfs_trans_commit(dir, handle, 0);
+
exit:
//unlock_kernel();
- smfs_trans_commit(dir, handle, 0);
post_smfs_dentry(cache_dentry);
post_smfs_dentry(cache_parent);
RETURN(rc);
@@ -346,44 +370,48 @@ static int smfs_mkdir(struct inode *dir, struct dentry *dentry,
struct dentry *cache_parent;
void *handle = NULL;
int rc = 0;
+ struct hook_msg msg = {
+ .dir = dir,
+ .dentry = dentry,
+ };
ENTRY;
- if (!cache_dir || !cache_dir->i_op->mkdir)
+ if (!cache_dir)
RETURN(-ENOENT);
cache_parent = pre_smfs_dentry(NULL, cache_dir, dentry);
cache_dentry = pre_smfs_dentry(cache_parent, NULL, dentry);
- if (!cache_parent || !cache_dentry)
- GOTO(exit, rc = -ENOMEM);
-
- pre_smfs_inode(dir, cache_dir);
+ if (!cache_parent || !cache_dentry) {
+ rc = -ENOMEM;
+ goto exit;
+ }
handle = smfs_trans_start(dir, FSFILT_OP_MKDIR, NULL);
- if (IS_ERR(handle))
- GOTO(exit, rc = -ENOSPC);
-
- //lock_kernel();
+ if (IS_ERR(handle)) {
+ rc = -ENOSPC;
+ goto exit;
+ }
- SMFS_HOOK(dir, dentry, NULL, NULL, HOOK_MKDIR, handle, PRE_HOOK, rc,
- exit);
+ pre_smfs_inode(dir, cache_dir);
+ SMFS_PRE_HOOK(dir->i_sb, HOOK_MKDIR, &msg);
rc = cache_dir->i_op->mkdir(cache_dir, cache_dentry, mode);
+ if (!rc) {
+ inode = smfs_get_inode(dir->i_sb, cache_dentry->d_inode->i_ino,
+ dir, 0);
+ if (inode)
+ d_instantiate(dentry, inode);
+ else
+ rc = -ENOENT;
+ }
- if (rc)
- GOTO(exit, rc);
-
- SMFS_IGET(dir, cache_dentry->d_inode->i_ino, inode, rc, exit);
-
- d_instantiate(dentry, inode);
+ SMFS_POST_HOOK(dir->i_sb, HOOK_MKDIR, &msg, rc);
post_smfs_inode(dir, cache_dir);
+ smfs_trans_commit(dir, handle, 0);
- SMFS_HOOK(dir, dentry, NULL, NULL, HOOK_MKDIR, handle, POST_HOOK, rc,
- exit);
exit:
- //unlock_kernel();
- smfs_trans_commit(dir, handle, 0);
post_smfs_dentry(cache_dentry);
post_smfs_dentry(cache_parent);
RETURN(rc);
@@ -396,7 +424,12 @@ static int smfs_rmdir(struct inode *dir, struct dentry *dentry)
struct dentry *cache_dentry = NULL;
struct dentry *cache_parent = NULL;
void *handle = NULL;
- int rc = 0, mode = S_IFDIR;
+ int rc = 0;
+ struct hook_unlink_msg msg = {
+ .dir = dir,
+ .dentry = dentry,
+ .mode = S_IFDIR
+ };
ENTRY;
@@ -405,36 +438,32 @@ static int smfs_rmdir(struct inode *dir, struct dentry *dentry)
cache_parent = pre_smfs_dentry(NULL, cache_dir, dentry);
cache_dentry = pre_smfs_dentry(cache_parent, cache_inode, dentry);
+ if (!cache_parent || !cache_dentry) {
+ rc = -ENOMEM;
+ goto exit;
+ }
- if (!cache_parent || !cache_dentry)
- GOTO(exit, rc = -ENOMEM);
-
- pre_smfs_inode(dir, cache_dir);
- pre_smfs_inode(dentry->d_inode, cache_dentry->d_inode);
-
handle = smfs_trans_start(dir, FSFILT_OP_RMDIR, NULL);
if (IS_ERR(handle) ) {
- CERROR("smfs_do_mkdir: no space for transaction\n");
- GOTO(exit, rc = -ENOSPC);
+ rc = -ENOSPC;
+ goto exit;
}
- //lock_kernel();
-
- SMFS_HOOK(dir, dentry, NULL, NULL, HOOK_RMDIR, handle, PRE_HOOK, rc,
- exit);
+ pre_smfs_inode(dir, cache_dir);
+ pre_smfs_inode(dentry->d_inode, cache_dentry->d_inode);
+
+ SMFS_PRE_HOOK(dir->i_sb, HOOK_RMDIR, &msg);
rc = cache_dir->i_op->rmdir(cache_dir, cache_dentry);
- if (rc)
- GOTO(exit, rc);
+
+ SMFS_POST_HOOK(dir->i_sb, HOOK_RMDIR, &msg, rc);
post_smfs_inode(dir, cache_dir);
post_smfs_inode(dentry->d_inode, cache_dentry->d_inode);
- //unlock_kernel();
-
- SMFS_HOOK(dir, dentry, &mode, NULL, HOOK_RMDIR, handle, POST_HOOK,
- rc, exit);
-exit:
+
smfs_trans_commit(dir, handle, 0);
+
+exit:
post_smfs_dentry(cache_dentry);
post_smfs_dentry(cache_parent);
RETURN(rc);
@@ -454,7 +483,11 @@ static int smfs_mknod(struct inode *dir, struct dentry *dentry,
struct dentry *cache_parent = NULL;
void *handle = NULL;
int rc = 0;
-
+ struct hook_msg msg = {
+ .dir = dir,
+ .dentry = dentry,
+ };
+
ENTRY;
if (!cache_dir || !cache_dir->i_op->mknod)
@@ -462,40 +495,39 @@ static int smfs_mknod(struct inode *dir, struct dentry *dentry,
cache_parent = pre_smfs_dentry(NULL, cache_dir, dentry->d_parent);
cache_dentry = pre_smfs_dentry(cache_parent, NULL, dentry);
-
- if (!cache_parent || !cache_dentry)
- GOTO(exit, rc = -ENOMEM);
-
- pre_smfs_inode(dir, cache_dir);
- pre_smfs_inode(dentry->d_inode, cache_dentry->d_inode);
+ if (!cache_parent || !cache_dentry) {
+ rc = -ENOMEM;
+ goto exit;
+ }
handle = smfs_trans_start(dir, FSFILT_OP_MKNOD, NULL);
if (IS_ERR(handle)) {
- CERROR("smfs_do_mkdir: no space for transaction\n");
- GOTO(exit, rc = -ENOSPC);
+ rc = -ENOSPC;
+ goto exit;
}
+
+ pre_smfs_inode(dir, cache_dir);
+ pre_smfs_inode(dentry->d_inode, cache_dentry->d_inode);
- //lock_kernel();
- SMFS_HOOK(dir, dentry, NULL, NULL, HOOK_MKNOD, handle, PRE_HOOK, rc,
- exit);
+ SMFS_PRE_HOOK(dir->i_sb, HOOK_MKNOD, &msg);
rc = cache_dir->i_op->mknod(cache_dir, cache_dentry, mode, rdev);
- if (rc)
- GOTO(exit, rc);
-
- SMFS_IGET(dir, cache_dentry->d_inode->i_ino, inode, rc, exit);
-
- d_instantiate(dentry, inode);
+ if (!rc) {
+ inode = smfs_get_inode(dir->i_sb, cache_dentry->d_inode->i_ino,
+ dir, 0);
+ if (inode)
+ d_instantiate(dentry, inode);
+ else
+ rc = -ENOENT;
+ }
+ SMFS_POST_HOOK(dir->i_sb, HOOK_MKNOD, &msg, rc);
+
post_smfs_inode(dir, cache_dir);
post_smfs_inode(dentry->d_inode, cache_dentry->d_inode);
+ smfs_trans_commit(dir, handle, 0);
- SMFS_HOOK(dir, dentry, NULL, NULL, HOOK_MKNOD, handle, POST_HOOK, rc,
- exit);
-
exit:
- //unlock_kernel();
- smfs_trans_commit(dir, handle, 0);
post_smfs_dentry(cache_dentry);
post_smfs_dentry(cache_parent);
RETURN(rc);
@@ -507,67 +539,73 @@ static int smfs_rename(struct inode *old_dir, struct dentry *old_dentry,
struct inode *cache_old_dir = I2CI(old_dir);
struct inode *cache_new_dir = I2CI(new_dir);
struct inode *cache_old_inode = I2CI(old_dentry->d_inode);
-
- struct inode *cache_new_inode = new_dentry->d_inode ?
- I2CI(new_dentry->d_inode) : NULL;
-
+ struct inode *cache_new_inode = NULL;
struct dentry *cache_old_dentry = NULL;
struct dentry *cache_new_dentry = NULL;
struct dentry *cache_new_parent = NULL;
struct dentry *cache_old_parent = NULL;
void *handle = NULL;
int rc = 0;
+ struct hook_rename_msg msg = {
+ .dir = old_dir,
+ .dentry = old_dentry,
+ .new_dir = new_dir,
+ .new_dentry = new_dentry
+ };
ENTRY;
-
- if (!cache_old_dir || !cache_new_dir || !cache_old_inode
- || !cache_old_dir->i_op->rename)
+
+ if (!cache_old_dir || !cache_new_dir || !cache_old_inode)
RETURN(-ENOENT);
+ if (new_dentry->d_inode) {
+ cache_new_inode = I2CI(new_dentry->d_inode);
+ if (!cache_new_inode)
+ RETURN(-ENOENT);
+ }
+
cache_old_parent = pre_smfs_dentry(NULL, cache_old_dir, old_dentry);
-
cache_old_dentry = pre_smfs_dentry(cache_old_parent, cache_old_inode,
old_dentry);
+ if (!cache_old_parent || !cache_old_dentry) {
+ rc = -ENOMEM;
+ goto exit;
+ }
- if (!cache_old_parent || !cache_old_dentry)
- GOTO(exit, rc = -ENOMEM);
-
cache_new_parent = pre_smfs_dentry(NULL, cache_new_dir, new_dentry);
cache_new_dentry = pre_smfs_dentry(cache_new_parent, cache_new_inode,
new_dentry);
-
- if (!cache_new_parent || !cache_new_dentry)
- GOTO(exit, rc = -ENOMEM);
-
- pre_smfs_inode(old_dir, cache_old_dir);
- pre_smfs_inode(new_dir, cache_new_dir);
+ if (!cache_new_parent || !cache_new_dentry) {
+ rc = -ENOMEM;
+ goto exit;
+ }
handle = smfs_trans_start(old_dir, FSFILT_OP_RENAME, NULL);
if (IS_ERR(handle)) {
- CERROR("smfs_do_mkdir: no space for transaction\n");
- GOTO(exit, rc = -ENOSPC);
+ rc = -ENOSPC;
+ goto exit;
}
- //lock_kernel();
- SMFS_HOOK(old_dir, old_dentry, new_dir, new_dentry, HOOK_RENAME,
- handle, PRE_HOOK, rc, exit);
+ pre_smfs_inode(old_dir, cache_old_dir);
+ pre_smfs_inode(new_dir, cache_new_dir);
+ if (new_dentry->d_inode)
+ pre_smfs_inode(new_dentry->d_inode, cache_new_dentry->d_inode);
+
+ SMFS_PRE_HOOK(old_dir->i_sb, HOOK_RENAME, &msg);
rc = cache_old_dir->i_op->rename(cache_old_dir, cache_old_dentry,
cache_new_dir, cache_new_dentry);
+ SMFS_POST_HOOK(old_dir->i_sb, HOOK_RENAME, &msg, rc);
+
post_smfs_inode(old_dir, cache_old_dir);
post_smfs_inode(new_dir, cache_new_dir);
-
if (new_dentry->d_inode)
post_smfs_inode(new_dentry->d_inode, cache_new_dentry->d_inode);
- SMFS_HOOK(old_dir, old_dentry, new_dir, new_dentry, HOOK_RENAME, handle,
- POST_HOOK, rc, exit);
+ smfs_trans_commit(old_dir, handle, 0);
-
exit:
- //unlock_kernel();
- smfs_trans_commit(old_dir, handle, 0);
post_smfs_dentry(cache_old_dentry);
post_smfs_dentry(cache_old_parent);
post_smfs_dentry(cache_new_dentry);
@@ -636,6 +674,13 @@ static int smfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
struct inode *cache_inode = NULL;
struct smfs_file_info *sfi = NULL;
int rc = 0;
+ struct hook_readdir_msg msg = {
+ .dir = dentry->d_inode,
+ .dentry = dentry,
+ .filp = filp,
+ .dirent = dirent,
+ .filldir = filldir
+ };
ENTRY;
@@ -646,22 +691,17 @@ static int smfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
sfi = F2SMFI(filp);
if (sfi->magic != SMFS_FILE_MAGIC) BUG();
- SMFS_HOOK(dentry->d_inode, filp, dirent, filldir, HOOK_READDIR, NULL,
- PRE_HOOK, rc, exit);
+ SMFS_PRE_HOOK(dentry->d_inode->i_sb, HOOK_READDIR, &msg);
rc = cache_inode->i_fop->readdir(sfi->c_file, dirent, filldir);
- CDEBUG(D_INODE,"readdir rc=%u\n",rc);
- if (rc < 0)
- RETURN(rc);
-
+
+ SMFS_POST_HOOK(dentry->d_inode->i_sb, HOOK_READDIR, &msg, rc);
duplicate_file(filp, sfi->c_file);
- SMFS_HOOK(dentry->d_inode, filp, dirent, filldir, HOOK_READDIR, NULL,
- POST_HOOK, rc, exit);
-
exit:
if (rc > 0)
rc = 0;
+
RETURN(rc);
}
diff --git a/lustre/smfs/file.c b/lustre/smfs/file.c
index 9ccb62bb304150e402c68c353e048fd1cb271977..939cf7706b99096a246076b95e47ac6390ced9c7 100644
--- a/lustre/smfs/file.c
+++ b/lustre/smfs/file.c
@@ -48,13 +48,18 @@ static ssize_t smfs_write(struct file *filp, const char *buf, size_t count,
{
struct inode *cache_inode;
struct smfs_file_info *sfi;
- loff_t tmp_ppos;
loff_t *cache_ppos = NULL;
int rc = 0;
+ struct hook_write_msg msg = {
+ .inode = filp->f_dentry->d_inode,
+ .dentry = filp->f_dentry,
+ .count = count,
+ .pos = *ppos
+ };
+
ENTRY;
cache_inode = I2CI(filp->f_dentry->d_inode);
-
if (!cache_inode || !cache_inode->i_fop->write)
RETURN(-ENOENT);
@@ -64,34 +69,29 @@ static ssize_t smfs_write(struct file *filp, const char *buf, size_t count,
LBUG();
if (filp->f_flags & O_APPEND)
- tmp_ppos = filp->f_dentry->d_inode->i_size;
- else {
- tmp_ppos = *ppos;
- }
+ msg.pos = filp->f_dentry->d_inode->i_size;
- SMFS_HOOK(filp->f_dentry->d_inode, filp->f_dentry, &count, &tmp_ppos,
- HOOK_WRITE, NULL, PRE_HOOK, rc, exit);
+ pre_smfs_inode(filp->f_dentry->d_inode, cache_inode);
+
+ SMFS_PRE_HOOK(filp->f_dentry->d_sb, HOOK_WRITE, &msg);
if (ppos != &(filp->f_pos)) {
- cache_ppos = &tmp_ppos;
+ cache_ppos = &msg.pos;
} else {
cache_ppos = &sfi->c_file->f_pos;
}
*cache_ppos = *ppos;
- pre_smfs_inode(filp->f_dentry->d_inode, cache_inode);
-
rc = cache_inode->i_fop->write(sfi->c_file, buf, count,
cache_ppos);
- SMFS_HOOK(filp->f_dentry->d_inode, filp->f_dentry, ppos, &count,
- HOOK_WRITE, NULL, POST_HOOK, rc, exit);
+ SMFS_POST_HOOK(filp->f_dentry->d_sb, HOOK_WRITE, &msg, rc);
-exit:
post_smfs_inode(filp->f_dentry->d_inode, cache_inode);
*ppos = *cache_ppos;
duplicate_file(filp, sfi->c_file);
+
RETURN(rc);
}
@@ -229,20 +229,22 @@ static int smfs_init_cache_file(struct inode *inode, struct file *filp)
RETURN(-ENOMEM);
cache_filp = get_empty_filp();
- if (!cache_filp)
- GOTO(err_exit, rc = -ENOMEM);
+ if (!cache_filp) {
+ rc = -ENOMEM;
+ goto err_exit;
+ }
sfi->magic = SMFS_FILE_MAGIC;
cache_dentry = pre_smfs_dentry(NULL, I2CI(inode), filp->f_dentry);
- if (!cache_dentry)
- GOTO(err_exit, rc = -ENOMEM);
+ if (!cache_dentry) {
+ rc = -ENOMEM;
+ goto err_exit;
+ }
cache_filp->f_vfsmnt = filp->f_vfsmnt;
-
cache_filp->f_dentry = cache_dentry;
duplicate_file(cache_filp, filp);
-
sfi->c_file = cache_filp;
if (filp->private_data != NULL)
@@ -250,7 +252,7 @@ static int smfs_init_cache_file(struct inode *inode, struct file *filp)
filp->private_data = sfi;
- RETURN(rc);
+ RETURN(0);
err_exit:
if (sfi)
OBD_FREE(sfi, sizeof(struct smfs_file_info));
@@ -262,11 +264,12 @@ err_exit:
static int smfs_cleanup_cache_file(struct file *filp)
{
struct smfs_file_info *sfi = NULL;
- int rc = 0;
+
ENTRY;
if (!filp)
- RETURN(rc);
+ RETURN(0);
+
sfi = F2SMFI(filp);
post_smfs_dentry(sfi->c_file->f_dentry);
@@ -277,13 +280,14 @@ static int smfs_cleanup_cache_file(struct file *filp)
filp->private_data = NULL;
- RETURN(rc);
+ RETURN(0);
}
int smfs_open(struct inode *inode, struct file *filp)
{
struct inode *cache_inode = NULL;
int rc = 0;
+
ENTRY;
cache_inode = I2CI(inode);
@@ -297,6 +301,7 @@ int smfs_open(struct inode *inode, struct file *filp)
rc = cache_inode->i_fop->open(cache_inode, F2CF(filp));
duplicate_file(filp, F2CF(filp));
}
+
RETURN(rc);
}
@@ -397,6 +402,12 @@ int smfs_setattr(struct dentry *dentry, struct iattr *attr)
struct dentry *cache_dentry;
void *handle = NULL;
int rc = 0;
+ struct hook_setattr_msg msg = {
+ .inode = dentry->d_inode,
+ .dentry = dentry,
+ .attr = attr
+ };
+
cache_inode = I2CI(dentry->d_inode);
if (!cache_inode || !cache_inode->i_op->setattr)
@@ -408,26 +419,22 @@ int smfs_setattr(struct dentry *dentry, struct iattr *attr)
handle = smfs_trans_start(dentry->d_inode, FSFILT_OP_SETATTR, NULL);
if (IS_ERR(handle) ) {
- CERROR("smfs_do_mkdir: no space for transaction\n");
- GOTO(exit, rc = -ENOSPC);
+ rc = -ENOSPC;
+ goto exit;
}
pre_smfs_inode(dentry->d_inode, cache_inode);
- SMFS_HOOK(dentry->d_inode, dentry, attr, NULL, HOOK_SETATTR, NULL,
- PRE_HOOK, rc, exit);
+ SMFS_PRE_HOOK(dentry->d_sb, HOOK_SETATTR, &msg);
rc = cache_inode->i_op->setattr(cache_dentry, attr);
- post_smfs_dentry(cache_dentry);
-
- SMFS_HOOK(dentry->d_inode, dentry, attr, NULL, HOOK_SETATTR, NULL,
- POST_HOOK, rc, exit);
-
+ SMFS_POST_HOOK(dentry->d_sb, HOOK_SETATTR, &msg, rc);
+
post_smfs_inode(dentry->d_inode, cache_inode);
-
-exit:
smfs_trans_commit(dentry->d_inode, handle, 0);
+exit:
+ post_smfs_dentry(cache_dentry);
RETURN(rc);
}
@@ -539,3 +546,4 @@ struct inode_operations smfs_file_iops = {
.listxattr = smfs_listxattr, /* BKL held */
.removexattr = smfs_removexattr, /* BKL held */
};
+
diff --git a/lustre/smfs/inode.c b/lustre/smfs/inode.c
index 71474ddb1f7104c2a1d407a3544365fc7d678305..0243f2c944e89578860c6b4f7ffefc1c5fa16098 100644
--- a/lustre/smfs/inode.c
+++ b/lustre/smfs/inode.c
@@ -41,14 +41,11 @@ static void smfs_init_inode_info(struct inode *inode, void *opaque)
{
if (!I2SMI(inode)) {
struct inode *cache_inode = NULL;
- struct smfs_iget_args *sargs;
+ struct smfs_iget_args *sargs = opaque;
unsigned long ino;
- sargs = (struct smfs_iget_args *)opaque;
-
/* getting backing fs inode. */
ino = sargs ? sargs->s_ino : inode->i_ino;
- //ino = sargs->s_ino;
cache_inode = iget(S2CSB(inode->i_sb), ino);
OBD_ALLOC(inode->u.generic_ip,
@@ -76,7 +73,7 @@ static void smfs_clear_inode_info(struct inode *inode)
if (I2SMI(inode)) {
struct inode *cache_inode = I2CI(inode);
- CDEBUG(D_INODE, "Clear_info: cache_inode %lu\n", cache_inode->i_ino);
+ //CDEBUG(D_INODE, "Clear_info: cache_inode %lu\n", cache_inode->i_ino);
LASSERTF(((atomic_read(&cache_inode->i_count) == 1) ||
cache_inode == cache_inode->i_sb->s_root->d_inode),
@@ -133,11 +130,10 @@ static int smfs_test_inode(struct inode *inode, void *opaque)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
int smfs_set_inode(struct inode *inode, void *opaque)
{
- //smfs_read_inode2(inode, opaque);
return 0;
}
-struct inode *smfs_iget(struct super_block *sb, ino_t hash,
+static struct inode *smfs_iget(struct super_block *sb, ino_t hash,
struct smfs_iget_args *sargs)
{
struct inode *inode;
@@ -193,29 +189,23 @@ struct inode *smfs_get_inode(struct super_block *sb, ino_t hash,
RETURN(inode);
}
-static void smfs_delete_inode(struct inode *inode)
-{
- ENTRY;
- clear_inode(inode);
- EXIT;
-}
-
static void smfs_write_inode(struct inode *inode, int wait)
{
struct inode *cache_inode;
+
ENTRY;
cache_inode = I2CI(inode);
- LASSERT(cache_inode != NULL);
+ LASSERT(cache_inode);
CDEBUG(D_INODE,"Write inode %lu\n",inode->i_ino);
pre_smfs_inode(inode, cache_inode);
- if (cache_inode->i_sb->s_op->write_inode)
- cache_inode->i_sb->s_op->write_inode(cache_inode, wait);
+ cache_inode->i_sb->s_op->write_inode(cache_inode, wait);
post_smfs_inode(inode, cache_inode);
+
EXIT;
}
@@ -225,45 +215,20 @@ static void smfs_dirty_inode(struct inode *inode)
ENTRY;
cache_inode = I2CI(inode);
- if (!cache_inode || !S2CSB(inode->i_sb)) {
- EXIT;
- return;
- }
-
+ LASSERT(cache_inode);
+
pre_smfs_inode(inode, cache_inode);
- if (S2CSB(inode->i_sb)->s_op->dirty_inode)
- S2CSB(inode->i_sb)->s_op->dirty_inode(cache_inode);
+ S2CSB(inode->i_sb)->s_op->dirty_inode(cache_inode);
post_smfs_inode(inode, cache_inode);
EXIT;
}
-static void smfs_put_inode(struct inode *inode)
+
+static void smfs_delete_inode(struct inode *inode)
{
-#if 0
- struct inode *cache_inode;
ENTRY;
-
- cache_inode = I2CI(inode);
- LASSERT(cache_inode != NULL);
-
- if (atomic_read(&cache_inode->i_count) > 1)
- iput(cache_inode);
-
- /*
- * check if we have to release backend inode. As iput() calls fs
- * specific ->put_inode() first and than decrements inode rerfcount, we
- * should check here ->i_count for 1, not for 0.
-
- * In principle we could rely on ->clear_inode(), but it will be called
- * later, and thus we will have iputing of @inode and @cache_inode in
- * different control paths, this is why we do it here. --umka
- */
- if (atomic_read(&inode->i_count) == 1 &&
- cache_inode->i_sb->s_root->d_inode != cache_inode)
- smfs_clear_inode_info(inode);
-
+ clear_inode(inode);
EXIT;
-#endif
}
static void smfs_clear_inode(struct inode *inode)
@@ -277,48 +242,33 @@ static void smfs_write_super(struct super_block *sb)
{
ENTRY;
- if (!S2CSB(sb)) {
- EXIT;
- return;
- }
+ LASSERT(S2CSB(sb));
- if (S2CSB(sb)->s_op->write_super)
- S2CSB(sb)->s_op->write_super(S2CSB(sb));
+ S2CSB(sb)->s_op->write_super(S2CSB(sb));
duplicate_sb(sb, S2CSB(sb));
EXIT;
}
static void smfs_write_super_lockfs(struct super_block *sb)
{
- struct super_block *cache_sb;
+ struct super_block * cache_sb = S2CSB(sb);
ENTRY;
- cache_sb = S2CSB(sb);
- if (!cache_sb) {
- EXIT;
- return;
- }
-
- if (cache_sb->s_op->write_super_lockfs)
- cache_sb->s_op->write_super_lockfs(cache_sb);
+ LASSERT(cache_sb);
+ cache_sb->s_op->write_super_lockfs(cache_sb);
duplicate_sb(sb, cache_sb);
EXIT;
}
static void smfs_unlockfs(struct super_block *sb)
{
- struct super_block *cache_sb;
+ struct super_block * cache_sb = S2CSB(sb);
ENTRY;
- cache_sb = S2CSB(sb);
- if (!cache_sb) {
- EXIT;
- return;
- }
-
- if (cache_sb->s_op->unlockfs)
- cache_sb->s_op->unlockfs(cache_sb);
+ LASSERT(cache_sb);
+
+ cache_sb->s_op->unlockfs(cache_sb);
duplicate_sb(sb, cache_sb);
EXIT;
@@ -330,35 +280,29 @@ static int smfs_statfs(struct super_block *sb, struct statfs *buf)
static int smfs_statfs(struct super_block *sb, struct kstatfs *buf)
#endif
{
- struct super_block *cache_sb;
+ struct super_block *cache_sb = S2CSB(sb);
int rc = 0;
ENTRY;
- cache_sb = S2CSB(sb);
- if (!cache_sb)
- RETURN(-EINVAL);
-
- if (cache_sb->s_op->statfs)
- rc = cache_sb->s_op->statfs(cache_sb, buf);
+ LASSERT(cache_sb);
+ rc = cache_sb->s_op->statfs(cache_sb, buf);
duplicate_sb(sb, cache_sb);
+
RETURN(rc);
}
+
static int smfs_remount(struct super_block *sb, int *flags, char *data)
{
- struct super_block *cache_sb;
+ struct super_block *cache_sb = S2CSB(sb);
int rc = 0;
ENTRY;
- cache_sb = S2CSB(sb);
-
- if (!cache_sb)
- RETURN(-EINVAL);
-
- if (cache_sb->s_op->remount_fs)
- rc = cache_sb->s_op->remount_fs(cache_sb, flags, data);
+ LASSERT(cache_sb);
+ rc = cache_sb->s_op->remount_fs(cache_sb, flags, data);
duplicate_sb(sb, cache_sb);
+
RETURN(rc);
}
@@ -371,7 +315,6 @@ struct super_operations smfs_super_ops = {
.delete_inode = smfs_delete_inode,
.write_inode = smfs_write_inode,
.dirty_inode = smfs_dirty_inode, /* BKL not held. */
- .put_inode = smfs_put_inode, /* BKL not held. */
.write_super = smfs_write_super, /* BKL held */
.write_super_lockfs = smfs_write_super_lockfs, /* BKL not held. */
.unlockfs = smfs_unlockfs, /* BKL not held. */
@@ -379,8 +322,4 @@ struct super_operations smfs_super_ops = {
.remount_fs = smfs_remount, /* BKL held */
};
-int is_smfs_sb(struct super_block *sb)
-{
- return (sb->s_op->put_super == smfs_super_ops.put_super);
-}
-EXPORT_SYMBOL(is_smfs_sb);
+
diff --git a/lustre/smfs/smfs_api.h b/lustre/smfs/smfs_api.h
index ec738113cbed5654fe03470a8143f1e011b09d48..379af9859dec339c918c5812e80e2ba69cd14e50 100644
--- a/lustre/smfs/smfs_api.h
+++ b/lustre/smfs/smfs_api.h
@@ -1,12 +1,15 @@
/* SMFS plugin stuff */
-#define SMFS_PLG_DUMMY 0
-#define SMFS_PLG_KML 1
-#define SMFS_PLG_LRU 2
-#define SMFS_PLG_COW 3
-#define SMFS_PLG_MAX 4
+#define SMFS_PLG_DUMMY 0x0001L
+#define SMFS_PLG_KML 0x0002L
+#define SMFS_PLG_LRU 0x0004L
+#define SMFS_PLG_COW 0x0008L
-typedef int (*smfs_plg_hook)(int hook_code, void *arg, void * priv);
-typedef int (*smfs_plg_func) (int help_code, void *arg, void * priv);
+#define SMFS_SET_PLG(flags, mask) (flags |= mask)
+#define SMFS_IS_PLG(flags, mask) (flags & mask)
+#define SMFS_CLEAR_PLG(flags, mask) (flags &= ~mask)
+
+typedef int (*smfs_plg_hook)(int hook_code, void *arg, int, void * priv);
+typedef int (*smfs_plg_func)(int help_code, void *arg, void * priv);
struct smfs_plugin {
struct list_head plg_list;
@@ -32,53 +35,79 @@ struct smfs_plugin {
#define HOOK_READDIR 12
#define HOOK_MAX 13
-struct hook_data {
+struct hook_msg {
+ struct inode * dir;
+ struct dentry * dentry;
+};
+
+struct hook_unlink_msg {
struct inode * dir;
struct dentry * dentry;
- int ret_code;
+ int mode;
};
-struct hook_data_rename {
- struct hook_data data;
+struct hook_symlink_msg {
+ struct inode * dir;
+ struct dentry * dentry;
+ int tgt_len;
+ char * symname;
+};
+
+struct hook_rename_msg {
+ struct inode * dir;
+ struct dentry * dentry;
struct inode * new_dir;
- struct inode * new_dentry;
+ struct dentry * new_dentry;
};
-struct hook_data_readdir {
- struct hook_data data;
+struct hook_readdir_msg {
+ struct inode * dir;
+ struct dentry * dentry;
struct file * filp;
void * dirent;
filldir_t filldir;
};
-struct hook_data_setattr {
- struct hook_data data;
- struct iattr *attr;
+struct hook_write_msg {
+ struct inode * inode;
+ struct dentry * dentry;
+ size_t count;
+ loff_t pos;
};
+struct hook_setattr_msg {
+ struct inode * inode;
+ struct dentry * dentry;
+ struct iattr *attr;
+};
+#define SMFS_HOOK(sb, op, msg, a,b,c,d,e,f) \
+do { \
+} while(0)
-#define SMFS_PRE_HOOK (op, data) \
-do { \
- struct list_head *hlist = &smfs_plg_list; \
- struct smfs_plugin *plugin; \
- \
- list_for_each_entry(plugin, hlist, plg_list) { \
- if (plugin->plg_pre_op) \
- plugin->plg_pre_op(op, data, \
- plg->plg_private); \
- } \
+#define SMFS_PRE_HOOK(sb, op, msg) \
+do { \
+ struct smfs_super_info *smb = S2SMI(sb); \
+ struct list_head *hlist = &smb->smsi_plg_list; \
+ struct smfs_plugin *plg; \
+ \
+ list_for_each_entry(plg, hlist, plg_list) { \
+ if (plg->plg_pre_op) \
+ plg->plg_pre_op(op, msg, 0, \
+ plg->plg_private); \
+ } \
} while(0)
-#define SMFS_POST_HOOK (op, data, rc) \
-do { \
- struct list_head *hlist = &smfs_plg_list; \
- struct smfs_plugin *plugin; \
- \
- list_for_each_entry(plugin, hlist, plg_list) { \
- if (plugin->plg_post_op) \
- plugin->plg_post_op(op, data, \
- plg->plg_private); \
- } \
+#define SMFS_POST_HOOK(sb, op, msg, rc) \
+do { \
+ struct smfs_super_info *smb = S2SMI(sb); \
+ struct list_head *hlist = &smb->smsi_plg_list; \
+ struct smfs_plugin *plg; \
+ \
+ list_for_each_entry(plg, hlist, plg_list) { \
+ if (plg->plg_post_op) \
+ plg->plg_post_op(op, msg, rc, \
+ plg->plg_private); \
+ } \
} while(0)
#define PLG_EXIT 0
@@ -87,22 +116,25 @@ do { \
#define PLG_SET_INODE 3
#define PLG_HELPER_MAX 4
-#define SMFS_PLG_HELP (op, data) \
-do { \
- struct list_head *hlist = &smfs_plg_list; \
- struct smfs_plugin *plugin; \
- \
- list_for_each_entry(plugin, hlist, plg_list) { \
- if (plugin->plg_helper) \
- plugin->plg_helper(op, data, \
- plg->plg_private); \
- } \
+#define SMFS_PLG_HELP(sb, op, data) \
+do { \
+ struct list_head *hlist = &S2SMI(sb)->smsi_plg_list; \
+ struct smfs_plugin *plugin, *tmp; \
+ \
+ list_for_each_entry_safe(plugin, tmp, hlist, plg_list) { \
+ if (plugin->plg_helper) \
+ plugin->plg_helper(op, data, \
+ plugin->plg_private); \
+ } \
} while(0)
-int smfs_register_plugin(struct smfs_plugin *);
-void * smfs_deregister_plugin(int);
-
+int smfs_register_plugin(struct super_block *, struct smfs_plugin *);
+void * smfs_deregister_plugin(struct super_block *, int);
+int smfs_init_dummy(struct super_block *);
+int smfs_init_kml(struct super_block *);
+int smfs_init_lru(struct super_block *);
+int smfs_init_cow(struct super_block *);
diff --git a/lustre/smfs/smfs_internal.h b/lustre/smfs/smfs_internal.h
index 4eb565c3def59012dc343bf4af4d5bc20b4631fd..f54d822114b0ff5b89e41432cafe045265cce54c 100644
--- a/lustre/smfs/smfs_internal.h
+++ b/lustre/smfs/smfs_internal.h
@@ -69,10 +69,6 @@ do{ \
extern int init_smfs_proc_sys(void);
-/*options.c*/
-extern int get_opt(struct option **option, char **pos);
-extern void cleanup_option(void);
-extern int init_option(char *data);
/*cache.c*/
extern void sm_set_inode_ops(struct inode *cache_inode, struct inode *inode);
extern void sm_set_sb_ops(struct super_block *cache_sb, struct super_block *sb);
@@ -81,10 +77,7 @@ extern void cleanup_smfs_cache(void);
extern void sm_set_journal_ops(struct super_block *sb, char *cache_type);
extern int smfs_init_sm_ops(struct smfs_super_info *smb);
extern void smfs_cleanup_sm_ops(struct smfs_super_info *smb);
-static inline struct super_operations *cache_sops(struct smfs_super_info *smb)
-{
- return &smb->sm_ops->sm_sb_ops;
-}
+
static inline struct inode_operations *cache_diops(struct smfs_super_info *smb)
{
return &smb->sm_ops->sm_dir_iops;
@@ -279,42 +272,6 @@ static inline int get_active_entry(struct inode *dir, __u64 *active_entry)
RETURN(rc);
}
-#define PRE_HOOK 0
-#define POST_HOOK 1
-
-#define SMFS_HOOK(inode, dentry, data1, data2, op, handle, flag, rc, label) \
-do { \
- LASSERT(inode->i_sb); \
- if (!rc) { \
- struct smfs_super_info *smb = S2SMI(inode->i_sb); \
- struct list_head *hlist = &smb->smsi_hook_list; \
- struct list_head *p; \
- \
- list_for_each(p, hlist) { \
- struct smfs_hook_ops *hops; \
- \
- hops = list_entry(p, typeof(*hops), smh_list); \
- if (flag == PRE_HOOK && hops->smh_pre_op) \
- rc = hops->smh_pre_op(inode, dentry, data1, \
- data2, op, handle); \
- else if (flag == POST_HOOK && hops->smh_post_op) \
- rc = hops->smh_post_op(inode, dentry, data1, \
- data2, op, handle); \
- if (rc) \
- break; \
- } \
- } \
- if (rc) \
- GOTO(label, rc); \
-} while(0) \
-
-#define SMFS_IGET(dir, hash, inode, rc, label) \
-do { \
- inode = smfs_get_inode(dir->i_sb, hash, dir, 0); \
- if (!inode) \
- GOTO(label, rc = -ENOENT); \
-} while(0)
-
#if CONFIG_SNAPFS
int smfs_cow_init(struct super_block *sb);
int smfs_cow_cleanup(struct smfs_super_info *smb);
diff --git a/lustre/smfs/smfs_lib.c b/lustre/smfs/smfs_lib.c
index 7c824fc00980ec2882504843c67e8fc314f518da..95c5fd48dcd97be743160ee2f7885090fcfaddfd 100644
--- a/lustre/smfs/smfs_lib.c
+++ b/lustre/smfs/smfs_lib.c
@@ -128,12 +128,6 @@ err_out:
static int smfs_umount_cache(struct smfs_super_info *smb)
{
- //struct dentry *root = smb->smsi_sb->s_root;
-
- //dput(root);
- //if (atomic_read(&root->d_inode->i_count) == 0)
- // igrab(root->d_inode);
-
mntput(smb->smsi_mnt);
smfs_cleanup_sm_ops(smb);
smfs_cleanup_fsfilt_ops(smb);
@@ -151,7 +145,7 @@ static int smfs_init_hook_ops(struct smfs_super_info *smb)
{
ENTRY;
INIT_LIST_HEAD(&smb->smsi_hook_list);
- INIT_LIST_HEAD(&smfs_plg_list);
+ INIT_LIST_HEAD(&smb->smsi_plg_list);
RETURN(0);
}
@@ -422,10 +416,10 @@ void smfs_trans_commit(struct inode *inode, void *handle, int force_sync)
}
-int smfs_register_plugin(struct smfs_plugin * new_plugin)
+int smfs_register_plugin(struct super_block * sb, struct smfs_plugin * new_plugin)
{
struct smfs_plugin * plg = NULL;
- struct list_head * plist = &smfs_plg_list;
+ struct list_head * plist = &S2SMI(sb)->smsi_plg_list;
ENTRY;
@@ -448,10 +442,10 @@ int smfs_register_plugin(struct smfs_plugin * new_plugin)
RETURN(0);
}
-void * smfs_deregister_plugin(int type)
+void * smfs_deregister_plugin(struct super_block * sb, int type)
{
struct smfs_plugin * plg = NULL;
- struct list_head * plist = &smfs_plg_list;
+ struct list_head * plist = &S2SMI(sb)->smsi_plg_list;
void * priv = NULL;
ENTRY;