[linux.git] / fs / ocfs2 / ioctl.c

/*
 * linux/fs/ocfs2/ioctl.c
 *
 * Copyright (C) 2006 Herbert Poetzl
 * adapted from Remy Card's ext2/ioctl.c
 */

#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/compat.h>

#define MLOG_MASK_PREFIX ML_INODE
#include <cluster/masklog.h>

#include "ocfs2.h"
#include "alloc.h"
#include "dlmglue.h"
#include "file.h"
#include "inode.h"
#include "journal.h"

#include "ocfs2_fs.h"
#include "ioctl.h"
#include "resize.h"
#include "refcounttree.h"

#include <linux/ext2_fs.h>

static int ocfs2_get_inode_attr(struct inode *inode, unsigned *flags)
{
	int status;

	status = ocfs2_inode_lock(inode, NULL, 0);
	if (status < 0) {
		mlog_errno(status);
		return status;
	}
	ocfs2_get_inode_flags(OCFS2_I(inode));
	*flags = OCFS2_I(inode)->ip_attr;
	ocfs2_inode_unlock(inode, 0);

	mlog_exit(status);
	return status;
}

static int ocfs2_set_inode_attr(struct inode *inode, unsigned flags,
				unsigned mask)
{
	struct ocfs2_inode_info *ocfs2_inode = OCFS2_I(inode);
	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
	handle_t *handle = NULL;
	struct buffer_head *bh = NULL;
	unsigned oldflags;
	int status;

	mutex_lock(&inode->i_mutex);

	status = ocfs2_inode_lock(inode, &bh, 1);
	if (status < 0) {
		mlog_errno(status);
		goto bail;
	}

	status = -EACCES;
	if (!is_owner_or_cap(inode))
		goto bail_unlock;

	if (!S_ISDIR(inode->i_mode))
		flags &= ~OCFS2_DIRSYNC_FL;

	handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
	if (IS_ERR(handle)) {
		status = PTR_ERR(handle);
		mlog_errno(status);
		goto bail_unlock;
	}

	oldflags = ocfs2_inode->ip_attr;
	flags = flags & mask;
	flags |= oldflags & ~mask;

	/*
	 * The IMMUTABLE and APPEND_ONLY flags can only be changed by
	 * the relevant capability.
	 */
	status = -EPERM;
	if ((oldflags & OCFS2_IMMUTABLE_FL) || ((flags ^ oldflags) &
		(OCFS2_APPEND_FL | OCFS2_IMMUTABLE_FL))) {
		if (!capable(CAP_LINUX_IMMUTABLE))
			goto bail_unlock;
	}

	ocfs2_inode->ip_attr = flags;
	ocfs2_set_inode_flags(inode);

	status = ocfs2_mark_inode_dirty(handle, inode, bh);
	if (status < 0)
		mlog_errno(status);

	ocfs2_commit_trans(osb, handle);
bail_unlock:
	ocfs2_inode_unlock(inode, 1);
bail:
	mutex_unlock(&inode->i_mutex);

	brelse(bh);

	mlog_exit(status);
	return status;
}

