Linux Audio

Check our new training course

Loading...
v3.15
 
   1/*
   2 * Copyright (c) 2000-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 "xfs.h"
  19#include "xfs_fs.h"
  20#include "xfs_shared.h"
  21#include "xfs_format.h"
  22#include "xfs_log_format.h"
  23#include "xfs_trans_resv.h"
  24#include "xfs_sb.h"
  25#include "xfs_ag.h"
  26#include "xfs_mount.h"
  27#include "xfs_inode.h"
  28#include "xfs_ioctl.h"
  29#include "xfs_alloc.h"
  30#include "xfs_rtalloc.h"
 
  31#include "xfs_itable.h"
  32#include "xfs_error.h"
 
 
  33#include "xfs_attr.h"
  34#include "xfs_bmap.h"
  35#include "xfs_bmap_util.h"
  36#include "xfs_fsops.h"
  37#include "xfs_discard.h"
  38#include "xfs_quota.h"
  39#include "xfs_export.h"
  40#include "xfs_trace.h"
  41#include "xfs_icache.h"
  42#include "xfs_symlink.h"
  43#include "xfs_dinode.h"
  44#include "xfs_trans.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  45
  46#include <linux/capability.h>
  47#include <linux/dcache.h>
  48#include <linux/mount.h>
  49#include <linux/namei.h>
  50#include <linux/pagemap.h>
  51#include <linux/slab.h>
  52#include <linux/exportfs.h>
  53
  54/*
  55 * xfs_find_handle maps from userspace xfs_fsop_handlereq structure to
  56 * a file or fs handle.
  57 *
  58 * XFS_IOC_PATH_TO_FSHANDLE
  59 *    returns fs handle for a mount point or path within that mount point
  60 * XFS_IOC_FD_TO_HANDLE
  61 *    returns full handle for a FD opened in user space
  62 * XFS_IOC_PATH_TO_HANDLE
  63 *    returns full handle for a path
  64 */
  65int
  66xfs_find_handle(
  67	unsigned int		cmd,
  68	xfs_fsop_handlereq_t	*hreq)
  69{
  70	int			hsize;
  71	xfs_handle_t		handle;
  72	struct inode		*inode;
  73	struct fd		f = {NULL};
  74	struct path		path;
  75	int			error;
  76	struct xfs_inode	*ip;
  77
  78	if (cmd == XFS_IOC_FD_TO_HANDLE) {
  79		f = fdget(hreq->fd);
  80		if (!f.file)
  81			return -EBADF;
  82		inode = file_inode(f.file);
  83	} else {
  84		error = user_lpath((const char __user *)hreq->path, &path);
  85		if (error)
  86			return error;
  87		inode = path.dentry->d_inode;
  88	}
  89	ip = XFS_I(inode);
  90
  91	/*
  92	 * We can only generate handles for inodes residing on a XFS filesystem,
  93	 * and only for regular files, directories or symbolic links.
  94	 */
  95	error = -EINVAL;
  96	if (inode->i_sb->s_magic != XFS_SB_MAGIC)
  97		goto out_put;
  98
  99	error = -EBADF;
 100	if (!S_ISREG(inode->i_mode) &&
 101	    !S_ISDIR(inode->i_mode) &&
 102	    !S_ISLNK(inode->i_mode))
 103		goto out_put;
 104
 105
 106	memcpy(&handle.ha_fsid, ip->i_mount->m_fixedfsid, sizeof(xfs_fsid_t));
 107
 108	if (cmd == XFS_IOC_PATH_TO_FSHANDLE) {
 109		/*
 110		 * This handle only contains an fsid, zero the rest.
 111		 */
 112		memset(&handle.ha_fid, 0, sizeof(handle.ha_fid));
 113		hsize = sizeof(xfs_fsid_t);
 114	} else {
 115		handle.ha_fid.fid_len = sizeof(xfs_fid_t) -
 116					sizeof(handle.ha_fid.fid_len);
 117		handle.ha_fid.fid_pad = 0;
 118		handle.ha_fid.fid_gen = ip->i_d.di_gen;
 119		handle.ha_fid.fid_ino = ip->i_ino;
 120
 121		hsize = XFS_HSIZE(handle);
 122	}
 123
 124	error = -EFAULT;
 125	if (copy_to_user(hreq->ohandle, &handle, hsize) ||
 126	    copy_to_user(hreq->ohandlen, &hsize, sizeof(__s32)))
 127		goto out_put;
 128
 129	error = 0;
 130
 131 out_put:
 132	if (cmd == XFS_IOC_FD_TO_HANDLE)
 133		fdput(f);
 134	else
 135		path_put(&path);
 136	return error;
 137}
 138
 139/*
 140 * No need to do permission checks on the various pathname components
 141 * as the handle operations are privileged.
 142 */
 143STATIC int
 144xfs_handle_acceptable(
 145	void			*context,
 146	struct dentry		*dentry)
 147{
 148	return 1;
 149}
 150
 151/*
 152 * Convert userspace handle data into a dentry.
 153 */
 154struct dentry *
 155xfs_handle_to_dentry(
 156	struct file		*parfilp,
 157	void __user		*uhandle,
 158	u32			hlen)
 159{
 160	xfs_handle_t		handle;
 161	struct xfs_fid64	fid;
 162
 163	/*
 164	 * Only allow handle opens under a directory.
 165	 */
 166	if (!S_ISDIR(file_inode(parfilp)->i_mode))
 167		return ERR_PTR(-ENOTDIR);
 168
 169	if (hlen != sizeof(xfs_handle_t))
 170		return ERR_PTR(-EINVAL);
 171	if (copy_from_user(&handle, uhandle, hlen))
 172		return ERR_PTR(-EFAULT);
 173	if (handle.ha_fid.fid_len !=
 174	    sizeof(handle.ha_fid) - sizeof(handle.ha_fid.fid_len))
 175		return ERR_PTR(-EINVAL);
 176
 177	memset(&fid, 0, sizeof(struct fid));
 178	fid.ino = handle.ha_fid.fid_ino;
 179	fid.gen = handle.ha_fid.fid_gen;
 180
 181	return exportfs_decode_fh(parfilp->f_path.mnt, (struct fid *)&fid, 3,
 182			FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG,
 183			xfs_handle_acceptable, NULL);
 184}
 185
 186STATIC struct dentry *
 187xfs_handlereq_to_dentry(
 188	struct file		*parfilp,
 189	xfs_fsop_handlereq_t	*hreq)
 190{
 191	return xfs_handle_to_dentry(parfilp, hreq->ihandle, hreq->ihandlen);
 192}
 193
 194int
 195xfs_open_by_handle(
 196	struct file		*parfilp,
 197	xfs_fsop_handlereq_t	*hreq)
 
 198{
 199	const struct cred	*cred = current_cred();
 
 
 
 
 
 
 
 200	int			error;
 201	int			fd;
 202	int			permflag;
 203	struct file		*filp;
 204	struct inode		*inode;
 205	struct dentry		*dentry;
 206	fmode_t			fmode;
 207	struct path		path;
 208
 209	if (!capable(CAP_SYS_ADMIN))
 210		return -XFS_ERROR(EPERM);
 211
 212	dentry = xfs_handlereq_to_dentry(parfilp, hreq);
 213	if (IS_ERR(dentry))
 214		return PTR_ERR(dentry);
 215	inode = dentry->d_inode;
 216
 217	/* Restrict xfs_open_by_handle to directories & regular files. */
 218	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
 219		error = -XFS_ERROR(EPERM);
 220		goto out_dput;
 221	}
 222
 223#if BITS_PER_LONG != 32
 224	hreq->oflags |= O_LARGEFILE;
 225#endif
 226
 227	permflag = hreq->oflags;
 228	fmode = OPEN_FMODE(permflag);
 229	if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&
 230	    (fmode & FMODE_WRITE) && IS_APPEND(inode)) {
 231		error = -XFS_ERROR(EPERM);
 232		goto out_dput;
 233	}
 234
 235	if ((fmode & FMODE_WRITE) && IS_IMMUTABLE(inode)) {
 236		error = -XFS_ERROR(EACCES);
 237		goto out_dput;
 238	}
 239
 240	/* Can't write directories. */
 241	if (S_ISDIR(inode->i_mode) && (fmode & FMODE_WRITE)) {
 242		error = -XFS_ERROR(EISDIR);
 243		goto out_dput;
 244	}
 245
 246	fd = get_unused_fd_flags(0);
 247	if (fd < 0) {
 248		error = fd;
 249		goto out_dput;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 250	}
 251
 252	path.mnt = parfilp->f_path.mnt;
 253	path.dentry = dentry;
 254	filp = dentry_open(&path, hreq->oflags, cred);
 255	dput(dentry);
 256	if (IS_ERR(filp)) {
 257		put_unused_fd(fd);
 258		return PTR_ERR(filp);
 259	}
 260
 261	if (S_ISREG(inode->i_mode)) {
 262		filp->f_flags |= O_NOATIME;
 263		filp->f_mode |= FMODE_NOCMTIME;
 264	}
 265
 266	fd_install(fd, filp);
 267	return fd;
 
 268
 269 out_dput:
 270	dput(dentry);
 271	return error;
 272}
 273
 274int
 275xfs_readlink_by_handle(
 276	struct file		*parfilp,
 277	xfs_fsop_handlereq_t	*hreq)
 278{
 279	struct dentry		*dentry;
 280	__u32			olen;
 281	void			*link;
 282	int			error;
 283
 284	if (!capable(CAP_SYS_ADMIN))
 285		return -XFS_ERROR(EPERM);
 286
 287	dentry = xfs_handlereq_to_dentry(parfilp, hreq);
 288	if (IS_ERR(dentry))
 289		return PTR_ERR(dentry);
 290
 291	/* Restrict this handle operation to symlinks only. */
 292	if (!S_ISLNK(dentry->d_inode->i_mode)) {
 293		error = -XFS_ERROR(EINVAL);
 294		goto out_dput;
 295	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 296
 297	if (copy_from_user(&olen, hreq->ohandlen, sizeof(__u32))) {
 298		error = -XFS_ERROR(EFAULT);
 299		goto out_dput;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 300	}
 301
 302	link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
 303	if (!link) {
 304		error = -XFS_ERROR(ENOMEM);
 305		goto out_dput;
 306	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 307
 308	error = -xfs_readlink(XFS_I(dentry->d_inode), link);
 309	if (error)
 310		goto out_kfree;
 311	error = readlink_copy(hreq->ohandle, olen, link);
 312	if (error)
 313		goto out_kfree;
 314
 315 out_kfree:
 316	kfree(link);
 317 out_dput:
 318	dput(dentry);
 319	return error;
 
 
 
 
 
 
 320}
 321
 322int
 323xfs_set_dmattrs(
 324	xfs_inode_t     *ip,
 325	u_int		evmask,
 326	u_int16_t	state)
 327{
 328	xfs_mount_t	*mp = ip->i_mount;
 329	xfs_trans_t	*tp;
 330	int		error;
 
 
 
 
 
 331
 332	if (!capable(CAP_SYS_ADMIN))
 333		return XFS_ERROR(EPERM);
 334
 335	if (XFS_FORCED_SHUTDOWN(mp))
 336		return XFS_ERROR(EIO);
 
 
 
 337
 338	tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS);
 339	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
 340	if (error) {
 341		xfs_trans_cancel(tp, 0);
 342		return error;
 343	}
 344	xfs_ilock(ip, XFS_ILOCK_EXCL);
 345	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 346
 347	ip->i_d.di_dmevmask = evmask;
 348	ip->i_d.di_dmstate  = state;
 
 349
 350	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 351	error = xfs_trans_commit(tp, 0);
 
 
 352
 353	return error;
 354}
 355
 356STATIC int
 357xfs_fssetdm_by_handle(
 358	struct file		*parfilp,
 359	void			__user *arg)
 360{
 361	int			error;
 362	struct fsdmidata	fsd;
 363	xfs_fsop_setdm_handlereq_t dmhreq;
 364	struct dentry		*dentry;
 365
 366	if (!capable(CAP_MKNOD))
 367		return -XFS_ERROR(EPERM);
 368	if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))
 369		return -XFS_ERROR(EFAULT);
 370
 371	error = mnt_want_write_file(parfilp);
 372	if (error)
 373		return error;
 374
 375	dentry = xfs_handlereq_to_dentry(parfilp, &dmhreq.hreq);
 376	if (IS_ERR(dentry)) {
 377		mnt_drop_write_file(parfilp);
 378		return PTR_ERR(dentry);
 379	}
 380
 381	if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) {
 382		error = -XFS_ERROR(EPERM);
 383		goto out;
 384	}
 385
 386	if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {
 387		error = -XFS_ERROR(EFAULT);
 388		goto out;
 389	}
 390
 391	error = -xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
 392				 fsd.fsd_dmstate);
 393
 394 out:
 395	mnt_drop_write_file(parfilp);
 396	dput(dentry);
 397	return error;
 398}
 399
 
 400STATIC int
 401xfs_attrlist_by_handle(
 402	struct file		*parfilp,
 403	void			__user *arg)
 404{
 405	int			error = -ENOMEM;
 406	attrlist_cursor_kern_t	*cursor;
 407	xfs_fsop_attrlist_handlereq_t al_hreq;
 408	struct dentry		*dentry;
 409	char			*kbuf;
 
 410
 411	if (!capable(CAP_SYS_ADMIN))
 412		return -XFS_ERROR(EPERM);
 413	if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))
 414		return -XFS_ERROR(EFAULT);
 415	if (al_hreq.buflen < sizeof(struct attrlist) ||
 416	    al_hreq.buflen > XATTR_LIST_MAX)
 417		return -XFS_ERROR(EINVAL);
 418
 419	/*
 420	 * Reject flags, only allow namespaces.
 421	 */
 422	if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
 423		return -XFS_ERROR(EINVAL);
 424
 425	dentry = xfs_handlereq_to_dentry(parfilp, &al_hreq.hreq);
 426	if (IS_ERR(dentry))
 427		return PTR_ERR(dentry);
 428
 429	kbuf = kmem_zalloc_large(al_hreq.buflen, KM_SLEEP);
 430	if (!kbuf)
 431		goto out_dput;
 432
 433	cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
 434	error = -xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
 435					al_hreq.flags, cursor);
 436	if (error)
 437		goto out_kfree;
 438
 439	if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))
 440		error = -EFAULT;
 441
 442out_kfree:
 443	kmem_free(kbuf);
 444out_dput:
 445	dput(dentry);
 446	return error;
 447}
 448
 449int
 450xfs_attrmulti_attr_get(
 451	struct inode		*inode,
 452	unsigned char		*name,
 453	unsigned char		__user *ubuf,
 454	__uint32_t		*len,
 455	__uint32_t		flags)
 456{
 457	unsigned char		*kbuf;
 458	int			error = EFAULT;
 459
 460	if (*len > XATTR_SIZE_MAX)
 461		return EINVAL;
 462	kbuf = kmem_zalloc_large(*len, KM_SLEEP);
 463	if (!kbuf)
 464		return ENOMEM;
 465
 466	error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
 467	if (error)
 468		goto out_kfree;
 469
 470	if (copy_to_user(ubuf, kbuf, *len))
 471		error = EFAULT;
 
 
 472
 473out_kfree:
 474	kmem_free(kbuf);
 475	return error;
 476}
 477
 478int
 479xfs_attrmulti_attr_set(
 480	struct inode		*inode,
 481	unsigned char		*name,
 482	const unsigned char	__user *ubuf,
 483	__uint32_t		len,
 484	__uint32_t		flags)
 485{
 486	unsigned char		*kbuf;
 487	int			error = EFAULT;
 488
 489	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 490		return EPERM;
 491	if (len > XATTR_SIZE_MAX)
 492		return EINVAL;
 493
 494	kbuf = memdup_user(ubuf, len);
 495	if (IS_ERR(kbuf))
 496		return PTR_ERR(kbuf);
 497
 498	error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
 499
 500	return error;
 501}
 
 
 
 
 
 
 502
 503int
 504xfs_attrmulti_attr_remove(
 505	struct inode		*inode,
 506	unsigned char		*name,
 507	__uint32_t		flags)
 508{
 509	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 510		return EPERM;
 511	return xfs_attr_remove(XFS_I(inode), name, flags);
 512}
 513
 514STATIC int
 515xfs_attrmulti_by_handle(
 516	struct file		*parfilp,
 517	void			__user *arg)
 518{
 
 
 519	int			error;
 520	xfs_attr_multiop_t	*ops;
 521	xfs_fsop_attrmulti_handlereq_t am_hreq;
 522	struct dentry		*dentry;
 523	unsigned int		i, size;
 524	unsigned char		*attr_name;
 525
 526	if (!capable(CAP_SYS_ADMIN))
 527		return -XFS_ERROR(EPERM);
 528	if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
 529		return -XFS_ERROR(EFAULT);
 530
 531	/* overflow check */
 532	if (am_hreq.opcount >= INT_MAX / sizeof(xfs_attr_multiop_t))
 533		return -E2BIG;
 534
 535	dentry = xfs_handlereq_to_dentry(parfilp, &am_hreq.hreq);
 536	if (IS_ERR(dentry))
 537		return PTR_ERR(dentry);
 538
 539	error = E2BIG;
 540	size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);
 541	if (!size || size > 16 * PAGE_SIZE)
 542		goto out_dput;
 543
 544	ops = memdup_user(am_hreq.ops, size);
 545	if (IS_ERR(ops)) {
 546		error = PTR_ERR(ops);
 547		goto out_dput;
 548	}
 549
 550	attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
 551	if (!attr_name)
 552		goto out_kfree_ops;
 553
 554	error = 0;
 555	for (i = 0; i < am_hreq.opcount; i++) {
 556		ops[i].am_error = strncpy_from_user((char *)attr_name,
 557				ops[i].am_attrname, MAXNAMELEN);
 558		if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
 559			error = -ERANGE;
 560		if (ops[i].am_error < 0)
 561			break;
 562
 563		switch (ops[i].am_opcode) {
 564		case ATTR_OP_GET:
 565			ops[i].am_error = xfs_attrmulti_attr_get(
 566					dentry->d_inode, attr_name,
 567					ops[i].am_attrvalue, &ops[i].am_length,
 568					ops[i].am_flags);
 569			break;
 570		case ATTR_OP_SET:
 571			ops[i].am_error = mnt_want_write_file(parfilp);
 572			if (ops[i].am_error)
 573				break;
 574			ops[i].am_error = xfs_attrmulti_attr_set(
 575					dentry->d_inode, attr_name,
 576					ops[i].am_attrvalue, ops[i].am_length,
 577					ops[i].am_flags);
 578			mnt_drop_write_file(parfilp);
 579			break;
 580		case ATTR_OP_REMOVE:
 581			ops[i].am_error = mnt_want_write_file(parfilp);
 582			if (ops[i].am_error)
 583				break;
 584			ops[i].am_error = xfs_attrmulti_attr_remove(
 585					dentry->d_inode, attr_name,
 586					ops[i].am_flags);
 587			mnt_drop_write_file(parfilp);
 588			break;
 589		default:
 590			ops[i].am_error = EINVAL;
 591		}
 592	}
 593
 594	if (copy_to_user(am_hreq.ops, ops, size))
 595		error = XFS_ERROR(EFAULT);
 
 
 596
 597	kfree(attr_name);
 598 out_kfree_ops:
 599	kfree(ops);
 600 out_dput:
 601	dput(dentry);
 602	return -error;
 603}
 604
 605int
 606xfs_ioc_space(
 607	struct xfs_inode	*ip,
 608	struct inode		*inode,
 609	struct file		*filp,
 610	int			ioflags,
 611	unsigned int		cmd,
 612	xfs_flock64_t		*bf)
 613{
 614	struct xfs_mount	*mp = ip->i_mount;
 615	struct xfs_trans	*tp;
 616	struct iattr		iattr;
 617	bool			setprealloc = false;
 618	bool			clrprealloc = false;
 619	int			error;
 620
 621	/*
 622	 * Only allow the sys admin to reserve space unless
 623	 * unwritten extents are enabled.
 624	 */
 625	if (!xfs_sb_version_hasextflgbit(&ip->i_mount->m_sb) &&
 626	    !capable(CAP_SYS_ADMIN))
 627		return -XFS_ERROR(EPERM);
 628
 629	if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
 630		return -XFS_ERROR(EPERM);
 631
 632	if (!(filp->f_mode & FMODE_WRITE))
 633		return -XFS_ERROR(EBADF);
 634
 635	if (!S_ISREG(inode->i_mode))
 636		return -XFS_ERROR(EINVAL);
 637
 638	error = mnt_want_write_file(filp);
 
 639	if (error)
 640		return error;
 641
 642	xfs_ilock(ip, XFS_IOLOCK_EXCL);
 
 
 
 643
 644	switch (bf->l_whence) {
 645	case 0: /*SEEK_SET*/
 646		break;
 647	case 1: /*SEEK_CUR*/
 648		bf->l_start += filp->f_pos;
 649		break;
 650	case 2: /*SEEK_END*/
 651		bf->l_start += XFS_ISIZE(ip);
 652		break;
 653	default:
 654		error = XFS_ERROR(EINVAL);
 655		goto out_unlock;
 656	}
 657
 658	/*
 659	 * length of <= 0 for resv/unresv/zero is invalid.  length for
 660	 * alloc/free is ignored completely and we have no idea what userspace
 661	 * might have set it to, so set it to zero to allow range
 662	 * checks to pass.
 663	 */
 664	switch (cmd) {
 665	case XFS_IOC_ZERO_RANGE:
 666	case XFS_IOC_RESVSP:
 667	case XFS_IOC_RESVSP64:
 668	case XFS_IOC_UNRESVSP:
 669	case XFS_IOC_UNRESVSP64:
 670		if (bf->l_len <= 0) {
 671			error = XFS_ERROR(EINVAL);
 672			goto out_unlock;
 673		}
 674		break;
 675	default:
 676		bf->l_len = 0;
 677		break;
 678	}
 679
 680	if (bf->l_start < 0 ||
 681	    bf->l_start > mp->m_super->s_maxbytes ||
 682	    bf->l_start + bf->l_len < 0 ||
 683	    bf->l_start + bf->l_len >= mp->m_super->s_maxbytes) {
 684		error = XFS_ERROR(EINVAL);
 685		goto out_unlock;
 686	}
 687
 688	switch (cmd) {
 689	case XFS_IOC_ZERO_RANGE:
 690		error = xfs_zero_file_space(ip, bf->l_start, bf->l_len);
 691		if (!error)
 692			setprealloc = true;
 693		break;
 694	case XFS_IOC_RESVSP:
 695	case XFS_IOC_RESVSP64:
 696		error = xfs_alloc_file_space(ip, bf->l_start, bf->l_len,
 697						XFS_BMAPI_PREALLOC);
 698		if (!error)
 699			setprealloc = true;
 700		break;
 701	case XFS_IOC_UNRESVSP:
 702	case XFS_IOC_UNRESVSP64:
 703		error = xfs_free_file_space(ip, bf->l_start, bf->l_len);
 704		break;
 705	case XFS_IOC_ALLOCSP:
 706	case XFS_IOC_ALLOCSP64:
 707	case XFS_IOC_FREESP:
 708	case XFS_IOC_FREESP64:
 709		if (bf->l_start > XFS_ISIZE(ip)) {
 710			error = xfs_alloc_file_space(ip, XFS_ISIZE(ip),
 711					bf->l_start - XFS_ISIZE(ip), 0);
 712			if (error)
 713				goto out_unlock;
 714		}
 715
 716		iattr.ia_valid = ATTR_SIZE;
 717		iattr.ia_size = bf->l_start;
 718
 719		error = xfs_setattr_size(ip, &iattr);
 720		if (!error)
 721			clrprealloc = true;
 722		break;
 723	default:
 724		ASSERT(0);
 725		error = XFS_ERROR(EINVAL);
 726	}
 727
 728	if (error)
 729		goto out_unlock;
 730
 731	tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID);
 732	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_writeid, 0, 0);
 733	if (error) {
 734		xfs_trans_cancel(tp, 0);
 735		goto out_unlock;
 736	}
 737
 738	xfs_ilock(ip, XFS_ILOCK_EXCL);
 739	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 740
 741	if (!(ioflags & IO_INVIS)) {
 742		ip->i_d.di_mode &= ~S_ISUID;
 743		if (ip->i_d.di_mode & S_IXGRP)
 744			ip->i_d.di_mode &= ~S_ISGID;
 745		xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
 746	}
 747
 748	if (setprealloc)
 749		ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
 750	else if (clrprealloc)
 751		ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
 752
 753	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 754	if (filp->f_flags & O_DSYNC)
 755		xfs_trans_set_sync(tp);
 756	error = xfs_trans_commit(tp, 0);
 757
 758out_unlock:
 759	xfs_iunlock(ip, XFS_IOLOCK_EXCL);
 760	mnt_drop_write_file(filp);
 761	return -error;
 762}
 763
 764STATIC int
 765xfs_ioc_bulkstat(
 766	xfs_mount_t		*mp,
 767	unsigned int		cmd,
 768	void			__user *arg)
 769{
 770	xfs_fsop_bulkreq_t	bulkreq;
 771	int			count;	/* # of records returned */
 772	xfs_ino_t		inlast;	/* last inode number */
 773	int			done;
 774	int			error;
 775
 776	/* done = 1 if there are more stats to get and if bulkstat */
 777	/* should be called again (unused here, but used in dmapi) */
 
 778
 779	if (!capable(CAP_SYS_ADMIN))
 780		return -EPERM;
 781
 782	if (XFS_FORCED_SHUTDOWN(mp))
 783		return -XFS_ERROR(EIO);
 
 
 
 
 784
 785	if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
 786		return -XFS_ERROR(EFAULT);
 787
 788	if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
 789		return -XFS_ERROR(EFAULT);
 
 790
 791	if ((count = bulkreq.icount) <= 0)
 792		return -XFS_ERROR(EINVAL);
 793
 794	if (bulkreq.ubuffer == NULL)
 795		return -XFS_ERROR(EINVAL);
 
 
 
 
 
 
 
 796
 797	if (cmd == XFS_IOC_FSINUMBERS)
 798		error = xfs_inumbers(mp, &inlast, &count,
 799					bulkreq.ubuffer, xfs_inumbers_fmt);
 800	else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
 801		error = xfs_bulkstat_single(mp, &inlast,
 802						bulkreq.ubuffer, &done);
 803	else	/* XFS_IOC_FSBULKSTAT */
 804		error = xfs_bulkstat(mp, &inlast, &count, xfs_bulkstat_one,
 805				     sizeof(xfs_bstat_t), bulkreq.ubuffer,
 806				     &done);
 807
 808	if (error)
 809		return -error;
 
 
 
 
 
 
 
 
 
 810
 811	if (bulkreq.ocount != NULL) {
 812		if (copy_to_user(bulkreq.lastip, &inlast,
 813						sizeof(xfs_ino_t)))
 814			return -XFS_ERROR(EFAULT);
 
 815
 816		if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
 817			return -XFS_ERROR(EFAULT);
 
 818	}
 819
 820	return 0;
 821}
 
 
 822
 823STATIC int
 824xfs_ioc_fsgeometry_v1(
 825	xfs_mount_t		*mp,
 826	void			__user *arg)
 827{
 828	xfs_fsop_geom_t         fsgeo;
 829	int			error;
 830
 831	error = xfs_fs_geometry(mp, &fsgeo, 3);
 832	if (error)
 833		return -error;
 834
 835	/*
 836	 * Caller should have passed an argument of type
 837	 * xfs_fsop_geom_v1_t.  This is a proper subset of the
 838	 * xfs_fsop_geom_t that xfs_fs_geometry() fills in.
 839	 */
 840	if (copy_to_user(arg, &fsgeo, sizeof(xfs_fsop_geom_v1_t)))
 841		return -XFS_ERROR(EFAULT);
 
 
 
 
 842	return 0;
 843}
 844
 845STATIC int
 846xfs_ioc_fsgeometry(
 847	xfs_mount_t		*mp,
 848	void			__user *arg)
 849{
 850	xfs_fsop_geom_t		fsgeo;
 851	int			error;
 852
 853	error = xfs_fs_geometry(mp, &fsgeo, 4);
 854	if (error)
 855		return -error;
 856
 857	if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
 858		return -XFS_ERROR(EFAULT);
 859	return 0;
 
 
 
 
 
 860}
 861
 862/*
 863 * Linux extended inode flags interface.
 
 
 
 864 */
 865
 866STATIC unsigned int
 867xfs_merge_ioc_xflags(
 868	unsigned int	flags,
 869	unsigned int	start)
 870{
 871	unsigned int	xflags = start;
 
 
 872
 873	if (flags & FS_IMMUTABLE_FL)
 874		xflags |= XFS_XFLAG_IMMUTABLE;
 875	else
 876		xflags &= ~XFS_XFLAG_IMMUTABLE;
 877	if (flags & FS_APPEND_FL)
 878		xflags |= XFS_XFLAG_APPEND;
 879	else
 880		xflags &= ~XFS_XFLAG_APPEND;
 881	if (flags & FS_SYNC_FL)
 882		xflags |= XFS_XFLAG_SYNC;
 883	else
 884		xflags &= ~XFS_XFLAG_SYNC;
 885	if (flags & FS_NOATIME_FL)
 886		xflags |= XFS_XFLAG_NOATIME;
 887	else
 888		xflags &= ~XFS_XFLAG_NOATIME;
 889	if (flags & FS_NODUMP_FL)
 890		xflags |= XFS_XFLAG_NODUMP;
 891	else
 892		xflags &= ~XFS_XFLAG_NODUMP;
 893
 894	return xflags;
 895}
 
 
 
 
 
 896
 897STATIC unsigned int
 898xfs_di2lxflags(
 899	__uint16_t	di_flags)
 900{
 901	unsigned int	flags = 0;
 902
 903	if (di_flags & XFS_DIFLAG_IMMUTABLE)
 904		flags |= FS_IMMUTABLE_FL;
 905	if (di_flags & XFS_DIFLAG_APPEND)
 906		flags |= FS_APPEND_FL;
 907	if (di_flags & XFS_DIFLAG_SYNC)
 908		flags |= FS_SYNC_FL;
 909	if (di_flags & XFS_DIFLAG_NOATIME)
 910		flags |= FS_NOATIME_FL;
 911	if (di_flags & XFS_DIFLAG_NODUMP)
 912		flags |= FS_NODUMP_FL;
 913	return flags;
 914}
 915
 916STATIC int
 917xfs_ioc_fsgetxattr(
 918	xfs_inode_t		*ip,
 919	int			attr,
 920	void			__user *arg)
 
 
 
 921{
 922	struct fsxattr		fa;
 
 
 923
 924	memset(&fa, 0, sizeof(struct fsxattr));
 
 925
 926	xfs_ilock(ip, XFS_ILOCK_SHARED);
 927	fa.fsx_xflags = xfs_ip2xflags(ip);
 928	fa.fsx_extsize = ip->i_d.di_extsize << ip->i_mount->m_sb.sb_blocklog;
 929	fa.fsx_projid = xfs_get_projid(ip);
 930
 931	if (attr) {
 932		if (ip->i_afp) {
 933			if (ip->i_afp->if_flags & XFS_IFEXTENTS)
 934				fa.fsx_nextents = ip->i_afp->if_bytes /
 935							sizeof(xfs_bmbt_rec_t);
 936			else
 937				fa.fsx_nextents = ip->i_d.di_anextents;
 938		} else
 939			fa.fsx_nextents = 0;
 940	} else {
 941		if (ip->i_df.if_flags & XFS_IFEXTENTS)
 942			fa.fsx_nextents = ip->i_df.if_bytes /
 943						sizeof(xfs_bmbt_rec_t);
 944		else
 945			fa.fsx_nextents = ip->i_d.di_nextents;
 
 
 946	}
 947	xfs_iunlock(ip, XFS_ILOCK_SHARED);
 948
 949	if (copy_to_user(arg, &fa, sizeof(fa)))
 950		return -EFAULT;
 951	return 0;
 
 952}
 953
 954STATIC void
 955xfs_set_diflags(
 956	struct xfs_inode	*ip,
 957	unsigned int		xflags)
 958{
 959	unsigned int		di_flags;
 
 
 
 960
 961	/* can't set PREALLOC this way, just preserve it */
 962	di_flags = (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC);
 963	if (xflags & XFS_XFLAG_IMMUTABLE)
 964		di_flags |= XFS_DIFLAG_IMMUTABLE;
 965	if (xflags & XFS_XFLAG_APPEND)
 966		di_flags |= XFS_DIFLAG_APPEND;
 967	if (xflags & XFS_XFLAG_SYNC)
 968		di_flags |= XFS_DIFLAG_SYNC;
 969	if (xflags & XFS_XFLAG_NOATIME)
 970		di_flags |= XFS_DIFLAG_NOATIME;
 971	if (xflags & XFS_XFLAG_NODUMP)
 972		di_flags |= XFS_DIFLAG_NODUMP;
 973	if (xflags & XFS_XFLAG_PROJINHERIT)
 974		di_flags |= XFS_DIFLAG_PROJINHERIT;
 975	if (xflags & XFS_XFLAG_NODEFRAG)
 976		di_flags |= XFS_DIFLAG_NODEFRAG;
 977	if (xflags & XFS_XFLAG_FILESTREAM)
 978		di_flags |= XFS_DIFLAG_FILESTREAM;
 979	if (S_ISDIR(ip->i_d.di_mode)) {
 980		if (xflags & XFS_XFLAG_RTINHERIT)
 981			di_flags |= XFS_DIFLAG_RTINHERIT;
 982		if (xflags & XFS_XFLAG_NOSYMLINKS)
 983			di_flags |= XFS_DIFLAG_NOSYMLINKS;
 984		if (xflags & XFS_XFLAG_EXTSZINHERIT)
 985			di_flags |= XFS_DIFLAG_EXTSZINHERIT;
 986	} else if (S_ISREG(ip->i_d.di_mode)) {
 987		if (xflags & XFS_XFLAG_REALTIME)
 988			di_flags |= XFS_DIFLAG_REALTIME;
 989		if (xflags & XFS_XFLAG_EXTSIZE)
 990			di_flags |= XFS_DIFLAG_EXTSIZE;
 991	}
 992
 993	ip->i_d.di_flags = di_flags;
 994}
 995
 996STATIC void
 997xfs_diflags_to_linux(
 998	struct xfs_inode	*ip)
 999{
1000	struct inode		*inode = VFS_I(ip);
1001	unsigned int		xflags = xfs_ip2xflags(ip);
1002
1003	if (xflags & XFS_XFLAG_IMMUTABLE)
1004		inode->i_flags |= S_IMMUTABLE;
1005	else
1006		inode->i_flags &= ~S_IMMUTABLE;
1007	if (xflags & XFS_XFLAG_APPEND)
1008		inode->i_flags |= S_APPEND;
1009	else
1010		inode->i_flags &= ~S_APPEND;
1011	if (xflags & XFS_XFLAG_SYNC)
1012		inode->i_flags |= S_SYNC;
1013	else
1014		inode->i_flags &= ~S_SYNC;
1015	if (xflags & XFS_XFLAG_NOATIME)
1016		inode->i_flags |= S_NOATIME;
1017	else
1018		inode->i_flags &= ~S_NOATIME;
1019}
1020
1021#define FSX_PROJID	1
1022#define FSX_EXTSIZE	2
1023#define FSX_XFLAGS	4
1024#define FSX_NONBLOCK	8
 
 
 
 
 
 
 
 
 
 
1025
1026STATIC int
1027xfs_ioctl_setattr(
1028	xfs_inode_t		*ip,
1029	struct fsxattr		*fa,
1030	int			mask)
1031{
 
1032	struct xfs_mount	*mp = ip->i_mount;
1033	struct xfs_trans	*tp;
1034	unsigned int		lock_flags = 0;
1035	struct xfs_dquot	*udqp = NULL;
1036	struct xfs_dquot	*pdqp = NULL;
1037	struct xfs_dquot	*olddquot = NULL;
1038	int			code;
1039
1040	trace_xfs_ioctl_setattr(ip);
1041
1042	if (mp->m_flags & XFS_MOUNT_RDONLY)
1043		return XFS_ERROR(EROFS);
1044	if (XFS_FORCED_SHUTDOWN(mp))
1045		return XFS_ERROR(EIO);
1046
1047	/*
1048	 * Disallow 32bit project ids when projid32bit feature is not enabled.
1049	 */
1050	if ((mask & FSX_PROJID) && (fa->fsx_projid > (__uint16_t)-1) &&
1051			!xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb))
1052		return XFS_ERROR(EINVAL);
 
 
 
 
1053
1054	/*
1055	 * If disk quotas is on, we make sure that the dquots do exist on disk,
1056	 * before we start any other transactions. Trying to do this later
1057	 * is messy. We don't care to take a readlock to look at the ids
1058	 * in inode here, because we can't hold it across the trans_reserve.
1059	 * If the IDs do change before we take the ilock, we're covered
1060	 * because the i_*dquot fields will get updated anyway.
1061	 */
1062	if (XFS_IS_QUOTA_ON(mp) && (mask & FSX_PROJID)) {
1063		code = xfs_qm_vop_dqalloc(ip, ip->i_d.di_uid,
1064					 ip->i_d.di_gid, fa->fsx_projid,
1065					 XFS_QMOPT_PQUOTA, &udqp, NULL, &pdqp);
1066		if (code)
1067			return code;
1068	}
1069
1070	/*
1071	 * For the other attributes, we acquire the inode lock and
1072	 * first do an error checking pass.
1073	 */
1074	tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
1075	code = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
1076	if (code)
1077		goto error_return;
1078
1079	lock_flags = XFS_ILOCK_EXCL;
1080	xfs_ilock(ip, lock_flags);
1081
1082	/*
1083	 * CAP_FOWNER overrides the following restrictions:
1084	 *
1085	 * The user ID of the calling process must be equal
1086	 * to the file owner ID, except in cases where the
1087	 * CAP_FSETID capability is applicable.
1088	 */
1089	if (!inode_owner_or_capable(VFS_I(ip))) {
1090		code = XFS_ERROR(EPERM);
1091		goto error_return;
1092	}
1093
1094	/*
1095	 * Do a quota reservation only if projid is actually going to change.
1096	 * Only allow changing of projid from init_user_ns since it is a
1097	 * non user namespace aware identifier.
1098	 */
1099	if (mask & FSX_PROJID) {
1100		if (current_user_ns() != &init_user_ns) {
1101			code = XFS_ERROR(EINVAL);
1102			goto error_return;
1103		}
1104
1105		if (XFS_IS_QUOTA_RUNNING(mp) &&
1106		    XFS_IS_PQUOTA_ON(mp) &&
1107		    xfs_get_projid(ip) != fa->fsx_projid) {
1108			ASSERT(tp);
1109			code = xfs_qm_vop_chown_reserve(tp, ip, udqp, NULL,
1110						pdqp, capable(CAP_FOWNER) ?
1111						XFS_QMOPT_FORCE_RES : 0);
1112			if (code)	/* out of quota */
1113				goto error_return;
1114		}
1115	}
1116
1117	if (mask & FSX_EXTSIZE) {
1118		/*
1119		 * Can't change extent size if any extents are allocated.
1120		 */
1121		if (ip->i_d.di_nextents &&
1122		    ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) !=
1123		     fa->fsx_extsize)) {
1124			code = XFS_ERROR(EINVAL);	/* EFBIG? */
1125			goto error_return;
1126		}
1127
1128		/*
1129		 * Extent size must be a multiple of the appropriate block
1130		 * size, if set at all. It must also be smaller than the
1131		 * maximum extent size supported by the filesystem.
1132		 *
1133		 * Also, for non-realtime files, limit the extent size hint to
1134		 * half the size of the AGs in the filesystem so alignment
1135		 * doesn't result in extents larger than an AG.
1136		 */
1137		if (fa->fsx_extsize != 0) {
1138			xfs_extlen_t    size;
1139			xfs_fsblock_t   extsize_fsb;
1140
1141			extsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_extsize);
1142			if (extsize_fsb > MAXEXTLEN) {
1143				code = XFS_ERROR(EINVAL);
1144				goto error_return;
1145			}
1146
1147			if (XFS_IS_REALTIME_INODE(ip) ||
1148			    ((mask & FSX_XFLAGS) &&
1149			    (fa->fsx_xflags & XFS_XFLAG_REALTIME))) {
1150				size = mp->m_sb.sb_rextsize <<
1151				       mp->m_sb.sb_blocklog;
1152			} else {
1153				size = mp->m_sb.sb_blocksize;
1154				if (extsize_fsb > mp->m_sb.sb_agblocks / 2) {
1155					code = XFS_ERROR(EINVAL);
1156					goto error_return;
1157				}
1158			}
1159
1160			if (fa->fsx_extsize % size) {
1161				code = XFS_ERROR(EINVAL);
1162				goto error_return;
1163			}
1164		}
1165	}
1166
 
 
 
