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

Pull Ceph updates from Sage Weil:
 "This time around we have a collection of CephFS fixes from Zheng
  around MDS failure handling and snapshots, support for a new CRUSH
  straw2 algorithm (to sync up with userspace) and several RBD cleanups
  and fixes from Ilya, an error path leak fix from Taesoo, and then an
  assorted collection of cleanups from others"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client: (28 commits)
  rbd: rbd_wq comment is obsolete
  libceph: announce support for straw2 buckets
  crush: straw2 bucket type with an efficient 64-bit crush_ln()
  crush: ensuring at most num-rep osds are selected
  crush: drop unnecessary include from mapper.c
  ceph: fix uninline data function
  ceph: rename snapshot support
  ceph: fix null pointer dereference in send_mds_reconnect()
  ceph: hold on to exclusive caps on complete directories
  libceph: simplify our debugfs attr macro
  ceph: show non-default options only
  libceph: expose client options through debugfs
  libceph, ceph: split ceph_show_options()
  rbd: mark block queue as non-rotational
  libceph: don't overwrite specific con error msgs
  ceph: cleanup unsafe requests when reconnecting is denied
  ceph: don't zero i_wrbuffer_ref when reconnecting is denied
  ceph: don't mark dirty caps when there is no auth cap
  ceph: keep i_snap_realm while there are writers
  libceph: osdmap.h: Add missing format newlines
  ...

8 files changed, 190 insertions, 92 deletions

diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index 155ab9c0246b..e162bcd105ee 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -1146,6 +1146,10 @@ static int ceph_write_begin(struct file *file, struct address_space *mapping,
                      inode, page, (int)pos, (int)len);
 
                 r = ceph_update_writeable_page(file, pos, len, page);
+                if (r < 0)
+                        page_cache_release(page);
+                else
+                        *pagep = page;
         } while (r == -EAGAIN);
 
         return r;
@@ -1534,19 +1538,27 @@ int ceph_uninline_data(struct file *filp, struct page *locked_page)
 
         osd_req_op_extent_osd_data_pages(req, 1, &page, len, 0, false, false);
 
-        err = osd_req_op_xattr_init(req, 0, CEPH_OSD_OP_CMPXATTR,
-                                    "inline_version", &inline_version,
-                                    sizeof(inline_version),
-                                    CEPH_OSD_CMPXATTR_OP_GT,
-                                    CEPH_OSD_CMPXATTR_MODE_U64);
-        if (err)
-                goto out_put;
-
-        err = osd_req_op_xattr_init(req, 2, CEPH_OSD_OP_SETXATTR,
-                                    "inline_version", &inline_version,
-                                    sizeof(inline_version), 0, 0);
-        if (err)
-                goto out_put;
+        {
+                __le64 xattr_buf = cpu_to_le64(inline_version);
+                err = osd_req_op_xattr_init(req, 0, CEPH_OSD_OP_CMPXATTR,
+                                            "inline_version", &xattr_buf,
+                                            sizeof(xattr_buf),
+                                            CEPH_OSD_CMPXATTR_OP_GT,
+                                            CEPH_OSD_CMPXATTR_MODE_U64);
+                if (err)
+                        goto out_put;
+        }
+
+        {
+                char xattr_buf[32];
+                int xattr_len = snprintf(xattr_buf, sizeof(xattr_buf),
+                                         "%llu", inline_version);
+                err = osd_req_op_xattr_init(req, 2, CEPH_OSD_OP_SETXATTR,
+                                            "inline_version",
+                                            xattr_buf, xattr_len, 0, 0);
+                if (err)
+                        goto out_put;
+        }
 
         ceph_osdc_build_request(req, 0, NULL, CEPH_NOSNAP, &inode->i_mtime);
         err = ceph_osdc_start_request(&fsc->client->osdc, req, false);
diff --git a/fs/ceph/caps.c b/fs/ceph/caps.c
index 8172775428a0..11631c4c7d14 100644
--- a/fs/ceph/caps.c
+++ b/fs/ceph/caps.c
@@ -896,6 +896,18 @@ int ceph_is_any_caps(struct inode *inode)
         return ret;
 }
 
