[mirror_ubuntu-bionic-kernel.git] / fs / xfs / xfs_ioctl32.c

/*
 * Copyright (c) 2004-2005 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would 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 the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
#include <linux/compat.h>
#include <linux/ioctl.h>
#include <linux/mount.h>
#include <linux/slab.h>
#include <asm/uaccess.h>
#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_log.h"
#include "xfs_trans.h"
#include "xfs_sb.h"
#include "xfs_ag.h"
#include "xfs_mount.h"
#include "xfs_bmap_btree.h"
#include "xfs_vnode.h"
#include "xfs_dinode.h"
#include "xfs_inode.h"
#include "xfs_itable.h"
#include "xfs_error.h"
#include "xfs_fsops.h"
#include "xfs_alloc.h"
#include "xfs_rtalloc.h"
#include "xfs_attr.h"
#include "xfs_ioctl.h"
#include "xfs_ioctl32.h"
#include "xfs_trace.h"

#define  _NATIVE_IOC(cmd, type) \
	  _IOC(_IOC_DIR(cmd), _IOC_TYPE(cmd), _IOC_NR(cmd), sizeof(type))

#ifdef BROKEN_X86_ALIGNMENT
STATIC int
xfs_compat_flock64_copyin(
	xfs_flock64_t		*bf,
	compat_xfs_flock64_t	__user *arg32)
{
	if (get_user(bf->l_type,	&arg32->l_type) ||
	    get_user(bf->l_whence,	&arg32->l_whence) ||
	    get_user(bf->l_start,	&arg32->l_start) ||
	    get_user(bf->l_len,		&arg32->l_len) ||
	    get_user(bf->l_sysid,	&arg32->l_sysid) ||
	    get_user(bf->l_pid,		&arg32->l_pid) ||
	    copy_from_user(bf->l_pad,	&arg32->l_pad,	4*sizeof(u32)))
		return -XFS_ERROR(EFAULT);
	return 0;
}

STATIC int
xfs_compat_ioc_fsgeometry_v1(
	struct xfs_mount	  *mp,
	compat_xfs_fsop_geom_v1_t __user *arg32)
{
	xfs_fsop_geom_t		  fsgeo;
	int			  error;

	error = xfs_fs_geometry(mp, &fsgeo, 3);
	if (error)
		return -error;
	/* The 32-bit variant simply has some padding at the end */
	if (copy_to_user(arg32, &fsgeo, sizeof(struct compat_xfs_fsop_geom_v1)))
		return -XFS_ERROR(EFAULT);
	return 0;
}

STATIC int
xfs_compat_growfs_data_copyin(
	struct xfs_growfs_data	 *in,
	compat_xfs_growfs_data_t __user *arg32)
{
	if (get_user(in->newblocks, &arg32->newblocks) ||
	    get_user(in->imaxpct,   &arg32->imaxpct))
		return -XFS_ERROR(EFAULT);
	return 0;
}

STATIC int
xfs_compat_growfs_rt_copyin(
	struct xfs_growfs_rt	 *in,
	compat_xfs_growfs_rt_t	__user *arg32)
{
	if (get_user(in->newblocks, &arg32->newblocks) ||
	    get_user(in->extsize,   &arg32->extsize))
		return -XFS_ERROR(EFAULT);
	return 0;
}

STATIC int
xfs_inumbers_fmt_compat(
	void			__user *ubuffer,
	const xfs_inogrp_t	*buffer,
	long			count,
	long			*written)
{
	compat_xfs_inogrp_t	__user *p32 = ubuffer;
	long			i;

	for (i = 0; i < count; i++) {
		if (put_user(buffer[i].xi_startino,   &p32[i].xi_startino) ||
		    put_user(buffer[i].xi_alloccount, &p32[i].xi_alloccount) ||
		    put_user(buffer[i].xi_allocmask,  &p32[i].xi_allocmask))
			return -XFS_ERROR(EFAULT);
	}
	*written = count * sizeof(*p32);
	return 0;
}

#else
#define xfs_inumbers_fmt_compat xfs_inumbers_fmt
#endif	/* BROKEN_X86_ALIGNMENT */

STATIC int
xfs_ioctl32_bstime_copyin(
	xfs_bstime_t		*bstime,
	compat_xfs_bstime_t	__user *bstime32)
{
	compat_time_t		sec32;	/* tv_sec differs on 64 vs. 32 */

	if (get_user(sec32,		&bstime32->tv_sec)	||
	    get_user(bstime->tv_nsec,	&bstime32->tv_nsec))
		return -XFS_ERROR(EFAULT);
	bstime->tv_sec = sec32;
	return 0;
}

/* xfs_bstat_t has differing alignment on intel, & bstime_t sizes everywhere */
STATIC int
xfs_ioctl32_bstat_copyin(
	xfs_bstat_t		*bstat,
	compat_xfs_bstat_t	__user *bstat32)
{
	if (get_user(bstat->bs_ino,	&bstat32->bs_ino)	||
	    get_user(bstat->bs_mode,	&bstat32->bs_mode)	||
	    get_user(bstat->bs_nlink,	&bstat32->bs_nlink)	||
	    get_user(bstat->bs_uid,	&bstat32->bs_uid)	||
	    get_user(bstat->bs_gid,	&bstat32->bs_gid)	||
	    get_user(bstat->bs_rdev,	&bstat32->bs_rdev)	||
	    get_user(bstat->bs_blksize,	&bstat32->bs_blksize)	||
	    get_user(bstat->bs_size,	&bstat32->bs_size)	||
	    xfs_ioctl32_bstime_copyin(&bstat->bs_atime, &bstat32->bs_atime) ||
	    xfs_ioctl32_bstime_copyin(&bstat->bs_mtime, &bstat32->bs_mtime) ||
	    xfs_ioctl32_bstime_copyin(&bstat->bs_ctime, &bstat32->bs_ctime) ||
	    get_user(bstat->bs_blocks,	&bstat32->bs_size)	||
	    get_user(bstat->bs_xflags,	&bstat32->bs_size)	||
	    get_user(bstat->bs_extsize,	&bstat32->bs_extsize)	||
	    get_user(bstat->bs_extents,	&bstat32->bs_extents)	||
	    get_user(bstat->bs_gen,	&bstat32->bs_gen)	||
	    get_user(bstat->bs_projid_lo, &bstat32->bs_projid_lo) ||
	    get_user(bstat->bs_projid_hi, &bstat32->bs_projid_hi) ||
	    get_user(bstat->bs_dmevmask, &bstat32->bs_dmevmask)	||
	    get_user(bstat->bs_dmstate,	&bstat32->bs_dmstate)	||
	    get_user(bstat->bs_aextents, &bstat32->bs_aextents))
		return -XFS_ERROR(EFAULT);
	return 0;
}

/* XFS_IOC_FSBULKSTAT and friends */

STATIC int
xfs_bstime_store_compat(
	compat_xfs_bstime_t	__user *p32,
	const xfs_bstime_t	*p)
{
	__s32			sec32;

	sec32 = p->tv_sec;
	if (put_user(sec32, &p32->tv_sec) ||
	    put_user(p->tv_nsec, &p32->tv_nsec))
		return -XFS_ERROR(EFAULT);
	return 0;
}