long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct inode *inode = filp->f_path.dentry->d_inode;
	unsigned int flags;
	int new_clusters;
	int status;
	struct ocfs2_space_resv sr;
	struct ocfs2_new_group_input input;
	struct reflink_arguments args;
	const char *old_path, *new_path;
	bool preserve;

	switch (cmd) {
	case OCFS2_IOC_GETFLAGS:
		status = ocfs2_get_inode_attr(inode, &flags);
		if (status < 0)
			return status;

		flags &= OCFS2_FL_VISIBLE;
		return put_user(flags, (int __user *) arg);
	case OCFS2_IOC_SETFLAGS:
		if (get_user(flags, (int __user *) arg))
			return -EFAULT;

		status = mnt_want_write(filp->f_path.mnt);
		if (status)
			return status;
		status = ocfs2_set_inode_attr(inode, flags,
			OCFS2_FL_MODIFIABLE);
		mnt_drop_write(filp->f_path.mnt);
		return status;
	case OCFS2_IOC_RESVSP:
	case OCFS2_IOC_RESVSP64:
	case OCFS2_IOC_UNRESVSP:
	case OCFS2_IOC_UNRESVSP64:
		if (copy_from_user(&sr, (int __user *) arg, sizeof(sr)))
			return -EFAULT;

		return ocfs2_change_file_space(filp, cmd, &sr);
	case OCFS2_IOC_GROUP_EXTEND:
		if (!capable(CAP_SYS_RESOURCE))
			return -EPERM;

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

		return ocfs2_group_extend(inode, new_clusters);
	case OCFS2_IOC_GROUP_ADD:
	case OCFS2_IOC_GROUP_ADD64:
		if (!capable(CAP_SYS_RESOURCE))
			return -EPERM;

		if (copy_from_user(&input, (int __user *) arg, sizeof(input)))
			return -EFAULT;

		return ocfs2_group_add(inode, &input);
	case OCFS2_IOC_REFLINK:
		if (copy_from_user(&args, (struct reflink_arguments *)arg,
				   sizeof(args)))
			return -EFAULT;
		old_path = (const char *)(unsigned long)args.old_path;
		new_path = (const char *)(unsigned long)args.new_path;
		preserve = (args.preserve != 0);

		return ocfs2_reflink_ioctl(inode, old_path, new_path, preserve);
	default:
		return -ENOTTY;
	}
}

#ifdef CONFIG_COMPAT
long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg)
{
	bool preserve;
	struct reflink_arguments args;
	struct inode *inode = file->f_path.dentry->d_inode;

	switch (cmd) {
	case OCFS2_IOC32_GETFLAGS:
		cmd = OCFS2_IOC_GETFLAGS;
		break;
	case OCFS2_IOC32_SETFLAGS:
		cmd = OCFS2_IOC_SETFLAGS;
		break;
	case OCFS2_IOC_RESVSP:
	case OCFS2_IOC_RESVSP64:
	case OCFS2_IOC_UNRESVSP:
	case OCFS2_IOC_UNRESVSP64:
	case OCFS2_IOC_GROUP_EXTEND:
	case OCFS2_IOC_GROUP_ADD:
	case OCFS2_IOC_GROUP_ADD64:
		break;
	case OCFS2_IOC_REFLINK:
		if (copy_from_user(&args, (struct reflink_arguments *)arg,
				   sizeof(args)))
			return -EFAULT;
		preserve = (args.preserve != 0);

		return ocfs2_reflink_ioctl(inode, compat_ptr(args.old_path),
					   compat_ptr(args.new_path), preserve);
	default:
		return -ENOIOCTLCMD;
	}

	return ocfs2_ioctl(file, cmd, arg);
}
#endif
Commit	Line	Data
ca4d147e HP	1	/*
	2	* linux/fs/ocfs2/ioctl.c
	3	*
	4	* Copyright (C) 2006 Herbert Poetzl
	5	* adapted from Remy Card's ext2/ioctl.c
	6	*/
	7
	8	#include <linux/fs.h>
	9	#include <linux/mount.h>
34e6c59a	10	#include <linux/compat.h>
ca4d147e HP	11
	12	#define MLOG_MASK_PREFIX ML_INODE
	13	#include <cluster/masklog.h>
	14
	15	#include "ocfs2.h"
	16	#include "alloc.h"
	17	#include "dlmglue.h"
b2580103	18	#include "file.h"
ca4d147e HP	19	#include "inode.h"
	20	#include "journal.h"
	21
	22	#include "ocfs2_fs.h"
