[deliverable/linux.git] / fs / ceph / export.c

#include <linux/ceph/ceph_debug.h>

#include <linux/exportfs.h>
#include <linux/slab.h>
#include <asm/unaligned.h>

#include "super.h"
#include "mds_client.h"

/*
 * Basic fh
 */
struct ceph_nfs_fh {
	u64 ino;
} __attribute__ ((packed));

/*
 * Larger fh that includes parent ino.
 */
struct ceph_nfs_confh {
	u64 ino, parent_ino;
} __attribute__ ((packed));

static int ceph_encode_fh(struct inode *inode, u32 *rawfh, int *max_len,
			  struct inode *parent_inode)
{
	int type;
	struct ceph_nfs_fh *fh = (void *)rawfh;
	struct ceph_nfs_confh *cfh = (void *)rawfh;
	int connected_handle_length = sizeof(*cfh)/4;
	int handle_length = sizeof(*fh)/4;

	/* don't re-export snaps */
	if (ceph_snap(inode) != CEPH_NOSNAP)
		return -EINVAL;

	if (parent_inode && (*max_len < connected_handle_length)) {
		*max_len = connected_handle_length;
		return FILEID_INVALID;
	} else if (*max_len < handle_length) {
		*max_len = handle_length;
		return FILEID_INVALID;
	}

	if (parent_inode) {
		dout("encode_fh %llx with parent %llx\n",
		     ceph_ino(inode), ceph_ino(parent_inode));
		cfh->ino = ceph_ino(inode);
		cfh->parent_ino = ceph_ino(parent_inode);
		*max_len = connected_handle_length;
		type = FILEID_INO32_GEN_PARENT;
	} else {
		dout("encode_fh %llx\n", ceph_ino(inode));
		fh->ino = ceph_ino(inode);
		*max_len = handle_length;
		type = FILEID_INO32_GEN;
	}
	return type;
}

static struct dentry *__fh_to_dentry(struct super_block *sb, u64 ino)
{
	struct ceph_mds_client *mdsc = ceph_sb_to_client(sb)->mdsc;
	struct inode *inode;
	struct dentry *dentry;
	struct ceph_vino vino;
	int err;

	vino.ino = ino;
	vino.snap = CEPH_NOSNAP;
	inode = ceph_find_inode(sb, vino);
	if (!inode) {
		struct ceph_mds_request *req;
		int mask;

		req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPINO,
					       USE_ANY_MDS);
		if (IS_ERR(req))
			return ERR_CAST(req);

		mask = CEPH_STAT_CAP_INODE;
		if (ceph_security_xattr_wanted(d_inode(sb->s_root)))
			mask |= CEPH_CAP_XATTR_SHARED;
		req->r_args.getattr.mask = cpu_to_le32(mask);

		req->r_ino1 = vino;
		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);
	}

	dentry = d_obtain_alias(inode);
	if (IS_ERR(dentry)) {
		iput(inode);
		return dentry;
	}
	err = ceph_init_dentry(dentry);
	if (err < 0) {
		dput(dentry);
		return ERR_PTR(err);
	}
	dout("__fh_to_dentry %llx %p dentry %p\n", ino, inode, dentry);
	return dentry;
}

/*
 * convert regular fh to dentry
 */
static struct dentry *ceph_fh_to_dentry(struct super_block *sb,
					struct fid *fid,
					int fh_len, int fh_type)
{
	struct ceph_nfs_fh *fh = (void *)fid->raw;

	if (fh_type != FILEID_INO32_GEN  &&
	    fh_type != FILEID_INO32_GEN_PARENT)
		return NULL;
	if (fh_len < sizeof(*fh) / 4)
		return NULL;

	dout("fh_to_dentry %llx\n", fh->ino);
	return __fh_to_dentry(sb, fh->ino);
}

static struct dentry *__get_parent(struct super_block *sb,
				   struct dentry *child, u64 ino)
{
	struct ceph_mds_client *mdsc = ceph_sb_to_client(sb)->mdsc;
	struct ceph_mds_request *req;
	struct inode *inode;
	struct dentry *dentry;
	int mask;
	int err;

	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPPARENT,
				       USE_ANY_MDS);
	if (IS_ERR(req))
		return ERR_CAST(req);

	if (child) {
		req->r_inode = d_inode(child);
		ihold(d_inode(child));
	} else {
		req->r_ino1 = (struct ceph_vino) {
			.ino = ino,
			.snap = CEPH_NOSNAP,
		};
	}

	mask = CEPH_STAT_CAP_INODE;
	if (ceph_security_xattr_wanted(d_inode(sb->s_root)))
		mask |= CEPH_CAP_XATTR_SHARED;
	req->r_args.getattr.mask = cpu_to_le32(mask);

	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(-ENOENT);

	dentry = d_obtain_alias(inode);
	if (IS_ERR(dentry)) {
		iput(inode);
		return dentry;
	}
	err = ceph_init_dentry(dentry);
	if (err < 0) {
		dput(dentry);
		return ERR_PTR(err);
	}
	dout("__get_parent ino %llx parent %p ino %llx.%llx\n",
	     child ? ceph_ino(d_inode(child)) : ino,
	     dentry, ceph_vinop(inode));
	return dentry;
}