/* Return 0 on success or positive error (to xfs_bulkstat()) */
STATIC int
xfs_bulkstat_one_fmt_compat(
	void			__user *ubuffer,
	int			ubsize,
	int			*ubused,
	const xfs_bstat_t	*buffer)
{
	compat_xfs_bstat_t	__user *p32 = ubuffer;

	if (ubsize < sizeof(*p32))
		return XFS_ERROR(ENOMEM);

	if (put_user(buffer->bs_ino,	  &p32->bs_ino)		||
	    put_user(buffer->bs_mode,	  &p32->bs_mode)	||
	    put_user(buffer->bs_nlink,	  &p32->bs_nlink)	||
	    put_user(buffer->bs_uid,	  &p32->bs_uid)		||
	    put_user(buffer->bs_gid,	  &p32->bs_gid)		||
	    put_user(buffer->bs_rdev,	  &p32->bs_rdev)	||
	    put_user(buffer->bs_blksize,  &p32->bs_blksize)	||
	    put_user(buffer->bs_size,	  &p32->bs_size)	||
	    xfs_bstime_store_compat(&p32->bs_atime, &buffer->bs_atime) ||
	    xfs_bstime_store_compat(&p32->bs_mtime, &buffer->bs_mtime) ||
	    xfs_bstime_store_compat(&p32->bs_ctime, &buffer->bs_ctime) ||
	    put_user(buffer->bs_blocks,	  &p32->bs_blocks)	||
	    put_user(buffer->bs_xflags,	  &p32->bs_xflags)	||
	    put_user(buffer->bs_extsize,  &p32->bs_extsize)	||
	    put_user(buffer->bs_extents,  &p32->bs_extents)	||
	    put_user(buffer->bs_gen,	  &p32->bs_gen)		||
	    put_user(buffer->bs_projid,	  &p32->bs_projid)	||
	    put_user(buffer->bs_projid_hi,	&p32->bs_projid_hi)	||
	    put_user(buffer->bs_dmevmask, &p32->bs_dmevmask)	||
	    put_user(buffer->bs_dmstate,  &p32->bs_dmstate)	||
	    put_user(buffer->bs_aextents, &p32->bs_aextents))
		return XFS_ERROR(EFAULT);
	if (ubused)
		*ubused = sizeof(*p32);
	return 0;
}

STATIC int
xfs_bulkstat_one_compat(
	xfs_mount_t	*mp,		/* mount point for filesystem */
	xfs_ino_t	ino,		/* inode number to get data for */
	void		__user *buffer,	/* buffer to place output in */
	int		ubsize,		/* size of buffer */
	int		*ubused,	/* bytes used by me */
	int		*stat)		/* BULKSTAT_RV_... */
{
	return xfs_bulkstat_one_int(mp, ino, buffer, ubsize,
				    xfs_bulkstat_one_fmt_compat,
				    ubused, stat);
}

/* copied from xfs_ioctl.c */
STATIC int
xfs_compat_ioc_bulkstat(
	xfs_mount_t		  *mp,
	unsigned int		  cmd,
	compat_xfs_fsop_bulkreq_t __user *p32)
{
	u32			addr;
	xfs_fsop_bulkreq_t	bulkreq;
	int			count;	/* # of records returned */
	xfs_ino_t		inlast;	/* last inode number */
	int			done;
	int			error;

	/* done = 1 if there are more stats to get and if bulkstat */
	/* should be called again (unused here, but used in dmapi) */

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

	if (XFS_FORCED_SHUTDOWN(mp))
		return -XFS_ERROR(EIO);

	if (get_user(addr, &p32->lastip))
		return -XFS_ERROR(EFAULT);
	bulkreq.lastip = compat_ptr(addr);
	if (get_user(bulkreq.icount, &p32->icount) ||
	    get_user(addr, &p32->ubuffer))
		return -XFS_ERROR(EFAULT);
	bulkreq.ubuffer = compat_ptr(addr);
	if (get_user(addr, &p32->ocount))
		return -XFS_ERROR(EFAULT);
	bulkreq.ocount = compat_ptr(addr);

	if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
		return -XFS_ERROR(EFAULT);

	if ((count = bulkreq.icount) <= 0)
		return -XFS_ERROR(EINVAL);

	if (bulkreq.ubuffer == NULL)
		return -XFS_ERROR(EINVAL);

	if (cmd == XFS_IOC_FSINUMBERS_32) {
		error = xfs_inumbers(mp, &inlast, &count,
				bulkreq.ubuffer, xfs_inumbers_fmt_compat);
	} else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE_32) {
		int res;

		error = xfs_bulkstat_one_compat(mp, inlast, bulkreq.ubuffer,
				sizeof(compat_xfs_bstat_t), NULL, &res);
	} else if (cmd == XFS_IOC_FSBULKSTAT_32) {
		error = xfs_bulkstat(mp, &inlast, &count,
			xfs_bulkstat_one_compat, sizeof(compat_xfs_bstat_t),
			bulkreq.ubuffer, &done);
	} else
		error = XFS_ERROR(EINVAL);
	if (error)
		return -error;

	if (bulkreq.ocount != NULL) {
		if (copy_to_user(bulkreq.lastip, &inlast,
						sizeof(xfs_ino_t)))
			return -XFS_ERROR(EFAULT);

		if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
			return -XFS_ERROR(EFAULT);
	}

	return 0;
}

STATIC int
xfs_compat_handlereq_copyin(
	xfs_fsop_handlereq_t		*hreq,
	compat_xfs_fsop_handlereq_t	__user *arg32)
{
	compat_xfs_fsop_handlereq_t	hreq32;

	if (copy_from_user(&hreq32, arg32, sizeof(compat_xfs_fsop_handlereq_t)))
		return -XFS_ERROR(EFAULT);

	hreq->fd = hreq32.fd;
	hreq->path = compat_ptr(hreq32.path);
	hreq->oflags = hreq32.oflags;
	hreq->ihandle = compat_ptr(hreq32.ihandle);
	hreq->ihandlen = hreq32.ihandlen;
	hreq->ohandle = compat_ptr(hreq32.ohandle);
	hreq->ohandlen = compat_ptr(hreq32.ohandlen);

	return 0;
}

STATIC struct dentry *
xfs_compat_handlereq_to_dentry(
	struct file		*parfilp,
	compat_xfs_fsop_handlereq_t *hreq)
{
	return xfs_handle_to_dentry(parfilp,
			compat_ptr(hreq->ihandle), hreq->ihandlen);
}

