xref: /openbmc/linux/fs/xfs/xfs_ioctl.c (revision 6774def6)
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  */
65 int
66 xfs_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  */
143 STATIC int
144 xfs_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  */
154 struct dentry *
155 xfs_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 
186 STATIC struct dentry *
187 xfs_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 
194 int
195 xfs_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 -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 = -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 = -EPERM;
232 		goto out_dput;
233 	}
234 
235 	if ((fmode & FMODE_WRITE) && IS_IMMUTABLE(inode)) {
236 		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 = -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 
274 int
275 xfs_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 -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 = -EINVAL;
294 		goto out_dput;
295 	}
296 
297 	if (copy_from_user(&olen, hreq->ohandlen, sizeof(__u32))) {
298 		error = -EFAULT;
299 		goto out_dput;
300 	}
301 
302 	link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
303 	if (!link) {
304 		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 
322 int
323 xfs_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 -EPERM;
334 
335 	if (XFS_FORCED_SHUTDOWN(mp))
336 		return -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 
356 STATIC int
357 xfs_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 -EPERM;
368 	if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))
369 		return -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 = -EPERM;
383 		goto out;
384 	}
385 
386 	if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {
387 		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 
400 STATIC int
401 xfs_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 -EPERM;
413 	if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))
414 		return -EFAULT;
415 	if (al_hreq.buflen < sizeof(struct attrlist) ||
416 	    al_hreq.buflen > XATTR_LIST_MAX)
417 		return -EINVAL;
418 
419 	/*
420 	 * Reject flags, only allow namespaces.
421 	 */
422 	if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
423 		return -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 
442 out_kfree:
443 	kmem_free(kbuf);
444 out_dput:
445 	dput(dentry);
446 	return error;
447 }
448 
449 int
450 xfs_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 
473 out_kfree:
474 	kmem_free(kbuf);
475 	return error;
476 }
477 
478 int
479 xfs_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 
488 	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
489 		return -EPERM;
490 	if (len > XATTR_SIZE_MAX)
491 		return -EINVAL;
492 
493 	kbuf = memdup_user(ubuf, len);
494 	if (IS_ERR(kbuf))
495 		return PTR_ERR(kbuf);
496 
497 	return xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
498 }
499 
500 int
501 xfs_attrmulti_attr_remove(
502 	struct inode		*inode,
503 	unsigned char		*name,
504 	__uint32_t		flags)
505 {
506 	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
507 		return -EPERM;
508 	return xfs_attr_remove(XFS_I(inode), name, flags);
509 }
510 
511 STATIC int
512 xfs_attrmulti_by_handle(
513 	struct file		*parfilp,
514 	void			__user *arg)
515 {
516 	int			error;
517 	xfs_attr_multiop_t	*ops;
518 	xfs_fsop_attrmulti_handlereq_t am_hreq;
519 	struct dentry		*dentry;
520 	unsigned int		i, size;
521 	unsigned char		*attr_name;
522 
523 	if (!capable(CAP_SYS_ADMIN))
524 		return -EPERM;
525 	if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
526 		return -EFAULT;
527 
528 	/* overflow check */
529 	if (am_hreq.opcount >= INT_MAX / sizeof(xfs_attr_multiop_t))
530 		return -E2BIG;
531 
532 	dentry = xfs_handlereq_to_dentry(parfilp, &am_hreq.hreq);
533 	if (IS_ERR(dentry))
534 		return PTR_ERR(dentry);
535 
536 	error = -E2BIG;
537 	size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);
538 	if (!size || size > 16 * PAGE_SIZE)
539 		goto out_dput;
540 
541 	ops = memdup_user(am_hreq.ops, size);
542 	if (IS_ERR(ops)) {
543 		error = PTR_ERR(ops);
544 		goto out_dput;
545 	}
546 
547 	error = -ENOMEM;
548 	attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
549 	if (!attr_name)
550 		goto out_kfree_ops;
551 
552 	error = 0;
553 	for (i = 0; i < am_hreq.opcount; i++) {
554 		ops[i].am_error = strncpy_from_user((char *)attr_name,
555 				ops[i].am_attrname, MAXNAMELEN);
556 		if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
557 			error = -ERANGE;
558 		if (ops[i].am_error < 0)
559 			break;
560 
561 		switch (ops[i].am_opcode) {
562 		case ATTR_OP_GET:
563 			ops[i].am_error = xfs_attrmulti_attr_get(
564 					dentry->d_inode, attr_name,
565 					ops[i].am_attrvalue, &ops[i].am_length,
566 					ops[i].am_flags);
567 			break;
568 		case ATTR_OP_SET:
569 			ops[i].am_error = mnt_want_write_file(parfilp);
570 			if (ops[i].am_error)
571 				break;
572 			ops[i].am_error = xfs_attrmulti_attr_set(
573 					dentry->d_inode, attr_name,
574 					ops[i].am_attrvalue, ops[i].am_length,
575 					ops[i].am_flags);
576 			mnt_drop_write_file(parfilp);
577 			break;
578 		case ATTR_OP_REMOVE:
579 			ops[i].am_error = mnt_want_write_file(parfilp);
580 			if (ops[i].am_error)
581 				break;
582 			ops[i].am_error = xfs_attrmulti_attr_remove(
583 					dentry->d_inode, attr_name,
584 					ops[i].am_flags);
585 			mnt_drop_write_file(parfilp);
586 			break;
587 		default:
588 			ops[i].am_error = -EINVAL;
589 		}
590 	}
591 
592 	if (copy_to_user(am_hreq.ops, ops, size))
593 		error = -EFAULT;
594 
595 	kfree(attr_name);
596  out_kfree_ops:
597 	kfree(ops);
598  out_dput:
599 	dput(dentry);
600 	return error;
601 }
602 
603 int
604 xfs_ioc_space(
605 	struct xfs_inode	*ip,
606 	struct inode		*inode,
607 	struct file		*filp,
608 	int			ioflags,
609 	unsigned int		cmd,
610 	xfs_flock64_t		*bf)
611 {
612 	struct xfs_mount	*mp = ip->i_mount;
613 	struct xfs_trans	*tp;
614 	struct iattr		iattr;
615 	bool			setprealloc = false;
616 	bool			clrprealloc = false;
617 	int			error;
618 
619 	/*
620 	 * Only allow the sys admin to reserve space unless
621 	 * unwritten extents are enabled.
622 	 */
623 	if (!xfs_sb_version_hasextflgbit(&ip->i_mount->m_sb) &&
624 	    !capable(CAP_SYS_ADMIN))
625 		return -EPERM;
626 
627 	if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
628 		return -EPERM;
629 
630 	if (!(filp->f_mode & FMODE_WRITE))
631 		return -EBADF;
632 
633 	if (!S_ISREG(inode->i_mode))
634 		return -EINVAL;
635 
636 	error = mnt_want_write_file(filp);
637 	if (error)
638 		return error;
639 
640 	xfs_ilock(ip, XFS_IOLOCK_EXCL);
641 
642 	switch (bf->l_whence) {
643 	case 0: /*SEEK_SET*/
644 		break;
645 	case 1: /*SEEK_CUR*/
646 		bf->l_start += filp->f_pos;
647 		break;
648 	case 2: /*SEEK_END*/
649 		bf->l_start += XFS_ISIZE(ip);
650 		break;
651 	default:
652 		error = -EINVAL;
653 		goto out_unlock;
654 	}
655 
656 	/*
657 	 * length of <= 0 for resv/unresv/zero is invalid.  length for
658 	 * alloc/free is ignored completely and we have no idea what userspace
659 	 * might have set it to, so set it to zero to allow range
660 	 * checks to pass.
661 	 */
662 	switch (cmd) {
663 	case XFS_IOC_ZERO_RANGE:
664 	case XFS_IOC_RESVSP:
665 	case XFS_IOC_RESVSP64:
666 	case XFS_IOC_UNRESVSP:
667 	case XFS_IOC_UNRESVSP64:
668 		if (bf->l_len <= 0) {
669 			error = -EINVAL;
670 			goto out_unlock;
671 		}
672 		break;
673 	default:
674 		bf->l_len = 0;
675 		break;
676 	}
677 
678 	if (bf->l_start < 0 ||
679 	    bf->l_start > mp->m_super->s_maxbytes ||
680 	    bf->l_start + bf->l_len < 0 ||
681 	    bf->l_start + bf->l_len >= mp->m_super->s_maxbytes) {
682 		error = -EINVAL;
683 		goto out_unlock;
684 	}
685 
686 	switch (cmd) {
687 	case XFS_IOC_ZERO_RANGE:
688 		error = xfs_zero_file_space(ip, bf->l_start, bf->l_len);
689 		if (!error)
690 			setprealloc = true;
691 		break;
692 	case XFS_IOC_RESVSP:
693 	case XFS_IOC_RESVSP64:
694 		error = xfs_alloc_file_space(ip, bf->l_start, bf->l_len,
695 						XFS_BMAPI_PREALLOC);
696 		if (!error)
697 			setprealloc = true;
698 		break;
699 	case XFS_IOC_UNRESVSP:
700 	case XFS_IOC_UNRESVSP64:
701 		error = xfs_free_file_space(ip, bf->l_start, bf->l_len);
702 		break;
703 	case XFS_IOC_ALLOCSP:
704 	case XFS_IOC_ALLOCSP64:
705 	case XFS_IOC_FREESP:
706 	case XFS_IOC_FREESP64:
707 		if (bf->l_start > XFS_ISIZE(ip)) {
708 			error = xfs_alloc_file_space(ip, XFS_ISIZE(ip),
709 					bf->l_start - XFS_ISIZE(ip), 0);
710 			if (error)
711 				goto out_unlock;
712 		}
713 
714 		iattr.ia_valid = ATTR_SIZE;
715 		iattr.ia_size = bf->l_start;
716 
717 		error = xfs_setattr_size(ip, &iattr);
718 		if (!error)
719 			clrprealloc = true;
720 		break;
721 	default:
722 		ASSERT(0);
723 		error = -EINVAL;
724 	}
725 
726 	if (error)
727 		goto out_unlock;
728 
729 	tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID);
730 	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_writeid, 0, 0);
731 	if (error) {
732 		xfs_trans_cancel(tp, 0);
733 		goto out_unlock;
734 	}
735 
736 	xfs_ilock(ip, XFS_ILOCK_EXCL);
737 	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
738 
739 	if (!(ioflags & XFS_IO_INVIS)) {
740 		ip->i_d.di_mode &= ~S_ISUID;
741 		if (ip->i_d.di_mode & S_IXGRP)
742 			ip->i_d.di_mode &= ~S_ISGID;
743 		xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
744 	}
745 
746 	if (setprealloc)
747 		ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
748 	else if (clrprealloc)
749 		ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
750 
751 	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
752 	if (filp->f_flags & O_DSYNC)
753 		xfs_trans_set_sync(tp);
754 	error = xfs_trans_commit(tp, 0);
755 
756 out_unlock:
757 	xfs_iunlock(ip, XFS_IOLOCK_EXCL);
758 	mnt_drop_write_file(filp);
759 	return error;
760 }
761 
762 STATIC int
763 xfs_ioc_bulkstat(
764 	xfs_mount_t		*mp,
765 	unsigned int		cmd,
766 	void			__user *arg)
767 {
768 	xfs_fsop_bulkreq_t	bulkreq;
769 	int			count;	/* # of records returned */
770 	xfs_ino_t		inlast;	/* last inode number */
771 	int			done;
772 	int			error;
773 
774 	/* done = 1 if there are more stats to get and if bulkstat */
775 	/* should be called again (unused here, but used in dmapi) */
776 
777 	if (!capable(CAP_SYS_ADMIN))
778 		return -EPERM;
779 
780 	if (XFS_FORCED_SHUTDOWN(mp))
781 		return -EIO;
782 
783 	if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
784 		return -EFAULT;
785 
786 	if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
787 		return -EFAULT;
788 
789 	if ((count = bulkreq.icount) <= 0)
790 		return -EINVAL;
791 
792 	if (bulkreq.ubuffer == NULL)
793 		return -EINVAL;
794 
795 	if (cmd == XFS_IOC_FSINUMBERS)
796 		error = xfs_inumbers(mp, &inlast, &count,
797 					bulkreq.ubuffer, xfs_inumbers_fmt);
798 	else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
799 		error = xfs_bulkstat_one(mp, inlast, bulkreq.ubuffer,
800 					sizeof(xfs_bstat_t), NULL, &done);
801 	else	/* XFS_IOC_FSBULKSTAT */
802 		error = xfs_bulkstat(mp, &inlast, &count, xfs_bulkstat_one,
803 				     sizeof(xfs_bstat_t), bulkreq.ubuffer,
804 				     &done);
805 
806 	if (error)
807 		return error;
808 
809 	if (bulkreq.ocount != NULL) {
810 		if (copy_to_user(bulkreq.lastip, &inlast,
811 						sizeof(xfs_ino_t)))
812 			return -EFAULT;
813 
814 		if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
815 			return -EFAULT;
816 	}
817 
818 	return 0;
819 }
820 
821 STATIC int
822 xfs_ioc_fsgeometry_v1(
823 	xfs_mount_t		*mp,
824 	void			__user *arg)
825 {
826 	xfs_fsop_geom_t         fsgeo;
827 	int			error;
828 
829 	error = xfs_fs_geometry(mp, &fsgeo, 3);
830 	if (error)
831 		return error;
832 
833 	/*
834 	 * Caller should have passed an argument of type
835 	 * xfs_fsop_geom_v1_t.  This is a proper subset of the
836 	 * xfs_fsop_geom_t that xfs_fs_geometry() fills in.
837 	 */
838 	if (copy_to_user(arg, &fsgeo, sizeof(xfs_fsop_geom_v1_t)))
839 		return -EFAULT;
840 	return 0;
841 }
842 
843 STATIC int
844 xfs_ioc_fsgeometry(
845 	xfs_mount_t		*mp,
846 	void			__user *arg)
847 {
848 	xfs_fsop_geom_t		fsgeo;
849 	int			error;
850 
851 	error = xfs_fs_geometry(mp, &fsgeo, 4);
852 	if (error)
853 		return error;
854 
855 	if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
856 		return -EFAULT;
857 	return 0;
858 }
859 
860 /*
861  * Linux extended inode flags interface.
862  */
863 
864 STATIC unsigned int
865 xfs_merge_ioc_xflags(
866 	unsigned int	flags,
867 	unsigned int	start)
868 {
869 	unsigned int	xflags = start;
870 
871 	if (flags & FS_IMMUTABLE_FL)
872 		xflags |= XFS_XFLAG_IMMUTABLE;
873 	else
874 		xflags &= ~XFS_XFLAG_IMMUTABLE;
875 	if (flags & FS_APPEND_FL)
876 		xflags |= XFS_XFLAG_APPEND;
877 	else
878 		xflags &= ~XFS_XFLAG_APPEND;
879 	if (flags & FS_SYNC_FL)
880 		xflags |= XFS_XFLAG_SYNC;
881 	else
882 		xflags &= ~XFS_XFLAG_SYNC;
883 	if (flags & FS_NOATIME_FL)
884 		xflags |= XFS_XFLAG_NOATIME;
885 	else
886 		xflags &= ~XFS_XFLAG_NOATIME;
887 	if (flags & FS_NODUMP_FL)
888 		xflags |= XFS_XFLAG_NODUMP;
889 	else
890 		xflags &= ~XFS_XFLAG_NODUMP;
891 
892 	return xflags;
893 }
894 
895 STATIC unsigned int
896 xfs_di2lxflags(
897 	__uint16_t	di_flags)
898 {
899 	unsigned int	flags = 0;
900 
901 	if (di_flags & XFS_DIFLAG_IMMUTABLE)
902 		flags |= FS_IMMUTABLE_FL;
903 	if (di_flags & XFS_DIFLAG_APPEND)
904 		flags |= FS_APPEND_FL;
905 	if (di_flags & XFS_DIFLAG_SYNC)
906 		flags |= FS_SYNC_FL;
907 	if (di_flags & XFS_DIFLAG_NOATIME)
908 		flags |= FS_NOATIME_FL;
909 	if (di_flags & XFS_DIFLAG_NODUMP)
910 		flags |= FS_NODUMP_FL;
911 	return flags;
912 }
913 
914 STATIC int
915 xfs_ioc_fsgetxattr(
916 	xfs_inode_t		*ip,
917 	int			attr,
918 	void			__user *arg)
919 {
920 	struct fsxattr		fa;
921 
922 	memset(&fa, 0, sizeof(struct fsxattr));
923 
924 	xfs_ilock(ip, XFS_ILOCK_SHARED);
925 	fa.fsx_xflags = xfs_ip2xflags(ip);
926 	fa.fsx_extsize = ip->i_d.di_extsize << ip->i_mount->m_sb.sb_blocklog;
927 	fa.fsx_projid = xfs_get_projid(ip);
928 
929 	if (attr) {
930 		if (ip->i_afp) {
931 			if (ip->i_afp->if_flags & XFS_IFEXTENTS)
932 				fa.fsx_nextents = ip->i_afp->if_bytes /
933 							sizeof(xfs_bmbt_rec_t);
934 			else
935 				fa.fsx_nextents = ip->i_d.di_anextents;
936 		} else
937 			fa.fsx_nextents = 0;
938 	} else {
939 		if (ip->i_df.if_flags & XFS_IFEXTENTS)
940 			fa.fsx_nextents = ip->i_df.if_bytes /
941 						sizeof(xfs_bmbt_rec_t);
942 		else
943 			fa.fsx_nextents = ip->i_d.di_nextents;
944 	}
945 	xfs_iunlock(ip, XFS_ILOCK_SHARED);
946 
947 	if (copy_to_user(arg, &fa, sizeof(fa)))
948 		return -EFAULT;
949 	return 0;
950 }
951 
952 STATIC void
953 xfs_set_diflags(
954 	struct xfs_inode	*ip,
955 	unsigned int		xflags)
956 {
957 	unsigned int		di_flags;
958 
959 	/* can't set PREALLOC this way, just preserve it */
960 	di_flags = (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC);
961 	if (xflags & XFS_XFLAG_IMMUTABLE)
962 		di_flags |= XFS_DIFLAG_IMMUTABLE;
963 	if (xflags & XFS_XFLAG_APPEND)
964 		di_flags |= XFS_DIFLAG_APPEND;
965 	if (xflags & XFS_XFLAG_SYNC)
966 		di_flags |= XFS_DIFLAG_SYNC;
967 	if (xflags & XFS_XFLAG_NOATIME)
968 		di_flags |= XFS_DIFLAG_NOATIME;
969 	if (xflags & XFS_XFLAG_NODUMP)
970 		di_flags |= XFS_DIFLAG_NODUMP;
971 	if (xflags & XFS_XFLAG_NODEFRAG)
972 		di_flags |= XFS_DIFLAG_NODEFRAG;
973 	if (xflags & XFS_XFLAG_FILESTREAM)
974 		di_flags |= XFS_DIFLAG_FILESTREAM;
975 	if (S_ISDIR(ip->i_d.di_mode)) {
976 		if (xflags & XFS_XFLAG_RTINHERIT)
977 			di_flags |= XFS_DIFLAG_RTINHERIT;
978 		if (xflags & XFS_XFLAG_NOSYMLINKS)
979 			di_flags |= XFS_DIFLAG_NOSYMLINKS;
980 		if (xflags & XFS_XFLAG_EXTSZINHERIT)
981 			di_flags |= XFS_DIFLAG_EXTSZINHERIT;
982 		if (xflags & XFS_XFLAG_PROJINHERIT)
983 			di_flags |= XFS_DIFLAG_PROJINHERIT;
984 	} else if (S_ISREG(ip->i_d.di_mode)) {
985 		if (xflags & XFS_XFLAG_REALTIME)
986 			di_flags |= XFS_DIFLAG_REALTIME;
987 		if (xflags & XFS_XFLAG_EXTSIZE)
988 			di_flags |= XFS_DIFLAG_EXTSIZE;
989 	}
990 
991 	ip->i_d.di_flags = di_flags;
992 }
993 
994 STATIC void
995 xfs_diflags_to_linux(
996 	struct xfs_inode	*ip)
997 {
998 	struct inode		*inode = VFS_I(ip);
999 	unsigned int		xflags = xfs_ip2xflags(ip);
1000 
1001 	if (xflags & XFS_XFLAG_IMMUTABLE)
1002 		inode->i_flags |= S_IMMUTABLE;
1003 	else
1004 		inode->i_flags &= ~S_IMMUTABLE;
1005 	if (xflags & XFS_XFLAG_APPEND)
1006 		inode->i_flags |= S_APPEND;
1007 	else
1008 		inode->i_flags &= ~S_APPEND;
1009 	if (xflags & XFS_XFLAG_SYNC)
1010 		inode->i_flags |= S_SYNC;
1011 	else
1012 		inode->i_flags &= ~S_SYNC;
1013 	if (xflags & XFS_XFLAG_NOATIME)
1014 		inode->i_flags |= S_NOATIME;
1015 	else
1016 		inode->i_flags &= ~S_NOATIME;
1017 }
1018 
1019 #define FSX_PROJID	1
1020 #define FSX_EXTSIZE	2
1021 #define FSX_XFLAGS	4
1022 #define FSX_NONBLOCK	8
1023 
1024 STATIC int
1025 xfs_ioctl_setattr(
1026 	xfs_inode_t		*ip,
1027 	struct fsxattr		*fa,
1028 	int			mask)
1029 {
1030 	struct xfs_mount	*mp = ip->i_mount;
1031 	struct xfs_trans	*tp;
1032 	unsigned int		lock_flags = 0;
1033 	struct xfs_dquot	*udqp = NULL;
1034 	struct xfs_dquot	*pdqp = NULL;
1035 	struct xfs_dquot	*olddquot = NULL;
1036 	int			code;
1037 
1038 	trace_xfs_ioctl_setattr(ip);
1039 
1040 	if (mp->m_flags & XFS_MOUNT_RDONLY)
1041 		return -EROFS;
1042 	if (XFS_FORCED_SHUTDOWN(mp))
1043 		return -EIO;
1044 
1045 	/*
1046 	 * Disallow 32bit project ids when projid32bit feature is not enabled.
1047 	 */
1048 	if ((mask & FSX_PROJID) && (fa->fsx_projid > (__uint16_t)-1) &&
1049 			!xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb))
1050 		return -EINVAL;
1051 
1052 	/*
1053 	 * If disk quotas is on, we make sure that the dquots do exist on disk,
1054 	 * before we start any other transactions. Trying to do this later
1055 	 * is messy. We don't care to take a readlock to look at the ids
1056 	 * in inode here, because we can't hold it across the trans_reserve.
1057 	 * If the IDs do change before we take the ilock, we're covered
1058 	 * because the i_*dquot fields will get updated anyway.
1059 	 */
1060 	if (XFS_IS_QUOTA_ON(mp) && (mask & FSX_PROJID)) {
1061 		code = xfs_qm_vop_dqalloc(ip, ip->i_d.di_uid,
1062 					 ip->i_d.di_gid, fa->fsx_projid,
1063 					 XFS_QMOPT_PQUOTA, &udqp, NULL, &pdqp);
1064 		if (code)
1065 			return code;
1066 	}
1067 
1068 	/*
1069 	 * For the other attributes, we acquire the inode lock and
1070 	 * first do an error checking pass.
1071 	 */
1072 	tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
1073 	code = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
1074 	if (code)
1075 		goto error_return;
1076 
1077 	lock_flags = XFS_ILOCK_EXCL;
1078 	xfs_ilock(ip, lock_flags);
1079 
1080 	/*
1081 	 * CAP_FOWNER overrides the following restrictions:
1082 	 *
1083 	 * The user ID of the calling process must be equal
1084 	 * to the file owner ID, except in cases where the
1085 	 * CAP_FSETID capability is applicable.
1086 	 */
1087 	if (!inode_owner_or_capable(VFS_I(ip))) {
1088 		code = -EPERM;
1089 		goto error_return;
1090 	}
1091 
1092 	/*
1093 	 * Do a quota reservation only if projid is actually going to change.
1094 	 * Only allow changing of projid from init_user_ns since it is a
1095 	 * non user namespace aware identifier.
1096 	 */
1097 	if (mask & FSX_PROJID) {
1098 		if (current_user_ns() != &init_user_ns) {
1099 			code = -EINVAL;
1100 			goto error_return;
1101 		}
1102 
1103 		if (XFS_IS_QUOTA_RUNNING(mp) &&
1104 		    XFS_IS_PQUOTA_ON(mp) &&
1105 		    xfs_get_projid(ip) != fa->fsx_projid) {
1106 			ASSERT(tp);
1107 			code = xfs_qm_vop_chown_reserve(tp, ip, udqp, NULL,
1108 						pdqp, capable(CAP_FOWNER) ?
1109 						XFS_QMOPT_FORCE_RES : 0);
1110 			if (code)	/* out of quota */
1111 				goto error_return;
1112 		}
1113 	}
1114 
1115 	if (mask & FSX_EXTSIZE) {
1116 		/*
1117 		 * Can't change extent size if any extents are allocated.
1118 		 */
1119 		if (ip->i_d.di_nextents &&
1120 		    ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) !=
1121 		     fa->fsx_extsize)) {
1122 			code = -EINVAL;	/* EFBIG? */
1123 			goto error_return;
1124 		}
1125 
1126 		/*
1127 		 * Extent size must be a multiple of the appropriate block
1128 		 * size, if set at all. It must also be smaller than the
1129 		 * maximum extent size supported by the filesystem.
1130 		 *
1131 		 * Also, for non-realtime files, limit the extent size hint to
1132 		 * half the size of the AGs in the filesystem so alignment
1133 		 * doesn't result in extents larger than an AG.
1134 		 */
1135 		if (fa->fsx_extsize != 0) {
1136 			xfs_extlen_t    size;
1137 			xfs_fsblock_t   extsize_fsb;
1138 
1139 			extsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_extsize);
1140 			if (extsize_fsb > MAXEXTLEN) {
1141 				code = -EINVAL;
1142 				goto error_return;
1143 			}
1144 
1145 			if (XFS_IS_REALTIME_INODE(ip) ||
1146 			    ((mask & FSX_XFLAGS) &&
1147 			    (fa->fsx_xflags & XFS_XFLAG_REALTIME))) {
1148 				size = mp->m_sb.sb_rextsize <<
1149 				       mp->m_sb.sb_blocklog;
1150 			} else {
1151 				size = mp->m_sb.sb_blocksize;
1152 				if (extsize_fsb > mp->m_sb.sb_agblocks / 2) {
1153 					code = -EINVAL;
1154 					goto error_return;
1155 				}
1156 			}
1157 
1158 			if (fa->fsx_extsize % size) {
1159 				code = -EINVAL;
1160 				goto error_return;
1161 			}
1162 		}
1163 	}
1164 
1165 
1166 	if (mask & FSX_XFLAGS) {
1167 		/*
1168 		 * Can't change realtime flag if any extents are allocated.
1169 		 */
1170 		if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
1171 		    (XFS_IS_REALTIME_INODE(ip)) !=
1172 		    (fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
1173 			code = -EINVAL;	/* EFBIG? */
1174 			goto error_return;
1175 		}
1176 
1177 		/*
1178 		 * If realtime flag is set then must have realtime data.
1179 		 */
1180 		if ((fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
1181 			if ((mp->m_sb.sb_rblocks == 0) ||
1182 			    (mp->m_sb.sb_rextsize == 0) ||
1183 			    (ip->i_d.di_extsize % mp->m_sb.sb_rextsize)) {
1184 				code = -EINVAL;
1185 				goto error_return;
1186 			}
1187 		}
1188 
1189 		/*
1190 		 * Can't modify an immutable/append-only file unless
1191 		 * we have appropriate permission.
1192 		 */
1193 		if ((ip->i_d.di_flags &
1194 				(XFS_DIFLAG_IMMUTABLE|XFS_DIFLAG_APPEND) ||
1195 		     (fa->fsx_xflags &
1196 				(XFS_XFLAG_IMMUTABLE | XFS_XFLAG_APPEND))) &&
1197 		    !capable(CAP_LINUX_IMMUTABLE)) {
1198 			code = -EPERM;
1199 			goto error_return;
1200 		}
1201 	}
1202 
1203 	xfs_trans_ijoin(tp, ip, 0);
1204 
1205 	/*
1206 	 * Change file ownership.  Must be the owner or privileged.
1207 	 */
1208 	if (mask & FSX_PROJID) {
1209 		/*
1210 		 * CAP_FSETID overrides the following restrictions:
1211 		 *
1212 		 * The set-user-ID and set-group-ID bits of a file will be
1213 		 * cleared upon successful return from chown()
1214 		 */
1215 		if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
1216 		    !capable_wrt_inode_uidgid(VFS_I(ip), CAP_FSETID))
1217 			ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);
1218 
1219 		/*
1220 		 * Change the ownerships and register quota modifications
1221 		 * in the transaction.
1222 		 */
1223 		if (xfs_get_projid(ip) != fa->fsx_projid) {
1224 			if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp)) {
1225 				olddquot = xfs_qm_vop_chown(tp, ip,
1226 							&ip->i_pdquot, pdqp);
1227 			}
1228 			ASSERT(ip->i_d.di_version > 1);
1229 			xfs_set_projid(ip, fa->fsx_projid);
1230 		}
1231 
1232 	}
1233 
1234 	if (mask & FSX_XFLAGS) {
1235 		xfs_set_diflags(ip, fa->fsx_xflags);
1236 		xfs_diflags_to_linux(ip);
1237 	}
1238 
1239 	/*
1240 	 * Only set the extent size hint if we've already determined that the
1241 	 * extent size hint should be set on the inode. If no extent size flags
1242 	 * are set on the inode then unconditionally clear the extent size hint.
1243 	 */
1244 	if (mask & FSX_EXTSIZE) {
1245 		int	extsize = 0;
1246 
1247 		if (ip->i_d.di_flags &
1248 				(XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT))
1249 			extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;
1250 		ip->i_d.di_extsize = extsize;
1251 	}
1252 
1253 	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1254 	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1255 
1256 	XFS_STATS_INC(xs_ig_attrchg);
1257 
1258 	/*
1259 	 * If this is a synchronous mount, make sure that the
1260 	 * transaction goes to disk before returning to the user.
1261 	 * This is slightly sub-optimal in that truncates require
1262 	 * two sync transactions instead of one for wsync filesystems.
1263 	 * One for the truncate and one for the timestamps since we
1264 	 * don't want to change the timestamps unless we're sure the
1265 	 * truncate worked.  Truncates are less than 1% of the laddis
1266 	 * mix so this probably isn't worth the trouble to optimize.
1267 	 */
1268 	if (mp->m_flags & XFS_MOUNT_WSYNC)
1269 		xfs_trans_set_sync(tp);
1270 	code = xfs_trans_commit(tp, 0);
1271 	xfs_iunlock(ip, lock_flags);
1272 
1273 	/*
1274 	 * Release any dquot(s) the inode had kept before chown.
1275 	 */
1276 	xfs_qm_dqrele(olddquot);
1277 	xfs_qm_dqrele(udqp);
1278 	xfs_qm_dqrele(pdqp);
1279 
1280 	return code;
1281 
1282  error_return:
1283 	xfs_qm_dqrele(udqp);
1284 	xfs_qm_dqrele(pdqp);
1285 	xfs_trans_cancel(tp, 0);
1286 	if (lock_flags)
1287 		xfs_iunlock(ip, lock_flags);
1288 	return code;
1289 }
1290 
1291 STATIC int
1292 xfs_ioc_fssetxattr(
1293 	xfs_inode_t		*ip,
1294 	struct file		*filp,
1295 	void			__user *arg)
1296 {
1297 	struct fsxattr		fa;
1298 	unsigned int		mask;
1299 	int error;
1300 
1301 	if (copy_from_user(&fa, arg, sizeof(fa)))
1302 		return -EFAULT;
1303 
1304 	mask = FSX_XFLAGS | FSX_EXTSIZE | FSX_PROJID;
1305 	if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1306 		mask |= FSX_NONBLOCK;
1307 
1308 	error = mnt_want_write_file(filp);
1309 	if (error)
1310 		return error;
1311 	error = xfs_ioctl_setattr(ip, &fa, mask);
1312 	mnt_drop_write_file(filp);
1313 	return error;
1314 }
1315 
1316 STATIC int
1317 xfs_ioc_getxflags(
1318 	xfs_inode_t		*ip,
1319 	void			__user *arg)
1320 {
1321 	unsigned int		flags;
1322 
1323 	flags = xfs_di2lxflags(ip->i_d.di_flags);
1324 	if (copy_to_user(arg, &flags, sizeof(flags)))
1325 		return -EFAULT;
1326 	return 0;
1327 }
1328 
1329 STATIC int
1330 xfs_ioc_setxflags(
1331 	xfs_inode_t		*ip,
1332 	struct file		*filp,
1333 	void			__user *arg)
1334 {
1335 	struct fsxattr		fa;
1336 	unsigned int		flags;
1337 	unsigned int		mask;
1338 	int error;
1339 
1340 	if (copy_from_user(&flags, arg, sizeof(flags)))
1341 		return -EFAULT;
1342 
1343 	if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
1344 		      FS_NOATIME_FL | FS_NODUMP_FL | \
1345 		      FS_SYNC_FL))
1346 		return -EOPNOTSUPP;
1347 
1348 	mask = FSX_XFLAGS;
1349 	if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1350 		mask |= FSX_NONBLOCK;
1351 	fa.fsx_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip));
1352 
1353 	error = mnt_want_write_file(filp);
1354 	if (error)
1355 		return error;
1356 	error = xfs_ioctl_setattr(ip, &fa, mask);
1357 	mnt_drop_write_file(filp);
1358 	return error;
1359 }
1360 
1361 STATIC int
1362 xfs_getbmap_format(void **ap, struct getbmapx *bmv, int *full)
1363 {
1364 	struct getbmap __user	*base = (struct getbmap __user *)*ap;
1365 
1366 	/* copy only getbmap portion (not getbmapx) */
1367 	if (copy_to_user(base, bmv, sizeof(struct getbmap)))
1368 		return -EFAULT;
1369 
1370 	*ap += sizeof(struct getbmap);
1371 	return 0;
1372 }
1373 
1374 STATIC int
1375 xfs_ioc_getbmap(
1376 	struct xfs_inode	*ip,
1377 	int			ioflags,
1378 	unsigned int		cmd,
1379 	void			__user *arg)
1380 {
1381 	struct getbmapx		bmx;
1382 	int			error;
1383 
1384 	if (copy_from_user(&bmx, arg, sizeof(struct getbmapx)))
1385 		return -EFAULT;
1386 
1387 	if (bmx.bmv_count < 2)
1388 		return -EINVAL;
1389 
1390 	bmx.bmv_iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
1391 	if (ioflags & XFS_IO_INVIS)
1392 		bmx.bmv_iflags |= BMV_IF_NO_DMAPI_READ;
1393 
1394 	error = xfs_getbmap(ip, &bmx, xfs_getbmap_format,
1395 			    (__force struct getbmap *)arg+1);
1396 	if (error)
1397 		return error;
1398 
1399 	/* copy back header - only size of getbmap */
1400 	if (copy_to_user(arg, &bmx, sizeof(struct getbmap)))
1401 		return -EFAULT;
1402 	return 0;
1403 }
1404 
1405 STATIC int
1406 xfs_getbmapx_format(void **ap, struct getbmapx *bmv, int *full)
1407 {
1408 	struct getbmapx __user	*base = (struct getbmapx __user *)*ap;
1409 
1410 	if (copy_to_user(base, bmv, sizeof(struct getbmapx)))
1411 		return -EFAULT;
1412 
1413 	*ap += sizeof(struct getbmapx);
1414 	return 0;
1415 }
1416 
1417 STATIC int
1418 xfs_ioc_getbmapx(
1419 	struct xfs_inode	*ip,
1420 	void			__user *arg)
1421 {
1422 	struct getbmapx		bmx;
1423 	int			error;
1424 
1425 	if (copy_from_user(&bmx, arg, sizeof(bmx)))
1426 		return -EFAULT;
1427 
1428 	if (bmx.bmv_count < 2)
1429 		return -EINVAL;
1430 
1431 	if (bmx.bmv_iflags & (~BMV_IF_VALID))
1432 		return -EINVAL;
1433 
1434 	error = xfs_getbmap(ip, &bmx, xfs_getbmapx_format,
1435 			    (__force struct getbmapx *)arg+1);
1436 	if (error)
1437 		return error;
1438 
1439 	/* copy back header */
1440 	if (copy_to_user(arg, &bmx, sizeof(struct getbmapx)))
1441 		return -EFAULT;
1442 
1443 	return 0;
1444 }
1445 
1446 int
1447 xfs_ioc_swapext(
1448 	xfs_swapext_t	*sxp)
1449 {
1450 	xfs_inode_t     *ip, *tip;
1451 	struct fd	f, tmp;
1452 	int		error = 0;
1453 
1454 	/* Pull information for the target fd */
1455 	f = fdget((int)sxp->sx_fdtarget);
1456 	if (!f.file) {
1457 		error = -EINVAL;
1458 		goto out;
1459 	}
1460 
1461 	if (!(f.file->f_mode & FMODE_WRITE) ||
1462 	    !(f.file->f_mode & FMODE_READ) ||
1463 	    (f.file->f_flags & O_APPEND)) {
1464 		error = -EBADF;
1465 		goto out_put_file;
1466 	}
1467 
1468 	tmp = fdget((int)sxp->sx_fdtmp);
1469 	if (!tmp.file) {
1470 		error = -EINVAL;
1471 		goto out_put_file;
1472 	}
1473 
1474 	if (!(tmp.file->f_mode & FMODE_WRITE) ||
1475 	    !(tmp.file->f_mode & FMODE_READ) ||
1476 	    (tmp.file->f_flags & O_APPEND)) {
1477 		error = -EBADF;
1478 		goto out_put_tmp_file;
1479 	}
1480 
1481 	if (IS_SWAPFILE(file_inode(f.file)) ||
1482 	    IS_SWAPFILE(file_inode(tmp.file))) {
1483 		error = -EINVAL;
1484 		goto out_put_tmp_file;
1485 	}
1486 
1487 	ip = XFS_I(file_inode(f.file));
1488 	tip = XFS_I(file_inode(tmp.file));
1489 
1490 	if (ip->i_mount != tip->i_mount) {
1491 		error = -EINVAL;
1492 		goto out_put_tmp_file;
1493 	}
1494 
1495 	if (ip->i_ino == tip->i_ino) {
1496 		error = -EINVAL;
1497 		goto out_put_tmp_file;
1498 	}
1499 
1500 	if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
1501 		error = -EIO;
1502 		goto out_put_tmp_file;
1503 	}
1504 
1505 	error = xfs_swap_extents(ip, tip, sxp);
1506 
1507  out_put_tmp_file:
1508 	fdput(tmp);
1509  out_put_file:
1510 	fdput(f);
1511  out:
1512 	return error;
1513 }
1514 
1515 /*
1516  * Note: some of the ioctl's return positive numbers as a
1517  * byte count indicating success, such as readlink_by_handle.
1518  * So we don't "sign flip" like most other routines.  This means
1519  * true errors need to be returned as a negative value.
1520  */
1521 long
1522 xfs_file_ioctl(
1523 	struct file		*filp,
1524 	unsigned int		cmd,
1525 	unsigned long		p)
1526 {
1527 	struct inode		*inode = file_inode(filp);
1528 	struct xfs_inode	*ip = XFS_I(inode);
1529 	struct xfs_mount	*mp = ip->i_mount;
1530 	void			__user *arg = (void __user *)p;
1531 	int			ioflags = 0;
1532 	int			error;
1533 
1534 	if (filp->f_mode & FMODE_NOCMTIME)
1535 		ioflags |= XFS_IO_INVIS;
1536 
1537 	trace_xfs_file_ioctl(ip);
1538 
1539 	switch (cmd) {
1540 	case FITRIM:
1541 		return xfs_ioc_trim(mp, arg);
1542 	case XFS_IOC_ALLOCSP:
1543 	case XFS_IOC_FREESP:
1544 	case XFS_IOC_RESVSP:
1545 	case XFS_IOC_UNRESVSP:
1546 	case XFS_IOC_ALLOCSP64:
1547 	case XFS_IOC_FREESP64:
1548 	case XFS_IOC_RESVSP64:
1549 	case XFS_IOC_UNRESVSP64:
1550 	case XFS_IOC_ZERO_RANGE: {
1551 		xfs_flock64_t		bf;
1552 
1553 		if (copy_from_user(&bf, arg, sizeof(bf)))
1554 			return -EFAULT;
1555 		return xfs_ioc_space(ip, inode, filp, ioflags, cmd, &bf);
1556 	}
1557 	case XFS_IOC_DIOINFO: {
1558 		struct dioattr	da;
1559 		xfs_buftarg_t	*target =
1560 			XFS_IS_REALTIME_INODE(ip) ?
1561 			mp->m_rtdev_targp : mp->m_ddev_targp;
1562 
1563 		da.d_mem =  da.d_miniosz = target->bt_logical_sectorsize;
1564 		da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1565 
1566 		if (copy_to_user(arg, &da, sizeof(da)))
1567 			return -EFAULT;
1568 		return 0;
1569 	}
1570 
1571 	case XFS_IOC_FSBULKSTAT_SINGLE:
1572 	case XFS_IOC_FSBULKSTAT:
1573 	case XFS_IOC_FSINUMBERS:
1574 		return xfs_ioc_bulkstat(mp, cmd, arg);
1575 
1576 	case XFS_IOC_FSGEOMETRY_V1:
1577 		return xfs_ioc_fsgeometry_v1(mp, arg);
1578 
1579 	case XFS_IOC_FSGEOMETRY:
1580 		return xfs_ioc_fsgeometry(mp, arg);
1581 
1582 	case XFS_IOC_GETVERSION:
1583 		return put_user(inode->i_generation, (int __user *)arg);
1584 
1585 	case XFS_IOC_FSGETXATTR:
1586 		return xfs_ioc_fsgetxattr(ip, 0, arg);
1587 	case XFS_IOC_FSGETXATTRA:
1588 		return xfs_ioc_fsgetxattr(ip, 1, arg);
1589 	case XFS_IOC_FSSETXATTR:
1590 		return xfs_ioc_fssetxattr(ip, filp, arg);
1591 	case XFS_IOC_GETXFLAGS:
1592 		return xfs_ioc_getxflags(ip, arg);
1593 	case XFS_IOC_SETXFLAGS:
1594 		return xfs_ioc_setxflags(ip, filp, arg);
1595 
1596 	case XFS_IOC_FSSETDM: {
1597 		struct fsdmidata	dmi;
1598 
1599 		if (copy_from_user(&dmi, arg, sizeof(dmi)))
1600 			return -EFAULT;
1601 
1602 		error = mnt_want_write_file(filp);
1603 		if (error)
1604 			return error;
1605 
1606 		error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
1607 				dmi.fsd_dmstate);
1608 		mnt_drop_write_file(filp);
1609 		return error;
1610 	}
1611 
1612 	case XFS_IOC_GETBMAP:
1613 	case XFS_IOC_GETBMAPA:
1614 		return xfs_ioc_getbmap(ip, ioflags, cmd, arg);
1615 
1616 	case XFS_IOC_GETBMAPX:
1617 		return xfs_ioc_getbmapx(ip, arg);
1618 
1619 	case XFS_IOC_FD_TO_HANDLE:
1620 	case XFS_IOC_PATH_TO_HANDLE:
1621 	case XFS_IOC_PATH_TO_FSHANDLE: {
1622 		xfs_fsop_handlereq_t	hreq;
1623 
1624 		if (copy_from_user(&hreq, arg, sizeof(hreq)))
1625 			return -EFAULT;
1626 		return xfs_find_handle(cmd, &hreq);
1627 	}
1628 	case XFS_IOC_OPEN_BY_HANDLE: {
1629 		xfs_fsop_handlereq_t	hreq;
1630 
1631 		if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1632 			return -EFAULT;
1633 		return xfs_open_by_handle(filp, &hreq);
1634 	}
1635 	case XFS_IOC_FSSETDM_BY_HANDLE:
1636 		return xfs_fssetdm_by_handle(filp, arg);
1637 
1638 	case XFS_IOC_READLINK_BY_HANDLE: {
1639 		xfs_fsop_handlereq_t	hreq;
1640 
1641 		if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1642 			return -EFAULT;
1643 		return xfs_readlink_by_handle(filp, &hreq);
1644 	}
1645 	case XFS_IOC_ATTRLIST_BY_HANDLE:
1646 		return xfs_attrlist_by_handle(filp, arg);
1647 
1648 	case XFS_IOC_ATTRMULTI_BY_HANDLE:
1649 		return xfs_attrmulti_by_handle(filp, arg);
1650 
1651 	case XFS_IOC_SWAPEXT: {
1652 		struct xfs_swapext	sxp;
1653 
1654 		if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
1655 			return -EFAULT;
1656 		error = mnt_want_write_file(filp);
1657 		if (error)
1658 			return error;
1659 		error = xfs_ioc_swapext(&sxp);
1660 		mnt_drop_write_file(filp);
1661 		return error;
1662 	}
1663 
1664 	case XFS_IOC_FSCOUNTS: {
1665 		xfs_fsop_counts_t out;
1666 
1667 		error = xfs_fs_counts(mp, &out);
1668 		if (error)
1669 			return error;
1670 
1671 		if (copy_to_user(arg, &out, sizeof(out)))
1672 			return -EFAULT;
1673 		return 0;
1674 	}
1675 
1676 	case XFS_IOC_SET_RESBLKS: {
1677 		xfs_fsop_resblks_t inout;
1678 		__uint64_t	   in;
1679 
1680 		if (!capable(CAP_SYS_ADMIN))
1681 			return -EPERM;
1682 
1683 		if (mp->m_flags & XFS_MOUNT_RDONLY)
1684 			return -EROFS;
1685 
1686 		if (copy_from_user(&inout, arg, sizeof(inout)))
1687 			return -EFAULT;
1688 
1689 		error = mnt_want_write_file(filp);
1690 		if (error)
1691 			return error;
1692 
1693 		/* input parameter is passed in resblks field of structure */
1694 		in = inout.resblks;
1695 		error = xfs_reserve_blocks(mp, &in, &inout);
1696 		mnt_drop_write_file(filp);
1697 		if (error)
1698 			return error;
1699 
1700 		if (copy_to_user(arg, &inout, sizeof(inout)))
1701 			return -EFAULT;
1702 		return 0;
1703 	}
1704 
1705 	case XFS_IOC_GET_RESBLKS: {
1706 		xfs_fsop_resblks_t out;
1707 
1708 		if (!capable(CAP_SYS_ADMIN))
1709 			return -EPERM;
1710 
1711 		error = xfs_reserve_blocks(mp, NULL, &out);
1712 		if (error)
1713 			return error;
1714 
1715 		if (copy_to_user(arg, &out, sizeof(out)))
1716 			return -EFAULT;
1717 
1718 		return 0;
1719 	}
1720 
1721 	case XFS_IOC_FSGROWFSDATA: {
1722 		xfs_growfs_data_t in;
1723 
1724 		if (copy_from_user(&in, arg, sizeof(in)))
1725 			return -EFAULT;
1726 
1727 		error = mnt_want_write_file(filp);
1728 		if (error)
1729 			return error;
1730 		error = xfs_growfs_data(mp, &in);
1731 		mnt_drop_write_file(filp);
1732 		return error;
1733 	}
1734 
1735 	case XFS_IOC_FSGROWFSLOG: {
1736 		xfs_growfs_log_t in;
1737 
1738 		if (copy_from_user(&in, arg, sizeof(in)))
1739 			return -EFAULT;
1740 
1741 		error = mnt_want_write_file(filp);
1742 		if (error)
1743 			return error;
1744 		error = xfs_growfs_log(mp, &in);
1745 		mnt_drop_write_file(filp);
1746 		return error;
1747 	}
1748 
1749 	case XFS_IOC_FSGROWFSRT: {
1750 		xfs_growfs_rt_t in;
1751 
1752 		if (copy_from_user(&in, arg, sizeof(in)))
1753 			return -EFAULT;
1754 
1755 		error = mnt_want_write_file(filp);
1756 		if (error)
1757 			return error;
1758 		error = xfs_growfs_rt(mp, &in);
1759 		mnt_drop_write_file(filp);
1760 		return error;
1761 	}
1762 
1763 	case XFS_IOC_GOINGDOWN: {
1764 		__uint32_t in;
1765 
1766 		if (!capable(CAP_SYS_ADMIN))
1767 			return -EPERM;
1768 
1769 		if (get_user(in, (__uint32_t __user *)arg))
1770 			return -EFAULT;
1771 
1772 		return xfs_fs_goingdown(mp, in);
1773 	}
1774 
1775 	case XFS_IOC_ERROR_INJECTION: {
1776 		xfs_error_injection_t in;
1777 
1778 		if (!capable(CAP_SYS_ADMIN))
1779 			return -EPERM;
1780 
1781 		if (copy_from_user(&in, arg, sizeof(in)))
1782 			return -EFAULT;
1783 
1784 		return xfs_errortag_add(in.errtag, mp);
1785 	}
1786 
1787 	case XFS_IOC_ERROR_CLEARALL:
1788 		if (!capable(CAP_SYS_ADMIN))
1789 			return -EPERM;
1790 
1791 		return xfs_errortag_clearall(mp, 1);
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 -EROFS;
1802 
1803 		if (copy_from_user(&eofb, arg, sizeof(eofb)))
1804 			return -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 }
1817