11 files changed, 265 insertions, 105 deletions

diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index d4f81edd9a5d..a60ea977af6f 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -236,16 +236,10 @@ static int ceph_readpage(struct file *filp, struct page *page)
 static void finish_read(struct ceph_osd_request *req, struct ceph_msg *msg)
 {
         struct inode *inode = req->r_inode;
-        struct ceph_osd_reply_head *replyhead;
-        int rc, bytes;
+        int rc = req->r_result;
+        int bytes = le32_to_cpu(msg->hdr.data_len);
         int i;
 
-        /* parse reply */
-        replyhead = msg->front.iov_base;
-        WARN_ON(le32_to_cpu(replyhead->num_ops) == 0);
-        rc = le32_to_cpu(replyhead->result);
-        bytes = le32_to_cpu(msg->hdr.data_len);
-
         dout("finish_read %p req %p rc %d bytes %d\n", inode, req, rc, bytes);
 
         /* unlock all pages, zeroing any data we didn't read */
@@ -315,7 +309,7 @@ static int start_read(struct inode *inode, struct list_head *page_list, int max)
                                     CEPH_OSD_OP_READ, CEPH_OSD_FLAG_READ,
                                     NULL, 0,
                                     ci->i_truncate_seq, ci->i_truncate_size,
-                                    NULL, false, 1, 0);
+                                    NULL, false, 0);
         if (IS_ERR(req))
                 return PTR_ERR(req);
 
@@ -492,8 +486,7 @@ static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
                                    &ci->i_layout, snapc,
                                    page_off, len,
                                    ci->i_truncate_seq, ci->i_truncate_size,
