[mirror_ubuntu-eoan-kernel.git] / fs / ubifs / ioctl.c

/*
 * This file is part of UBIFS.
 *
 * Copyright (C) 2006-2008 Nokia Corporation.
 * Copyright (C) 2006, 2007 University of Szeged, Hungary
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * Authors: Zoltan Sogor
 *          Artem Bityutskiy (Битюцкий Артём)
 *          Adrian Hunter
 */

/* This file implements EXT2-compatible extended attribute ioctl() calls */

#include <linux/compat.h>
#include <linux/mount.h>
#include "ubifs.h"

/* Need to be kept consistent with checked flags in ioctl2ubifs() */
#define UBIFS_SUPPORTED_IOCTL_FLAGS \
	(FS_COMPR_FL | FS_SYNC_FL | FS_APPEND_FL | \
	 FS_IMMUTABLE_FL | FS_DIRSYNC_FL)

/**
 * ubifs_set_inode_flags - set VFS inode flags.
 * @inode: VFS inode to set flags for
 *
 * This function propagates flags from UBIFS inode object to VFS inode object.
 */
void ubifs_set_inode_flags(struct inode *inode)
{
	unsigned int flags = ubifs_inode(inode)->flags;

	inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_DIRSYNC |
			    S_ENCRYPTED);
	if (flags & UBIFS_SYNC_FL)
		inode->i_flags |= S_SYNC;
	if (flags & UBIFS_APPEND_FL)
		inode->i_flags |= S_APPEND;
	if (flags & UBIFS_IMMUTABLE_FL)
		inode->i_flags |= S_IMMUTABLE;
	if (flags & UBIFS_DIRSYNC_FL)
		inode->i_flags |= S_DIRSYNC;
	if (flags & UBIFS_CRYPT_FL)
		inode->i_flags |= S_ENCRYPTED;
}

/*
 * ioctl2ubifs - convert ioctl inode flags to UBIFS inode flags.
 * @ioctl_flags: flags to convert
 *
 * This function converts ioctl flags (@FS_COMPR_FL, etc) to UBIFS inode flags
 * (@UBIFS_COMPR_FL, etc).
 */
static int ioctl2ubifs(int ioctl_flags)
{
	int ubifs_flags = 0;

	if (ioctl_flags & FS_COMPR_FL)
		ubifs_flags |= UBIFS_COMPR_FL;
	if (ioctl_flags & FS_SYNC_FL)
		ubifs_flags |= UBIFS_SYNC_FL;
	if (ioctl_flags & FS_APPEND_FL)
		ubifs_flags |= UBIFS_APPEND_FL;
	if (ioctl_flags & FS_IMMUTABLE_FL)
		ubifs_flags |= UBIFS_IMMUTABLE_FL;
	if (ioctl_flags & FS_DIRSYNC_FL)
		ubifs_flags |= UBIFS_DIRSYNC_FL;

	return ubifs_flags;
}

/*
 * ubifs2ioctl - convert UBIFS inode flags to ioctl inode flags.
 * @ubifs_flags: flags to convert
 *
 * This function converts UBIFS inode flags (@UBIFS_COMPR_FL, etc) to ioctl
 * flags (@FS_COMPR_FL, etc).
 */
static int ubifs2ioctl(int ubifs_flags)
{
	int ioctl_flags = 0;

	if (ubifs_flags & UBIFS_COMPR_FL)
		ioctl_flags |= FS_COMPR_FL;
	if (ubifs_flags & UBIFS_SYNC_FL)
		ioctl_flags |= FS_SYNC_FL;
	if (ubifs_flags & UBIFS_APPEND_FL)
		ioctl_flags |= FS_APPEND_FL;
	if (ubifs_flags & UBIFS_IMMUTABLE_FL)
		ioctl_flags |= FS_IMMUTABLE_FL;
	if (ubifs_flags & UBIFS_DIRSYNC_FL)
		ioctl_flags |= FS_DIRSYNC_FL;

	return ioctl_flags;
}