1167
1168	if (mask & FSX_XFLAGS) {
1169		/*
1170		 * Can't change realtime flag if any extents are allocated.
1171		 */
1172		if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
1173		    (XFS_IS_REALTIME_INODE(ip)) !=
1174		    (fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
1175			code = XFS_ERROR(EINVAL);	/* EFBIG? */
1176			goto error_return;
1177		}
1178
1179		/*
1180		 * If realtime flag is set then must have realtime data.
1181		 */
1182		if ((fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
1183			if ((mp->m_sb.sb_rblocks == 0) ||
1184			    (mp->m_sb.sb_rextsize == 0) ||
1185			    (ip->i_d.di_extsize % mp->m_sb.sb_rextsize)) {
1186				code = XFS_ERROR(EINVAL);
1187				goto error_return;
1188			}
1189		}
1190
1191		/*
1192		 * Can't modify an immutable/append-only file unless
1193		 * we have appropriate permission.
1194		 */
1195		if ((ip->i_d.di_flags &
1196				(XFS_DIFLAG_IMMUTABLE|XFS_DIFLAG_APPEND) ||
1197		     (fa->fsx_xflags &
1198				(XFS_XFLAG_IMMUTABLE | XFS_XFLAG_APPEND))) &&
1199		    !capable(CAP_LINUX_IMMUTABLE)) {
1200			code = XFS_ERROR(EPERM);
1201			goto error_return;
1202		}
 
1203	}
1204
1205	xfs_trans_ijoin(tp, ip, 0);
1206
1207	/*
1208	 * Change file ownership.  Must be the owner or privileged.
 
 
1209	 */
1210	if (mask & FSX_PROJID) {
1211		/*
1212		 * CAP_FSETID overrides the following restrictions:
1213		 *
1214		 * The set-user-ID and set-group-ID bits of a file will be
1215		 * cleared upon successful return from chown()
1216		 */
1217		if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
1218		    !inode_capable(VFS_I(ip), CAP_FSETID))
1219			ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);
1220
1221		/*
1222		 * Change the ownerships and register quota modifications
1223		 * in the transaction.
1224		 */
1225		if (xfs_get_projid(ip) != fa->fsx_projid) {
1226			if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp)) {
1227				olddquot = xfs_qm_vop_chown(tp, ip,
1228							&ip->i_pdquot, pdqp);
1229			}
1230			xfs_set_projid(ip, fa->fsx_projid);
1231
1232			/*
1233			 * We may have to rev the inode as well as
1234			 * the superblock version number since projids didn't
1235			 * exist before DINODE_VERSION_2 and SB_VERSION_NLINK.
1236			 */
1237			if (ip->i_d.di_version == 1)
1238				xfs_bump_ino_vers2(tp, ip);
1239		}
1240
1241	}
1242
1243	if (mask & FSX_EXTSIZE)
1244		ip->i_d.di_extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;
1245	if (mask & FSX_XFLAGS) {
1246		xfs_set_diflags(ip, fa->fsx_xflags);
1247		xfs_diflags_to_linux(ip);
1248	}
1249
1250	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1251	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1252
1253	XFS_STATS_INC(xs_ig_attrchg);
1254
1255	/*
1256	 * If this is a synchronous mount, make sure that the
1257	 * transaction goes to disk before returning to the user.
1258	 * This is slightly sub-optimal in that truncates require
1259	 * two sync transactions instead of one for wsync filesystems.
1260	 * One for the truncate and one for the timestamps since we
1261	 * don't want to change the timestamps unless we're sure the
1262	 * truncate worked.  Truncates are less than 1% of the laddis
1263	 * mix so this probably isn't worth the trouble to optimize.
1264	 */
1265	if (mp->m_flags & XFS_MOUNT_WSYNC)
1266		xfs_trans_set_sync(tp);
1267	code = xfs_trans_commit(tp, 0);
1268	xfs_iunlock(ip, lock_flags);
1269
1270	/*
1271	 * Release any dquot(s) the inode had kept before chown.
1272	 */
1273	xfs_qm_dqrele(olddquot);
1274	xfs_qm_dqrele(udqp);
1275	xfs_qm_dqrele(pdqp);
1276
1277	return code;
1278
1279 error_return:
1280	xfs_qm_dqrele(udqp);
 
