Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client

Pull Ceph updates from Sage Weil:
 "There is a lot of refactoring and hardening of the libceph and rbd
  code here from Ilya that fix various smaller bugs, and a few more
  important fixes with clone overlap.  The main fix is a critical change
  to the request_fn handling to not sleep that was exposed by the recent
  mutex changes (which will also go to the 3.16 stable series).

  Yan Zheng has several fixes in here for CephFS fixing ACL handling,
  time stamps, and request resends when the MDS restarts.

  Finally, there are a few cleanups from Himangi Saraogi based on
  Coccinelle"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client: (39 commits)
  libceph: set last_piece in ceph_msg_data_pages_cursor_init() correctly
  rbd: remove extra newlines from rbd_warn() messages
  rbd: allocate img_request with GFP_NOIO instead GFP_ATOMIC
  rbd: rework rbd_request_fn()
  ceph: fix kick_requests()
  ceph: fix append mode write
  ceph: fix sizeof(struct tYpO *) typo
  ceph: remove redundant memset(0)
  rbd: take snap_id into account when reading in parent info
  rbd: do not read in parent info before snap context
  rbd: update mapping size only on refresh
  rbd: harden rbd_dev_refresh() and callers a bit
  rbd: split rbd_dev_spec_update() into two functions
  rbd: remove unnecessary asserts in rbd_dev_image_probe()
  rbd: introduce rbd_dev_header_info()
  rbd: show the entire chain of parent images
  ceph: replace comma with a semicolon
  rbd: use rbd_segment_name_free() instead of kfree()
  ceph: check zero length in ceph_sync_read()
  ceph: reset r_resend_mds after receiving -ESTALE
  ...

5 files changed, 43 insertions, 17 deletions

