Merge tag 'sunxi-dt-for-3.16-2' of https://github.com/mripard/linux into for-next

[firefly-linux-kernel-4.4.55.git] / fs / ceph / export.c

diff --git a/fs/ceph/export.c b/fs/ceph/export.c
index 976d3411d5ed4d88bf617926448662c6f8ebedc5..00d6af6a32ec9a37f204705da091122e7ddd7151 100644 (file)
--- a/fs/ceph/export.c
+++ b/fs/ceph/export.c
@@ -121,54 +121,130 @@ static struct dentry *ceph_fh_to_dentry(struct super_block *sb,
        return __fh_to_dentry(sb, fh->ino);
 }
 
-/*
- * get parent, if possible.
- *
- * FIXME: we could do better by querying the mds to discover the
- * parent.
- */
-static struct dentry *ceph_fh_to_parent(struct super_block *sb,
-                                        struct fid *fid,
-                                       int fh_len, int fh_type)
+static struct dentry *__get_parent(struct super_block *sb,
+                                  struct dentry *child, u64 ino)
 {
-       struct ceph_nfs_confh *cfh = (void *)fid->raw;
-       struct ceph_vino vino;
+       struct ceph_mds_client *mdsc = ceph_sb_to_client(sb)->mdsc;
+       struct ceph_mds_request *req;
        struct inode *inode;
        struct dentry *dentry;
        int err;
 
-       if (fh_type == 1)
-               return ERR_PTR(-ESTALE);
-       if (fh_len < sizeof(*cfh) / 4)
-               return ERR_PTR(-ESTALE);
-
-       pr_debug("fh_to_parent %llx/%d\n", cfh->parent_ino,
-                cfh->parent_name_hash);
+       req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPPARENT,
+                                      USE_ANY_MDS);
+       if (IS_ERR(req))
+               return ERR_CAST(req);
 
-       vino.ino = cfh->ino;
-       vino.snap = CEPH_NOSNAP;
-       inode = ceph_find_inode(sb, vino);
+       if (child) {
+               req->r_inode = child->d_inode;
+               ihold(child->d_inode);
+       } else {
+               req->r_ino1 = (struct ceph_vino) {
+                       .ino = ino,
+                       .snap = CEPH_NOSNAP,
+               };
+       }
+       req->r_num_caps = 1;
+       err = ceph_mdsc_do_request(mdsc, NULL, req);
+       inode = req->r_target_inode;
+       if (inode)
+               ihold(inode);
+       ceph_mdsc_put_request(req);
        if (!inode)
-               return ERR_PTR(-ESTALE);
+               return ERR_PTR(-ENOENT);
 
        dentry = d_obtain_alias(inode);
        if (IS_ERR(dentry)) {
-               pr_err("fh_to_parent %llx -- inode %p but ENOMEM\n",
-                      cfh->ino, inode);
                iput(inode);
                return dentry;
        }
        err = ceph_init_dentry(dentry);
        if (err < 0) {
-               iput(inode);
+               dput(dentry);
                return ERR_PTR(err);
        }
-       dout("fh_to_parent %llx %p dentry %p\n", cfh->ino, inode, dentry);
+       dout("__get_parent ino %llx parent %p ino %llx.%llx\n",
+            child ? ceph_ino(child->d_inode) : ino,
+            dentry, ceph_vinop(inode));
+       return dentry;
+}
+
+struct dentry *ceph_get_parent(struct dentry *child)
+{
+       /* don't re-export snaps */
+       if (ceph_snap(child->d_inode) != CEPH_NOSNAP)
+               return ERR_PTR(-EINVAL);
+
+       dout("get_parent %p ino %llx.%llx\n",
+            child, ceph_vinop(child->d_inode));
+       return __get_parent(child->d_sb, child, 0);
+}
+
+/*
+ * convert regular fh to parent
+ */
+static struct dentry *ceph_fh_to_parent(struct super_block *sb,
+                                       struct fid *fid,
+                                       int fh_len, int fh_type)
+{
+       struct ceph_nfs_confh *cfh = (void *)fid->raw;
+       struct dentry *dentry;
+
+       if (fh_type != FILEID_INO32_GEN_PARENT)
+               return NULL;
+       if (fh_len < sizeof(*cfh) / 4)
+               return NULL;
+
+       dout("fh_to_parent %llx\n", cfh->parent_ino);
+       dentry = __get_parent(sb, NULL, cfh->ino);
+       if (IS_ERR(dentry) && PTR_ERR(dentry) == -ENOENT)
+               dentry = __fh_to_dentry(sb, cfh->parent_ino);
        return dentry;
 }
 
+static int ceph_get_name(struct dentry *parent, char *name,
+                        struct dentry *child)
+{
+       struct ceph_mds_client *mdsc;
+       struct ceph_mds_request *req;
+       int err;
+
+       mdsc = ceph_inode_to_client(child->d_inode)->mdsc;
+       req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPNAME,
+                                      USE_ANY_MDS);
+       if (IS_ERR(req))
+               return PTR_ERR(req);
+
+       mutex_lock(&parent->d_inode->i_mutex);
+
+       req->r_inode = child->d_inode;
+       ihold(child->d_inode);
+       req->r_ino2 = ceph_vino(parent->d_inode);
+       req->r_locked_dir = parent->d_inode;
+       req->r_num_caps = 2;
+       err = ceph_mdsc_do_request(mdsc, NULL, req);
+
+       mutex_unlock(&parent->d_inode->i_mutex);
+
+       if (!err) {
+               struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
+               memcpy(name, rinfo->dname, rinfo->dname_len);
+               name[rinfo->dname_len] = 0;
+               dout("get_name %p ino %llx.%llx name %s\n",
+                    child, ceph_vinop(child->d_inode), name);
+       } else {
+               dout("get_name %p ino %llx.%llx err %d\n",
+                    child, ceph_vinop(child->d_inode), err);
+       }
+
+       ceph_mdsc_put_request(req);
+       return err;
+}
+
 const struct export_operations ceph_export_ops = {
        .encode_fh = ceph_encode_fh,
        .fh_to_dentry = ceph_fh_to_dentry,
        .fh_to_parent = ceph_fh_to_parent,
+       .get_parent = ceph_get_parent,
+       .get_name = ceph_get_name,
 };