-                                   &inode->i_mtime,
-                                   &page, 1, 0, 0, true);
+                                   &inode->i_mtime, &page, 1);
         if (err < 0) {
                 dout("writepage setting page/mapping error %d %p\n", err, page);
                 SetPageError(page);
@@ -554,27 +547,18 @@ static void writepages_finish(struct ceph_osd_request *req,
                               struct ceph_msg *msg)
 {
         struct inode *inode = req->r_inode;
-        struct ceph_osd_reply_head *replyhead;
-        struct ceph_osd_op *op;
         struct ceph_inode_info *ci = ceph_inode(inode);
         unsigned wrote;
         struct page *page;
         int i;
         struct ceph_snap_context *snapc = req->r_snapc;
         struct address_space *mapping = inode->i_mapping;
-        __s32 rc = -EIO;
-        u64 bytes = 0;
+        int rc = req->r_result;
+        u64 bytes = le64_to_cpu(req->r_request_ops[0].extent.length);
         struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
         long writeback_stat;
         unsigned issued = ceph_caps_issued(ci);
 
-        /* parse reply */
-        replyhead = msg->front.iov_base;
-        WARN_ON(le32_to_cpu(replyhead->num_ops) == 0);
-        op = (void *)(replyhead + 1);
-        rc = le32_to_cpu(replyhead->result);
-        bytes = le64_to_cpu(op->extent.length);
-
         if (rc >= 0) {
                 /*
                  * Assume we wrote the pages we originally sent.  The
@@ -741,8 +725,6 @@ retry:
                 struct page *page;
                 int want;
                 u64 offset, len;
-                struct ceph_osd_request_head *reqhead;
-                struct ceph_osd_op *op;
                 long writeback_stat;
 
                 next = 0;
@@ -838,7 +820,7 @@ get_more_pages:
                                             snapc, do_sync,
                                             ci->i_truncate_seq,
                                             ci->i_truncate_size,
-                                            &inode->i_mtime, true, 1, 0);
+                                            &inode->i_mtime, true, 0);
 
                                 if (IS_ERR(req)) {
                                         rc = PTR_ERR(req);
@@ -906,10 +888,8 @@ get_more_pages:
 
                 /* revise final length, page count */
                 req->r_num_pages = locked_pages;
-                reqhead = req->r_request->front.iov_base;
-                op = (void *)(reqhead + 1);
-                op->extent.length = cpu_to_le64(len);
-                op->payload_len = cpu_to_le32(len);
+                req->r_request_ops[0].extent.length = cpu_to_le64(len);
+                req->r_request_ops[0].payload_len = cpu_to_le32(len);
                 req->r_request->hdr.data_len = cpu_to_le32(len);
 
                 rc = ceph_osdc_start_request(&fsc->client->osdc, req, true);
diff --git a/fs/ceph/caps.c b/fs/ceph/caps.c
index ae2be696eb5b..78e2f575247d 100644
--- a/fs/ceph/caps.c
+++ b/fs/ceph/caps.c
@@ -611,8 +611,16 @@ retry:
 
         if (flags & CEPH_CAP_FLAG_AUTH)
                 ci->i_auth_cap = cap;
-        else if (ci->i_auth_cap == cap)
+        else if (ci->i_auth_cap == cap) {
                 ci->i_auth_cap = NULL;
+                spin_lock(&mdsc->cap_dirty_lock);
+                if (!list_empty(&ci->i_dirty_item)) {
+                        dout(" moving %p to cap_dirty_migrating\n", inode);
+                        list_move(&ci->i_dirty_item,
+                                  &mdsc->cap_dirty_migrating);
+                }
+                spin_unlock(&mdsc->cap_dirty_lock);
+        }
 
         dout("add_cap inode %p (%llx.%llx) cap %p %s now %s seq %d mds%d\n",
              inode, ceph_vinop(inode), cap, ceph_cap_string(issued),
@@ -1460,7 +1468,7 @@ void ceph_check_caps(struct ceph_inode_info *ci, int flags,
         struct ceph_mds_client *mdsc = fsc->mdsc;
         struct inode *inode = &ci->vfs_inode;
         struct ceph_cap *cap;
-        int file_wanted, used;
+        int file_wanted, used, cap_used;
         int took_snap_rwsem = 0;             /* true if mdsc->snap_rwsem held */
         int issued, implemented, want, retain, revoking, flushing = 0;
         int mds = -1;   /* keep track of how far we've gone through i_caps list
@@ -1563,9 +1571,14 @@ retry_locked:
 
                 /* NOTE: no side-effects allowed, until we take s_mutex */
 
+                cap_used = used;
+                if (ci->i_auth_cap && cap != ci->i_auth_cap)
+                        cap_used &= ~ci->i_auth_cap->issued;
+
                 revoking = cap->implemented & ~cap->issued;
-                dout(" mds%d cap %p issued %s implemented %s revoking %s\n",
+                dout(" mds%d cap %p used %s issued %s implemented %s revoking %s\n",
                      cap->mds, cap, ceph_cap_string(cap->issued),
+                     ceph_cap_string(cap_used),
                      ceph_cap_string(cap->implemented),
                      ceph_cap_string(revoking));
 
@@ -1593,7 +1606,7 @@ retry_locked:
                 }
 
                 /* completed revocation? going down and there are no caps? */
-                if (revoking && (revoking & used) == 0) {
+                if (revoking && (revoking & cap_used) == 0) {
                         dout("completed revocation of %s\n",
                              ceph_cap_string(cap->implemented & ~cap->issued));
                         goto ack;
@@ -1670,8 +1683,8 @@ ack:
                 sent++;
 
                 /* __send_cap drops i_ceph_lock */
-                delayed += __send_cap(mdsc, cap, CEPH_CAP_OP_UPDATE, used, want,
-                                      retain, flushing, NULL);
+                delayed += __send_cap(mdsc, cap, CEPH_CAP_OP_UPDATE, cap_used,
+                                      want, retain, flushing, NULL);
                 goto retry; /* retake i_ceph_lock and restart our cap scan. */
         }
 
@@ -2417,7 +2430,9 @@ static void handle_cap_grant(struct inode *inode, struct ceph_mds_caps *grant,
                 dout("mds wanted %s -> %s\n",
                      ceph_cap_string(le32_to_cpu(grant->wanted)),
                      ceph_cap_string(wanted));
-                grant->wanted = cpu_to_le32(wanted);
+                /* imported cap may not have correct mds_wanted */
+                if (le32_to_cpu(grant->op) == CEPH_CAP_OP_IMPORT)
+                        check_caps = 1;
         }
 
         cap->seq = seq;
@@ -2821,6 +2836,9 @@ void ceph_handle_caps(struct ceph_mds_session *session,
         dout(" mds%d seq %lld cap seq %u\n", session->s_mds, session->s_seq,
              (unsigned)seq);
 
+        if (op == CEPH_CAP_OP_IMPORT)
+                ceph_add_cap_releases(mdsc, session);
+
         /* lookup ino */
         inode = ceph_find_inode(sb, vino);
         ci = ceph_inode(inode);
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index 11b57c2c8f15..bf338d9b67e3 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -243,6 +243,9 @@ int ceph_atomic_open(struct inode *dir, struct dentry *dentry,
         err = ceph_mdsc_do_request(mdsc,
                                    (flags & (O_CREAT|O_TRUNC)) ? dir : NULL,
                                    req);
+        if (err)
+                goto out_err;
+
         err = ceph_handle_snapdir(req, dentry, err);
         if (err == 0 && (flags & O_CREAT) && !req->r_reply_info.head->is_dentry)
                 err = ceph_handle_notrace_create(dir, dentry);
@@ -263,6 +266,9 @@ int ceph_atomic_open(struct inode *dir, struct dentry *dentry,
                 err = finish_no_open(file, dn);
         } else {
                 dout("atomic_open finish_open on dn %p\n", dn);
+                if (req->r_op == CEPH_MDS_OP_CREATE && req->r_reply_info.has_create_ino) {
+                        *opened |= FILE_CREATED;
+                }
                 err = finish_open(file, dentry, ceph_open, opened);
         }
 
@@ -535,7 +541,7 @@ more:
                                     ci->i_snap_realm->cached_context,
                                     do_sync,
                                     ci->i_truncate_seq, ci->i_truncate_size,
-                                    &mtime, false, 2, page_align);
+                                    &mtime, false, page_align);
         if (IS_ERR(req))
                 return PTR_ERR(req);
 
diff --git a/fs/ceph/ioctl.c b/fs/ceph/ioctl.c
index f5ed767806df..4a989345b37b 100644
--- a/fs/ceph/ioctl.c
+++ b/fs/ceph/ioctl.c
@@ -185,7 +185,6 @@ static long ceph_ioctl_get_dataloc(struct file *file, void __user *arg)
                 &ceph_sb_to_client(inode->i_sb)->client->osdc;
         u64 len = 1, olen;
         u64 tmp;
-        struct ceph_object_layout ol;
         struct ceph_pg pgid;
         int r;
 
@@ -194,7 +193,7 @@ static long ceph_ioctl_get_dataloc(struct file *file, void __user *arg)
                 return -EFAULT;
 
         down_read(&osdc->map_sem);
-        r = ceph_calc_file_object_mapping(&ci->i_layout, dl.file_offset, &len,
+        r = ceph_calc_file_object_mapping(&ci->i_layout, dl.file_offset, len,
                                           &dl.object_no, &dl.object_offset,
                                           &olen);
         if (r < 0)
@@ -209,10 +208,9 @@ static long ceph_ioctl_get_dataloc(struct file *file, void __user *arg)
 
         snprintf(dl.object_name, sizeof(dl.object_name), "%llx.%08llx",
                  ceph_ino(inode), dl.object_no);
-        ceph_calc_object_layout(&ol, dl.object_name, &ci->i_layout,
+        ceph_calc_object_layout(&pgid, dl.object_name, &ci->i_layout,
                                 osdc->osdmap);
 
-        pgid = ol.ol_pgid;
         dl.osd = ceph_calc_pg_primary(osdc->osdmap, pgid);
         if (dl.osd >= 0) {
                 struct ceph_entity_addr *a =
diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c
index 7a3dfe0a9a80..442880d099c9 100644
--- a/fs/ceph/mds_client.c
+++ b/fs/ceph/mds_client.c
@@ -233,6 +233,30 @@ bad:
 }
 
 /*
+ * parse create results
+ */
+static int parse_reply_info_create(void **p, void *end,
+                                  struct ceph_mds_reply_info_parsed *info,
+                                  int features)
+{
+        if (features & CEPH_FEATURE_REPLY_CREATE_INODE) {
+                if (*p == end) {
+                        info->has_create_ino = false;
+                } else {
+                        info->has_create_ino = true;
+                        info->ino = ceph_decode_64(p);
+                }
+        }
+
+        if (unlikely(*p != end))
+                goto bad;
+        return 0;
+
+bad:
+        return -EIO;
+}
+
+/*
  * parse extra results
  */
 static int parse_reply_info_extra(void **p, void *end,
@@ -241,8 +265,12 @@ static int parse_reply_info_extra(void **p, void *end,
 {
         if (info->head->op == CEPH_MDS_OP_GETFILELOCK)
                 return parse_reply_info_filelock(p, end, info, features);
-        else
+        else if (info->head->op == CEPH_MDS_OP_READDIR)
                 return parse_reply_info_dir(p, end, info, features);
+        else if (info->head->op == CEPH_MDS_OP_CREATE)
+                return parse_reply_info_create(p, end, info, features);
+        else
+                return -EIO;
 }
 
 /*
@@ -2170,7 +2198,8 @@ static void handle_reply(struct ceph_mds_session *session, struct ceph_msg *msg)
         mutex_lock(&req->r_fill_mutex);
         err = ceph_fill_trace(mdsc->fsc->sb, req, req->r_session);
         if (err == 0) {
-                if (result == 0 && req->r_op != CEPH_MDS_OP_GETFILELOCK &&
+                if (result == 0 && (req->r_op == CEPH_MDS_OP_READDIR ||
+                                    req->r_op == CEPH_MDS_OP_LSSNAP) &&
                     rinfo->dir_nr)
                         ceph_readdir_prepopulate(req, req->r_session);
                 ceph_unreserve_caps(mdsc, &req->r_caps_reservation);
diff --git a/fs/ceph/mds_client.h b/fs/ceph/mds_client.h
index ff4188bf6199..c2a19fbbe517 100644
--- a/fs/ceph/mds_client.h
+++ b/fs/ceph/mds_client.h
@@ -74,6 +74,12 @@ struct ceph_mds_reply_info_parsed {
                         struct ceph_mds_reply_info_in *dir_in;
                         u8                            dir_complete, dir_end;
                 };
+
+                /* for create results */
+                struct {
+                        bool has_create_ino;
+                        u64 ino;
+                };
         };
 
         /* encoded blob describing snapshot contexts for certain
diff --git a/fs/ceph/mdsmap.c b/fs/ceph/mdsmap.c
index 73b7d44e8a35..0d3c9240c61b 100644
--- a/fs/ceph/mdsmap.c
+++ b/fs/ceph/mdsmap.c
@@ -59,6 +59,10 @@ struct ceph_mdsmap *ceph_mdsmap_decode(void **p, void *end)
                 return ERR_PTR(-ENOMEM);
 
         ceph_decode_16_safe(p, end, version, bad);
+        if (version > 3) {
+                pr_warning("got mdsmap version %d > 3, failing", version);
+                goto bad;
+        }
 
         ceph_decode_need(p, end, 8*sizeof(u32) + sizeof(u64), bad);
         m->m_epoch = ceph_decode_32(p);
@@ -144,13 +148,13 @@ struct ceph_mdsmap *ceph_mdsmap_decode(void **p, void *end)
         /* pg_pools */
         ceph_decode_32_safe(p, end, n, bad);
         m->m_num_data_pg_pools = n;
-        m->m_data_pg_pools = kcalloc(n, sizeof(u32), GFP_NOFS);
+        m->m_data_pg_pools = kcalloc(n, sizeof(u64), GFP_NOFS);
         if (!m->m_data_pg_pools)
                 goto badmem;
-        ceph_decode_need(p, end, sizeof(u32)*(n+1), bad);
+        ceph_decode_need(p, end, sizeof(u64)*(n+1), bad);
         for (i = 0; i < n; i++)
-                m->m_data_pg_pools[i] = ceph_decode_32(p);
-        m->m_cas_pg_pool = ceph_decode_32(p);
+                m->m_data_pg_pools[i] = ceph_decode_64(p);
+        m->m_cas_pg_pool = ceph_decode_64(p);
 
         /* ok, we don't care about the rest. */
         dout("mdsmap_decode success epoch %u\n", m->m_epoch);
diff --git a/fs/ceph/strings.c b/fs/ceph/strings.c
index cd5097d7c804..89fa4a940a0f 100644
--- a/fs/ceph/strings.c
+++ b/fs/ceph/strings.c
@@ -15,6 +15,7 @@ const char *ceph_mds_state_name(int s)
         case CEPH_MDS_STATE_BOOT:       return "up:boot";
         case CEPH_MDS_STATE_STANDBY:    return "up:standby";
         case CEPH_MDS_STATE_STANDBY_REPLAY:    return "up:standby-replay";
+        case CEPH_MDS_STATE_REPLAYONCE: return "up:oneshot-replay";
         case CEPH_MDS_STATE_CREATING:   return "up:creating";
         case CEPH_MDS_STATE_STARTING:   return "up:starting";
                 /* up and in */
@@ -50,10 +51,13 @@ const char *ceph_mds_op_name(int op)
         case CEPH_MDS_OP_LOOKUP:  return "lookup";
         case CEPH_MDS_OP_LOOKUPHASH:  return "lookuphash";
         case CEPH_MDS_OP_LOOKUPPARENT:  return "lookupparent";
+        case CEPH_MDS_OP_LOOKUPINO:  return "lookupino";
         case CEPH_MDS_OP_GETATTR:  return "getattr";
         case CEPH_MDS_OP_SETXATTR: return "setxattr";
         case CEPH_MDS_OP_SETATTR: return "setattr";
         case CEPH_MDS_OP_RMXATTR: return "rmxattr";
+        case CEPH_MDS_OP_SETLAYOUT: return "setlayou";
+        case CEPH_MDS_OP_SETDIRLAYOUT: return "setdirlayout";
         case CEPH_MDS_OP_READDIR: return "readdir";
         case CEPH_MDS_OP_MKNOD: return "mknod";
         case CEPH_MDS_OP_LINK: return "link";
diff --git a/fs/ceph/super.c b/fs/ceph/super.c
index e86aa9948124..9fe17c6c2876 100644
--- a/fs/ceph/super.c
+++ b/fs/ceph/super.c
@@ -71,8 +71,14 @@ static int ceph_statfs(struct dentry *dentry, struct kstatfs *buf)
         /*
          * express utilization in terms of large blocks to avoid
          * overflow on 32-bit machines.
+         *
+         * NOTE: for the time being, we make bsize == frsize to humor
+         * not-yet-ancient versions of glibc that are broken.
+         * Someday, we will probably want to report a real block
+         * size...  whatever that may mean for a network file system!
          */
         buf->f_bsize = 1 << CEPH_BLOCK_SHIFT;
+        buf->f_frsize = 1 << CEPH_BLOCK_SHIFT;
         buf->f_blocks = le64_to_cpu(st.kb) >> (CEPH_BLOCK_SHIFT-10);
         buf->f_bfree = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10);
         buf->f_bavail = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10);
@@ -80,7 +86,6 @@ static int ceph_statfs(struct dentry *dentry, struct kstatfs *buf)
         buf->f_files = le64_to_cpu(st.num_objects);
         buf->f_ffree = -1;
         buf->f_namelen = NAME_MAX;
-        buf->f_frsize = PAGE_CACHE_SIZE;
 
         /* leave fsid little-endian, regardless of host endianness */
         fsid = *(u64 *)(&monmap->fsid) ^ *((u64 *)&monmap->fsid + 1);
diff --git a/fs/ceph/super.h b/fs/ceph/super.h
index f053bbd1886f..c7b309723dcc 100644
--- a/fs/ceph/super.h
+++ b/fs/ceph/super.h
@@ -21,7 +21,7 @@
 
 /* large granularity for statfs utilization stats to facilitate
  * large volume sizes on 32-bit machines. */
-#define CEPH_BLOCK_SHIFT   20  /* 1 MB */
+#define CEPH_BLOCK_SHIFT   22  /* 4 MB */
 #define CEPH_BLOCK         (1 << CEPH_BLOCK_SHIFT)
 
 #define CEPH_MOUNT_OPT_DIRSTAT         (1<<4) /* `cat dirname` for stats */
@@ -798,13 +798,7 @@ 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_copy_to_page_vector(struct page **pages,
-                                    const char *data,
-                                    loff_t off, size_t len);
-extern int ceph_copy_from_page_vector(struct page **pages,
-                                    char *data,
-                                    loff_t off, size_t len);
-extern struct page **ceph_alloc_page_vector(int num_pages, gfp_t flags);
+
 extern int ceph_open(struct inode *inode, struct file *file);
 extern int ceph_atomic_open(struct inode *dir, struct dentry *dentry,
                             struct file *file, unsigned flags, umode_t mode,
diff --git a/fs/ceph/xattr.c b/fs/ceph/xattr.c
index 2c2ae5be9902..9b6b2b6dd164 100644
--- a/fs/ceph/xattr.c
+++ b/fs/ceph/xattr.c
@@ -29,9 +29,94 @@ struct ceph_vxattr {
         size_t name_size;       /* strlen(name) + 1 (for '\0') */
         size_t (*getxattr_cb)(struct ceph_inode_info *ci, char *val,
                               size_t size);
-        bool readonly;
+        bool readonly, hidden;
+        bool (*exists_cb)(struct ceph_inode_info *ci);
 };
 
+/* layouts */
+
+static bool ceph_vxattrcb_layout_exists(struct ceph_inode_info *ci)
+{
+        size_t s;
+        char *p = (char *)&ci->i_layout;
+
+        for (s = 0; s < sizeof(ci->i_layout); s++, p++)
+                if (*p)
+                        return true;
+        return false;
+}
+
+static size_t ceph_vxattrcb_layout(struct ceph_inode_info *ci, char *val,
+                                        size_t size)
+{
+        int ret;
+        struct ceph_fs_client *fsc = ceph_sb_to_client(ci->vfs_inode.i_sb);
+        struct ceph_osd_client *osdc = &fsc->client->osdc;
+        s64 pool = ceph_file_layout_pg_pool(ci->i_layout);
+        const char *pool_name;
+
+        dout("ceph_vxattrcb_layout %p\n", &ci->vfs_inode);
+        down_read(&osdc->map_sem);
+        pool_name = ceph_pg_pool_name_by_id(osdc->osdmap, pool);
+        if (pool_name)
+                ret = snprintf(val, size,
+                "stripe_unit=%lld stripe_count=%lld object_size=%lld pool=%s",
+                (unsigned long long)ceph_file_layout_su(ci->i_layout),
+                (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout),
+                (unsigned long long)ceph_file_layout_object_size(ci->i_layout),
+                pool_name);
+        else
+                ret = snprintf(val, size,
+                "stripe_unit=%lld stripe_count=%lld object_size=%lld pool=%lld",
+                (unsigned long long)ceph_file_layout_su(ci->i_layout),
+                (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout),
+                (unsigned long long)ceph_file_layout_object_size(ci->i_layout),
+                (unsigned long long)pool);
+
+        up_read(&osdc->map_sem);
+        return ret;
+}
+
+static size_t ceph_vxattrcb_layout_stripe_unit(struct ceph_inode_info *ci,
+                                               char *val, size_t size)
+{
+        return snprintf(val, size, "%lld",
+                        (unsigned long long)ceph_file_layout_su(ci->i_layout));
+}
+
+static size_t ceph_vxattrcb_layout_stripe_count(struct ceph_inode_info *ci,
+                                                char *val, size_t size)
+{
+        return snprintf(val, size, "%lld",
+               (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout));
+}
+
+static size_t ceph_vxattrcb_layout_object_size(struct ceph_inode_info *ci,
+                                               char *val, size_t size)
+{
+        return snprintf(val, size, "%lld",
+               (unsigned long long)ceph_file_layout_object_size(ci->i_layout));
+}
+
+static size_t ceph_vxattrcb_layout_pool(struct ceph_inode_info *ci,
+                                        char *val, size_t size)
+{
+        int ret;
+        struct ceph_fs_client *fsc = ceph_sb_to_client(ci->vfs_inode.i_sb);
+        struct ceph_osd_client *osdc = &fsc->client->osdc;
+        s64 pool = ceph_file_layout_pg_pool(ci->i_layout);
+        const char *pool_name;
+
+        down_read(&osdc->map_sem);
+        pool_name = ceph_pg_pool_name_by_id(osdc->osdmap, pool);
+        if (pool_name)
+                ret = snprintf(val, size, "%s", pool_name);
+        else
+                ret = snprintf(val, size, "%lld", (unsigned long long)pool);
+        up_read(&osdc->map_sem);
+        return ret;
+}
+
 /* directories */
 
 static size_t ceph_vxattrcb_dir_entries(struct ceph_inode_info *ci, char *val,
@@ -83,17 +168,43 @@ static size_t ceph_vxattrcb_dir_rctime(struct ceph_inode_info *ci, char *val,
                         (long)ci->i_rctime.tv_nsec);
 }
 
-#define CEPH_XATTR_NAME(_type, _name)   XATTR_CEPH_PREFIX #_type "." #_name
 
-#define XATTR_NAME_CEPH(_type, _name) \
-                { \
-                        .name = CEPH_XATTR_NAME(_type, _name), \
-                        .name_size = sizeof (CEPH_XATTR_NAME(_type, _name)), \
-                        .getxattr_cb = ceph_vxattrcb_ ## _type ## _ ## _name, \
-                        .readonly = true, \
-                }
+#define CEPH_XATTR_NAME(_type, _name)   XATTR_CEPH_PREFIX #_type "." #_name
+#define CEPH_XATTR_NAME2(_type, _name, _name2)  \
+        XATTR_CEPH_PREFIX #_type "." #_name "." #_name2
+
+#define XATTR_NAME_CEPH(_type, _name)                                   \
+        {                                                               \
+                .name = CEPH_XATTR_NAME(_type, _name),                  \
+                .name_size = sizeof (CEPH_XATTR_NAME(_type, _name)), \
+                .getxattr_cb = ceph_vxattrcb_ ## _type ## _ ## _name, \
+                .readonly = true,                               \
+                .hidden = false,                                \
+                .exists_cb = NULL,                      \
+        }
+#define XATTR_LAYOUT_FIELD(_type, _name, _field)                        \
+        {                                                               \
+                .name = CEPH_XATTR_NAME2(_type, _name, _field), \
+                .name_size = sizeof (CEPH_XATTR_NAME2(_type, _name, _field)), \
+                .getxattr_cb = ceph_vxattrcb_ ## _name ## _ ## _field, \
+                .readonly = false,                              \
+                .hidden = true,                 \
+                .exists_cb = ceph_vxattrcb_layout_exists,       \
+        }
 
 static struct ceph_vxattr ceph_dir_vxattrs[] = {
+        {
+                .name = "ceph.dir.layout",
+                .name_size = sizeof("ceph.dir.layout"),
+                .getxattr_cb = ceph_vxattrcb_layout,
+                .readonly = false,
+                .hidden = false,
+                .exists_cb = ceph_vxattrcb_layout_exists,
+        },
+        XATTR_LAYOUT_FIELD(dir, layout, stripe_unit),
+        XATTR_LAYOUT_FIELD(dir, layout, stripe_count),
+        XATTR_LAYOUT_FIELD(dir, layout, object_size),
+        XATTR_LAYOUT_FIELD(dir, layout, pool),
         XATTR_NAME_CEPH(dir, entries),
         XATTR_NAME_CEPH(dir, files),
         XATTR_NAME_CEPH(dir, subdirs),
@@ -102,35 +213,26 @@ static struct ceph_vxattr ceph_dir_vxattrs[] = {
         XATTR_NAME_CEPH(dir, rsubdirs),
         XATTR_NAME_CEPH(dir, rbytes),
         XATTR_NAME_CEPH(dir, rctime),
-        { 0 }   /* Required table terminator */
+        { .name = NULL, 0 }     /* Required table terminator */
 };
 static size_t ceph_dir_vxattrs_name_size;       /* total size of all names */
 
 /* files */
 
-static size_t ceph_vxattrcb_file_layout(struct ceph_inode_info *ci, char *val,
-                                   size_t size)
-{
-        int ret;
-
-        ret = snprintf(val, size,
-                "chunk_bytes=%lld\nstripe_count=%lld\nobject_size=%lld\n",
-                (unsigned long long)ceph_file_layout_su(ci->i_layout),
-                (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout),
-                (unsigned long long)ceph_file_layout_object_size(ci->i_layout));
-        return ret;
-}
-
 static struct ceph_vxattr ceph_file_vxattrs[] = {
-        XATTR_NAME_CEPH(file, layout),
-        /* The following extended attribute name is deprecated */
         {
-                .name = XATTR_CEPH_PREFIX "layout",
-                .name_size = sizeof (XATTR_CEPH_PREFIX "layout"),
-                .getxattr_cb = ceph_vxattrcb_file_layout,
-                .readonly = true,
+                .name = "ceph.file.layout",
+                .name_size = sizeof("ceph.file.layout"),
+                .getxattr_cb = ceph_vxattrcb_layout,
+                .readonly = false,
+                .hidden = false,
+                .exists_cb = ceph_vxattrcb_layout_exists,
         },
-        { 0 }   /* Required table terminator */
+        XATTR_LAYOUT_FIELD(file, layout, stripe_unit),
+        XATTR_LAYOUT_FIELD(file, layout, stripe_count),
+        XATTR_LAYOUT_FIELD(file, layout, object_size),
+        XATTR_LAYOUT_FIELD(file, layout, pool),
+        { .name = NULL, 0 }     /* Required table terminator */
 };
 static size_t ceph_file_vxattrs_name_size;      /* total size of all names */
 
@@ -164,7 +266,8 @@ static size_t __init vxattrs_name_size(struct ceph_vxattr *vxattrs)
         size_t size = 0;
 
         for (vxattr = vxattrs; vxattr->name; vxattr++)
-                size += vxattr->name_size;
+                if (!vxattr->hidden)
+                        size += vxattr->name_size;
 
         return size;
 }
@@ -572,13 +675,17 @@ ssize_t ceph_getxattr(struct dentry *dentry, const char *name, void *value,
         if (!ceph_is_valid_xattr(name))
                 return -ENODATA;
 
-        /* let's see if a virtual xattr was requested */
-        vxattr = ceph_match_vxattr(inode, name);
-
         spin_lock(&ci->i_ceph_lock);
         dout("getxattr %p ver=%lld index_ver=%lld\n", inode,
              ci->i_xattrs.version, ci->i_xattrs.index_version);
 
+        /* let's see if a virtual xattr was requested */
+        vxattr = ceph_match_vxattr(inode, name);
+        if (vxattr && !(vxattr->exists_cb && !vxattr->exists_cb(ci))) {
+                err = vxattr->getxattr_cb(ci, value, size);
+                goto out;
+        }
+
         if (__ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 1) &&
             (ci->i_xattrs.index_version >= ci->i_xattrs.version)) {
                 goto get_xattr;
@@ -592,11 +699,6 @@ ssize_t ceph_getxattr(struct dentry *dentry, const char *name, void *value,
 
         spin_lock(&ci->i_ceph_lock);
 
-        if (vxattr && vxattr->readonly) {
-                err = vxattr->getxattr_cb(ci, value, size);
-                goto out;
-        }
-
         err = __build_xattrs(inode);
         if (err < 0)
                 goto out;
@@ -604,11 +706,8 @@ ssize_t ceph_getxattr(struct dentry *dentry, const char *name, void *value,
 get_xattr:
         err = -ENODATA;  /* == ENOATTR */
         xattr = __get_xattr(ci, name);
-        if (!xattr) {
-                if (vxattr)
-                        err = vxattr->getxattr_cb(ci, value, size);
+        if (!xattr)
                 goto out;
-        }
 
         err = -ERANGE;
         if (size && size < xattr->val_len)
@@ -664,23 +763,30 @@ list_xattr:
         vir_namelen = ceph_vxattrs_name_size(vxattrs);
 
         /* adding 1 byte per each variable due to the null termination */
-        namelen = vir_namelen + ci->i_xattrs.names_size + ci->i_xattrs.count;
+        namelen = ci->i_xattrs.names_size + ci->i_xattrs.count;
         err = -ERANGE;
-        if (size && namelen > size)
+        if (size && vir_namelen + namelen > size)
                 goto out;
 
-        err = namelen;
+        err = namelen + vir_namelen;
         if (size == 0)
                 goto out;
 
         names = __copy_xattr_names(ci, names);
 
         /* virtual xattr names, too */
-        if (vxattrs)
+        err = namelen;
+        if (vxattrs) {
                 for (i = 0; vxattrs[i].name; i++) {
-                        len = sprintf(names, "%s", vxattrs[i].name);
-                        names += len + 1;
+                        if (!vxattrs[i].hidden &&
+                            !(vxattrs[i].exists_cb &&
+                              !vxattrs[i].exists_cb(ci))) {
+                                len = sprintf(names, "%s", vxattrs[i].name);
+                                names += len + 1;
+                                err += len + 1;
+                        }
                 }
+        }
 
 out:
         spin_unlock(&ci->i_ceph_lock);
@@ -782,6 +888,10 @@ int ceph_setxattr(struct dentry *dentry, const char *name,
         if (vxattr && vxattr->readonly)
                 return -EOPNOTSUPP;
 
+        /* pass any unhandled ceph.* xattrs through to the MDS */
+        if (!strncmp(name, XATTR_CEPH_PREFIX, XATTR_CEPH_PREFIX_LEN))
+                goto do_sync_unlocked;
+
         /* preallocate memory for xattr name, value, index node */
         err = -ENOMEM;
         newname = kmemdup(name, name_len + 1, GFP_NOFS);
@@ -838,6 +948,7 @@ retry:
 
 do_sync:
         spin_unlock(&ci->i_ceph_lock);
+do_sync_unlocked:
         err = ceph_sync_setxattr(dentry, name, value, size, flags);
 out:
         kfree(newname);
@@ -892,6 +1003,10 @@ int ceph_removexattr(struct dentry *dentry, const char *name)
         if (vxattr && vxattr->readonly)
                 return -EOPNOTSUPP;
 
+        /* pass any unhandled ceph.* xattrs through to the MDS */
+        if (!strncmp(name, XATTR_CEPH_PREFIX, XATTR_CEPH_PREFIX_LEN))
+                goto do_sync_unlocked;
+
         err = -ENOMEM;
         spin_lock(&ci->i_ceph_lock);
 retry:
@@ -931,6 +1046,7 @@ retry:
         return err;
 do_sync:
         spin_unlock(&ci->i_ceph_lock);
+do_sync_unlocked:
         err = ceph_send_removexattr(dentry, name);
 out:
         return err;