r=alex

- replace iget() in smfs_init_inode_info() with igrab()

diff --git a/lustre/smfs/cache.c b/lustre/smfs/cache.c
index ff10281..7275899 100644 (file)
--- a/lustre/smfs/cache.c
+++ b/lustre/smfs/cache.c
@@ -56,204 +56,173 @@ void smfs_cleanup_sm_ops(struct smfs_super_info *smb)
 }
 
 static void setup_iops(struct inode *cache_inode,
-                       struct inode_operations *iops,
-                       struct inode_operations *cache_iops)
+                       struct inode_operations *smfs_iops,
+                       struct inode_operations *iops)
 {
 
-        if (cache_inode->i_op && cache_iops && iops) {
-                if (cache_inode->i_op->create)
-                        iops->create = cache_iops->create;
-                if (cache_inode->i_op->lookup)
-                        iops->lookup = cache_iops->lookup;
-                if (cache_inode->i_op->link)
-                        iops->link = cache_iops->link;
-                if (cache_inode->i_op->unlink)
-                        iops->unlink = cache_iops->unlink;
-                if (cache_inode->i_op->symlink)
-                        iops->symlink = cache_iops->symlink;
-                if (cache_inode->i_op->mkdir)
-                        iops->mkdir = cache_iops->mkdir;
-                if (cache_inode->i_op->rmdir)
-                        iops->rmdir = cache_iops->rmdir;
-                if (cache_inode->i_op->mknod)
-                        iops->mknod = cache_iops->mknod;
-                if (cache_inode->i_op->rename)
-                        iops->rename = cache_iops->rename;
-                if (cache_inode->i_op->readlink)
-                        iops->readlink = cache_iops->readlink;
-                if (cache_inode->i_op->follow_link)
-                        iops->follow_link = cache_iops->follow_link;
-                if (cache_inode->i_op->truncate)
-                        iops->truncate = cache_iops->truncate;
-                if (cache_inode->i_op->permission)
-                        iops->permission = cache_iops->permission;
+        LASSERT(cache_inode->i_op && smfs_iops && iops);
+        
+        if (cache_inode->i_op->create)
+                iops->create = smfs_iops->create;
+        if (cache_inode->i_op->lookup)
+                iops->lookup = smfs_iops->lookup;
+        if (cache_inode->i_op->link)
+                iops->link = smfs_iops->link;
+        if (cache_inode->i_op->unlink)
+                iops->unlink = smfs_iops->unlink;
+        if (cache_inode->i_op->symlink)
+                iops->symlink = smfs_iops->symlink;
+        if (cache_inode->i_op->mkdir)
+                iops->mkdir = smfs_iops->mkdir;
+        if (cache_inode->i_op->rmdir)
+                iops->rmdir = smfs_iops->rmdir;
+        if (cache_inode->i_op->mknod)
+                iops->mknod = smfs_iops->mknod;
+        if (cache_inode->i_op->rename)
+                iops->rename = smfs_iops->rename;
+        if (cache_inode->i_op->readlink)
+                iops->readlink = smfs_iops->readlink;
+        if (cache_inode->i_op->follow_link)
+                iops->follow_link = smfs_iops->follow_link;
+        if (cache_inode->i_op->truncate)
+                iops->truncate = smfs_iops->truncate;
+        if (cache_inode->i_op->permission)
+                iops->permission = smfs_iops->permission;
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
-                if (cache_inode->i_op->revalidate)
-                        iops->revalidate = cache_iops->revalidate;
+        if (cache_inode->i_op->revalidate)
+                iops->revalidate = smfs_iops->revalidate;
 #endif
-                if (cache_inode->i_op->setattr)
-                        iops->setattr = cache_iops->setattr;
-                if (cache_inode->i_op->getattr)
-                        iops->getattr = cache_iops->getattr;
-                if (cache_inode->i_op->setxattr)
-                        iops->setxattr = cache_iops->setxattr;
-                if (cache_inode->i_op->getxattr)
-                        iops->getxattr = cache_iops->getxattr;
-                if (cache_inode->i_op->listxattr)
-                        iops->listxattr = cache_iops->listxattr;
-                if (cache_inode->i_op->removexattr)
-                        iops->removexattr = cache_iops->removexattr;
+        if (cache_inode->i_op->setattr)
+                iops->setattr = smfs_iops->setattr;
+        if (cache_inode->i_op->getattr)
+                iops->getattr = smfs_iops->getattr;
+        if (cache_inode->i_op->setxattr)
+                iops->setxattr = smfs_iops->setxattr;
+        if (cache_inode->i_op->getxattr)
+                iops->getxattr = smfs_iops->getxattr;
+        if (cache_inode->i_op->listxattr)
+                iops->listxattr = smfs_iops->listxattr;
+        if (cache_inode->i_op->removexattr)
+                iops->removexattr = smfs_iops->removexattr;
 #if HAVE_LOOKUP_RAW
-                if (cache_inode->i_op->lookup_raw)
-                        iops->lookup_raw = cache_iops->lookup_raw;
+        if (cache_inode->i_op->lookup_raw)
+                iops->lookup_raw = smfs_iops->lookup_raw;
 #endif
-        }
+
 }
 
 static void setup_fops(struct inode *cache_inode,
-                       struct file_operations *fops,
-                       struct file_operations *cache_fops)
+                       struct file_operations *smfs_fops,
+                       struct file_operations *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->flush)
-                        fops->flush = cache_fops->flush;
-                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;
-
-                /* for dir file we also need replace the open and release method,
-                 * because we need initialize the cache file structs. */
-                fops->open = cache_fops->open;
-                fops->release = cache_fops->release;
-        }
+        LASSERT(cache_inode->i_fop && smfs_fops && fops);
+        
+        if (cache_inode->i_fop->llseek)
+                fops->llseek = smfs_fops->llseek;
+        if (cache_inode->i_fop->read)
+                fops->read = smfs_fops->read;
+        if (cache_inode->i_fop->write)
+                fops->write = smfs_fops->write;
+        if (cache_inode->i_fop->readdir)
+                fops->readdir = smfs_fops->readdir;
+        if (cache_inode->i_fop->poll)
+                fops->poll = smfs_fops->poll;
+        if (cache_inode->i_fop->ioctl)
+                fops->ioctl = smfs_fops->ioctl;
+        if (cache_inode->i_fop->mmap)
+                fops->mmap = smfs_fops->mmap;
+        if (cache_inode->i_fop->flush)
+                fops->flush = smfs_fops->flush;
+        if (cache_inode->i_fop->fsync)
+                fops->fsync = smfs_fops->fsync;
+        if (cache_inode->i_fop->fasync)
+                fops->fasync = smfs_fops->fasync;
+        if (cache_inode->i_fop->lock)
+                fops->lock = smfs_fops->lock;
+        if (cache_inode->i_fop->readv)
+                fops->readv = smfs_fops->readv;
+        if (cache_inode->i_fop->writev)
+                fops->writev = smfs_fops->writev;
+        if (cache_inode->i_fop->sendpage)
+                fops->sendpage = smfs_fops->sendpage;
+        if (cache_inode->i_fop->get_unmapped_area)
+                fops->get_unmapped_area = smfs_fops->get_unmapped_area;
+                
+        /* for dir file we also need replace the open and release method,
+         * because we need initialize the cache file structs. */
+        fops->open = smfs_fops->open;
+        fops->release = smfs_fops->release;
 }
 