static struct dentry *ceph_get_parent(struct dentry *child)
{
	/* don't re-export snaps */
	if (ceph_snap(d_inode(child)) != CEPH_NOSNAP)
		return ERR_PTR(-EINVAL);

	dout("get_parent %p ino %llx.%llx\n",
	     child, ceph_vinop(d_inode(child)));
	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(d_inode(child))->mdsc;
	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPNAME,
				       USE_ANY_MDS);
	if (IS_ERR(req))
		return PTR_ERR(req);

	inode_lock(d_inode(parent));

	req->r_inode = d_inode(child);
	ihold(d_inode(child));
	req->r_ino2 = ceph_vino(d_inode(parent));
	req->r_locked_dir = d_inode(parent);
	req->r_num_caps = 2;
	err = ceph_mdsc_do_request(mdsc, NULL, req);

	inode_unlock(d_inode(parent));

	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(d_inode(child)), name);
	} else {
		dout("get_name %p ino %llx.%llx err %d\n",
		     child, ceph_vinop(d_inode(child)), 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,
};
Commit	Line	Data
3d14c5d2	1	#include <linux/ceph/ceph_debug.h>
a8e63b7d SW	2
a8e63b7d SW	3	#include <linux/exportfs.h>
5a0e3ad6	4	#include <linux/slab.h>
a8e63b7d SW	5	#include <asm/unaligned.h>
	6
	7	#include "super.h"
3d14c5d2	8	#include "mds_client.h"
a8e63b7d	9
a8e63b7d SW	10	/*
	11	* Basic fh
	12	*/
	13	struct ceph_nfs_fh {
	14	u64 ino;
	15	} __attribute__ ((packed));
	16
	17	/*
4f32b42d	18	* Larger fh that includes parent ino.
a8e63b7d SW	19	*/
	20	struct ceph_nfs_confh {
	21	u64 ino, parent_ino;
a8e63b7d SW	22	} __attribute__ ((packed));
a8e63b7d SW	23
c862868b SW	24	static int ceph_encode_fh(struct inode inode, u32 rawfh, int *max_len,
c862868b SW	25	struct inode *parent_inode)
a8e63b7d	26	{
92923dcb	27	int type;
a8e63b7d SW	28	struct ceph_nfs_fh fh = (void )rawfh;
a8e63b7d SW	29	struct ceph_nfs_confh cfh = (void )rawfh;
92923dcb AK	30	int connected_handle_length = sizeof(*cfh)/4;
92923dcb AK	31	int handle_length = sizeof(*fh)/4;
a8e63b7d SW	32
	33	/* don't re-export snaps */
	34	if (ceph_snap(inode) != CEPH_NOSNAP)
	35	return -EINVAL;
	36
4f32b42d YZ	37	if (parent_inode && (*max_len < connected_handle_length)) {
	38	*max_len = connected_handle_length;
	39	return FILEID_INVALID;
	40	} else if (*max_len < handle_length) {
	41	*max_len = handle_length;
	42	return FILEID_INVALID;
	43	}
f6af75da	44
4f32b42d YZ	45	if (parent_inode) {
	46	dout("encode_fh %llx with parent %llx\n",
	47	ceph_ino(inode), ceph_ino(parent_inode));
c862868b	48	cfh->ino = ceph_ino(inode);
4f32b42d	49	cfh->parent_ino = ceph_ino(parent_inode);
92923dcb	50	*max_len = connected_handle_length;
4f32b42d	51	type = FILEID_INO32_GEN_PARENT;
a8e63b7d	52	} else {
4f32b42d YZ	53	dout("encode_fh %llx\n", ceph_ino(inode));
4f32b42d YZ	54	fh->ino = ceph_ino(inode);
bba0cd0e	55	*max_len = handle_length;
4f32b42d	56	type = FILEID_INO32_GEN;
a8e63b7d SW	57	}
	58	return type;
	59	}
	60
4f32b42d	61	static struct dentry __fh_to_dentry(struct super_block sb, u64 ino)
a8e63b7d	62	{
3c454cf2	63	struct ceph_mds_client *mdsc = ceph_sb_to_client(sb)->mdsc;
a8e63b7d SW	64	struct inode *inode;
	65	struct dentry *dentry;
	66	struct ceph_vino vino;
	67	int err;
	68
4f32b42d	69	vino.ino = ino;
a8e63b7d SW	70	vino.snap = CEPH_NOSNAP;
a8e63b7d SW	71	inode = ceph_find_inode(sb, vino);
3c454cf2 SW	72	if (!inode) {
3c454cf2 SW	73	struct ceph_mds_request *req;
315f2408	74	int mask;
3c454cf2 SW	75
	76	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPINO,
	77	USE_ANY_MDS);
	78	if (IS_ERR(req))
	79	return ERR_CAST(req);
	80
315f2408 YZ	81	mask = CEPH_STAT_CAP_INODE;
	82	if (ceph_security_xattr_wanted(d_inode(sb->s_root)))
	83	mask \|= CEPH_CAP_XATTR_SHARED;
	84	req->r_args.getattr.mask = cpu_to_le32(mask);
	85
3c454cf2 SW	86	req->r_ino1 = vino;
	87	req->r_num_caps = 1;
	88	err = ceph_mdsc_do_request(mdsc, NULL, req);
45e3d3ee SW	89	inode = req->r_target_inode;
45e3d3ee SW	90	if (inode)
70b666c3	91	ihold(inode);
3c454cf2	92	ceph_mdsc_put_request(req);
3c454cf2 SW	93	if (!inode)
	94	return ERR_PTR(-ESTALE);
	95	}
a8e63b7d SW	96
a8e63b7d SW	97	dentry = d_obtain_alias(inode);
0d509c94	98	if (IS_ERR(dentry)) {
a8e63b7d	99	iput(inode);
0d509c94	100	return dentry;
a8e63b7d SW	101	}
a8e63b7d SW	102	err = ceph_init_dentry(dentry);
a8e63b7d	103	if (err < 0) {
4f32b42d	104	dput(dentry);
a8e63b7d SW	105	return ERR_PTR(err);
a8e63b7d SW	106	}
4f32b42d	107	dout("__fh_to_dentry %llx %p dentry %p\n", ino, inode, dentry);
a8e63b7d SW	108	return dentry;
	109	}
	110
	111	/*
4f32b42d	112	* convert regular fh to dentry
a8e63b7d	113	*/
4f32b42d YZ	114	static struct dentry ceph_fh_to_dentry(struct super_block sb,
	115	struct fid *fid,
	116	int fh_len, int fh_type)
