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

// SPDX-License-Identifier: GPL-2.0
#include <linux/ceph/ceph_debug.h>

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

#include "super.h"
#include "mds_client.h"
#include "crypto.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));

/*
 * fh for snapped inode
 */
struct ceph_nfs_snapfh {
	u64 ino;
	u64 snapid;
	u64 parent_ino;
	u32 hash;
} __attribute__ ((packed));

static int ceph_encode_snapfh(struct inode *inode, u32 *rawfh, int *max_len,
			      struct inode *parent_inode)
{
	struct ceph_client *cl = ceph_inode_to_client(inode);
	static const int snap_handle_length =
		sizeof(struct ceph_nfs_snapfh) >> 2;
	struct ceph_nfs_snapfh *sfh = (void *)rawfh;
	u64 snapid = ceph_snap(inode);
	int ret;
	bool no_parent = true;

	if (*max_len < snap_handle_length) {
		*max_len = snap_handle_length;
		ret = FILEID_INVALID;
		goto out;
	}

	ret =  -EINVAL;
	if (snapid != CEPH_SNAPDIR) {
		struct inode *dir;
		struct dentry *dentry = d_find_alias(inode);
		if (!dentry)
			goto out;

		rcu_read_lock();
		dir = d_inode_rcu(dentry->d_parent);
		if (ceph_snap(dir) != CEPH_SNAPDIR) {
			sfh->parent_ino = ceph_ino(dir);
			sfh->hash = ceph_dentry_hash(dir, dentry);
			no_parent = false;
		}
		rcu_read_unlock();
		dput(dentry);
	}

	if (no_parent) {
		if (!S_ISDIR(inode->i_mode))
			goto out;
		sfh->parent_ino = sfh->ino;
		sfh->hash = 0;
	}
	sfh->ino = ceph_ino(inode);
	sfh->snapid = snapid;

	*max_len = snap_handle_length;
	ret = FILEID_BTRFS_WITH_PARENT;
out:
	doutc(cl, "%p %llx.%llx ret=%d\n", inode, ceph_vinop(inode), ret);
	return ret;
}

static int ceph_encode_fh(struct inode *inode, u32 *rawfh, int *max_len,
			  struct inode *parent_inode)
{
	struct ceph_client *cl = ceph_inode_to_client(inode);
	static const int handle_length =
		sizeof(struct ceph_nfs_fh) >> 2;
	static const int connected_handle_length =
		sizeof(struct ceph_nfs_confh) >> 2;
	int type;

	if (ceph_snap(inode) != CEPH_NOSNAP)
		return ceph_encode_snapfh(inode, rawfh, max_len, parent_inode);

	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) {
		struct ceph_nfs_confh *cfh = (void *)rawfh;
		doutc(cl, "%p %llx.%llx with parent %p %llx.%llx\n", inode,
		      ceph_vinop(inode), parent_inode, ceph_vinop(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 {
		struct ceph_nfs_fh *fh = (void *)rawfh;
		doutc(cl, "%p %llx.%llx\n", inode, ceph_vinop(inode));
		fh->ino = ceph_ino(inode);
		*max_len = handle_length;
		type = FILEID_INO32_GEN;
	}
	return type;
}

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

	vino.ino = ino;
	vino.snap = CEPH_NOSNAP;

	if (ceph_vino_is_reserved(vino))
		return ERR_PTR(-ESTALE);

	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.lookupino.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 < 0 ? ERR_PTR(err) : ERR_PTR(-ESTALE);
	} else {
		if (ceph_inode_is_shutdown(inode)) {
			iput(inode);
			return ERR_PTR(-ESTALE);
		}
	}
	return inode;
}

struct inode *ceph_lookup_inode(struct super_block *sb, u64 ino)
{
	struct inode *inode = __lookup_inode(sb, ino);
	if (IS_ERR(inode))
		return inode;
	if (inode->i_nlink == 0) {
		iput(inode);
		return ERR_PTR(-ESTALE);
	}
	return inode;
}

static struct dentry *__fh_to_dentry(struct super_block *sb, u64 ino)
{
	struct inode *inode = __lookup_inode(sb, ino);
	struct ceph_inode_info *ci = ceph_inode(inode);
	int err;

	if (IS_ERR(inode))
		return ERR_CAST(inode);
	/* We need LINK caps to reliably check i_nlink */
	err = ceph_do_getattr(inode, CEPH_CAP_LINK_SHARED, false);
	if (err) {
		iput(inode);
		return ERR_PTR(err);
	}
	/* -ESTALE if inode as been unlinked and no file is open */
	if ((inode->i_nlink == 0) && !__ceph_is_file_opened(ci)) {
		iput(inode);
		return ERR_PTR(-ESTALE);
	}
	return d_obtain_alias(inode);
}

