[linux-block.git] / fs / ext3 / ioctl.c

/*
 * linux/fs/ext3/ioctl.c
 *
 * Copyright (C) 1993, 1994, 1995
 * Remy Card (card@masi.ibp.fr)
 * Laboratoire MASI - Institut Blaise Pascal
 * Universite Pierre et Marie Curie (Paris VI)
 */

#include <linux/mount.h>
#include <linux/compat.h>
#include <asm/uaccess.h>
#include "ext3.h"

long ext3_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct inode *inode = filp->f_dentry->d_inode;
	struct ext3_inode_info *ei = EXT3_I(inode);
	unsigned int flags;
	unsigned short rsv_window_size;

	ext3_debug ("cmd = %u, arg = %lu\n", cmd, arg);

	switch (cmd) {
	case EXT3_IOC_GETFLAGS:
		ext3_get_inode_flags(ei);
		flags = ei->i_flags & EXT3_FL_USER_VISIBLE;
		return put_user(flags, (int __user *) arg);
	case EXT3_IOC_SETFLAGS: {
		handle_t *handle = NULL;
		int err;
		struct ext3_iloc iloc;
		unsigned int oldflags;
		unsigned int jflag;

		if (!inode_owner_or_capable(inode))
			return -EACCES;

		if (get_user(flags, (int __user *) arg))
			return -EFAULT;

		err = mnt_want_write_file(filp);
		if (err)
			return err;

		flags = ext3_mask_flags(inode->i_mode, flags);

		mutex_lock(&inode->i_mutex);

		/* Is it quota file? Do not allow user to mess with it */
		err = -EPERM;
		if (IS_NOQUOTA(inode))
			goto flags_out;

		oldflags = ei->i_flags;

		/* The JOURNAL_DATA flag is modifiable only by root */
		jflag = flags & EXT3_JOURNAL_DATA_FL;

		/*
		 * The IMMUTABLE and APPEND_ONLY flags can only be changed by
		 * the relevant capability.
		 *
		 * This test looks nicer. Thanks to Pauline Middelink
		 */
		if ((flags ^ oldflags) & (EXT3_APPEND_FL | EXT3_IMMUTABLE_FL)) {
			if (!capable(CAP_LINUX_IMMUTABLE))
				goto flags_out;
		}

		/*
		 * The JOURNAL_DATA flag can only be changed by
		 * the relevant capability.
		 */
		if ((jflag ^ oldflags) & (EXT3_JOURNAL_DATA_FL)) {
			if (!capable(CAP_SYS_RESOURCE))
				goto flags_out;
		}

		handle = ext3_journal_start(inode, 1);
		if (IS_ERR(handle)) {
			err = PTR_ERR(handle);
			goto flags_out;
		}
		if (IS_SYNC(inode))
			handle->h_sync = 1;
		err = ext3_reserve_inode_write(handle, inode, &iloc);
		if (err)
			goto flags_err;

		flags = flags & EXT3_FL_USER_MODIFIABLE;
		flags |= oldflags & ~EXT3_FL_USER_MODIFIABLE;
		ei->i_flags = flags;

		ext3_set_inode_flags(inode);
		inode->i_ctime = CURRENT_TIME_SEC;

		err = ext3_mark_iloc_dirty(handle, inode, &iloc);
flags_err:
		ext3_journal_stop(handle);
		if (err)
			goto flags_out;

		if ((jflag ^ oldflags) & (EXT3_JOURNAL_DATA_FL))
			err = ext3_change_inode_journal_flag(inode, jflag);
flags_out:
		mutex_unlock(&inode->i_mutex);
		mnt_drop_write_file(filp);
		return err;
	}
	case EXT3_IOC_GETVERSION:
	case EXT3_IOC_GETVERSION_OLD:
		return put_user(inode->i_generation, (int __user *) arg);
	case EXT3_IOC_SETVERSION:
	case EXT3_IOC_SETVERSION_OLD: {
		handle_t *handle;
		struct ext3_iloc iloc;
		__u32 generation;
		int err;

		if (!inode_owner_or_capable(inode))
			return -EPERM;

		err = mnt_want_write_file(filp);
		if (err)
			return err;
		if (get_user(generation, (int __user *) arg)) {
			err = -EFAULT;
			goto setversion_out;
		}

		mutex_lock(&inode->i_mutex);
		handle = ext3_journal_start(inode, 1);
		if (IS_ERR(handle)) {
			err = PTR_ERR(handle);
			goto unlock_out;
		}
		err = ext3_reserve_inode_write(handle, inode, &iloc);
		if (err == 0) {
			inode->i_ctime = CURRENT_TIME_SEC;
			inode->i_generation = generation;
			err = ext3_mark_iloc_dirty(handle, inode, &iloc);
		}
		ext3_journal_stop(handle);

unlock_out:
		mutex_unlock(&inode->i_mutex);
setversion_out:
		mnt_drop_write_file(filp);
		return err;
	}
	case EXT3_IOC_GETRSVSZ:
		if (test_opt(inode->i_sb, RESERVATION)
			&& S_ISREG(inode->i_mode)
			&& ei->i_block_alloc_info) {
			rsv_window_size = ei->i_block_alloc_info->rsv_window_node.rsv_goal_size;
			return put_user(rsv_window_size, (int __user *)arg);
		}
		return -ENOTTY;
	case EXT3_IOC_SETRSVSZ: {
		int err;

		if (!test_opt(inode->i_sb, RESERVATION) ||!S_ISREG(inode->i_mode))
			return -ENOTTY;

		err = mnt_want_write_file(filp);
		if (err)
			return err;

		if (!inode_owner_or_capable(inode)) {
			err = -EACCES;
			goto setrsvsz_out;
		}

		if (get_user(rsv_window_size, (int __user *)arg)) {
			err = -EFAULT;
			goto setrsvsz_out;
		}

		if (rsv_window_size > EXT3_MAX_RESERVE_BLOCKS)
			rsv_window_size = EXT3_MAX_RESERVE_BLOCKS;

		/*
		 * need to allocate reservation structure for this inode
		 * before set the window size
		 */
		mutex_lock(&ei->truncate_mutex);
		if (!ei->i_block_alloc_info)
			ext3_init_block_alloc_info(inode);

		if (ei->i_block_alloc_info){
			struct ext3_reserve_window_node *rsv = &ei->i_block_alloc_info->rsv_window_node;
			rsv->rsv_goal_size = rsv_window_size;
		}
		mutex_unlock(&ei->truncate_mutex);
setrsvsz_out:
		mnt_drop_write_file(filp);
		return err;
	}
	case EXT3_IOC_GROUP_EXTEND: {
		ext3_fsblk_t n_blocks_count;
		struct super_block *sb = inode->i_sb;
		int err, err2;

		if (!capable(CAP_SYS_RESOURCE))
			return -EPERM;

		err = mnt_want_write_file(filp);
		if (err)
			return err;

		if (get_user(n_blocks_count, (__u32 __user *)arg)) {
			err = -EFAULT;
			goto group_extend_out;
		}
		err = ext3_group_extend(sb, EXT3_SB(sb)->s_es, n_blocks_count);
		journal_lock_updates(EXT3_SB(sb)->s_journal);
		err2 = journal_flush(EXT3_SB(sb)->s_journal);
		journal_unlock_updates(EXT3_SB(sb)->s_journal);
		if (err == 0)
			err = err2;
group_extend_out:
		mnt_drop_write_file(filp);
		return err;
	}
	case EXT3_IOC_GROUP_ADD: {
		struct ext3_new_group_data input;
		struct super_block *sb = inode->i_sb;
		int err, err2;

		if (!capable(CAP_SYS_RESOURCE))
			return -EPERM;

		err = mnt_want_write_file(filp);
		if (err)
			return err;

		if (copy_from_user(&input, (struct ext3_new_group_input __user *)arg,
				sizeof(input))) {
			err = -EFAULT;
			goto group_add_out;
		}

		err = ext3_group_add(sb, &input);
		journal_lock_updates(EXT3_SB(sb)->s_journal);
		err2 = journal_flush(EXT3_SB(sb)->s_journal);
		journal_unlock_updates(EXT3_SB(sb)->s_journal);
		if (err == 0)
			err = err2;
group_add_out:
		mnt_drop_write_file(filp);
		return err;
	}
	case FITRIM: {

		struct super_block *sb = inode->i_sb;
		struct fstrim_range range;
		int ret = 0;

		if (!capable(CAP_SYS_ADMIN))
			return -EPERM;

		if (copy_from_user(&range, (struct fstrim_range __user *)arg,
				   sizeof(range)))
			return -EFAULT;

		ret = ext3_trim_fs(sb, &range);
		if (ret < 0)
			return ret;

		if (copy_to_user((struct fstrim_range __user *)arg, &range,
				 sizeof(range)))
			return -EFAULT;

		return 0;
	}

	default:
		return -ENOTTY;
	}
}

