unsigned int		cmd,	unsigned long		arg){	int			error;	vnode_t			*vp;	xfs_inode_t		*ip;	xfs_mount_t		*mp;	vp = LINVFS_GET_VP(inode);	vn_trace_entry(vp, "xfs_ioctl", (inst_t *)__return_address);	ip = XFS_BHVTOI(bdp);	mp = ip->i_mount;	switch (cmd) {	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:		/*		 * Only allow the sys admin to reserve space unless		 * unwritten extents are enabled.		 */		if (!XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb) &&		    !capable(CAP_SYS_ADMIN))			return -EPERM;		return xfs_ioc_space(bdp, vp, filp, ioflags, cmd, arg);	case XFS_IOC_DIOINFO: {		struct dioattr	da;		xfs_buftarg_t	*target =			(ip->i_d.di_flags & XFS_DIFLAG_REALTIME) ?			mp->m_rtdev_targp : mp->m_ddev_targp;		da.d_mem = da.d_miniosz = 1 << target->pbr_sshift;		/* The size dio will do in one go */		da.d_maxiosz = 64 * PAGE_CACHE_SIZE;		if (copy_to_user((struct dioattr *)arg, &da, sizeof(da)))			return -XFS_ERROR(EFAULT);		return 0;	}	case XFS_IOC_FSBULKSTAT_SINGLE:	case XFS_IOC_FSBULKSTAT:	case XFS_IOC_FSINUMBERS:		return xfs_ioc_bulkstat(mp, cmd, arg);	case XFS_IOC_FSGEOMETRY_V1:		return xfs_ioc_fsgeometry_v1(mp, arg);	case XFS_IOC_FSGEOMETRY:		return xfs_ioc_fsgeometry(mp, arg);	case XFS_IOC_GETVERSION:	case XFS_IOC_GETXFLAGS:	case XFS_IOC_SETXFLAGS:	case XFS_IOC_FSGETXATTR:	case XFS_IOC_FSSETXATTR:	case XFS_IOC_FSGETXATTRA:		return xfs_ioc_xattr(vp, ip, filp, cmd, arg);	case XFS_IOC_FSSETDM: {		struct fsdmidata	dmi;		if (copy_from_user(&dmi, (struct fsdmidata *)arg, sizeof(dmi)))			return -XFS_ERROR(EFAULT);		error = xfs_set_dmattrs(bdp, dmi.fsd_dmevmask, dmi.fsd_dmstate,							NULL);		return -error;	}	case XFS_IOC_GETBMAP:	case XFS_IOC_GETBMAPA:		return xfs_ioc_getbmap(bdp, filp, ioflags, cmd, arg);	case XFS_IOC_GETBMAPX:		return xfs_ioc_getbmapx(bdp, arg);	case XFS_IOC_FD_TO_HANDLE:	case XFS_IOC_PATH_TO_HANDLE:	case XFS_IOC_PATH_TO_FSHANDLE:		return xfs_find_handle(cmd, arg);	case XFS_IOC_OPEN_BY_HANDLE:		return xfs_open_by_handle(mp, arg, filp, inode);	case XFS_IOC_FSSETDM_BY_HANDLE:		return xfs_fssetdm_by_handle(mp, arg, filp, inode);	case XFS_IOC_READLINK_BY_HANDLE:		return xfs_readlink_by_handle(mp, arg, filp, inode);	case XFS_IOC_ATTRLIST_BY_HANDLE:		return xfs_attrlist_by_handle(mp, arg, filp, inode);	case XFS_IOC_ATTRMULTI_BY_HANDLE:		return xfs_attrmulti_by_handle(mp, arg, filp, inode);	case XFS_IOC_SWAPEXT: {		error = xfs_swapext((struct xfs_swapext *)arg);		return -error;	}	case XFS_IOC_FSCOUNTS: {		xfs_fsop_counts_t out;		error = xfs_fs_counts(mp, &out);		if (error)			return -error;		if (copy_to_user((char *)arg, &out, sizeof(out)))			return -XFS_ERROR(EFAULT);		return 0;	}	case XFS_IOC_SET_RESBLKS: {		xfs_fsop_resblks_t inout;		__uint64_t	   in;		if (!capable(CAP_SYS_ADMIN))			return -EPERM;		if (copy_from_user(&inout, (char *)arg, sizeof(inout)))			return -XFS_ERROR(EFAULT);		/* input parameter is passed in resblks field of structure */		in = inout.resblks;		error = xfs_reserve_blocks(mp, &in, &inout);		if (error)			return -error;		if (copy_to_user((char *)arg, &inout, sizeof(inout)))			return -XFS_ERROR(EFAULT);		return 0;	}	case XFS_IOC_GET_RESBLKS: {		xfs_fsop_resblks_t out;		if (!capable(CAP_SYS_ADMIN))			return -EPERM;		error = xfs_reserve_blocks(mp, NULL, &out);		if (error)			return -error;		if (copy_to_user((char *)arg, &out, sizeof(out)))			return -XFS_ERROR(EFAULT);		return 0;	}	case XFS_IOC_FSGROWFSDATA: {		xfs_growfs_data_t in;		if (!capable(CAP_SYS_ADMIN))			return -EPERM;		if (copy_from_user(&in, (char *)arg, sizeof(in)))			return -XFS_ERROR(EFAULT);		error = xfs_growfs_data(mp, &in);		return -error;	}	case XFS_IOC_FSGROWFSLOG: {		xfs_growfs_log_t in;		if (!capable(CAP_SYS_ADMIN))			return -EPERM;		if (copy_from_user(&in, (char *)arg, sizeof(in)))			return -XFS_ERROR(EFAULT);		error = xfs_growfs_log(mp, &in);		return -error;	}	case XFS_IOC_FSGROWFSRT: {		xfs_growfs_rt_t in;		if (!capable(CAP_SYS_ADMIN))			return -EPERM;		if (copy_from_user(&in, (char *)arg, sizeof(in)))			return -XFS_ERROR(EFAULT);		error = xfs_growfs_rt(mp, &in);		return -error;	}	case XFS_IOC_FREEZE:		if (!capable(CAP_SYS_ADMIN))			return -EPERM;		freeze_bdev(inode->i_sb->s_bdev);		return 0;	case XFS_IOC_THAW:		if (!capable(CAP_SYS_ADMIN))			return -EPERM;		thaw_bdev(inode->i_sb->s_bdev, inode->i_sb);		return 0;	case XFS_IOC_GOINGDOWN: {		__uint32_t in;		if (!capable(CAP_SYS_ADMIN))			return -EPERM;		if (get_user(in, (__uint32_t *)arg))			return -XFS_ERROR(EFAULT);		error = xfs_fs_goingdown(mp, in);		return -error;	}	case XFS_IOC_ERROR_INJECTION: {		xfs_error_injection_t in;		if (!capable(CAP_SYS_ADMIN))			return -EPERM;		if (copy_from_user(&in, (char *)arg, sizeof(in)))			return -XFS_ERROR(EFAULT);		error = xfs_errortag_add(in.errtag, mp);		return -error;	}	case XFS_IOC_ERROR_CLEARALL:		if (!capable(CAP_SYS_ADMIN))			return -EPERM;		error = xfs_errortag_clearall(mp);		return -error;	default:		return -ENOTTY;	}}STATIC intxfs_ioc_space(	bhv_desc_t		*bdp,	vnode_t			*vp,	struct file		*filp,	int			ioflags,	unsigned int		cmd,	unsigned long		arg){	xfs_flock64_t		bf;	int			attr_flags = 0;	int			error;	if (vp->v_inode.i_flags & (S_IMMUTABLE|S_APPEND))		return -XFS_ERROR(EPERM);	if (!(filp->f_flags & FMODE_WRITE))		return -XFS_ERROR(EBADF);	if (vp->v_type != VREG)		return -XFS_ERROR(EINVAL);	if (copy_from_user(&bf, (xfs_flock64_t *)arg, sizeof(bf)))		return -XFS_ERROR(EFAULT);	if (filp->f_flags & (O_NDELAY|O_NONBLOCK))		attr_flags |= ATTR_NONBLOCK;	if (ioflags & IO_INVIS)		attr_flags |= ATTR_DMI;	error = xfs_change_file_space(bdp, cmd, &bf, filp->f_pos,					      NULL, attr_flags);	return -error;}STATIC intxfs_ioc_bulkstat(	xfs_mount_t		*mp,	unsigned int		cmd,	unsigned long		arg){	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 -EPERM;	if (XFS_FORCED_SHUTDOWN(mp))		return -XFS_ERROR(EIO);	if (copy_from_user(&bulkreq, (xfs_fsop_bulkreq_t *)arg,					sizeof(xfs_fsop_bulkreq_t)))		return -XFS_ERROR(EFAULT);	if (copy_from_user(&inlast, (__s64 *)bulkreq.lastip,						sizeof(__s64)))		return -XFS_ERROR(EFAULT);	if ((count = bulkreq.icount) <= 0)		return -XFS_ERROR(EINVAL);	if (cmd == XFS_IOC_FSINUMBERS)		error = xfs_inumbers(mp, &inlast, &count,						bulkreq.ubuffer);	else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)		error = xfs_bulkstat_single(mp, &inlast,						bulkreq.ubuffer, &done);	else {	/* XFS_IOC_FSBULKSTAT */		if (count == 1 && inlast != 0) {			inlast++;			error = xfs_bulkstat_single(mp, &inlast,					bulkreq.ubuffer, &done);		} else {			error = xfs_bulkstat(mp, &inlast, &count,				(bulkstat_one_pf)xfs_bulkstat_one, NULL,				sizeof(xfs_bstat_t), bulkreq.ubuffer,				BULKSTAT_FG_QUICK, &done);		}	}	if (error)		return -error;	if (bulkreq.ocount != NULL) {		if (copy_to_user((xfs_ino_t *)bulkreq.lastip, &inlast,						sizeof(xfs_ino_t)))			return -XFS_ERROR(EFAULT);		if (copy_to_user((__s32 *)bulkreq.ocount, &count,						sizeof(count)))			return -XFS_ERROR(EFAULT);	}	return 0;}STATIC intxfs_ioc_fsgeometry_v1(	xfs_mount_t		*mp,	unsigned long		arg){	xfs_fsop_geom_v1_t	fsgeo;	int			error;	error = xfs_fs_geometry(mp, (xfs_fsop_geom_t *)&fsgeo, 3);	if (error)		return -error;	if (copy_to_user((xfs_fsop_geom_t *)arg, &fsgeo, sizeof(fsgeo)))		return -XFS_ERROR(EFAULT);	return 0;}STATIC intxfs_ioc_fsgeometry(	xfs_mount_t		*mp,	unsigned long		arg){	xfs_fsop_geom_t		fsgeo;	int			error;	error = xfs_fs_geometry(mp, &fsgeo, 4);	if (error)		return -error;	if (copy_to_user((xfs_fsop_geom_t *)arg, &fsgeo, sizeof(fsgeo)))		return -XFS_ERROR(EFAULT);	return 0;}/* * Linux extended inode flags interface. */#define LINUX_XFLAG_SYNC	0x00000008 /* Synchronous updates */#define LINUX_XFLAG_IMMUTABLE	0x00000010 /* Immutable file */#define LINUX_XFLAG_APPEND	0x00000020 /* writes to file may only append */#define LINUX_XFLAG_NODUMP	0x00000040 /* do not dump file */#define LINUX_XFLAG_NOATIME	0x00000080 /* do not update atime */STATIC unsigned intxfs_merge_ioc_xflags(	unsigned int	flags,	unsigned int	start){	unsigned int	xflags = start;	if (flags & LINUX_XFLAG_IMMUTABLE)		xflags |= XFS_XFLAG_IMMUTABLE;	else		xflags &= ~XFS_XFLAG_IMMUTABLE;	if (flags & LINUX_XFLAG_APPEND)		xflags |= XFS_XFLAG_APPEND;	else		xflags &= ~XFS_XFLAG_APPEND;	if (flags & LINUX_XFLAG_SYNC)		xflags |= XFS_XFLAG_SYNC;	else		xflags &= ~XFS_XFLAG_SYNC;	if (flags & LINUX_XFLAG_NOATIME)		xflags |= XFS_XFLAG_NOATIME;	else		xflags &= ~XFS_XFLAG_NOATIME;	if (flags & LINUX_XFLAG_NODUMP)		xflags |= XFS_XFLAG_NODUMP;	else		xflags &= ~XFS_XFLAG_NODUMP;	return xflags;}STATIC unsigned intxfs_di2lxflags(	__uint16_t	di_flags){	unsigned int	flags = 0;	if (di_flags & XFS_DIFLAG_IMMUTABLE)		flags |= LINUX_XFLAG_IMMUTABLE;	if (di_flags & XFS_DIFLAG_APPEND)		flags |= LINUX_XFLAG_APPEND;	if (di_flags & XFS_DIFLAG_SYNC)		flags |= LINUX_XFLAG_SYNC;	if (di_flags & XFS_DIFLAG_NOATIME)		flags |= LINUX_XFLAG_NOATIME;	if (di_flags & XFS_DIFLAG_NODUMP)		flags |= LINUX_XFLAG_NODUMP;	return flags;}STATIC intxfs_ioc_xattr(	vnode_t			*vp,	xfs_inode_t		*ip,	struct file		*filp,	unsigned int		cmd,	unsigned long		arg){	struct fsxattr		fa;	vattr_t			va;	int			error;	int			attr_flags;	unsigned int		flags;	switch (cmd) {	case XFS_IOC_FSGETXATTR: {		va.va_mask = XFS_AT_XFLAGS|XFS_AT_EXTSIZE|XFS_AT_NEXTENTS;		VOP_GETATTR(vp, &va, 0, NULL, error);		if (error)			return -error;		fa.fsx_xflags	= va.va_xflags;		fa.fsx_extsize	= va.va_extsize;		fa.fsx_nextents = va.va_nextents;		if (copy_to_user((struct fsxattr *)arg, &fa, sizeof(fa)))			return -XFS_ERROR(EFAULT);		return 0;	}	case XFS_IOC_FSSETXATTR: {		if (copy_from_user(&fa, (struct fsxattr *)arg, sizeof(fa)))			return -XFS_ERROR(EFAULT);		attr_flags = 0;		if (filp->f_flags & (O_NDELAY|O_NONBLOCK))			attr_flags |= ATTR_NONBLOCK;		va.va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE;		va.va_xflags  = fa.fsx_xflags;		va.va_extsize = fa.fsx_extsize;		VOP_SETATTR(vp, &va, attr_flags, NULL, error);		if (!error)			vn_revalidate(vp);	/* update Linux inode flags */		return -error;	}	case XFS_IOC_FSGETXATTRA: {		va.va_mask = XFS_AT_XFLAGS|XFS_AT_EXTSIZE|XFS_AT_ANEXTENTS;		VOP_GETATTR(vp, &va, 0, NULL, error);		if (error)			return -error;		fa.fsx_xflags	= va.va_xflags;		fa.fsx_extsize	= va.va_extsize;		fa.fsx_nextents = va.va_anextents;		if (copy_to_user((struct fsxattr *)arg, &fa, sizeof(fa)))			return -XFS_ERROR(EFAULT);		return 0;	}	case XFS_IOC_GETXFLAGS: {		flags = xfs_di2lxflags(ip->i_d.di_flags);		if (copy_to_user((unsigned int *)arg, &flags, sizeof(flags)))			return -XFS_ERROR(EFAULT);		return 0;	}	case XFS_IOC_SETXFLAGS: {		if (copy_from_user(&flags, (unsigned int *)arg, sizeof(flags)))			return -XFS_ERROR(EFAULT);		if (flags & ~(LINUX_XFLAG_IMMUTABLE | LINUX_XFLAG_APPEND | \			      LINUX_XFLAG_NOATIME | LINUX_XFLAG_NODUMP | \			      LINUX_XFLAG_SYNC))			return -XFS_ERROR(EOPNOTSUPP);		attr_flags = 0;		if (filp->f_flags & (O_NDELAY|O_NONBLOCK))			attr_flags |= ATTR_NONBLOCK;		va.va_mask = XFS_AT_XFLAGS;		va.va_xflags = xfs_merge_ioc_xflags(flags,				xfs_dic2xflags(&ip->i_d, ARCH_NOCONVERT));		VOP_SETATTR(vp, &va, attr_flags, NULL, error);		if (!error)			vn_revalidate(vp);	/* update Linux inode flags */		return -error;	}	case XFS_IOC_GETVERSION: {		flags = LINVFS_GET_IP(vp)->i_generation;		if (copy_to_user((unsigned int *)arg, &flags, sizeof(flags)))			return -XFS_ERROR(EFAULT);		return 0;	}	default:		return -ENOTTY;	}}STATIC intxfs_ioc_getbmap(	bhv_desc_t		*bdp,	struct file		*filp,	int			ioflags,	unsigned int		cmd,	unsigned long		arg){	struct getbmap		bm;	int			iflags;	int			error;	if (copy_from_user(&bm, (struct getbmap *)arg, sizeof(bm)))		return -XFS_ERROR(EFAULT);	if (bm.bmv_count < 2)		return -XFS_ERROR(EINVAL);	iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);	if (ioflags & IO_INVIS)		iflags |= BMV_IF_NO_DMAPI_READ;	error = xfs_getbmap(bdp, &bm, (struct getbmap *)arg+1, iflags);	if (error)		return -error;	if (copy_to_user((struct getbmap *)arg, &bm, sizeof(bm)))		return -XFS_ERROR(EFAULT);	return 0;}STATIC intxfs_ioc_getbmapx(	bhv_desc_t		*bdp,	unsigned long		arg){	struct getbmapx		bmx;	struct getbmap		bm;	int			iflags;	int			error;	if (copy_from_user(&bmx, (struct getbmapx *)arg, sizeof(bmx)))		return -XFS_ERROR(EFAULT);	if (bmx.bmv_count < 2)		return -XFS_ERROR(EINVAL);	/*	 * Map input getbmapx structure to a getbmap	 * structure for xfs_getbmap.	 */	GETBMAP_CONVERT(bmx, bm);	iflags = bmx.bmv_iflags;	if (iflags & (~BMV_IF_VALID))		return -XFS_ERROR(EINVAL);	iflags |= BMV_IF_EXTENDED;	error = xfs_getbmap(bdp, &bm, (struct getbmapx *)arg+1, iflags);	if (error)		return -error;	GETBMAP_CONVERT(bm, bmx);	if (copy_to_user((struct getbmapx *)arg, &bmx, sizeof(bmx)))		return -XFS_ERROR(EFAULT);	return 0;}