static struct dentry *__snapfh_to_dentry(struct super_block *sb,
					  struct ceph_nfs_snapfh *sfh,
					  bool want_parent)
{
	struct ceph_mds_client *mdsc = ceph_sb_to_fs_client(sb)->mdsc;
	struct ceph_client *cl = mdsc->fsc->client;
	struct ceph_mds_request *req;
	struct inode *inode;
	struct ceph_vino vino;
	int mask;
	int err;
	bool unlinked = false;

	if (want_parent) {
		vino.ino = sfh->parent_ino;
		if (sfh->snapid == CEPH_SNAPDIR)
			vino.snap = CEPH_NOSNAP;
		else if (sfh->ino == sfh->parent_ino)
			vino.snap = CEPH_SNAPDIR;
		else
			vino.snap = sfh->snapid;
	} else {
		vino.ino = sfh->ino;
		vino.snap = sfh->snapid;
	}

	if (ceph_vino_is_reserved(vino))
		return ERR_PTR(-ESTALE);

	inode = ceph_find_inode(sb, vino);
	if (inode) {
		if (ceph_inode_is_shutdown(inode)) {
			iput(inode);
			return ERR_PTR(-ESTALE);
		}
		return d_obtain_alias(inode);
	}

	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.lookupino.mask = cpu_to_le32(mask);
	if (vino.snap < CEPH_NOSNAP) {
		req->r_args.lookupino.snapid = cpu_to_le64(vino.snap);
		if (!want_parent && sfh->ino != sfh->parent_ino) {
			req->r_args.lookupino.parent =
					cpu_to_le64(sfh->parent_ino);
			req->r_args.lookupino.hash =
					cpu_to_le32(sfh->hash);
		}
	}

	req->r_ino1 = vino;
	req->r_num_caps = 1;
	err = ceph_mdsc_do_request(mdsc, NULL, req);
	inode = req->r_target_inode;
	if (inode) {
		if (vino.snap == CEPH_SNAPDIR) {
			if (inode->i_nlink == 0)
				unlinked = true;
			inode = ceph_get_snapdir(inode);
		} else if (ceph_snap(inode) == vino.snap) {
			ihold(inode);
		} else {
			/* mds does not support lookup snapped inode */
			inode = ERR_PTR(-EOPNOTSUPP);
		}
	} else {
		inode = ERR_PTR(-ESTALE);
	}
	ceph_mdsc_put_request(req);

	if (want_parent) {
		doutc(cl, "%llx.%llx\n err=%d\n", vino.ino, vino.snap, err);
	} else {
		doutc(cl, "%llx.%llx parent %llx hash %x err=%d", vino.ino,
		      vino.snap, sfh->parent_ino, sfh->hash, err);
	}
	/* see comments in ceph_get_parent() */
	return unlinked ? d_obtain_root(inode) : d_obtain_alias(inode);
}

/*
 * 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_fs_client *fsc = ceph_sb_to_fs_client(sb);
	struct ceph_nfs_fh *fh = (void *)fid->raw;

	if (fh_type == FILEID_BTRFS_WITH_PARENT) {
		struct ceph_nfs_snapfh *sfh = (void *)fid->raw;
		return __snapfh_to_dentry(sb, sfh, false);
	}

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

	doutc(fsc->client, "%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_fs_client(sb)->mdsc;
	struct ceph_mds_request *req;
	struct inode *inode;
	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);
	if (err) {
		ceph_mdsc_put_request(req);
		return ERR_PTR(err);
	}

	inode = req->r_target_inode;
	if (inode)
		ihold(inode);
	ceph_mdsc_put_request(req);
	if (!inode)
		return ERR_PTR(-ENOENT);

	return d_obtain_alias(inode);
}

static struct dentry *ceph_get_parent(struct dentry *child)
{
	struct inode *inode = d_inode(child);
	struct ceph_client *cl = ceph_inode_to_client(inode);
	struct dentry *dn;

	if (ceph_snap(inode) != CEPH_NOSNAP) {
		struct inode* dir;
		bool unlinked = false;
		/* do not support non-directory */
		if (!d_is_dir(child)) {
			dn = ERR_PTR(-EINVAL);
			goto out;
		}
		dir = __lookup_inode(inode->i_sb, ceph_ino(inode));
		if (IS_ERR(dir)) {
			dn = ERR_CAST(dir);
			goto out;
		}
		/* There can be multiple paths to access snapped inode.
		 * For simplicity, treat snapdir of head inode as parent */
		if (ceph_snap(inode) != CEPH_SNAPDIR) {
			struct inode *snapdir = ceph_get_snapdir(dir);
			if (dir->i_nlink == 0)
				unlinked = true;
			iput(dir);
			if (IS_ERR(snapdir)) {
				dn = ERR_CAST(snapdir);
				goto out;
			}
			dir = snapdir;
		}
		/* If directory has already been deleted, further get_parent
		 * will fail. Do not mark snapdir dentry as disconnected,
		 * this prevents exportfs from doing further get_parent. */
		if (unlinked)
			dn = d_obtain_root(dir);
		else
			dn = d_obtain_alias(dir);
	} else {
		dn = __get_parent(child->d_sb, child, 0);
	}
out:
	doutc(cl, "child %p %p %llx.%llx err=%ld\n", child, inode,
	      ceph_vinop(inode), (long)PTR_ERR_OR_ZERO(dn));
	return dn;
}