+static void drop_inode_snap_realm(struct ceph_inode_info *ci)
+{
+        struct ceph_snap_realm *realm = ci->i_snap_realm;
+        spin_lock(&realm->inodes_with_caps_lock);
+        list_del_init(&ci->i_snap_realm_item);
+        ci->i_snap_realm_counter++;
+        ci->i_snap_realm = NULL;
+        spin_unlock(&realm->inodes_with_caps_lock);
+        ceph_put_snap_realm(ceph_sb_to_client(ci->vfs_inode.i_sb)->mdsc,
+                            realm);
+}
+
 /*
  * Remove a cap.  Take steps to deal with a racing iterate_session_caps.
  *
@@ -946,15 +958,13 @@ void __ceph_remove_cap(struct ceph_cap *cap, bool queue_release)
         if (removed)
                 ceph_put_cap(mdsc, cap);
 
-        if (!__ceph_is_any_caps(ci) && ci->i_snap_realm) {
-                struct ceph_snap_realm *realm = ci->i_snap_realm;
-                spin_lock(&realm->inodes_with_caps_lock);
-                list_del_init(&ci->i_snap_realm_item);
-                ci->i_snap_realm_counter++;
-                ci->i_snap_realm = NULL;
-                spin_unlock(&realm->inodes_with_caps_lock);
-                ceph_put_snap_realm(mdsc, realm);
-        }
+        /* when reconnect denied, we remove session caps forcibly,
+         * i_wr_ref can be non-zero. If there are ongoing write,
+         * keep i_snap_realm.
+         */
+        if (!__ceph_is_any_caps(ci) && ci->i_wr_ref == 0 && ci->i_snap_realm)
+                drop_inode_snap_realm(ci);
+
         if (!__ceph_is_any_real_caps(ci))
                 __cap_delay_cancel(mdsc, ci);
 }
@@ -1394,6 +1404,13 @@ int __ceph_mark_dirty_caps(struct ceph_inode_info *ci, int mask)
         int was = ci->i_dirty_caps;
         int dirty = 0;
 
+        if (!ci->i_auth_cap) {
+                pr_warn("__mark_dirty_caps %p %llx mask %s, "
+                        "but no auth cap (session was closed?)\n",
+                        inode, ceph_ino(inode), ceph_cap_string(mask));
+                return 0;
+        }
+
         dout("__mark_dirty_caps %p %s dirty %s -> %s\n", &ci->vfs_inode,
              ceph_cap_string(mask), ceph_cap_string(was),
              ceph_cap_string(was | mask));
@@ -1404,7 +1421,6 @@ int __ceph_mark_dirty_caps(struct ceph_inode_info *ci, int mask)
                                 ci->i_snap_realm->cached_context);
                 dout(" inode %p now dirty snapc %p auth cap %p\n",
                      &ci->vfs_inode, ci->i_head_snapc, ci->i_auth_cap);
