Whamcloud - gitweb
git://git.whamcloud.com / fs / lustre-release.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
- tagging RC_CURRENT
[fs/lustre-release.git] / lustre / smfs / file.c
diff --git a/lustre/smfs/file.c b/lustre/smfs/file.c
index e4666c4..eaf1901 100644 (file)
--- a/lustre/smfs/file.c
+++ b/lustre/smfs/file.c
@@ -11,53 +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;
-       int     rc;
-       
-       ENTRY;
-       
-       cache_inode = I2CI(inode);
- 
-        if (!cache_inode)
-                RETURN(-ENOENT);
-
-       if (cache_inode->i_mapping->a_ops->readpage)
-               rc = cache_inode->i_mapping->a_ops->readpage(file, 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,
@@ -72,9 +27,18 @@ void smfs_prepare_cachefile(struct inode *inode,
         cache_file->f_flags = file->f_flags;
         cache_file->f_count  = file->f_count;
         cache_file->f_owner  = file->f_owner;
+       cache_file->f_error = file->f_error;
        cache_file->f_op = inode->i_fop;
        cache_file->f_dentry = cache_dentry;
         cache_file->f_dentry->d_inode = cache_inode;
+       cache_file->f_vfsmnt = file->f_vfsmnt;
+       cache_file->private_data = file->private_data;
+       cache_file->f_it = file->f_it;
+       cache_file->f_reada = file->f_reada;
+       cache_file->f_ramax = file->f_ramax;
+       cache_file->f_raend = file->f_raend;
+       cache_file->f_ralen = file->f_ralen;
+       cache_file->f_rawin = file->f_rawin;
        EXIT;
 }
 /* update file structs*/
@@ -87,6 +51,11 @@ void smfs_update_file(struct file *file,
         file->f_flags = cache_file->f_flags;
         file->f_count  = cache_file->f_count;
         file->f_owner  = cache_file->f_owner;
+       file->f_reada = cache_file->f_reada;
+       file->f_ramax = cache_file->f_ramax;
+       file->f_raend = cache_file->f_raend;
+       file->f_ralen = cache_file->f_ralen;
+       file->f_rawin = cache_file->f_rawin;
        EXIT;
 }
 
@@ -98,7 +67,9 @@ static ssize_t smfs_write (struct file *filp, const char *buf,
        struct  inode *inode = dentry->d_inode;
         struct  file open_file;
        struct  dentry open_dentry;
-       int     rc;
+       loff_t  tmp_ppos;
+       loff_t  *cache_ppos;
+       int     rc = 0;
        
        ENTRY;
        
@@ -106,16 +77,28 @@ static ssize_t smfs_write (struct file *filp, const char *buf,
  
         if (!cache_inode)
                 RETURN(-ENOENT);
-
+       
+       if (ppos != &(filp->f_pos)) {
+               cache_ppos = &tmp_ppos; 
+       } else {
+               cache_ppos = &open_file.f_pos; 
+       }
+       *cache_ppos = *ppos;
+       
        smfs_prepare_cachefile(inode, filp, cache_inode, 
                               &open_file, &open_dentry);
+       pre_smfs_inode(inode, cache_inode);
        
        if (cache_inode->i_fop->write)
-               cache_inode->i_fop->write(&open_file, buf, count, ppos);
-
+               rc = cache_inode->i_fop->write(&open_file, buf, count, cache_ppos);
+       
+       *ppos = *cache_ppos;
+       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)
 {
@@ -123,7 +106,7 @@ int smfs_ioctl(struct inode * inode, struct file * filp,
        struct  dentry *dentry = filp->f_dentry;
         struct  file open_file;
        struct  dentry open_dentry;
-       ssize_t rc;
+       ssize_t rc = 0;
        
        ENTRY;
        
@@ -137,17 +120,22 @@ 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);
                
+       post_smfs_inode(inode, cache_inode);
        smfs_update_file(filp, &open_file);
         RETURN(rc);
 }
+
 static ssize_t smfs_read (struct file *filp, char *buf, 
                          size_t count, loff_t *ppos)
 {
        struct  inode *cache_inode;
        struct  dentry *dentry = filp->f_dentry;
+       struct  inode *inode = dentry->d_inode;
         struct  file open_file;
        struct  dentry open_dentry;
-       ssize_t rc;
+       loff_t  tmp_ppos;
+       loff_t  *cache_ppos;
+       ssize_t rc = 0;
        
        ENTRY;
        
@@ -155,15 +143,28 @@ static ssize_t smfs_read (struct file *filp, char *buf,
         if (!cache_inode)
                 RETURN(-ENOENT);
 
-       smfs_prepare_cachefile(dentry->d_inode, filp, cache_inode, 
+       if (ppos != &(filp->f_pos)) {
+               cache_ppos = &tmp_ppos; 
+       } else {
+               cache_ppos = &open_file.f_pos; 
+       }
+       *cache_ppos = *ppos;
+       
+       
+       smfs_prepare_cachefile(inode, filp, cache_inode, 
                               &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, ppos);
-               
+               rc = cache_inode->i_fop->read(&open_file, buf, count, cache_ppos);
+    
+       *ppos = *cache_ppos;
+       post_smfs_inode(inode, cache_inode);
        smfs_update_file(filp, &open_file);
-        RETURN(rc);
+       RETURN(rc);
 }
+
 static loff_t smfs_llseek(struct file *file, 
                          loff_t offset, 
                          int origin)
@@ -172,7 +173,7 @@ static loff_t smfs_llseek(struct file *file,
        struct  dentry *dentry = file->f_dentry;
         struct  file open_file;
        struct  dentry open_dentry;
-       ssize_t rc;
+       ssize_t rc = 0;
        
        ENTRY;
        
@@ -183,9 +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);
-       
+
+       post_smfs_inode(dentry->d_inode, cache_inode);
        smfs_update_file(file, &open_file);
                
         RETURN(rc);
@@ -193,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;
@@ -206,10 +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);
-       
+      
+       post_smfs_inode(inode, cache_inode);
        smfs_update_file(file, &open_file);
        
        RETURN(rc);
@@ -229,9 +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);
         
+       post_smfs_inode(inode, cache_inode);
        smfs_update_file(filp, &open_file);
        
        RETURN(rc);
@@ -251,9 +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);
 
+       post_smfs_inode(inode, cache_inode);
        smfs_update_file(filp, &open_file);
         
        RETURN(rc);
@@ -275,9 +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);
        
+       post_smfs_inode(inode, cache_inode);
        smfs_update_file(file, &open_file);
        
        RETURN(rc);
@@ -321,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; 
 } 
@@ -339,9 +352,12 @@ 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);
 
+       post_smfs_inode(dentry->d_inode, cache_inode);
+       
        RETURN(rc);
 } 
   
@@ -357,11 +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);
 
+       post_smfs_inode(dentry->d_inode, cache_inode);
        RETURN(rc);
 } 
                         
@@ -378,10 +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);
 
+       post_smfs_inode(dentry->d_inode, cache_inode);
        RETURN(rc);
 }
 
@@ -397,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);
 }                                                                                                                                                           
 
@@ -416,10 +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);
 
+       post_smfs_inode(dentry->d_inode, cache_inode);
        RETURN(rc);
 }
 
Lustre primary development and releases