Patched in Tegra support.

1 files changed, 90 insertions, 85 deletions

diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index e51558fca3a..ce549d31eeb 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -4,7 +4,6 @@
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/file.h>
-#include <linux/mount.h>
 #include <linux/namei.h>
 #include <linux/writeback.h>
 
@@ -55,6 +54,7 @@ prepare_open_request(struct super_block *sb, int flags, int create_mode)
         req->r_fmode = ceph_flags_to_mode(flags);
         req->r_args.open.flags = cpu_to_le32(flags);
         req->r_args.open.mode = cpu_to_le32(create_mode);
+        req->r_args.open.preferred = cpu_to_le32(-1);
 out:
         return req;
 }
@@ -107,6 +107,9 @@ static int ceph_init_file(struct inode *inode, struct file *file, int fmode)
 }
 
 /*
+ * If the filp already has private_data, that means the file was
+ * already opened by intent during lookup, and we do nothing.
+ *
  * If we already have the requisite capabilities, we can satisfy
  * the open request locally (no need to request new caps from the
  * MDS).  We do, however, need to inform the MDS (asynchronously)
@@ -144,9 +147,9 @@ int ceph_open(struct inode *inode, struct file *file)
 
         /* trivially open snapdir */
         if (ceph_snap(inode) == CEPH_SNAPDIR) {
-                spin_lock(&ci->i_ceph_lock);
+                spin_lock(&inode->i_lock);
                 __ceph_get_fmode(ci, fmode);
-                spin_unlock(&ci->i_ceph_lock);
+                spin_unlock(&inode->i_lock);
                 return ceph_init_file(inode, file, fmode);
         }
 
@@ -155,7 +158,7 @@ int ceph_open(struct inode *inode, struct file *file)
          * write) or any MDS (for read).  Update wanted set
          * asynchronously.
          */
-        spin_lock(&ci->i_ceph_lock);
+        spin_lock(&inode->i_lock);
         if (__ceph_is_any_real_caps(ci) &&
             (((fmode & CEPH_FILE_MODE_WR) == 0) || ci->i_auth_cap)) {
                 int mds_wanted = __ceph_caps_mds_wanted(ci);
@@ -165,7 +168,7 @@ int ceph_open(struct inode *inode, struct file *file)
                      inode, fmode, ceph_cap_string(wanted),
                      ceph_cap_string(issued));
                 __ceph_get_fmode(ci, fmode);
-                spin_unlock(&ci->i_ceph_lock);
+                spin_unlock(&inode->i_lock);
 
                 /* adjust wanted? */
                 if ((issued & wanted) != wanted &&
@@ -177,10 +180,10 @@ int ceph_open(struct inode *inode, struct file *file)
         } else if (ceph_snap(inode) != CEPH_NOSNAP &&
                    (ci->i_snap_caps & wanted) == wanted) {
                 __ceph_get_fmode(ci, fmode);
-                spin_unlock(&ci->i_ceph_lock);
+                spin_unlock(&inode->i_lock);
                 return ceph_init_file(inode, file, fmode);
         }
-        spin_unlock(&ci->i_ceph_lock);
+        spin_unlock(&inode->i_lock);
 
         dout("open fmode %d wants %s\n", fmode, ceph_cap_string(wanted));
         req = prepare_open_request(inode->i_sb, flags, 0);
@@ -205,34 +208,36 @@ out:
 
 
 /*
- * Do a lookup + open with a single request.  If we get a non-existent
- * file or symlink, return 1 so the VFS can retry.
+ * Do a lookup + open with a single request.
+ *
+ * If this succeeds, but some subsequent check in the vfs
+ * may_open() fails, the struct *file gets cleaned up (i.e.
+ * ceph_release gets called).  So fear not!
+ */
+/*
+ * flags
+ *  path_lookup_open   -> LOOKUP_OPEN
+ *  path_lookup_create -> LOOKUP_OPEN|LOOKUP_CREATE
  */
-int ceph_atomic_open(struct inode *dir, struct dentry *dentry,
-                     struct file *file, unsigned flags, umode_t mode,
-                     int *opened)
+struct dentry *ceph_lookup_open(struct inode *dir, struct dentry *dentry,
+                                struct nameidata *nd, int mode,
+                                int locked_dir)
 {
         struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb);
         struct ceph_mds_client *mdsc = fsc->mdsc;
+        struct file *file;
         struct ceph_mds_request *req;
-        struct dentry *dn;
+        struct dentry *ret;
         int err;
+        int flags = nd->intent.open.flags;
 
