[linux-2.6-block.git] / fs / ceph / ioctl.c

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

#include "super.h"
#include "mds_client.h"
#include "ioctl.h"
#include <linux/ceph/striper.h>
#include <linux/fscrypt.h>

/*
 * ioctls
 */

/*
 * get and set the file layout
 */
static long ceph_ioctl_get_layout(struct file *file, void __user *arg)
{
	struct ceph_inode_info *ci = ceph_inode(file_inode(file));
	struct ceph_ioctl_layout l;
	int err;

	err = ceph_do_getattr(file_inode(file), CEPH_STAT_CAP_LAYOUT, false);
	if (!err) {
		l.stripe_unit = ci->i_layout.stripe_unit;
		l.stripe_count = ci->i_layout.stripe_count;
		l.object_size = ci->i_layout.object_size;
		l.data_pool = ci->i_layout.pool_id;
		l.preferred_osd = -1;
		if (copy_to_user(arg, &l, sizeof(l)))
			return -EFAULT;
	}

	return err;
}

static long __validate_layout(struct ceph_mds_client *mdsc,
			      struct ceph_ioctl_layout *l)
{
	int i, err;

	/* validate striping parameters */
	if ((l->object_size & ~PAGE_MASK) ||
	    (l->stripe_unit & ~PAGE_MASK) ||
	    ((unsigned)l->stripe_unit != 0 &&
	     ((unsigned)l->object_size % (unsigned)l->stripe_unit)))
		return -EINVAL;

	/* make sure it's a valid data pool */
	mutex_lock(&mdsc->mutex);
	err = -EINVAL;
	for (i = 0; i < mdsc->mdsmap->m_num_data_pg_pools; i++)
		if (mdsc->mdsmap->m_data_pg_pools[i] == l->data_pool) {
			err = 0;
			break;
		}
	mutex_unlock(&mdsc->mutex);
	if (err)
		return err;

	return 0;
}

static long ceph_ioctl_set_layout(struct file *file, void __user *arg)
{
	struct inode *inode = file_inode(file);
	struct ceph_mds_client *mdsc = ceph_sb_to_fs_client(inode->i_sb)->mdsc;
	struct ceph_mds_request *req;
	struct ceph_ioctl_layout l;
	struct ceph_inode_info *ci = ceph_inode(file_inode(file));
	struct ceph_ioctl_layout nl;
	int err;

	if (copy_from_user(&l, arg, sizeof(l)))
		return -EFAULT;

	/* validate changed params against current layout */
	err = ceph_do_getattr(file_inode(file), CEPH_STAT_CAP_LAYOUT, false);
	if (err)
		return err;

	memset(&nl, 0, sizeof(nl));
	if (l.stripe_count)
		nl.stripe_count = l.stripe_count;
	else
		nl.stripe_count = ci->i_layout.stripe_count;
	if (l.stripe_unit)
		nl.stripe_unit = l.stripe_unit;
	else
		nl.stripe_unit = ci->i_layout.stripe_unit;
	if (l.object_size)
		nl.object_size = l.object_size;
	else
		nl.object_size = ci->i_layout.object_size;
	if (l.data_pool)
		nl.data_pool = l.data_pool;
	else
		nl.data_pool = ci->i_layout.pool_id;

	/* this is obsolete, and always -1 */
	nl.preferred_osd = -1;

	err = __validate_layout(mdsc, &nl);
	if (err)
		return err;

	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETLAYOUT,
				       USE_AUTH_MDS);
	if (IS_ERR(req))
		return PTR_ERR(req);
	req->r_inode = inode;
	ihold(inode);
	req->r_num_caps = 1;

	req->r_inode_drop = CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_EXCL;

	req->r_args.setlayout.layout.fl_stripe_unit =
		cpu_to_le32(l.stripe_unit);
	req->r_args.setlayout.layout.fl_stripe_count =
		cpu_to_le32(l.stripe_count);
	req->r_args.setlayout.layout.fl_object_size =
		cpu_to_le32(l.object_size);
	req->r_args.setlayout.layout.fl_pg_pool = cpu_to_le32(l.data_pool);

	err = ceph_mdsc_do_request(mdsc, NULL, req);
	ceph_mdsc_put_request(req);
	return err;
}