STATIC int
xfs_compat_attrlist_by_handle(
	struct file		*parfilp,
	void			__user *arg)
{
	int			error;
	attrlist_cursor_kern_t	*cursor;
	compat_xfs_fsop_attrlist_handlereq_t al_hreq;
	struct dentry		*dentry;
	char			*kbuf;

	if (!capable(CAP_SYS_ADMIN))
		return -XFS_ERROR(EPERM);
	if (copy_from_user(&al_hreq, arg,
			   sizeof(compat_xfs_fsop_attrlist_handlereq_t)))
		return -XFS_ERROR(EFAULT);
	if (al_hreq.buflen > XATTR_LIST_MAX)
		return -XFS_ERROR(EINVAL);

	/*
	 * Reject flags, only allow namespaces.
	 */
	if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
		return -XFS_ERROR(EINVAL);

	dentry = xfs_compat_handlereq_to_dentry(parfilp, &al_hreq.hreq);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);

	error = -ENOMEM;
	kbuf = kmem_zalloc(al_hreq.buflen, KM_SLEEP | KM_MAYFAIL);
	if (!kbuf) {
		kbuf = kmem_zalloc_large(al_hreq.buflen);
		if (!kbuf)
			goto out_dput;
	}

	cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
	error = -xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
					al_hreq.flags, cursor);
	if (error)
		goto out_kfree;

	if (copy_to_user(compat_ptr(al_hreq.buffer), kbuf, al_hreq.buflen))
		error = -EFAULT;

 out_kfree:
	if (is_vmalloc_addr(kbuf))
		kmem_free_large(kbuf);
	else
		kmem_free(kbuf);
 out_dput:
	dput(dentry);
	return error;
}

STATIC int
xfs_compat_attrmulti_by_handle(
	struct file				*parfilp,
	void					__user *arg)
{
	int					error;
	compat_xfs_attr_multiop_t		*ops;
	compat_xfs_fsop_attrmulti_handlereq_t	am_hreq;
	struct dentry				*dentry;
	unsigned int				i, size;
	unsigned char				*attr_name;

	if (!capable(CAP_SYS_ADMIN))
		return -XFS_ERROR(EPERM);
	if (copy_from_user(&am_hreq, arg,
			   sizeof(compat_xfs_fsop_attrmulti_handlereq_t)))
		return -XFS_ERROR(EFAULT);

	/* overflow check */
	if (am_hreq.opcount >= INT_MAX / sizeof(compat_xfs_attr_multiop_t))
		return -E2BIG;

	dentry = xfs_compat_handlereq_to_dentry(parfilp, &am_hreq.hreq);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);

	error = E2BIG;
	size = am_hreq.opcount * sizeof(compat_xfs_attr_multiop_t);
	if (!size || size > 16 * PAGE_SIZE)
		goto out_dput;

	ops = memdup_user(compat_ptr(am_hreq.ops), size);
	if (IS_ERR(ops)) {
		error = PTR_ERR(ops);
		goto out_dput;
	}

	attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
	if (!attr_name)
		goto out_kfree_ops;

	error = 0;
	for (i = 0; i < am_hreq.opcount; i++) {
		ops[i].am_error = strncpy_from_user((char *)attr_name,
				compat_ptr(ops[i].am_attrname),
				MAXNAMELEN);
		if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
			error = -ERANGE;
		if (ops[i].am_error < 0)
			break;

		switch (ops[i].am_opcode) {
		case ATTR_OP_GET:
			ops[i].am_error = xfs_attrmulti_attr_get(
					dentry->d_inode, attr_name,
					compat_ptr(ops[i].am_attrvalue),
					&ops[i].am_length, ops[i].am_flags);
			break;
		case ATTR_OP_SET:
			ops[i].am_error = mnt_want_write_file(parfilp);
			if (ops[i].am_error)
				break;
			ops[i].am_error = xfs_attrmulti_attr_set(
					dentry->d_inode, attr_name,
					compat_ptr(ops[i].am_attrvalue),
					ops[i].am_length, ops[i].am_flags);
			mnt_drop_write_file(parfilp);
			break;
		case ATTR_OP_REMOVE:
			ops[i].am_error = mnt_want_write_file(parfilp);
			if (ops[i].am_error)
				break;
			ops[i].am_error = xfs_attrmulti_attr_remove(
					dentry->d_inode, attr_name,
					ops[i].am_flags);
			mnt_drop_write_file(parfilp);
			break;
		default:
			ops[i].am_error = EINVAL;
		}
	}

	if (copy_to_user(compat_ptr(am_hreq.ops), ops, size))
		error = XFS_ERROR(EFAULT);

	kfree(attr_name);
 out_kfree_ops:
	kfree(ops);
 out_dput:
	dput(dentry);
	return -error;
}

STATIC int
xfs_compat_fssetdm_by_handle(
	struct file		*parfilp,
	void			__user *arg)
{
	int			error;
	struct fsdmidata	fsd;
	compat_xfs_fsop_setdm_handlereq_t dmhreq;
	struct dentry		*dentry;

	if (!capable(CAP_MKNOD))
		return -XFS_ERROR(EPERM);
	if (copy_from_user(&dmhreq, arg,
			   sizeof(compat_xfs_fsop_setdm_handlereq_t)))
		return -XFS_ERROR(EFAULT);

	dentry = xfs_compat_handlereq_to_dentry(parfilp, &dmhreq.hreq);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);

	if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) {
		error = -XFS_ERROR(EPERM);
		goto out;
	}

	if (copy_from_user(&fsd, compat_ptr(dmhreq.data), sizeof(fsd))) {
		error = -XFS_ERROR(EFAULT);
		goto out;
	}

	error = -xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
				 fsd.fsd_dmstate);

out:
	dput(dentry);
	return error;
}