-        dout("atomic_open %p dentry %p '%.*s' %s flags %d mode 0%o\n",
-             dir, dentry, dentry->d_name.len, dentry->d_name.name,
-             d_unhashed(dentry) ? "unhashed" : "hashed", flags, mode);
-
-        if (dentry->d_name.len > NAME_MAX)
-                return -ENAMETOOLONG;
-
-        err = ceph_init_dentry(dentry);
-        if (err < 0)
-                return err;
+        dout("ceph_lookup_open dentry %p '%.*s' flags %d mode 0%o\n",
+             dentry, dentry->d_name.len, dentry->d_name.name, flags, mode);
 
         /* do the open */
         req = prepare_open_request(dir->i_sb, flags, mode);
         if (IS_ERR(req))
-                return PTR_ERR(req);
+                return ERR_CAST(req);
         req->r_dentry = dget(dentry);
         req->r_num_caps = 2;
         if (flags & O_CREAT) {
@@ -244,32 +249,20 @@ int ceph_atomic_open(struct inode *dir, struct dentry *dentry,
                                    (flags & (O_CREAT|O_TRUNC)) ? dir : NULL,
                                    req);
         err = ceph_handle_snapdir(req, dentry, err);
-        if (err == 0 && (flags & O_CREAT) && !req->r_reply_info.head->is_dentry)
+        if (err)
+                goto out;
+        if ((flags & O_CREAT) && !req->r_reply_info.head->is_dentry)
                 err = ceph_handle_notrace_create(dir, dentry);
-
-        if (d_unhashed(dentry)) {
-                dn = ceph_finish_lookup(req, dentry, err);
-                if (IS_ERR(dn))
-                        err = PTR_ERR(dn);
-        } else {
-                /* we were given a hashed negative dentry */
-                dn = NULL;
-        }
         if (err)
-                goto out_err;
-        if (dn || dentry->d_inode == NULL || S_ISLNK(dentry->d_inode->i_mode)) {
-                /* make vfs retry on splice, ENOENT, or symlink */
-                dout("atomic_open finish_no_open on dn %p\n", dn);
-                err = finish_no_open(file, dn);
-        } else {
-                dout("atomic_open finish_open on dn %p\n", dn);
-                err = finish_open(file, dentry, ceph_open, opened);
-        }
-
-out_err:
+                goto out;
+        file = lookup_instantiate_filp(nd, req->r_dentry, ceph_open);
+        if (IS_ERR(file))
+                err = PTR_ERR(file);
+out:
+        ret = ceph_finish_lookup(req, dentry, err);
         ceph_mdsc_put_request(req);
-        dout("atomic_open result=%d\n", err);
-        return err;
+        dout("ceph_lookup_open result=%p\n", ret);
+        return ret;
 }
 
 int ceph_release(struct inode *inode, struct file *file)
@@ -536,8 +529,8 @@ more:
                                     do_sync,
                                     ci->i_truncate_seq, ci->i_truncate_size,
                                     &mtime, false, 2, page_align);
