[deliverable/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>

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

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

#include "ocfs2_fs.h"
#include "ioctl.h"

#include <linux/ext2_fs.h>

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

	status = ocfs2_meta_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_meta_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_meta_lock(inode, &bh, 1);
	if (status < 0) {
		mlog_errno(status);
		goto bail;
	}

	status = -EROFS;
	if (IS_RDONLY(inode))
		goto bail_unlock;

	status = -EACCES;
	if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
		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_meta_unlock(inode, 1);
bail:
	mutex_unlock(&inode->i_mutex);

	if (bh)
		brelse(bh);

	mlog_exit(status);
	return status;
}

int ocfs2_ioctl(struct inode * inode, struct file * filp,
	unsigned int cmd, unsigned long arg)
{
	unsigned int flags;
	int status;

	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;

		return ocfs2_set_inode_attr(inode, flags,
			OCFS2_FL_MODIFIABLE);
	default:
		return -ENOTTY;
	}
}

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

	switch (cmd) {
	case OCFS2_IOC32_GETFLAGS:
		cmd = OCFS2_IOC_GETFLAGS;
		break;
	case OCFS2_IOC32_SETFLAGS:
		cmd = OCFS2_IOC_SETFLAGS;
		break;
	default:
		return -ENOIOCTLCMD;
	}

	lock_kernel();
	ret = ocfs2_ioctl(inode, file, cmd, arg);
	unlock_kernel();
	return ret;
}
#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>
	10
	11	#define MLOG_MASK_PREFIX ML_INODE
	12	#include <cluster/masklog.h>
	13
	14	#include "ocfs2.h"
	15	#include "alloc.h"
	16	#include "dlmglue.h"
	17	#include "inode.h"
	18	#include "journal.h"
	19
	20	#include "ocfs2_fs.h"
2d562518 AB	21	#include "ioctl.h"
2d562518 AB	22
ca4d147e HP	23	#include <linux/ext2_fs.h>
	24
	25	static int ocfs2_get_inode_attr(struct inode inode, unsigned flags)
	26	{
	27	int status;
	28
4bcec184	29	status = ocfs2_meta_lock(inode, NULL, 0);
ca4d147e HP	30	if (status < 0) {
	31	mlog_errno(status);
	32	return status;
	33	}
6e4b0d56	34	ocfs2_get_inode_flags(OCFS2_I(inode));
ca4d147e HP	35	*flags = OCFS2_I(inode)->ip_attr;
	36	ocfs2_meta_unlock(inode, 0);
	37
	38	mlog_exit(status);
	39	return status;
	40	}
	41
	42	static int ocfs2_set_inode_attr(struct inode *inode, unsigned flags,
	43	unsigned mask)
	44	{
	45	struct ocfs2_inode_info *ocfs2_inode = OCFS2_I(inode);
	46	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1fabe148	47	handle_t *handle = NULL;
ca4d147e HP	48	struct buffer_head *bh = NULL;
	49	unsigned oldflags;
	50	int status;
	51
	52	mutex_lock(&inode->i_mutex);
	53
4bcec184	54	status = ocfs2_meta_lock(inode, &bh, 1);
ca4d147e HP	55	if (status < 0) {
	56	mlog_errno(status);
	57	goto bail;
	58	}
	59
	60	status = -EROFS;
	61	if (IS_RDONLY(inode))
	62	goto bail_unlock;
	63
	64	status = -EACCES;
	65	if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
	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 HP	101	bail_unlock:
	102	ocfs2_meta_unlock(inode, 1);
	103	bail:
	104	mutex_unlock(&inode->i_mutex);
	105
	106	if (bh)
	107	brelse(bh);
	108
	109	mlog_exit(status);
	110	return status;
	111	}
	112
	113	int ocfs2_ioctl(struct inode * inode, struct file * filp,
	114	unsigned int cmd, unsigned long arg)
	115	{
	116	unsigned int flags;
	117	int status;
	118
	119	switch (cmd) {
	120	case OCFS2_IOC_GETFLAGS:
	121	status = ocfs2_get_inode_attr(inode, &flags);
	122	if (status < 0)
	123	return status;
	124
	125	flags &= OCFS2_FL_VISIBLE;
	126	return put_user(flags, (int __user *) arg);
	127	case OCFS2_IOC_SETFLAGS:
	128	if (get_user(flags, (int __user *) arg))
	129	return -EFAULT;
	130
	131	return ocfs2_set_inode_attr(inode, flags,
	132	OCFS2_FL_MODIFIABLE);
	133	default:
	134	return -ENOTTY;
	135	}
	136	}
	137
586d232b MF	138	#ifdef CONFIG_COMPAT
	139	long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg)
	140	{
	141	struct inode *inode = file->f_path.dentry->d_inode;
	142	int ret;
	143
	144	switch (cmd) {
	145	case OCFS2_IOC32_GETFLAGS:
	146	cmd = OCFS2_IOC_GETFLAGS;
	147	break;
	148	case OCFS2_IOC32_SETFLAGS:
	149	cmd = OCFS2_IOC_SETFLAGS;
	150	break;
	151	default:
	152	return -ENOIOCTLCMD;
	153	}
	154
	155	lock_kernel();
	156	ret = ocfs2_ioctl(inode, file, cmd, arg);
	157	unlock_kernel();
	158	return ret;
	159	}
	160	#endif