b=5881

r=alex
d=24-33

support for iopen
FC3 compatibility

lustre/smfs/inode.c

@@ -37,6 +37,8 @@
 #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)
 {
         if (!I2SMI(inode)) {
@@ -45,6 +47,7 @@ static void smfs_init_inode_info(struct inode *inode, void *opaque)
                 unsigned long ino;
 
                 /* getting backing fs inode. */
+                LASSERT(sargs);
                 ino = sargs ? sargs->s_ino : inode->i_ino;
                 cache_inode = iget(S2CSB(inode->i_sb), ino); 
                 
@@ -52,6 +55,7 @@ static void smfs_init_inode_info(struct inode *inode, void *opaque)
                           sizeof(struct smfs_inode_info));
         
                 LASSERT(inode->u.generic_ip);
+                      
                 I2CI(inode) = cache_inode;
         
                 CDEBUG(D_INODE, "cache_inode %lu i_count %d\n",
@@ -59,13 +63,18 @@ static void smfs_init_inode_info(struct inode *inode, void *opaque)
         
                 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;
+                }
                 if (sargs) { 
                         struct inode *dir = sargs->s_inode; 
                         if (dir)
                                 I2SMI(inode)->smi_flags = I2SMI(dir)->smi_flags;
                 }
-        }
+        } else
+                LBUG();
 }
 
 static void smfs_clear_inode_info(struct inode *inode)
@@ -73,7 +82,8 @@ 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: inode %p\n",
+                       cache_inode);
 
                 LASSERTF(((atomic_read(&cache_inode->i_count) == 1) || 
                           cache_inode == cache_inode->i_sb->s_root->d_inode),
@@ -81,13 +91,12 @@ static void smfs_clear_inode_info(struct inode *inode)
                          inode, cache_inode, cache_inode->i_ino, 
                          atomic_read(&cache_inode->i_count));
                 
-                //if (cache_inode != cache_inode->i_sb->s_root->d_inode)
                 iput(cache_inode);
                 
-                OBD_FREE(inode->u.generic_ip,
-                         sizeof(struct smfs_inode_info));
+                OBD_FREE(inode->u.generic_ip, sizeof(struct smfs_inode_info));
                 inode->u.generic_ip = NULL;
-        }
+        } else
+                LBUG();
 }
 
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
@@ -123,6 +132,7 @@ static int smfs_test_inode(struct inode *inode, void *opaque)
             !smfs_snap_test_inode(inode, opaque))
                 return 0;  
 #endif
+        
         return 1;
 }
 
@@ -145,12 +155,12 @@ static struct inode *smfs_iget(struct super_block *sb, ino_t hash,
                         smfs_init_inode_info(inode, (void*)sargs);
                         unlock_new_inode(inode);
                 }
-                inode->i_ino = hash;
-                CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p) index %d "
+                //inode->i_ino = hash;
+                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);
+                inode->i_ino = hash;
         }
-        
         return inode;
 }
 #else
@@ -164,7 +174,7 @@ struct inode *smfs_iget(struct super_block *sb, ino_t hash,
         if (inode) {
                 struct inode *cache_inode = I2CI(inode);
                 
-                CDEBUG(D_VFSTRACE, "new inode: %lu/%u(%p)\n", inode->i_ino,
+                CDEBUG(D_INODE, "new inode: %lu/%u(%p)\n", inode->i_ino,
                        inode->i_generation, inode);
         }
         return inode;
@@ -181,29 +191,41 @@ struct inode *smfs_get_inode(struct super_block *sb, ino_t hash,
         sargs.s_ino = hash; 
         sargs.s_inode = dir; 
         sargs.s_index = index;
-        CDEBUG(D_VFSTRACE, "get_inode: %lu\n", hash);
+        
         inode = smfs_iget(sb, hash, &sargs);
+
         RETURN(inode);
 }
- 
+#ifdef FC3_KERNEL 
+static int smfs_write_inode(struct inode *inode, int wait)
+#else
 static void smfs_write_inode(struct inode *inode, int wait)
+#endif
 {
-        struct inode *cache_inode;
-        
+        struct inode *cache_inode = I2CI(inode);
+#ifdef FC3_KERNEL
+        int rc = 0;
+#endif        
         ENTRY;
 
-        cache_inode = I2CI(inode);
         LASSERT(cache_inode);
         
         CDEBUG(D_INODE,"Write inode %lu\n",inode->i_ino);
 
         pre_smfs_inode(inode, cache_inode);
         
+#ifdef FC3_KERNEL
+        rc = cache_inode->i_sb->s_op->write_inode(cache_inode, wait);
+#else
         cache_inode->i_sb->s_op->write_inode(cache_inode, wait);
-        
+#endif
         post_smfs_inode(inode, cache_inode);
         
+#ifdef FC3_KERNEL
+        RETURN(rc);
+#else
         EXIT;
+#endif
 }
 
 static void smfs_dirty_inode(struct inode *inode)
@@ -215,6 +237,7 @@ static void smfs_dirty_inode(struct inode *inode)
         LASSERT(cache_inode);
         
         pre_smfs_inode(inode, cache_inode);
+    
         S2CSB(inode->i_sb)->s_op->dirty_inode(cache_inode);
 
         post_smfs_inode(inode, cache_inode);