2d562518	23	#include "ioctl.h"
d659072f	24	#include "resize.h"
bd50873d	25	#include "refcounttree.h"
2d562518	26
ca4d147e HP	27	#include <linux/ext2_fs.h>
	28
	29	static int ocfs2_get_inode_attr(struct inode inode, unsigned flags)
	30	{
	31	int status;
	32
e63aecb6	33	status = ocfs2_inode_lock(inode, NULL, 0);
ca4d147e HP	34	if (status < 0) {
	35	mlog_errno(status);
	36	return status;
	37	}
6e4b0d56	38	ocfs2_get_inode_flags(OCFS2_I(inode));
ca4d147e	39	*flags = OCFS2_I(inode)->ip_attr;
e63aecb6	40	ocfs2_inode_unlock(inode, 0);
ca4d147e HP	41
	42	mlog_exit(status);
	43	return status;
	44	}
	45
	46	static int ocfs2_set_inode_attr(struct inode *inode, unsigned flags,
	47	unsigned mask)
	48	{
	49	struct ocfs2_inode_info *ocfs2_inode = OCFS2_I(inode);
	50	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1fabe148	51	handle_t *handle = NULL;
ca4d147e HP	52	struct buffer_head *bh = NULL;
	53	unsigned oldflags;
	54	int status;
	55
	56	mutex_lock(&inode->i_mutex);
	57
e63aecb6	58	status = ocfs2_inode_lock(inode, &bh, 1);
ca4d147e HP	59	if (status < 0) {
	60	mlog_errno(status);
	61	goto bail;
	62	}
	63
ca4d147e	64	status = -EACCES;
3bd858ab	65	if (!is_owner_or_cap(inode))
ca4d147e HP	66	goto bail_unlock;
	67
	68	if (!S_ISDIR(inode->i_mode))
	69	flags &= ~OCFS2_DIRSYNC_FL;
	70
65eff9cc	71	handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
ca4d147e HP	72	if (IS_ERR(handle)) {
	73	status = PTR_ERR(handle);
	74	mlog_errno(status);
	75	goto bail_unlock;
	76	}
	77
	78	oldflags = ocfs2_inode->ip_attr;
	79	flags = flags & mask;
	80	flags \|= oldflags & ~mask;
	81
	82	/*
	83	* The IMMUTABLE and APPEND_ONLY flags can only be changed by
	84	* the relevant capability.
	85	*/
	86	status = -EPERM;
	87	if ((oldflags & OCFS2_IMMUTABLE_FL) \|\| ((flags ^ oldflags) &
	88	(OCFS2_APPEND_FL \| OCFS2_IMMUTABLE_FL))) {
	89	if (!capable(CAP_LINUX_IMMUTABLE))
	90	goto bail_unlock;
	91	}
	92
	93	ocfs2_inode->ip_attr = flags;
	94	ocfs2_set_inode_flags(inode);
	95
	96	status = ocfs2_mark_inode_dirty(handle, inode, bh);
	97	if (status < 0)
	98	mlog_errno(status);
	99
02dc1af4	100	ocfs2_commit_trans(osb, handle);
ca4d147e	101	bail_unlock:
e63aecb6	102	ocfs2_inode_unlock(inode, 1);
ca4d147e HP	103	bail:
	104	mutex_unlock(&inode->i_mutex);
	105
a81cb88b	106	brelse(bh);
ca4d147e HP	107
	108	mlog_exit(status);
	109	return status;
	110	}
	111
