git.openpandora.org / pandora-kernel.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
CRED: Use creds in file structs
[pandora-kernel.git] / fs / coda / file.c
diff --git a/fs/coda/file.c b/fs/coda/file.c
index dbfbcfa..5a87699 100644 (file)
--- a/fs/coda/file.c
+++ b/fs/coda/file.c
@@ -22,14 +22,9 @@
 #include <linux/coda_linux.h>
 #include <linux/coda_fs_i.h>
 #include <linux/coda_psdev.h>
-#include <linux/coda_proc.h>
 
 #include "coda_int.h"
 
-/* if CODA_STORE fails with EOPNOTSUPP, venus clearly doesn't support
- * CODA_STORE/CODA_RELEASE and we fall back on using the CODA_CLOSE upcall */
-static int use_coda_close;
-
 static ssize_t
 coda_file_read(struct file *coda_file, char __user *buf, size_t count, loff_t *ppos)
 {
@@ -47,8 +42,9 @@ coda_file_read(struct file *coda_file, char __user *buf, size_t count, loff_t *p
 }
 
 static ssize_t
-coda_file_sendfile(struct file *coda_file, loff_t *ppos, size_t count,
-                  read_actor_t actor, void *target)
+coda_file_splice_read(struct file *coda_file, loff_t *ppos,
+                     struct pipe_inode_info *pipe, size_t count,
+                     unsigned int flags)
 {
        struct coda_file_info *cfi;
        struct file *host_file;
@@ -57,16 +53,16 @@ coda_file_sendfile(struct file *coda_file, loff_t *ppos, size_t count,
        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
        host_file = cfi->cfi_container;
 
-       if (!host_file->f_op || !host_file->f_op->sendfile)
+       if (!host_file->f_op || !host_file->f_op->splice_read)
                return -EINVAL;
 
-       return host_file->f_op->sendfile(host_file, ppos, count, actor, target);
+       return host_file->f_op->splice_read(host_file, ppos, pipe, count,flags);
 }
 
 static ssize_t
 coda_file_write(struct file *coda_file, const char __user *buf, size_t count, loff_t *ppos)
 {
-       struct inode *host_inode, *coda_inode = coda_file->f_dentry->d_inode;
+       struct inode *host_inode, *coda_inode = coda_file->f_path.dentry->d_inode;
        struct coda_file_info *cfi;
        struct file *host_file;
        ssize_t ret;
@@ -78,7 +74,7 @@ coda_file_write(struct file *coda_file, const char __user *buf, size_t count, lo
        if (!host_file->f_op || !host_file->f_op->write)
                return -EINVAL;
 
-       host_inode = host_file->f_dentry->d_inode;
+       host_inode = host_file->f_path.dentry->d_inode;
        mutex_lock(&coda_inode->i_mutex);
 
        ret = host_file->f_op->write(host_file, buf, count, ppos);
@@ -106,8 +102,8 @@ coda_file_mmap(struct file *coda_file, struct vm_area_struct *vma)
        if (!host_file->f_op || !host_file->f_op->mmap)
                return -ENODEV;
 
-       coda_inode = coda_file->f_dentry->d_inode;
-       host_inode = host_file->f_dentry->d_inode;
+       coda_inode = coda_file->f_path.dentry->d_inode;
+       host_inode = host_file->f_path.dentry->d_inode;
        coda_file->f_mapping = host_file->f_mapping;
        if (coda_inode->i_mapping == &coda_inode->i_data)
                coda_inode->i_mapping = host_inode->i_mapping;
@@ -133,8 +129,6 @@ int coda_open(struct inode *coda_inode, struct file *coda_file)
        unsigned short coda_flags = coda_flags_to_cflags(flags);
        struct coda_file_info *cfi;
 
-       coda_vfs_stat.open++;
-
        cfi = kmalloc(sizeof(struct coda_file_info), GFP_KERNEL);
        if (!cfi)
                return -ENOMEM;
@@ -142,8 +136,11 @@ int coda_open(struct inode *coda_inode, struct file *coda_file)
        lock_kernel();
 
        error = venus_open(coda_inode->i_sb, coda_i2f(coda_inode), coda_flags,
-                          &host_file); 
-       if (error || !host_file) {
+                          &host_file);
+       if (!host_file)
+               error = -EIO;
+
+       if (error) {
                kfree(cfi);
                unlock_kernel();
                return error;
@@ -162,49 +159,6 @@ int coda_open(struct inode *coda_inode, struct file *coda_file)
        return 0;
 }
 
-int coda_flush(struct file *coda_file, fl_owner_t id)
-{
-       unsigned short flags = coda_file->f_flags & ~O_EXCL;
-       unsigned short coda_flags = coda_flags_to_cflags(flags);
-       struct coda_file_info *cfi;
-       struct inode *coda_inode;
-       int err = 0, fcnt;
-
-       lock_kernel();
-
-       coda_vfs_stat.flush++;
-
-       /* last close semantics */
-       fcnt = file_count(coda_file);
-       if (fcnt > 1)
-               goto out;
-
-       /* No need to make an upcall when we have not made any modifications
-        * to the file */
-       if ((coda_file->f_flags & O_ACCMODE) == O_RDONLY)
-               goto out;
-
-       if (use_coda_close)
-               goto out;
-
-       cfi = CODA_FTOC(coda_file);
-       BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
-
-       coda_inode = coda_file->f_dentry->d_inode;
-
-       err = venus_store(coda_inode->i_sb, coda_i2f(coda_inode), coda_flags,
-                         coda_file->f_uid);
-
-       if (err == -EOPNOTSUPP) {
-               use_coda_close = 1;
-               err = 0;
-       }
-
-out:
-       unlock_kernel();
-       return err;
-}
-
 int coda_release(struct inode *coda_inode, struct file *coda_file)
 {
        unsigned short flags = (coda_file->f_flags) & (~O_EXCL);
@@ -215,25 +169,14 @@ int coda_release(struct inode *coda_inode, struct file *coda_file)
        int err = 0;
 
        lock_kernel();
-       coda_vfs_stat.release++;
- 
-       if (!use_coda_close) {
-               err = venus_release(coda_inode->i_sb, coda_i2f(coda_inode),
-                                   coda_flags);
-               if (err == -EOPNOTSUPP) {
-                       use_coda_close = 1;
-                       err = 0;
-               }
-       }
 
        cfi = CODA_FTOC(coda_file);
        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
 
-       if (use_coda_close)
-               err = venus_close(coda_inode->i_sb, coda_i2f(coda_inode),
-                                 coda_flags, coda_file->f_uid);
+       err = venus_close(coda_inode->i_sb, coda_i2f(coda_inode),
+                         coda_flags, coda_file->f_cred->fsuid);
 
-       host_inode = cfi->cfi_container->f_dentry->d_inode;
+       host_inode = cfi->cfi_container->f_path.dentry->d_inode;
        cii = ITOC(coda_inode);
 
        /* did we mmap this file? */
@@ -248,7 +191,10 @@ int coda_release(struct inode *coda_inode, struct file *coda_file)
        coda_file->private_data = NULL;
 
        unlock_kernel();
-       return err;
+
+       /* VFS fput ignores the return value from file_operations->release, so
+        * there is no use returning an error here */
+       return 0;
 }
 
 int coda_fsync(struct file *coda_file, struct dentry *coda_dentry, int datasync)
@@ -267,10 +213,8 @@ int coda_fsync(struct file *coda_file, struct dentry *coda_dentry, int datasync)
        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
        host_file = cfi->cfi_container;
 
-       coda_vfs_stat.fsync++;
-
        if (host_file->f_op && host_file->f_op->fsync) {
-               host_dentry = host_file->f_dentry;
+               host_dentry = host_file->f_path.dentry;
                host_inode = host_dentry->d_inode;
                mutex_lock(&host_inode->i_mutex);
                err = host_file->f_op->fsync(host_file, host_dentry, datasync);
@@ -292,9 +236,8 @@ const struct file_operations coda_file_operations = {
        .write          = coda_file_write,
        .mmap           = coda_file_mmap,
        .open           = coda_open,
-       .flush          = coda_flush,
        .release        = coda_release,
        .fsync          = coda_fsync,
-       .sendfile       = coda_file_sendfile,
+       .splice_read    = coda_file_splice_read,
 };
 
Pandora Kernel Repository