[mirror_ubuntu-bionic-kernel.git] / fs / hfsplus / ioctl.c

/*
 *  linux/fs/hfsplus/ioctl.c
 *
 * Copyright (C) 2003
 * Ethan Benson <erbenson@alaska.net>
 * partially derived from linux/fs/ext2/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)
 *
 * hfsplus ioctls
 */

#include <linux/capability.h>
#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/sched.h>
#include <linux/xattr.h>
#include <asm/uaccess.h>
#include "hfsplus_fs.h"

/*
 * "Blessing" an HFS+ filesystem writes metadata to the superblock informing
 * the platform firmware which file to boot from
 */
static int hfsplus_ioctl_bless(struct file *file, int __user *user_flags)
{
	struct dentry *dentry = file->f_path.dentry;
	struct inode *inode = dentry->d_inode;
	struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);
	struct hfsplus_vh *vh = sbi->s_vhdr;
	struct hfsplus_vh *bvh = sbi->s_backup_vhdr;

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

	mutex_lock(&sbi->vh_mutex);

	/* Directory containing the bootable system */
	vh->finder_info[0] = bvh->finder_info[0] =
		cpu_to_be32(parent_ino(dentry));

	/* Bootloader */
	vh->finder_info[1] = bvh->finder_info[1] = cpu_to_be32(inode->i_ino);

	/* Per spec, the OS X system folder - same as finder_info[0] here */
	vh->finder_info[5] = bvh->finder_info[5] =
		cpu_to_be32(parent_ino(dentry));

	mutex_unlock(&sbi->vh_mutex);
	return 0;
}

static int hfsplus_ioctl_getflags(struct file *file, int __user *user_flags)
{
	struct inode *inode = file->f_path.dentry->d_inode;
	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
	unsigned int flags = 0;

	if (inode->i_flags & S_IMMUTABLE)
		flags |= FS_IMMUTABLE_FL;
	if (inode->i_flags & S_APPEND)
		flags |= FS_APPEND_FL;
	if (hip->userflags & HFSPLUS_FLG_NODUMP)
		flags |= FS_NODUMP_FL;

	return put_user(flags, user_flags);
}

static int hfsplus_ioctl_setflags(struct file *file, int __user *user_flags)
{
	struct inode *inode = file->f_path.dentry->d_inode;
	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
	unsigned int flags;
	int err = 0;

	err = mnt_want_write_file(file);
	if (err)
		goto out;

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

	if (get_user(flags, user_flags)) {
		err = -EFAULT;
		goto out_drop_write;
	}

	mutex_lock(&inode->i_mutex);

	if ((flags & (FS_IMMUTABLE_FL|FS_APPEND_FL)) ||
	    inode->i_flags & (S_IMMUTABLE|S_APPEND)) {
		if (!capable(CAP_LINUX_IMMUTABLE)) {
			err = -EPERM;
			goto out_unlock_inode;
		}
	}

	/* don't silently ignore unsupported ext2 flags */
	if (flags & ~(FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NODUMP_FL)) {
		err = -EOPNOTSUPP;
		goto out_unlock_inode;
	}

	if (flags & FS_IMMUTABLE_FL)
		inode->i_flags |= S_IMMUTABLE;
	else
		inode->i_flags &= ~S_IMMUTABLE;

	if (flags & FS_APPEND_FL)
		inode->i_flags |= S_APPEND;
	else
		inode->i_flags &= ~S_APPEND;

	if (flags & FS_NODUMP_FL)
		hip->userflags |= HFSPLUS_FLG_NODUMP;
	else
		hip->userflags &= ~HFSPLUS_FLG_NODUMP;

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

out_unlock_inode:
	mutex_unlock(&inode->i_mutex);
out_drop_write:
	mnt_drop_write_file(file);
out:
	return err;
}

long hfsplus_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	void __user *argp = (void __user *)arg;

	switch (cmd) {
	case HFSPLUS_IOC_EXT2_GETFLAGS:
		return hfsplus_ioctl_getflags(file, argp);
	case HFSPLUS_IOC_EXT2_SETFLAGS:
		return hfsplus_ioctl_setflags(file, argp);
	case HFSPLUS_IOC_BLESS:
		return hfsplus_ioctl_bless(file, argp);
	default:
		return -ENOTTY;
	}
}