/*
 * 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_fs_client *fsc = ceph_sb_to_fs_client(sb);
	struct ceph_nfs_confh *cfh = (void *)fid->raw;
	struct dentry *dentry;

	if (fh_type == FILEID_BTRFS_WITH_PARENT) {
		struct ceph_nfs_snapfh *sfh = (void *)fid->raw;
		return __snapfh_to_dentry(sb, sfh, true);
	}

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

	doutc(fsc->client, "%llx\n", cfh->parent_ino);
	dentry = __get_parent(sb, NULL, cfh->ino);
	if (unlikely(dentry == ERR_PTR(-ENOENT)))
		dentry = __fh_to_dentry(sb, cfh->parent_ino);
	return dentry;
}

static int __get_snap_name(struct dentry *parent, char *name,
			   struct dentry *child)
{
	struct inode *inode = d_inode(child);
	struct inode *dir = d_inode(parent);
	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
	struct ceph_mds_request *req = NULL;
	char *last_name = NULL;
	unsigned next_offset = 2;
	int err = -EINVAL;

	if (ceph_ino(inode) != ceph_ino(dir))
		goto out;
	if (ceph_snap(inode) == CEPH_SNAPDIR) {
		if (ceph_snap(dir) == CEPH_NOSNAP) {
			/*
			 * .get_name() from struct export_operations
			 * assumes that its 'name' parameter is pointing
			 * to a NAME_MAX+1 sized buffer
			 */
			strscpy(name, fsc->mount_options->snapdir_name,
				NAME_MAX + 1);
			err = 0;
		}
		goto out;
	}
	if (ceph_snap(dir) != CEPH_SNAPDIR)
		goto out;

	while (1) {
		struct ceph_mds_reply_info_parsed *rinfo;
		struct ceph_mds_reply_dir_entry *rde;
		int i;

		req = ceph_mdsc_create_request(fsc->mdsc, CEPH_MDS_OP_LSSNAP,
					       USE_AUTH_MDS);
		if (IS_ERR(req)) {
			err = PTR_ERR(req);
			req = NULL;
			goto out;
		}
		err = ceph_alloc_readdir_reply_buffer(req, inode);
		if (err)
			goto out;

		req->r_direct_mode = USE_AUTH_MDS;
		req->r_readdir_offset = next_offset;
		req->r_args.readdir.flags =
				cpu_to_le16(CEPH_READDIR_REPLY_BITFLAGS);
		if (last_name) {
			req->r_path2 = last_name;
			last_name = NULL;
		}

		req->r_inode = dir;
		ihold(dir);
		req->r_dentry = dget(parent);

		inode_lock(dir);
		err = ceph_mdsc_do_request(fsc->mdsc, NULL, req);
		inode_unlock(dir);

		if (err < 0)
			goto out;

		rinfo = &req->r_reply_info;
		for (i = 0; i < rinfo->dir_nr; i++) {
			rde = rinfo->dir_entries + i;
			BUG_ON(!rde->inode.in);
			if (ceph_snap(inode) ==
			    le64_to_cpu(rde->inode.in->snapid)) {
				memcpy(name, rde->name, rde->name_len);
				name[rde->name_len] = '\0';
				err = 0;
				goto out;
			}
		}

		if (rinfo->dir_end)
			break;

		BUG_ON(rinfo->dir_nr <= 0);
		rde = rinfo->dir_entries + (rinfo->dir_nr - 1);
		next_offset += rinfo->dir_nr;
		last_name = kstrndup(rde->name, rde->name_len, GFP_KERNEL);
		if (!last_name) {
			err = -ENOMEM;
			goto out;
		}

		ceph_mdsc_put_request(req);
		req = NULL;
	}
	err = -ENOENT;
out:
	if (req)
		ceph_mdsc_put_request(req);
	kfree(last_name);
	doutc(fsc->client, "child dentry %p %p %llx.%llx err=%d\n", child,
	      inode, ceph_vinop(inode), err);
	return err;
}

static int ceph_get_name(struct dentry *parent, char *name,
			 struct dentry *child)
{
	struct ceph_mds_client *mdsc;
	struct ceph_mds_request *req;
	struct inode *dir = d_inode(parent);
	struct inode *inode = d_inode(child);
	struct ceph_mds_reply_info_parsed *rinfo;
	int err;

	if (ceph_snap(inode) != CEPH_NOSNAP)
		return __get_snap_name(parent, name, child);

	mdsc = ceph_inode_to_fs_client(inode)->mdsc;
	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPNAME,
				       USE_ANY_MDS);
	if (IS_ERR(req))
		return PTR_ERR(req);

	inode_lock(dir);
	req->r_inode = inode;
	ihold(inode);
	req->r_ino2 = ceph_vino(d_inode(parent));
	req->r_parent = dir;
	ihold(dir);
	set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags);
	req->r_num_caps = 2;
	err = ceph_mdsc_do_request(mdsc, NULL, req);
	inode_unlock(dir);

	if (err)
		goto out;

	rinfo = &req->r_reply_info;
	if (!IS_ENCRYPTED(dir)) {
		memcpy(name, rinfo->dname, rinfo->dname_len);
		name[rinfo->dname_len] = 0;
	} else {
		struct fscrypt_str oname = FSTR_INIT(NULL, 0);
		struct ceph_fname fname = { .dir	= dir,
					    .name	= rinfo->dname,
					    .ctext	= rinfo->altname,
					    .name_len	= rinfo->dname_len,
					    .ctext_len	= rinfo->altname_len };

		err = ceph_fname_alloc_buffer(dir, &oname);
		if (err < 0)
			goto out;

		err = ceph_fname_to_usr(&fname, NULL, &oname, NULL);
		if (!err) {
			memcpy(name, oname.name, oname.len);
			name[oname.len] = 0;
		}
		ceph_fname_free_buffer(dir, &oname);
	}
out:
	doutc(mdsc->fsc->client, "child dentry %p %p %llx.%llx err %d %s%s\n",
	      child, inode, ceph_vinop(inode), err, err ? "" : "name ",
	      err ? "" : name);
	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
