- tagging RC_CURRENT

[fs/lustre-release.git] / lustre / smfs / file.c

diff --git a/lustre/smfs/file.c b/lustre/smfs/file.c
index 3175c56..eaf1901 100644 (file)
--- a/lustre/smfs/file.c
+++ b/lustre/smfs/file.c
@@ -11,81 +11,8 @@
 #include <linux/stat.h>
 #include <linux/unistd.h>
 #include <linux/pagemap.h>
+#include <linux/lustre_idl.h>
 #include "smfs_internal.h" 
-
-static int smfs_readpage(struct file *file, 
-                        struct page *page)
-{
-       struct  inode *inode = page->mapping->host;
-       struct  inode *cache_inode;
-       struct page *cache_page = NULL;
-       int rc = 0; 
-
-       ENTRY;
-       
-       cache_inode = I2CI(inode);
- 
-        if (!cache_inode)
-                RETURN(-ENOENT);
-       
-       cache_page = grab_cache_page(cache_inode->i_mapping, page->index);
-
-       if (!cache_page) 
-               GOTO(exit_release, rc = -ENOMEM);
-
-       if ((rc = cache_inode->i_mapping->a_ops->readpage(file, cache_page)))
-               GOTO(exit_release, 0);
-       
-       wait_on_page(cache_page);
-
-       if (!Page_Uptodate(cache_page))
-               GOTO(exit_release, rc = -EIO);
-
-       memcpy(kmap(page), kmap(cache_page), PAGE_CACHE_SIZE);
-
-       flush_dcache_page(page);
-
-       kunmap(cache_page);
-       page_cache_release(cache_page);
-
-exit:  
-       kunmap(page);
-       SetPageUptodate(page);
-       UnlockPage(page);
-
-       RETURN(rc);
-
-exit_release:
-       if (cache_page) 
-               page_cache_release(cache_page);
-       UnlockPage(page);
-       RETURN(rc);
-}
-
-static int smfs_writepage(struct page *page)
-{
-
-       struct  inode *inode = page->mapping->host;
-       struct  inode *cache_inode;
-       int     rc;
-       
-       ENTRY;
-       
-       cache_inode = I2CI(inode);
- 
-        if (!cache_inode)
-                RETURN(-ENOENT);
-
-       if (cache_inode->i_mapping->a_ops->writepage)
-               rc = cache_inode->i_mapping->a_ops->writepage(page);
-               
-        RETURN(rc);
-}
-
-struct address_space_operations smfs_file_aops = {
-       readpage:   smfs_readpage,
-       writepage:  smfs_writepage,
-};
         
 /* instantiate a file handle to the cache file */
 void smfs_prepare_cachefile(struct inode *inode,
@@ -160,15 +87,18 @@ static ssize_t smfs_write (struct file *filp, const char *buf,
        
        smfs_prepare_cachefile(inode, filp, cache_inode, 
                               &open_file, &open_dentry);
+       pre_smfs_inode(inode, cache_inode);
+       
        if (cache_inode->i_fop->write)
                rc = cache_inode->i_fop->write(&open_file, buf, count, cache_ppos);
        
        *ppos = *cache_ppos;
-       duplicate_inode(cache_inode, inode);
+       post_smfs_inode(inode, cache_inode);
        smfs_update_file(filp, &open_file);
 
        RETURN(rc);
 }
+
 int smfs_ioctl(struct inode * inode, struct file * filp, 
               unsigned int cmd, unsigned long arg)
 {
@@ -190,7 +120,7 @@ int smfs_ioctl(struct inode * inode, struct file * filp,
        if (cache_inode->i_fop->ioctl)
                rc = cache_inode->i_fop->ioctl(cache_inode, &open_file, cmd, arg);
                
-       duplicate_inode(cache_inode, inode);
+       post_smfs_inode(inode, cache_inode);
        smfs_update_file(filp, &open_file);
         RETURN(rc);
 }
@@ -225,11 +155,12 @@ static ssize_t smfs_read (struct file *filp, char *buf,
                               &open_file, &open_dentry);
 
        
+       pre_smfs_inode(inode, cache_inode);
        if (cache_inode->i_fop->read)
                rc = cache_inode->i_fop->read(&open_file, buf, count, cache_ppos);
     
        *ppos = *cache_ppos;
-       duplicate_inode(cache_inode, inode);
+       post_smfs_inode(inode, cache_inode);
        smfs_update_file(filp, &open_file);
        RETURN(rc);
 }
@@ -253,10 +184,11 @@ static loff_t smfs_llseek(struct file *file,
        smfs_prepare_cachefile(dentry->d_inode, file, cache_inode, 
                               &open_file, &open_dentry);
        
+       pre_smfs_inode(dentry->d_inode, cache_inode);
        if (cache_inode->i_fop->llseek)
                rc = cache_inode->i_fop->llseek(&open_file, offset, origin);
 
-       duplicate_inode(cache_inode, dentry->d_inode);
+       post_smfs_inode(dentry->d_inode, cache_inode);
        smfs_update_file(file, &open_file);
                
         RETURN(rc);
@@ -264,8 +196,7 @@ static loff_t smfs_llseek(struct file *file,
 
 static int smfs_mmap(struct file * file, struct vm_area_struct * vma)
 {
-       struct address_space *mapping = file->f_dentry->d_inode->i_mapping;
-        struct inode *inode = mapping->host;
+        struct inode *inode = file->f_dentry->d_inode;
         struct inode *cache_inode = NULL;
         struct  file open_file;
        struct  dentry open_dentry;
@@ -277,11 +208,15 @@ static int smfs_mmap(struct file * file, struct vm_area_struct * vma)
 
        smfs_prepare_cachefile(inode, file, cache_inode, 
                               &open_file, &open_dentry);
-       
+  
+       if (cache_inode->i_mapping == &cache_inode->i_data)
+                inode->i_mapping = cache_inode->i_mapping;
+
+       pre_smfs_inode(inode, cache_inode);
        if (cache_inode->i_fop->mmap)
                rc = cache_inode->i_fop->mmap(&open_file, vma);
-       
-       duplicate_inode(cache_inode, inode);
+      
+       post_smfs_inode(inode, cache_inode);
        smfs_update_file(file, &open_file);
        
        RETURN(rc);
@@ -301,10 +236,11 @@ static int smfs_open(struct inode * inode, struct file * filp)
        smfs_prepare_cachefile(inode, filp, cache_inode, 
                               &open_file, &open_dentry);
        
+       pre_smfs_inode(inode, cache_inode);
        if (cache_inode->i_fop->open)
                rc = cache_inode->i_fop->open(cache_inode, &open_file);
         
-       duplicate_inode(cache_inode, inode);
+       post_smfs_inode(inode, cache_inode);
        smfs_update_file(filp, &open_file);
        
        RETURN(rc);
@@ -324,10 +260,11 @@ static int smfs_release(struct inode * inode, struct file * filp)
        smfs_prepare_cachefile(inode, filp, cache_inode, 
                               &open_file, &open_dentry);
 
+       pre_smfs_inode(inode, cache_inode);
        if (cache_inode->i_fop->release)
                rc = cache_inode->i_fop->release(cache_inode, &open_file);
 
-       duplicate_inode(cache_inode, inode);
+       post_smfs_inode(inode, cache_inode);
        smfs_update_file(filp, &open_file);
         
        RETURN(rc);
@@ -349,10 +286,11 @@ int smfs_fsync(struct file * file,
        smfs_prepare_cachefile(inode, file, cache_inode, 
                               &open_file, &open_dentry);
 
+       pre_smfs_inode(inode, cache_inode);
        if (cache_inode->i_fop->fsync)
                rc = cache_inode->i_fop->fsync(&open_file, &open_dentry, datasync);
        
-       duplicate_inode(cache_inode, inode);
+       post_smfs_inode(inode, cache_inode);
        smfs_update_file(file, &open_file);
        
        RETURN(rc);
@@ -396,7 +334,7 @@ static void smfs_truncate(struct inode * inode)
        if (cache_inode->i_op->truncate)
                cache_inode->i_op->truncate(cache_inode);
 
-       duplicate_inode(inode, cache_inode);            
+       post_smfs_inode(inode, cache_inode);
         
        return; 
 } 
@@ -414,10 +352,11 @@ int smfs_setattr(struct dentry *dentry, struct iattr *attr)
                RETURN(-ENOENT);
        smfs_prepare_cache_dentry(&open_dentry, cache_inode);
        
+       pre_smfs_inode(dentry->d_inode, cache_inode);
        if (cache_inode->i_op->setattr)
                rc = cache_inode->i_op->setattr(&open_dentry, attr);
 
-       duplicate_inode(inode, cache_inode);            
+       post_smfs_inode(dentry->d_inode, cache_inode);
        
        RETURN(rc);
 } 
@@ -434,12 +373,13 @@ int smfs_setxattr(struct dentry *dentry, const char *name,
        if (!cache_inode) 
                RETURN(-ENOENT);
 
+       pre_smfs_inode(dentry->d_inode, cache_inode);
        smfs_prepare_cache_dentry(&open_dentry, cache_inode);
        
        if (cache_inode->i_op->setattr)
                rc = cache_inode->i_op->setxattr(&open_dentry, name, value, size, flags);
 
-       duplicate_inode(inode, cache_inode);            
+       post_smfs_inode(dentry->d_inode, cache_inode);
        RETURN(rc);
 } 
                         
@@ -456,11 +396,12 @@ int smfs_getxattr(struct dentry *dentry, const char *name,
                RETURN(-ENOENT);
 
        smfs_prepare_cache_dentry(&open_dentry, cache_inode);
+       pre_smfs_inode(dentry->d_inode, cache_inode);
        
        if (cache_inode->i_op->setattr)
                rc = cache_inode->i_op->getxattr(&open_dentry, name, buffer, size);
 
-       duplicate_inode(inode, cache_inode);            
+       post_smfs_inode(dentry->d_inode, cache_inode);
        RETURN(rc);
 }
 
@@ -476,10 +417,12 @@ ssize_t smfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
                RETURN(-ENOENT);
 
        smfs_prepare_cache_dentry(&open_dentry, cache_inode);
+       pre_smfs_inode(dentry->d_inode, cache_inode);
        
        if (cache_inode->i_op->listxattr)
                rc = cache_inode->i_op->listxattr(&open_dentry, buffer, size);
 
+       post_smfs_inode(dentry->d_inode, cache_inode);
        RETURN(rc);
 }                                                                                                                                                           
 
@@ -495,11 +438,12 @@ int smfs_removexattr(struct dentry *dentry, const char *name)
                RETURN(-ENOENT);
 
        smfs_prepare_cache_dentry(&open_dentry, cache_inode);
+       pre_smfs_inode(dentry->d_inode, cache_inode);
        
        if (cache_inode->i_op->removexattr)
                rc = cache_inode->i_op->removexattr(&open_dentry, name);
 
-       duplicate_inode(inode, cache_inode);            
+       post_smfs_inode(dentry->d_inode, cache_inode);
        RETURN(rc);
 }