- fixed stupid bug with locking in MDS. It caused clients do not flush local

[fs/lustre-release.git] / lustre / lvfs / fsfilt_smfs.c

diff --git a/lustre/lvfs/fsfilt_smfs.c b/lustre/lvfs/fsfilt_smfs.c
index 98f1383..b64cf91 100644 (file)
--- a/lustre/lvfs/fsfilt_smfs.c
+++ b/lustre/lvfs/fsfilt_smfs.c
@@ -76,7 +76,7 @@ static void *fsfilt_smfs_brw_start(int objcount, struct fsfilt_objinfo *fso,
                 return NULL;
 
         cache_inode = I2CI(fso->fso_dentry->d_inode);
-         cache_dentry = pre_smfs_dentry(NULL, cache_inode, fso->fso_dentry);
+        cache_dentry = pre_smfs_dentry(NULL, cache_inode, fso->fso_dentry);
 
         if (!cache_dentry)
                 GOTO(exit, rc = ERR_PTR(-ENOMEM));
@@ -231,11 +231,11 @@ static int fsfilt_smfs_iocontrol(struct inode *inode, struct file *file,
         } else {
                 rc = cache_fsfilt->fs_iocontrol(cache_inode, NULL, cmd, arg);
         }
-
+#if 0
         /* FIXME-UMKA: Should this be in duplicate_inode()? */
         if (rc == 0 && cmd == EXT3_IOC_SETFLAGS)
                 inode->i_flags = cache_inode->i_flags;
-
+#endif
         post_smfs_inode(inode, cache_inode);
 
         RETURN(rc);
@@ -301,11 +301,7 @@ static int fsfilt_smfs_get_md(struct inode *inode, void *lmm, int lmm_size)
         RETURN(rc);
 }
 
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-static int fsfilt_smfs_send_bio(struct inode *inode, struct bio *bio)
-#else
-static int fsfilt_smfs_send_bio(struct inode *inode, struct kiobuf *bio)
-#endif
+static int fsfilt_smfs_send_bio(int rw, struct inode *inode, struct kiobuf *bio)
 {
         struct inode *cache_inode;
         struct fsfilt_operations *cache_fsfilt;
@@ -321,7 +317,7 @@ static int fsfilt_smfs_send_bio(struct inode *inode, struct kiobuf *bio)
         if (!cache_fsfilt->fs_send_bio)
                 RETURN(-ENOSYS);
 
-        return cache_fsfilt->fs_send_bio(cache_inode, bio);
+        return cache_fsfilt->fs_send_bio(rw, cache_inode, bio);
 }
 
 static struct page *
@@ -340,7 +336,27 @@ fsfilt_smfs_getpage(struct inode *inode, long int index)
 
         if (!cache_fsfilt->fs_getpage)
                 RETURN(ERR_PTR(-ENOSYS));
-
+#if CONFIG_SNAPFS
+        if (SMFS_DO_COW(S2SMI(inode->i_sb))) {
+                struct address_space_operations *aops = 
+                                cache_inode->i_mapping->a_ops;
+                if (aops->bmap(cache_inode->i_mapping, index)) {
+                        struct inode *ind_inode = NULL;
+                        struct inode *cache_ind = NULL;
+                        struct page  *page = NULL;
+                        
+                        ind_inode = smfs_cow_get_ind(inode, index);
+                        if (!ind_inode) {
+                                RETURN(ERR_PTR(-EIO));
+                        }
+                        cache_ind = I2CI(ind_inode);
+                        /*FIXME cow inode should be bottom fs inode */         
+                        page = cache_fsfilt->fs_getpage(cache_ind, index);
+                        iput(ind_inode); 
+                        RETURN(page);
+                } 
+        }
+#endif
         return cache_fsfilt->fs_getpage(cache_inode, index);
 }
 