-                WARN_ON(!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);
@@ -1545,7 +1561,19 @@ retry_locked:
         if (!mdsc->stopping && inode->i_nlink > 0) {
                 if (want) {
                         retain |= CEPH_CAP_ANY;       /* be greedy */
+                } else if (S_ISDIR(inode->i_mode) &&
+                           (issued & CEPH_CAP_FILE_SHARED) &&
+                            __ceph_dir_is_complete(ci)) {
+                        /*
+                         * If a directory is complete, we want to keep
+                         * the exclusive cap. So that MDS does not end up
+                         * revoking the shared cap on every create/unlink
+                         * operation.
+                         */
+                        want = CEPH_CAP_ANY_SHARED | CEPH_CAP_FILE_EXCL;
+                        retain |= want;
                 } else {
+
                         retain |= CEPH_CAP_ANY_SHARED;
                         /*
                          * keep RD only if we didn't have the file open RW,
@@ -2309,6 +2337,9 @@ void ceph_put_cap_refs(struct ceph_inode_info *ci, int had)
                                         wake = 1;
                                 }
                         }
+                        /* see comment in __ceph_remove_cap() */
+                        if (!__ceph_is_any_caps(ci) && ci->i_snap_realm)
+                                drop_inode_snap_realm(ci);
                 }
         spin_unlock(&ci->i_ceph_lock);
 
diff --git a/fs/ceph/dir.c b/fs/ceph/dir.c
index 83e9976f7189..e729b79812b4 100644
--- a/fs/ceph/dir.c
+++ b/fs/ceph/dir.c
@@ -281,6 +281,7 @@ static int ceph_readdir(struct file *file, struct dir_context *ctx)
         /* can we use the dcache? */
         spin_lock(&ci->i_ceph_lock);
         if ((ctx->pos == 2 || fi->dentry) &&
+            ceph_test_mount_opt(fsc, DCACHE) &&
             !ceph_test_mount_opt(fsc, NOASYNCREADDIR) &&
             ceph_snap(inode) != CEPH_SNAPDIR &&
             __ceph_dir_is_complete_ordered(ci) &&
@@ -336,16 +337,23 @@ more:
                         ceph_mdsc_put_request(req);
                         return err;
                 }
-                req->r_inode = inode;
-                ihold(inode);
-                req->r_dentry = dget(file->f_path.dentry);
                 /* hints to request -> mds selection code */
                 req->r_direct_mode = USE_AUTH_MDS;
                 req->r_direct_hash = ceph_frag_value(frag);
                 req->r_direct_is_hash = true;
-                req->r_path2 = kstrdup(fi->last_name, GFP_NOFS);
+                if (fi->last_name) {
+                        req->r_path2 = kstrdup(fi->last_name, GFP_NOFS);
+                        if (!req->r_path2) {
+                                ceph_mdsc_put_request(req);
+                                return -ENOMEM;
+                        }
+                }
                 req->r_readdir_offset = fi->next_offset;
                 req->r_args.readdir.frag = cpu_to_le32(frag);
+
+                req->r_inode = inode;
+                ihold(inode);
+                req->r_dentry = dget(file->f_path.dentry);
                 err = ceph_mdsc_do_request(mdsc, NULL, req);
                 if (err < 0) {
                         ceph_mdsc_put_request(req);
@@ -629,6 +637,7 @@ static struct dentry *ceph_lookup(struct inode *dir, struct dentry *dentry,
                             fsc->mount_options->snapdir_name,
                             dentry->d_name.len) &&
                     !is_root_ceph_dentry(dir, dentry) &&
+                    ceph_test_mount_opt(fsc, DCACHE) &&
                     __ceph_dir_is_complete(ci) &&
                     (__ceph_caps_issued_mask(ci, CEPH_CAP_FILE_SHARED, 1))) {
                         spin_unlock(&ci->i_ceph_lock);
@@ -755,10 +764,15 @@ static int ceph_symlink(struct inode *dir, struct dentry *dentry,
                 err = PTR_ERR(req);
                 goto out;
         }
-        req->r_dentry = dget(dentry);
-        req->r_num_caps = 2;
         req->r_path2 = kstrdup(dest, GFP_NOFS);
+        if (!req->r_path2) {
+                err = -ENOMEM;
+                ceph_mdsc_put_request(req);
+                goto out;
+        }
         req->r_locked_dir = dir;
+        req->r_dentry = dget(dentry);
+        req->r_num_caps = 2;
         req->r_dentry_drop = CEPH_CAP_FILE_SHARED;
         req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
         err = ceph_mdsc_do_request(mdsc, dir, req);
@@ -933,16 +947,20 @@ static int ceph_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct ceph_fs_client *fsc = ceph_sb_to_client(old_dir->i_sb);
         struct ceph_mds_client *mdsc = fsc->mdsc;
         struct ceph_mds_request *req;
+        int op = CEPH_MDS_OP_RENAME;
         int err;
 
         if (ceph_snap(old_dir) != ceph_snap(new_dir))
                 return -EXDEV;
-        if (ceph_snap(old_dir) != CEPH_NOSNAP ||
-            ceph_snap(new_dir) != CEPH_NOSNAP)
-                return -EROFS;
+        if (ceph_snap(old_dir) != CEPH_NOSNAP) {
+                if (old_dir == new_dir && ceph_snap(old_dir) == CEPH_SNAPDIR)
+                        op = CEPH_MDS_OP_RENAMESNAP;
+                else
+                        return -EROFS;
+        }
         dout("rename dir %p dentry %p to dir %p dentry %p\n",
              old_dir, old_dentry, new_dir, new_dentry);
-        req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_RENAME, USE_AUTH_MDS);
+        req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS);
         if (IS_ERR(req))
                 return PTR_ERR(req);
         ihold(old_dir);