int hfsplus_setxattr(struct dentry *dentry, const char *name,
		     const void *value, size_t size, int flags)
{
	struct inode *inode = dentry->d_inode;
	struct hfs_find_data fd;
	hfsplus_cat_entry entry;
	struct hfsplus_cat_file *file;
	int res;

	if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode))
		return -EOPNOTSUPP;

	res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
	if (res)
		return res;
	res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
	if (res)
		goto out;
	hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
			sizeof(struct hfsplus_cat_file));
	file = &entry.file;

	if (!strcmp(name, "hfs.type")) {
		if (size == 4)
			memcpy(&file->user_info.fdType, value, 4);
		else
			res = -ERANGE;
	} else if (!strcmp(name, "hfs.creator")) {
		if (size == 4)
			memcpy(&file->user_info.fdCreator, value, 4);
		else
			res = -ERANGE;
	} else
		res = -EOPNOTSUPP;
	if (!res) {
		hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
				sizeof(struct hfsplus_cat_file));
		hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
	}
out:
	hfs_find_exit(&fd);
	return res;
}

ssize_t hfsplus_getxattr(struct dentry *dentry, const char *name,
			 void *value, size_t size)
{
	struct inode *inode = dentry->d_inode;
	struct hfs_find_data fd;
	hfsplus_cat_entry entry;
	struct hfsplus_cat_file *file;
	ssize_t res = 0;

	if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode))
		return -EOPNOTSUPP;

	if (size) {
		res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
		if (res)
			return res;
		res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
		if (res)
			goto out;
		hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
				sizeof(struct hfsplus_cat_file));
	}
	file = &entry.file;

	if (!strcmp(name, "hfs.type")) {
		if (size >= 4) {
			memcpy(value, &file->user_info.fdType, 4);
			res = 4;
		} else
			res = size ? -ERANGE : 4;
	} else if (!strcmp(name, "hfs.creator")) {
		if (size >= 4) {
			memcpy(value, &file->user_info.fdCreator, 4);
			res = 4;
		} else
			res = size ? -ERANGE : 4;
	} else
		res = -EOPNOTSUPP;
out:
	if (size)
		hfs_find_exit(&fd);
	return res;
}

#define HFSPLUS_ATTRLIST_SIZE (sizeof("hfs.creator")+sizeof("hfs.type"))

ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
{
	struct inode *inode = dentry->d_inode;

	if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode))
		return -EOPNOTSUPP;

	if (!buffer || !size)
		return HFSPLUS_ATTRLIST_SIZE;
	if (size < HFSPLUS_ATTRLIST_SIZE)
		return -ERANGE;
	strcpy(buffer, "hfs.type");
	strcpy(buffer + sizeof("hfs.type"), "hfs.creator");

	return HFSPLUS_ATTRLIST_SIZE;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/hfsplus/ioctl.c
	3	*
	4	* Copyright (C) 2003
	5	* Ethan Benson <erbenson@alaska.net>
	6	* partially derived from linux/fs/ext2/ioctl.c
	7	* Copyright (C) 1993, 1994, 1995
	8	* Remy Card (card@masi.ibp.fr)
	9	* Laboratoire MASI - Institut Blaise Pascal
	10	* Universite Pierre et Marie Curie (Paris VI)
	11	*
	12	* hfsplus ioctls
	13	*/
	14
16f7e0fe	15	#include <linux/capability.h>
1da177e4	16	#include <linux/fs.h>
42a74f20	17	#include <linux/mount.h>
1da177e4 LT	18	#include <linux/sched.h>
	19	#include <linux/xattr.h>
	20	#include <asm/uaccess.h>
	21	#include "hfsplus_fs.h"
	22
a051f71c MG	23	/*
	24	* "Blessing" an HFS+ filesystem writes metadata to the superblock informing
	25	* the platform firmware which file to boot from
	26	*/
	27	static int hfsplus_ioctl_bless(struct file file, int __user user_flags)
	28	{
	29	struct dentry *dentry = file->f_path.dentry;
	30	struct inode *inode = dentry->d_inode;
	31	struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);
	32	struct hfsplus_vh *vh = sbi->s_vhdr;
	33	struct hfsplus_vh *bvh = sbi->s_backup_vhdr;
	34
	35	if (!capable(CAP_SYS_ADMIN))
	36	return -EPERM;
	37
	38	mutex_lock(&sbi->vh_mutex);
	39
	40	/* Directory containing the bootable system */
	41	vh->finder_info[0] = bvh->finder_info[0] =
	42	cpu_to_be32(parent_ino(dentry));
	43
	44	/* Bootloader */
	45	vh->finder_info[1] = bvh->finder_info[1] = cpu_to_be32(inode->i_ino);
	46
	47	/* Per spec, the OS X system folder - same as finder_info[0] here */
	48	vh->finder_info[5] = bvh->finder_info[5] =
	49	cpu_to_be32(parent_ino(dentry));
	50
	51	mutex_unlock(&sbi->vh_mutex);
	52	return 0;
	53	}
	54