@@ -375,11 +391,27 @@ static ssize_t fsfilt_smfs_readpage(struct file *file, char *buf,
         *cache_ppos = *off;
 
         pre_smfs_inode(file->f_dentry->d_inode, cache_inode);
-
+#if CONFIG_SNAPFS
+        /*readdir page*/
+        if (smfs_dotsnap_inode(file->f_dentry->d_inode)) {
+                struct fsfilt_operations *snapops = 
+                                        I2SNAPOPS(file->f_dentry->d_inode);
+                
+                LASSERT(S_ISDIR(file->f_dentry->d_inode->i_mode));
+                
+                rc = snapops->fs_read_dotsnap_dir_page(sfi->c_file, buf, count, 
+                                                       cache_ppos); 
+        } else {
+                if (cache_fsfilt->fs_readpage)
+                        rc = cache_fsfilt->fs_readpage(sfi->c_file, buf, count,
+                                                       cache_ppos);
+        }
+#else
         if (cache_fsfilt->fs_readpage)
                 rc = cache_fsfilt->fs_readpage(sfi->c_file, buf, count,
                                                cache_ppos);
 
+#endif
         *off = *cache_ppos;
         post_smfs_inode(file->f_dentry->d_inode, cache_inode);
         duplicate_file(file, sfi->c_file);
@@ -581,7 +613,8 @@ static int fsfilt_smfs_write_record(struct file *file, void *buf, int bufsize,
         RETURN(rc);
 }
 
-static int fsfilt_smfs_post_setup(struct obd_device *obd, struct vfsmount *mnt)
+static int fsfilt_smfs_post_setup(struct obd_device *obd, struct vfsmount *mnt,
+                                  struct dentry *root_dentry)
 {
         struct super_block *sb = NULL;
         int rc = 0;
@@ -589,6 +622,7 @@ static int fsfilt_smfs_post_setup(struct obd_device *obd, struct vfsmount *mnt)
         if (mnt) {
                 sb = mnt->mnt_sb;
                 S2SMI(sb)->smsi_exp = obd->obd_self_export;
+                smfs_post_setup(sb, mnt);
                 if (SMFS_DO_REC(S2SMI(sb)))
                         rc = smfs_start_rec(sb, mnt);
                 if (rc)
@@ -609,31 +643,56 @@ static int fsfilt_smfs_post_cleanup(struct obd_device *obd,
 {
         struct super_block *sb = NULL;
         int rc = 0;
-
+        ENTRY;
+        
         if (mnt) {
                 sb = mnt->mnt_sb;
                 if (SMFS_DO_REC(S2SMI(sb)))
                         rc = smfs_stop_rec(sb);
+                smfs_post_cleanup(sb);
         }
         RETURN(rc);
 }
 
-static int fsfilt_smfs_set_kml_flags(struct inode *inode)
+static int fsfilt_smfs_set_fs_flags(struct inode *inode, int flags)
 {
         int rc = 0;
-        if (SMFS_DO_REC(S2SMI(inode->i_sb)))
+        ENTRY;
+
+        if (SMFS_DO_REC(S2SMI(inode->i_sb)) && (flags & SM_DO_REC))
                 SMFS_SET_INODE_REC(inode);
+        if (SMFS_DO_COW(S2SMI(inode->i_sb)) && (flags & SM_DO_COW))
+                SMFS_SET_INODE_COW(inode);
         RETURN(rc);
 }
 
-static int fsfilt_smfs_clear_kml_flags(struct inode *inode)
+static int fsfilt_smfs_clear_fs_flags(struct inode *inode, int flags)
 {
         int rc = 0;
-        if (SMFS_DO_REC(S2SMI(inode->i_sb)))
+        ENTRY;
+        
+        if (SMFS_DO_REC(S2SMI(inode->i_sb)) && (flags & SM_DO_REC))
                 SMFS_CLEAN_INODE_REC(inode);
+        if (SMFS_DO_COW(S2SMI(inode->i_sb)) && (flags & SM_DO_COW))
+                SMFS_CLEAN_INODE_COW(inode);
         RETURN(rc);
 }
 
+static int fsfilt_smfs_get_fs_flags(struct dentry *de)
+{
+        struct inode *inode = de->d_inode;
+        int flags = 0;
+        ENTRY;
+
+        LASSERT(inode);
+
+        if (SMFS_DO_REC(S2SMI(inode->i_sb)) && SMFS_DO_INODE_REC(inode))
+                flags |= SM_DO_REC;
+        if (SMFS_DO_COW(S2SMI(inode->i_sb)) && SMFS_DO_INODE_COW(inode))
+                flags |= SM_DO_COW;
+       
+        RETURN(flags); 
+}
 static int fsfilt_smfs_set_ost_flags(struct super_block *sb)
 {
         int rc = 0;
@@ -910,11 +969,29 @@ static int fsfilt_smfs_set_snap_item(struct super_block *sb, char *name)
 
         ENTRY;
 #if CONFIG_SNAPFS
-        rc = smfs_add_snap_item(sb, name);
+#warning "still not implement for add snap item -wangdi"         
 #endif
         RETURN(rc);        
 }
-
+static int fsfilt_smfs_do_write_cow(struct dentry *de, void *extents,
+                                    int num_extents)
+{
+        int rc = 0;
+#if CONFIG_SNAPFS
+        struct write_extents *w_ext = (struct write_extents *)extents;
+        int i = 0;
+        ENTRY;
+        for (i = 0; i < num_extents; i++) {
+               size_t count = w_ext->w_count;
+               loff_t off = w_ext->w_pos;
+               rc = smfs_cow_write_pre(de->d_inode, de, &count, &off);
+               if (rc)
+                        RETURN(rc);  
+               w_ext ++;
+        }
+#endif
+        RETURN(rc);
+}
 static struct fsfilt_operations fsfilt_smfs_ops = {
         .fs_type                = "smfs",
         .fs_owner               = THIS_MODULE,
@@ -939,8 +1016,9 @@ static struct fsfilt_operations fsfilt_smfs_ops = {
         .fs_setup               = fsfilt_smfs_setup,
         .fs_post_setup          = fsfilt_smfs_post_setup,
         .fs_post_cleanup        = fsfilt_smfs_post_cleanup,
-        .fs_set_kml_flags       = fsfilt_smfs_set_kml_flags,
-        .fs_clear_kml_flags     = fsfilt_smfs_clear_kml_flags,
+        .fs_set_fs_flags       = fsfilt_smfs_set_fs_flags,
+        .fs_clear_fs_flags     = fsfilt_smfs_clear_fs_flags,
+        .fs_get_fs_flags       = fsfilt_smfs_get_fs_flags,
         .fs_set_ost_flags       = fsfilt_smfs_set_ost_flags,
         .fs_set_mds_flags       = fsfilt_smfs_set_mds_flags,
         .fs_precreate_rec       = fsfilt_smfs_precreate_rec,
@@ -955,7 +1033,7 @@ static struct fsfilt_operations fsfilt_smfs_ops = {
         .fs_free_write_extents  = fsfilt_smfs_free_extents,
         .fs_write_extents       = fsfilt_smfs_write_extents,
         .fs_set_snap_item       = fsfilt_smfs_set_snap_item,
-        
+        .fs_do_write_cow        = fsfilt_smfs_do_write_cow,
         /* FIXME-UMKA: probably fsfilt_smfs_get_op_len() should be
          * put here too. */
 };