diff --git a/fs/ceph/acl.c b/fs/ceph/acl.c
index 469f2e8657e8..cebf2ebefb55 100644
--- a/fs/ceph/acl.c
+++ b/fs/ceph/acl.c
@@ -172,14 +172,24 @@ out:
 int ceph_init_acl(struct dentry *dentry, struct inode *inode, struct inode *dir)
 {
         struct posix_acl *default_acl, *acl;
+        umode_t new_mode = inode->i_mode;
         int error;
 
-        error = posix_acl_create(dir, &inode->i_mode, &default_acl, &acl);
+        error = posix_acl_create(dir, &new_mode, &default_acl, &acl);
         if (error)
                 return error;
 
-        if (!default_acl && !acl)
+        if (!default_acl && !acl) {
                 cache_no_acl(inode);
+                if (new_mode != inode->i_mode) {
+                        struct iattr newattrs = {
+                                .ia_mode = new_mode,
+                                .ia_valid = ATTR_MODE,
+                        };
+                        error = ceph_setattr(dentry, &newattrs);
+                }
+                return error;
+        }
 
         if (default_acl) {
                 error = ceph_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
diff --git a/fs/ceph/caps.c b/fs/ceph/caps.c
index 1fde164b74b5..6d1cd45dca89 100644
--- a/fs/ceph/caps.c
+++ b/fs/ceph/caps.c
@@ -3277,7 +3277,7 @@ int ceph_encode_inode_release(void **p, struct inode *inode,
                         rel->ino = cpu_to_le64(ceph_ino(inode));
                         rel->cap_id = cpu_to_le64(cap->cap_id);
                         rel->seq = cpu_to_le32(cap->seq);
-                        rel->issue_seq = cpu_to_le32(cap->issue_seq),
+                        rel->issue_seq = cpu_to_le32(cap->issue_seq);
                         rel->mseq = cpu_to_le32(cap->mseq);
                         rel->caps = cpu_to_le32(cap->implemented);
                         rel->wanted = cpu_to_le32(cap->mds_wanted);
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index 302085100c28..2eb02f80a0ab 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -423,6 +423,9 @@ static ssize_t ceph_sync_read(struct kiocb *iocb, struct iov_iter *i,
         dout("sync_read on file %p %llu~%u %s\n", file, off,
              (unsigned)len,
              (file->f_flags & O_DIRECT) ? "O_DIRECT" : "");
+
+        if (!len)
+                return 0;
         /*
          * flush any page cache pages in this range.  this
          * will make concurrent normal and sync io slow,
@@ -470,8 +473,11 @@ static ssize_t ceph_sync_read(struct kiocb *iocb, struct iov_iter *i,
                         size_t left = ret;
 
                         while (left) {
-                                int copy = min_t(size_t, PAGE_SIZE, left);
-                                l = copy_page_to_iter(pages[k++], 0, copy, i);
+                                size_t page_off = off & ~PAGE_MASK;
+                                size_t copy = min_t(size_t,
+                                                    PAGE_SIZE - page_off, left);
+                                l = copy_page_to_iter(pages[k++], page_off,
+                                                      copy, i);
                                 off += l;
                                 left -= l;
                                 if (l < copy)
@@ -531,7 +537,7 @@ static void ceph_sync_write_unsafe(struct ceph_osd_request *req, bool unsafe)
  * objects, rollback on failure, etc.)
  */
 static ssize_t
-ceph_sync_direct_write(struct kiocb *iocb, struct iov_iter *from)
+ceph_sync_direct_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos)
 {
         struct file *file = iocb->ki_filp;
         struct inode *inode = file_inode(file);
@@ -547,7 +553,6 @@ ceph_sync_direct_write(struct kiocb *iocb, struct iov_iter *from)
         int check_caps = 0;
         int ret;
         struct timespec mtime = CURRENT_TIME;
-        loff_t pos = iocb->ki_pos;
         size_t count = iov_iter_count(from);
 
         if (ceph_snap(file_inode(file)) != CEPH_NOSNAP)
@@ -646,7 +651,8 @@ ceph_sync_direct_write(struct kiocb *iocb, struct iov_iter *from)
  * correct atomic write, we should e.g. take write locks on all
  * objects, rollback on failure, etc.)
  */
-static ssize_t ceph_sync_write(struct kiocb *iocb, struct iov_iter *from)
+static ssize_t
+ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos)
 {
         struct file *file = iocb->ki_filp;
         struct inode *inode = file_inode(file);
@@ -663,7 +669,6 @@ static ssize_t ceph_sync_write(struct kiocb *iocb, struct iov_iter *from)
         int check_caps = 0;
         int ret;
         struct timespec mtime = CURRENT_TIME;
-        loff_t pos = iocb->ki_pos;
         size_t count = iov_iter_count(from);
 
         if (ceph_snap(file_inode(file)) != CEPH_NOSNAP)
@@ -918,9 +923,9 @@ retry_snap:
                 /* we might need to revert back to that point */
                 data = *from;
                 if (file->f_flags & O_DIRECT)
-                        written = ceph_sync_direct_write(iocb, &data);
+                        written = ceph_sync_direct_write(iocb, &data, pos);
                 else
-                        written = ceph_sync_write(iocb, &data);
+                        written = ceph_sync_write(iocb, &data, pos);
                 if (written == -EOLDSNAPC) {
                         dout("aio_write %p %llx.%llx %llu~%u"
                                 "got EOLDSNAPC, retrying\n",
@@ -1177,6 +1182,9 @@ static long ceph_fallocate(struct file *file, int mode,
         loff_t endoff = 0;
         loff_t size;
 
+        if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
+                return -EOPNOTSUPP;
+
         if (!S_ISREG(inode->i_mode))
                 return -EOPNOTSUPP;
 
diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c
index 92a2548278fc..bad07c09f91e 100644
--- a/fs/ceph/mds_client.c
+++ b/fs/ceph/mds_client.c
@@ -1904,6 +1904,7 @@ static int __prepare_send_request(struct ceph_mds_client *mdsc,
              req->r_tid, ceph_mds_op_name(req->r_op), req->r_attempts);
 
         if (req->r_got_unsafe) {
+                void *p;
                 /*
                  * Replay.  Do not regenerate message (and rebuild
                  * paths, etc.); just use the original message.
@@ -1924,8 +1925,13 @@ static int __prepare_send_request(struct ceph_mds_client *mdsc,
 
                 /* remove cap/dentry releases from message */
                 rhead->num_releases = 0;
-                msg->hdr.front_len = cpu_to_le32(req->r_request_release_offset);
-                msg->front.iov_len = req->r_request_release_offset;
+
+                /* time stamp */
+                p = msg->front.iov_base + req->r_request_release_offset;
+                ceph_encode_copy(&p, &req->r_stamp, sizeof(req->r_stamp));
+
+                msg->front.iov_len = p - msg->front.iov_base;
+                msg->hdr.front_len = cpu_to_le32(msg->front.iov_len);
                 return 0;
         }
 
@@ -2061,11 +2067,12 @@ static void __wake_requests(struct ceph_mds_client *mdsc,
 static void kick_requests(struct ceph_mds_client *mdsc, int mds)
 {
         struct ceph_mds_request *req;
-        struct rb_node *p;
+        struct rb_node *p = rb_first(&mdsc->request_tree);
 
         dout("kick_requests mds%d\n", mds);
-        for (p = rb_first(&mdsc->request_tree); p; p = rb_next(p)) {
+        while (p) {
                 req = rb_entry(p, struct ceph_mds_request, r_node);
+                p = rb_next(p);
                 if (req->r_got_unsafe)
                         continue;
                 if (req->r_session &&
@@ -2248,6 +2255,7 @@ static void handle_reply(struct ceph_mds_session *session, struct ceph_msg *msg)
          */
         if (result == -ESTALE) {
                 dout("got ESTALE on request %llu", req->r_tid);
+                req->r_resend_mds = -1;
                 if (req->r_direct_mode != USE_AUTH_MDS) {
                         dout("not using auth, setting for that now");
                         req->r_direct_mode = USE_AUTH_MDS;
diff --git a/fs/ceph/xattr.c b/fs/ceph/xattr.c
index c9c2b887381e..12f58d22e017 100644
--- a/fs/ceph/xattr.c
+++ b/fs/ceph/xattr.c
@@ -592,12 +592,12 @@ start:
                 xattr_version = ci->i_xattrs.version;
                 spin_unlock(&ci->i_ceph_lock);
 
-                xattrs = kcalloc(numattr, sizeof(struct ceph_xattr *),
+                xattrs = kcalloc(numattr, sizeof(struct ceph_inode_xattr *),
                                  GFP_NOFS);
                 err = -ENOMEM;
                 if (!xattrs)
                         goto bad_lock;
-                memset(xattrs, 0, numattr*sizeof(struct ceph_xattr *));
+
                 for (i = 0; i < numattr; i++) {
                         xattrs[i] = kmalloc(sizeof(struct ceph_inode_xattr),
                                             GFP_NOFS);