long
xfs_file_compat_ioctl(
	struct file		*filp,
	unsigned		cmd,
	unsigned long		p)
{
	struct inode		*inode = file_inode(filp);
	struct xfs_inode	*ip = XFS_I(inode);
	struct xfs_mount	*mp = ip->i_mount;
	void			__user *arg = (void __user *)p;
	int			ioflags = 0;
	int			error;

	if (filp->f_mode & FMODE_NOCMTIME)
		ioflags |= IO_INVIS;

	trace_xfs_file_compat_ioctl(ip);

	switch (cmd) {
	/* No size or alignment issues on any arch */
	case XFS_IOC_DIOINFO:
	case XFS_IOC_FSGEOMETRY:
	case XFS_IOC_FSGETXATTR:
	case XFS_IOC_FSSETXATTR:
	case XFS_IOC_FSGETXATTRA:
	case XFS_IOC_FSSETDM:
	case XFS_IOC_GETBMAP:
	case XFS_IOC_GETBMAPA:
	case XFS_IOC_GETBMAPX:
	case XFS_IOC_FSCOUNTS:
	case XFS_IOC_SET_RESBLKS:
	case XFS_IOC_GET_RESBLKS:
	case XFS_IOC_FSGROWFSLOG:
	case XFS_IOC_GOINGDOWN:
	case XFS_IOC_ERROR_INJECTION:
	case XFS_IOC_ERROR_CLEARALL:
		return xfs_file_ioctl(filp, cmd, p);
#ifndef BROKEN_X86_ALIGNMENT
	/* These are handled fine if no alignment issues */
	case XFS_IOC_ALLOCSP:
	case XFS_IOC_FREESP:
	case XFS_IOC_RESVSP:
	case XFS_IOC_UNRESVSP:
	case XFS_IOC_ALLOCSP64:
	case XFS_IOC_FREESP64:
	case XFS_IOC_RESVSP64:
	case XFS_IOC_UNRESVSP64:
	case XFS_IOC_FSGEOMETRY_V1:
	case XFS_IOC_FSGROWFSDATA:
	case XFS_IOC_FSGROWFSRT:
	case XFS_IOC_ZERO_RANGE:
		return xfs_file_ioctl(filp, cmd, p);
#else
	case XFS_IOC_ALLOCSP_32:
	case XFS_IOC_FREESP_32:
	case XFS_IOC_ALLOCSP64_32:
	case XFS_IOC_FREESP64_32:
	case XFS_IOC_RESVSP_32:
	case XFS_IOC_UNRESVSP_32:
	case XFS_IOC_RESVSP64_32:
	case XFS_IOC_UNRESVSP64_32:
	case XFS_IOC_ZERO_RANGE_32: {
		struct xfs_flock64	bf;

		if (xfs_compat_flock64_copyin(&bf, arg))
			return -XFS_ERROR(EFAULT);
		cmd = _NATIVE_IOC(cmd, struct xfs_flock64);
		return xfs_ioc_space(ip, inode, filp, ioflags, cmd, &bf);
	}
	case XFS_IOC_FSGEOMETRY_V1_32:
		return xfs_compat_ioc_fsgeometry_v1(mp, arg);
	case XFS_IOC_FSGROWFSDATA_32: {
		struct xfs_growfs_data	in;

		if (xfs_compat_growfs_data_copyin(&in, arg))
			return -XFS_ERROR(EFAULT);
		error = mnt_want_write_file(filp);
		if (error)
			return error;
		error = xfs_growfs_data(mp, &in);
		mnt_drop_write_file(filp);
		return -error;
	}
	case XFS_IOC_FSGROWFSRT_32: {
		struct xfs_growfs_rt	in;

		if (xfs_compat_growfs_rt_copyin(&in, arg))
			return -XFS_ERROR(EFAULT);
		error = mnt_want_write_file(filp);
		if (error)
			return error;
		error = xfs_growfs_rt(mp, &in);
		mnt_drop_write_file(filp);
		return -error;
	}
#endif
	/* long changes size, but xfs only copiese out 32 bits */
	case XFS_IOC_GETXFLAGS_32:
	case XFS_IOC_SETXFLAGS_32:
	case XFS_IOC_GETVERSION_32:
		cmd = _NATIVE_IOC(cmd, long);
		return xfs_file_ioctl(filp, cmd, p);
	case XFS_IOC_SWAPEXT_32: {
		struct xfs_swapext	  sxp;
		struct compat_xfs_swapext __user *sxu = arg;

		/* Bulk copy in up to the sx_stat field, then copy bstat */
		if (copy_from_user(&sxp, sxu,
				   offsetof(struct xfs_swapext, sx_stat)) ||
		    xfs_ioctl32_bstat_copyin(&sxp.sx_stat, &sxu->sx_stat))
			return -XFS_ERROR(EFAULT);
		error = mnt_want_write_file(filp);
		if (error)
			return error;
		error = xfs_ioc_swapext(&sxp);
		mnt_drop_write_file(filp);
		return -error;
	}
	case XFS_IOC_FSBULKSTAT_32:
	case XFS_IOC_FSBULKSTAT_SINGLE_32:
	case XFS_IOC_FSINUMBERS_32:
		return xfs_compat_ioc_bulkstat(mp, cmd, arg);
	case XFS_IOC_FD_TO_HANDLE_32:
	case XFS_IOC_PATH_TO_HANDLE_32:
	case XFS_IOC_PATH_TO_FSHANDLE_32: {
		struct xfs_fsop_handlereq	hreq;

		if (xfs_compat_handlereq_copyin(&hreq, arg))
			return -XFS_ERROR(EFAULT);
		cmd = _NATIVE_IOC(cmd, struct xfs_fsop_handlereq);
		return xfs_find_handle(cmd, &hreq);
	}
	case XFS_IOC_OPEN_BY_HANDLE_32: {
		struct xfs_fsop_handlereq	hreq;

		if (xfs_compat_handlereq_copyin(&hreq, arg))
			return -XFS_ERROR(EFAULT);
		return xfs_open_by_handle(filp, &hreq);
	}
	case XFS_IOC_READLINK_BY_HANDLE_32: {
		struct xfs_fsop_handlereq	hreq;

		if (xfs_compat_handlereq_copyin(&hreq, arg))
			return -XFS_ERROR(EFAULT);
		return xfs_readlink_by_handle(filp, &hreq);
	}
	case XFS_IOC_ATTRLIST_BY_HANDLE_32:
		return xfs_compat_attrlist_by_handle(filp, arg);
	case XFS_IOC_ATTRMULTI_BY_HANDLE_32:
		return xfs_compat_attrmulti_by_handle(filp, arg);
	case XFS_IOC_FSSETDM_BY_HANDLE_32:
		return xfs_compat_fssetdm_by_handle(filp, arg);
	default:
		return -XFS_ERROR(ENOIOCTLCMD);
	}
}
Commit	Line	Data
	1	/*
	2	* Copyright (c) 2004-2005 Silicon Graphics, Inc.
	3	* All Rights Reserved.
	4	*
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU General Public License as
	7	* published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	17	*/
	18	#include <linux/compat.h>
	19	#include <linux/ioctl.h>
	20	#include <linux/mount.h>
	21	#include <linux/slab.h>
	22	#include <asm/uaccess.h>
	23	#include "xfs.h"
	24	#include "xfs_fs.h"
	25	#include "xfs_log.h"
	26	#include "xfs_trans.h"
	27	#include "xfs_sb.h"
	28	#include "xfs_ag.h"
	29	#include "xfs_mount.h"
	30	#include "xfs_bmap_btree.h"
	31	#include "xfs_vnode.h"
	32	#include "xfs_dinode.h"
	33	#include "xfs_inode.h"
	34	#include "xfs_itable.h"
	35	#include "xfs_error.h"
	36	#include "xfs_fsops.h"
	37	#include "xfs_alloc.h"
	38	#include "xfs_rtalloc.h"
	39	#include "xfs_attr.h"
	40	#include "xfs_ioctl.h"
	41	#include "xfs_ioctl32.h"
	42	#include "xfs_trace.h"
	43
	44	#define _NATIVE_IOC(cmd, type) \
	45	_IOC(_IOC_DIR(cmd), _IOC_TYPE(cmd), _IOC_NR(cmd), sizeof(type))
	46
	47	#ifdef BROKEN_X86_ALIGNMENT
	48	STATIC int
	49	xfs_compat_flock64_copyin(
	50	xfs_flock64_t *bf,
	51	compat_xfs_flock64_t __user *arg32)
	52	{
	53	if (get_user(bf->l_type, &arg32->l_type) \|\|
	54	get_user(bf->l_whence, &arg32->l_whence) \|\|
	55	get_user(bf->l_start, &arg32->l_start) \|\|
	56	get_user(bf->l_len, &arg32->l_len) \|\|
	57	get_user(bf->l_sysid, &arg32->l_sysid) \|\|
	58	get_user(bf->l_pid, &arg32->l_pid) \|\|
	59	copy_from_user(bf->l_pad, &arg32->l_pad, 4*sizeof(u32)))
	60	return -XFS_ERROR(EFAULT);
	61	return 0;
	62	}
	63
	64	STATIC int
	65	xfs_compat_ioc_fsgeometry_v1(
	66	struct xfs_mount *mp,
	67	compat_xfs_fsop_geom_v1_t __user *arg32)
	68	{
	69	xfs_fsop_geom_t fsgeo;
	70	int error;
	71
	72	error = xfs_fs_geometry(mp, &fsgeo, 3);
	73	if (error)
	74	return -error;
	75	/* The 32-bit variant simply has some padding at the end */
	76	if (copy_to_user(arg32, &fsgeo, sizeof(struct compat_xfs_fsop_geom_v1)))
	77	return -XFS_ERROR(EFAULT);
	78	return 0;
	79	}
	80
	81	STATIC int
	82	xfs_compat_growfs_data_copyin(
	83	struct xfs_growfs_data *in,
	84	compat_xfs_growfs_data_t __user *arg32)
	85	{
	86	if (get_user(in->newblocks, &arg32->newblocks) \|\|
	87	get_user(in->imaxpct, &arg32->imaxpct))
	88	return -XFS_ERROR(EFAULT);
	89	return 0;
	90	}
	91
	92	STATIC int
	93	xfs_compat_growfs_rt_copyin(
	94	struct xfs_growfs_rt *in,
	95	compat_xfs_growfs_rt_t __user *arg32)
	96	{
	97	if (get_user(in->newblocks, &arg32->newblocks) \|\|
	98	get_user(in->extsize, &arg32->extsize))
	99	return -XFS_ERROR(EFAULT);
	100	return 0;
	101	}
	102
	103	STATIC int
	104	xfs_inumbers_fmt_compat(
	105	void __user *ubuffer,
	106	const xfs_inogrp_t *buffer,
	107	long count,
	108	long *written)
	109	{
	110	compat_xfs_inogrp_t __user *p32 = ubuffer;
	111	long i;
	112
	113	for (i = 0; i < count; i++) {
	114	if (put_user(buffer[i].xi_startino, &p32[i].xi_startino) \|\|
	115	put_user(buffer[i].xi_alloccount, &p32[i].xi_alloccount) \|\|
	116	put_user(buffer[i].xi_allocmask, &p32[i].xi_allocmask))
	117	return -XFS_ERROR(EFAULT);
	118	}
	119	written = count sizeof(*p32);
	120	return 0;
	121	}
	122
	123	#else
	124	#define xfs_inumbers_fmt_compat xfs_inumbers_fmt
	125	#endif /* BROKEN_X86_ALIGNMENT */
	126
	127	STATIC int
	128	xfs_ioctl32_bstime_copyin(
	129	xfs_bstime_t *bstime,
	130	compat_xfs_bstime_t __user *bstime32)
	131	{
	132	compat_time_t sec32; /* tv_sec differs on 64 vs. 32 */
	133
	134	if (get_user(sec32, &bstime32->tv_sec) \|\|
	135	get_user(bstime->tv_nsec, &bstime32->tv_nsec))
	136	return -XFS_ERROR(EFAULT);
	137	bstime->tv_sec = sec32;
	138	return 0;
	139	}
	140
	141	/* xfs_bstat_t has differing alignment on intel, & bstime_t sizes everywhere */
	142	STATIC int
	143	xfs_ioctl32_bstat_copyin(
	144	xfs_bstat_t *bstat,
	145	compat_xfs_bstat_t __user *bstat32)
	146	{
	147	if (get_user(bstat->bs_ino, &bstat32->bs_ino) \|\|
	148	get_user(bstat->bs_mode, &bstat32->bs_mode) \|\|
	149	get_user(bstat->bs_nlink, &bstat32->bs_nlink) \|\|
	150	get_user(bstat->bs_uid, &bstat32->bs_uid) \|\|
	151	get_user(bstat->bs_gid, &bstat32->bs_gid) \|\|
	152	get_user(bstat->bs_rdev, &bstat32->bs_rdev) \|\|
	153	get_user(bstat->bs_blksize, &bstat32->bs_blksize) \|\|
	154	get_user(bstat->bs_size, &bstat32->bs_size) \|\|
	155	xfs_ioctl32_bstime_copyin(&bstat->bs_atime, &bstat32->bs_atime) \|\|
	156	xfs_ioctl32_bstime_copyin(&bstat->bs_mtime, &bstat32->bs_mtime) \|\|
	157	xfs_ioctl32_bstime_copyin(&bstat->bs_ctime, &bstat32->bs_ctime) \|\|
	158	get_user(bstat->bs_blocks, &bstat32->bs_size) \|\|
	159	get_user(bstat->bs_xflags, &bstat32->bs_size) \|\|
	160	get_user(bstat->bs_extsize, &bstat32->bs_extsize) \|\|
	161	get_user(bstat->bs_extents, &bstat32->bs_extents) \|\|
	162	get_user(bstat->bs_gen, &bstat32->bs_gen) \|\|
	163	get_user(bstat->bs_projid_lo, &bstat32->bs_projid_lo) \|\|
	164	get_user(bstat->bs_projid_hi, &bstat32->bs_projid_hi) \|\|
	165	get_user(bstat->bs_dmevmask, &bstat32->bs_dmevmask) \|\|
	166	get_user(bstat->bs_dmstate, &bstat32->bs_dmstate) \|\|
	167	get_user(bstat->bs_aextents, &bstat32->bs_aextents))
	168	return -XFS_ERROR(EFAULT);
	169	return 0;
	170	}
	171
	172	/* XFS_IOC_FSBULKSTAT and friends */
	173
	174	STATIC int
	175	xfs_bstime_store_compat(
	176	compat_xfs_bstime_t __user *p32,
	177	const xfs_bstime_t *p)
	178	{
	179	__s32 sec32;
	180
	181	sec32 = p->tv_sec;
	182	if (put_user(sec32, &p32->tv_sec) \|\|
	183	put_user(p->tv_nsec, &p32->tv_nsec))
	184	return -XFS_ERROR(EFAULT);
	185	return 0;
	186	}
	187
	188	/* Return 0 on success or positive error (to xfs_bulkstat()) */
	189	STATIC int
	190	xfs_bulkstat_one_fmt_compat(
	191	void __user *ubuffer,
	192	int ubsize,
	193	int *ubused,
	194	const xfs_bstat_t *buffer)
	195	{
	196	compat_xfs_bstat_t __user *p32 = ubuffer;
	197
	198	if (ubsize < sizeof(*p32))
	199	return XFS_ERROR(ENOMEM);
	200
	201	if (put_user(buffer->bs_ino, &p32->bs_ino) \|\|
	202	put_user(buffer->bs_mode, &p32->bs_mode) \|\|
	203	put_user(buffer->bs_nlink, &p32->bs_nlink) \|\|
	204	put_user(buffer->bs_uid, &p32->bs_uid) \|\|
	205	put_user(buffer->bs_gid, &p32->bs_gid) \|\|
	206	put_user(buffer->bs_rdev, &p32->bs_rdev) \|\|
	207	put_user(buffer->bs_blksize, &p32->bs_blksize) \|\|
	208	put_user(buffer->bs_size, &p32->bs_size) \|\|
	209	xfs_bstime_store_compat(&p32->bs_atime, &buffer->bs_atime) \|\|
	210	xfs_bstime_store_compat(&p32->bs_mtime, &buffer->bs_mtime) \|\|
	211	xfs_bstime_store_compat(&p32->bs_ctime, &buffer->bs_ctime) \|\|
	212	put_user(buffer->bs_blocks, &p32->bs_blocks) \|\|
	213	put_user(buffer->bs_xflags, &p32->bs_xflags) \|\|
	214	put_user(buffer->bs_extsize, &p32->bs_extsize) \|\|
	215	put_user(buffer->bs_extents, &p32->bs_extents) \|\|
	216	put_user(buffer->bs_gen, &p32->bs_gen) \|\|
	217	put_user(buffer->bs_projid, &p32->bs_projid) \|\|
	218	put_user(buffer->bs_projid_hi, &p32->bs_projid_hi) \|\|
	219	put_user(buffer->bs_dmevmask, &p32->bs_dmevmask) \|\|
	220	put_user(buffer->bs_dmstate, &p32->bs_dmstate) \|\|
	221	put_user(buffer->bs_aextents, &p32->bs_aextents))
	222	return XFS_ERROR(EFAULT);
	223	if (ubused)
	224	ubused = sizeof(p32);
	225	return 0;
	226	}
	227
	228	STATIC int
	229	xfs_bulkstat_one_compat(
	230	xfs_mount_t mp, / mount point for filesystem */
	231	xfs_ino_t ino, /* inode number to get data for */
	232	void __user buffer, / buffer to place output in */
	233	int ubsize, /* size of buffer */
	234	int ubused, / bytes used by me */
	235	int stat) / BULKSTAT_RV_... */
	236	{
	237	return xfs_bulkstat_one_int(mp, ino, buffer, ubsize,
	238	xfs_bulkstat_one_fmt_compat,
	239	ubused, stat);
	240	}
	241
	242	/* copied from xfs_ioctl.c */
	243	STATIC int
	244	xfs_compat_ioc_bulkstat(
	245	xfs_mount_t *mp,
	246	unsigned int cmd,
	247	compat_xfs_fsop_bulkreq_t __user *p32)
	248	{
	249	u32 addr;
	250	xfs_fsop_bulkreq_t bulkreq;
	251	int count; /* # of records returned */
	252	xfs_ino_t inlast; /* last inode number */
	253	int done;
	254	int error;
	255
	256	/* done = 1 if there are more stats to get and if bulkstat */
	257	/* should be called again (unused here, but used in dmapi) */
	258
	259	if (!capable(CAP_SYS_ADMIN))
	260	return -XFS_ERROR(EPERM);
	261
	262	if (XFS_FORCED_SHUTDOWN(mp))
	263	return -XFS_ERROR(EIO);
	264
	265	if (get_user(addr, &p32->lastip))
	266	return -XFS_ERROR(EFAULT);
	267	bulkreq.lastip = compat_ptr(addr);
	268	if (get_user(bulkreq.icount, &p32->icount) \|\|
	269	get_user(addr, &p32->ubuffer))
	270	return -XFS_ERROR(EFAULT);
	271	bulkreq.ubuffer = compat_ptr(addr);
	272	if (get_user(addr, &p32->ocount))
	273	return -XFS_ERROR(EFAULT);
	274	bulkreq.ocount = compat_ptr(addr);
	275
	276	if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
	277	return -XFS_ERROR(EFAULT);
	278
	279	if ((count = bulkreq.icount) <= 0)
	280	return -XFS_ERROR(EINVAL);
	281
	282	if (bulkreq.ubuffer == NULL)
	283	return -XFS_ERROR(EINVAL);
	284
	285	if (cmd == XFS_IOC_FSINUMBERS_32) {
	286	error = xfs_inumbers(mp, &inlast, &count,
	287	bulkreq.ubuffer, xfs_inumbers_fmt_compat);
	288	} else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE_32) {
	289	int res;
	290
	291	error = xfs_bulkstat_one_compat(mp, inlast, bulkreq.ubuffer,
	292	sizeof(compat_xfs_bstat_t), NULL, &res);
	293	} else if (cmd == XFS_IOC_FSBULKSTAT_32) {
	294	error = xfs_bulkstat(mp, &inlast, &count,
	295	xfs_bulkstat_one_compat, sizeof(compat_xfs_bstat_t),
	296	bulkreq.ubuffer, &done);
	297	} else
	298	error = XFS_ERROR(EINVAL);
	299	if (error)
	300	return -error;
	301
	302	if (bulkreq.ocount != NULL) {
	303	if (copy_to_user(bulkreq.lastip, &inlast,
	304	sizeof(xfs_ino_t)))
	305	return -XFS_ERROR(EFAULT);
	306
	307	if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
	308	return -XFS_ERROR(EFAULT);
	309	}
	310
	311	return 0;
	312	}
	313
	314	STATIC int
	315	xfs_compat_handlereq_copyin(
	316	xfs_fsop_handlereq_t *hreq,
	317	compat_xfs_fsop_handlereq_t __user *arg32)
	318	{
	319	compat_xfs_fsop_handlereq_t hreq32;
	320
	321	if (copy_from_user(&hreq32, arg32, sizeof(compat_xfs_fsop_handlereq_t)))
	322	return -XFS_ERROR(EFAULT);
	323
	324	hreq->fd = hreq32.fd;
	325	hreq->path = compat_ptr(hreq32.path);
	326	hreq->oflags = hreq32.oflags;
	327	hreq->ihandle = compat_ptr(hreq32.ihandle);
	328	hreq->ihandlen = hreq32.ihandlen;
	329	hreq->ohandle = compat_ptr(hreq32.ohandle);
	330	hreq->ohandlen = compat_ptr(hreq32.ohandlen);
	331
	332	return 0;
	333	}
	334
	335	STATIC struct dentry *
	336	xfs_compat_handlereq_to_dentry(
	337	struct file *parfilp,
	338	compat_xfs_fsop_handlereq_t *hreq)
	339	{
	340	return xfs_handle_to_dentry(parfilp,
	341	compat_ptr(hreq->ihandle), hreq->ihandlen);
	342	}
	343
	344	STATIC int
	345	xfs_compat_attrlist_by_handle(
	346	struct file *parfilp,
	347	void __user *arg)
	348	{
	349	int error;
	350	attrlist_cursor_kern_t *cursor;
	351	compat_xfs_fsop_attrlist_handlereq_t al_hreq;
	352	struct dentry *dentry;
	353	char *kbuf;
	354
	355	if (!capable(CAP_SYS_ADMIN))
	356	return -XFS_ERROR(EPERM);
	357	if (copy_from_user(&al_hreq, arg,
	358	sizeof(compat_xfs_fsop_attrlist_handlereq_t)))
	359	return -XFS_ERROR(EFAULT);
	360	if (al_hreq.buflen > XATTR_LIST_MAX)
	361	return -XFS_ERROR(EINVAL);
	362
	363	/*
	364	* Reject flags, only allow namespaces.
	365	*/
	366	if (al_hreq.flags & ~(ATTR_ROOT \| ATTR_SECURE))
	367	return -XFS_ERROR(EINVAL);
	368
	369	dentry = xfs_compat_handlereq_to_dentry(parfilp, &al_hreq.hreq);
	370	if (IS_ERR(dentry))
	371	return PTR_ERR(dentry);
	372
	373	error = -ENOMEM;
	374	kbuf = kmem_zalloc(al_hreq.buflen, KM_SLEEP \| KM_MAYFAIL);
	375	if (!kbuf) {
	376	kbuf = kmem_zalloc_large(al_hreq.buflen);
	377	if (!kbuf)
	378	goto out_dput;
	379	}
	380
	381	cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
	382	error = -xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
	383	al_hreq.flags, cursor);
	384	if (error)
	385	goto out_kfree;
	386
	387	if (copy_to_user(compat_ptr(al_hreq.buffer), kbuf, al_hreq.buflen))
	388	error = -EFAULT;
	389
	390	out_kfree:
	391	if (is_vmalloc_addr(kbuf))
	392	kmem_free_large(kbuf);
	393	else
	394	kmem_free(kbuf);
	395	out_dput:
	396	dput(dentry);
	397	return error;
	398	}
	399
	400	STATIC int
	401	xfs_compat_attrmulti_by_handle(
	402	struct file *parfilp,
	403	void __user *arg)
	404	{
	405	int error;
	406	compat_xfs_attr_multiop_t *ops;
	407	compat_xfs_fsop_attrmulti_handlereq_t am_hreq;
	408	struct dentry *dentry;
	409	unsigned int i, size;
	410	unsigned char *attr_name;
	411
	412	if (!capable(CAP_SYS_ADMIN))
	413	return -XFS_ERROR(EPERM);
	414	if (copy_from_user(&am_hreq, arg,
	415	sizeof(compat_xfs_fsop_attrmulti_handlereq_t)))
	416	return -XFS_ERROR(EFAULT);
	417
	418	/* overflow check */
	419	if (am_hreq.opcount >= INT_MAX / sizeof(compat_xfs_attr_multiop_t))
	420	return -E2BIG;
	421
	422	dentry = xfs_compat_handlereq_to_dentry(parfilp, &am_hreq.hreq);
	423	if (IS_ERR(dentry))
	424	return PTR_ERR(dentry);
	425
	426	error = E2BIG;
	427	size = am_hreq.opcount * sizeof(compat_xfs_attr_multiop_t);
	428	if (!size \|\| size > 16 * PAGE_SIZE)
	429	goto out_dput;
	430
	431	ops = memdup_user(compat_ptr(am_hreq.ops), size);
	432	if (IS_ERR(ops)) {
	433	error = PTR_ERR(ops);
	434	goto out_dput;
	435	}
	436
	437	attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
	438	if (!attr_name)
	439	goto out_kfree_ops;
	440
	441	error = 0;
	442	for (i = 0; i < am_hreq.opcount; i++) {
	443	ops[i].am_error = strncpy_from_user((char *)attr_name,
	444	compat_ptr(ops[i].am_attrname),
	445	MAXNAMELEN);
	446	if (ops[i].am_error == 0 \|\| ops[i].am_error == MAXNAMELEN)
	447	error = -ERANGE;
	448	if (ops[i].am_error < 0)
	449	break;
	450
	451	switch (ops[i].am_opcode) {
	452	case ATTR_OP_GET:
	453	ops[i].am_error = xfs_attrmulti_attr_get(
	454	dentry->d_inode, attr_name,
	455	compat_ptr(ops[i].am_attrvalue),
	456	&ops[i].am_length, ops[i].am_flags);
	457	break;
	458	case ATTR_OP_SET:
	459	ops[i].am_error = mnt_want_write_file(parfilp);
	460	if (ops[i].am_error)
	461	break;
	462	ops[i].am_error = xfs_attrmulti_attr_set(
	463	dentry->d_inode, attr_name,
	464	compat_ptr(ops[i].am_attrvalue),
	465	ops[i].am_length, ops[i].am_flags);
	466	mnt_drop_write_file(parfilp);
	467	break;
	468	case ATTR_OP_REMOVE:
	469	ops[i].am_error = mnt_want_write_file(parfilp);
	470	if (ops[i].am_error)
	471	break;
	472	ops[i].am_error = xfs_attrmulti_attr_remove(
	473	dentry->d_inode, attr_name,
	474	ops[i].am_flags);
	475	mnt_drop_write_file(parfilp);
	476	break;
	477	default:
	478	ops[i].am_error = EINVAL;
	479	}
	480	}
	481
	482	if (copy_to_user(compat_ptr(am_hreq.ops), ops, size))
	483	error = XFS_ERROR(EFAULT);
	484
	485	kfree(attr_name);
	486	out_kfree_ops:
	487	kfree(ops);
	488	out_dput:
	489	dput(dentry);
	490	return -error;
	491	}
	492
	493	STATIC int
	494	xfs_compat_fssetdm_by_handle(
	495	struct file *parfilp,
	496	void __user *arg)
	497	{
	498	int error;
	499	struct fsdmidata fsd;
	500	compat_xfs_fsop_setdm_handlereq_t dmhreq;
	501	struct dentry *dentry;
	502
	503	if (!capable(CAP_MKNOD))
	504	return -XFS_ERROR(EPERM);
	505	if (copy_from_user(&dmhreq, arg,
	506	sizeof(compat_xfs_fsop_setdm_handlereq_t)))
	507	return -XFS_ERROR(EFAULT);
	508
	509	dentry = xfs_compat_handlereq_to_dentry(parfilp, &dmhreq.hreq);
	510	if (IS_ERR(dentry))
	511	return PTR_ERR(dentry);
	512
	513	if (IS_IMMUTABLE(dentry->d_inode) \|\| IS_APPEND(dentry->d_inode)) {
	514	error = -XFS_ERROR(EPERM);
	515	goto out;
	516	}
	517
	518	if (copy_from_user(&fsd, compat_ptr(dmhreq.data), sizeof(fsd))) {
	519	error = -XFS_ERROR(EFAULT);
	520	goto out;
	521	}
	522
	523	error = -xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
	524	fsd.fsd_dmstate);
	525
	526	out:
	527	dput(dentry);
	528	return error;
	529	}
	530
	531	long
	532	xfs_file_compat_ioctl(
	533	struct file *filp,
	534	unsigned cmd,
	535	unsigned long p)
	536	{
	537	struct inode *inode = file_inode(filp);
	538	struct xfs_inode *ip = XFS_I(inode);
	539	struct xfs_mount *mp = ip->i_mount;
	540	void __user arg = (void __user )p;
	541	int ioflags = 0;
	542	int error;
	543
	544	if (filp->f_mode & FMODE_NOCMTIME)
	545	ioflags \|= IO_INVIS;
	546
	547	trace_xfs_file_compat_ioctl(ip);
	548
	549	switch (cmd) {
	550	/* No size or alignment issues on any arch */
	551	case XFS_IOC_DIOINFO:
	552	case XFS_IOC_FSGEOMETRY:
	553	case XFS_IOC_FSGETXATTR:
	554	case XFS_IOC_FSSETXATTR:
	555	case XFS_IOC_FSGETXATTRA:
	556	case XFS_IOC_FSSETDM:
	557	case XFS_IOC_GETBMAP:
	558	case XFS_IOC_GETBMAPA:
	559	case XFS_IOC_GETBMAPX:
	560	case XFS_IOC_FSCOUNTS:
	561	case XFS_IOC_SET_RESBLKS:
	562	case XFS_IOC_GET_RESBLKS:
	563	case XFS_IOC_FSGROWFSLOG:
	564	case XFS_IOC_GOINGDOWN:
	565	case XFS_IOC_ERROR_INJECTION:
	566	case XFS_IOC_ERROR_CLEARALL:
	567	return xfs_file_ioctl(filp, cmd, p);
	568	#ifndef BROKEN_X86_ALIGNMENT
	569	/* These are handled fine if no alignment issues */
	570	case XFS_IOC_ALLOCSP:
	571	case XFS_IOC_FREESP:
	572	case XFS_IOC_RESVSP:
	573	case XFS_IOC_UNRESVSP:
	574	case XFS_IOC_ALLOCSP64:
	575	case XFS_IOC_FREESP64:
	576	case XFS_IOC_RESVSP64:
	577	case XFS_IOC_UNRESVSP64:
	578	case XFS_IOC_FSGEOMETRY_V1:
	579	case XFS_IOC_FSGROWFSDATA:
	580	case XFS_IOC_FSGROWFSRT:
	581	case XFS_IOC_ZERO_RANGE:
	582	return xfs_file_ioctl(filp, cmd, p);
	583	#else
	584	case XFS_IOC_ALLOCSP_32:
	585	case XFS_IOC_FREESP_32:
	586	case XFS_IOC_ALLOCSP64_32:
	587	case XFS_IOC_FREESP64_32:
	588	case XFS_IOC_RESVSP_32:
	589	case XFS_IOC_UNRESVSP_32:
	590	case XFS_IOC_RESVSP64_32:
	591	case XFS_IOC_UNRESVSP64_32:
	592	case XFS_IOC_ZERO_RANGE_32: {
	593	struct xfs_flock64 bf;
	594
	595	if (xfs_compat_flock64_copyin(&bf, arg))
	596	return -XFS_ERROR(EFAULT);
	597	cmd = _NATIVE_IOC(cmd, struct xfs_flock64);
	598	return xfs_ioc_space(ip, inode, filp, ioflags, cmd, &bf);
	599	}
	600	case XFS_IOC_FSGEOMETRY_V1_32:
	601	return xfs_compat_ioc_fsgeometry_v1(mp, arg);
	602	case XFS_IOC_FSGROWFSDATA_32: {
	603	struct xfs_growfs_data in;
	604
	605	if (xfs_compat_growfs_data_copyin(&in, arg))
	606	return -XFS_ERROR(EFAULT);
	607	error = mnt_want_write_file(filp);
	608	if (error)
	609	return error;
	610	error = xfs_growfs_data(mp, &in);
	611	mnt_drop_write_file(filp);
	612	return -error;
	613	}
	614	case XFS_IOC_FSGROWFSRT_32: {
	615	struct xfs_growfs_rt in;
	616
	617	if (xfs_compat_growfs_rt_copyin(&in, arg))
	618	return -XFS_ERROR(EFAULT);
	619	error = mnt_want_write_file(filp);
	620	if (error)
	621	return error;
	622	error = xfs_growfs_rt(mp, &in);
	623	mnt_drop_write_file(filp);
	624	return -error;
	625	}
	626	#endif
	627	/* long changes size, but xfs only copiese out 32 bits */
	628	case XFS_IOC_GETXFLAGS_32:
	629	case XFS_IOC_SETXFLAGS_32:
	630	case XFS_IOC_GETVERSION_32:
	631	cmd = _NATIVE_IOC(cmd, long);
	632	return xfs_file_ioctl(filp, cmd, p);
	633	case XFS_IOC_SWAPEXT_32: {
	634	struct xfs_swapext sxp;
	635	struct compat_xfs_swapext __user *sxu = arg;
	636
	637	/* Bulk copy in up to the sx_stat field, then copy bstat */
	638	if (copy_from_user(&sxp, sxu,
	639	offsetof(struct xfs_swapext, sx_stat)) \|\|
	640	xfs_ioctl32_bstat_copyin(&sxp.sx_stat, &sxu->sx_stat))
	641	return -XFS_ERROR(EFAULT);
	642	error = mnt_want_write_file(filp);
	643	if (error)
	644	return error;
	645	error = xfs_ioc_swapext(&sxp);
	646	mnt_drop_write_file(filp);
	647	return -error;
	648	}
	649	case XFS_IOC_FSBULKSTAT_32:
	650	case XFS_IOC_FSBULKSTAT_SINGLE_32:
	651	case XFS_IOC_FSINUMBERS_32:
	652	return xfs_compat_ioc_bulkstat(mp, cmd, arg);
	653	case XFS_IOC_FD_TO_HANDLE_32:
	654	case XFS_IOC_PATH_TO_HANDLE_32:
	655	case XFS_IOC_PATH_TO_FSHANDLE_32: {
	656	struct xfs_fsop_handlereq hreq;
	657
	658	if (xfs_compat_handlereq_copyin(&hreq, arg))
	659	return -XFS_ERROR(EFAULT);
	660	cmd = _NATIVE_IOC(cmd, struct xfs_fsop_handlereq);
	661	return xfs_find_handle(cmd, &hreq);
	662	}
	663	case XFS_IOC_OPEN_BY_HANDLE_32: {
	664	struct xfs_fsop_handlereq hreq;
	665
	666	if (xfs_compat_handlereq_copyin(&hreq, arg))
	667	return -XFS_ERROR(EFAULT);
	668	return xfs_open_by_handle(filp, &hreq);
	669	}
	670	case XFS_IOC_READLINK_BY_HANDLE_32: {
	671	struct xfs_fsop_handlereq hreq;
	672
	673	if (xfs_compat_handlereq_copyin(&hreq, arg))
	674	return -XFS_ERROR(EFAULT);
	675	return xfs_readlink_by_handle(filp, &hreq);
	676	}
	677	case XFS_IOC_ATTRLIST_BY_HANDLE_32:
	678	return xfs_compat_attrlist_by_handle(filp, arg);
	679	case XFS_IOC_ATTRMULTI_BY_HANDLE_32:
	680	return xfs_compat_attrmulti_by_handle(filp, arg);
	681	case XFS_IOC_FSSETDM_BY_HANDLE_32:
	682	return xfs_compat_fssetdm_by_handle(filp, arg);
	683	default:
	684	return -XFS_ERROR(ENOIOCTLCMD);
	685	}
	686	}