-static void setup_sm_file_ops(struct inode *cache_inode, struct inode *inode,
-                              struct inode_operations *cache_iops,
-                              struct file_operations *cache_fops)
+static void setup_sm_file_ops(struct inode *inode)
 {
-        struct smfs_super_info *smb;
-        struct inode_operations *iops;
-        struct file_operations *fops;
-
-        smb = S2SMI(inode->i_sb);
-
-        if (smb->smsi_ops_check & FILE_OPS_CHECK)
-                return;
-
-        iops = cache_fiops(smb);
-        fops = cache_ffops(smb);
-
-        setup_iops(cache_inode, iops, cache_iops);
-        setup_fops(cache_inode, fops, cache_fops);
+        struct smfs_super_info *smb = S2SMI(inode->i_sb);
+        struct inode *cache_inode = I2CI(inode);
+        
+        setup_iops(cache_inode, &smfs_file_iops, &smb->sm_ops->sm_file_iops);
+        setup_fops(cache_inode, &smfs_file_fops, &smb->sm_ops->sm_file_fops);
 
         lock_kernel();
         smb->smsi_ops_check |= FILE_OPS_CHECK;
         unlock_kernel();
 }
 
-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)
+static void setup_sm_dir_ops(struct inode *inode)
 {
-        struct smfs_super_info *smb;
-        struct inode_operations *iops;
-        struct file_operations *fops;
-
-        smb = S2SMI(inode->i_sb);
-
-        if (smb->smsi_ops_check & DIR_OPS_CHECK)
-                return;
-
-        iops = cache_diops(smb);
-        fops = cache_dfops(smb);
-
-        setup_iops(cache_inode, iops, cache_dir_iops);
-        setup_fops(cache_inode, fops, cache_dir_fops);
+        struct smfs_super_info *smb = S2SMI(inode->i_sb);
+        struct inode *cache_inode = I2CI(inode);
+        
+        setup_iops(cache_inode, &smfs_dir_iops, &smb->sm_ops->sm_dir_iops);
+        setup_fops(cache_inode, &smfs_dir_fops, &smb->sm_ops->sm_dir_fops);
 
         lock_kernel();
         smb->smsi_ops_check |= DIR_OPS_CHECK;
         unlock_kernel();
 }
 