a8e63b7d	117	{
4f32b42d	118	struct ceph_nfs_fh fh = (void )fid->raw;
a8e63b7d	119
4f32b42d YZ	120	if (fh_type != FILEID_INO32_GEN &&
	121	fh_type != FILEID_INO32_GEN_PARENT)
	122	return NULL;
	123	if (fh_len < sizeof(*fh) / 4)
	124	return NULL;
a8e63b7d	125
4f32b42d YZ	126	dout("fh_to_dentry %llx\n", fh->ino);
4f32b42d YZ	127	return __fh_to_dentry(sb, fh->ino);
a8e63b7d SW	128	}
a8e63b7d SW	129
9017c2ec YZ	130	static struct dentry __get_parent(struct super_block sb,
	131	struct dentry *child, u64 ino)
	132	{
	133	struct ceph_mds_client *mdsc = ceph_sb_to_client(sb)->mdsc;
	134	struct ceph_mds_request *req;
	135	struct inode *inode;
	136	struct dentry *dentry;
315f2408	137	int mask;
9017c2ec YZ	138	int err;
	139
	140	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPPARENT,
	141	USE_ANY_MDS);
	142	if (IS_ERR(req))
	143	return ERR_CAST(req);
	144
	145	if (child) {
2b0143b5 DH	146	req->r_inode = d_inode(child);
2b0143b5 DH	147	ihold(d_inode(child));
9017c2ec YZ	148	} else {
	149	req->r_ino1 = (struct ceph_vino) {
	150	.ino = ino,
	151	.snap = CEPH_NOSNAP,
	152	};
	153	}
315f2408 YZ	154
	155	mask = CEPH_STAT_CAP_INODE;
	156	if (ceph_security_xattr_wanted(d_inode(sb->s_root)))
	157	mask \|= CEPH_CAP_XATTR_SHARED;
	158	req->r_args.getattr.mask = cpu_to_le32(mask);
	159
