[net-next-2.6.git] / fs / reiserfs / ioctl.c

/*
 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
 */

#include <linux/capability.h>
#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/reiserfs_fs.h>
#include <linux/time.h>
#include <asm/uaccess.h>
#include <linux/pagemap.h>
#include <linux/smp_lock.h>
#include <linux/compat.h>

/*
 * reiserfs_ioctl - handler for ioctl for inode
 * supported commands:
 *  1) REISERFS_IOC_UNPACK - try to unpack tail from direct item into indirect
 *                           and prevent packing file (argument arg has to be non-zero)
 *  2) REISERFS_IOC_[GS]ETFLAGS, REISERFS_IOC_[GS]ETVERSION
 *  3) That's all for a while ...
 */
long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct inode *inode = filp->f_path.dentry->d_inode;
	unsigned int flags;
	int err = 0;

	reiserfs_write_lock(inode->i_sb);

	switch (cmd) {
	case REISERFS_IOC_UNPACK:
		if (S_ISREG(inode->i_mode)) {
			if (arg)
				err = reiserfs_unpack(inode, filp);
		} else
			err = -ENOTTY;
		break;
		/*
		 * following two cases are taken from fs/ext2/ioctl.c by Remy
		 * Card (card@masi.ibp.fr)
		 */
	case REISERFS_IOC_GETFLAGS:
		if (!reiserfs_attrs(inode->i_sb)) {
			err = -ENOTTY;
			break;
		}

		flags = REISERFS_I(inode)->i_attrs;
		i_attrs_to_sd_attrs(inode, (__u16 *) & flags);
		err = put_user(flags, (int __user *)arg);
		break;
	case REISERFS_IOC_SETFLAGS:{
			if (!reiserfs_attrs(inode->i_sb)) {
				err = -ENOTTY;
				break;
			}

			err = mnt_want_write(filp->f_path.mnt);
			if (err)
				break;

			if (!is_owner_or_cap(inode)) {
				err = -EPERM;
				goto setflags_out;
			}
			if (get_user(flags, (int __user *)arg)) {
				err = -EFAULT;
				goto setflags_out;
			}
			/*
			 * Is it quota file? Do not allow user to mess with it
			 */
			if (IS_NOQUOTA(inode)) {
				err = -EPERM;
				goto setflags_out;
			}
			if (((flags ^ REISERFS_I(inode)->
			      i_attrs) & (REISERFS_IMMUTABLE_FL |
					  REISERFS_APPEND_FL))
			    && !capable(CAP_LINUX_IMMUTABLE)) {
				err = -EPERM;
				goto setflags_out;
			}
			if ((flags & REISERFS_NOTAIL_FL) &&
			    S_ISREG(inode->i_mode)) {
				int result;

				result = reiserfs_unpack(inode, filp);
				if (result) {
					err = result;
					goto setflags_out;
				}
			}
			sd_attrs_to_i_attrs(flags, inode);
			REISERFS_I(inode)->i_attrs = flags;
			inode->i_ctime = CURRENT_TIME_SEC;
			mark_inode_dirty(inode);
setflags_out:
			mnt_drop_write(filp->f_path.mnt);
			break;
		}
	case REISERFS_IOC_GETVERSION:
		err = put_user(inode->i_generation, (int __user *)arg);
		break;
	case REISERFS_IOC_SETVERSION:
		if (!is_owner_or_cap(inode)) {
			err = -EPERM;
			break;
		}
		err = mnt_want_write(filp->f_path.mnt);
		if (err)
			break;
		if (get_user(inode->i_generation, (int __user *)arg)) {
			err = -EFAULT;
			goto setversion_out;
		}
		inode->i_ctime = CURRENT_TIME_SEC;
		mark_inode_dirty(inode);
setversion_out:
		mnt_drop_write(filp->f_path.mnt);
		break;
	default:
		err = -ENOTTY;
	}

	reiserfs_write_unlock(inode->i_sb);

	return err;
}