#ifdef CONFIG_COMPAT
long ext3_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	/* These are just misnamed, they actually get/put from/to user an int */
	switch (cmd) {
	case EXT3_IOC32_GETFLAGS:
		cmd = EXT3_IOC_GETFLAGS;
		break;
	case EXT3_IOC32_SETFLAGS:
		cmd = EXT3_IOC_SETFLAGS;
		break;
	case EXT3_IOC32_GETVERSION:
		cmd = EXT3_IOC_GETVERSION;
		break;
	case EXT3_IOC32_SETVERSION:
		cmd = EXT3_IOC_SETVERSION;
		break;
	case EXT3_IOC32_GROUP_EXTEND:
		cmd = EXT3_IOC_GROUP_EXTEND;
		break;
	case EXT3_IOC32_GETVERSION_OLD:
		cmd = EXT3_IOC_GETVERSION_OLD;
		break;
	case EXT3_IOC32_SETVERSION_OLD:
		cmd = EXT3_IOC_SETVERSION_OLD;
		break;
#ifdef CONFIG_JBD_DEBUG
	case EXT3_IOC32_WAIT_FOR_READONLY:
		cmd = EXT3_IOC_WAIT_FOR_READONLY;
		break;
#endif
	case EXT3_IOC32_GETRSVSZ:
		cmd = EXT3_IOC_GETRSVSZ;
		break;
	case EXT3_IOC32_SETRSVSZ:
		cmd = EXT3_IOC_SETRSVSZ;
		break;
	case EXT3_IOC_GROUP_ADD:
		break;
	default:
		return -ENOIOCTLCMD;
	}
	return ext3_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
}
#endif
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/ext3/ioctl.c
	3	*
	4	* Copyright (C) 1993, 1994, 1995
	5	* Remy Card (card@masi.ibp.fr)
	6	* Laboratoire MASI - Institut Blaise Pascal
	7	* Universite Pierre et Marie Curie (Paris VI)
	8	*/
	9