-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)
+static void setup_sm_symlink_ops(struct inode *inode)
 {
-        struct smfs_super_info *smb;
-        struct inode_operations *iops;
-        struct file_operations *fops;
-
-        smb = S2SMI(inode->i_sb);
-
-        if (smb->smsi_ops_check & SYMLINK_OPS_CHECK)
-                return;
-
-        iops = cache_siops(smb);
-        fops = cache_sfops(smb);
-
-        setup_iops(cache_inode, iops, cache_sym_iops);
-        setup_fops(cache_inode, fops, cache_sym_fops);
+        struct smfs_super_info *smb = S2SMI(inode->i_sb);
+        struct inode *cache_inode = I2CI(inode);
+        
+        setup_iops(cache_inode, &smfs_sym_iops, &smb->sm_ops->sm_sym_iops);
+        setup_fops(cache_inode, &smfs_sym_fops, &smb->sm_ops->sm_sym_fops);
 
         lock_kernel();
         smb->smsi_ops_check |= SYMLINK_OPS_CHECK;
         unlock_kernel();
 }
 
+#define SMFS_IOPEN_INO  1
 
-void sm_set_inode_ops(struct inode *cache_inode, struct inode *inode)
+void sm_set_inode_ops(struct inode *inode)
 {
         struct smfs_super_info *smb = S2SMI(inode->i_sb);
 
-        /* XXX now set the correct sm_{file,dir,sym}_iops */
+        //iopen stuff
+        if (inode->i_ino == SMFS_IOPEN_INO) {
+                inode->i_op = &smfs_iopen_iops;
+                inode->i_fop = &smfs_iopen_fops;
+                return;
+        }
+
+        /* 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);
+                if (!(smb->smsi_ops_check & DIR_OPS_CHECK))
+                        setup_sm_dir_ops(inode);
+                inode->i_op = &smb->sm_ops->sm_dir_iops;
+                inode->i_fop = &smb->sm_ops->sm_dir_fops;   
         } 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);
+                if (!(smb->smsi_ops_check & FILE_OPS_CHECK))
+                        setup_sm_file_ops(inode);
+                inode->i_fop = &smb->sm_ops->sm_file_fops;
+                inode->i_op = &smb->sm_ops->sm_file_iops;
 
         } 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);
+                if (!(smb->smsi_ops_check & SYMLINK_OPS_CHECK))
+                        setup_sm_symlink_ops(inode);
+                inode->i_op = &smb->sm_ops->sm_sym_iops;
+                inode->i_fop =  &smb->sm_ops->sm_sym_fops;
         }
 }
 

diff --git a/lustre/smfs/dir.c b/lustre/smfs/dir.c
index 4130858..cc3ae29 100644 (file)
--- a/lustre/smfs/dir.c
+++ b/lustre/smfs/dir.c
@@ -88,8 +88,8 @@ static int smfs_create(struct inode *dir, struct dentry *dentry,
         rc = cache_dir->i_op->create(cache_dir, cache_dentry, mode, nd);
 #endif
         if (!rc) {
-                inode = smfs_get_inode(dir->i_sb, cache_dentry->d_inode->i_ino,
-                                       dir, 0);
+                inode = smfs_get_inode(dir->i_sb, cache_dentry->d_inode,
+                                       I2SMI(dir), 0);
                 if (inode) {
                         d_instantiate(dentry, inode);
                 }
@@ -219,8 +219,8 @@ static int smfs_do_lookup (struct inode * dir,
                                 CWARN("inode #%lu (%p) nlink is 0\n",
                                       tmp->d_inode->i_ino, tmp->d_inode);
                         
-                        *inode = smfs_get_inode(dir->i_sb, tmp->d_inode->i_ino, 
-                                        dir, 0); 
+                        *inode = smfs_get_inode(dir->i_sb, tmp->d_inode, 
+                                                I2SMI(dir), 0); 
                         if (!(*inode))
                                 rc = -ENOENT;
                 }
@@ -489,8 +489,8 @@ static int smfs_symlink(struct inode *dir, struct dentry *dentry,
         
         rc = cache_dir->i_op->symlink(cache_dir, cache_dentry, symname);
         if (!rc) {        
-                inode = smfs_get_inode(dir->i_sb, cache_dentry->d_inode->i_ino,
-                                       dir, 0);
+                inode = smfs_get_inode(dir->i_sb, cache_dentry->d_inode,
+                                       I2SMI(dir), 0);
                 if (inode) {
                         d_instantiate(dentry, inode);
                 }
@@ -545,8 +545,8 @@ static int smfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         
         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);
+                inode = smfs_get_inode(dir->i_sb, cache_dentry->d_inode,
+                                       I2SMI(dir), 0);
                 if (inode) {
                         //smsf_update_dentry(dentry, cache_dentry);
                         d_instantiate(dentry, inode);
@@ -665,8 +665,8 @@ static int smfs_mknod(struct inode *dir, struct dentry *dentry,
         
         rc = cache_dir->i_op->mknod(cache_dir, cache_dentry, mode, rdev);
         if (!rc) {
-                inode = smfs_get_inode(dir->i_sb, cache_dentry->d_inode->i_ino,
-                                       dir, 0);
+                inode = smfs_get_inode(dir->i_sb, cache_dentry->d_inode,
+                                       I2SMI(dir), 0);
                 if (inode) {
                         //smsf_update_dentry(dentry, cache_dentry);
                         d_instantiate(dentry, inode);

diff --git a/lustre/smfs/inode.c b/lustre/smfs/inode.c
index 1e6a729..d7c638d 100644 (file)
--- a/lustre/smfs/inode.c
+++ b/lustre/smfs/inode.c
@@ -37,22 +37,20 @@
 #include <linux/lustre_smfs.h>
 #include "smfs_internal.h"
 
-#define SMFS_IOPEN_INO  1
-
 static void smfs_init_inode_info(struct inode *inode, void *opaque)
 {
         
         struct inode *cache_inode = NULL;
         struct smfs_iget_args *sargs = opaque;
-        unsigned long ino;
-
+        
         LASSERTF((!I2SMI(inode)), "Inode %lu already has smfs_inode_info %p \n",
                  inode->i_ino, I2SMI(inode));
         
         /* getting backing fs inode. */
         LASSERT(sargs);
-        ino = inode->i_ino;
-        cache_inode = iget(S2CSB(inode->i_sb), ino); 
+        
+        cache_inode = igrab(sargs->s_inode); 
+        LASSERT(cache_inode);
         
         OBD_ALLOC(inode->u.generic_ip, sizeof(struct smfs_inode_info));
 
@@ -63,15 +61,11 @@ static void smfs_init_inode_info(struct inode *inode, void *opaque)
                         atomic_read(&cache_inode->i_count));
         
         post_smfs_inode(inode, cache_inode);
