lustre/smfs/file.c

   1 /*
   2  * file.c
   3  */
   4
   5 #define DEBUG_SUBSYSTEM S_SM
   6
   7 #include <linux/module.h>
   8 #include <linux/kernel.h>
   9 #include <linux/string.h>
  10 #include <linux/slab.h>
  11 #include <linux/stat.h>
  12 #include <linux/unistd.h>
  13 #include <linux/pagemap.h>
  14 #include "smfs_internal.h"
  15
  16
  17 static int smfs_readpage(struct file *file,
  18                          struct page *page)
  19 {
  20         struct  inode *inode = page->mapping->host;
  21         struct  inode *cache_inode;
  22         int     rc;
  23
  24         ENTRY;
  25
  26         cache_inode = I2CI(inode);
  27
  28         if (!cache_inode)
  29                 RETURN(-ENOENT);
  30
  31         if (cache_inode->i_mapping->a_ops->readpage)
  32                 rc = cache_inode->i_mapping->a_ops->readpage(file, page);
  33
  34         RETURN(rc);
  35
  36 }
  37 static int smfs_writepage(struct page *page)
  38 {
  39
  40         struct  inode *inode = page->mapping->host;
  41         struct  inode *cache_inode;
  42         int     rc;
  43
  44         ENTRY;
  45
  46         cache_inode = I2CI(inode);
  47
  48         if (!cache_inode)
  49                 RETURN(-ENOENT);
  50
  51         if (cache_inode->i_mapping->a_ops->writepage)
  52                 rc = cache_inode->i_mapping->a_ops->writepage(page);
  53
  54         RETURN(rc);
  55
  56 }
  57 struct address_space_operations smfs_file_aops = {
  58         readpage:   smfs_readpage,
  59         writepage:  smfs_writepage,
  60 };
  61
  62
  63 static ssize_t smfs_write (struct file *filp, const char *buf,
  64                            size_t count, loff_t *ppos)
  65 {
  66         struct  inode *cache_inode;
  67         struct  dentry *dentry = filp->f_dentry;
  68         int     rc;
  69
  70         ENTRY;
  71
  72         cache_inode = I2CI(dentry->d_inode);
  73
  74         if (!cache_inode)
  75                 RETURN(-ENOENT);
  76
  77         if (cache_inode->i_fop->write)
  78                 cache_inode->i_fop->write(filp, buf, count, ppos);
  79
  80         RETURN(rc);
  81 }
  82
  83 static ssize_t smfs_read (struct file *filp, char *buf,
  84                           size_t count, loff_t *ppos)
  85 {
  86         struct  inode *cache_inode;
  87         struct  dentry *dentry = filp->f_dentry;
  88         ssize_t rc;
  89
  90         ENTRY;
  91
  92         cache_inode = I2CI(dentry->d_inode);
  93
  94         if (!cache_inode)
  95                 RETURN(-ENOENT);
  96
  97         if (cache_inode->i_fop->read)
  98                 rc = cache_inode->i_fop->read(filp, buf, count, ppos);
  99
 100         RETURN(rc);
 101 }
 102
 103 struct file_operations smfs_file_fops = {
 104         read:   smfs_read,
 105         write:  smfs_write,
 106 };
 107
 108 static void smfs_truncate(struct inode * inode)
 109 {
 110         struct  inode *cache_inode;
 111
 112         cache_inode = I2CI(inode);
 113
 114         if (!cache_inode)
 115                 return;
 116
 117         if (cache_inode->i_op->truncate)
 118                 cache_inode->i_op->truncate(cache_inode);
 119
 120         duplicate(inode, cache_inode);
 121
 122         return;
 123 }
 124
 125 static int smfs_setattr(struct dentry *dentry, struct iattr *attr)
 126 {
 127         struct  inode *cache_inode;
 128         int     rc = 0;
 129
 130         cache_inode = I2CI(dentry->d_inode);
 131
 132         if (!cache_inode)
 133                 RETURN(-ENOENT);
 134
 135         if (cache_inode->i_op->setattr)
 136                 rc = cache_inode->i_op->setattr(dentry, attr);
 137
 138         RETURN(rc);
 139 }
 140
 141 struct inode_operations smfs_file_iops = {
 142         truncate:       smfs_truncate,          /* BKL held */
 143         setattr:        smfs_setattr,           /* BKL held */
 144 };
 145