9017c2ec YZ	160	req->r_num_caps = 1;
	161	err = ceph_mdsc_do_request(mdsc, NULL, req);
	162	inode = req->r_target_inode;
	163	if (inode)
	164	ihold(inode);
	165	ceph_mdsc_put_request(req);
	166	if (!inode)
	167	return ERR_PTR(-ENOENT);
	168
	169	dentry = d_obtain_alias(inode);
	170	if (IS_ERR(dentry)) {
	171	iput(inode);
	172	return dentry;
	173	}
	174	err = ceph_init_dentry(dentry);
	175	if (err < 0) {
	176	dput(dentry);
	177	return ERR_PTR(err);
	178	}
	179	dout("__get_parent ino %llx parent %p ino %llx.%llx\n",
2b0143b5	180	child ? ceph_ino(d_inode(child)) : ino,
9017c2ec YZ	181	dentry, ceph_vinop(inode));
	182	return dentry;
	183	}
	184
e84be11c	185	static struct dentry ceph_get_parent(struct dentry child)
9017c2ec YZ	186	{
9017c2ec YZ	187	/* don't re-export snaps */
2b0143b5	188	if (ceph_snap(d_inode(child)) != CEPH_NOSNAP)
9017c2ec YZ	189	return ERR_PTR(-EINVAL);
	190
	191	dout("get_parent %p ino %llx.%llx\n",
2b0143b5	192	child, ceph_vinop(d_inode(child)));
9017c2ec YZ	193	return __get_parent(child->d_sb, child, 0);
	194	}
	195
a8e63b7d	196	/*
8996f4f2	197	* convert regular fh to parent
a8e63b7d SW	198	*/
a8e63b7d SW	199	static struct dentry ceph_fh_to_parent(struct super_block sb,
8996f4f2	200	struct fid *fid,
a8e63b7d SW	201	int fh_len, int fh_type)
	202	{
	203	struct ceph_nfs_confh cfh = (void )fid->raw;
a8e63b7d	204	struct dentry *dentry;
a8e63b7d	205
8996f4f2 YZ	206	if (fh_type != FILEID_INO32_GEN_PARENT)
8996f4f2 YZ	207	return NULL;
35c2a7f4	208	if (fh_len < sizeof(*cfh) / 4)
8996f4f2	209	return NULL;
a8e63b7d	210
8996f4f2 YZ	211	dout("fh_to_parent %llx\n", cfh->parent_ino);
	212	dentry = __get_parent(sb, NULL, cfh->ino);
	213	if (IS_ERR(dentry) && PTR_ERR(dentry) == -ENOENT)
	214	dentry = __fh_to_dentry(sb, cfh->parent_ino);
a8e63b7d SW	215	return dentry;
	216	}
	217
19913b4e YZ	218	static int ceph_get_name(struct dentry parent, char name,
	219	struct dentry *child)
	220	{
	221	struct ceph_mds_client *mdsc;
	222	struct ceph_mds_request *req;
	223	int err;
	224
2b0143b5	225	mdsc = ceph_inode_to_client(d_inode(child))->mdsc;
19913b4e YZ	226	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPNAME,
	227	USE_ANY_MDS);
	228	if (IS_ERR(req))
	229	return PTR_ERR(req);
	230
5955102c	231	inode_lock(d_inode(parent));
19913b4e	232
2b0143b5 DH	233	req->r_inode = d_inode(child);
	234	ihold(d_inode(child));
	235	req->r_ino2 = ceph_vino(d_inode(parent));
	236	req->r_locked_dir = d_inode(parent);
19913b4e YZ	237	req->r_num_caps = 2;
	238	err = ceph_mdsc_do_request(mdsc, NULL, req);
	239
5955102c	240	inode_unlock(d_inode(parent));
19913b4e YZ	241
	242	if (!err) {
	243	struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
	244	memcpy(name, rinfo->dname, rinfo->dname_len);
	245	name[rinfo->dname_len] = 0;
	246	dout("get_name %p ino %llx.%llx name %s\n",
2b0143b5	247	child, ceph_vinop(d_inode(child)), name);
19913b4e YZ	248	} else {
19913b4e YZ	249	dout("get_name %p ino %llx.%llx err %d\n",
2b0143b5	250	child, ceph_vinop(d_inode(child)), err);
19913b4e YZ	251	}
	252
	253	ceph_mdsc_put_request(req);
	254	return err;
	255	}
	256
a8e63b7d SW	257	const struct export_operations ceph_export_ops = {
	258	.encode_fh = ceph_encode_fh,
	259	.fh_to_dentry = ceph_fh_to_dentry,
	260	.fh_to_parent = ceph_fh_to_parent,
9017c2ec	261	.get_parent = ceph_get_parent,
19913b4e	262	.get_name = ceph_get_name,
a8e63b7d	263	};