1281	xfs_qm_dqrele(pdqp);
1282	xfs_trans_cancel(tp, 0);
1283	if (lock_flags)
1284		xfs_iunlock(ip, lock_flags);
1285	return code;
1286}
1287
1288STATIC int
1289xfs_ioc_fssetxattr(
1290	xfs_inode_t		*ip,
1291	struct file		*filp,
1292	void			__user *arg)
1293{
1294	struct fsxattr		fa;
1295	unsigned int		mask;
1296	int error;
1297
1298	if (copy_from_user(&fa, arg, sizeof(fa)))
1299		return -EFAULT;
1300
1301	mask = FSX_XFLAGS | FSX_EXTSIZE | FSX_PROJID;
1302	if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1303		mask |= FSX_NONBLOCK;
1304
1305	error = mnt_want_write_file(filp);
1306	if (error)
1307		return error;
1308	error = xfs_ioctl_setattr(ip, &fa, mask);
1309	mnt_drop_write_file(filp);
1310	return -error;
1311}
1312
1313STATIC int
1314xfs_ioc_getxflags(
1315	xfs_inode_t		*ip,
 
1316	void			__user *arg)
1317{
1318	unsigned int		flags;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1319
1320	flags = xfs_di2lxflags(ip->i_d.di_flags);
1321	if (copy_to_user(arg, &flags, sizeof(flags)))
1322		return -EFAULT;
1323	return 0;
1324}
1325
1326STATIC int
1327xfs_ioc_setxflags(
1328	xfs_inode_t		*ip,
1329	struct file		*filp,
1330	void			__user *arg)
1331{
1332	struct fsxattr		fa;
1333	unsigned int		flags;
1334	unsigned int		mask;
1335	int error;
1336
1337	if (copy_from_user(&flags, arg, sizeof(flags)))
1338		return -EFAULT;
1339
1340	if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
1341		      FS_NOATIME_FL | FS_NODUMP_FL | \
1342		      FS_SYNC_FL))
1343		return -EOPNOTSUPP;
1344
1345	mask = FSX_XFLAGS;
1346	if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1347		mask |= FSX_NONBLOCK;
1348	fa.fsx_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip));
1349
1350	error = mnt_want_write_file(filp);
1351	if (error)
1352		return error;
1353	error = xfs_ioctl_setattr(ip, &fa, mask);
1354	mnt_drop_write_file(filp);
1355	return -error;
1356}
1357
1358STATIC int
1359xfs_getbmap_format(void **ap, struct getbmapx *bmv, int *full)
1360{
1361	struct getbmap __user	*base = *ap;
1362
1363	/* copy only getbmap portion (not getbmapx) */
1364	if (copy_to_user(base, bmv, sizeof(struct getbmap)))
1365		return XFS_ERROR(EFAULT);
 
 
1366
1367	*ap += sizeof(struct getbmap);
1368	return 0;
 
 
1369}
1370
1371STATIC int
1372xfs_ioc_getbmap(
1373	struct xfs_inode	*ip,
1374	int			ioflags,
1375	unsigned int		cmd,
1376	void			__user *arg)
1377{
1378	struct getbmapx		bmx;
1379	int			error;
1380
1381	if (copy_from_user(&bmx, arg, sizeof(struct getbmapx)))
1382		return -XFS_ERROR(EFAULT);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1383
1384	if (bmx.bmv_count < 2)
1385		return -XFS_ERROR(EINVAL);
 
 
 
 
 
 
1386
1387	bmx.bmv_iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
1388	if (ioflags & IO_INVIS)
1389		bmx.bmv_iflags |= BMV_IF_NO_DMAPI_READ;
1390
1391	error = xfs_getbmap(ip, &bmx, xfs_getbmap_format,
1392			    (struct getbmap *)arg+1);
1393	if (error)
1394		return -error;
1395
1396	/* copy back header - only size of getbmap */
1397	if (copy_to_user(arg, &bmx, sizeof(struct getbmap)))
1398		return -XFS_ERROR(EFAULT);
1399	return 0;
 
 
 
1400}
1401
1402STATIC int
1403xfs_getbmapx_format(void **ap, struct getbmapx *bmv, int *full)
 
 
1404{
1405	struct getbmapx __user	*base = *ap;
 
1406
1407	if (copy_to_user(base, bmv, sizeof(struct getbmapx)))
1408		return XFS_ERROR(EFAULT);
1409
1410	*ap += sizeof(struct getbmapx);
 
 
 
 
 
 
 
1411	return 0;
1412}
1413
1414STATIC int
1415xfs_ioc_getbmapx(
1416	struct xfs_inode	*ip,
1417	void			__user *arg)
 
