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)
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)
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;
-}
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);
}
#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))
#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,
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);
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;
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);
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;
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);
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);
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;
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);
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)
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);
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);
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;
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);
}
{
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,
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),
#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;
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;
}
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)
{
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;
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);
}
.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. */
.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);
+
/* 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;
#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
#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 *);
git://git.whamcloud.com / fs / lustre-release.git / commitdiff