[linux-2.6-block.git] / fs / hfsplus / ioctl.c

// SPDX-License-Identifier: GPL-2.0
/*
 *  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/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 = d_inode(dentry);
	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;
	u32 cnid = (unsigned long)dentry->d_fsdata;

	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. Just using the inode here breaks in the case of
	 * hard links - the firmware wants the ID of the hard link file,
	 * but the inode points at the indirect inode
	 */
	vh->finder_info[1] = bvh->finder_info[1] = cpu_to_be32(cnid);

	/* 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_inode(file);
	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_inode(file);
	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
	unsigned int flags, new_fl = 0;
	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;
	}

	inode_lock(inode);

	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)
		new_fl |= S_IMMUTABLE;

	if (flags & FS_APPEND_FL)
		new_fl |= S_APPEND;

	inode_set_flags(inode, new_fl, S_IMMUTABLE | S_APPEND);

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

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

out_unlock_inode:
	inode_unlock(inode);
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;
	}
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	2	/*
	3	* linux/fs/hfsplus/ioctl.c
	4	*
	5	* Copyright (C) 2003
	6	* Ethan Benson <erbenson@alaska.net>
	7	* partially derived from linux/fs/ext2/ioctl.c
	8	* Copyright (C) 1993, 1994, 1995
	9	* Remy Card (card@masi.ibp.fr)
	10	* Laboratoire MASI - Institut Blaise Pascal
	11	* Universite Pierre et Marie Curie (Paris VI)
	12	*
	13	* hfsplus ioctls
	14	*/
	15
16f7e0fe	16	#include <linux/capability.h>
1da177e4	17	#include <linux/fs.h>
42a74f20	18	#include <linux/mount.h>
1da177e4	19	#include <linux/sched.h>
7c0f6ba6	20	#include <linux/uaccess.h>
1da177e4 LT	21	#include "hfsplus_fs.h"
1da177e4 LT	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;
2b0143b5	30	struct inode *inode = d_inode(dentry);
a051f71c MG	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;
7dea9665	34	u32 cnid = (unsigned long)dentry->d_fsdata;
a051f71c MG	35
	36	if (!capable(CAP_SYS_ADMIN))
	37	return -EPERM;
	38
	39	mutex_lock(&sbi->vh_mutex);
	40
	41	/* Directory containing the bootable system */
	42	vh->finder_info[0] = bvh->finder_info[0] =
	43	cpu_to_be32(parent_ino(dentry));
	44
7dea9665 MG	45	/*
	46	* Bootloader. Just using the inode here breaks in the case of
	47	* hard links - the firmware wants the ID of the hard link file,
	48	* but the inode points at the indirect inode
	49	*/
	50	vh->finder_info[1] = bvh->finder_info[1] = cpu_to_be32(cnid);
a051f71c MG	51
	52	/* Per spec, the OS X system folder - same as finder_info[0] here */
	53	vh->finder_info[5] = bvh->finder_info[5] =
	54	cpu_to_be32(parent_ino(dentry));
	55
	56	mutex_unlock(&sbi->vh_mutex);
	57	return 0;
	58	}
	59
94744567	60	static int hfsplus_ioctl_getflags(struct file file, int __user user_flags)
1da177e4	61	{
496ad9aa	62	struct inode *inode = file_inode(file);
6af502de	63	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
94744567 CH	64	unsigned int flags = 0;
94744567 CH	65
722c55d1	66	if (inode->i_flags & S_IMMUTABLE)
94744567	67	flags \|= FS_IMMUTABLE_FL;
596276c3	68	if (inode->i_flags & S_APPEND)
94744567	69	flags \|= FS_APPEND_FL;
6af502de	70	if (hip->userflags & HFSPLUS_FLG_NODUMP)
94744567 CH	71	flags \|= FS_NODUMP_FL;
	72
	73	return put_user(flags, user_flags);
	74	}
	75
	76	static int hfsplus_ioctl_setflags(struct file file, int __user user_flags)
	77	{
496ad9aa	78	struct inode *inode = file_inode(file);
6af502de	79	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
73d28d57	80	unsigned int flags, new_fl = 0;
94744567	81	int err = 0;
1da177e4	82
a561be71	83	err = mnt_want_write_file(file);
94744567	84	if (err)
6333816a	85	goto out;
1da177e4	86
2e149670	87	if (!inode_owner_or_capable(inode)) {
94744567 CH	88	err = -EACCES;
	89	goto out_drop_write;
	90	}
1da177e4	91
94744567 CH	92	if (get_user(flags, user_flags)) {
	93	err = -EFAULT;
	94	goto out_drop_write;
	95	}
	96
5955102c	97	inode_lock(inode);
6333816a	98
722c55d1 CH	99	if ((flags & (FS_IMMUTABLE_FL\|FS_APPEND_FL)) \|\|
722c55d1 CH	100	inode->i_flags & (S_IMMUTABLE\|S_APPEND)) {
94744567 CH	101	if (!capable(CAP_LINUX_IMMUTABLE)) {
94744567 CH	102	err = -EPERM;
6333816a	103	goto out_unlock_inode;
1da177e4	104	}
1da177e4	105	}
94744567 CH	106
	107	/* don't silently ignore unsupported ext2 flags */
	108	if (flags & ~(FS_IMMUTABLE_FL\|FS_APPEND_FL\|FS_NODUMP_FL)) {
	109	err = -EOPNOTSUPP;
6333816a	110	goto out_unlock_inode;
94744567	111	}
722c55d1 CH	112
722c55d1 CH	113	if (flags & FS_IMMUTABLE_FL)
73d28d57	114	new_fl \|= S_IMMUTABLE;
722c55d1 CH	115
722c55d1 CH	116	if (flags & FS_APPEND_FL)
73d28d57 FF	117	new_fl \|= S_APPEND;
	118
	119	inode_set_flags(inode, new_fl, S_IMMUTABLE \| S_APPEND);
722c55d1	120
94744567	121	if (flags & FS_NODUMP_FL)
6af502de	122	hip->userflags \|= HFSPLUS_FLG_NODUMP;
94744567	123	else
6af502de	124	hip->userflags &= ~HFSPLUS_FLG_NODUMP;
94744567	125
02027d42	126	inode->i_ctime = current_time(inode);
94744567 CH	127	mark_inode_dirty(inode);
94744567 CH	128
6333816a	129	out_unlock_inode:
5955102c	130	inode_unlock(inode);
94744567	131	out_drop_write:
2a79f17e	132	mnt_drop_write_file(file);
6333816a	133	out:
94744567 CH	134	return err;
	135	}
	136
	137	long hfsplus_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	138	{
	139	void __user argp = (void __user )arg;
	140
	141	switch (cmd) {
	142	case HFSPLUS_IOC_EXT2_GETFLAGS:
	143	return hfsplus_ioctl_getflags(file, argp);
	144	case HFSPLUS_IOC_EXT2_SETFLAGS:
	145	return hfsplus_ioctl_setflags(file, argp);
a051f71c MG	146	case HFSPLUS_IOC_BLESS:
a051f71c MG	147	return hfsplus_ioctl_bless(file, argp);
1da177e4 LT	148	default:
	149	return -ENOTTY;
	150	}
	151	}