b2441318	1	// SPDX-License-Identifier: GPL-2.0
3d14c5d2	2	#include <linux/ceph/ceph_debug.h>
a8e63b7d SW	3
a8e63b7d SW	4	#include <linux/exportfs.h>
5a0e3ad6	5	#include <linux/slab.h>
5f60d5f6	6	#include <linux/unaligned.h>
a8e63b7d SW	7
a8e63b7d SW	8	#include "super.h"
3d14c5d2	9	#include "mds_client.h"
85529096	10	#include "crypto.h"
a8e63b7d	11
a8e63b7d SW	12	/*
	13	* Basic fh
	14	*/
	15	struct ceph_nfs_fh {
	16	u64 ino;
	17	} __attribute__ ((packed));
	18
	19	/*
4f32b42d	20	* Larger fh that includes parent ino.
a8e63b7d SW	21	*/
	22	struct ceph_nfs_confh {
	23	u64 ino, parent_ino;
a8e63b7d SW	24	} __attribute__ ((packed));
a8e63b7d SW	25
570df4e9 YZ	26	/*
	27	* fh for snapped inode
	28	*/
	29	struct ceph_nfs_snapfh {
	30	u64 ino;
	31	u64 snapid;
	32	u64 parent_ino;
	33	u32 hash;
	34	} __attribute__ ((packed));
	35
	36	static int ceph_encode_snapfh(struct inode inode, u32 rawfh, int *max_len,
	37	struct inode *parent_inode)
	38	{
38d46409	39	struct ceph_client *cl = ceph_inode_to_client(inode);
536cc331	40	static const int snap_handle_length =
570df4e9 YZ	41	sizeof(struct ceph_nfs_snapfh) >> 2;
	42	struct ceph_nfs_snapfh sfh = (void )rawfh;
	43	u64 snapid = ceph_snap(inode);
	44	int ret;
	45	bool no_parent = true;
	46
	47	if (*max_len < snap_handle_length) {
	48	*max_len = snap_handle_length;
	49	ret = FILEID_INVALID;
	50	goto out;
	51	}
	52
	53	ret = -EINVAL;
	54	if (snapid != CEPH_SNAPDIR) {
	55	struct inode *dir;
	56	struct dentry *dentry = d_find_alias(inode);
	57	if (!dentry)
	58	goto out;
	59
	60	rcu_read_lock();
	61	dir = d_inode_rcu(dentry->d_parent);
	62	if (ceph_snap(dir) != CEPH_SNAPDIR) {
	63	sfh->parent_ino = ceph_ino(dir);
	64	sfh->hash = ceph_dentry_hash(dir, dentry);
	65	no_parent = false;
	66	}
	67	rcu_read_unlock();
	68	dput(dentry);
	69	}
	70
	71	if (no_parent) {
	72	if (!S_ISDIR(inode->i_mode))
	73	goto out;
	74	sfh->parent_ino = sfh->ino;
	75	sfh->hash = 0;
	76	}
	77	sfh->ino = ceph_ino(inode);
	78	sfh->snapid = snapid;
	79
	80	*max_len = snap_handle_length;
	81	ret = FILEID_BTRFS_WITH_PARENT;
	82	out:
38d46409	83	doutc(cl, "%p %llx.%llx ret=%d\n", inode, ceph_vinop(inode), ret);
570df4e9 YZ	84	return ret;
	85	}
	86
c862868b SW	87	static int ceph_encode_fh(struct inode inode, u32 rawfh, int *max_len,
c862868b SW	88	struct inode *parent_inode)
a8e63b7d	89	{
38d46409	90	struct ceph_client *cl = ceph_inode_to_client(inode);
536cc331	91	static const int handle_length =
570df4e9	92	sizeof(struct ceph_nfs_fh) >> 2;
536cc331	93	static const int connected_handle_length =
570df4e9	94	sizeof(struct ceph_nfs_confh) >> 2;
92923dcb	95	int type;
a8e63b7d	96
a8e63b7d	97	if (ceph_snap(inode) != CEPH_NOSNAP)
570df4e9	98	return ceph_encode_snapfh(inode, rawfh, max_len, parent_inode);
a8e63b7d	99
4f32b42d YZ	100	if (parent_inode && (*max_len < connected_handle_length)) {
	101	*max_len = connected_handle_length;
	102	return FILEID_INVALID;
	103	} else if (*max_len < handle_length) {
	104	*max_len = handle_length;
	105	return FILEID_INVALID;
	106	}
f6af75da	107
4f32b42d	108	if (parent_inode) {
570df4e9	109	struct ceph_nfs_confh cfh = (void )rawfh;
38d46409 XL	110	doutc(cl, "%p %llx.%llx with parent %p %llx.%llx\n", inode,
38d46409 XL	111	ceph_vinop(inode), parent_inode, ceph_vinop(parent_inode));
c862868b	112	cfh->ino = ceph_ino(inode);
4f32b42d	113	cfh->parent_ino = ceph_ino(parent_inode);
92923dcb	114	*max_len = connected_handle_length;
4f32b42d	115	type = FILEID_INO32_GEN_PARENT;
a8e63b7d	116	} else {
570df4e9	117	struct ceph_nfs_fh fh = (void )rawfh;
38d46409	118	doutc(cl, "%p %llx.%llx\n", inode, ceph_vinop(inode));
4f32b42d	119	fh->ino = ceph_ino(inode);
bba0cd0e	120	*max_len = handle_length;
4f32b42d	121	type = FILEID_INO32_GEN;
a8e63b7d SW	122	}
	123	return type;
	124	}
	125
