xref: /linux/fs/xfs/xfs_ioctl.c (revision b477ff98d903618a1ab8247861f2ea6e70c0f0f8)
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 		/*
474 		 * Don't let a misaligned CoW extent size hint on a directory
475 		 * escape to userspace if it won't pass the setattr checks
476 		 * later.
477 		 */
478 		if ((ip->i_diflags & XFS_DIFLAG_RTINHERIT) &&
479 		    ip->i_cowextsize % mp->m_sb.sb_rextsize > 0) {
480 			fa->fsx_xflags &= ~FS_XFLAG_COWEXTSIZE;
481 			fa->fsx_cowextsize = 0;
482 		} else {
483 			fa->fsx_cowextsize = XFS_FSB_TO_B(mp, ip->i_cowextsize);
484 		}
485 	}
486 
487 	fa->fsx_projid = ip->i_projid;
488 	if (ifp && !xfs_need_iread_extents(ifp))
489 		fa->fsx_nextents = xfs_iext_count(ifp);
490 	else
491 		fa->fsx_nextents = xfs_ifork_nextents(ifp);
492 }
493 
494 STATIC int
xfs_ioc_fsgetxattra(xfs_inode_t * ip,void __user * arg)495 xfs_ioc_fsgetxattra(
496 	xfs_inode_t		*ip,
497 	void			__user *arg)
498 {
499 	struct fileattr		fa;
500 
501 	xfs_ilock(ip, XFS_ILOCK_SHARED);
502 	xfs_fill_fsxattr(ip, XFS_ATTR_FORK, &fa);
503 	xfs_iunlock(ip, XFS_ILOCK_SHARED);
504 
505 	return copy_fsxattr_to_user(&fa, arg);
506 }
507 
508 int
xfs_fileattr_get(struct dentry * dentry,struct fileattr * fa)509 xfs_fileattr_get(
510 	struct dentry		*dentry,
511 	struct fileattr		*fa)
512 {
513 	struct xfs_inode	*ip = XFS_I(d_inode(dentry));
514 
515 	if (d_is_special(dentry))
516 		return -ENOTTY;
517 
518 	xfs_ilock(ip, XFS_ILOCK_SHARED);
519 	xfs_fill_fsxattr(ip, XFS_DATA_FORK, fa);
520 	xfs_iunlock(ip, XFS_ILOCK_SHARED);
521 
522 	return 0;
523 }
524 
525 static int
xfs_ioctl_setattr_xflags(struct xfs_trans * tp,struct xfs_inode * ip,struct fileattr * fa)526 xfs_ioctl_setattr_xflags(
527 	struct xfs_trans	*tp,
528 	struct xfs_inode	*ip,
529 	struct fileattr		*fa)
530 {
531 	struct xfs_mount	*mp = ip->i_mount;
532 	bool			rtflag = (fa->fsx_xflags & FS_XFLAG_REALTIME);
533 	uint64_t		i_flags2;
534 
535 	if (rtflag != XFS_IS_REALTIME_INODE(ip)) {
536 		/* Can't change realtime flag if any extents are allocated. */
537 		if (xfs_inode_has_filedata(ip))
538 			return -EINVAL;
539 
540 		/*
541 		 * If S_DAX is enabled on this file, we can only switch the
542 		 * device if both support fsdax.  We can't update S_DAX because
543 		 * there might be other threads walking down the access paths.
544 		 */
545 		if (IS_DAX(VFS_I(ip)) &&
546 		    (mp->m_ddev_targp->bt_daxdev == NULL ||
547 		     (mp->m_rtdev_targp &&
548 		      mp->m_rtdev_targp->bt_daxdev == NULL)))
549 			return -EINVAL;
550 	}
551 
552 	if (rtflag) {
553 		/* If realtime flag is set then must have realtime device */
554 		if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 ||
555 		    xfs_extlen_to_rtxmod(mp, ip->i_extsize))
556 			return -EINVAL;
557 	}
558 
559 	/* diflags2 only valid for v3 inodes. */
560 	i_flags2 = xfs_flags2diflags2(ip, fa->fsx_xflags);
561 	if (i_flags2 && !xfs_has_v3inodes(mp))
562 		return -EINVAL;
563 
564 	ip->i_diflags = xfs_flags2diflags(ip, fa->fsx_xflags);
565 	ip->i_diflags2 = i_flags2;
566 
567 	xfs_diflags_to_iflags(ip, false);
568 
569 	/*
570 	 * Make the stable writes flag match that of the device the inode
571 	 * resides on when flipping the RT flag.
572 	 */
573 	if (rtflag != XFS_IS_REALTIME_INODE(ip) && S_ISREG(VFS_I(ip)->i_mode))
574 		xfs_update_stable_writes(ip);
575 
576 	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
577 	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
578 	XFS_STATS_INC(mp, xs_ig_attrchg);
579 	return 0;
580 }
581 
582 static void
xfs_ioctl_setattr_prepare_dax(struct xfs_inode * ip,struct fileattr * fa)583 xfs_ioctl_setattr_prepare_dax(
584 	struct xfs_inode	*ip,
585 	struct fileattr		*fa)
586 {
587 	struct xfs_mount	*mp = ip->i_mount;
588 	struct inode            *inode = VFS_I(ip);
589 
590 	if (S_ISDIR(inode->i_mode))
591 		return;
592 
593 	if (xfs_has_dax_always(mp) || xfs_has_dax_never(mp))
594 		return;
595 
596 	if (((fa->fsx_xflags & FS_XFLAG_DAX) &&
597 	    !(ip->i_diflags2 & XFS_DIFLAG2_DAX)) ||
598 	    (!(fa->fsx_xflags & FS_XFLAG_DAX) &&
599 	     (ip->i_diflags2 & XFS_DIFLAG2_DAX)))
600 		d_mark_dontcache(inode);
601 }
602 
603 /*
604  * Set up the transaction structure for the setattr operation, checking that we
605  * have permission to do so. On success, return a clean transaction and the
606  * inode locked exclusively ready for further operation specific checks. On
607  * failure, return an error without modifying or locking the inode.
608  */
609 static struct xfs_trans *
xfs_ioctl_setattr_get_trans(struct xfs_inode * ip,struct xfs_dquot * pdqp)610 xfs_ioctl_setattr_get_trans(
611 	struct xfs_inode	*ip,
612 	struct xfs_dquot	*pdqp)
613 {
614 	struct xfs_mount	*mp = ip->i_mount;
615 	struct xfs_trans	*tp;
616 	int			error = -EROFS;
617 
618 	if (xfs_is_readonly(mp))
619 		goto out_error;
620 	error = -EIO;
621 	if (xfs_is_shutdown(mp))
622 		goto out_error;
623 
624 	error = xfs_trans_alloc_ichange(ip, NULL, NULL, pdqp,
625 			has_capability_noaudit(current, CAP_FOWNER), &tp);
626 	if (error)
627 		goto out_error;
628 
629 	if (xfs_has_wsync(mp))
630 		xfs_trans_set_sync(tp);
631 
632 	return tp;
633 
634 out_error:
635 	return ERR_PTR(error);
636 }
637 
638 /*
639  * Validate a proposed extent size hint.  For regular files, the hint can only
640  * be changed if no extents are allocated.
641  */
642 static int
xfs_ioctl_setattr_check_extsize(struct xfs_inode * ip,struct fileattr * fa)643 xfs_ioctl_setattr_check_extsize(
644 	struct xfs_inode	*ip,
645 	struct fileattr		*fa)
646 {
647 	struct xfs_mount	*mp = ip->i_mount;
648 	xfs_failaddr_t		failaddr;
649 	uint16_t		new_diflags;
650 
651 	if (!fa->fsx_valid)
652 		return 0;
653 
654 	if (S_ISREG(VFS_I(ip)->i_mode) && xfs_inode_has_filedata(ip) &&
655 	    XFS_FSB_TO_B(mp, ip->i_extsize) != fa->fsx_extsize)
656 		return -EINVAL;
657 
658 	if (fa->fsx_extsize & mp->m_blockmask)
659 		return -EINVAL;
660 
661 	new_diflags = xfs_flags2diflags(ip, fa->fsx_xflags);
662 
663 	/*
664 	 * Inode verifiers do not check that the extent size hint is an integer
665 	 * multiple of the rt extent size on a directory with both rtinherit
666 	 * and extszinherit flags set.  Don't let sysadmins misconfigure
667 	 * directories.
668 	 */
669 	if ((new_diflags & XFS_DIFLAG_RTINHERIT) &&
670 	    (new_diflags & XFS_DIFLAG_EXTSZINHERIT)) {
671 		unsigned int	rtextsize_bytes;
672 
673 		rtextsize_bytes = XFS_FSB_TO_B(mp, mp->m_sb.sb_rextsize);
674 		if (fa->fsx_extsize % rtextsize_bytes)
675 			return -EINVAL;
676 	}
677 
678 	failaddr = xfs_inode_validate_extsize(ip->i_mount,
679 			XFS_B_TO_FSB(mp, fa->fsx_extsize),
680 			VFS_I(ip)->i_mode, new_diflags);
681 	return failaddr != NULL ? -EINVAL : 0;
682 }
683 
684 static int
xfs_ioctl_setattr_check_cowextsize(struct xfs_inode * ip,struct fileattr * fa)685 xfs_ioctl_setattr_check_cowextsize(
686 	struct xfs_inode	*ip,
687 	struct fileattr		*fa)
688 {
689 	struct xfs_mount	*mp = ip->i_mount;
690 	xfs_failaddr_t		failaddr;
691 	uint64_t		new_diflags2;
692 	uint16_t		new_diflags;
693 
694 	if (!fa->fsx_valid)
695 		return 0;
696 
697 	if (fa->fsx_cowextsize & mp->m_blockmask)
698 		return -EINVAL;
699 
700 	new_diflags = xfs_flags2diflags(ip, fa->fsx_xflags);
701 	new_diflags2 = xfs_flags2diflags2(ip, fa->fsx_xflags);
702 
703 	failaddr = xfs_inode_validate_cowextsize(ip->i_mount,
704 			XFS_B_TO_FSB(mp, fa->fsx_cowextsize),
705 			VFS_I(ip)->i_mode, new_diflags, new_diflags2);
706 	return failaddr != NULL ? -EINVAL : 0;
707 }
708 
709 static int
xfs_ioctl_setattr_check_projid(struct xfs_inode * ip,struct fileattr * fa)710 xfs_ioctl_setattr_check_projid(
711 	struct xfs_inode	*ip,
712 	struct fileattr		*fa)
713 {
714 	if (!fa->fsx_valid)
715 		return 0;
716 
717 	/* Disallow 32bit project ids if 32bit IDs are not enabled. */
718 	if (fa->fsx_projid > (uint16_t)-1 &&
719 	    !xfs_has_projid32(ip->i_mount))
720 		return -EINVAL;
721 	return 0;
722 }
723 
724 int
xfs_fileattr_set(struct mnt_idmap * idmap,struct dentry * dentry,struct fileattr * fa)725 xfs_fileattr_set(
726 	struct mnt_idmap	*idmap,
727 	struct dentry		*dentry,
728 	struct fileattr		*fa)
729 {
730 	struct xfs_inode	*ip = XFS_I(d_inode(dentry));
731 	struct xfs_mount	*mp = ip->i_mount;
732 	struct xfs_trans	*tp;
733 	struct xfs_dquot	*pdqp = NULL;
734 	struct xfs_dquot	*olddquot = NULL;
735 	int			error;
736 
737 	trace_xfs_ioctl_setattr(ip);
738 
739 	if (d_is_special(dentry))
740 		return -ENOTTY;
741 
742 	if (!fa->fsx_valid) {
743 		if (fa->flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL |
744 				  FS_NOATIME_FL | FS_NODUMP_FL |
745 				  FS_SYNC_FL | FS_DAX_FL | FS_PROJINHERIT_FL))
746 			return -EOPNOTSUPP;
747 	}
748 
749 	error = xfs_ioctl_setattr_check_projid(ip, fa);
750 	if (error)
751 		return error;
752 
753 	/*
754 	 * If disk quotas is on, we make sure that the dquots do exist on disk,
755 	 * before we start any other transactions. Trying to do this later
756 	 * is messy. We don't care to take a readlock to look at the ids
757 	 * in inode here, because we can't hold it across the trans_reserve.
758 	 * If the IDs do change before we take the ilock, we're covered
759 	 * because the i_*dquot fields will get updated anyway.
760 	 */
761 	if (fa->fsx_valid && XFS_IS_QUOTA_ON(mp)) {
762 		error = xfs_qm_vop_dqalloc(ip, VFS_I(ip)->i_uid,
763 				VFS_I(ip)->i_gid, fa->fsx_projid,
764 				XFS_QMOPT_PQUOTA, NULL, NULL, &pdqp);
765 		if (error)
766 			return error;
767 	}
768 
769 	xfs_ioctl_setattr_prepare_dax(ip, fa);
770 
771 	tp = xfs_ioctl_setattr_get_trans(ip, pdqp);
772 	if (IS_ERR(tp)) {
773 		error = PTR_ERR(tp);
774 		goto error_free_dquots;
775 	}
776 
777 	error = xfs_ioctl_setattr_check_extsize(ip, fa);
778 	if (error)
779 		goto error_trans_cancel;
780 
781 	error = xfs_ioctl_setattr_check_cowextsize(ip, fa);
782 	if (error)
783 		goto error_trans_cancel;
784 
785 	error = xfs_ioctl_setattr_xflags(tp, ip, fa);
786 	if (error)
787 		goto error_trans_cancel;
788 
789 	if (!fa->fsx_valid)
790 		goto skip_xattr;
791 	/*
792 	 * Change file ownership.  Must be the owner or privileged.  CAP_FSETID
793 	 * overrides the following restrictions:
794 	 *
795 	 * The set-user-ID and set-group-ID bits of a file will be cleared upon
796 	 * successful return from chown()
797 	 */
798 
799 	if ((VFS_I(ip)->i_mode & (S_ISUID|S_ISGID)) &&
800 	    !capable_wrt_inode_uidgid(idmap, VFS_I(ip), CAP_FSETID))
801 		VFS_I(ip)->i_mode &= ~(S_ISUID|S_ISGID);
802 
803 	/* Change the ownerships and register project quota modifications */
804 	if (ip->i_projid != fa->fsx_projid) {
805 		if (XFS_IS_PQUOTA_ON(mp)) {
806 			olddquot = xfs_qm_vop_chown(tp, ip,
807 						&ip->i_pdquot, pdqp);
808 		}
809 		ip->i_projid = fa->fsx_projid;
810 	}
811 
812 	/*
813 	 * Only set the extent size hint if we've already determined that the
814 	 * extent size hint should be set on the inode. If no extent size flags
815 	 * are set on the inode then unconditionally clear the extent size hint.
816 	 */
817 	if (ip->i_diflags & (XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT))
818 		ip->i_extsize = XFS_B_TO_FSB(mp, fa->fsx_extsize);
819 	else
820 		ip->i_extsize = 0;
821 
822 	if (xfs_has_v3inodes(mp)) {
823 		if (ip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE)
824 			ip->i_cowextsize = XFS_B_TO_FSB(mp, fa->fsx_cowextsize);
825 		else
826 			ip->i_cowextsize = 0;
827 	}
828 
829 skip_xattr:
830 	error = xfs_trans_commit(tp);
831 
832 	/*
833 	 * Release any dquot(s) the inode had kept before chown.
834 	 */
835 	xfs_qm_dqrele(olddquot);
836 	xfs_qm_dqrele(pdqp);
837 
838 	return error;
839 
840 error_trans_cancel:
841 	xfs_trans_cancel(tp);
842 error_free_dquots:
843 	xfs_qm_dqrele(pdqp);
844 	return error;
845 }
846 
847 static bool
xfs_getbmap_format(struct kgetbmap * p,struct getbmapx __user * u,size_t recsize)848 xfs_getbmap_format(
849 	struct kgetbmap		*p,
850 	struct getbmapx __user	*u,
851 	size_t			recsize)
852 {
853 	if (put_user(p->bmv_offset, &u->bmv_offset) ||
854 	    put_user(p->bmv_block, &u->bmv_block) ||
855 	    put_user(p->bmv_length, &u->bmv_length) ||
856 	    put_user(0, &u->bmv_count) ||
857 	    put_user(0, &u->bmv_entries))
858 		return false;
859 	if (recsize < sizeof(struct getbmapx))
860 		return true;
861 	if (put_user(0, &u->bmv_iflags) ||
862 	    put_user(p->bmv_oflags, &u->bmv_oflags) ||
863 	    put_user(0, &u->bmv_unused1) ||
864 	    put_user(0, &u->bmv_unused2))
865 		return false;
866 	return true;
867 }
868 
869 STATIC int
xfs_ioc_getbmap(struct file * file,unsigned int cmd,void __user * arg)870 xfs_ioc_getbmap(
871 	struct file		*file,
872 	unsigned int		cmd,
873 	void			__user *arg)
874 {
875 	struct getbmapx		bmx = { 0 };
876 	struct kgetbmap		*buf;
877 	size_t			recsize;
878 	int			error, i;
879 
880 	switch (cmd) {
881 	case XFS_IOC_GETBMAPA:
882 		bmx.bmv_iflags = BMV_IF_ATTRFORK;
883 		fallthrough;
884 	case XFS_IOC_GETBMAP:
885 		/* struct getbmap is a strict subset of struct getbmapx. */
886 		recsize = sizeof(struct getbmap);
887 		break;
888 	case XFS_IOC_GETBMAPX:
889 		recsize = sizeof(struct getbmapx);
890 		break;
891 	default:
892 		return -EINVAL;
893 	}
894 
895 	if (copy_from_user(&bmx, arg, recsize))
896 		return -EFAULT;
897 
898 	if (bmx.bmv_count < 2)
899 		return -EINVAL;
900 	if (bmx.bmv_count >= INT_MAX / recsize)
901 		return -ENOMEM;
902 
903 	buf = kvcalloc(bmx.bmv_count, sizeof(*buf), GFP_KERNEL);
904 	if (!buf)
905 		return -ENOMEM;
906 
907 	error = xfs_getbmap(XFS_I(file_inode(file)), &bmx, buf);
908 	if (error)
909 		goto out_free_buf;
910 
911 	error = -EFAULT;
912 	if (copy_to_user(arg, &bmx, recsize))
913 		goto out_free_buf;
914 	arg += recsize;
915 
916 	for (i = 0; i < bmx.bmv_entries; i++) {
917 		if (!xfs_getbmap_format(buf + i, arg, recsize))
918 			goto out_free_buf;
919 		arg += recsize;
920 	}
921 
922 	error = 0;
923 out_free_buf:
924 	kvfree(buf);
925 	return error;
926 }
927 
928 int
xfs_ioc_swapext(xfs_swapext_t * sxp)929 xfs_ioc_swapext(
930 	xfs_swapext_t	*sxp)
931 {
932 	xfs_inode_t     *ip, *tip;
933 
934 	/* Pull information for the target fd */
935 	CLASS(fd, f)((int)sxp->sx_fdtarget);
936 	if (fd_empty(f))
937 		return -EINVAL;
938 
939 	if (!(fd_file(f)->f_mode & FMODE_WRITE) ||
940 	    !(fd_file(f)->f_mode & FMODE_READ) ||
941 	    (fd_file(f)->f_flags & O_APPEND))
942 		return -EBADF;
943 
944 	CLASS(fd, tmp)((int)sxp->sx_fdtmp);
945 	if (fd_empty(tmp))
946 		return -EINVAL;
947 
948 	if (!(fd_file(tmp)->f_mode & FMODE_WRITE) ||
949 	    !(fd_file(tmp)->f_mode & FMODE_READ) ||
950 	    (fd_file(tmp)->f_flags & O_APPEND))
951 		return -EBADF;
952 
953 	if (IS_SWAPFILE(file_inode(fd_file(f))) ||
954 	    IS_SWAPFILE(file_inode(fd_file(tmp))))
955 		return -EINVAL;
956 
957 	/*
958 	 * We need to ensure that the fds passed in point to XFS inodes
959 	 * before we cast and access them as XFS structures as we have no
960 	 * control over what the user passes us here.
961 	 */
962 	if (fd_file(f)->f_op != &xfs_file_operations ||
963 	    fd_file(tmp)->f_op != &xfs_file_operations)
964 		return -EINVAL;
965 
966 	ip = XFS_I(file_inode(fd_file(f)));
967 	tip = XFS_I(file_inode(fd_file(tmp)));
968 
969 	if (ip->i_mount != tip->i_mount)
970 		return -EINVAL;
971 
972 	if (ip->i_ino == tip->i_ino)
973 		return -EINVAL;
974 
975 	if (xfs_is_shutdown(ip->i_mount))
976 		return -EIO;
977 
978 	return xfs_swap_extents(ip, tip, sxp);
979 }
980 
981 static int
xfs_ioc_getlabel(struct xfs_mount * mp,char __user * user_label)982 xfs_ioc_getlabel(
983 	struct xfs_mount	*mp,
984 	char			__user *user_label)
985 {
986 	struct xfs_sb		*sbp = &mp->m_sb;
987 	char			label[XFSLABEL_MAX + 1];
988 
989 	/* Paranoia */
990 	BUILD_BUG_ON(sizeof(sbp->sb_fname) > FSLABEL_MAX);
991 
992 	/* 1 larger than sb_fname, so this ensures a trailing NUL char */
993 	memset(label, 0, sizeof(label));
994 	spin_lock(&mp->m_sb_lock);
995 	strncpy(label, sbp->sb_fname, XFSLABEL_MAX);
996 	spin_unlock(&mp->m_sb_lock);
997 
998 	if (copy_to_user(user_label, label, sizeof(label)))
999 		return -EFAULT;
1000 	return 0;
1001 }
1002 
1003 static int
xfs_ioc_setlabel(struct file * filp,struct xfs_mount * mp,char __user * newlabel)1004 xfs_ioc_setlabel(
1005 	struct file		*filp,
1006 	struct xfs_mount	*mp,
1007 	char			__user *newlabel)
1008 {
1009 	struct xfs_sb		*sbp = &mp->m_sb;
1010 	char			label[XFSLABEL_MAX + 1];
1011 	size_t			len;
1012 	int			error;
1013 
1014 	if (!capable(CAP_SYS_ADMIN))
1015 		return -EPERM;
1016 	/*
1017 	 * The generic ioctl allows up to FSLABEL_MAX chars, but XFS is much
1018 	 * smaller, at 12 bytes.  We copy one more to be sure we find the
1019 	 * (required) NULL character to test the incoming label length.
1020 	 * NB: The on disk label doesn't need to be null terminated.
1021 	 */
1022 	if (copy_from_user(label, newlabel, XFSLABEL_MAX + 1))
1023 		return -EFAULT;
1024 	len = strnlen(label, XFSLABEL_MAX + 1);
1025 	if (len > sizeof(sbp->sb_fname))
1026 		return -EINVAL;
1027 
1028 	error = mnt_want_write_file(filp);
1029 	if (error)
1030 		return error;
1031 
1032 	spin_lock(&mp->m_sb_lock);
1033 	memset(sbp->sb_fname, 0, sizeof(sbp->sb_fname));
1034 	memcpy(sbp->sb_fname, label, len);
1035 	spin_unlock(&mp->m_sb_lock);
1036 
1037 	/*
1038 	 * Now we do several things to satisfy userspace.
1039 	 * In addition to normal logging of the primary superblock, we also
1040 	 * immediately write these changes to sector zero for the primary, then
1041 	 * update all backup supers (as xfs_db does for a label change), then
1042 	 * invalidate the block device page cache.  This is so that any prior
1043 	 * buffered reads from userspace (i.e. from blkid) are invalidated,
1044 	 * and userspace will see the newly-written label.
1045 	 */
1046 	error = xfs_sync_sb_buf(mp, true);
1047 	if (error)
1048 		goto out;
1049 	/*
1050 	 * growfs also updates backup supers so lock against that.
1051 	 */
1052 	mutex_lock(&mp->m_growlock);
1053 	error = xfs_update_secondary_sbs(mp);
1054 	mutex_unlock(&mp->m_growlock);
1055 
1056 	invalidate_bdev(mp->m_ddev_targp->bt_bdev);
1057 	if (xfs_has_rtsb(mp) && mp->m_rtdev_targp)
1058 		invalidate_bdev(mp->m_rtdev_targp->bt_bdev);
1059 
1060 out:
1061 	mnt_drop_write_file(filp);
1062 	return error;
1063 }
1064 
1065 static inline int
xfs_fs_eofblocks_from_user(struct xfs_fs_eofblocks * src,struct xfs_icwalk * dst)1066 xfs_fs_eofblocks_from_user(
1067 	struct xfs_fs_eofblocks		*src,
1068 	struct xfs_icwalk		*dst)
1069 {
1070 	if (src->eof_version != XFS_EOFBLOCKS_VERSION)
1071 		return -EINVAL;
1072 
1073 	if (src->eof_flags & ~XFS_EOF_FLAGS_VALID)
1074 		return -EINVAL;
1075 
1076 	if (memchr_inv(&src->pad32, 0, sizeof(src->pad32)) ||
1077 	    memchr_inv(src->pad64, 0, sizeof(src->pad64)))
1078 		return -EINVAL;
1079 
1080 	dst->icw_flags = 0;
1081 	if (src->eof_flags & XFS_EOF_FLAGS_SYNC)
1082 		dst->icw_flags |= XFS_ICWALK_FLAG_SYNC;
1083 	if (src->eof_flags & XFS_EOF_FLAGS_UID)
1084 		dst->icw_flags |= XFS_ICWALK_FLAG_UID;
1085 	if (src->eof_flags & XFS_EOF_FLAGS_GID)
1086 		dst->icw_flags |= XFS_ICWALK_FLAG_GID;
1087 	if (src->eof_flags & XFS_EOF_FLAGS_PRID)
1088 		dst->icw_flags |= XFS_ICWALK_FLAG_PRID;
1089 	if (src->eof_flags & XFS_EOF_FLAGS_MINFILESIZE)
1090 		dst->icw_flags |= XFS_ICWALK_FLAG_MINFILESIZE;
1091 
1092 	dst->icw_prid = src->eof_prid;
1093 	dst->icw_min_file_size = src->eof_min_file_size;
1094 
1095 	dst->icw_uid = INVALID_UID;
1096 	if (src->eof_flags & XFS_EOF_FLAGS_UID) {
1097 		dst->icw_uid = make_kuid(current_user_ns(), src->eof_uid);
1098 		if (!uid_valid(dst->icw_uid))
1099 			return -EINVAL;
1100 	}
1101 
1102 	dst->icw_gid = INVALID_GID;
1103 	if (src->eof_flags & XFS_EOF_FLAGS_GID) {
1104 		dst->icw_gid = make_kgid(current_user_ns(), src->eof_gid);
1105 		if (!gid_valid(dst->icw_gid))
1106 			return -EINVAL;
1107 	}
1108 	return 0;
1109 }
1110 
1111 static int
xfs_ioctl_getset_resblocks(struct file * filp,unsigned int cmd,void __user * arg)1112 xfs_ioctl_getset_resblocks(
1113 	struct file		*filp,
1114 	unsigned int		cmd,
1115 	void __user		*arg)
1116 {
1117 	struct xfs_mount	*mp = XFS_I(file_inode(filp))->i_mount;
1118 	struct xfs_fsop_resblks	fsop = { };
1119 	int			error;
1120 
1121 	if (!capable(CAP_SYS_ADMIN))
1122 		return -EPERM;
1123 
1124 	if (cmd == XFS_IOC_SET_RESBLKS) {
1125 		if (xfs_is_readonly(mp))
1126 			return -EROFS;
1127 
1128 		if (copy_from_user(&fsop, arg, sizeof(fsop)))
1129 			return -EFAULT;
1130 
1131 		error = mnt_want_write_file(filp);
1132 		if (error)
1133 			return error;
1134 		error = xfs_reserve_blocks(mp, fsop.resblks);
1135 		mnt_drop_write_file(filp);
1136 		if (error)
1137 			return error;
1138 	}
1139 
1140 	spin_lock(&mp->m_sb_lock);
1141 	fsop.resblks = mp->m_resblks;
1142 	fsop.resblks_avail = mp->m_resblks_avail;
1143 	spin_unlock(&mp->m_sb_lock);
1144 
1145 	if (copy_to_user(arg, &fsop, sizeof(fsop)))
1146 		return -EFAULT;
1147 	return 0;
1148 }
1149 
1150 static int
xfs_ioctl_fs_counts(struct xfs_mount * mp,struct xfs_fsop_counts __user * uarg)1151 xfs_ioctl_fs_counts(
1152 	struct xfs_mount	*mp,
1153 	struct xfs_fsop_counts __user	*uarg)
1154 {
1155 	struct xfs_fsop_counts	out = {
1156 		.allocino = percpu_counter_read_positive(&mp->m_icount),
1157 		.freeino  = percpu_counter_read_positive(&mp->m_ifree),
1158 		.freedata = percpu_counter_read_positive(&mp->m_fdblocks) -
1159 				xfs_fdblocks_unavailable(mp),
1160 		.freertx  = percpu_counter_read_positive(&mp->m_frextents),
1161 	};
1162 
1163 	if (copy_to_user(uarg, &out, sizeof(out)))
1164 		return -EFAULT;
1165 	return 0;
1166 }
1167 
1168 /*
1169  * These long-unused ioctls were removed from the official ioctl API in 5.17,
1170  * but retain these definitions so that we can log warnings about them.
1171  */
1172 #define XFS_IOC_ALLOCSP		_IOW ('X', 10, struct xfs_flock64)
1173 #define XFS_IOC_FREESP		_IOW ('X', 11, struct xfs_flock64)
1174 #define XFS_IOC_ALLOCSP64	_IOW ('X', 36, struct xfs_flock64)
1175 #define XFS_IOC_FREESP64	_IOW ('X', 37, struct xfs_flock64)
1176 
1177 /*
1178  * Note: some of the ioctl's return positive numbers as a
1179  * byte count indicating success, such as readlink_by_handle.
1180  * So we don't "sign flip" like most other routines.  This means
1181  * true errors need to be returned as a negative value.
1182  */
1183 long
xfs_file_ioctl(struct file * filp,unsigned int cmd,unsigned long p)1184 xfs_file_ioctl(
1185 	struct file		*filp,
1186 	unsigned int		cmd,
1187 	unsigned long		p)
1188 {
1189 	struct inode		*inode = file_inode(filp);
1190 	struct xfs_inode	*ip = XFS_I(inode);
1191 	struct xfs_mount	*mp = ip->i_mount;
1192 	void			__user *arg = (void __user *)p;
1193 	int			error;
1194 
1195 	trace_xfs_file_ioctl(ip);
1196 
1197 	switch (cmd) {
1198 	case FITRIM:
1199 		return xfs_ioc_trim(mp, arg);
1200 	case FS_IOC_GETFSLABEL:
1201 		return xfs_ioc_getlabel(mp, arg);
1202 	case FS_IOC_SETFSLABEL:
1203 		return xfs_ioc_setlabel(filp, mp, arg);
1204 	case XFS_IOC_ALLOCSP:
1205 	case XFS_IOC_FREESP:
1206 	case XFS_IOC_ALLOCSP64:
1207 	case XFS_IOC_FREESP64:
1208 		xfs_warn_once(mp,
1209 	"%s should use fallocate; XFS_IOC_{ALLOC,FREE}SP ioctl unsupported",
1210 				current->comm);
1211 		return -ENOTTY;
1212 	case XFS_IOC_DIOINFO: {
1213 		struct xfs_buftarg	*target = xfs_inode_buftarg(ip);
1214 		struct dioattr		da;
1215 
1216 		da.d_mem = target->bt_logical_sectorsize;
1217 
1218 		/*
1219 		 * See xfs_report_dioalign() for an explanation about why this
1220 		 * reports a value larger than the sector size for COW inodes.
1221 		 */
1222 		if (xfs_is_cow_inode(ip))
1223 			da.d_miniosz = xfs_inode_alloc_unitsize(ip);
1224 		else
1225 			da.d_miniosz = target->bt_logical_sectorsize;
1226 		da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1227 
1228 		if (copy_to_user(arg, &da, sizeof(da)))
1229 			return -EFAULT;
1230 		return 0;
1231 	}
1232 
1233 	case XFS_IOC_FSBULKSTAT_SINGLE:
1234 	case XFS_IOC_FSBULKSTAT:
1235 	case XFS_IOC_FSINUMBERS:
1236 		return xfs_ioc_fsbulkstat(filp, cmd, arg);
1237 
1238 	case XFS_IOC_BULKSTAT:
1239 		return xfs_ioc_bulkstat(filp, cmd, arg);
1240 	case XFS_IOC_INUMBERS:
1241 		return xfs_ioc_inumbers(mp, cmd, arg);
1242 
1243 	case XFS_IOC_FSGEOMETRY_V1:
1244 		return xfs_ioc_fsgeometry(mp, arg, 3);
1245 	case XFS_IOC_FSGEOMETRY_V4:
1246 		return xfs_ioc_fsgeometry(mp, arg, 4);
1247 	case XFS_IOC_FSGEOMETRY:
1248 		return xfs_ioc_fsgeometry(mp, arg, 5);
1249 
1250 	case XFS_IOC_AG_GEOMETRY:
1251 		return xfs_ioc_ag_geometry(mp, arg);
1252 	case XFS_IOC_RTGROUP_GEOMETRY:
1253 		return xfs_ioc_rtgroup_geometry(mp, arg);
1254 
1255 	case XFS_IOC_GETVERSION:
1256 		return put_user(inode->i_generation, (int __user *)arg);
1257 
1258 	case XFS_IOC_FSGETXATTRA:
1259 		return xfs_ioc_fsgetxattra(ip, arg);
1260 	case XFS_IOC_GETPARENTS:
1261 		return xfs_ioc_getparents(filp, arg);
1262 	case XFS_IOC_GETPARENTS_BY_HANDLE:
1263 		return xfs_ioc_getparents_by_handle(filp, arg);
1264 	case XFS_IOC_GETBMAP:
1265 	case XFS_IOC_GETBMAPA:
1266 	case XFS_IOC_GETBMAPX:
1267 		return xfs_ioc_getbmap(filp, cmd, arg);
1268 
1269 	case FS_IOC_GETFSMAP:
1270 		return xfs_ioc_getfsmap(ip, arg);
1271 
1272 	case XFS_IOC_SCRUBV_METADATA:
1273 		return xfs_ioc_scrubv_metadata(filp, arg);
1274 	case XFS_IOC_SCRUB_METADATA:
1275 		return xfs_ioc_scrub_metadata(filp, arg);
1276 
1277 	case XFS_IOC_FD_TO_HANDLE:
1278 	case XFS_IOC_PATH_TO_HANDLE:
1279 	case XFS_IOC_PATH_TO_FSHANDLE: {
1280 		xfs_fsop_handlereq_t	hreq;
1281 
1282 		if (copy_from_user(&hreq, arg, sizeof(hreq)))
1283 			return -EFAULT;
1284 		return xfs_find_handle(cmd, &hreq);
1285 	}
1286 	case XFS_IOC_OPEN_BY_HANDLE: {
1287 		xfs_fsop_handlereq_t	hreq;
1288 
1289 		if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1290 			return -EFAULT;
1291 		return xfs_open_by_handle(filp, &hreq);
1292 	}
1293 
1294 	case XFS_IOC_READLINK_BY_HANDLE: {
1295 		xfs_fsop_handlereq_t	hreq;
1296 
1297 		if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1298 			return -EFAULT;
1299 		return xfs_readlink_by_handle(filp, &hreq);
1300 	}
1301 	case XFS_IOC_ATTRLIST_BY_HANDLE:
1302 		return xfs_attrlist_by_handle(filp, arg);
1303 
1304 	case XFS_IOC_ATTRMULTI_BY_HANDLE:
1305 		return xfs_attrmulti_by_handle(filp, arg);
1306 
1307 	case XFS_IOC_SWAPEXT: {
1308 		struct xfs_swapext	sxp;
1309 
1310 		if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
1311 			return -EFAULT;
1312 		error = mnt_want_write_file(filp);
1313 		if (error)
1314 			return error;
1315 		error = xfs_ioc_swapext(&sxp);
1316 		mnt_drop_write_file(filp);
1317 		return error;
1318 	}
1319 
1320 	case XFS_IOC_FSCOUNTS:
1321 		return xfs_ioctl_fs_counts(mp, arg);
1322 
1323 	case XFS_IOC_SET_RESBLKS:
1324 	case XFS_IOC_GET_RESBLKS:
1325 		return xfs_ioctl_getset_resblocks(filp, cmd, arg);
1326 
1327 	case XFS_IOC_FSGROWFSDATA: {
1328 		struct xfs_growfs_data in;
1329 
1330 		if (copy_from_user(&in, arg, sizeof(in)))
1331 			return -EFAULT;
1332 
1333 		error = mnt_want_write_file(filp);
1334 		if (error)
1335 			return error;
1336 		error = xfs_growfs_data(mp, &in);
1337 		mnt_drop_write_file(filp);
1338 		return error;
1339 	}
1340 
1341 	case XFS_IOC_FSGROWFSLOG: {
1342 		struct xfs_growfs_log in;
1343 
1344 		if (copy_from_user(&in, arg, sizeof(in)))
1345 			return -EFAULT;
1346 
1347 		error = mnt_want_write_file(filp);
1348 		if (error)
1349 			return error;
1350 		error = xfs_growfs_log(mp, &in);
1351 		mnt_drop_write_file(filp);
1352 		return error;
1353 	}
1354 
1355 	case XFS_IOC_FSGROWFSRT: {
1356 		xfs_growfs_rt_t in;
1357 
1358 		if (copy_from_user(&in, arg, sizeof(in)))
1359 			return -EFAULT;
1360 
1361 		error = mnt_want_write_file(filp);
1362 		if (error)
1363 			return error;
1364 		error = xfs_growfs_rt(mp, &in);
1365 		mnt_drop_write_file(filp);
1366 		return error;
1367 	}
1368 
1369 	case XFS_IOC_GOINGDOWN: {
1370 		uint32_t in;
1371 
1372 		if (!capable(CAP_SYS_ADMIN))
1373 			return -EPERM;
1374 
1375 		if (get_user(in, (uint32_t __user *)arg))
1376 			return -EFAULT;
1377 
1378 		return xfs_fs_goingdown(mp, in);
1379 	}
1380 
1381 	case XFS_IOC_ERROR_INJECTION: {
1382 		xfs_error_injection_t in;
1383 
1384 		if (!capable(CAP_SYS_ADMIN))
1385 			return -EPERM;
1386 
1387 		if (copy_from_user(&in, arg, sizeof(in)))
1388 			return -EFAULT;
1389 
1390 		return xfs_errortag_add(mp, in.errtag);
1391 	}
1392 
1393 	case XFS_IOC_ERROR_CLEARALL:
1394 		if (!capable(CAP_SYS_ADMIN))
1395 			return -EPERM;
1396 
1397 		return xfs_errortag_clearall(mp);
1398 
1399 	case XFS_IOC_FREE_EOFBLOCKS: {
1400 		struct xfs_fs_eofblocks	eofb;
1401 		struct xfs_icwalk	icw;
1402 
1403 		if (!capable(CAP_SYS_ADMIN))
1404 			return -EPERM;
1405 
1406 		if (xfs_is_readonly(mp))
1407 			return -EROFS;
1408 
1409 		if (copy_from_user(&eofb, arg, sizeof(eofb)))
1410 			return -EFAULT;
1411 
1412 		error = xfs_fs_eofblocks_from_user(&eofb, &icw);
1413 		if (error)
1414 			return error;
1415 
1416 		trace_xfs_ioc_free_eofblocks(mp, &icw, _RET_IP_);
1417 
1418 		sb_start_write(mp->m_super);
1419 		error = xfs_blockgc_free_space(mp, &icw);
1420 		sb_end_write(mp->m_super);
1421 		return error;
1422 	}
1423 
1424 	case XFS_IOC_EXCHANGE_RANGE:
1425 		return xfs_ioc_exchange_range(filp, arg);
1426 	case XFS_IOC_START_COMMIT:
1427 		return xfs_ioc_start_commit(filp, arg);
1428 	case XFS_IOC_COMMIT_RANGE:
1429 		return xfs_ioc_commit_range(filp, arg);
1430 
1431 	default:
1432 		return -ENOTTY;
1433 	}
1434 }
1435