/*
 * Set a layout policy on a directory inode. All items in the tree
 * rooted at this inode will inherit this layout on creation,
 * (It doesn't apply retroactively )
 * unless a subdirectory has its own layout policy.
 */
static long ceph_ioctl_set_layout_policy (struct file *file, void __user *arg)
{
	struct inode *inode = file_inode(file);
	struct ceph_mds_request *req;
	struct ceph_ioctl_layout l;
	int err;
	struct ceph_mds_client *mdsc = ceph_sb_to_fs_client(inode->i_sb)->mdsc;

	/* copy and validate */
	if (copy_from_user(&l, arg, sizeof(l)))
		return -EFAULT;

	err = __validate_layout(mdsc, &l);
	if (err)
		return err;

	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETDIRLAYOUT,
				       USE_AUTH_MDS);

	if (IS_ERR(req))
		return PTR_ERR(req);
	req->r_inode = inode;
	ihold(inode);
	req->r_num_caps = 1;

	req->r_args.setlayout.layout.fl_stripe_unit =
			cpu_to_le32(l.stripe_unit);
	req->r_args.setlayout.layout.fl_stripe_count =
			cpu_to_le32(l.stripe_count);
	req->r_args.setlayout.layout.fl_object_size =
			cpu_to_le32(l.object_size);
	req->r_args.setlayout.layout.fl_pg_pool =
			cpu_to_le32(l.data_pool);

	err = ceph_mdsc_do_request(mdsc, inode, req);
	ceph_mdsc_put_request(req);
	return err;
}

/*
 * Return object name, size/offset information, and location (OSD
 * number, network address) for a given file offset.
 */
static long ceph_ioctl_get_dataloc(struct file *file, void __user *arg)
{
	struct ceph_ioctl_dataloc dl;
	struct inode *inode = file_inode(file);
	struct ceph_inode_info *ci = ceph_inode(inode);
	struct ceph_osd_client *osdc =
		&ceph_sb_to_fs_client(inode->i_sb)->client->osdc;
	struct ceph_object_locator oloc;
	CEPH_DEFINE_OID_ONSTACK(oid);
	u32 xlen;
	u64 tmp;
	struct ceph_pg pgid;
	int r;

	/* copy and validate */
	if (copy_from_user(&dl, arg, sizeof(dl)))
		return -EFAULT;

	down_read(&osdc->lock);
	ceph_calc_file_object_mapping(&ci->i_layout, dl.file_offset, 1,
				      &dl.object_no, &dl.object_offset, &xlen);
	dl.file_offset -= dl.object_offset;
	dl.object_size = ci->i_layout.object_size;
	dl.block_size = ci->i_layout.stripe_unit;

	/* block_offset = object_offset % block_size */
	tmp = dl.object_offset;
	dl.block_offset = do_div(tmp, dl.block_size);

	snprintf(dl.object_name, sizeof(dl.object_name), "%llx.%08llx",
		 ceph_ino(inode), dl.object_no);

	oloc.pool = ci->i_layout.pool_id;
	oloc.pool_ns = ceph_try_get_string(ci->i_layout.pool_ns);
	ceph_oid_printf(&oid, "%s", dl.object_name);

	r = ceph_object_locator_to_pg(osdc->osdmap, &oid, &oloc, &pgid);

	ceph_oloc_destroy(&oloc);
	if (r < 0) {
		up_read(&osdc->lock);
		return r;
	}

	dl.osd = ceph_pg_to_acting_primary(osdc->osdmap, &pgid);
	if (dl.osd >= 0) {
		struct ceph_entity_addr *a =
			ceph_osd_addr(osdc->osdmap, dl.osd);
		if (a)
			memcpy(&dl.osd_addr, &a->in_addr, sizeof(dl.osd_addr));
	} else {
		memset(&dl.osd_addr, 0, sizeof(dl.osd_addr));
	}
	up_read(&osdc->lock);

	/* send result back to user */
	if (copy_to_user(arg, &dl, sizeof(dl)))
		return -EFAULT;

	return 0;
}