#ifdef CONFIG_COMPAT
long reiserfs_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 REISERFS_IOC32_UNPACK:
		cmd = REISERFS_IOC_UNPACK;
		break;
	case REISERFS_IOC32_GETFLAGS:
		cmd = REISERFS_IOC_GETFLAGS;
		break;
	case REISERFS_IOC32_SETFLAGS:
		cmd = REISERFS_IOC_SETFLAGS;
		break;
	case REISERFS_IOC32_GETVERSION:
		cmd = REISERFS_IOC_GETVERSION;
		break;
	case REISERFS_IOC32_SETVERSION:
		cmd = REISERFS_IOC_SETVERSION;
		break;
	default:
		return -ENOIOCTLCMD;
	}

	return reiserfs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
}
#endif

int reiserfs_commit_write(struct file *f, struct page *page,
			  unsigned from, unsigned to);
int reiserfs_prepare_write(struct file *f, struct page *page,
			   unsigned from, unsigned to);
/*
** reiserfs_unpack
** Function try to convert tail from direct item into indirect.
** It set up nopack attribute in the REISERFS_I(inode)->nopack
*/
int reiserfs_unpack(struct inode *inode, struct file *filp)
{
	int retval = 0;
	int index;
	struct page *page;
	struct address_space *mapping;
	unsigned long write_from;
	unsigned long blocksize = inode->i_sb->s_blocksize;

	if (inode->i_size == 0) {
		REISERFS_I(inode)->i_flags |= i_nopack_mask;
		return 0;
	}
	/* ioctl already done */
	if (REISERFS_I(inode)->i_flags & i_nopack_mask) {
		return 0;
	}

	/* we need to make sure nobody is changing the file size beneath
	 ** us
	 */
	reiserfs_mutex_lock_safe(&inode->i_mutex, inode->i_sb);
	reiserfs_write_lock(inode->i_sb);

	write_from = inode->i_size & (blocksize - 1);
	/* if we are on a block boundary, we are already unpacked.  */
	if (write_from == 0) {
		REISERFS_I(inode)->i_flags |= i_nopack_mask;
		goto out;
	}

	/* we unpack by finding the page with the tail, and calling
	 ** reiserfs_prepare_write on that page.  This will force a
	 ** reiserfs_get_block to unpack the tail for us.
	 */
	index = inode->i_size >> PAGE_CACHE_SHIFT;
	mapping = inode->i_mapping;
	page = grab_cache_page(mapping, index);
	retval = -ENOMEM;
	if (!page) {
		goto out;
	}
	retval = reiserfs_prepare_write(NULL, page, write_from, write_from);
	if (retval)
		goto out_unlock;

	/* conversion can change page contents, must flush */
	flush_dcache_page(page);
	retval = reiserfs_commit_write(NULL, page, write_from, write_from);
	REISERFS_I(inode)->i_flags |= i_nopack_mask;

      out_unlock:
	unlock_page(page);
	page_cache_release(page);

      out:
	mutex_unlock(&inode->i_mutex);
	reiserfs_write_unlock(inode->i_sb);
	return retval;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
	3	*/
	4
16f7e0fe	5	#include <linux/capability.h>
1da177e4	6	#include <linux/fs.h>
42a74f20	7	#include <linux/mount.h>
1da177e4 LT	8	#include <linux/reiserfs_fs.h>
	9	#include <linux/time.h>
	10	#include <asm/uaccess.h>
	11	#include <linux/pagemap.h>
	12	#include <linux/smp_lock.h>
52b499c4	13	#include <linux/compat.h>
1da177e4	14
1da177e4	15	/*
ac78a078 FW	16	* reiserfs_ioctl - handler for ioctl for inode
	17	* supported commands:
	18	* 1) REISERFS_IOC_UNPACK - try to unpack tail from direct item into indirect
	19	* and prevent packing file (argument arg has to be non-zero)
	20	* 2) REISERFS_IOC_[GS]ETFLAGS, REISERFS_IOC_[GS]ETVERSION
	21	* 3) That's all for a while ...
	22	*/
205cb37b	23	long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1da177e4	24	{
205cb37b	25	struct inode *inode = filp->f_path.dentry->d_inode;
1da177e4	26	unsigned int flags;
42a74f20	27	int err = 0;
1da177e4	28
ac78a078 FW	29	reiserfs_write_lock(inode->i_sb);
ac78a078 FW	30
1da177e4	31	switch (cmd) {
bd4c625c LT	32	case REISERFS_IOC_UNPACK:
	33	if (S_ISREG(inode->i_mode)) {
	34	if (arg)
ac78a078	35	err = reiserfs_unpack(inode, filp);
1da177e4	36	} else
ac78a078 FW	37	err = -ENOTTY;
	38	break;
	39	/*
	40	* following two cases are taken from fs/ext2/ioctl.c by Remy
	41	* Card (card@masi.ibp.fr)
	42	*/
1da177e4	43	case REISERFS_IOC_GETFLAGS:
ac78a078 FW	44	if (!reiserfs_attrs(inode->i_sb)) {
	45	err = -ENOTTY;
	46	break;
	47	}
869eb76e	48
bd4c625c LT	49	flags = REISERFS_I(inode)->i_attrs;
bd4c625c LT	50	i_attrs_to_sd_attrs(inode, (__u16 *) & flags);
ac78a078 FW	51	err = put_user(flags, (int __user *)arg);
ac78a078 FW	52	break;
bd4c625c	53	case REISERFS_IOC_SETFLAGS:{
ac78a078 FW	54	if (!reiserfs_attrs(inode->i_sb)) {
	55	err = -ENOTTY;
	56	break;
	57	}
869eb76e	58
42a74f20 DH	59	err = mnt_want_write(filp->f_path.mnt);
42a74f20 DH	60	if (err)
ac78a078	61	break;
1da177e4	62
42a74f20 DH	63	if (!is_owner_or_cap(inode)) {
	64	err = -EPERM;
	65	goto setflags_out;
	66	}
	67	if (get_user(flags, (int __user *)arg)) {
	68	err = -EFAULT;
	69	goto setflags_out;
	70	}
	71	/*
	72	* Is it quota file? Do not allow user to mess with it
	73	*/
	74	if (IS_NOQUOTA(inode)) {
	75	err = -EPERM;
	76	goto setflags_out;
	77	}
bd4c625c LT	78	if (((flags ^ REISERFS_I(inode)->
	79	i_attrs) & (REISERFS_IMMUTABLE_FL \|
	80	REISERFS_APPEND_FL))
42a74f20 DH	81	&& !capable(CAP_LINUX_IMMUTABLE)) {
	82	err = -EPERM;
	83	goto setflags_out;
	84	}
bd4c625c LT	85	if ((flags & REISERFS_NOTAIL_FL) &&
bd4c625c LT	86	S_ISREG(inode->i_mode)) {
1da177e4 LT	87	int result;
1da177e4 LT	88
bd4c625c	89	result = reiserfs_unpack(inode, filp);
42a74f20 DH	90	if (result) {
	91	err = result;
	92	goto setflags_out;
	93	}
bd4c625c LT	94	}
	95	sd_attrs_to_i_attrs(flags, inode);
	96	REISERFS_I(inode)->i_attrs = flags;
	97	inode->i_ctime = CURRENT_TIME_SEC;
	98	mark_inode_dirty(inode);
42a74f20 DH	99	setflags_out:
42a74f20 DH	100	mnt_drop_write(filp->f_path.mnt);
ac78a078	101	break;
1da177e4	102	}
1da177e4	103	case REISERFS_IOC_GETVERSION:
ac78a078 FW	104	err = put_user(inode->i_generation, (int __user *)arg);
ac78a078 FW	105	break;
1da177e4	106	case REISERFS_IOC_SETVERSION:
e0baec1b	107	if (!is_owner_or_cap(inode)) {
ac78a078 FW	108	err = -EPERM;
ac78a078 FW	109	break;
e0baec1b	110	}
42a74f20 DH	111	err = mnt_want_write(filp->f_path.mnt);
42a74f20 DH	112	if (err)
ac78a078	113	break;
42a74f20 DH	114	if (get_user(inode->i_generation, (int __user *)arg)) {
	115	err = -EFAULT;
	116	goto setversion_out;
	117	}
1da177e4 LT	118	inode->i_ctime = CURRENT_TIME_SEC;
1da177e4 LT	119	mark_inode_dirty(inode);
42a74f20 DH	120	setversion_out:
42a74f20 DH	121	mnt_drop_write(filp->f_path.mnt);
ac78a078	122	break;
1da177e4	123	default:
ac78a078	124	err = -ENOTTY;
1da177e4	125	}
ac78a078 FW	126
	127	reiserfs_write_unlock(inode->i_sb);
	128
	129	return err;
1da177e4 LT	130	}
1da177e4 LT	131
52b499c4 DH	132	#ifdef CONFIG_COMPAT
	133	long reiserfs_compat_ioctl(struct file *file, unsigned int cmd,
	134	unsigned long arg)
	135	{
52b499c4 DH	136	/* These are just misnamed, they actually get/put from/to user an int */
	137	switch (cmd) {
	138	case REISERFS_IOC32_UNPACK:
	139	cmd = REISERFS_IOC_UNPACK;
	140	break;
	141	case REISERFS_IOC32_GETFLAGS:
	142	cmd = REISERFS_IOC_GETFLAGS;
	143	break;
	144	case REISERFS_IOC32_SETFLAGS:
	145	cmd = REISERFS_IOC_SETFLAGS;
	146	break;
	147	case REISERFS_IOC32_GETVERSION:
	148	cmd = REISERFS_IOC_GETVERSION;
	149	break;
	150	case REISERFS_IOC32_SETVERSION:
	151	cmd = REISERFS_IOC_SETVERSION;
	152	break;
	153	default:
	154	return -ENOIOCTLCMD;
	155	}
8ebc4232	156
205cb37b	157	return reiserfs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
52b499c4 DH	158	}
	159	#endif
	160
ba9d8cec VS	161	int reiserfs_commit_write(struct file f, struct page page,
	162	unsigned from, unsigned to);
	163	int reiserfs_prepare_write(struct file f, struct page page,
	164	unsigned from, unsigned to);
1da177e4 LT	165	/*
	166	** reiserfs_unpack
	167	** Function try to convert tail from direct item into indirect.
	168	** It set up nopack attribute in the REISERFS_I(inode)->nopack
	169	*/
d5dee5c3	170	int reiserfs_unpack(struct inode inode, struct file filp)
1da177e4	171	{
bd4c625c LT	172	int retval = 0;
	173	int index;
	174	struct page *page;
	175	struct address_space *mapping;
	176	unsigned long write_from;
	177	unsigned long blocksize = inode->i_sb->s_blocksize;
	178
	179	if (inode->i_size == 0) {
	180	REISERFS_I(inode)->i_flags \|= i_nopack_mask;
	181	return 0;
	182	}
	183	/* ioctl already done */
	184	if (REISERFS_I(inode)->i_flags & i_nopack_mask) {
	185	return 0;
	186	}
bd4c625c LT	187
	188	/* we need to make sure nobody is changing the file size beneath
	189	** us
	190	*/
3f259d09	191	reiserfs_mutex_lock_safe(&inode->i_mutex, inode->i_sb);
b5f3953c	192	reiserfs_write_lock(inode->i_sb);
bd4c625c LT	193
	194	write_from = inode->i_size & (blocksize - 1);
	195	/* if we are on a block boundary, we are already unpacked. */
	196	if (write_from == 0) {
	197	REISERFS_I(inode)->i_flags \|= i_nopack_mask;
	198	goto out;
	199	}
	200
	201	/* we unpack by finding the page with the tail, and calling
0222e657	202	** reiserfs_prepare_write on that page. This will force a
bd4c625c LT	203	** reiserfs_get_block to unpack the tail for us.
	204	*/
	205	index = inode->i_size >> PAGE_CACHE_SHIFT;
	206	mapping = inode->i_mapping;
	207	page = grab_cache_page(mapping, index);
	208	retval = -ENOMEM;
	209	if (!page) {
	210	goto out;
	211	}
ba9d8cec	212	retval = reiserfs_prepare_write(NULL, page, write_from, write_from);
bd4c625c LT	213	if (retval)
	214	goto out_unlock;
	215
	216	/* conversion can change page contents, must flush */
	217	flush_dcache_page(page);
ba9d8cec	218	retval = reiserfs_commit_write(NULL, page, write_from, write_from);
1da177e4	219	REISERFS_I(inode)->i_flags \|= i_nopack_mask;
bd4c625c LT	220
	221	out_unlock:
	222	unlock_page(page);
	223	page_cache_release(page);
	224
	225	out:
1b1dcc1b	226	mutex_unlock(&inode->i_mutex);
bd4c625c LT	227	reiserfs_write_unlock(inode->i_sb);
bd4c625c LT	228	return retval;
1da177e4	229	}