94744567	55	static int hfsplus_ioctl_getflags(struct file file, int __user user_flags)
1da177e4	56	{
94744567	57	struct inode *inode = file->f_path.dentry->d_inode;
6af502de	58	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
94744567 CH	59	unsigned int flags = 0;
94744567 CH	60
722c55d1	61	if (inode->i_flags & S_IMMUTABLE)
94744567	62	flags \|= FS_IMMUTABLE_FL;
596276c3	63	if (inode->i_flags & S_APPEND)
94744567	64	flags \|= FS_APPEND_FL;
6af502de	65	if (hip->userflags & HFSPLUS_FLG_NODUMP)
94744567 CH	66	flags \|= FS_NODUMP_FL;
	67
	68	return put_user(flags, user_flags);
	69	}
	70
	71	static int hfsplus_ioctl_setflags(struct file file, int __user user_flags)
	72	{
	73	struct inode *inode = file->f_path.dentry->d_inode;
6af502de	74	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
1da177e4	75	unsigned int flags;
94744567	76	int err = 0;
1da177e4	77
a561be71	78	err = mnt_want_write_file(file);
94744567	79	if (err)
6333816a	80	goto out;
1da177e4	81
2e149670	82	if (!inode_owner_or_capable(inode)) {
94744567 CH	83	err = -EACCES;
	84	goto out_drop_write;
	85	}
1da177e4	86
94744567 CH	87	if (get_user(flags, user_flags)) {
	88	err = -EFAULT;
	89	goto out_drop_write;
	90	}
	91
6333816a CH	92	mutex_lock(&inode->i_mutex);
6333816a CH	93
722c55d1 CH	94	if ((flags & (FS_IMMUTABLE_FL\|FS_APPEND_FL)) \|\|
722c55d1 CH	95	inode->i_flags & (S_IMMUTABLE\|S_APPEND)) {
94744567 CH	96	if (!capable(CAP_LINUX_IMMUTABLE)) {
94744567 CH	97	err = -EPERM;
6333816a	98	goto out_unlock_inode;
1da177e4	99	}
1da177e4	100	}
94744567 CH	101
	102	/* don't silently ignore unsupported ext2 flags */
	103	if (flags & ~(FS_IMMUTABLE_FL\|FS_APPEND_FL\|FS_NODUMP_FL)) {
	104	err = -EOPNOTSUPP;
6333816a	105	goto out_unlock_inode;
94744567	106	}
722c55d1 CH	107
722c55d1 CH	108	if (flags & FS_IMMUTABLE_FL)
94744567	109	inode->i_flags \|= S_IMMUTABLE;
722c55d1	110	else
94744567	111	inode->i_flags &= ~S_IMMUTABLE;
722c55d1 CH	112
722c55d1 CH	113	if (flags & FS_APPEND_FL)
94744567	114	inode->i_flags \|= S_APPEND;
722c55d1	115	else
94744567	116	inode->i_flags &= ~S_APPEND;
722c55d1	117
94744567	118	if (flags & FS_NODUMP_FL)
6af502de	119	hip->userflags \|= HFSPLUS_FLG_NODUMP;
94744567	120	else
6af502de	121	hip->userflags &= ~HFSPLUS_FLG_NODUMP;
94744567 CH	122
	123	inode->i_ctime = CURRENT_TIME_SEC;
	124	mark_inode_dirty(inode);
	125
6333816a	126	out_unlock_inode:
e50fb58b	127	mutex_unlock(&inode->i_mutex);
94744567	128	out_drop_write:
2a79f17e	129	mnt_drop_write_file(file);
6333816a	130	out:
94744567 CH	131	return err;
	132	}
	133
	134	long hfsplus_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	135	{
	136	void __user argp = (void __user )arg;
	137
	138	switch (cmd) {
	139	case HFSPLUS_IOC_EXT2_GETFLAGS:
	140	return hfsplus_ioctl_getflags(file, argp);
	141	case HFSPLUS_IOC_EXT2_SETFLAGS:
	142	return hfsplus_ioctl_setflags(file, argp);
a051f71c MG	143	case HFSPLUS_IOC_BLESS:
a051f71c MG	144	return hfsplus_ioctl_bless(file, argp);
1da177e4 LT	145	default:
	146	return -ENOTTY;
	147	}
	148	}
	149
	150	int hfsplus_setxattr(struct dentry dentry, const char name,
	151	const void *value, size_t size, int flags)
	152	{
	153	struct inode *inode = dentry->d_inode;
	154	struct hfs_find_data fd;
	155	hfsplus_cat_entry entry;
	156	struct hfsplus_cat_file *file;
	157	int res;
	158
	159	if (!S_ISREG(inode->i_mode) \|\| HFSPLUS_IS_RSRC(inode))
	160	return -EOPNOTSUPP;
	161
dd73a01a	162	res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
1da177e4 LT	163	if (res)
	164	return res;
	165	res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
	166	if (res)
	167	goto out;
	168	hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
	169	sizeof(struct hfsplus_cat_file));
	170	file = &entry.file;
	171
	172	if (!strcmp(name, "hfs.type")) {
	173	if (size == 4)
	174	memcpy(&file->user_info.fdType, value, 4);
	175	else
	176	res = -ERANGE;
	177	} else if (!strcmp(name, "hfs.creator")) {
	178	if (size == 4)
	179	memcpy(&file->user_info.fdCreator, value, 4);
	180	else
	181	res = -ERANGE;
	182	} else
	183	res = -EOPNOTSUPP;