-        sm_set_inode_ops(cache_inode, inode);
-        //iopen stuff
-        if (ino == SMFS_IOPEN_INO) {
-                inode->i_op = &smfs_iopen_iops;
-                inode->i_fop = &smfs_iopen_fops;
-        }
+        sm_set_inode_ops(inode);
+
         //inherit parent inode flags
-        if (sargs->s_inode) { 
-                I2SMI(inode)->smi_flags = I2SMI(sargs->s_inode)->smi_flags;
+        if (sargs->s_info) { 
+                I2SMI(inode)->smi_flags = sargs->s_info->smi_flags;
                 CDEBUG(D_INODE, "set inode %lu flags 0x%.8x\n", inode->i_ino,
                       I2SMI(inode)->smi_flags);
         } 
@@ -113,7 +107,7 @@ static int smfs_test_inode(struct inode *inode, void *opaque)
 {
         struct smfs_iget_args *sargs = (struct smfs_iget_args*)opaque;
 
-        if (!sargs || (inode->i_ino != sargs->s_ino))
+        if (!sargs || (inode->i_ino != sargs->s_inode->i_ino))
                 return 0;
         
 #ifdef CONFIG_SNAPFS
@@ -130,7 +124,7 @@ int smfs_set_inode(struct inode *inode, void *opaque)
 {
         struct smfs_iget_args *sargs = opaque;
         
-        inode->i_ino = sargs->s_ino;
+        inode->i_ino = sargs->s_inode->i_ino;
         
         return 0;
 }
@@ -149,9 +143,9 @@ static struct inode *smfs_iget(struct super_block *sb, ino_t hash,
                         unlock_new_inode(inode);
                 }
                 
-                CDEBUG(D_INODE, "inode: %lu/%u(%p) index %d "
-                       "ino %d\n", inode->i_ino, inode->i_generation,
-                       inode, sargs->s_index, sargs->s_ino);
+                CDEBUG(D_INODE, "inode: %lu/%u(%p) index %d\n",
+                                inode->i_ino, inode->i_generation,
+                                inode, sargs->s_index);
                 
         }
         return inode;
@@ -174,19 +168,19 @@ struct inode *smfs_iget(struct super_block *sb, ino_t hash,
 }
 #endif
 
-struct inode *smfs_get_inode(struct super_block *sb, ino_t hash,
-                             struct inode *dir, int index)
+struct inode *smfs_get_inode(struct super_block *sb, struct inode * cache_inode,
+                             struct smfs_inode_info * dir_info, int index)
 {
         struct smfs_iget_args sargs;
         struct inode *inode;
         ENTRY;
        
-        sargs.s_ino = hash; 
-        sargs.s_inode = dir; 
+        sargs.s_inode = cache_inode; 
+        sargs.s_info = dir_info; 
         sargs.s_index = index;
         
-        inode = smfs_iget(sb, hash, &sargs);
-
+        inode = smfs_iget(sb, cache_inode->i_ino, &sargs);
+        LASSERT(inode);
         RETURN(inode);
 }
 #ifdef FC3_KERNEL 
@@ -239,7 +233,7 @@ static void smfs_dirty_inode(struct inode *inode)
 
 static void smfs_delete_inode(struct inode *inode)
 {
-        struct inode * cache_inode = I2CI(inode);
+        //struct inode * cache_inode = I2CI(inode);
 
         //smfs_clear_inode_info(inode);
         clear_inode(inode);

diff --git a/lustre/smfs/smfs_internal.h b/lustre/smfs/smfs_internal.h
index 2d3bfd3..ec7fab5 100644 (file)
--- a/lustre/smfs/smfs_internal.h
+++ b/lustre/smfs/smfs_internal.h
@@ -71,47 +71,14 @@ do{                                                 \
 
 extern int init_smfs_proc_sys(void);
 /*cache.c*/
-extern void sm_set_inode_ops(struct inode *cache_inode, struct inode *inode);
+extern void sm_set_inode_ops(struct inode *);
 extern void sm_set_sb_ops(struct super_block *cache_sb, struct super_block *sb);
-extern void init_smfs_cache(void);
-extern void cleanup_smfs_cache(void);
-extern void sm_set_journal_ops(struct super_block *sb, char *cache_type);
+//extern void init_smfs_cache(void);
+//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 inode_operations *cache_diops(struct smfs_super_info *smb)
-{
-        return &smb->sm_ops->sm_dir_iops;
-}
-static inline struct inode_operations *cache_fiops(struct smfs_super_info *smb)
-{
-        return &smb->sm_ops->sm_file_iops;
-}
-static inline struct inode_operations *cache_siops(struct smfs_super_info *smb)
-{
-        return &smb->sm_ops->sm_sym_iops;
-}
-static inline struct file_operations *cache_dfops(struct smfs_super_info *smb)
-{
-        return &smb->sm_ops->sm_dir_fops;
-}
-static inline struct file_operations *cache_ffops(struct smfs_super_info *smb)
-{
-        return &smb->sm_ops->sm_file_fops;
-}
-static inline struct file_operations *cache_sfops(struct smfs_super_info *smb)
-{
-        return &smb->sm_ops->sm_sym_fops;
-}
-static inline struct dentry_operations *cache_dops(struct smfs_super_info *smb)
-{
-        return &smb->sm_ops->sm_dentry_ops;
-}
-static inline struct journal_operations *journal_ops(struct smfs_super_info *smb)
-{
-        return &smb->sm_ops->sm_journal_ops;
-}
-
 /*smfs_lib.c*/
 void smfs_put_super(struct super_block *sb);
 int smfs_fill_super(struct super_block *sb, void *data, int silent);
@@ -144,16 +111,17 @@ extern int smfs_removexattr(struct dentry *dentry, const char *name);
 extern int smfs_open(struct inode * inode, struct file * filp);
 extern int smfs_release(struct inode * inode, struct file * filp);
 /*inode.c*/
-struct inode *smfs_get_inode(struct super_block *sb, ino_t hash, 
-                             struct inode *dir, int index);
+struct inode *smfs_get_inode(struct super_block *, struct inode*,  
+                             struct smfs_inode_info *, int);
 
 extern struct super_operations smfs_super_ops;
 
 struct smfs_iget_args {
-        struct inode *s_inode;
-        int           s_index;
-        int           s_ino;
+        struct inode            *s_inode;
+        struct smfs_inode_info  *s_info;
+        int                      s_index;
 };
+
 /*symlink.c*/
 extern struct inode_operations smfs_sym_iops;
 extern struct file_operations smfs_sym_fops;

diff --git a/lustre/smfs/smfs_lib.c b/lustre/smfs/smfs_lib.c
index 9723e74..b8144cf 100644 (file)
--- a/lustre/smfs/smfs_lib.c
+++ b/lustre/smfs/smfs_lib.c
@@ -367,13 +367,13 @@ void smfs_put_super(struct super_block *sb)
 int smfs_fill_super(struct super_block *sb, void *data, int silent)
 {
         struct inode *root_inode = NULL;
+       struct inode *back_root_inode = NULL;
         struct smfs_super_info *smb = NULL;
         char *devstr = NULL, *typestr = NULL; 
         char *opts = NULL;
         int err = 0;
         int flags = 0;
-        ino_t root_ino;
-
+        
         ENTRY;
         
         if (!data) {
@@ -420,11 +420,11 @@ int smfs_fill_super(struct super_block *sb, void *data, int silent)
         sm_set_sb_ops(smb->smsi_sb, sb);
 
         /* init the root_inode of smfs. */ 
-        root_ino = S2CSB(sb)->s_root->d_inode->i_ino;
-        root_inode = smfs_get_inode(sb, root_ino, NULL, 0);
+        back_root_inode = S2CSB(sb)->s_root->d_inode;
+        root_inode = smfs_get_inode(sb, back_root_inode, NULL, 0);
 
         CDEBUG(D_SUPER, "readinode %p, root ino %ld, root inode at %p\n",
-               sb->s_op->read_inode, root_ino, root_inode);
+               sb->s_op->read_inode, root_inode->i_ino, root_inode);
 
         sb->s_root = d_alloc_root(root_inode);
         if (!sb->s_root) {