static long ceph_ioctl_lazyio(struct file *file)
{
	struct ceph_file_info *fi = file->private_data;
	struct inode *inode = file_inode(file);
	struct ceph_inode_info *ci = ceph_inode(inode);
	struct ceph_mds_client *mdsc = ceph_inode_to_fs_client(inode)->mdsc;
	struct ceph_client *cl = mdsc->fsc->client;

	if ((fi->fmode & CEPH_FILE_MODE_LAZY) == 0) {
		spin_lock(&ci->i_ceph_lock);
		fi->fmode |= CEPH_FILE_MODE_LAZY;
		ci->i_nr_by_mode[ffs(CEPH_FILE_MODE_LAZY)]++;
		__ceph_touch_fmode(ci, mdsc, fi->fmode);
		spin_unlock(&ci->i_ceph_lock);
		doutc(cl, "file %p %p %llx.%llx marked lazy\n", file, inode,
		      ceph_vinop(inode));

		ceph_check_caps(ci, 0);
	} else {
		doutc(cl, "file %p %p %llx.%llx already lazy\n", file, inode,
		      ceph_vinop(inode));
	}
	return 0;
}

static long ceph_ioctl_syncio(struct file *file)
{
	struct ceph_file_info *fi = file->private_data;

	fi->flags |= CEPH_F_SYNC;
	return 0;
}

static int vet_mds_for_fscrypt(struct file *file)
{
	int i, ret = -EOPNOTSUPP;
	struct ceph_mds_client	*mdsc = ceph_sb_to_mdsc(file_inode(file)->i_sb);

	mutex_lock(&mdsc->mutex);
	for (i = 0; i < mdsc->max_sessions; i++) {
		struct ceph_mds_session *s = mdsc->sessions[i];

		if (!s)
			continue;
		if (test_bit(CEPHFS_FEATURE_ALTERNATE_NAME, &s->s_features))
			ret = 0;
		break;
	}
	mutex_unlock(&mdsc->mutex);
	return ret;
}

static long ceph_set_encryption_policy(struct file *file, unsigned long arg)
{
	int ret, got = 0;
	struct inode *inode = file_inode(file);
	struct ceph_inode_info *ci = ceph_inode(inode);

	/* encrypted directories can't have striped layout */
	if (ci->i_layout.stripe_count > 1)
		return -EINVAL;

	ret = vet_mds_for_fscrypt(file);
	if (ret)
		return ret;

	/*
	 * Ensure we hold these caps so that we _know_ that the rstats check
	 * in the empty_dir check is reliable.
	 */
	ret = ceph_get_caps(file, CEPH_CAP_FILE_SHARED, 0, -1, &got);
	if (ret)
		return ret;

	ret = fscrypt_ioctl_set_policy(file, (const void __user *)arg);
	if (got)
		ceph_put_cap_refs(ci, got);

	return ret;
}

static const char *ceph_ioctl_cmd_name(const unsigned int cmd)
{
	switch (cmd) {
	case CEPH_IOC_GET_LAYOUT:
		return "get_layout";
	case CEPH_IOC_SET_LAYOUT:
		return "set_layout";
	case CEPH_IOC_SET_LAYOUT_POLICY:
		return "set_layout_policy";
	case CEPH_IOC_GET_DATALOC:
		return "get_dataloc";
	case CEPH_IOC_LAZYIO:
		return "lazyio";
	case CEPH_IOC_SYNCIO:
		return "syncio";
	case FS_IOC_SET_ENCRYPTION_POLICY:
		return "set_encryption_policy";
	case FS_IOC_GET_ENCRYPTION_POLICY:
		return "get_encryption_policy";
	case FS_IOC_GET_ENCRYPTION_POLICY_EX:
		return "get_encryption_policy_ex";
	case FS_IOC_ADD_ENCRYPTION_KEY:
		return "add_encryption_key";
	case FS_IOC_REMOVE_ENCRYPTION_KEY:
		return "remove_encryption_key";
	case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
		return "remove_encryption_key_all_users";
	case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
		return "get_encryption_key_status";
	case FS_IOC_GET_ENCRYPTION_NONCE:
		return "get_encryption_nonce";
	default:
		return "unknown";
	}
}

