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;