-        if (IS_ERR(req))
-                return PTR_ERR(req);
+        if (!req)
+                return -ENOMEM;
 
         if (file->f_flags & O_DIRECT) {
                 pages = ceph_get_direct_page_vector(data, num_pages, false);
@@ -712,65 +705,78 @@ static ssize_t ceph_aio_write(struct kiocb *iocb, const struct iovec *iov,
         struct ceph_osd_client *osdc =
                 &ceph_sb_to_client(inode->i_sb)->client->osdc;
         loff_t endoff = pos + iov->iov_len;
-        int got = 0;
-        int ret, err, written;
+        int want, got = 0;
+        int ret, err;
 
         if (ceph_snap(inode) != CEPH_NOSNAP)
                 return -EROFS;
 
 retry_snap:
-        written = 0;
         if (ceph_osdmap_flag(osdc->osdmap, CEPH_OSDMAP_FULL))
                 return -ENOSPC;
         __ceph_do_pending_vmtruncate(inode);
+        dout("aio_write %p %llx.%llx %llu~%u getting caps. i_size %llu\n",
+             inode, ceph_vinop(inode), pos, (unsigned)iov->iov_len,
+             inode->i_size);
+        if (fi->fmode & CEPH_FILE_MODE_LAZY)
+                want = CEPH_CAP_FILE_BUFFER | CEPH_CAP_FILE_LAZYIO;
+        else
+                want = CEPH_CAP_FILE_BUFFER;
+        ret = ceph_get_caps(ci, CEPH_CAP_FILE_WR, want, &got, endoff);
+        if (ret < 0)
+                goto out_put;
 
-        /*
-         * try to do a buffered write.  if we don't have sufficient
-         * caps, we'll get -EAGAIN from generic_file_aio_write, or a
-         * short write if we only get caps for some pages.
-         */
-        if (!(iocb->ki_filp->f_flags & O_DIRECT) &&
-            !(inode->i_sb->s_flags & MS_SYNCHRONOUS) &&
-            !(fi->flags & CEPH_F_SYNC)) {
-                ret = generic_file_aio_write(iocb, iov, nr_segs, pos);
-                if (ret >= 0)
-                        written = ret;
+        dout("aio_write %p %llx.%llx %llu~%u  got cap refs on %s\n",
+             inode, ceph_vinop(inode), pos, (unsigned)iov->iov_len,
+             ceph_cap_string(got));
 
+        if ((got & (CEPH_CAP_FILE_BUFFER|CEPH_CAP_FILE_LAZYIO)) == 0 ||
+            (iocb->ki_filp->f_flags & O_DIRECT) ||
+            (inode->i_sb->s_flags & MS_SYNCHRONOUS) ||
+            (fi->flags & CEPH_F_SYNC)) {
+                ret = ceph_sync_write(file, iov->iov_base, iov->iov_len,
+                        &iocb->ki_pos);
+        } else {
+                /*
+                 * buffered write; drop Fw early to avoid slow
+                 * revocation if we get stuck on balance_dirty_pages
+                 */
+                int dirty;
+
+                spin_lock(&inode->i_lock);
+                dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_FILE_WR);
+                spin_unlock(&inode->i_lock);
+                ceph_put_cap_refs(ci, got);
+
+                ret = generic_file_aio_write(iocb, iov, nr_segs, pos);
                 if ((ret >= 0 || ret == -EIOCBQUEUED) &&
                     ((file->f_flags & O_SYNC) || IS_SYNC(file->f_mapping->host)
                      || ceph_osdmap_flag(osdc->osdmap, CEPH_OSDMAP_NEARFULL))) {
-                        err = vfs_fsync_range(file, pos, pos + written - 1, 1);
+                        err = vfs_fsync_range(file, pos, pos + ret - 1, 1);
                         if (err < 0)
                                 ret = err;
                 }
-                if ((ret < 0 && ret != -EAGAIN) || pos + written >= endoff)
-                        goto out;
-        }
 
-        dout("aio_write %p %llx.%llx %llu~%u getting caps. i_size %llu\n",
-             inode, ceph_vinop(inode), pos + written,
-             (unsigned)iov->iov_len - written, inode->i_size);
-        ret = ceph_get_caps(ci, CEPH_CAP_FILE_WR, 0, &got, endoff);
-        if (ret < 0)
+                if (dirty)
+                        __mark_inode_dirty(inode, dirty);
                 goto out;
+        }
 
-        dout("aio_write %p %llx.%llx %llu~%u  got cap refs on %s\n",
-             inode, ceph_vinop(inode), pos + written,
-             (unsigned)iov->iov_len - written, ceph_cap_string(got));
-        ret = ceph_sync_write(file, iov->iov_base + written,
-                              iov->iov_len - written, &iocb->ki_pos);
         if (ret >= 0) {
                 int dirty;
-                spin_lock(&ci->i_ceph_lock);
+                spin_lock(&inode->i_lock);
                 dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_FILE_WR);
-                spin_unlock(&ci->i_ceph_lock);
+                spin_unlock(&inode->i_lock);
                 if (dirty)
                         __mark_inode_dirty(inode, dirty);
         }
+
+out_put:
         dout("aio_write %p %llx.%llx %llu~%u  dropping cap refs on %s\n",
-             inode, ceph_vinop(inode), pos + written,
-             (unsigned)iov->iov_len - written, ceph_cap_string(got));
+             inode, ceph_vinop(inode), pos, (unsigned)iov->iov_len,
+             ceph_cap_string(got));
         ceph_put_cap_refs(ci, got);
+
 out:
         if (ret == -EOLDSNAPC) {
                 dout("aio_write %p %llx.%llx %llu~%u got EOLDSNAPC, retrying\n",
@@ -784,15 +790,14 @@ out:
 /*
  * llseek.  be sure to verify file size on SEEK_END.
  */
-static loff_t ceph_llseek(struct file *file, loff_t offset, int whence)
+static loff_t ceph_llseek(struct file *file, loff_t offset, int origin)
 {
         struct inode *inode = file->f_mapping->host;
         int ret;
 
         mutex_lock(&inode->i_mutex);
         __ceph_do_pending_vmtruncate(inode);
-
-        if (whence == SEEK_END || whence == SEEK_DATA || whence == SEEK_HOLE) {
+        if (origin != SEEK_CUR || origin != SEEK_SET) {
                 ret = ceph_do_getattr(inode, CEPH_STAT_CAP_SIZE);
                 if (ret < 0) {
                         offset = ret;
@@ -800,7 +805,7 @@ static loff_t ceph_llseek(struct file *file, loff_t offset, int whence)
                 }
         }
 
-        switch (whence) {
+        switch (origin) {
         case SEEK_END:
                 offset += inode->i_size;
                 break;