570df4e9	126	static struct inode __lookup_inode(struct super_block sb, u64 ino)
a8e63b7d	127	{
5995d90d	128	struct ceph_mds_client *mdsc = ceph_sb_to_fs_client(sb)->mdsc;
a8e63b7d	129	struct inode *inode;
a8e63b7d SW	130	struct ceph_vino vino;
	131	int err;
	132
4f32b42d	133	vino.ino = ino;
a8e63b7d	134	vino.snap = CEPH_NOSNAP;
d4f6b31d JL	135
	136	if (ceph_vino_is_reserved(vino))
	137	return ERR_PTR(-ESTALE);
	138
a8e63b7d	139	inode = ceph_find_inode(sb, vino);
3c454cf2 SW	140	if (!inode) {
3c454cf2 SW	141	struct ceph_mds_request *req;
315f2408	142	int mask;
3c454cf2 SW	143
	144	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPINO,
	145	USE_ANY_MDS);
	146	if (IS_ERR(req))
	147	return ERR_CAST(req);
	148
315f2408 YZ	149	mask = CEPH_STAT_CAP_INODE;
	150	if (ceph_security_xattr_wanted(d_inode(sb->s_root)))
	151	mask \|= CEPH_CAP_XATTR_SHARED;
570df4e9	152	req->r_args.lookupino.mask = cpu_to_le32(mask);
315f2408	153
3c454cf2 SW	154	req->r_ino1 = vino;
	155	req->r_num_caps = 1;
	156	err = ceph_mdsc_do_request(mdsc, NULL, req);
45e3d3ee SW	157	inode = req->r_target_inode;
45e3d3ee SW	158	if (inode)
70b666c3	159	ihold(inode);
3c454cf2	160	ceph_mdsc_put_request(req);
3c454cf2	161	if (!inode)
3886274a	162	return err < 0 ? ERR_PTR(err) : ERR_PTR(-ESTALE);
5d6451b1 JL	163	} else {
	164	if (ceph_inode_is_shutdown(inode)) {
	165	iput(inode);
	166	return ERR_PTR(-ESTALE);
	167	}
3c454cf2	168	}
570df4e9 YZ	169	return inode;
570df4e9 YZ	170	}
a8e63b7d	171
570df4e9 YZ	172	struct inode ceph_lookup_inode(struct super_block sb, u64 ino)
	173	{
	174	struct inode *inode = __lookup_inode(sb, ino);
	175	if (IS_ERR(inode))
	176	return inode;
	177	if (inode->i_nlink == 0) {
	178	iput(inode);
	179	return ERR_PTR(-ESTALE);
	180	}
3886274a LH	181	return inode;
	182	}
	183
	184	static struct dentry __fh_to_dentry(struct super_block sb, u64 ino)
	185	{
570df4e9	186	struct inode *inode = __lookup_inode(sb, ino);
bd04b919	187	struct ceph_inode_info *ci = ceph_inode(inode);
878dabb6 LH	188	int err;
878dabb6 LH	189
3886274a LH	190	if (IS_ERR(inode))
3886274a LH	191	return ERR_CAST(inode);
878dabb6 LH	192	/* We need LINK caps to reliably check i_nlink */
878dabb6 LH	193	err = ceph_do_getattr(inode, CEPH_CAP_LINK_SHARED, false);
1775c7dd JL	194	if (err) {
1775c7dd JL	195	iput(inode);
878dabb6	196	return ERR_PTR(err);
1775c7dd	197	}
878dabb6	198	/* -ESTALE if inode as been unlinked and no file is open */
bd04b919	199	if ((inode->i_nlink == 0) && !__ceph_is_file_opened(ci)) {
570df4e9 YZ	200	iput(inode);
	201	return ERR_PTR(-ESTALE);
	202	}
ad5cb123	203	return d_obtain_alias(inode);
a8e63b7d SW	204	}
a8e63b7d SW	205
570df4e9 YZ	206	static struct dentry __snapfh_to_dentry(struct super_block sb,
	207	struct ceph_nfs_snapfh *sfh,
	208	bool want_parent)
	209	{
5995d90d	210	struct ceph_mds_client *mdsc = ceph_sb_to_fs_client(sb)->mdsc;
38d46409	211	struct ceph_client *cl = mdsc->fsc->client;
570df4e9 YZ	212	struct ceph_mds_request *req;
	213	struct inode *inode;
	214	struct ceph_vino vino;
	215	int mask;
	216	int err;
	217	bool unlinked = false;
	218
	219	if (want_parent) {
	220	vino.ino = sfh->parent_ino;
	221	if (sfh->snapid == CEPH_SNAPDIR)
	222	vino.snap = CEPH_NOSNAP;
	223	else if (sfh->ino == sfh->parent_ino)
	224	vino.snap = CEPH_SNAPDIR;
	225	else
	226	vino.snap = sfh->snapid;
	227	} else {
	228	vino.ino = sfh->ino;
	229	vino.snap = sfh->snapid;
	230	}
d4f6b31d JL	231
	232	if (ceph_vino_is_reserved(vino))
	233	return ERR_PTR(-ESTALE);
	234
570df4e9	235	inode = ceph_find_inode(sb, vino);
5d6451b1 JL	236	if (inode) {
	237	if (ceph_inode_is_shutdown(inode)) {
	238	iput(inode);
	239	return ERR_PTR(-ESTALE);
	240	}
570df4e9	241	return d_obtain_alias(inode);
5d6451b1	242	}
570df4e9 YZ	243
	244	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPINO,
	245	USE_ANY_MDS);
	246	if (IS_ERR(req))
	247	return ERR_CAST(req);
	248
	249	mask = CEPH_STAT_CAP_INODE;
	250	if (ceph_security_xattr_wanted(d_inode(sb->s_root)))
	251	mask \|= CEPH_CAP_XATTR_SHARED;
	252	req->r_args.lookupino.mask = cpu_to_le32(mask);
	253	if (vino.snap < CEPH_NOSNAP) {
	254	req->r_args.lookupino.snapid = cpu_to_le64(vino.snap);
	255	if (!want_parent && sfh->ino != sfh->parent_ino) {
	256	req->r_args.lookupino.parent =
	257	cpu_to_le64(sfh->parent_ino);
	258	req->r_args.lookupino.hash =
	259	cpu_to_le32(sfh->hash);
	260	}
	261	}
	262
	263	req->r_ino1 = vino;
	264	req->r_num_caps = 1;
	265	err = ceph_mdsc_do_request(mdsc, NULL, req);
	266	inode = req->r_target_inode;
	267	if (inode) {
	268	if (vino.snap == CEPH_SNAPDIR) {
	269	if (inode->i_nlink == 0)
	270	unlinked = true;
	271	inode = ceph_get_snapdir(inode);
	272	} else if (ceph_snap(inode) == vino.snap) {
	273	ihold(inode);
	274	} else {
	275	/* mds does not support lookup snapped inode */
3e10a15f	276	inode = ERR_PTR(-EOPNOTSUPP);
570df4e9	277	}
3e10a15f JL	278	} else {
3e10a15f JL	279	inode = ERR_PTR(-ESTALE);
570df4e9 YZ	280	}
	281	ceph_mdsc_put_request(req);
	282
	283	if (want_parent) {
38d46409	284	doutc(cl, "%llx.%llx\n err=%d\n", vino.ino, vino.snap, err);
570df4e9	285	} else {
38d46409 XL	286	doutc(cl, "%llx.%llx parent %llx hash %x err=%d", vino.ino,
38d46409 XL	287	vino.snap, sfh->parent_ino, sfh->hash, err);
570df4e9	288	}
570df4e9 YZ	289	/* see comments in ceph_get_parent() */
	290	return unlinked ? d_obtain_root(inode) : d_obtain_alias(inode);
	291	}
	292