static int setflags(struct inode *inode, int flags)
{
	int oldflags, err, release;
	struct ubifs_inode *ui = ubifs_inode(inode);
	struct ubifs_info *c = inode->i_sb->s_fs_info;
	struct ubifs_budget_req req = { .dirtied_ino = 1,
					.dirtied_ino_d = ui->data_len };

	err = ubifs_budget_space(c, &req);
	if (err)
		return err;

	/*
	 * The IMMUTABLE and APPEND_ONLY flags can only be changed by
	 * the relevant capability.
	 */
	mutex_lock(&ui->ui_mutex);
	oldflags = ubifs2ioctl(ui->flags);
	if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
		if (!capable(CAP_LINUX_IMMUTABLE)) {
			err = -EPERM;
			goto out_unlock;
		}
	}

	ui->flags = ioctl2ubifs(flags);
	ubifs_set_inode_flags(inode);
	inode->i_ctime = current_time(inode);
	release = ui->dirty;
	mark_inode_dirty_sync(inode);
	mutex_unlock(&ui->ui_mutex);

	if (release)
		ubifs_release_budget(c, &req);
	if (IS_SYNC(inode))
		err = write_inode_now(inode, 1);
	return err;

out_unlock:
	ubifs_err(c, "can't modify inode %lu attributes", inode->i_ino);
	mutex_unlock(&ui->ui_mutex);
	ubifs_release_budget(c, &req);
	return err;
}

long ubifs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	int flags, err;
	struct inode *inode = file_inode(file);

	switch (cmd) {
	case FS_IOC_GETFLAGS:
		flags = ubifs2ioctl(ubifs_inode(inode)->flags);

		dbg_gen("get flags: %#x, i_flags %#x", flags, inode->i_flags);
		return put_user(flags, (int __user *) arg);

	case FS_IOC_SETFLAGS: {
		if (IS_RDONLY(inode))
			return -EROFS;

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

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

		if (flags & ~UBIFS_SUPPORTED_IOCTL_FLAGS)
			return -EOPNOTSUPP;

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

		/*
		 * Make sure the file-system is read-write and make sure it
		 * will not become read-only while we are changing the flags.
		 */
		err = mnt_want_write_file(file);
		if (err)
			return err;
		dbg_gen("set flags: %#x, i_flags %#x", flags, inode->i_flags);
		err = setflags(inode, flags);
		mnt_drop_write_file(file);
		return err;
	}
	case FS_IOC_SET_ENCRYPTION_POLICY: {
#ifdef CONFIG_FS_ENCRYPTION
		struct ubifs_info *c = inode->i_sb->s_fs_info;

		err = ubifs_enable_encryption(c);
		if (err)
			return err;

		return fscrypt_ioctl_set_policy(file, (const void __user *)arg);
#else
		return -EOPNOTSUPP;
#endif
	}
	case FS_IOC_GET_ENCRYPTION_POLICY: {
#ifdef CONFIG_FS_ENCRYPTION
		return fscrypt_ioctl_get_policy(file, (void __user *)arg);
#else
		return -EOPNOTSUPP;
#endif
	}

	default:
		return -ENOTTY;
	}
}

#ifdef CONFIG_COMPAT
long ubifs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	switch (cmd) {
	case FS_IOC32_GETFLAGS:
		cmd = FS_IOC_GETFLAGS;
		break;
	case FS_IOC32_SETFLAGS:
		cmd = FS_IOC_SETFLAGS;
		break;
	case FS_IOC_SET_ENCRYPTION_POLICY:
	case FS_IOC_GET_ENCRYPTION_POLICY:
		break;
	default:
		return -ENOIOCTLCMD;
	}
	return ubifs_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
}
#endif
Commit	Line	Data
1e51764a AB	1	/*
	2	* This file is part of UBIFS.
	3	*
	4	* Copyright (C) 2006-2008 Nokia Corporation.
	5	* Copyright (C) 2006, 2007 University of Szeged, Hungary
	6	*
	7	* This program is free software; you can redistribute it and/or modify it
	8	* under the terms of the GNU General Public License version 2 as published by
	9	* the Free Software Foundation.
	10	*
	11	* This program is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	14	* more details.
	15	*
	16	* You should have received a copy of the GNU General Public License along with
	17	* this program; if not, write to the Free Software Foundation, Inc., 51
	18	* Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	19	*
	20	* Authors: Zoltan Sogor
	21	* Artem Bityutskiy (Битюцкий Артём)
	22	* Adrian Hunter
	23	*/
	24
	25	/* This file implements EXT2-compatible extended attribute ioctl() calls */
	26
	27	#include <linux/compat.h>
1e51764a AB	28	#include <linux/mount.h>
	29	#include "ubifs.h"
	30
2fe8b2d5 HT	31	/* Need to be kept consistent with checked flags in ioctl2ubifs() */
	32	#define UBIFS_SUPPORTED_IOCTL_FLAGS \
	33	(FS_COMPR_FL \| FS_SYNC_FL \| FS_APPEND_FL \| \
	34	FS_IMMUTABLE_FL \| FS_DIRSYNC_FL)
	35