1418{
1419	struct getbmapx		bmx;
 
 
1420	int			error;
1421
1422	if (copy_from_user(&bmx, arg, sizeof(bmx)))
1423		return -XFS_ERROR(EFAULT);
 
 
 
 
 
 
 
 
 
 
 
1424
1425	if (bmx.bmv_count < 2)
1426		return -XFS_ERROR(EINVAL);
 
1427
1428	if (bmx.bmv_iflags & (~BMV_IF_VALID))
1429		return -XFS_ERROR(EINVAL);
 
 
1430
1431	error = xfs_getbmap(ip, &bmx, xfs_getbmapx_format,
1432			    (struct getbmapx *)arg+1);
 
 
 
 
 
 
 
 
1433	if (error)
1434		return -error;
 
 
 
 
 
 
 
 
 
 
1435
1436	/* copy back header */
1437	if (copy_to_user(arg, &bmx, sizeof(struct getbmapx)))
1438		return -XFS_ERROR(EFAULT);
 
1439
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1440	return 0;
1441}
1442
1443int
1444xfs_ioc_swapext(
1445	xfs_swapext_t	*sxp)
 
 
1446{
1447	xfs_inode_t     *ip, *tip;
1448	struct fd	f, tmp;
1449	int		error = 0;
1450
1451	/* Pull information for the target fd */
1452	f = fdget((int)sxp->sx_fdtarget);
1453	if (!f.file) {
1454		error = XFS_ERROR(EINVAL);
1455		goto out;
1456	}
1457
1458	if (!(f.file->f_mode & FMODE_WRITE) ||
1459	    !(f.file->f_mode & FMODE_READ) ||
1460	    (f.file->f_flags & O_APPEND)) {
1461		error = XFS_ERROR(EBADF);
1462		goto out_put_file;
1463	}
1464
1465	tmp = fdget((int)sxp->sx_fdtmp);
1466	if (!tmp.file) {
1467		error = XFS_ERROR(EINVAL);
1468		goto out_put_file;
1469	}
1470
1471	if (!(tmp.file->f_mode & FMODE_WRITE) ||
1472	    !(tmp.file->f_mode & FMODE_READ) ||
1473	    (tmp.file->f_flags & O_APPEND)) {
1474		error = XFS_ERROR(EBADF);
1475		goto out_put_tmp_file;
1476	}
1477
1478	if (IS_SWAPFILE(file_inode(f.file)) ||
1479	    IS_SWAPFILE(file_inode(tmp.file))) {
1480		error = XFS_ERROR(EINVAL);
1481		goto out_put_tmp_file;
1482	}
1483
1484	ip = XFS_I(file_inode(f.file));
1485	tip = XFS_I(file_inode(tmp.file));
1486
1487	if (ip->i_mount != tip->i_mount) {
1488		error = XFS_ERROR(EINVAL);
1489		goto out_put_tmp_file;
 
 
 
 
1490	}
1491
1492	if (ip->i_ino == tip->i_ino) {
1493		error = XFS_ERROR(EINVAL);
1494		goto out_put_tmp_file;
1495	}
1496
1497	if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
1498		error = XFS_ERROR(EIO);
1499		goto out_put_tmp_file;
1500	}
1501
1502	error = xfs_swap_extents(ip, tip, sxp);
 
 
 
 
 
 
 
 
 
 
 