a8e63b7d	293	/*
4f32b42d	294	* convert regular fh to dentry
a8e63b7d	295	*/
4f32b42d YZ	296	static struct dentry ceph_fh_to_dentry(struct super_block sb,
	297	struct fid *fid,
	298	int fh_len, int fh_type)
a8e63b7d	299	{
38d46409	300	struct ceph_fs_client *fsc = ceph_sb_to_fs_client(sb);
4f32b42d	301	struct ceph_nfs_fh fh = (void )fid->raw;
a8e63b7d	302
570df4e9 YZ	303	if (fh_type == FILEID_BTRFS_WITH_PARENT) {
	304	struct ceph_nfs_snapfh sfh = (void )fid->raw;
	305	return __snapfh_to_dentry(sb, sfh, false);
	306	}
	307
4f32b42d YZ	308	if (fh_type != FILEID_INO32_GEN &&
	309	fh_type != FILEID_INO32_GEN_PARENT)
	310	return NULL;
	311	if (fh_len < sizeof(*fh) / 4)
	312	return NULL;
a8e63b7d	313
38d46409	314	doutc(fsc->client, "%llx\n", fh->ino);
4f32b42d	315	return __fh_to_dentry(sb, fh->ino);
a8e63b7d SW	316	}
a8e63b7d SW	317
9017c2ec YZ	318	static struct dentry __get_parent(struct super_block sb,
	319	struct dentry *child, u64 ino)
	320	{
5995d90d	321	struct ceph_mds_client *mdsc = ceph_sb_to_fs_client(sb)->mdsc;
9017c2ec YZ	322	struct ceph_mds_request *req;
9017c2ec YZ	323	struct inode *inode;
315f2408	324	int mask;
9017c2ec YZ	325	int err;
	326
	327	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPPARENT,
	328	USE_ANY_MDS);
	329	if (IS_ERR(req))
	330	return ERR_CAST(req);
	331
	332	if (child) {
2b0143b5 DH	333	req->r_inode = d_inode(child);
2b0143b5 DH	334	ihold(d_inode(child));
9017c2ec YZ	335	} else {
	336	req->r_ino1 = (struct ceph_vino) {
	337	.ino = ino,
	338	.snap = CEPH_NOSNAP,
	339	};
	340	}
315f2408 YZ	341
	342	mask = CEPH_STAT_CAP_INODE;
	343	if (ceph_security_xattr_wanted(d_inode(sb->s_root)))
	344	mask \|= CEPH_CAP_XATTR_SHARED;
	345	req->r_args.getattr.mask = cpu_to_le32(mask);
	346
9017c2ec YZ	347	req->r_num_caps = 1;
9017c2ec YZ	348	err = ceph_mdsc_do_request(mdsc, NULL, req);
c6d50296 QH	349	if (err) {
	350	ceph_mdsc_put_request(req);
	351	return ERR_PTR(err);
	352	}
	353
9017c2ec YZ	354	inode = req->r_target_inode;
	355	if (inode)
	356	ihold(inode);
	357	ceph_mdsc_put_request(req);
	358	if (!inode)
	359	return ERR_PTR(-ENOENT);
	360