long ceph_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	struct inode *inode = file_inode(file);
	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
	int ret;

	doutc(fsc->client, "file %p %p %llx.%llx cmd %s arg %lu\n", file,
	      inode, ceph_vinop(inode), ceph_ioctl_cmd_name(cmd), arg);
	switch (cmd) {
	case CEPH_IOC_GET_LAYOUT:
		return ceph_ioctl_get_layout(file, (void __user *)arg);

	case CEPH_IOC_SET_LAYOUT:
		return ceph_ioctl_set_layout(file, (void __user *)arg);

	case CEPH_IOC_SET_LAYOUT_POLICY:
		return ceph_ioctl_set_layout_policy(file, (void __user *)arg);

	case CEPH_IOC_GET_DATALOC:
		return ceph_ioctl_get_dataloc(file, (void __user *)arg);

	case CEPH_IOC_LAZYIO:
		return ceph_ioctl_lazyio(file);

	case CEPH_IOC_SYNCIO:
		return ceph_ioctl_syncio(file);

	case FS_IOC_SET_ENCRYPTION_POLICY:
		return ceph_set_encryption_policy(file, arg);

	case FS_IOC_GET_ENCRYPTION_POLICY:
		ret = vet_mds_for_fscrypt(file);
		if (ret)
			return ret;
		return fscrypt_ioctl_get_policy(file, (void __user *)arg);

	case FS_IOC_GET_ENCRYPTION_POLICY_EX:
		ret = vet_mds_for_fscrypt(file);
		if (ret)
			return ret;
		return fscrypt_ioctl_get_policy_ex(file, (void __user *)arg);

	case FS_IOC_ADD_ENCRYPTION_KEY:
		ret = vet_mds_for_fscrypt(file);
		if (ret)
			return ret;
		return fscrypt_ioctl_add_key(file, (void __user *)arg);

	case FS_IOC_REMOVE_ENCRYPTION_KEY:
		return fscrypt_ioctl_remove_key(file, (void __user *)arg);

	case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
		return fscrypt_ioctl_remove_key_all_users(file,
							  (void __user *)arg);

	case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
		return fscrypt_ioctl_get_key_status(file, (void __user *)arg);

	case FS_IOC_GET_ENCRYPTION_NONCE:
		ret = vet_mds_for_fscrypt(file);
		if (ret)
			return ret;
		return fscrypt_ioctl_get_nonce(file, (void __user *)arg);
	}

	return -ENOTTY;
}
Commit	Line	Data
	1	// SPDX-License-Identifier: GPL-2.0
	2	#include <linux/ceph/ceph_debug.h>
	3	#include <linux/in.h>
	4
	5	#include "super.h"
	6	#include "mds_client.h"
	7	#include "ioctl.h"
	8	#include <linux/ceph/striper.h>
	9	#include <linux/fscrypt.h>
	10
	11	/*
	12	* ioctls
	13	*/
	14
	15	/*
	16	* get and set the file layout
	17	*/
	18	static long ceph_ioctl_get_layout(struct file file, void __user arg)
	19	{
	20	struct ceph_inode_info *ci = ceph_inode(file_inode(file));
	21	struct ceph_ioctl_layout l;
	22	int err;
	23
	24	err = ceph_do_getattr(file_inode(file), CEPH_STAT_CAP_LAYOUT, false);
	25	if (!err) {
	26	l.stripe_unit = ci->i_layout.stripe_unit;
	27	l.stripe_count = ci->i_layout.stripe_count;
	28	l.object_size = ci->i_layout.object_size;
	29	l.data_pool = ci->i_layout.pool_id;
	30	l.preferred_osd = -1;
	31	if (copy_to_user(arg, &l, sizeof(l)))
	32	return -EFAULT;
	33	}
	34
	35	return err;
	36	}
	37
	38	static long __validate_layout(struct ceph_mds_client *mdsc,
	39	struct ceph_ioctl_layout *l)
	40	{
	41	int i, err;
	42
	43	/* validate striping parameters */
	44	if ((l->object_size & ~PAGE_MASK) \|\|
	45	(l->stripe_unit & ~PAGE_MASK) \|\|
	46	((unsigned)l->stripe_unit != 0 &&
	47	((unsigned)l->object_size % (unsigned)l->stripe_unit)))
	48	return -EINVAL;
	49
	50	/* make sure it's a valid data pool */
	51	mutex_lock(&mdsc->mutex);
	52	err = -EINVAL;
	53	for (i = 0; i < mdsc->mdsmap->m_num_data_pg_pools; i++)
	54	if (mdsc->mdsmap->m_data_pg_pools[i] == l->data_pool) {
	55	err = 0;
	56	break;
	57	}
	58	mutex_unlock(&mdsc->mutex);
	59	if (err)
	60	return err;
	61
	62	return 0;
	63	}
	64
	65	static long ceph_ioctl_set_layout(struct file file, void __user arg)
	66	{
	67	struct inode *inode = file_inode(file);
	68	struct ceph_mds_client *mdsc = ceph_sb_to_fs_client(inode->i_sb)->mdsc;
	69	struct ceph_mds_request *req;
	70	struct ceph_ioctl_layout l;
	71	struct ceph_inode_info *ci = ceph_inode(file_inode(file));
	72	struct ceph_ioctl_layout nl;
	73	int err;
	74
	75	if (copy_from_user(&l, arg, sizeof(l)))
	76	return -EFAULT;
	77
	78	/* validate changed params against current layout */
	79	err = ceph_do_getattr(file_inode(file), CEPH_STAT_CAP_LAYOUT, false);
	80	if (err)
	81	return err;
	82
	83	memset(&nl, 0, sizeof(nl));
	84	if (l.stripe_count)
	85	nl.stripe_count = l.stripe_count;
	86	else
	87	nl.stripe_count = ci->i_layout.stripe_count;
	88	if (l.stripe_unit)
	89	nl.stripe_unit = l.stripe_unit;
	90	else
	91	nl.stripe_unit = ci->i_layout.stripe_unit;
	92	if (l.object_size)
	93	nl.object_size = l.object_size;
	94	else
	95	nl.object_size = ci->i_layout.object_size;
	96	if (l.data_pool)
	97	nl.data_pool = l.data_pool;
	98	else
	99	nl.data_pool = ci->i_layout.pool_id;
	100
	101	/* this is obsolete, and always -1 */
	102	nl.preferred_osd = -1;
	103
	104	err = __validate_layout(mdsc, &nl);
	105	if (err)
	106	return err;
	107
	108	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETLAYOUT,
	109	USE_AUTH_MDS);
	110	if (IS_ERR(req))
	111	return PTR_ERR(req);
	112	req->r_inode = inode;
	113	ihold(inode);
	114	req->r_num_caps = 1;
	115
	116	req->r_inode_drop = CEPH_CAP_FILE_SHARED \| CEPH_CAP_FILE_EXCL;
	117
	118	req->r_args.setlayout.layout.fl_stripe_unit =
	119	cpu_to_le32(l.stripe_unit);
	120	req->r_args.setlayout.layout.fl_stripe_count =
	121	cpu_to_le32(l.stripe_count);
	122	req->r_args.setlayout.layout.fl_object_size =
	123	cpu_to_le32(l.object_size);
	124	req->r_args.setlayout.layout.fl_pg_pool = cpu_to_le32(l.data_pool);
	125
	126	err = ceph_mdsc_do_request(mdsc, NULL, req);
	127	ceph_mdsc_put_request(req);
	128	return err;
	129	}
	130
	131	/*
	132	* Set a layout policy on a directory inode. All items in the tree
	133	* rooted at this inode will inherit this layout on creation,
	134	* (It doesn't apply retroactively )
	135	* unless a subdirectory has its own layout policy.
	136	*/
	137	static long ceph_ioctl_set_layout_policy (struct file file, void __user arg)
	138	{
	139	struct inode *inode = file_inode(file);
	140	struct ceph_mds_request *req;
	141	struct ceph_ioctl_layout l;
	142	int err;
	143	struct ceph_mds_client *mdsc = ceph_sb_to_fs_client(inode->i_sb)->mdsc;
	144
	145	/* copy and validate */
	146	if (copy_from_user(&l, arg, sizeof(l)))
	147	return -EFAULT;
	148
	149	err = __validate_layout(mdsc, &l);
	150	if (err)
	151	return err;
	152
	153	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETDIRLAYOUT,
	154	USE_AUTH_MDS);
	155
	156	if (IS_ERR(req))
	157	return PTR_ERR(req);
	158	req->r_inode = inode;
	159	ihold(inode);
	160	req->r_num_caps = 1;
	161
	162	req->r_args.setlayout.layout.fl_stripe_unit =
	163	cpu_to_le32(l.stripe_unit);
	164	req->r_args.setlayout.layout.fl_stripe_count =
	165	cpu_to_le32(l.stripe_count);
	166	req->r_args.setlayout.layout.fl_object_size =
	167	cpu_to_le32(l.object_size);
	168	req->r_args.setlayout.layout.fl_pg_pool =
	169	cpu_to_le32(l.data_pool);
	170
	171	err = ceph_mdsc_do_request(mdsc, inode, req);
	172	ceph_mdsc_put_request(req);
	173	return err;
	174	}
	175
	176	/*
	177	* Return object name, size/offset information, and location (OSD
	178	* number, network address) for a given file offset.
	179	*/
	180	static long ceph_ioctl_get_dataloc(struct file file, void __user arg)
	181	{
	182	struct ceph_ioctl_dataloc dl;
	183	struct inode *inode = file_inode(file);
	184	struct ceph_inode_info *ci = ceph_inode(inode);
	185	struct ceph_osd_client *osdc =
	186	&ceph_sb_to_fs_client(inode->i_sb)->client->osdc;
	187	struct ceph_object_locator oloc;
	188	CEPH_DEFINE_OID_ONSTACK(oid);
	189	u32 xlen;
	190	u64 tmp;
	191	struct ceph_pg pgid;
	192	int r;
	193
	194	/* copy and validate */
	195	if (copy_from_user(&dl, arg, sizeof(dl)))
	196	return -EFAULT;
	197
	198	down_read(&osdc->lock);
	199	ceph_calc_file_object_mapping(&ci->i_layout, dl.file_offset, 1,
	200	&dl.object_no, &dl.object_offset, &xlen);
	201	dl.file_offset -= dl.object_offset;
	202	dl.object_size = ci->i_layout.object_size;
	203	dl.block_size = ci->i_layout.stripe_unit;
	204
	205	/* block_offset = object_offset % block_size */
	206	tmp = dl.object_offset;
	207	dl.block_offset = do_div(tmp, dl.block_size);
	208
	209	snprintf(dl.object_name, sizeof(dl.object_name), "%llx.%08llx",
	210	ceph_ino(inode), dl.object_no);
	211
	212	oloc.pool = ci->i_layout.pool_id;
	213	oloc.pool_ns = ceph_try_get_string(ci->i_layout.pool_ns);
	214	ceph_oid_printf(&oid, "%s", dl.object_name);
	215
	216	r = ceph_object_locator_to_pg(osdc->osdmap, &oid, &oloc, &pgid);
	217
	218	ceph_oloc_destroy(&oloc);
	219	if (r < 0) {
	220	up_read(&osdc->lock);
	221	return r;
	222	}
	223
	224	dl.osd = ceph_pg_to_acting_primary(osdc->osdmap, &pgid);
	225	if (dl.osd >= 0) {
	226	struct ceph_entity_addr *a =
	227	ceph_osd_addr(osdc->osdmap, dl.osd);
	228	if (a)
	229	memcpy(&dl.osd_addr, &a->in_addr, sizeof(dl.osd_addr));
	230	} else {
	231	memset(&dl.osd_addr, 0, sizeof(dl.osd_addr));
	232	}
	233	up_read(&osdc->lock);
	234
	235	/* send result back to user */
	236	if (copy_to_user(arg, &dl, sizeof(dl)))
	237	return -EFAULT;
	238
	239	return 0;
	240	}
	241
	242	static long ceph_ioctl_lazyio(struct file *file)
	243	{
	244	struct ceph_file_info *fi = file->private_data;
	245	struct inode *inode = file_inode(file);
	246	struct ceph_inode_info *ci = ceph_inode(inode);
	247	struct ceph_mds_client *mdsc = ceph_inode_to_fs_client(inode)->mdsc;
	248	struct ceph_client *cl = mdsc->fsc->client;
	249
	250	if ((fi->fmode & CEPH_FILE_MODE_LAZY) == 0) {
	251	spin_lock(&ci->i_ceph_lock);
	252	fi->fmode \|= CEPH_FILE_MODE_LAZY;
	253	ci->i_nr_by_mode[ffs(CEPH_FILE_MODE_LAZY)]++;
	254	__ceph_touch_fmode(ci, mdsc, fi->fmode);
	255	spin_unlock(&ci->i_ceph_lock);
	256	doutc(cl, "file %p %p %llx.%llx marked lazy\n", file, inode,
	257	ceph_vinop(inode));
	258
	259	ceph_check_caps(ci, 0);
	260	} else {
	261	doutc(cl, "file %p %p %llx.%llx already lazy\n", file, inode,
	262	ceph_vinop(inode));
	263	}
	264	return 0;
	265	}
	266
	267	static long ceph_ioctl_syncio(struct file *file)
	268	{
	269	struct ceph_file_info *fi = file->private_data;
	270
	271	fi->flags \|= CEPH_F_SYNC;
	272	return 0;
	273	}
	274
	275	static int vet_mds_for_fscrypt(struct file *file)
	276	{
	277	int i, ret = -EOPNOTSUPP;
	278	struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(file_inode(file)->i_sb);
	279
	280	mutex_lock(&mdsc->mutex);
	281	for (i = 0; i < mdsc->max_sessions; i++) {
	282	struct ceph_mds_session *s = mdsc->sessions[i];
	283
	284	if (!s)
	285	continue;
	286	if (test_bit(CEPHFS_FEATURE_ALTERNATE_NAME, &s->s_features))
	287	ret = 0;
	288	break;
	289	}
	290	mutex_unlock(&mdsc->mutex);
	291	return ret;
	292	}
	293
	294	static long ceph_set_encryption_policy(struct file *file, unsigned long arg)
	295	{
	296	int ret, got = 0;
	297	struct inode *inode = file_inode(file);
	298	struct ceph_inode_info *ci = ceph_inode(inode);
	299
	300	/* encrypted directories can't have striped layout */
	301	if (ci->i_layout.stripe_count > 1)
	302	return -EINVAL;
	303
	304	ret = vet_mds_for_fscrypt(file);
	305	if (ret)
	306	return ret;
	307
	308	/*
	309	* Ensure we hold these caps so that we _know_ that the rstats check
	310	* in the empty_dir check is reliable.
	311	*/
	312	ret = ceph_get_caps(file, CEPH_CAP_FILE_SHARED, 0, -1, &got);
	313	if (ret)
	314	return ret;
	315
	316	ret = fscrypt_ioctl_set_policy(file, (const void __user *)arg);
	317	if (got)
	318	ceph_put_cap_refs(ci, got);
	319
	320	return ret;
	321	}
	322
	323	static const char *ceph_ioctl_cmd_name(const unsigned int cmd)
	324	{
	325	switch (cmd) {
	326	case CEPH_IOC_GET_LAYOUT:
	327	return "get_layout";
	328	case CEPH_IOC_SET_LAYOUT:
	329	return "set_layout";
	330	case CEPH_IOC_SET_LAYOUT_POLICY:
	331	return "set_layout_policy";
	332	case CEPH_IOC_GET_DATALOC:
	333	return "get_dataloc";
	334	case CEPH_IOC_LAZYIO:
	335	return "lazyio";
	336	case CEPH_IOC_SYNCIO:
	337	return "syncio";
	338	case FS_IOC_SET_ENCRYPTION_POLICY:
	339	return "set_encryption_policy";
	340	case FS_IOC_GET_ENCRYPTION_POLICY:
	341	return "get_encryption_policy";
	342	case FS_IOC_GET_ENCRYPTION_POLICY_EX:
	343	return "get_encryption_policy_ex";
	344	case FS_IOC_ADD_ENCRYPTION_KEY:
	345	return "add_encryption_key";
	346	case FS_IOC_REMOVE_ENCRYPTION_KEY:
	347	return "remove_encryption_key";
	348	case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
	349	return "remove_encryption_key_all_users";
	350	case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
	351	return "get_encryption_key_status";
	352	case FS_IOC_GET_ENCRYPTION_NONCE:
	353	return "get_encryption_nonce";
	354	default:
	355	return "unknown";
	356	}
	357	}
	358
	359	long ceph_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	360	{
	361	struct inode *inode = file_inode(file);
	362	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
	363	int ret;
	364
	365	doutc(fsc->client, "file %p %p %llx.%llx cmd %s arg %lu\n", file,
	366	inode, ceph_vinop(inode), ceph_ioctl_cmd_name(cmd), arg);
	367	switch (cmd) {
	368	case CEPH_IOC_GET_LAYOUT:
	369	return ceph_ioctl_get_layout(file, (void __user *)arg);
	370
	371	case CEPH_IOC_SET_LAYOUT:
	372	return ceph_ioctl_set_layout(file, (void __user *)arg);
	373
	374	case CEPH_IOC_SET_LAYOUT_POLICY:
	375	return ceph_ioctl_set_layout_policy(file, (void __user *)arg);
	376
	377	case CEPH_IOC_GET_DATALOC:
	378	return ceph_ioctl_get_dataloc(file, (void __user *)arg);
	379
	380	case CEPH_IOC_LAZYIO:
	381	return ceph_ioctl_lazyio(file);
	382
	383	case CEPH_IOC_SYNCIO:
	384	return ceph_ioctl_syncio(file);
	385
	386	case FS_IOC_SET_ENCRYPTION_POLICY:
	387	return ceph_set_encryption_policy(file, arg);
	388
	389	case FS_IOC_GET_ENCRYPTION_POLICY:
	390	ret = vet_mds_for_fscrypt(file);
	391	if (ret)
	392	return ret;
	393	return fscrypt_ioctl_get_policy(file, (void __user *)arg);
	394
	395	case FS_IOC_GET_ENCRYPTION_POLICY_EX:
	396	ret = vet_mds_for_fscrypt(file);
	397	if (ret)
	398	return ret;
	399	return fscrypt_ioctl_get_policy_ex(file, (void __user *)arg);
	400
	401	case FS_IOC_ADD_ENCRYPTION_KEY:
	402	ret = vet_mds_for_fscrypt(file);
	403	if (ret)
	404	return ret;
	405	return fscrypt_ioctl_add_key(file, (void __user *)arg);
	406
	407	case FS_IOC_REMOVE_ENCRYPTION_KEY:
	408	return fscrypt_ioctl_remove_key(file, (void __user *)arg);
	409
	410	case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
	411	return fscrypt_ioctl_remove_key_all_users(file,
	412	(void __user *)arg);
	413
	414	case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
	415	return fscrypt_ioctl_get_key_status(file, (void __user *)arg);
	416
	417	case FS_IOC_GET_ENCRYPTION_NONCE:
	418	ret = vet_mds_for_fscrypt(file);
	419	if (ret)
	420	return ret;
	421	return fscrypt_ioctl_get_nonce(file, (void __user *)arg);
	422	}
	423
	424	return -ENOTTY;
	425	}