42a74f20	10	#include <linux/mount.h>
52a700c5	11	#include <linux/compat.h>
1da177e4	12	#include <asm/uaccess.h>
4613ad18	13	#include "ext3.h"
1da177e4	14
039fd8ce	15	long ext3_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1da177e4	16	{
039fd8ce	17	struct inode *inode = filp->f_dentry->d_inode;
1da177e4 LT	18	struct ext3_inode_info *ei = EXT3_I(inode);
	19	unsigned int flags;
	20	unsigned short rsv_window_size;
	21
	22	ext3_debug ("cmd = %u, arg = %lu\n", cmd, arg);
	23
	24	switch (cmd) {
	25	case EXT3_IOC_GETFLAGS:
28be5abb	26	ext3_get_inode_flags(ei);
1da177e4 LT	27	flags = ei->i_flags & EXT3_FL_USER_VISIBLE;
	28	return put_user(flags, (int __user *) arg);
	29	case EXT3_IOC_SETFLAGS: {
	30	handle_t *handle = NULL;
	31	int err;
	32	struct ext3_iloc iloc;
	33	unsigned int oldflags;
	34	unsigned int jflag;
	35
2e149670	36	if (!inode_owner_or_capable(inode))
039fd8ce CM	37	return -EACCES;
	38
	39	if (get_user(flags, (int __user *) arg))
	40	return -EFAULT;
	41
a561be71	42	err = mnt_want_write_file(filp);
42a74f20 DH	43	if (err)
42a74f20 DH	44	return err;
1da177e4	45
04143e2f	46	flags = ext3_mask_flags(inode->i_mode, flags);
1da177e4	47
a090d913	48	mutex_lock(&inode->i_mutex);
039fd8ce	49
e47776a0	50	/* Is it quota file? Do not allow user to mess with it */
039fd8ce CM	51	err = -EPERM;
039fd8ce CM	52	if (IS_NOQUOTA(inode))
42a74f20	53	goto flags_out;
039fd8ce	54
1da177e4 LT	55	oldflags = ei->i_flags;
	56
	57	/* The JOURNAL_DATA flag is modifiable only by root */
	58	jflag = flags & EXT3_JOURNAL_DATA_FL;
	59
	60	/*
	61	* The IMMUTABLE and APPEND_ONLY flags can only be changed by
	62	* the relevant capability.
	63	*
	64	* This test looks nicer. Thanks to Pauline Middelink
	65	*/
	66	if ((flags ^ oldflags) & (EXT3_APPEND_FL \| EXT3_IMMUTABLE_FL)) {
039fd8ce	67	if (!capable(CAP_LINUX_IMMUTABLE))
42a74f20	68	goto flags_out;
1da177e4 LT	69	}
	70
	71	/*
	72	* The JOURNAL_DATA flag can only be changed by
	73	* the relevant capability.
	74	*/
	75	if ((jflag ^ oldflags) & (EXT3_JOURNAL_DATA_FL)) {
039fd8ce	76	if (!capable(CAP_SYS_RESOURCE))
42a74f20	77	goto flags_out;
1da177e4 LT	78	}
1da177e4 LT	79
1da177e4	80	handle = ext3_journal_start(inode, 1);
a090d913	81	if (IS_ERR(handle)) {
42a74f20 DH	82	err = PTR_ERR(handle);
42a74f20 DH	83	goto flags_out;
a090d913	84	}
1da177e4 LT	85	if (IS_SYNC(inode))
	86	handle->h_sync = 1;
	87	err = ext3_reserve_inode_write(handle, inode, &iloc);
	88	if (err)
	89	goto flags_err;
	90
	91	flags = flags & EXT3_FL_USER_MODIFIABLE;
	92	flags \|= oldflags & ~EXT3_FL_USER_MODIFIABLE;
	93	ei->i_flags = flags;
	94
	95	ext3_set_inode_flags(inode);
	96	inode->i_ctime = CURRENT_TIME_SEC;
	97
	98	err = ext3_mark_iloc_dirty(handle, inode, &iloc);
	99	flags_err:
	100	ext3_journal_stop(handle);
039fd8ce CM	101	if (err)
039fd8ce CM	102	goto flags_out;
1da177e4 LT	103
	104	if ((jflag ^ oldflags) & (EXT3_JOURNAL_DATA_FL))
	105	err = ext3_change_inode_journal_flag(inode, jflag);
42a74f20	106	flags_out:
039fd8ce	107	mutex_unlock(&inode->i_mutex);
2a79f17e	108	mnt_drop_write_file(filp);
1da177e4 LT	109	return err;
	110	}
	111	case EXT3_IOC_GETVERSION:
	112	case EXT3_IOC_GETVERSION_OLD:
	113	return put_user(inode->i_generation, (int __user *) arg);
	114	case EXT3_IOC_SETVERSION:
	115	case EXT3_IOC_SETVERSION_OLD: {
	116	handle_t *handle;
	117	struct ext3_iloc iloc;
	118	__u32 generation;
	119	int err;
	120
2e149670	121	if (!inode_owner_or_capable(inode))
1da177e4	122	return -EPERM;
039fd8ce	123
a561be71	124	err = mnt_want_write_file(filp);
42a74f20 DH	125	if (err)
	126	return err;
	127	if (get_user(generation, (int __user *) arg)) {
	128	err = -EFAULT;
	129	goto setversion_out;
	130	}
039fd8ce	131
6c2155b9	132	mutex_lock(&inode->i_mutex);
1da177e4	133	handle = ext3_journal_start(inode, 1);
42a74f20 DH	134	if (IS_ERR(handle)) {
42a74f20 DH	135	err = PTR_ERR(handle);
6c2155b9	136	goto unlock_out;
42a74f20	137	}
1da177e4 LT	138	err = ext3_reserve_inode_write(handle, inode, &iloc);
	139	if (err == 0) {
	140	inode->i_ctime = CURRENT_TIME_SEC;
	141	inode->i_generation = generation;
	142	err = ext3_mark_iloc_dirty(handle, inode, &iloc);
	143	}
	144	ext3_journal_stop(handle);
6c2155b9 DH	145
	146	unlock_out:
	147	mutex_unlock(&inode->i_mutex);
42a74f20	148	setversion_out:
2a79f17e	149	mnt_drop_write_file(filp);
1da177e4 LT	150	return err;
1da177e4 LT	151	}
1da177e4 LT	152	case EXT3_IOC_GETRSVSZ:
	153	if (test_opt(inode->i_sb, RESERVATION)
	154	&& S_ISREG(inode->i_mode)
	155	&& ei->i_block_alloc_info) {
	156	rsv_window_size = ei->i_block_alloc_info->rsv_window_node.rsv_goal_size;
	157	return put_user(rsv_window_size, (int __user *)arg);
	158	}
	159	return -ENOTTY;
	160	case EXT3_IOC_SETRSVSZ: {
42a74f20	161	int err;
1da177e4 LT	162
	163	if (!test_opt(inode->i_sb, RESERVATION) \|\|!S_ISREG(inode->i_mode))
	164	return -ENOTTY;
	165
a561be71	166	err = mnt_want_write_file(filp);
42a74f20 DH	167	if (err)
42a74f20 DH	168	return err;
1da177e4	169
2e149670	170	if (!inode_owner_or_capable(inode)) {
42a74f20 DH	171	err = -EACCES;
	172	goto setrsvsz_out;
	173	}
1da177e4	174
42a74f20 DH	175	if (get_user(rsv_window_size, (int __user *)arg)) {
	176	err = -EFAULT;
	177	goto setrsvsz_out;
	178	}
1da177e4 LT	179
	180	if (rsv_window_size > EXT3_MAX_RESERVE_BLOCKS)
	181	rsv_window_size = EXT3_MAX_RESERVE_BLOCKS;
	182
	183	/*
	184	* need to allocate reservation structure for this inode
	185	* before set the window size
	186	*/
97461518	187	mutex_lock(&ei->truncate_mutex);
1da177e4 LT	188	if (!ei->i_block_alloc_info)
	189	ext3_init_block_alloc_info(inode);
	190
	191	if (ei->i_block_alloc_info){
	192	struct ext3_reserve_window_node *rsv = &ei->i_block_alloc_info->rsv_window_node;
	193	rsv->rsv_goal_size = rsv_window_size;
	194	}
97461518	195	mutex_unlock(&ei->truncate_mutex);
42a74f20	196	setrsvsz_out:
2a79f17e	197	mnt_drop_write_file(filp);
42a74f20	198	return err;
1da177e4 LT	199	}
1da177e4 LT	200	case EXT3_IOC_GROUP_EXTEND: {
43d23f90	201	ext3_fsblk_t n_blocks_count;
1da177e4	202	struct super_block *sb = inode->i_sb;
2d7c820e	203	int err, err2;
1da177e4 LT	204
	205	if (!capable(CAP_SYS_RESOURCE))
	206	return -EPERM;
	207
a561be71	208	err = mnt_want_write_file(filp);
42a74f20 DH	209	if (err)
42a74f20 DH	210	return err;
1da177e4	211
42a74f20 DH	212	if (get_user(n_blocks_count, (__u32 __user *)arg)) {
	213	err = -EFAULT;
	214	goto group_extend_out;
	215	}
1da177e4 LT	216	err = ext3_group_extend(sb, EXT3_SB(sb)->s_es, n_blocks_count);
1da177e4 LT	217	journal_lock_updates(EXT3_SB(sb)->s_journal);
2d7c820e	218	err2 = journal_flush(EXT3_SB(sb)->s_journal);
1da177e4	219	journal_unlock_updates(EXT3_SB(sb)->s_journal);
2d7c820e HK	220	if (err == 0)
2d7c820e HK	221	err = err2;
42a74f20	222	group_extend_out:
2a79f17e	223	mnt_drop_write_file(filp);
1da177e4 LT	224	return err;
	225	}
	226	case EXT3_IOC_GROUP_ADD: {
	227	struct ext3_new_group_data input;
	228	struct super_block *sb = inode->i_sb;
2d7c820e	229	int err, err2;
1da177e4 LT	230
	231	if (!capable(CAP_SYS_RESOURCE))
	232	return -EPERM;
	233
a561be71	234	err = mnt_want_write_file(filp);
42a74f20 DH	235	if (err)
42a74f20 DH	236	return err;
1da177e4 LT	237
1da177e4 LT	238	if (copy_from_user(&input, (struct ext3_new_group_input __user *)arg,
42a74f20 DH	239	sizeof(input))) {
	240	err = -EFAULT;
	241	goto group_add_out;
	242	}
1da177e4 LT	243
	244	err = ext3_group_add(sb, &input);
	245	journal_lock_updates(EXT3_SB(sb)->s_journal);
2d7c820e	246	err2 = journal_flush(EXT3_SB(sb)->s_journal);
1da177e4	247	journal_unlock_updates(EXT3_SB(sb)->s_journal);
2d7c820e HK	248	if (err == 0)
2d7c820e HK	249	err = err2;
42a74f20	250	group_add_out:
2a79f17e	251	mnt_drop_write_file(filp);
1da177e4 LT	252	return err;
1da177e4 LT	253	}
9c527492	254	case FITRIM: {
1da177e4	255
9c527492 LC	256	struct super_block *sb = inode->i_sb;
	257	struct fstrim_range range;
	258	int ret = 0;
	259
	260	if (!capable(CAP_SYS_ADMIN))
	261	return -EPERM;
	262
81fe8c62	263	if (copy_from_user(&range, (struct fstrim_range __user *)arg,
9c527492 LC	264	sizeof(range)))
	265	return -EFAULT;
	266
	267	ret = ext3_trim_fs(sb, &range);
	268	if (ret < 0)
	269	return ret;
	270
81fe8c62	271	if (copy_to_user((struct fstrim_range __user *)arg, &range,
9c527492 LC	272	sizeof(range)))
	273	return -EFAULT;
	274
	275	return 0;
	276	}
1da177e4 LT	277
	278	default:
	279	return -ENOTTY;
	280	}
	281	}
