xref: /linux/fs/xfs/xfs_ioctl.c (revision 3fd6c59042dbba50391e30862beac979491145fe)
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 */
49 int
xfs_fsbulkstat_one_fmt(struct xfs_ibulk * breq,const struct xfs_bulkstat * bstat)50 xfs_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 
62 int
xfs_fsinumbers_fmt(struct xfs_ibulk * breq,const struct xfs_inumbers * igrp)63 xfs_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 
75 STATIC int
xfs_ioc_fsbulkstat(struct file * file,unsigned int cmd,void __user * arg)76 xfs_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 */
155 static int
xfs_bulkstat_fmt(struct xfs_ibulk * breq,const struct xfs_bulkstat * bstat)156 xfs_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  */
171 static int
xfs_bulk_ireq_setup(struct xfs_mount * mp,const struct xfs_bulk_ireq * hdr,struct xfs_ibulk * breq,void __user * ubuffer)172 xfs_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  */
248 static void
xfs_bulk_ireq_teardown(struct xfs_bulk_ireq * hdr,struct xfs_ibulk * breq)249 xfs_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. */
258 STATIC int
xfs_ioc_bulkstat(struct file * file,unsigned int cmd,struct xfs_bulkstat_req __user * arg)259 xfs_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 
291 out_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 
299 STATIC int
xfs_inumbers_fmt(struct xfs_ibulk * breq,const struct xfs_inumbers * igrp)300 xfs_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. */
310 STATIC int
xfs_ioc_inumbers(struct xfs_mount * mp,unsigned int cmd,struct xfs_inumbers_req __user * arg)311 xfs_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 
344 out_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 
352 STATIC int
xfs_ioc_fsgeometry(struct xfs_mount * mp,void __user * arg,int struct_version)353 xfs_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 
377 STATIC int
xfs_ioc_ag_geometry(struct xfs_mount * mp,void __user * arg)378 xfs_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 
407 STATIC int
xfs_ioc_rtgroup_geometry(struct xfs_mount * mp,void __user * arg)408 xfs_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 
443 static void
xfs_fill_fsxattr(struct xfs_inode * ip,int whichfork,struct fileattr * fa)444 xfs_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 
481 STATIC int
xfs_ioc_fsgetxattra(xfs_inode_t * ip,void __user * arg)482 xfs_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 
495 int
xfs_fileattr_get(struct dentry * dentry,struct fileattr * fa)496 xfs_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 
512 static int
xfs_ioctl_setattr_xflags(struct xfs_trans * tp,struct xfs_inode * ip,struct fileattr * fa)513 xfs_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 
573 static void
xfs_ioctl_setattr_prepare_dax(struct xfs_inode * ip,struct fileattr * fa)574 xfs_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  */
600 static struct xfs_trans *
xfs_ioctl_setattr_get_trans(struct xfs_inode * ip,struct xfs_dquot * pdqp)601 xfs_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 
625 out_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  */
633 static int
xfs_ioctl_setattr_check_extsize(struct xfs_inode * ip,struct fileattr * fa)634 xfs_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 
675 static int
xfs_ioctl_setattr_check_cowextsize(struct xfs_inode * ip,struct fileattr * fa)676 xfs_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 
700 static int
xfs_ioctl_setattr_check_projid(struct xfs_inode * ip,struct fileattr * fa)701 xfs_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 
715 int
xfs_fileattr_set(struct mnt_idmap * idmap,struct dentry * dentry,struct fileattr * fa)716 xfs_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 
820 skip_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 
831 error_trans_cancel:
832 	xfs_trans_cancel(tp);
833 error_free_dquots:
834 	xfs_qm_dqrele(pdqp);
835 	return error;
836 }
837 
838 static bool
xfs_getbmap_format(struct kgetbmap * p,struct getbmapx __user * u,size_t recsize)839 xfs_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 
860 STATIC int
xfs_ioc_getbmap(struct file * file,unsigned int cmd,void __user * arg)861 xfs_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;
914 out_free_buf:
915 	kvfree(buf);
916 	return error;
917 }
918 
919 int
xfs_ioc_swapext(xfs_swapext_t * sxp)920 xfs_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 
972 static int
xfs_ioc_getlabel(struct xfs_mount * mp,char __user * user_label)973 xfs_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 
994 static int
xfs_ioc_setlabel(struct file * filp,struct xfs_mount * mp,char __user * newlabel)995 xfs_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 
1051 out:
1052 	mnt_drop_write_file(filp);
1053 	return error;
1054 }
1055 
1056 static inline int
xfs_fs_eofblocks_from_user(struct xfs_fs_eofblocks * src,struct xfs_icwalk * dst)1057 xfs_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 
1102 static int
xfs_ioctl_getset_resblocks(struct file * filp,unsigned int cmd,void __user * arg)1103 xfs_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 
1141 static int
xfs_ioctl_fs_counts(struct xfs_mount * mp,struct xfs_fsop_counts __user * uarg)1142 xfs_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  */
1174 long
xfs_file_ioctl(struct file * filp,unsigned int cmd,unsigned long p)1175 xfs_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 }
1417