1e51764a AB	36	/**
	37	* ubifs_set_inode_flags - set VFS inode flags.
	38	* @inode: VFS inode to set flags for
	39	*
	40	* This function propagates flags from UBIFS inode object to VFS inode object.
	41	*/
	42	void ubifs_set_inode_flags(struct inode *inode)
	43	{
	44	unsigned int flags = ubifs_inode(inode)->flags;
	45
2ee6a576 EB	46	inode->i_flags &= ~(S_SYNC \| S_APPEND \| S_IMMUTABLE \| S_DIRSYNC \|
2ee6a576 EB	47	S_ENCRYPTED);
1e51764a AB	48	if (flags & UBIFS_SYNC_FL)
	49	inode->i_flags \|= S_SYNC;
	50	if (flags & UBIFS_APPEND_FL)
	51	inode->i_flags \|= S_APPEND;
	52	if (flags & UBIFS_IMMUTABLE_FL)
	53	inode->i_flags \|= S_IMMUTABLE;
	54	if (flags & UBIFS_DIRSYNC_FL)
	55	inode->i_flags \|= S_DIRSYNC;
2ee6a576 EB	56	if (flags & UBIFS_CRYPT_FL)
2ee6a576 EB	57	inode->i_flags \|= S_ENCRYPTED;
1e51764a AB	58	}
	59
	60	/*
	61	* ioctl2ubifs - convert ioctl inode flags to UBIFS inode flags.
	62	* @ioctl_flags: flags to convert
	63	*
798868c0	64	* This function converts ioctl flags (@FS_COMPR_FL, etc) to UBIFS inode flags
1e51764a AB	65	* (@UBIFS_COMPR_FL, etc).
	66	*/
	67	static int ioctl2ubifs(int ioctl_flags)
	68	{
	69	int ubifs_flags = 0;
	70
	71	if (ioctl_flags & FS_COMPR_FL)
	72	ubifs_flags \|= UBIFS_COMPR_FL;
	73	if (ioctl_flags & FS_SYNC_FL)
	74	ubifs_flags \|= UBIFS_SYNC_FL;
	75	if (ioctl_flags & FS_APPEND_FL)
	76	ubifs_flags \|= UBIFS_APPEND_FL;
	77	if (ioctl_flags & FS_IMMUTABLE_FL)
	78	ubifs_flags \|= UBIFS_IMMUTABLE_FL;
	79	if (ioctl_flags & FS_DIRSYNC_FL)
	80	ubifs_flags \|= UBIFS_DIRSYNC_FL;
	81
	82	return ubifs_flags;
	83	}
	84
	85	/*
	86	* ubifs2ioctl - convert UBIFS inode flags to ioctl inode flags.
	87	* @ubifs_flags: flags to convert
	88	*
798868c0 RL	89	* This function converts UBIFS inode flags (@UBIFS_COMPR_FL, etc) to ioctl
798868c0 RL	90	* flags (@FS_COMPR_FL, etc).
1e51764a AB	91	*/
	92	static int ubifs2ioctl(int ubifs_flags)
	93	{
	94	int ioctl_flags = 0;
	95
	96	if (ubifs_flags & UBIFS_COMPR_FL)
	97	ioctl_flags \|= FS_COMPR_FL;
	98	if (ubifs_flags & UBIFS_SYNC_FL)
	99	ioctl_flags \|= FS_SYNC_FL;
	100	if (ubifs_flags & UBIFS_APPEND_FL)
	101	ioctl_flags \|= FS_APPEND_FL;
	102	if (ubifs_flags & UBIFS_IMMUTABLE_FL)
	103	ioctl_flags \|= FS_IMMUTABLE_FL;
	104	if (ubifs_flags & UBIFS_DIRSYNC_FL)
	105	ioctl_flags \|= FS_DIRSYNC_FL;
	106
	107	return ioctl_flags;
	108	}
	109
	110	static int setflags(struct inode *inode, int flags)
	111	{
	112	int oldflags, err, release;
	113	struct ubifs_inode *ui = ubifs_inode(inode);
	114	struct ubifs_info *c = inode->i_sb->s_fs_info;
	115	struct ubifs_budget_req req = { .dirtied_ino = 1,
	116	.dirtied_ino_d = ui->data_len };
	117
	118	err = ubifs_budget_space(c, &req);
	119	if (err)
	120	return err;
	121
	122	/*
	123	* The IMMUTABLE and APPEND_ONLY flags can only be changed by
	124	* the relevant capability.
	125	*/
	126	mutex_lock(&ui->ui_mutex);
	127	oldflags = ubifs2ioctl(ui->flags);
	128	if ((flags ^ oldflags) & (FS_APPEND_FL \| FS_IMMUTABLE_FL)) {
	129	if (!capable(CAP_LINUX_IMMUTABLE)) {
	130	err = -EPERM;
	131	goto out_unlock;
	132	}
	133	}
	134
	135	ui->flags = ioctl2ubifs(flags);
	136	ubifs_set_inode_flags(inode);
607a11ad	137	inode->i_ctime = current_time(inode);
1e51764a AB	138	release = ui->dirty;
	139	mark_inode_dirty_sync(inode);
	140	mutex_unlock(&ui->ui_mutex);
	141
	142	if (release)
	143	ubifs_release_budget(c, &req);
	144	if (IS_SYNC(inode))
	145	err = write_inode_now(inode, 1);
	146	return err;
	147
	148	out_unlock:
235c362b	149	ubifs_err(c, "can't modify inode %lu attributes", inode->i_ino);
1e51764a AB	150	mutex_unlock(&ui->ui_mutex);
	151	ubifs_release_budget(c, &req);
	152	return err;
	153	}
	154
	155	long ubifs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	156	{
	157	int flags, err;
496ad9aa	158	struct inode *inode = file_inode(file);
1e51764a AB	159
	160	switch (cmd) {
	161	case FS_IOC_GETFLAGS:
	162	flags = ubifs2ioctl(ubifs_inode(inode)->flags);
	163
a9f2fc0e	164	dbg_gen("get flags: %#x, i_flags %#x", flags, inode->i_flags);
1e51764a AB	165	return put_user(flags, (int __user *) arg);
	166
	167	case FS_IOC_SETFLAGS: {
	168	if (IS_RDONLY(inode))
	169	return -EROFS;
	170
2e149670	171	if (!inode_owner_or_capable(inode))
1e51764a AB	172	return -EACCES;
	173
	174	if (get_user(flags, (int __user *) arg))
	175	return -EFAULT;
	176
2fe8b2d5 HT	177	if (flags & ~UBIFS_SUPPORTED_IOCTL_FLAGS)
	178	return -EOPNOTSUPP;
	179
1e51764a AB	180	if (!S_ISDIR(inode->i_mode))
	181	flags &= ~FS_DIRSYNC_FL;
	182
	183	/*
	184	* Make sure the file-system is read-write and make sure it
	185	* will not become read-only while we are changing the flags.
	186	*/
a561be71	187	err = mnt_want_write_file(file);
1e51764a AB	188	if (err)
1e51764a AB	189	return err;
a9f2fc0e	190	dbg_gen("set flags: %#x, i_flags %#x", flags, inode->i_flags);
1e51764a	191	err = setflags(inode, flags);
2a79f17e	192	mnt_drop_write_file(file);
1e51764a AB	193	return err;
1e51764a AB	194	}
d475a507	195	case FS_IOC_SET_ENCRYPTION_POLICY: {
643fa961	196	#ifdef CONFIG_FS_ENCRYPTION
e021986e	197	struct ubifs_info *c = inode->i_sb->s_fs_info;
d475a507	198
e021986e RW	199	err = ubifs_enable_encryption(c);
	200	if (err)
	201	return err;
	202
ec9160da	203	return fscrypt_ioctl_set_policy(file, (const void __user *)arg);
d475a507 RW	204	#else
	205	return -EOPNOTSUPP;
	206	#endif
	207	}
	208	case FS_IOC_GET_ENCRYPTION_POLICY: {
643fa961	209	#ifdef CONFIG_FS_ENCRYPTION
ec9160da	210	return fscrypt_ioctl_get_policy(file, (void __user *)arg);
d475a507 RW	211	#else
	212	return -EOPNOTSUPP;
	213	#endif
	214	}
1e51764a AB	215
	216	default:
	217	return -ENOTTY;
	218	}
	219	}
	220
	221	#ifdef CONFIG_COMPAT
	222	long ubifs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	223	{
	224	switch (cmd) {
	225	case FS_IOC32_GETFLAGS:
	226	cmd = FS_IOC_GETFLAGS;
	227	break;
	228	case FS_IOC32_SETFLAGS:
	229	cmd = FS_IOC_SETFLAGS;
	230	break;
a75467d9 EB	231	case FS_IOC_SET_ENCRYPTION_POLICY:
	232	case FS_IOC_GET_ENCRYPTION_POLICY:
	233	break;
1e51764a AB	234	default:
	235	return -ENOIOCTLCMD;
	236	}
	237	return ubifs_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
	238	}
	239	#endif