1503
1504 out_put_tmp_file:
1505	fdput(tmp);
1506 out_put_file:
1507	fdput(f);
1508 out:
1509	return error;
1510}
1511
1512/*
 
 
 
 
 
 
 
 
 
1513 * Note: some of the ioctl's return positive numbers as a
1514 * byte count indicating success, such as readlink_by_handle.
1515 * So we don't "sign flip" like most other routines.  This means
1516 * true errors need to be returned as a negative value.
1517 */
1518long
1519xfs_file_ioctl(
1520	struct file		*filp,
1521	unsigned int		cmd,
1522	unsigned long		p)
1523{
1524	struct inode		*inode = file_inode(filp);
1525	struct xfs_inode	*ip = XFS_I(inode);
1526	struct xfs_mount	*mp = ip->i_mount;
1527	void			__user *arg = (void __user *)p;
1528	int			ioflags = 0;
1529	int			error;
1530
1531	if (filp->f_mode & FMODE_NOCMTIME)
1532		ioflags |= IO_INVIS;
1533
1534	trace_xfs_file_ioctl(ip);
1535
1536	switch (cmd) {
1537	case FITRIM:
1538		return xfs_ioc_trim(mp, arg);
 
 
 
 
1539	case XFS_IOC_ALLOCSP:
1540	case XFS_IOC_FREESP:
1541	case XFS_IOC_RESVSP:
1542	case XFS_IOC_UNRESVSP:
1543	case XFS_IOC_ALLOCSP64:
1544	case XFS_IOC_FREESP64:
1545	case XFS_IOC_RESVSP64:
1546	case XFS_IOC_UNRESVSP64:
1547	case XFS_IOC_ZERO_RANGE: {
1548		xfs_flock64_t		bf;
1549
1550		if (copy_from_user(&bf, arg, sizeof(bf)))
1551			return -XFS_ERROR(EFAULT);
1552		return xfs_ioc_space(ip, inode, filp, ioflags, cmd, &bf);
1553	}
1554	case XFS_IOC_DIOINFO: {
1555		struct dioattr	da;
1556		xfs_buftarg_t	*target =
1557			XFS_IS_REALTIME_INODE(ip) ?
1558			mp->m_rtdev_targp : mp->m_ddev_targp;
1559
1560		da.d_mem =  da.d_miniosz = target->bt_logical_sectorsize;
1561		da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1562
1563		if (copy_to_user(arg, &da, sizeof(da)))
1564			return -XFS_ERROR(EFAULT);
1565		return 0;
1566	}
1567
1568	case XFS_IOC_FSBULKSTAT_SINGLE:
1569	case XFS_IOC_FSBULKSTAT:
1570	case XFS_IOC_FSINUMBERS:
1571		return xfs_ioc_bulkstat(mp, cmd, arg);
1572
1573	case XFS_IOC_FSGEOMETRY_V1:
1574		return xfs_ioc_fsgeometry_v1(mp, arg);
 
 
1575
 
 
 
 
1576	case XFS_IOC_FSGEOMETRY:
1577		return xfs_ioc_fsgeometry(mp, arg);
 
 
 
 
 
1578
1579	case XFS_IOC_GETVERSION:
1580		return put_user(inode->i_generation, (int __user *)arg);
1581
1582	case XFS_IOC_FSGETXATTR:
1583		return xfs_ioc_fsgetxattr(ip, 0, arg);
1584	case XFS_IOC_FSGETXATTRA:
1585		return xfs_ioc_fsgetxattr(ip, 1, arg);
1586	case XFS_IOC_FSSETXATTR:
1587		return xfs_ioc_fssetxattr(ip, filp, arg);
1588	case XFS_IOC_GETXFLAGS:
1589		return xfs_ioc_getxflags(ip, arg);
1590	case XFS_IOC_SETXFLAGS:
1591		return xfs_ioc_setxflags(ip, filp, arg);
1592
1593	case XFS_IOC_FSSETDM: {
1594		struct fsdmidata	dmi;
1595
1596		if (copy_from_user(&dmi, arg, sizeof(dmi)))
1597			return -XFS_ERROR(EFAULT);
1598
1599		error = mnt_want_write_file(filp);
1600		if (error)
1601			return error;
1602
1603		error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
1604				dmi.fsd_dmstate);
1605		mnt_drop_write_file(filp);
1606		return -error;
1607	}
1608
1609	case XFS_IOC_GETBMAP:
1610	case XFS_IOC_GETBMAPA:
1611		return xfs_ioc_getbmap(ip, ioflags, cmd, arg);
1612
1613	case XFS_IOC_GETBMAPX:
1614		return xfs_ioc_getbmapx(ip, arg);
 
 
 
 
 
 
 
 
1615
1616	case XFS_IOC_FD_TO_HANDLE:
1617	case XFS_IOC_PATH_TO_HANDLE:
1618	case XFS_IOC_PATH_TO_FSHANDLE: {
1619		xfs_fsop_handlereq_t	hreq;
1620
1621		if (copy_from_user(&hreq, arg, sizeof(hreq)))
1622			return -XFS_ERROR(EFAULT);
1623		return xfs_find_handle(cmd, &hreq);
1624	}
1625	case XFS_IOC_OPEN_BY_HANDLE: {
1626		xfs_fsop_handlereq_t	hreq;
1627
1628		if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1629			return -XFS_ERROR(EFAULT);
1630		return xfs_open_by_handle(filp, &hreq);
1631	}
1632	case XFS_IOC_FSSETDM_BY_HANDLE:
1633		return xfs_fssetdm_by_handle(filp, arg);
1634
1635	case XFS_IOC_READLINK_BY_HANDLE: {
1636		xfs_fsop_handlereq_t	hreq;
1637
1638		if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1639			return -XFS_ERROR(EFAULT);
1640		return xfs_readlink_by_handle(filp, &hreq);
1641	}
1642	case XFS_IOC_ATTRLIST_BY_HANDLE:
1643		return xfs_attrlist_by_handle(filp, arg);
1644
1645	case XFS_IOC_ATTRMULTI_BY_HANDLE:
1646		return xfs_attrmulti_by_handle(filp, arg);
1647
1648	case XFS_IOC_SWAPEXT: {
1649		struct xfs_swapext	sxp;
1650
1651		if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
1652			return -XFS_ERROR(EFAULT);
1653		error = mnt_want_write_file(filp);
1654		if (error)
1655			return error;
1656		error = xfs_ioc_swapext(&sxp);
1657		mnt_drop_write_file(filp);
1658		return -error;
1659	}
1660
1661	case XFS_IOC_FSCOUNTS: {
1662		xfs_fsop_counts_t out;
1663
1664		error = xfs_fs_counts(mp, &out);
1665		if (error)
1666			return -error;
1667
1668		if (copy_to_user(arg, &out, sizeof(out)))
1669			return -XFS_ERROR(EFAULT);
1670		return 0;
1671	}
1672
1673	case XFS_IOC_SET_RESBLKS: {
1674		xfs_fsop_resblks_t inout;
1675		__uint64_t	   in;
1676
1677		if (!capable(CAP_SYS_ADMIN))
1678			return -EPERM;
1679
1680		if (mp->m_flags & XFS_MOUNT_RDONLY)
1681			return -XFS_ERROR(EROFS);
1682
1683		if (copy_from_user(&inout, arg, sizeof(inout)))
1684			return -XFS_ERROR(EFAULT);
1685
1686		error = mnt_want_write_file(filp);
1687		if (error)
1688			return error;
1689
1690		/* input parameter is passed in resblks field of structure */
1691		in = inout.resblks;
1692		error = xfs_reserve_blocks(mp, &in, &inout);
1693		mnt_drop_write_file(filp);
1694		if (error)
1695			return -error;
1696
1697		if (copy_to_user(arg, &inout, sizeof(inout)))
1698			return -XFS_ERROR(EFAULT);
1699		return 0;
1700	}
1701
1702	case XFS_IOC_GET_RESBLKS: {
1703		xfs_fsop_resblks_t out;
1704
1705		if (!capable(CAP_SYS_ADMIN))
1706			return -EPERM;
1707
1708		error = xfs_reserve_blocks(mp, NULL, &out);
1709		if (error)
1710			return -error;
1711
1712		if (copy_to_user(arg, &out, sizeof(out)))
1713			return -XFS_ERROR(EFAULT);
1714
1715		return 0;
1716	}
1717
1718	case XFS_IOC_FSGROWFSDATA: {
1719		xfs_growfs_data_t in;
1720
1721		if (copy_from_user(&in, arg, sizeof(in)))
1722			return -XFS_ERROR(EFAULT);
1723
1724		error = mnt_want_write_file(filp);
1725		if (error)
1726			return error;
1727		error = xfs_growfs_data(mp, &in);
1728		mnt_drop_write_file(filp);
1729		return -error;
1730	}
1731
1732	case XFS_IOC_FSGROWFSLOG: {
1733		xfs_growfs_log_t in;
1734
1735		if (copy_from_user(&in, arg, sizeof(in)))
1736			return -XFS_ERROR(EFAULT);
1737
1738		error = mnt_want_write_file(filp);
1739		if (error)
1740			return error;
1741		error = xfs_growfs_log(mp, &in);
1742		mnt_drop_write_file(filp);
1743		return -error;
1744	}
1745
1746	case XFS_IOC_FSGROWFSRT: {
1747		xfs_growfs_rt_t in;
1748
1749		if (copy_from_user(&in, arg, sizeof(in)))
1750			return -XFS_ERROR(EFAULT);
1751
1752		error = mnt_want_write_file(filp);
1753		if (error)
1754			return error;
1755		error = xfs_growfs_rt(mp, &in);
1756		mnt_drop_write_file(filp);
1757		return -error;
1758	}
1759
1760	case XFS_IOC_GOINGDOWN: {
1761		__uint32_t in;
1762
1763		if (!capable(CAP_SYS_ADMIN))
1764			return -EPERM;
1765
1766		if (get_user(in, (__uint32_t __user *)arg))
1767			return -XFS_ERROR(EFAULT);
1768
1769		error = xfs_fs_goingdown(mp, in);
1770		return -error;
1771	}
1772
1773	case XFS_IOC_ERROR_INJECTION: {
1774		xfs_error_injection_t in;
1775
1776		if (!capable(CAP_SYS_ADMIN))
1777			return -EPERM;
1778
1779		if (copy_from_user(&in, arg, sizeof(in)))
1780			return -XFS_ERROR(EFAULT);
1781
1782		error = xfs_errortag_add(in.errtag, mp);
1783		return -error;
1784	}
1785
1786	case XFS_IOC_ERROR_CLEARALL:
1787		if (!capable(CAP_SYS_ADMIN))
1788			return -EPERM;
1789
1790		error = xfs_errortag_clearall(mp, 1);
1791		return -error;
1792
1793	case XFS_IOC_FREE_EOFBLOCKS: {
1794		struct xfs_fs_eofblocks eofb;
1795		struct xfs_eofblocks keofb;
1796
1797		if (!capable(CAP_SYS_ADMIN))
1798			return -EPERM;
1799
1800		if (mp->m_flags & XFS_MOUNT_RDONLY)
1801			return -XFS_ERROR(EROFS);
1802
1803		if (copy_from_user(&eofb, arg, sizeof(eofb)))
1804			return -XFS_ERROR(EFAULT);
1805
1806		error = xfs_fs_eofblocks_from_user(&eofb, &keofb);
1807		if (error)
1808			return -error;
 
 
1809
1810		return -xfs_icache_free_eofblocks(mp, &keofb);
 
 
 
1811	}
 
 
 
 
 
 
 
1812
1813	default:
1814		return -ENOTTY;
1815	}
1816}
v6.13.7
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   4 * All Rights Reserved.
 
 
 
 
 
 
 
 
 
 
 
 
 
   5 */
   6#include "xfs.h"
   7#include "xfs_fs.h"
   8#include "xfs_shared.h"
   9#include "xfs_format.h"
  10#include "xfs_log_format.h"
  11#include "xfs_trans_resv.h"
 
 
  12#include "xfs_mount.h"
  13#include "xfs_inode.h"
 
 
  14#include "xfs_rtalloc.h"
  15#include "xfs_iwalk.h"
  16#include "xfs_itable.h"
  17#include "xfs_error.h"
  18#include "xfs_da_format.h"
  19#include "xfs_da_btree.h"
  20#include "xfs_attr.h"
  21#include "xfs_bmap.h"
  22#include "xfs_bmap_util.h"
  23#include "xfs_fsops.h"
  24#include "xfs_discard.h"
  25#include "xfs_quota.h"
 
  26#include "xfs_trace.h"
  27#include "xfs_icache.h"
 
 
  28#include "xfs_trans.h"
  29#include "xfs_btree.h"
  30#include <linux/fsmap.h>
  31#include "xfs_fsmap.h"
  32#include "scrub/xfs_scrub.h"
  33#include "xfs_sb.h"
  34#include "xfs_ag.h"
  35#include "xfs_health.h"
  36#include "xfs_reflink.h"
  37#include "xfs_ioctl.h"
  38#include "xfs_xattr.h"
  39#include "xfs_rtbitmap.h"
  40#include "xfs_file.h"
  41#include "xfs_exchrange.h"
  42#include "xfs_handle.h"
  43#include "xfs_rtgroup.h"
  44
 
 
  45#include <linux/mount.h>
  46#include <linux/fileattr.h>
 
 
 
  47
  48/* Return 0 on success or positive error */
 
 
 
 
 
 
 
 
 
 
  49int
  50xfs_fsbulkstat_one_fmt(
  51	struct xfs_ibulk		*breq,
  52	const struct xfs_bulkstat	*bstat)
  53{
  54	struct xfs_bstat		bs1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  55
  56	xfs_bulkstat_to_bstat(breq->mp, &bs1, bstat);
  57	if (copy_to_user(breq->ubuffer, &bs1, sizeof(bs1)))
  58		return -EFAULT;
  59	return xfs_ibulk_advance(breq, sizeof(struct xfs_bstat));
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  60}
  61
  62int
  63xfs_fsinumbers_fmt(
  64	struct xfs_ibulk		*breq,
  65	const struct xfs_inumbers	*igrp)
 
 
 
 
  66{
  67	struct xfs_inogrp		ig1;
 
  68
  69	xfs_inumbers_to_inogrp(&ig1, igrp);
  70	if (copy_to_user(breq->ubuffer, &ig1, sizeof(struct xfs_inogrp)))
  71		return -EFAULT;
  72	return xfs_ibulk_advance(breq, sizeof(struct xfs_inogrp));
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  73}
  74
  75STATIC int
  76xfs_ioc_fsbulkstat(
  77	struct file		*file,
  78	unsigned int		cmd,
  79	void			__user *arg)
  80{
  81	struct xfs_mount	*mp = XFS_I(file_inode(file))->i_mount;
  82	struct xfs_fsop_bulkreq	bulkreq;
  83	struct xfs_ibulk	breq = {
  84		.mp		= mp,
  85		.idmap		= file_mnt_idmap(file),
  86		.ocount		= 0,
  87	};
  88	xfs_ino_t		lastino;
  89	int			error;
  90
  91	/* done = 1 if there are more stats to get and if bulkstat */
  92	/* should be called again (unused here, but used in dmapi) */
 
 
 
 
  93
  94	if (!capable(CAP_SYS_ADMIN))
  95		return -EPERM;
  96
  97	if (xfs_is_shutdown(mp))
  98		return -EIO;
 
 
  99
 100	if (copy_from_user(&bulkreq, arg, sizeof(struct xfs_fsop_bulkreq)))
 101		return -EFAULT;
 
 
 
 102
 103	if (copy_from_user(&lastino, bulkreq.lastip, sizeof(__s64)))
 104		return -EFAULT;
 
 105
 106	if (bulkreq.icount <= 0)
 107		return -EINVAL;
 
 
 
 
 
 108
 109	if (bulkreq.ubuffer == NULL)
 110		return -EINVAL;
 
 
 111
 112	breq.ubuffer = bulkreq.ubuffer;
 113	breq.icount = bulkreq.icount;
 
 
 
 114
 115	/*
 116	 * FSBULKSTAT_SINGLE expects that *lastip contains the inode number
 117	 * that we want to stat.  However, FSINUMBERS and FSBULKSTAT expect
 118	 * that *lastip contains either zero or the number of the last inode to
 119	 * be examined by the previous call and return results starting with
 120	 * the next inode after that.  The new bulk request back end functions
 121	 * take the inode to start with, so we have to compute the startino
 122	 * parameter from lastino to maintain correct function.  lastino == 0
 123	 * is a special case because it has traditionally meant "first inode
 124	 * in filesystem".
 125	 */
 126	if (cmd == XFS_IOC_FSINUMBERS) {
 127		breq.startino = lastino ? lastino + 1 : 0;
 128		error = xfs_inumbers(&breq, xfs_fsinumbers_fmt);
 129		lastino = breq.startino - 1;
 130	} else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE) {
 131		breq.startino = lastino;
 132		breq.icount = 1;
 133		error = xfs_bulkstat_one(&breq, xfs_fsbulkstat_one_fmt);
 134	} else {	/* XFS_IOC_FSBULKSTAT */
 135		breq.startino = lastino ? lastino + 1 : 0;
 136		error = xfs_bulkstat(&breq, xfs_fsbulkstat_one_fmt);
 137		lastino = breq.startino - 1;
 138	}
 139
 140	if (error)
 141		return error;
 
 
 
 
 
 
 142
 143	if (bulkreq.lastip != NULL &&
 144	    copy_to_user(bulkreq.lastip, &lastino, sizeof(xfs_ino_t)))
 145		return -EFAULT;
 
 146
 147	if (bulkreq.ocount != NULL &&
 148	    copy_to_user(bulkreq.ocount, &breq.ocount, sizeof(__s32)))
 149		return -EFAULT;
 150
 151	return 0;
 
 
 152}
 153
 154/* Return 0 on success or positive error */
 155static int
 156xfs_bulkstat_fmt(
 157	struct xfs_ibulk		*breq,
 158	const struct xfs_bulkstat	*bstat)
 159{
 160	if (copy_to_user(breq->ubuffer, bstat, sizeof(struct xfs_bulkstat)))
 161		return -EFAULT;
 162	return xfs_ibulk_advance(breq, sizeof(struct xfs_bulkstat));
 163}
 
 
 
 
 
 
 164
 165/*
 166 * Check the incoming bulk request @hdr from userspace and initialize the
 167 * internal @breq bulk request appropriately.  Returns 0 if the bulk request
 168 * should proceed; -ECANCELED if there's nothing to do; or the usual
 169 * negative error code.
 170 */
 171static int
 172xfs_bulk_ireq_setup(
 173	struct xfs_mount	*mp,
 174	const struct xfs_bulk_ireq *hdr,
 175	struct xfs_ibulk	*breq,
 176	void __user		*ubuffer)
 177{
 178	if (hdr->icount == 0 ||
 179	    (hdr->flags & ~XFS_BULK_IREQ_FLAGS_ALL) ||
 180	    memchr_inv(hdr->reserved, 0, sizeof(hdr->reserved)))
 181		return -EINVAL;
 182
 183	breq->startino = hdr->ino;
 184	breq->ubuffer = ubuffer;
 185	breq->icount = hdr->icount;
 186	breq->ocount = 0;
 187	breq->flags = 0;
 188
 189	/*
 190	 * The @ino parameter is a special value, so we must look it up here.
 191	 * We're not allowed to have IREQ_AGNO, and we only return one inode
 192	 * worth of data.
 193	 */
 194	if (hdr->flags & XFS_BULK_IREQ_SPECIAL) {
 195		if (hdr->flags & XFS_BULK_IREQ_AGNO)
 196			return -EINVAL;
 197
 198		switch (hdr->ino) {
 199		case XFS_BULK_IREQ_SPECIAL_ROOT:
 200			breq->startino = mp->m_sb.sb_rootino;
 201			break;
 202		default:
 203			return -EINVAL;
 204		}
 205		breq->icount = 1;
 206	}
 207
 208	/*
 209	 * The IREQ_AGNO flag means that we only want results from a given AG.
 210	 * If @hdr->ino is zero, we start iterating in that AG.  If @hdr->ino is
 211	 * beyond the specified AG then we return no results.
 212	 */
 213	if (hdr->flags & XFS_BULK_IREQ_AGNO) {
 214		if (hdr->agno >= mp->m_sb.sb_agcount)
 215			return -EINVAL;
 216
 217		if (breq->startino == 0)
 218			breq->startino = XFS_AGINO_TO_INO(mp, hdr->agno, 0);
 219		else if (XFS_INO_TO_AGNO(mp, breq->startino) < hdr->agno)
 220			return -EINVAL;
 221
 222		breq->flags |= XFS_IBULK_SAME_AG;
 223
 224		/* Asking for an inode past the end of the AG?  We're done! */
 225		if (XFS_INO_TO_AGNO(mp, breq->startino) > hdr->agno)
 226			return -ECANCELED;
 227	} else if (hdr->agno)
 228		return -EINVAL;
 229
 230	/* Asking for an inode past the end of the FS?  We're done! */
 231	if (XFS_INO_TO_AGNO(mp, breq->startino) >= mp->m_sb.sb_agcount)
 232		return -ECANCELED;
 233
 234	if (hdr->flags & XFS_BULK_IREQ_NREXT64)
 235		breq->flags |= XFS_IBULK_NREXT64;
 236
 237	/* Caller wants to see metadata directories in bulkstat output. */
 238	if (hdr->flags & XFS_BULK_IREQ_METADIR)
 239		breq->flags |= XFS_IBULK_METADIR;
 240
 241	return 0;
 242}
 
 
 
 
 243
 244/*
 245 * Update the userspace bulk request @hdr to reflect the end state of the
 246 * internal bulk request @breq.
 247 */
 248static void
 249xfs_bulk_ireq_teardown(
 250	struct xfs_bulk_ireq	*hdr,
 251	struct xfs_ibulk	*breq)
 252{
 253	hdr->ino = breq->startino;
 254	hdr->ocount = breq->ocount;
 255}
 256
 257/* Handle the v5 bulkstat ioctl. */
 258STATIC int
 259xfs_ioc_bulkstat(
 260	struct file			*file,
 261	unsigned int			cmd,
 262	struct xfs_bulkstat_req __user	*arg)
 263{
 264	struct xfs_mount		*mp = XFS_I(file_inode(file))->i_mount;
 265	struct xfs_bulk_ireq		hdr;
 266	struct xfs_ibulk		breq = {
 267		.mp			= mp,
 268		.idmap			= file_mnt_idmap(file),
 269	};
 270	int				error;
 271
 272	if (!capable(CAP_SYS_ADMIN))
 273		return -EPERM;
 274
 275	if (xfs_is_shutdown(mp))
 276		return -EIO;
 277
 278	if (copy_from_user(&hdr, &arg->hdr, sizeof(hdr)))
 279		return -EFAULT;
 280
 281	error = xfs_bulk_ireq_setup(mp, &hdr, &breq, arg->bulkstat);
 282	if (error == -ECANCELED)
 283		goto out_teardown;
 284	if (error < 0)
 285		return error;
 
 
 
 286
 287	error = xfs_bulkstat(&breq, xfs_bulkstat_fmt);
 288	if (error)
 289		return error;
 290
 291out_teardown:
 292	xfs_bulk_ireq_teardown(&hdr, &breq);
 293	if (copy_to_user(&arg->hdr, &hdr, sizeof(hdr)))
 294		return -EFAULT;
 295
 296	return 0;
 297}
 298
 299STATIC int
 300xfs_inumbers_fmt(
 301	struct xfs_ibulk		*breq,
 302	const struct xfs_inumbers	*igrp)
 303{
 304	if (copy_to_user(breq->ubuffer, igrp, sizeof(struct xfs_inumbers)))
 305		return -EFAULT;
 306	return xfs_ibulk_advance(breq, sizeof(struct xfs_inumbers));
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 307}
 308
 309/* Handle the v5 inumbers ioctl. */
 310STATIC int
 311xfs_ioc_inumbers(
 312	struct xfs_mount		*mp,
 313	unsigned int			cmd,
 314	struct xfs_inumbers_req __user	*arg)
 315{
 316	struct xfs_bulk_ireq		hdr;
 317	struct xfs_ibulk		breq = {
 318		.mp			= mp,
 319	};
 320	int				error;
 321
 322	if (!capable(CAP_SYS_ADMIN))
 323		return -EPERM;
 
 
 
 
 
 
 
 
 
 
 
 324
 325	if (xfs_is_shutdown(mp))
 326		return -EIO;
 
 
 
 
 
 
 
 
 
 
 
 327
 328	if (copy_from_user(&hdr, &arg->hdr, sizeof(hdr)))
 329		return -EFAULT;
 330
 331	if (hdr.flags & XFS_BULK_IREQ_METADIR)
 332		return -EINVAL;
 
 
 
 
 333
 334	error = xfs_bulk_ireq_setup(mp, &hdr, &breq, arg->inumbers);
 335	if (error == -ECANCELED)
 336		goto out_teardown;
 337	if (error < 0)
 338		return error;
 
 
 
 
 
 
 
 
 
 
 
 339
 340	error = xfs_inumbers(&breq, xfs_inumbers_fmt);
 341	if (error)
 342		return error;
 343
 344out_teardown:
 345	xfs_bulk_ireq_teardown(&hdr, &breq);
 346	if (copy_to_user(&arg->hdr, &hdr, sizeof(hdr)))
 347		return -EFAULT;
 348
 349	return 0;
 
 
 350}
 351
 352STATIC int
 353xfs_ioc_fsgeometry(
 354	struct xfs_mount	*mp,
 355	void			__user *arg,
 356	int			struct_version)
 357{
 358	struct xfs_fsop_geom	fsgeo;
 359	size_t			len;
 
 
 
 
 
 
 
 
 
 
 
 360
 361	xfs_fs_geometry(mp, &fsgeo, struct_version);
 362
 363	if (struct_version <= 3)
 364		len = sizeof(struct xfs_fsop_geom_v1);
 365	else if (struct_version == 4)
 366		len = sizeof(struct xfs_fsop_geom_v4);
 367	else {
 368		xfs_fsop_geom_health(mp, &fsgeo);
 369		len = sizeof(fsgeo);
 370	}
 371
 372	if (copy_to_user(arg, &fsgeo, len))
 373		return -EFAULT;
 374	return 0;
 
 
 
 
 
 
 375}
 376
 377STATIC int
 378xfs_ioc_ag_geometry(
 379	struct xfs_mount	*mp,
 380	void			__user *arg)
 381{
 382	struct xfs_perag	*pag;
 383	struct xfs_ag_geometry	ageo;
 384	int			error;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 385
 386	if (copy_from_user(&ageo, arg, sizeof(ageo)))
 387		return -EFAULT;
 388	if (ageo.ag_flags)
 389		return -EINVAL;
 390	if (memchr_inv(&ageo.ag_reserved, 0, sizeof(ageo.ag_reserved)))
 391		return -EINVAL;
 392
 393	pag = xfs_perag_get(mp, ageo.ag_number);
 394	if (!pag)
 395		return -EINVAL;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 396
 397	error = xfs_ag_get_geometry(pag, &ageo);
 398	xfs_perag_put(pag);
 399	if (error)
 400		return error;
 401
 402	if (copy_to_user(arg, &ageo, sizeof(ageo)))
 403		return -EFAULT;
 404	return 0;
 
 
 
 405}
 406
 407STATIC int
 408xfs_ioc_rtgroup_geometry(
 409	struct xfs_mount	*mp,
 410	void			__user *arg)
 
 
 
 
 411{
 412	struct xfs_rtgroup	*rtg;
 413	struct xfs_rtgroup_geometry rgeo;
 
 
 
 414	int			error;
 415
 416	if (copy_from_user(&rgeo, arg, sizeof(rgeo)))
 417		return -EFAULT;
 418	if (rgeo.rg_flags)
 419		return -EINVAL;
 420	if (memchr_inv(&rgeo.rg_reserved, 0, sizeof(rgeo.rg_reserved)))
 421		return -EINVAL;
 422	if (!xfs_has_rtgroups(mp))
 423		return -EINVAL;
 424
 425	rtg = xfs_rtgroup_get(mp, rgeo.rg_number);
 426	if (!rtg)
 427		return -EINVAL;
 
 
 
 
 428
 429	error = xfs_rtgroup_get_geometry(rtg, &rgeo);
 430	xfs_rtgroup_put(rtg);
 431	if (error)
 432		return error;
 433
 434	if (copy_to_user(arg, &rgeo, sizeof(rgeo)))
 435		return -EFAULT;
 436	return 0;
 437}
 438
 439/*
 440 * Linux extended inode flags interface.
 441 */
 
 
 
 
 
 
 
 
 
 
 442
 443static void
 444xfs_fill_fsxattr(
 445	struct xfs_inode	*ip,
 446	int			whichfork,
 447	struct fileattr		*fa)
 448{
 449	struct xfs_mount	*mp = ip->i_mount;
 450	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
 
 
 
 
 
 
 
 
 
 
 
 
 
 451
 452	fileattr_fill_xflags(fa, xfs_ip2xflags(ip));
 
 
 
 
 
 
 453
 454	if (ip->i_diflags & XFS_DIFLAG_EXTSIZE) {
 455		fa->fsx_extsize = XFS_FSB_TO_B(mp, ip->i_extsize);
 456	} else if (ip->i_diflags & XFS_DIFLAG_EXTSZINHERIT) {
 457		/*
 458		 * Don't let a misaligned extent size hint on a directory
 459		 * escape to userspace if it won't pass the setattr checks
 460		 * later.
 461		 */
 462		if ((ip->i_diflags & XFS_DIFLAG_RTINHERIT) &&
 463		    xfs_extlen_to_rtxmod(mp, ip->i_extsize) > 0) {
 464			fa->fsx_xflags &= ~(FS_XFLAG_EXTSIZE |
 465					    FS_XFLAG_EXTSZINHERIT);
 466			fa->fsx_extsize = 0;
 467		} else {
 468			fa->fsx_extsize = XFS_FSB_TO_B(mp, ip->i_extsize);
 
 
 
 
 
 
 
 
 
 
 
 469		}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 470	}
 471
 472	if (ip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE)
 473		fa->fsx_cowextsize = XFS_FSB_TO_B(mp, ip->i_cowextsize);
 474	fa->fsx_projid = ip->i_projid;
 475	if (ifp && !xfs_need_iread_extents(ifp))
 476		fa->fsx_nextents = xfs_iext_count(ifp);
 477	else
 478		fa->fsx_nextents = xfs_ifork_nextents(ifp);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 479}
 480
 481STATIC int
 482xfs_ioc_fsgetxattra(
 483	xfs_inode_t		*ip,
 
 484	void			__user *arg)
 485{
 486	struct fileattr		fa;
 
 
 
 
 487
 488	xfs_ilock(ip, XFS_ILOCK_SHARED);
 489	xfs_fill_fsxattr(ip, XFS_ATTR_FORK, &fa);
 490	xfs_iunlock(ip, XFS_ILOCK_SHARED);
 491
 492	return copy_fsxattr_to_user(&fa, arg);
 493}
 494
 495int
 496xfs_fileattr_get(
 497	struct dentry		*dentry,
 498	struct fileattr		*fa)
 499{
 500	struct xfs_inode	*ip = XFS_I(d_inode(dentry));
 501
 502	if (d_is_special(dentry))
 503		return -ENOTTY;
 504
 505	xfs_ilock(ip, XFS_ILOCK_SHARED);
 506	xfs_fill_fsxattr(ip, XFS_DATA_FORK, fa);
 507	xfs_iunlock(ip, XFS_ILOCK_SHARED);
 508
 509	return 0;
 510}
 511
 512static int
 513xfs_ioctl_setattr_xflags(
 514	struct xfs_trans	*tp,
 515	struct xfs_inode	*ip,
 516	struct fileattr		*fa)
 517{
 518	struct xfs_mount	*mp = ip->i_mount;
 519	bool			rtflag = (fa->fsx_xflags & FS_XFLAG_REALTIME);
 520	uint64_t		i_flags2;
 521
 522	if (rtflag != XFS_IS_REALTIME_INODE(ip)) {
 523		/* Can't change realtime flag if any extents are allocated. */
 524		if (xfs_inode_has_filedata(ip))
 525			return -EINVAL;
 
 
 
 
 
 
 526
 527		/*
 528		 * If S_DAX is enabled on this file, we can only switch the
 529		 * device if both support fsdax.  We can't update S_DAX because
 530		 * there might be other threads walking down the access paths.
 531		 */
 532		if (IS_DAX(VFS_I(ip)) &&
 533		    (mp->m_ddev_targp->bt_daxdev == NULL ||
 534		     (mp->m_rtdev_targp &&
 535		      mp->m_rtdev_targp->bt_daxdev == NULL)))
 536			return -EINVAL;
 537	}
 538
 539	if (rtflag) {
 540		/* If realtime flag is set then must have realtime device */
 541		if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 ||
 542		    xfs_extlen_to_rtxmod(mp, ip->i_extsize))
 543			return -EINVAL;
 544
 545		/* Clear reflink if we are actually able to set the rt flag. */
 546		if (xfs_is_reflink_inode(ip))
 547			ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
 548	}
 549
 550	/* diflags2 only valid for v3 inodes. */
 551	i_flags2 = xfs_flags2diflags2(ip, fa->fsx_xflags);
 552	if (i_flags2 && !xfs_has_v3inodes(mp))
 553		return -EINVAL;
 554
 555	ip->i_diflags = xfs_flags2diflags(ip, fa->fsx_xflags);
 556	ip->i_diflags2 = i_flags2;
 
 
 
 
 
 557
 558	xfs_diflags_to_iflags(ip, false);
 
 
 559
 560	/*
 561	 * Make the stable writes flag match that of the device the inode
 562	 * resides on when flipping the RT flag.
 
 563	 */
 564	if (rtflag != XFS_IS_REALTIME_INODE(ip) && S_ISREG(VFS_I(ip)->i_mode))
 565		xfs_update_stable_writes(ip);
 566
 567	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
 568	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 569	XFS_STATS_INC(mp, xs_ig_attrchg);
 570	return 0;
 571}
 572
 573static void
 574xfs_ioctl_setattr_prepare_dax(
 575	struct xfs_inode	*ip,
 576	struct fileattr		*fa)
 577{
 578	struct xfs_mount	*mp = ip->i_mount;
 579	struct inode            *inode = VFS_I(ip);
 580
 581	if (S_ISDIR(inode->i_mode))
 582		return;
 
 583
 584	if (xfs_has_dax_always(mp) || xfs_has_dax_never(mp))
 585		return;
 586
 587	if (((fa->fsx_xflags & FS_XFLAG_DAX) &&
 588	    !(ip->i_diflags2 & XFS_DIFLAG2_DAX)) ||
 589	    (!(fa->fsx_xflags & FS_XFLAG_DAX) &&
 590	     (ip->i_diflags2 & XFS_DIFLAG2_DAX)))
 591		d_mark_dontcache(inode);
 592}
 593
 594/*
 595 * Set up the transaction structure for the setattr operation, checking that we
 596 * have permission to do so. On success, return a clean transaction and the
 597 * inode locked exclusively ready for further operation specific checks. On
 598 * failure, return an error without modifying or locking the inode.
 599 */
 600static struct xfs_trans *
 601xfs_ioctl_setattr_get_trans(
 602	struct xfs_inode	*ip,
 603	struct xfs_dquot	*pdqp)
 
 604{
 605	struct xfs_mount	*mp = ip->i_mount;
 606	struct xfs_trans	*tp;
 607	int			error = -EROFS;
 608
 609	if (xfs_is_readonly(mp))
 610		goto out_error;
 611	error = -EIO;
 612	if (xfs_is_shutdown(mp))
 613		goto out_error;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 614
 615	error = xfs_trans_alloc_ichange(ip, NULL, NULL, pdqp,
 616			has_capability_noaudit(current, CAP_FOWNER), &tp);
 617	if (error)
 618		goto out_error;
 619
 620	if (xfs_has_wsync(mp))
 621		xfs_trans_set_sync(tp);
 622
 623	return tp;
 624
 625out_error:
 626	return ERR_PTR(error);
 
 
 
 
 
 
 
 
 
 
 
 
 
 627}
 628
 629/*
 630 * Validate a proposed extent size hint.  For regular files, the hint can only
 631 * be changed if no extents are allocated.
 632 */
 633static int
 634xfs_ioctl_setattr_check_extsize(
 635	struct xfs_inode	*ip,
 636	struct fileattr		*fa)
 637{
 638	struct xfs_mount	*mp = ip->i_mount;
 639	xfs_failaddr_t		failaddr;
 640	uint16_t		new_diflags;
 641
 642	if (!fa->fsx_valid)
 643		return 0;
 644
 645	if (S_ISREG(VFS_I(ip)->i_mode) && xfs_inode_has_filedata(ip) &&
 646	    XFS_FSB_TO_B(mp, ip->i_extsize) != fa->fsx_extsize)
 647		return -EINVAL;
 648
 649	if (fa->fsx_extsize & mp->m_blockmask)
 650		return -EINVAL;
 651
 652	new_diflags = xfs_flags2diflags(ip, fa->fsx_xflags);
 653
 654	/*
 655	 * Inode verifiers do not check that the extent size hint is an integer
 656	 * multiple of the rt extent size on a directory with both rtinherit
 657	 * and extszinherit flags set.  Don't let sysadmins misconfigure
 658	 * directories.
 659	 */
 660	if ((new_diflags & XFS_DIFLAG_RTINHERIT) &&
 661	    (new_diflags & XFS_DIFLAG_EXTSZINHERIT)) {
 662		unsigned int	rtextsize_bytes;
 663
 664		rtextsize_bytes = XFS_FSB_TO_B(mp, mp->m_sb.sb_rextsize);
 665		if (fa->fsx_extsize % rtextsize_bytes)
 666			return -EINVAL;
 667	}
 
 668
 669	failaddr = xfs_inode_validate_extsize(ip->i_mount,
 670			XFS_B_TO_FSB(mp, fa->fsx_extsize),
 671			VFS_I(ip)->i_mode, new_diflags);
 672	return failaddr != NULL ? -EINVAL : 0;
 673}
 674
 675static int
 676xfs_ioctl_setattr_check_cowextsize(
 677	struct xfs_inode	*ip,
 678	struct fileattr		*fa)
 679{
 680	struct xfs_mount	*mp = ip->i_mount;
 681	xfs_failaddr_t		failaddr;
 682	uint64_t		new_diflags2;
 683	uint16_t		new_diflags;
 684
 685	if (!fa->fsx_valid)
 686		return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 687
 688	if (fa->fsx_cowextsize & mp->m_blockmask)
 689		return -EINVAL;
 690
 691	new_diflags = xfs_flags2diflags(ip, fa->fsx_xflags);
 692	new_diflags2 = xfs_flags2diflags2(ip, fa->fsx_xflags);
 693
 694	failaddr = xfs_inode_validate_cowextsize(ip->i_mount,
 695			XFS_B_TO_FSB(mp, fa->fsx_cowextsize),
 696			VFS_I(ip)->i_mode, new_diflags, new_diflags2);
 697	return failaddr != NULL ? -EINVAL : 0;
 
 
 
 
 
 
 698}
 699
 700static int
 701xfs_ioctl_setattr_check_projid(
 702	struct xfs_inode	*ip,
 703	struct fileattr		*fa)
 704{
 705	if (!fa->fsx_valid)
 706		return 0;
 707
 708	/* Disallow 32bit project ids if 32bit IDs are not enabled. */
 709	if (fa->fsx_projid > (uint16_t)-1 &&
 710	    !xfs_has_projid32(ip->i_mount))
 711		return -EINVAL;
 712	return 0;
 713}
 714
 715int
 716xfs_fileattr_set(
 717	struct mnt_idmap	*idmap,
 718	struct dentry		*dentry,
 719	struct fileattr		*fa)
 720{
 721	struct xfs_inode	*ip = XFS_I(d_inode(dentry));
 722	struct xfs_mount	*mp = ip->i_mount;
 723	struct xfs_trans	*tp;
 
 
 724	struct xfs_dquot	*pdqp = NULL;
 725	struct xfs_dquot	*olddquot = NULL;
 726	int			error;
 727
 728	trace_xfs_ioctl_setattr(ip);
 729
 730	if (d_is_special(dentry))
 731		return -ENOTTY;
 
 
 732
 733	if (!fa->fsx_valid) {
 734		if (fa->flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL |
 735				  FS_NOATIME_FL | FS_NODUMP_FL |
 736				  FS_SYNC_FL | FS_DAX_FL | FS_PROJINHERIT_FL))
 737			return -EOPNOTSUPP;
 738	}
 739
 740	error = xfs_ioctl_setattr_check_projid(ip, fa);
 741	if (error)
 742		return error;
 743
 744	/*
 745	 * If disk quotas is on, we make sure that the dquots do exist on disk,
 746	 * before we start any other transactions. Trying to do this later
 747	 * is messy. We don't care to take a readlock to look at the ids
 748	 * in inode here, because we can't hold it across the trans_reserve.
 749	 * If the IDs do change before we take the ilock, we're covered
 750	 * because the i_*dquot fields will get updated anyway.
 751	 */
 752	if (fa->fsx_valid && XFS_IS_QUOTA_ON(mp)) {
 753		error = xfs_qm_vop_dqalloc(ip, VFS_I(ip)->i_uid,
 754				VFS_I(ip)->i_gid, fa->fsx_projid,
 755				XFS_QMOPT_PQUOTA, NULL, NULL, &pdqp);
 756		if (error)
 757			return error;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 758	}
 759
 760	xfs_ioctl_setattr_prepare_dax(ip, fa);
 
 
 
 
 
 
 
 
 
 761
 762	tp = xfs_ioctl_setattr_get_trans(ip, pdqp);
 763	if (IS_ERR(tp)) {
 764		error = PTR_ERR(tp);
 765		goto error_free_dquots;
 
 
 
 
 
 
 766	}
 767
 768	error = xfs_ioctl_setattr_check_extsize(ip, fa);
 769	if (error)
 770		goto error_trans_cancel;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 771
 772	error = xfs_ioctl_setattr_check_cowextsize(ip, fa);
 773	if (error)
 774		goto error_trans_cancel;
 775
 776	error = xfs_ioctl_setattr_xflags(tp, ip, fa);
 777	if (error)
 778		goto error_trans_cancel;
 
 
 
 
 
 
 
 779
 780	if (!fa->fsx_valid)
 781		goto skip_xattr;
 782	/*
 783	 * Change file ownership.  Must be the owner or privileged.  CAP_FSETID
 784	 * overrides the following restrictions:
 785	 *
 786	 * The set-user-ID and set-group-ID bits of a file will be cleared upon
 787	 * successful return from chown()
 788	 */
 
 
 789
 790	if ((VFS_I(ip)->i_mode & (S_ISUID|S_ISGID)) &&
 791	    !capable_wrt_inode_uidgid(idmap, VFS_I(ip), CAP_FSETID))
 792		VFS_I(ip)->i_mode &= ~(S_ISUID|S_ISGID);
 793
 794	/* Change the ownerships and register project quota modifications */
 795	if (ip->i_projid != fa->fsx_projid) {
 796		if (XFS_IS_PQUOTA_ON(mp)) {
 797			olddquot = xfs_qm_vop_chown(tp, ip,
 798						&ip->i_pdquot, pdqp);
 
 
 799		}
 800		ip->i_projid = fa->fsx_projid;
 801	}
 802
 
 
 803	/*
 804	 * Only set the extent size hint if we've already determined that the
 805	 * extent size hint should be set on the inode. If no extent size flags
 806	 * are set on the inode then unconditionally clear the extent size hint.
 807	 */
 808	if (ip->i_diflags & (XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT))
 809		ip->i_extsize = XFS_B_TO_FSB(mp, fa->fsx_extsize);
 810	else
 811		ip->i_extsize = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 812
 813	if (xfs_has_v3inodes(mp)) {
 814		if (ip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE)
 815			ip->i_cowextsize = XFS_B_TO_FSB(mp, fa->fsx_cowextsize);
 816		else
 817			ip->i_cowextsize = 0;
 818	}
 819
 820skip_xattr:
 821	error = xfs_trans_commit(tp);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 822
 823	/*
 824	 * Release any dquot(s) the inode had kept before chown.
 825	 */
 826	xfs_qm_dqrele(olddquot);
 
 827	xfs_qm_dqrele(pdqp);
 828
 829	return error;
 830
 831error_trans_cancel:
 832	xfs_trans_cancel(tp);
 833error_free_dquots:
 834	xfs_qm_dqrele(pdqp);
 835	return error;
 
 
 
 836}
 837
 838static bool
 839xfs_getbmap_format(
 840	struct kgetbmap		*p,
 841	struct getbmapx __user	*u,
 842	size_t			recsize)
 843{
 844	if (put_user(p->bmv_offset, &u->bmv_offset) ||
 845	    put_user(p->bmv_block, &u->bmv_block) ||
 846	    put_user(p->bmv_length, &u->bmv_length) ||
 847	    put_user(0, &u->bmv_count) ||
 848	    put_user(0, &u->bmv_entries))
 849		return false;
 850	if (recsize < sizeof(struct getbmapx))
 851		return true;
 852	if (put_user(0, &u->bmv_iflags) ||
 853	    put_user(p->bmv_oflags, &u->bmv_oflags) ||
 854	    put_user(0, &u->bmv_unused1) ||
 855	    put_user(0, &u->bmv_unused2))
 856		return false;
 857	return true;
 
 
 
 858}
 859
 860STATIC int
 861xfs_ioc_getbmap(
 862	struct file		*file,
 863	unsigned int		cmd,
 864	void			__user *arg)
 865{
 866	struct getbmapx		bmx = { 0 };
 867	struct kgetbmap		*buf;
 868	size_t			recsize;
 869	int			error, i;
 870
 871	switch (cmd) {
 872	case XFS_IOC_GETBMAPA:
 873		bmx.bmv_iflags = BMV_IF_ATTRFORK;
 874		fallthrough;
 875	case XFS_IOC_GETBMAP:
 876		/* struct getbmap is a strict subset of struct getbmapx. */
 877		recsize = sizeof(struct getbmap);
 878		break;
 879	case XFS_IOC_GETBMAPX:
 880		recsize = sizeof(struct getbmapx);
 881		break;
 882	default:
 883		return -EINVAL;
 884	}
 885
 886	if (copy_from_user(&bmx, arg, recsize))
 
 887		return -EFAULT;
 
 
 888
 889	if (bmx.bmv_count < 2)
 890		return -EINVAL;
 891	if (bmx.bmv_count >= INT_MAX / recsize)
 892		return -ENOMEM;
 893
 894	buf = kvcalloc(bmx.bmv_count, sizeof(*buf), GFP_KERNEL);
 895	if (!buf)
 896		return -ENOMEM;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 897
 898	error = xfs_getbmap(XFS_I(file_inode(file)), &bmx, buf);
 899	if (error)
 900		goto out_free_buf;
 
 
 
 
 901
 902	error = -EFAULT;
 903	if (copy_to_user(arg, &bmx, recsize))
 904		goto out_free_buf;
 905	arg += recsize;
 906
 907	for (i = 0; i < bmx.bmv_entries; i++) {
 908		if (!xfs_getbmap_format(buf + i, arg, recsize))
 909			goto out_free_buf;
 910		arg += recsize;
 911	}
 912
 913	error = 0;
 914out_free_buf:
 915	kvfree(buf);
 916	return error;
 917}
 918
 919int
 920xfs_ioc_swapext(
 921	xfs_swapext_t	*sxp)
 
 
 
 922{
 923	xfs_inode_t     *ip, *tip;
 
 924
 925	/* Pull information for the target fd */
 926	CLASS(fd, f)((int)sxp->sx_fdtarget);
 927	if (fd_empty(f))
 928		return -EINVAL;
 929
 930	if (!(fd_file(f)->f_mode & FMODE_WRITE) ||
 931	    !(fd_file(f)->f_mode & FMODE_READ) ||
 932	    (fd_file(f)->f_flags & O_APPEND))
 933		return -EBADF;
 934
 935	CLASS(fd, tmp)((int)sxp->sx_fdtmp);
 936	if (fd_empty(tmp))
 937		return -EINVAL;
 938
 939	if (!(fd_file(tmp)->f_mode & FMODE_WRITE) ||
 940	    !(fd_file(tmp)->f_mode & FMODE_READ) ||
 941	    (fd_file(tmp)->f_flags & O_APPEND))
 942		return -EBADF;
 943
 944	if (IS_SWAPFILE(file_inode(fd_file(f))) ||
 945	    IS_SWAPFILE(file_inode(fd_file(tmp))))
 946		return -EINVAL;
 947
 948	/*
 949	 * We need to ensure that the fds passed in point to XFS inodes
 950	 * before we cast and access them as XFS structures as we have no
 951	 * control over what the user passes us here.
 952	 */
 953	if (fd_file(f)->f_op != &xfs_file_operations ||
 954	    fd_file(tmp)->f_op != &xfs_file_operations)
 955		return -EINVAL;
 956
 957	ip = XFS_I(file_inode(fd_file(f)));
 958	tip = XFS_I(file_inode(fd_file(tmp)));
 
 959
 960	if (ip->i_mount != tip->i_mount)
 961		return -EINVAL;
 
 
 962
 963	if (ip->i_ino == tip->i_ino)
 964		return -EINVAL;
 965
 966	if (xfs_is_shutdown(ip->i_mount))
 967		return -EIO;
 968
 969	return xfs_swap_extents(ip, tip, sxp);
 970}
 971
 972static int
 973xfs_ioc_getlabel(
 974	struct xfs_mount	*mp,
 975	char			__user *user_label)
 976{
 977	struct xfs_sb		*sbp = &mp->m_sb;
 978	char			label[XFSLABEL_MAX + 1];
 979
 980	/* Paranoia */
 981	BUILD_BUG_ON(sizeof(sbp->sb_fname) > FSLABEL_MAX);
 982
 983	/* 1 larger than sb_fname, so this ensures a trailing NUL char */
 984	memset(label, 0, sizeof(label));
 985	spin_lock(&mp->m_sb_lock);
 986	strncpy(label, sbp->sb_fname, XFSLABEL_MAX);
 987	spin_unlock(&mp->m_sb_lock);
 988
 989	if (copy_to_user(user_label, label, sizeof(label)))
 990		return -EFAULT;
 991	return 0;
 992}
 993
 994static int
 995xfs_ioc_setlabel(
 996	struct file		*filp,
 997	struct xfs_mount	*mp,
 998	char			__user *newlabel)
 999{
1000	struct xfs_sb		*sbp = &mp->m_sb;
1001	char			label[XFSLABEL_MAX + 1];
1002	size_t			len;
1003	int			error;
1004
1005	if (!capable(CAP_SYS_ADMIN))
1006		return -EPERM;
1007	/*
1008	 * The generic ioctl allows up to FSLABEL_MAX chars, but XFS is much
1009	 * smaller, at 12 bytes.  We copy one more to be sure we find the
1010	 * (required) NULL character to test the incoming label length.
1011	 * NB: The on disk label doesn't need to be null terminated.
1012	 */
1013	if (copy_from_user(label, newlabel, XFSLABEL_MAX + 1))
1014		return -EFAULT;
1015	len = strnlen(label, XFSLABEL_MAX + 1);
1016	if (len > sizeof(sbp->sb_fname))
1017		return -EINVAL;
1018
1019	error = mnt_want_write_file(filp);
1020	if (error)
1021		return error;
1022
1023	spin_lock(&mp->m_sb_lock);
1024	memset(sbp->sb_fname, 0, sizeof(sbp->sb_fname));
1025	memcpy(sbp->sb_fname, label, len);
1026	spin_unlock(&mp->m_sb_lock);
1027
1028	/*
1029	 * Now we do several things to satisfy userspace.
1030	 * In addition to normal logging of the primary superblock, we also
1031	 * immediately write these changes to sector zero for the primary, then
1032	 * update all backup supers (as xfs_db does for a label change), then
1033	 * invalidate the block device page cache.  This is so that any prior
1034	 * buffered reads from userspace (i.e. from blkid) are invalidated,
1035	 * and userspace will see the newly-written label.
1036	 */
1037	error = xfs_sync_sb_buf(mp, true);
1038	if (error)
1039		goto out;
1040	/*
1041	 * growfs also updates backup supers so lock against that.
1042	 */
1043	mutex_lock(&mp->m_growlock);
1044	error = xfs_update_secondary_sbs(mp);
1045	mutex_unlock(&mp->m_growlock);
1046
1047	invalidate_bdev(mp->m_ddev_targp->bt_bdev);
1048	if (xfs_has_rtsb(mp) && mp->m_rtdev_targp)
1049		invalidate_bdev(mp->m_rtdev_targp->bt_bdev);
1050
1051out:
1052	mnt_drop_write_file(filp);
1053	return error;
1054}
1055
1056static inline int
1057xfs_fs_eofblocks_from_user(
1058	struct xfs_fs_eofblocks		*src,
1059	struct xfs_icwalk		*dst)
1060{
1061	if (src->eof_version != XFS_EOFBLOCKS_VERSION)
1062		return -EINVAL;
1063
1064	if (src->eof_flags & ~XFS_EOF_FLAGS_VALID)
1065		return -EINVAL;
1066
1067	if (memchr_inv(&src->pad32, 0, sizeof(src->pad32)) ||
1068	    memchr_inv(src->pad64, 0, sizeof(src->pad64)))
1069		return -EINVAL;
1070
1071	dst->icw_flags = 0;
1072	if (src->eof_flags & XFS_EOF_FLAGS_SYNC)
1073		dst->icw_flags |= XFS_ICWALK_FLAG_SYNC;
1074	if (src->eof_flags & XFS_EOF_FLAGS_UID)
1075		dst->icw_flags |= XFS_ICWALK_FLAG_UID;
1076	if (src->eof_flags & XFS_EOF_FLAGS_GID)
1077		dst->icw_flags |= XFS_ICWALK_FLAG_GID;
1078	if (src->eof_flags & XFS_EOF_FLAGS_PRID)
1079		dst->icw_flags |= XFS_ICWALK_FLAG_PRID;
1080	if (src->eof_flags & XFS_EOF_FLAGS_MINFILESIZE)
1081		dst->icw_flags |= XFS_ICWALK_FLAG_MINFILESIZE;
1082
1083	dst->icw_prid = src->eof_prid;
1084	dst->icw_min_file_size = src->eof_min_file_size;
1085
1086	dst->icw_uid = INVALID_UID;
1087	if (src->eof_flags & XFS_EOF_FLAGS_UID) {
1088		dst->icw_uid = make_kuid(current_user_ns(), src->eof_uid);
1089		if (!uid_valid(dst->icw_uid))
1090			return -EINVAL;
1091	}
1092
1093	dst->icw_gid = INVALID_GID;
1094	if (src->eof_flags & XFS_EOF_FLAGS_GID) {
1095		dst->icw_gid = make_kgid(current_user_ns(), src->eof_gid);
1096		if (!gid_valid(dst->icw_gid))
1097			return -EINVAL;
1098	}
1099	return 0;
1100}
1101
1102static int
1103xfs_ioctl_getset_resblocks(
1104	struct file		*filp,
1105	unsigned int		cmd,
1106	void __user		*arg)
1107{
1108	struct xfs_mount	*mp = XFS_I(file_inode(filp))->i_mount;
1109	struct xfs_fsop_resblks	fsop = { };
1110	int			error;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1111
1112	if (!capable(CAP_SYS_ADMIN))
1113		return -EPERM;
 
 
 
 
1114
1115	if (cmd == XFS_IOC_SET_RESBLKS) {
1116		if (xfs_is_readonly(mp))
1117			return -EROFS;
 
 
1118
1119		if (copy_from_user(&fsop, arg, sizeof(fsop)))
1120			return -EFAULT;
1121
1122		error = mnt_want_write_file(filp);
1123		if (error)
1124			return error;
1125		error = xfs_reserve_blocks(mp, fsop.resblks);
1126		mnt_drop_write_file(filp);
1127		if (error)
1128			return error;
1129	}
1130
1131	spin_lock(&mp->m_sb_lock);
1132	fsop.resblks = mp->m_resblks;
1133	fsop.resblks_avail = mp->m_resblks_avail;
1134	spin_unlock(&mp->m_sb_lock);
1135
1136	if (copy_to_user(arg, &fsop, sizeof(fsop)))
1137		return -EFAULT;
1138	return 0;
1139}
1140
1141static int
1142xfs_ioctl_fs_counts(
1143	struct xfs_mount	*mp,
1144	struct xfs_fsop_counts __user	*uarg)
1145{
1146	struct xfs_fsop_counts	out = {
1147		.allocino = percpu_counter_read_positive(&mp->m_icount),
1148		.freeino  = percpu_counter_read_positive(&mp->m_ifree),
1149		.freedata = percpu_counter_read_positive(&mp->m_fdblocks) -
1150				xfs_fdblocks_unavailable(mp),
1151		.freertx  = percpu_counter_read_positive(&mp->m_frextents),
1152	};
1153
1154	if (copy_to_user(uarg, &out, sizeof(out)))
1155		return -EFAULT;
1156	return 0;
 
 
 
1157}
1158
1159/*
1160 * These long-unused ioctls were removed from the official ioctl API in 5.17,
1161 * but retain these definitions so that we can log warnings about them.
1162 */
1163#define XFS_IOC_ALLOCSP		_IOW ('X', 10, struct xfs_flock64)
1164#define XFS_IOC_FREESP		_IOW ('X', 11, struct xfs_flock64)
1165#define XFS_IOC_ALLOCSP64	_IOW ('X', 36, struct xfs_flock64)
1166#define XFS_IOC_FREESP64	_IOW ('X', 37, struct xfs_flock64)
1167
1168/*
1169 * Note: some of the ioctl's return positive numbers as a
1170 * byte count indicating success, such as readlink_by_handle.
1171 * So we don't "sign flip" like most other routines.  This means
1172 * true errors need to be returned as a negative value.
1173 */
1174long
1175xfs_file_ioctl(
1176	struct file		*filp,
1177	unsigned int		cmd,
1178	unsigned long		p)
1179{
1180	struct inode		*inode = file_inode(filp);
1181	struct xfs_inode	*ip = XFS_I(inode);
1182	struct xfs_mount	*mp = ip->i_mount;
1183	void			__user *arg = (void __user *)p;
 
1184	int			error;
1185
 
 
 
1186	trace_xfs_file_ioctl(ip);
1187
1188	switch (cmd) {
1189	case FITRIM:
1190		return xfs_ioc_trim(mp, arg);
1191	case FS_IOC_GETFSLABEL:
1192		return xfs_ioc_getlabel(mp, arg);
1193	case FS_IOC_SETFSLABEL:
1194		return xfs_ioc_setlabel(filp, mp, arg);
1195	case XFS_IOC_ALLOCSP:
1196	case XFS_IOC_FREESP:
 
 
1197	case XFS_IOC_ALLOCSP64:
1198	case XFS_IOC_FREESP64:
1199		xfs_warn_once(mp,
1200	"%s should use fallocate; XFS_IOC_{ALLOC,FREE}SP ioctl unsupported",
1201				current->comm);
1202		return -ENOTTY;
 
 
 
 
 
1203	case XFS_IOC_DIOINFO: {
1204		struct xfs_buftarg	*target = xfs_inode_buftarg(ip);
1205		struct dioattr		da;
 
 
1206
1207		da.d_mem =  da.d_miniosz = target->bt_logical_sectorsize;
1208		da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1209
1210		if (copy_to_user(arg, &da, sizeof(da)))
1211			return -EFAULT;
1212		return 0;
1213	}
1214
1215	case XFS_IOC_FSBULKSTAT_SINGLE:
1216	case XFS_IOC_FSBULKSTAT:
1217	case XFS_IOC_FSINUMBERS:
1218		return xfs_ioc_fsbulkstat(filp, cmd, arg);
1219
1220	case XFS_IOC_BULKSTAT:
1221		return xfs_ioc_bulkstat(filp, cmd, arg);
1222	case XFS_IOC_INUMBERS:
1223		return xfs_ioc_inumbers(mp, cmd, arg);
1224
1225	case XFS_IOC_FSGEOMETRY_V1:
1226		return xfs_ioc_fsgeometry(mp, arg, 3);
1227	case XFS_IOC_FSGEOMETRY_V4:
1228		return xfs_ioc_fsgeometry(mp, arg, 4);
1229	case XFS_IOC_FSGEOMETRY:
1230		return xfs_ioc_fsgeometry(mp, arg, 5);
1231
1232	case XFS_IOC_AG_GEOMETRY:
1233		return xfs_ioc_ag_geometry(mp, arg);
1234	case XFS_IOC_RTGROUP_GEOMETRY:
1235		return xfs_ioc_rtgroup_geometry(mp, arg);
1236
1237	case XFS_IOC_GETVERSION:
1238		return put_user(inode->i_generation, (int __user *)arg);
1239
 
 
1240	case XFS_IOC_FSGETXATTRA:
1241		return xfs_ioc_fsgetxattra(ip, arg);
1242	case XFS_IOC_GETPARENTS:
1243		return xfs_ioc_getparents(filp, arg);
1244	case XFS_IOC_GETPARENTS_BY_HANDLE:
1245		return xfs_ioc_getparents_by_handle(filp, arg);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1246	case XFS_IOC_GETBMAP:
1247	case XFS_IOC_GETBMAPA:
 
 
1248	case XFS_IOC_GETBMAPX:
1249		return xfs_ioc_getbmap(filp, cmd, arg);
1250
1251	case FS_IOC_GETFSMAP:
1252		return xfs_ioc_getfsmap(ip, arg);
1253
1254	case XFS_IOC_SCRUBV_METADATA:
1255		return xfs_ioc_scrubv_metadata(filp, arg);
1256	case XFS_IOC_SCRUB_METADATA:
1257		return xfs_ioc_scrub_metadata(filp, arg);
1258
1259	case XFS_IOC_FD_TO_HANDLE:
1260	case XFS_IOC_PATH_TO_HANDLE:
1261	case XFS_IOC_PATH_TO_FSHANDLE: {
1262		xfs_fsop_handlereq_t	hreq;
1263
1264		if (copy_from_user(&hreq, arg, sizeof(hreq)))
1265			return -EFAULT;
1266		return xfs_find_handle(cmd, &hreq);
1267	}
1268	case XFS_IOC_OPEN_BY_HANDLE: {
1269		xfs_fsop_handlereq_t	hreq;
1270
1271		if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1272			return -EFAULT;
1273		return xfs_open_by_handle(filp, &hreq);
1274	}
 
 
1275
1276	case XFS_IOC_READLINK_BY_HANDLE: {
1277		xfs_fsop_handlereq_t	hreq;
1278
1279		if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1280			return -EFAULT;
1281		return xfs_readlink_by_handle(filp, &hreq);
1282	}
1283	case XFS_IOC_ATTRLIST_BY_HANDLE:
1284		return xfs_attrlist_by_handle(filp, arg);
1285
1286	case XFS_IOC_ATTRMULTI_BY_HANDLE:
1287		return xfs_attrmulti_by_handle(filp, arg);
1288
1289	case XFS_IOC_SWAPEXT: {
1290		struct xfs_swapext	sxp;
1291
1292		if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
1293			return -EFAULT;
1294		error = mnt_want_write_file(filp);
1295		if (error)
1296			return error;
1297		error = xfs_ioc_swapext(&sxp);
1298		mnt_drop_write_file(filp);
1299		return error;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1300	}
1301
1302	case XFS_IOC_FSCOUNTS:
1303		return xfs_ioctl_fs_counts(mp, arg);
1304
1305	case XFS_IOC_SET_RESBLKS:
1306	case XFS_IOC_GET_RESBLKS:
1307		return xfs_ioctl_getset_resblocks(filp, cmd, arg);
 
 
 
 
 
 
 
 
 
1308
1309	case XFS_IOC_FSGROWFSDATA: {
1310		struct xfs_growfs_data in;
1311
1312		if (copy_from_user(&in, arg, sizeof(in)))
1313			return -EFAULT;
1314
1315		error = mnt_want_write_file(filp);
1316		if (error)
1317			return error;
1318		error = xfs_growfs_data(mp, &in);
1319		mnt_drop_write_file(filp);
1320		return error;
1321	}
1322
1323	case XFS_IOC_FSGROWFSLOG: {
1324		struct xfs_growfs_log in;
1325
1326		if (copy_from_user(&in, arg, sizeof(in)))
1327			return -EFAULT;
1328
1329		error = mnt_want_write_file(filp);
1330		if (error)
1331			return error;
1332		error = xfs_growfs_log(mp, &in);
1333		mnt_drop_write_file(filp);
1334		return error;
1335	}
1336
1337	case XFS_IOC_FSGROWFSRT: {
1338		xfs_growfs_rt_t in;
1339
1340		if (copy_from_user(&in, arg, sizeof(in)))
1341			return -EFAULT;
1342
1343		error = mnt_want_write_file(filp);
1344		if (error)
1345			return error;
1346		error = xfs_growfs_rt(mp, &in);
1347		mnt_drop_write_file(filp);
1348		return error;
1349	}
1350
1351	case XFS_IOC_GOINGDOWN: {
1352		uint32_t in;
1353
1354		if (!capable(CAP_SYS_ADMIN))
1355			return -EPERM;
1356
1357		if (get_user(in, (uint32_t __user *)arg))
1358			return -EFAULT;
1359
1360		return xfs_fs_goingdown(mp, in);
 
1361	}
1362
1363	case XFS_IOC_ERROR_INJECTION: {
1364		xfs_error_injection_t in;
1365
1366		if (!capable(CAP_SYS_ADMIN))
1367			return -EPERM;
1368
1369		if (copy_from_user(&in, arg, sizeof(in)))
1370			return -EFAULT;
1371
1372		return xfs_errortag_add(mp, in.errtag);
 
1373	}
1374
1375	case XFS_IOC_ERROR_CLEARALL:
1376		if (!capable(CAP_SYS_ADMIN))
1377			return -EPERM;
1378
1379		return xfs_errortag_clearall(mp);
 
1380
1381	case XFS_IOC_FREE_EOFBLOCKS: {
1382		struct xfs_fs_eofblocks	eofb;
1383		struct xfs_icwalk	icw;
1384
1385		if (!capable(CAP_SYS_ADMIN))
1386			return -EPERM;
1387
1388		if (xfs_is_readonly(mp))
1389			return -EROFS;
1390
1391		if (copy_from_user(&eofb, arg, sizeof(eofb)))
1392			return -EFAULT;
1393
1394		error = xfs_fs_eofblocks_from_user(&eofb, &icw);
1395		if (error)
1396			return error;
1397
1398		trace_xfs_ioc_free_eofblocks(mp, &icw, _RET_IP_);
1399
1400		sb_start_write(mp->m_super);
1401		error = xfs_blockgc_free_space(mp, &icw);
1402		sb_end_write(mp->m_super);
1403		return error;
1404	}
1405
1406	case XFS_IOC_EXCHANGE_RANGE:
1407		return xfs_ioc_exchange_range(filp, arg);
1408	case XFS_IOC_START_COMMIT:
1409		return xfs_ioc_start_commit(filp, arg);
1410	case XFS_IOC_COMMIT_RANGE:
1411		return xfs_ioc_commit_range(filp, arg);
1412
1413	default:
1414		return -ENOTTY;
1415	}
1416}