e3494705	184	if (!res) {
1da177e4 LT	185	hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
1da177e4 LT	186	sizeof(struct hfsplus_cat_file));
e3494705 CH	187	hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
e3494705 CH	188	}
1da177e4 LT	189	out:
	190	hfs_find_exit(&fd);
	191	return res;
	192	}
	193
	194	ssize_t hfsplus_getxattr(struct dentry dentry, const char name,
	195	void *value, size_t size)
	196	{
	197	struct inode *inode = dentry->d_inode;
	198	struct hfs_find_data fd;
	199	hfsplus_cat_entry entry;
	200	struct hfsplus_cat_file *file;
	201	ssize_t res = 0;
	202
	203	if (!S_ISREG(inode->i_mode) \|\| HFSPLUS_IS_RSRC(inode))
	204	return -EOPNOTSUPP;
	205
	206	if (size) {
dd73a01a	207	res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
1da177e4 LT	208	if (res)
	209	return res;
	210	res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
	211	if (res)
	212	goto out;
	213	hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
	214	sizeof(struct hfsplus_cat_file));
	215	}
	216	file = &entry.file;
	217
	218	if (!strcmp(name, "hfs.type")) {
	219	if (size >= 4) {
	220	memcpy(value, &file->user_info.fdType, 4);
	221	res = 4;
	222	} else
	223	res = size ? -ERANGE : 4;
	224	} else if (!strcmp(name, "hfs.creator")) {
	225	if (size >= 4) {
	226	memcpy(value, &file->user_info.fdCreator, 4);
	227	res = 4;
	228	} else
	229	res = size ? -ERANGE : 4;
	230	} else
46bf36ec	231	res = -EOPNOTSUPP;
1da177e4 LT	232	out:
	233	if (size)
	234	hfs_find_exit(&fd);
	235	return res;
	236	}
	237
	238	#define HFSPLUS_ATTRLIST_SIZE (sizeof("hfs.creator")+sizeof("hfs.type"))
	239
	240	ssize_t hfsplus_listxattr(struct dentry dentry, char buffer, size_t size)
	241	{
	242	struct inode *inode = dentry->d_inode;
	243
	244	if (!S_ISREG(inode->i_mode) \|\| HFSPLUS_IS_RSRC(inode))
	245	return -EOPNOTSUPP;
	246
	247	if (!buffer \|\| !size)
	248	return HFSPLUS_ATTRLIST_SIZE;
	249	if (size < HFSPLUS_ATTRLIST_SIZE)
	250	return -ERANGE;
	251	strcpy(buffer, "hfs.type");
	252	strcpy(buffer + sizeof("hfs.type"), "hfs.creator");
	253
	254	return HFSPLUS_ATTRLIST_SIZE;
	255	}