@@ -1240,11 +1258,12 @@ static int ceph_dir_fsync(struct file *file, loff_t start, loff_t end,
                 dout("dir_fsync %p wait on tid %llu (until %llu)\n",
                      inode, req->r_tid, last_tid);
                 if (req->r_timeout) {
-                        ret = wait_for_completion_timeout(
-                                &req->r_safe_completion, req->r_timeout);
-                        if (ret > 0)
+                        unsigned long time_left = wait_for_completion_timeout(
+                                                        &req->r_safe_completion,
+                                                        req->r_timeout);
+                        if (time_left > 0)
                                 ret = 0;
-                        else if (ret == 0)
+                        else
                                 ret = -EIO;  /* timed out */
                 } else {
                         wait_for_completion(&req->r_safe_completion);
@@ -1372,6 +1391,7 @@ const struct inode_operations ceph_snapdir_iops = {
         .getattr = ceph_getattr,
         .mkdir = ceph_mkdir,
         .rmdir = ceph_unlink,
+        .rename = ceph_rename,
 };
 
 const struct dentry_operations ceph_dentry_ops = {
diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c
index 71c073f38e54..0a2eb32ffe43 100644
--- a/fs/ceph/mds_client.c
+++ b/fs/ceph/mds_client.c
@@ -1021,6 +1021,33 @@ static void cleanup_cap_releases(struct ceph_mds_session *session)
         spin_unlock(&session->s_cap_lock);
 }
 
+static void cleanup_session_requests(struct ceph_mds_client *mdsc,
+                                     struct ceph_mds_session *session)
+{
+        struct ceph_mds_request *req;
+        struct rb_node *p;
+
+        dout("cleanup_session_requests mds%d\n", session->s_mds);
+        mutex_lock(&mdsc->mutex);
+        while (!list_empty(&session->s_unsafe)) {
+                req = list_first_entry(&session->s_unsafe,
+                                       struct ceph_mds_request, r_unsafe_item);
+                list_del_init(&req->r_unsafe_item);
+                pr_info(" dropping unsafe request %llu\n", req->r_tid);
+                __unregister_request(mdsc, req);
+        }
+        /* zero r_attempts, so kick_requests() will re-send requests */
+        p = rb_first(&mdsc->request_tree);
+        while (p) {
+                req = rb_entry(p, struct ceph_mds_request, r_node);
+                p = rb_next(p);
+                if (req->r_session &&
+                    req->r_session->s_mds == session->s_mds)
+                        req->r_attempts = 0;
+        }
+        mutex_unlock(&mdsc->mutex);
+}
+
 /*
  * Helper to safely iterate over all caps associated with a session, with
  * special care taken to handle a racing __ceph_remove_cap().
@@ -1098,7 +1125,7 @@ static int remove_session_caps_cb(struct inode *inode, struct ceph_cap *cap,
              cap, ci, &ci->vfs_inode);
         spin_lock(&ci->i_ceph_lock);
         __ceph_remove_cap(cap, false);
-        if (!__ceph_is_any_real_caps(ci)) {
+        if (!ci->i_auth_cap) {
                 struct ceph_mds_client *mdsc =
                         ceph_sb_to_client(inode->i_sb)->mdsc;
 
@@ -1120,13 +1147,6 @@ static int remove_session_caps_cb(struct inode *inode, struct ceph_cap *cap,
                         mdsc->num_cap_flushing--;
                         drop = 1;
                 }
-                if (drop && ci->i_wrbuffer_ref) {
-                        pr_info(" dropping dirty data for %p %lld\n",
-                                inode, ceph_ino(inode));
-                        ci->i_wrbuffer_ref = 0;
-                        ci->i_wrbuffer_ref_head = 0;
-                        drop++;
-                }
                 spin_unlock(&mdsc->cap_dirty_lock);
         }
         spin_unlock(&ci->i_ceph_lock);
@@ -1853,7 +1873,7 @@ static int set_request_path_attr(struct inode *rinode, struct dentry *rdentry,
  */
 static struct ceph_msg *create_request_message(struct ceph_mds_client *mdsc,
                                                struct ceph_mds_request *req,
-                                               int mds)
+                                               int mds, bool drop_cap_releases)
 {
         struct ceph_msg *msg;
         struct ceph_mds_request_head *head;
@@ -1937,6 +1957,12 @@ static struct ceph_msg *create_request_message(struct ceph_mds_client *mdsc,
                 releases += ceph_encode_inode_release(&p,
                       req->r_old_dentry->d_inode,
                       mds, req->r_old_inode_drop, req->r_old_inode_unless, 0);
+
+        if (drop_cap_releases) {
+                releases = 0;
+                p = msg->front.iov_base + req->r_request_release_offset;
+        }
+
         head->num_releases = cpu_to_le16(releases);
 
         /* time stamp */
@@ -1989,7 +2015,7 @@ static void complete_request(struct ceph_mds_client *mdsc,
  */
 static int __prepare_send_request(struct ceph_mds_client *mdsc,
                                   struct ceph_mds_request *req,
-                                  int mds)
+                                  int mds, bool drop_cap_releases)
 {
         struct ceph_mds_request_head *rhead;
         struct ceph_msg *msg;
@@ -2048,7 +2074,7 @@ static int __prepare_send_request(struct ceph_mds_client *mdsc,
                 ceph_msg_put(req->r_request);
                 req->r_request = NULL;
         }
-        msg = create_request_message(mdsc, req, mds);
+        msg = create_request_message(mdsc, req, mds, drop_cap_releases);
         if (IS_ERR(msg)) {
                 req->r_err = PTR_ERR(msg);
                 complete_request(mdsc, req);
@@ -2132,7 +2158,7 @@ static int __do_request(struct ceph_mds_client *mdsc,
         if (req->r_request_started == 0)   /* note request start time */
                 req->r_request_started = jiffies;
 
-        err = __prepare_send_request(mdsc, req, mds);
+        err = __prepare_send_request(mdsc, req, mds, false);
         if (!err) {
                 ceph_msg_get(req->r_request);
                 ceph_con_send(&session->s_con, req->r_request);
@@ -2590,6 +2616,7 @@ static void handle_session(struct ceph_mds_session *session,
         case CEPH_SESSION_CLOSE:
                 if (session->s_state == CEPH_MDS_SESSION_RECONNECTING)
                         pr_info("mds%d reconnect denied\n", session->s_mds);
+                cleanup_session_requests(mdsc, session);
                 remove_session_caps(session);
                 wake = 2; /* for good measure */
                 wake_up_all(&mdsc->session_close_wq);
@@ -2658,7 +2685,7 @@ static void replay_unsafe_requests(struct ceph_mds_client *mdsc,
 
         mutex_lock(&mdsc->mutex);
         list_for_each_entry_safe(req, nreq, &session->s_unsafe, r_unsafe_item) {
-                err = __prepare_send_request(mdsc, req, session->s_mds);
+                err = __prepare_send_request(mdsc, req, session->s_mds, true);
                 if (!err) {
                         ceph_msg_get(req->r_request);
                         ceph_con_send(&session->s_con, req->r_request);
@@ -2679,7 +2706,8 @@ static void replay_unsafe_requests(struct ceph_mds_client *mdsc,
                         continue; /* only old requests */
                 if (req->r_session &&
                     req->r_session->s_mds == session->s_mds) {
-                        err = __prepare_send_request(mdsc, req, session->s_mds);
+                        err = __prepare_send_request(mdsc, req,
+                                                     session->s_mds, true);
                         if (!err) {
                                 ceph_msg_get(req->r_request);
                                 ceph_con_send(&session->s_con, req->r_request);
@@ -2864,7 +2892,8 @@ static void send_mds_reconnect(struct ceph_mds_client *mdsc,
         spin_unlock(&session->s_cap_lock);
 
         /* trim unused caps to reduce MDS's cache rejoin time */
-        shrink_dcache_parent(mdsc->fsc->sb->s_root);
+        if (mdsc->fsc->sb->s_root)
+                shrink_dcache_parent(mdsc->fsc->sb->s_root);
 
         ceph_con_close(&session->s_con);
         ceph_con_open(&session->s_con,
@@ -3133,7 +3162,7 @@ static void handle_lease(struct ceph_mds_client *mdsc,
                     di->lease_renew_from &&
                     di->lease_renew_after == 0) {
                         unsigned long duration =
-                                le32_to_cpu(h->duration_ms) * HZ / 1000;
+                                msecs_to_jiffies(le32_to_cpu(h->duration_ms));
 
                         di->lease_seq = seq;
                         dentry->d_time = di->lease_renew_from + duration;
diff --git a/fs/ceph/strings.c b/fs/ceph/strings.c
index 51cc23e48111..89e6bc321df3 100644
--- a/fs/ceph/strings.c
+++ b/fs/ceph/strings.c
@@ -75,6 +75,7 @@ const char *ceph_mds_op_name(int op)
         case CEPH_MDS_OP_LSSNAP: return "lssnap";
         case CEPH_MDS_OP_MKSNAP: return "mksnap";
         case CEPH_MDS_OP_RMSNAP: return "rmsnap";
+        case CEPH_MDS_OP_RENAMESNAP: return "renamesnap";
         case CEPH_MDS_OP_SETFILELOCK: return "setfilelock";
         case CEPH_MDS_OP_GETFILELOCK: return "getfilelock";
         }
diff --git a/fs/ceph/super.c b/fs/ceph/super.c
index a63997b8bcff..e463ebd69a9c 100644
--- a/fs/ceph/super.c
+++ b/fs/ceph/super.c
@@ -345,6 +345,11 @@ static int parse_mount_options(struct ceph_mount_options **pfsopt,
         fsopt->rsize = CEPH_RSIZE_DEFAULT;
         fsopt->rasize = CEPH_RASIZE_DEFAULT;
         fsopt->snapdir_name = kstrdup(CEPH_SNAPDIRNAME_DEFAULT, GFP_KERNEL);
+        if (!fsopt->snapdir_name) {
+                err = -ENOMEM;
+                goto out;
+        }
+
         fsopt->caps_wanted_delay_min = CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT;
         fsopt->caps_wanted_delay_max = CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT;
         fsopt->cap_release_safety = CEPH_CAP_RELEASE_SAFETY_DEFAULT;
@@ -406,31 +411,20 @@ static int ceph_show_options(struct seq_file *m, struct dentry *root)
 {
         struct ceph_fs_client *fsc = ceph_sb_to_client(root->d_sb);
         struct ceph_mount_options *fsopt = fsc->mount_options;
-        struct ceph_options *opt = fsc->client->options;
-
-        if (opt->flags & CEPH_OPT_FSID)
-                seq_printf(m, ",fsid=%pU", &opt->fsid);
-        if (opt->flags & CEPH_OPT_NOSHARE)
-                seq_puts(m, ",noshare");
-        if (opt->flags & CEPH_OPT_NOCRC)
-                seq_puts(m, ",nocrc");
-        if (opt->flags & CEPH_OPT_NOMSGAUTH)
-                seq_puts(m, ",nocephx_require_signatures");
-        if ((opt->flags & CEPH_OPT_TCP_NODELAY) == 0)
-                seq_puts(m, ",notcp_nodelay");
-
-        if (opt->name)
-                seq_printf(m, ",name=%s", opt->name);
-        if (opt->key)
-                seq_puts(m, ",secret=<hidden>");
-
-        if (opt->mount_timeout != CEPH_MOUNT_TIMEOUT_DEFAULT)
-                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_keepalive_timeout != CEPH_OSD_KEEPALIVE_DEFAULT)
-                seq_printf(m, ",osdkeepalivetimeout=%d",
-                           opt->osd_keepalive_timeout);
+        size_t pos;
+        int ret;
+
+        /* a comma between MNT/MS and client options */
+        seq_putc(m, ',');
+        pos = m->count;
+
+        ret = ceph_print_client_options(m, fsc->client);
+        if (ret)
+                return ret;
+
+        /* retract our comma if no client options */
+        if (m->count == pos)
+                m->count--;
 
         if (fsopt->flags & CEPH_MOUNT_OPT_DIRSTAT)
                 seq_puts(m, ",dirstat");
@@ -438,14 +432,10 @@ static int ceph_show_options(struct seq_file *m, struct dentry *root)
                 seq_puts(m, ",norbytes");
         if (fsopt->flags & CEPH_MOUNT_OPT_NOASYNCREADDIR)
                 seq_puts(m, ",noasyncreaddir");
-        if (fsopt->flags & CEPH_MOUNT_OPT_DCACHE)
-                seq_puts(m, ",dcache");
-        else
+        if ((fsopt->flags & CEPH_MOUNT_OPT_DCACHE) == 0)
                 seq_puts(m, ",nodcache");
         if (fsopt->flags & CEPH_MOUNT_OPT_FSCACHE)
                 seq_puts(m, ",fsc");
-        else
-                seq_puts(m, ",nofsc");
 
 #ifdef CONFIG_CEPH_FS_POSIX_ACL
         if (fsopt->sb_flags & MS_POSIXACL)
@@ -477,6 +467,7 @@ static int ceph_show_options(struct seq_file *m, struct dentry *root)
                 seq_printf(m, ",readdir_max_bytes=%d", fsopt->max_readdir_bytes);
         if (strcmp(fsopt->snapdir_name, CEPH_SNAPDIRNAME_DEFAULT))
                 seq_printf(m, ",snapdirname=%s", fsopt->snapdir_name);
+
         return 0;
 }
 
@@ -730,6 +721,11 @@ static struct dentry *open_root_dentry(struct ceph_fs_client *fsc,
         if (IS_ERR(req))
                 return ERR_CAST(req);
         req->r_path1 = kstrdup(path, GFP_NOFS);
+        if (!req->r_path1) {
+                root = ERR_PTR(-ENOMEM);
+                goto out;
+        }
+
         req->r_ino1.ino = CEPH_INO_ROOT;
         req->r_ino1.snap = CEPH_NOSNAP;
         req->r_started = started;
diff --git a/fs/ceph/super.h b/fs/ceph/super.h
index 04c8124ed30e..fa20e1318939 100644
--- a/fs/ceph/super.h
+++ b/fs/ceph/super.h
@@ -36,7 +36,8 @@
 #define CEPH_MOUNT_OPT_DCACHE          (1<<9) /* use dcache for readdir etc */
 #define CEPH_MOUNT_OPT_FSCACHE         (1<<10) /* use fscache */
 
-#define CEPH_MOUNT_OPT_DEFAULT    (CEPH_MOUNT_OPT_RBYTES)
+#define CEPH_MOUNT_OPT_DEFAULT    (CEPH_MOUNT_OPT_RBYTES | \
+                                   CEPH_MOUNT_OPT_DCACHE)
 
 #define ceph_set_mount_opt(fsc, opt) \
         (fsc)->mount_options->flags |= CEPH_MOUNT_OPT_##opt;
@@ -881,7 +882,6 @@ extern int ceph_mmap(struct file *file, struct vm_area_struct *vma);
 
 /* file.c */
 extern const struct file_operations ceph_file_fops;
-extern const struct address_space_operations ceph_aops;
 
 extern int ceph_open(struct inode *inode, struct file *file);
 extern int ceph_atomic_open(struct inode *dir, struct dentry *dentry,
diff --git a/fs/ceph/xattr.c b/fs/ceph/xattr.c
index 5a492caf34cb..5c4c9c256931 100644
--- a/fs/ceph/xattr.c
+++ b/fs/ceph/xattr.c
@@ -877,16 +877,23 @@ static int ceph_sync_setxattr(struct dentry *dentry, const char *name,
                 err = PTR_ERR(req);
                 goto out;
         }
-        req->r_inode = inode;
-        ihold(inode);
-        req->r_inode_drop = CEPH_CAP_XATTR_SHARED;
-        req->r_num_caps = 1;
+
         req->r_args.setxattr.flags = cpu_to_le32(flags);
         req->r_path2 = kstrdup(name, GFP_NOFS);
+        if (!req->r_path2) {
+                ceph_mdsc_put_request(req);
+                err = -ENOMEM;
+                goto out;
+        }
 
         req->r_pagelist = pagelist;
         pagelist = NULL;
 
+        req->r_inode = inode;
+        ihold(inode);
+        req->r_num_caps = 1;
+        req->r_inode_drop = CEPH_CAP_XATTR_SHARED;
+
         dout("xattr.ver (before): %lld\n", ci->i_xattrs.version);
         err = ceph_mdsc_do_request(mdsc, NULL, req);
         ceph_mdsc_put_request(req);
@@ -1019,12 +1026,14 @@ static int ceph_send_removexattr(struct dentry *dentry, const char *name)
                                        USE_AUTH_MDS);
         if (IS_ERR(req))
                 return PTR_ERR(req);
+        req->r_path2 = kstrdup(name, GFP_NOFS);
+        if (!req->r_path2)
+                return -ENOMEM;
+
         req->r_inode = inode;
         ihold(inode);
-        req->r_inode_drop = CEPH_CAP_XATTR_SHARED;
         req->r_num_caps = 1;
-        req->r_path2 = kstrdup(name, GFP_NOFS);
-
+        req->r_inode_drop = CEPH_CAP_XATTR_SHARED;
         err = ceph_mdsc_do_request(mdsc, NULL, req);
         ceph_mdsc_put_request(req);
         return err;