ad5cb123	361	return d_obtain_alias(inode);
9017c2ec YZ	362	}
9017c2ec YZ	363
e84be11c	364	static struct dentry ceph_get_parent(struct dentry child)
9017c2ec	365	{
570df4e9	366	struct inode *inode = d_inode(child);
38d46409	367	struct ceph_client *cl = ceph_inode_to_client(inode);
570df4e9 YZ	368	struct dentry *dn;
	369
	370	if (ceph_snap(inode) != CEPH_NOSNAP) {
	371	struct inode* dir;
	372	bool unlinked = false;
	373	/* do not support non-directory */
	374	if (!d_is_dir(child)) {
	375	dn = ERR_PTR(-EINVAL);
	376	goto out;
	377	}
	378	dir = __lookup_inode(inode->i_sb, ceph_ino(inode));
	379	if (IS_ERR(dir)) {
	380	dn = ERR_CAST(dir);
	381	goto out;
	382	}
	383	/* There can be multiple paths to access snapped inode.
	384	* For simplicity, treat snapdir of head inode as parent */
	385	if (ceph_snap(inode) != CEPH_SNAPDIR) {
	386	struct inode *snapdir = ceph_get_snapdir(dir);
	387	if (dir->i_nlink == 0)
	388	unlinked = true;
	389	iput(dir);
	390	if (IS_ERR(snapdir)) {
	391	dn = ERR_CAST(snapdir);
	392	goto out;
	393	}
	394	dir = snapdir;
	395	}
3500000b	396	/* If directory has already been deleted, further get_parent
570df4e9	397	* will fail. Do not mark snapdir dentry as disconnected,
3500000b	398	* this prevents exportfs from doing further get_parent. */
570df4e9 YZ	399	if (unlinked)
	400	dn = d_obtain_root(dir);
	401	else
	402	dn = d_obtain_alias(dir);
	403	} else {
	404	dn = __get_parent(child->d_sb, child, 0);
	405	}
	406	out:
38d46409 XL	407	doutc(cl, "child %p %p %llx.%llx err=%ld\n", child, inode,
38d46409 XL	408	ceph_vinop(inode), (long)PTR_ERR_OR_ZERO(dn));
570df4e9	409	return dn;
9017c2ec YZ	410	}
9017c2ec YZ	411
a8e63b7d	412	/*
8996f4f2	413	* convert regular fh to parent
a8e63b7d SW	414	*/
a8e63b7d SW	415	static struct dentry ceph_fh_to_parent(struct super_block sb,
8996f4f2	416	struct fid *fid,
a8e63b7d SW	417	int fh_len, int fh_type)
a8e63b7d SW	418	{
38d46409	419	struct ceph_fs_client *fsc = ceph_sb_to_fs_client(sb);
a8e63b7d	420	struct ceph_nfs_confh cfh = (void )fid->raw;
a8e63b7d	421	struct dentry *dentry;
a8e63b7d	422
570df4e9 YZ	423	if (fh_type == FILEID_BTRFS_WITH_PARENT) {
	424	struct ceph_nfs_snapfh sfh = (void )fid->raw;
	425	return __snapfh_to_dentry(sb, sfh, true);
	426	}
	427
8996f4f2 YZ	428	if (fh_type != FILEID_INO32_GEN_PARENT)
8996f4f2 YZ	429	return NULL;
35c2a7f4	430	if (fh_len < sizeof(*cfh) / 4)
8996f4f2	431	return NULL;
a8e63b7d	432
38d46409	433	doutc(fsc->client, "%llx\n", cfh->parent_ino);
8996f4f2	434	dentry = __get_parent(sb, NULL, cfh->ino);
b42b90d1	435	if (unlikely(dentry == ERR_PTR(-ENOENT)))
8996f4f2	436	dentry = __fh_to_dentry(sb, cfh->parent_ino);
a8e63b7d SW	437	return dentry;
	438	}
	439