52a700c5 DH	282
	283	#ifdef CONFIG_COMPAT
	284	long ext3_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	285	{
52a700c5 DH	286	/* These are just misnamed, they actually get/put from/to user an int */
	287	switch (cmd) {
	288	case EXT3_IOC32_GETFLAGS:
	289	cmd = EXT3_IOC_GETFLAGS;
	290	break;
	291	case EXT3_IOC32_SETFLAGS:
	292	cmd = EXT3_IOC_SETFLAGS;
	293	break;
	294	case EXT3_IOC32_GETVERSION:
	295	cmd = EXT3_IOC_GETVERSION;
	296	break;
	297	case EXT3_IOC32_SETVERSION:
	298	cmd = EXT3_IOC_SETVERSION;
	299	break;
	300	case EXT3_IOC32_GROUP_EXTEND:
	301	cmd = EXT3_IOC_GROUP_EXTEND;
	302	break;
	303	case EXT3_IOC32_GETVERSION_OLD:
	304	cmd = EXT3_IOC_GETVERSION_OLD;
	305	break;
	306	case EXT3_IOC32_SETVERSION_OLD:
	307	cmd = EXT3_IOC_SETVERSION_OLD;
	308	break;
	309	#ifdef CONFIG_JBD_DEBUG
	310	case EXT3_IOC32_WAIT_FOR_READONLY:
	311	cmd = EXT3_IOC_WAIT_FOR_READONLY;
	312	break;
	313	#endif
	314	case EXT3_IOC32_GETRSVSZ:
	315	cmd = EXT3_IOC_GETRSVSZ;
	316	break;
	317	case EXT3_IOC32_SETRSVSZ:
	318	cmd = EXT3_IOC_SETRSVSZ;
	319	break;
	320	case EXT3_IOC_GROUP_ADD:
	321	break;
	322	default:
	323	return -ENOIOCTLCMD;
	324	}
039fd8ce	325	return ext3_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
52a700c5 DH	326	}
52a700c5 DH	327	#endif