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

Pull Ceph update from Sage Weil:
 "There are a few different groups of commits here.  The largest is
  Alex's ongoing work to enable the coming RBD features (cloning,
  striping).  There is some cleanup in libceph that goes along with it.

  Cyril and David have fixed some problems with NFS reexport (leaking
  dentries and page locks), and there is a batch of patches from Yan
  fixing problems with the fs client when running against a clustered
  MDS.  There are a few bug fixes mixed in for good measure, many of
  which will be going to the stable trees once they're upstream.

  My apologies for the late pull.  There is still a gremlin in the rbd
  map/unmap code and I was hoping to include the fix for that as well,
  but we haven't been able to confirm the fix is correct yet; I'll send
  that in a separate pull once it's nailed down."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client: (68 commits)
  rbd: get rid of rbd_{get,put}_dev()
  libceph: register request before unregister linger
  libceph: don't use rb_init_node() in ceph_osdc_alloc_request()
  libceph: init event->node in ceph_osdc_create_event()
  libceph: init osd->o_node in create_osd()
  libceph: report connection fault with warning
  libceph: socket can close in any connection state
  rbd: don't use ENOTSUPP
  rbd: remove linger unconditionally
  rbd: get rid of RBD_MAX_SEG_NAME_LEN
  libceph: avoid using freed osd in __kick_osd_requests()
  ceph: don't reference req after put
  rbd: do not allow remove of mounted-on image
  libceph: Unlock unprocessed pages in start_read() error path
  ceph: call handle_cap_grant() for cap import message
  ceph: Fix __ceph_do_pending_vmtruncate
  ceph: Don't add dirty inode to dirty list if caps is in migration
  ceph: Fix infinite loop in __wake_requests
  ceph: Don't update i_max_size when handling non-auth cap
  bdi_register: add __printf verification, fix arg mismatch
  ...

6 files changed, 116 insertions, 65 deletions

diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index 6690269f5dde..064d1a68d2c1 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -267,6 +267,14 @@ static void finish_read(struct ceph_osd_request *req, struct ceph_msg *msg)
         kfree(req->r_pages);
 }
 
+static void ceph_unlock_page_vector(struct page **pages, int num_pages)
+{
+        int i;
+
+        for (i = 0; i < num_pages; i++)
+                unlock_page(pages[i]);
+}
+
 /*
  * start an async read(ahead) operation.  return nr_pages we submitted
  * a read for on success, or negative error code.
@@ -347,6 +355,7 @@ static int start_read(struct inode *inode, struct list_head *page_list, int max)
         return nr_pages;
 
 out_pages:
+        ceph_unlock_page_vector(pages, nr_pages);
         ceph_release_page_vector(pages, nr_pages);
 out:
         ceph_osdc_put_request(req);
@@ -1078,23 +1087,51 @@ static int ceph_write_begin(struct file *file, struct address_space *mapping,
                             struct page **pagep, void **fsdata)
 {
         struct inode *inode = file->f_dentry->d_inode;
+        struct ceph_inode_info *ci = ceph_inode(inode);
+        struct ceph_file_info *fi = file->private_data;
         struct page *page;
         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
-        int r;
+        int r, want, got = 0;
+
+        if (fi->fmode & CEPH_FILE_MODE_LAZY)
+                want = CEPH_CAP_FILE_BUFFER | CEPH_CAP_FILE_LAZYIO;
+        else
+                want = CEPH_CAP_FILE_BUFFER;
+
+        dout("write_begin %p %llx.%llx %llu~%u getting caps. i_size %llu\n",
+             inode, ceph_vinop(inode), pos, len, inode->i_size);
+        r = ceph_get_caps(ci, CEPH_CAP_FILE_WR, want, &got, pos+len);
+        if (r < 0)
+                return r;
+        dout("write_begin %p %llx.%llx %llu~%u  got cap refs on %s\n",
+             inode, ceph_vinop(inode), pos, len, ceph_cap_string(got));
+        if (!(got & (CEPH_CAP_FILE_BUFFER|CEPH_CAP_FILE_LAZYIO))) {
+                ceph_put_cap_refs(ci, got);
+                return -EAGAIN;
+        }
 
         do {
                 /* get a page */
                 page = grab_cache_page_write_begin(mapping, index, 0);
-                if (!page)
-                        return -ENOMEM;
-                *pagep = page;
+                if (!page) {
+                        r = -ENOMEM;
+                        break;
+                }
 
                 dout("write_begin file %p inode %p page %p %d~%d\n", file,
                      inode, page, (int)pos, (int)len);
 
                 r = ceph_update_writeable_page(file, pos, len, page);
+                if (r)
+                        page_cache_release(page);
         } while (r == -EAGAIN);
 
+        if (r) {
+                ceph_put_cap_refs(ci, got);
+        } else {
+                *pagep = page;
+                *(int *)fsdata = got;
+        }
         return r;
 }
 