c9ec1488	112	long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
ca4d147e	113	{
c9ec1488	114	struct inode *inode = filp->f_path.dentry->d_inode;
ca4d147e	115	unsigned int flags;
d659072f	116	int new_clusters;
ca4d147e	117	int status;
b2580103	118	struct ocfs2_space_resv sr;
7909f2bf	119	struct ocfs2_new_group_input input;
bd50873d TM	120	struct reflink_arguments args;
	121	const char old_path, new_path;
	122	bool preserve;
ca4d147e HP	123
	124	switch (cmd) {
	125	case OCFS2_IOC_GETFLAGS:
	126	status = ocfs2_get_inode_attr(inode, &flags);
	127	if (status < 0)
	128	return status;
	129
	130	flags &= OCFS2_FL_VISIBLE;
	131	return put_user(flags, (int __user *) arg);
	132	case OCFS2_IOC_SETFLAGS:
	133	if (get_user(flags, (int __user *) arg))
	134	return -EFAULT;
	135
42a74f20 DH	136	status = mnt_want_write(filp->f_path.mnt);
	137	if (status)
	138	return status;
	139	status = ocfs2_set_inode_attr(inode, flags,
ca4d147e	140	OCFS2_FL_MODIFIABLE);
42a74f20 DH	141	mnt_drop_write(filp->f_path.mnt);
42a74f20 DH	142	return status;
b2580103 MF	143	case OCFS2_IOC_RESVSP:
	144	case OCFS2_IOC_RESVSP64:
	145	case OCFS2_IOC_UNRESVSP:
	146	case OCFS2_IOC_UNRESVSP64:
	147	if (copy_from_user(&sr, (int __user *) arg, sizeof(sr)))
	148	return -EFAULT;
	149
	150	return ocfs2_change_file_space(filp, cmd, &sr);
d659072f	151	case OCFS2_IOC_GROUP_EXTEND:
0957f007 MF	152	if (!capable(CAP_SYS_RESOURCE))
	153	return -EPERM;
	154
d659072f TM	155	if (get_user(new_clusters, (int __user *)arg))
	156	return -EFAULT;
	157
	158	return ocfs2_group_extend(inode, new_clusters);
7909f2bf TM	159	case OCFS2_IOC_GROUP_ADD:
7909f2bf TM	160	case OCFS2_IOC_GROUP_ADD64:
0957f007 MF	161	if (!capable(CAP_SYS_RESOURCE))
	162	return -EPERM;
	163
7909f2bf TM	164	if (copy_from_user(&input, (int __user *) arg, sizeof(input)))
	165	return -EFAULT;
	166
	167	return ocfs2_group_add(inode, &input);
bd50873d TM	168	case OCFS2_IOC_REFLINK:
	169	if (copy_from_user(&args, (struct reflink_arguments *)arg,
	170	sizeof(args)))
	171	return -EFAULT;
	172	old_path = (const char *)(unsigned long)args.old_path;
	173	new_path = (const char *)(unsigned long)args.new_path;
	174	preserve = (args.preserve != 0);
	175
	176	return ocfs2_reflink_ioctl(inode, old_path, new_path, preserve);
ca4d147e HP	177	default:
	178	return -ENOTTY;
	179	}
	180	}
	181
586d232b MF	182	#ifdef CONFIG_COMPAT
	183	long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg)
	184	{
34e6c59a TM	185	bool preserve;
	186	struct reflink_arguments args;
	187	struct inode *inode = file->f_path.dentry->d_inode;
	188
586d232b MF	189	switch (cmd) {
	190	case OCFS2_IOC32_GETFLAGS:
	191	cmd = OCFS2_IOC_GETFLAGS;
	192	break;
	193	case OCFS2_IOC32_SETFLAGS:
	194	cmd = OCFS2_IOC_SETFLAGS;
	195	break;
b2580103 MF	196	case OCFS2_IOC_RESVSP:
	197	case OCFS2_IOC_RESVSP64:
	198	case OCFS2_IOC_UNRESVSP:
	199	case OCFS2_IOC_UNRESVSP64:
d659072f	200	case OCFS2_IOC_GROUP_EXTEND:
7909f2bf TM	201	case OCFS2_IOC_GROUP_ADD:
7909f2bf TM	202	case OCFS2_IOC_GROUP_ADD64:
b2580103	203	break;
34e6c59a TM	204	case OCFS2_IOC_REFLINK:
	205	if (copy_from_user(&args, (struct reflink_arguments *)arg,
	206	sizeof(args)))
	207	return -EFAULT;
	208	preserve = (args.preserve != 0);
	209
	210	return ocfs2_reflink_ioctl(inode, compat_ptr(args.old_path),
	211	compat_ptr(args.new_path), preserve);
586d232b MF	212	default:
	213	return -ENOIOCTLCMD;
	214	}
	215
c9ec1488	216	return ocfs2_ioctl(file, cmd, arg);
586d232b MF	217	}
586d232b MF	218	#endif