570df4e9 YZ	440	static int __get_snap_name(struct dentry parent, char name,
	441	struct dentry *child)
	442	{
	443	struct inode *inode = d_inode(child);
	444	struct inode *dir = d_inode(parent);
5995d90d	445	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
570df4e9 YZ	446	struct ceph_mds_request *req = NULL;
	447	char *last_name = NULL;
	448	unsigned next_offset = 2;
	449	int err = -EINVAL;
	450
	451	if (ceph_ino(inode) != ceph_ino(dir))
	452	goto out;
	453	if (ceph_snap(inode) == CEPH_SNAPDIR) {
	454	if (ceph_snap(dir) == CEPH_NOSNAP) {
c152737b AR	455	/*
	456	* .get_name() from struct export_operations
	457	* assumes that its 'name' parameter is pointing
	458	* to a NAME_MAX+1 sized buffer
	459	*/
	460	strscpy(name, fsc->mount_options->snapdir_name,
	461	NAME_MAX + 1);
570df4e9 YZ	462	err = 0;
	463	}
	464	goto out;
	465	}
	466	if (ceph_snap(dir) != CEPH_SNAPDIR)
	467	goto out;
	468
	469	while (1) {
	470	struct ceph_mds_reply_info_parsed *rinfo;
	471	struct ceph_mds_reply_dir_entry *rde;
	472	int i;
	473
	474	req = ceph_mdsc_create_request(fsc->mdsc, CEPH_MDS_OP_LSSNAP,
	475	USE_AUTH_MDS);
	476	if (IS_ERR(req)) {
	477	err = PTR_ERR(req);
	478	req = NULL;
	479	goto out;
	480	}
	481	err = ceph_alloc_readdir_reply_buffer(req, inode);
	482	if (err)
	483	goto out;
	484
	485	req->r_direct_mode = USE_AUTH_MDS;
	486	req->r_readdir_offset = next_offset;
	487	req->r_args.readdir.flags =
	488	cpu_to_le16(CEPH_READDIR_REPLY_BITFLAGS);
	489	if (last_name) {
	490	req->r_path2 = last_name;
	491	last_name = NULL;
	492	}
	493
	494	req->r_inode = dir;
	495	ihold(dir);
	496	req->r_dentry = dget(parent);
	497
	498	inode_lock(dir);
	499	err = ceph_mdsc_do_request(fsc->mdsc, NULL, req);
	500	inode_unlock(dir);
	501
	502	if (err < 0)
	503	goto out;
	504
0ed26f36 ID	505	rinfo = &req->r_reply_info;
	506	for (i = 0; i < rinfo->dir_nr; i++) {
	507	rde = rinfo->dir_entries + i;
	508	BUG_ON(!rde->inode.in);
	509	if (ceph_snap(inode) ==
	510	le64_to_cpu(rde->inode.in->snapid)) {
	511	memcpy(name, rde->name, rde->name_len);
	512	name[rde->name_len] = '\0';
	513	err = 0;
	514	goto out;
	515	}
	516	}
	517
	518	if (rinfo->dir_end)
	519	break;
	520
	521	BUG_ON(rinfo->dir_nr <= 0);
	522	rde = rinfo->dir_entries + (rinfo->dir_nr - 1);
	523	next_offset += rinfo->dir_nr;
	524	last_name = kstrndup(rde->name, rde->name_len, GFP_KERNEL);
	525	if (!last_name) {
	526	err = -ENOMEM;
	527	goto out;
	528	}
	529
	530	ceph_mdsc_put_request(req);
	531	req = NULL;
570df4e9 YZ	532	}
	533	err = -ENOENT;
	534	out:
	535	if (req)
	536	ceph_mdsc_put_request(req);
	537	kfree(last_name);
38d46409 XL	538	doutc(fsc->client, "child dentry %p %p %llx.%llx err=%d\n", child,
38d46409 XL	539	inode, ceph_vinop(inode), err);
570df4e9 YZ	540	return err;
	541	}
	542
19913b4e YZ	543	static int ceph_get_name(struct dentry parent, char name,
	544	struct dentry *child)
	545	{
	546	struct ceph_mds_client *mdsc;
	547	struct ceph_mds_request *req;
85529096	548	struct inode *dir = d_inode(parent);
570df4e9	549	struct inode *inode = d_inode(child);
85529096	550	struct ceph_mds_reply_info_parsed *rinfo;
19913b4e YZ	551	int err;
19913b4e YZ	552
570df4e9 YZ	553	if (ceph_snap(inode) != CEPH_NOSNAP)
	554	return __get_snap_name(parent, name, child);
	555
5995d90d	556	mdsc = ceph_inode_to_fs_client(inode)->mdsc;
19913b4e YZ	557	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPNAME,
	558	USE_ANY_MDS);
	559	if (IS_ERR(req))
	560	return PTR_ERR(req);
	561
85529096	562	inode_lock(dir);
570df4e9 YZ	563	req->r_inode = inode;
570df4e9 YZ	564	ihold(inode);
2b0143b5	565	req->r_ino2 = ceph_vino(d_inode(parent));
85529096 JL	566	req->r_parent = dir;
85529096 JL	567	ihold(dir);
3dd69aab	568	set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags);
19913b4e YZ	569	req->r_num_caps = 2;
19913b4e YZ	570	err = ceph_mdsc_do_request(mdsc, NULL, req);
85529096	571	inode_unlock(dir);
19913b4e	572
85529096 JL	573	if (err)
85529096 JL	574	goto out;
19913b4e	575
85529096 JL	576	rinfo = &req->r_reply_info;
85529096 JL	577	if (!IS_ENCRYPTED(dir)) {
19913b4e YZ	578	memcpy(name, rinfo->dname, rinfo->dname_len);
19913b4e YZ	579	name[rinfo->dname_len] = 0;
19913b4e	580	} else {
85529096 JL	581	struct fscrypt_str oname = FSTR_INIT(NULL, 0);
	582	struct ceph_fname fname = { .dir = dir,
	583	.name = rinfo->dname,
	584	.ctext = rinfo->altname,
	585	.name_len = rinfo->dname_len,
	586	.ctext_len = rinfo->altname_len };
	587
	588	err = ceph_fname_alloc_buffer(dir, &oname);
	589	if (err < 0)
	590	goto out;
19913b4e	591
85529096 JL	592	err = ceph_fname_to_usr(&fname, NULL, &oname, NULL);
	593	if (!err) {
	594	memcpy(name, oname.name, oname.len);
	595	name[oname.len] = 0;
	596	}
	597	ceph_fname_free_buffer(dir, &oname);
	598	}
	599	out:
38d46409 XL	600	doutc(mdsc->fsc->client, "child dentry %p %p %llx.%llx err %d %s%s\n",
	601	child, inode, ceph_vinop(inode), err, err ? "" : "name ",
	602	err ? "" : name);
19913b4e YZ	603	ceph_mdsc_put_request(req);
	604	return err;
	605	}
	606
a8e63b7d SW	607	const struct export_operations ceph_export_ops = {
	608	.encode_fh = ceph_encode_fh,
	609	.fh_to_dentry = ceph_fh_to_dentry,
	610	.fh_to_parent = ceph_fh_to_parent,
9017c2ec	611	.get_parent = ceph_get_parent,
19913b4e	612	.get_name = ceph_get_name,
a8e63b7d	613	};