@@ -1108,10 +1145,12 @@ static int ceph_write_end(struct file *file, struct address_space *mapping,
                           struct page *page, void *fsdata)
 {
         struct inode *inode = file->f_dentry->d_inode;
+        struct ceph_inode_info *ci = ceph_inode(inode);
         struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
         struct ceph_mds_client *mdsc = fsc->mdsc;
         unsigned from = pos & (PAGE_CACHE_SIZE - 1);
         int check_cap = 0;
+        int got = (unsigned long)fsdata;
 
         dout("write_end file %p inode %p page %p %d~%d (%d)\n", file,
              inode, page, (int)pos, (int)copied, (int)len);
@@ -1134,6 +1173,19 @@ static int ceph_write_end(struct file *file, struct address_space *mapping,
         up_read(&mdsc->snap_rwsem);
         page_cache_release(page);
 
+        if (copied > 0) {
+                int dirty;
+                spin_lock(&ci->i_ceph_lock);
+                dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_FILE_WR);
+                spin_unlock(&ci->i_ceph_lock);
+                if (dirty)
+                        __mark_inode_dirty(inode, dirty);
+        }
+
+        dout("write_end %p %llx.%llx %llu~%u  dropping cap refs on %s\n",
+             inode, ceph_vinop(inode), pos, len, ceph_cap_string(got));
+        ceph_put_cap_refs(ci, got);
+
         if (check_cap)
                 ceph_check_caps(ceph_inode(inode), CHECK_CAPS_AUTHONLY, NULL);
 
diff --git a/fs/ceph/caps.c b/fs/ceph/caps.c
index 3251e9cc6401..a1d9bb30c1bf 100644
--- a/fs/ceph/caps.c
+++ b/fs/ceph/caps.c
@@ -236,8 +236,10 @@ static struct ceph_cap *get_cap(struct ceph_mds_client *mdsc,
         if (!ctx) {
                 cap = kmem_cache_alloc(ceph_cap_cachep, GFP_NOFS);
                 if (cap) {
+                        spin_lock(&mdsc->caps_list_lock);
                         mdsc->caps_use_count++;
                         mdsc->caps_total_count++;
+                        spin_unlock(&mdsc->caps_list_lock);
                 }
                 return cap;
         }
@@ -1349,11 +1351,15 @@ int __ceph_mark_dirty_caps(struct ceph_inode_info *ci, int mask)
                 if (!ci->i_head_snapc)
                         ci->i_head_snapc = ceph_get_snap_context(
                                 ci->i_snap_realm->cached_context);
-                dout(" inode %p now dirty snapc %p\n", &ci->vfs_inode,
-                        ci->i_head_snapc);
+                dout(" inode %p now dirty snapc %p auth cap %p\n",
+                     &ci->vfs_inode, ci->i_head_snapc, ci->i_auth_cap);
                 BUG_ON(!list_empty(&ci->i_dirty_item));
                 spin_lock(&mdsc->cap_dirty_lock);
-                list_add(&ci->i_dirty_item, &mdsc->cap_dirty);
+                if (ci->i_auth_cap)
+                        list_add(&ci->i_dirty_item, &mdsc->cap_dirty);
+                else
+                        list_add(&ci->i_dirty_item,
+                                 &mdsc->cap_dirty_migrating);
                 spin_unlock(&mdsc->cap_dirty_lock);
                 if (ci->i_flushing_caps == 0) {
                         ihold(inode);
@@ -2388,7 +2394,7 @@ static void handle_cap_grant(struct inode *inode, struct ceph_mds_caps *grant,
                             &atime);
 
         /* max size increase? */
-        if (max_size != ci->i_max_size) {
+        if (ci->i_auth_cap == cap && max_size != ci->i_max_size) {
                 dout("max_size %lld -> %llu\n", ci->i_max_size, max_size);
                 ci->i_max_size = max_size;
                 if (max_size >= ci->i_wanted_max_size) {
@@ -2745,6 +2751,7 @@ static void handle_cap_import(struct ceph_mds_client *mdsc,
 
         /* make sure we re-request max_size, if necessary */
         spin_lock(&ci->i_ceph_lock);
+        ci->i_wanted_max_size = 0;  /* reset */
         ci->i_requested_max_size = 0;
         spin_unlock(&ci->i_ceph_lock);
 }
@@ -2840,8 +2847,6 @@ void ceph_handle_caps(struct ceph_mds_session *session,
         case CEPH_CAP_OP_IMPORT:
                 handle_cap_import(mdsc, inode, h, session,
                                   snaptrace, snaptrace_len);
-                ceph_check_caps(ceph_inode(inode), 0, session);
-                goto done_unlocked;
         }
 
         /* the rest require a cap */
@@ -2858,6 +2863,7 @@ void ceph_handle_caps(struct ceph_mds_session *session,
         switch (op) {
         case CEPH_CAP_OP_REVOKE:
         case CEPH_CAP_OP_GRANT:
+        case CEPH_CAP_OP_IMPORT:
                 handle_cap_grant(inode, h, session, cap, msg->middle);
                 goto done_unlocked;
 
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index d4dfdcf76d7f..e51558fca3a3 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -712,63 +712,53 @@ 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 want, got = 0;
-        int ret, err;
+        int got = 0;
+        int ret, err, written;
 
         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;
-
-        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(&ci->i_ceph_lock);
-                dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_FILE_WR);
-                spin_unlock(&ci->i_ceph_lock);
-                ceph_put_cap_refs(ci, got);
 
+        /*
+         * 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;
+
                 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 + ret - 1, 1);
+                        err = vfs_fsync_range(file, pos, pos + written - 1, 1);
                         if (err < 0)
                                 ret = err;
                 }
+                if ((ret < 0 && ret != -EAGAIN) || pos + written >= endoff)
+                        goto out;
+        }
 
-                if (dirty)
-                        __mark_inode_dirty(inode, dirty);
+        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)
                 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);
@@ -777,13 +767,10 @@ retry_snap:
                 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, (unsigned)iov->iov_len,
-             ceph_cap_string(got));
+             inode, ceph_vinop(inode), pos + written,
+             (unsigned)iov->iov_len - written, 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",
diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index ba95eea201bf..2971eaa65cdc 100644
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -1466,7 +1466,7 @@ void __ceph_do_pending_vmtruncate(struct inode *inode)
 {
         struct ceph_inode_info *ci = ceph_inode(inode);
         u64 to;
-        int wrbuffer_refs, wake = 0;
+        int wrbuffer_refs, finish = 0;
 
 retry:
         spin_lock(&ci->i_ceph_lock);
@@ -1498,15 +1498,18 @@ retry:
         truncate_inode_pages(inode->i_mapping, to);
 
         spin_lock(&ci->i_ceph_lock);
-        ci->i_truncate_pending--;
-        if (ci->i_truncate_pending == 0)
-                wake = 1;
+        if (to == ci->i_truncate_size) {
+                ci->i_truncate_pending = 0;
+                finish = 1;
+        }
         spin_unlock(&ci->i_ceph_lock);
+        if (!finish)
+                goto retry;
 
         if (wrbuffer_refs == 0)
                 ceph_check_caps(ci, CHECK_CAPS_AUTHONLY, NULL);
-        if (wake)
-                wake_up_all(&ci->i_cap_wq);
+
+        wake_up_all(&ci->i_cap_wq);
 }
 
 
diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c
index 1bcf712655d9..9165eb8309eb 100644
--- a/fs/ceph/mds_client.c
+++ b/fs/ceph/mds_client.c
@@ -1590,7 +1590,7 @@ static int set_request_path_attr(struct inode *rinode, struct dentry *rdentry,
         } else if (rpath || rino) {
                 *ino = rino;
                 *ppath = rpath;
-                *pathlen = strlen(rpath);
+                *pathlen = rpath ? strlen(rpath) : 0;
                 dout(" path %.*s\n", *pathlen, rpath);
         }
 
@@ -1876,9 +1876,14 @@ finish:
 static void __wake_requests(struct ceph_mds_client *mdsc,
                             struct list_head *head)
 {
-        struct ceph_mds_request *req, *nreq;
+        struct ceph_mds_request *req;
+        LIST_HEAD(tmp_list);
+
+        list_splice_init(head, &tmp_list);
 
-        list_for_each_entry_safe(req, nreq, head, r_wait) {
+        while (!list_empty(&tmp_list)) {
+                req = list_entry(tmp_list.next,
+                                 struct ceph_mds_request, r_wait);
                 list_del_init(&req->r_wait);
                 __do_request(mdsc, req);
         }
diff --git a/fs/ceph/super.c b/fs/ceph/super.c
index 2eb43f211325..e86aa9948124 100644
--- a/fs/ceph/super.c
+++ b/fs/ceph/super.c
@@ -403,8 +403,6 @@ static int ceph_show_options(struct seq_file *m, struct dentry *root)
                 seq_printf(m, ",mount_timeout=%d", opt->mount_timeout);
         if (opt->osd_idle_ttl != CEPH_OSD_IDLE_TTL_DEFAULT)
                 seq_printf(m, ",osd_idle_ttl=%d", opt->osd_idle_ttl);
-        if (opt->osd_timeout != CEPH_OSD_TIMEOUT_DEFAULT)
-                seq_printf(m, ",osdtimeout=%d", opt->osd_timeout);
         if (opt->osd_keepalive_timeout != CEPH_OSD_KEEPALIVE_DEFAULT)
                 seq_printf(m, ",osdkeepalivetimeout=%d",
                            opt->osd_keepalive_timeout);
@@ -849,7 +847,7 @@ static int ceph_register_bdi(struct super_block *sb,
                 fsc->backing_dev_info.ra_pages =
                         default_backing_dev_info.ra_pages;
 
-        err = bdi_register(&fsc->backing_dev_info, NULL, "ceph-%d",
+        err = bdi_register(&fsc->backing_dev_info, NULL, "ceph-%ld",
                            atomic_long_inc_return(&bdi_seq));
         if (!err)
                 sb->s_bdi = &fsc->backing_dev_info;