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_export.h"
27	#include "xfs_trace.h"
28	#include "xfs_icache.h"
29	#include "xfs_trans.h"
30	#include "xfs_acl.h"
31	#include "xfs_btree.h"
32	#include <linux/fsmap.h>
33	#include "xfs_fsmap.h"
34	#include "scrub/xfs_scrub.h"
35	#include "xfs_sb.h"
36	#include "xfs_ag.h"
37	#include "xfs_health.h"
38	#include "xfs_reflink.h"
39	#include "xfs_ioctl.h"
40	#include "xfs_xattr.h"
41	#include "xfs_rtbitmap.h"
42
43	#include <linux/mount.h>
44	#include <linux/namei.h>
45	#include <linux/fileattr.h>
46
47	/*
48	* xfs_find_handle maps from userspace xfs_fsop_handlereq structure to
49	* a file or fs handle.
50	*
51	* XFS_IOC_PATH_TO_FSHANDLE
52	* returns fs handle for a mount point or path within that mount point
53	* XFS_IOC_FD_TO_HANDLE
54	* returns full handle for a FD opened in user space
55	* XFS_IOC_PATH_TO_HANDLE
56	* returns full handle for a path
57	*/
58	int
59	xfs_find_handle(
60	unsigned int cmd,
61	xfs_fsop_handlereq_t *hreq)
62	{
63	int hsize;
64	xfs_handle_t handle;
65	struct inode *inode;
66	struct fd f = {NULL};
67	struct path path;
68	int error;
69	struct xfs_inode *ip;
70
71	if (cmd == XFS_IOC_FD_TO_HANDLE) {
72	f = fdget(fd: hreq->fd);
73	if (!f.file)
74	return -EBADF;
75	inode = file_inode(f: f.file);
76	} else {
77	error = user_path_at(AT_FDCWD, name: hreq->path, flags: 0, path: &path);
78	if (error)
79	return error;
80	inode = d_inode(dentry: path.dentry);
81	}
82	ip = XFS_I(inode);
83
84	/*
85	* We can only generate handles for inodes residing on a XFS filesystem,
86	* and only for regular files, directories or symbolic links.
87	*/
88	error = -EINVAL;
89	if (inode->i_sb->s_magic != XFS_SB_MAGIC)
90	goto out_put;
91
92	error = -EBADF;
93	if (!S_ISREG(inode->i_mode) &&
94	!S_ISDIR(inode->i_mode) &&
95	!S_ISLNK(inode->i_mode))
96	goto out_put;
97
98
99	memcpy(&handle.ha_fsid, ip->i_mount->m_fixedfsid, sizeof(xfs_fsid_t));
100
101	if (cmd == XFS_IOC_PATH_TO_FSHANDLE) {
102	/*
103	* This handle only contains an fsid, zero the rest.
104	*/
105	memset(&handle.ha_fid, 0, sizeof(handle.ha_fid));
106	hsize = sizeof(xfs_fsid_t);
107	} else {
108	handle.ha_fid.fid_len = sizeof(xfs_fid_t) -
109	sizeof(handle.ha_fid.fid_len);
110	handle.ha_fid.fid_pad = 0;
111	handle.ha_fid.fid_gen = inode->i_generation;
112	handle.ha_fid.fid_ino = ip->i_ino;
113	hsize = sizeof(xfs_handle_t);
114	}
115
116	error = -EFAULT;
117	if (copy_to_user(hreq->ohandle, &handle, hsize) ||
118	copy_to_user(hreq->ohandlen, &hsize, sizeof(__s32)))
119	goto out_put;
120
121	error = 0;
122
123	out_put:
124	if (cmd == XFS_IOC_FD_TO_HANDLE)
125	fdput(fd: f);
126	else
127	path_put(&path);
128	return error;
129	}
130
131	/*
132	* No need to do permission checks on the various pathname components
133	* as the handle operations are privileged.
134	*/
135	STATIC int
136	xfs_handle_acceptable(
137	void *context,
138	struct dentry *dentry)
139	{
140	return 1;
141	}
142
143	/*
144	* Convert userspace handle data into a dentry.
145	*/
146	struct dentry *
147	xfs_handle_to_dentry(
148	struct file *parfilp,
149	void __user *uhandle,
150	u32 hlen)
151	{
152	xfs_handle_t handle;
153	struct xfs_fid64 fid;
154
155	/*
156	* Only allow handle opens under a directory.
157	*/
158	if (!S_ISDIR(file_inode(parfilp)->i_mode))
159	return ERR_PTR(error: -ENOTDIR);
160
161	if (hlen != sizeof(xfs_handle_t))
162	return ERR_PTR(error: -EINVAL);
163	if (copy_from_user(&handle, uhandle, hlen))
164	return ERR_PTR(error: -EFAULT);
165	if (handle.ha_fid.fid_len !=
166	sizeof(handle.ha_fid) - sizeof(handle.ha_fid.fid_len))
167	return ERR_PTR(error: -EINVAL);
168
169	memset(&fid, 0, sizeof(struct fid));
170	fid.ino = handle.ha_fid.fid_ino;
171	fid.gen = handle.ha_fid.fid_gen;
172
173	return exportfs_decode_fh(mnt: parfilp->f_path.mnt, fid: (struct fid *)&fid, fh_len: 3,
174	fileid_type: FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG,
175	acceptable: xfs_handle_acceptable, NULL);
176	}
177
178	STATIC struct dentry *
179	xfs_handlereq_to_dentry(
180	struct file *parfilp,
181	xfs_fsop_handlereq_t *hreq)
182	{
183	return xfs_handle_to_dentry(parfilp, uhandle: hreq->ihandle, hlen: hreq->ihandlen);
184	}
185
186	int
187	xfs_open_by_handle(
188	struct file *parfilp,
189	xfs_fsop_handlereq_t *hreq)
190	{
191	const struct cred *cred = current_cred();
192	int error;
193	int fd;
194	int permflag;
195	struct file *filp;
196	struct inode *inode;
197	struct dentry *dentry;
198	fmode_t fmode;
199	struct path path;
200
201	if (!capable(CAP_SYS_ADMIN))
202	return -EPERM;
203
204	dentry = xfs_handlereq_to_dentry(parfilp, hreq);
205	if (IS_ERR(ptr: dentry))
206	return PTR_ERR(ptr: dentry);
207	inode = d_inode(dentry);
208
209	/* Restrict xfs_open_by_handle to directories & regular files. */
210	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
211	error = -EPERM;
212	goto out_dput;
213	}
214
215	#if BITS_PER_LONG != 32
216	hreq->oflags |= O_LARGEFILE;
217	#endif
218
219	permflag = hreq->oflags;
220	fmode = OPEN_FMODE(permflag);
221	if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&
222	(fmode & FMODE_WRITE) && IS_APPEND(inode)) {
223	error = -EPERM;
224	goto out_dput;
225	}
226
227	if ((fmode & FMODE_WRITE) && IS_IMMUTABLE(inode)) {
228	error = -EPERM;
229	goto out_dput;
230	}
231
232	/* Can't write directories. */
233	if (S_ISDIR(inode->i_mode) && (fmode & FMODE_WRITE)) {
234	error = -EISDIR;
235	goto out_dput;
236	}
237
238	fd = get_unused_fd_flags(flags: 0);
239	if (fd < 0) {
240	error = fd;
241	goto out_dput;
242	}
243
244	path.mnt = parfilp->f_path.mnt;
245	path.dentry = dentry;
246	filp = dentry_open(path: &path, flags: hreq->oflags, creds: cred);
247	dput(dentry);
248	if (IS_ERR(ptr: filp)) {
249	put_unused_fd(fd);
250	return PTR_ERR(ptr: filp);
251	}
252
253	if (S_ISREG(inode->i_mode)) {
254	filp->f_flags |= O_NOATIME;
255	filp->f_mode |= FMODE_NOCMTIME;
256	}
257
258	fd_install(fd, file: filp);
259	return fd;
260
261	out_dput:
262	dput(dentry);
263	return error;
264	}
265
266	int
267	xfs_readlink_by_handle(
268	struct file *parfilp,
269	xfs_fsop_handlereq_t *hreq)
270	{
271	struct dentry *dentry;
272	__u32 olen;
273	int error;
274
275	if (!capable(CAP_SYS_ADMIN))
276	return -EPERM;
277
278	dentry = xfs_handlereq_to_dentry(parfilp, hreq);
279	if (IS_ERR(ptr: dentry))
280	return PTR_ERR(ptr: dentry);
281
282	/* Restrict this handle operation to symlinks only. */
283	if (!d_is_symlink(dentry)) {
284	error = -EINVAL;
285	goto out_dput;
286	}
287
288	if (copy_from_user(to: &olen, from: hreq->ohandlen, n: sizeof(__u32))) {
289	error = -EFAULT;
290	goto out_dput;
291	}
292
293	error = vfs_readlink(dentry, hreq->ohandle, olen);
294
295	out_dput:
296	dput(dentry);
297	return error;
298	}
299
300	/*
301	* Format an attribute and copy it out to the user's buffer.
302	* Take care to check values and protect against them changing later,
303	* we may be reading them directly out of a user buffer.
304	*/
305	static void
306	xfs_ioc_attr_put_listent(
307	struct xfs_attr_list_context *context,
308	int flags,
309	unsigned char *name,
310	int namelen,
311	int valuelen)
312	{
313	struct xfs_attrlist *alist = context->buffer;
314	struct xfs_attrlist_ent *aep;
315	int arraytop;
316
317	ASSERT(!context->seen_enough);
318	ASSERT(context->count >= 0);
319	ASSERT(context->count < (ATTR_MAX_VALUELEN/8));
320	ASSERT(context->firstu >= sizeof(*alist));
321	ASSERT(context->firstu <= context->bufsize);
322
323	/*
324	* Only list entries in the right namespace.
325	*/
326	if (context->attr_filter != (flags & XFS_ATTR_NSP_ONDISK_MASK))
327	return;
328
329	arraytop = sizeof(*alist) +
330	context->count * sizeof(alist->al_offset[0]);
331
332	/* decrement by the actual bytes used by the attr */
333	context->firstu -= round_up(offsetof(struct xfs_attrlist_ent, a_name) +
334	namelen + 1, sizeof(uint32_t));
335	if (context->firstu < arraytop) {
336	trace_xfs_attr_list_full(ctx: context);
337	alist->al_more = 1;
338	context->seen_enough = 1;
339	return;
340	}
341
342	aep = context->buffer + context->firstu;
343	aep->a_valuelen = valuelen;
344	memcpy(aep->a_name, name, namelen);
345	aep->a_name[namelen] = 0;
346	alist->al_offset[context->count++] = context->firstu;
347	alist->al_count = context->count;
348	trace_xfs_attr_list_add(ctx: context);
349	}
350
351	static unsigned int
352	xfs_attr_filter(
353	u32 ioc_flags)
354	{
355	if (ioc_flags & XFS_IOC_ATTR_ROOT)
356	return XFS_ATTR_ROOT;
357	if (ioc_flags & XFS_IOC_ATTR_SECURE)
358	return XFS_ATTR_SECURE;
359	return 0;
360	}
361
362	static unsigned int
363	xfs_attr_flags(
364	u32 ioc_flags)
365	{
366	if (ioc_flags & XFS_IOC_ATTR_CREATE)
367	return XATTR_CREATE;
368	if (ioc_flags & XFS_IOC_ATTR_REPLACE)
369	return XATTR_REPLACE;
370	return 0;
371	}
372
373	int
374	xfs_ioc_attr_list(
375	struct xfs_inode *dp,
376	void __user *ubuf,
377	size_t bufsize,
378	int flags,
379	struct xfs_attrlist_cursor __user *ucursor)
380	{
381	struct xfs_attr_list_context context = { };
382	struct xfs_attrlist *alist;
383	void *buffer;
384	int error;
385
386	if (bufsize < sizeof(struct xfs_attrlist) ||
387	bufsize > XFS_XATTR_LIST_MAX)
388	return -EINVAL;
389
390	/*
391	* Reject flags, only allow namespaces.
392	*/
393	if (flags & ~(XFS_IOC_ATTR_ROOT | XFS_IOC_ATTR_SECURE))
394	return -EINVAL;
395	if (flags == (XFS_IOC_ATTR_ROOT | XFS_IOC_ATTR_SECURE))
396	return -EINVAL;
397
398	/*
399	* Validate the cursor.
400	*/
401	if (copy_from_user(to: &context.cursor, from: ucursor, n: sizeof(context.cursor)))
402	return -EFAULT;
403	if (context.cursor.pad1 || context.cursor.pad2)
404	return -EINVAL;
405	if (!context.cursor.initted &&
406	(context.cursor.hashval || context.cursor.blkno ||
407	context.cursor.offset))
408	return -EINVAL;
409
410	buffer = kvzalloc(size: bufsize, GFP_KERNEL);
411	if (!buffer)
412	return -ENOMEM;
413
414	/*
415	* Initialize the output buffer.
416	*/
417	context.dp = dp;
418	context.resynch = 1;
419	context.attr_filter = xfs_attr_filter(ioc_flags: flags);
420	context.buffer = buffer;
421	context.bufsize = round_down(bufsize, sizeof(uint32_t));
422	context.firstu = context.bufsize;
423	context.put_listent = xfs_ioc_attr_put_listent;
424
425	alist = context.buffer;
426	alist->al_count = 0;
427	alist->al_more = 0;
428	alist->al_offset[0] = context.bufsize;
429
430	error = xfs_attr_list(&context);
431	if (error)
432	goto out_free;
433
434	if (copy_to_user(to: ubuf, from: buffer, n: bufsize) ||
435	copy_to_user(to: ucursor, from: &context.cursor, n: sizeof(context.cursor)))
436	error = -EFAULT;
437	out_free:
438	kvfree(addr: buffer);
439	return error;
440	}
441
442	STATIC int
443	xfs_attrlist_by_handle(
444	struct file *parfilp,
445	struct xfs_fsop_attrlist_handlereq __user *p)
446	{
447	struct xfs_fsop_attrlist_handlereq al_hreq;
448	struct dentry *dentry;
449	int error = -ENOMEM;
450
451	if (!capable(CAP_SYS_ADMIN))
452	return -EPERM;
453	if (copy_from_user(to: &al_hreq, from: p, n: sizeof(al_hreq)))
454	return -EFAULT;
455
456	dentry = xfs_handlereq_to_dentry(parfilp, &al_hreq.hreq);
457	if (IS_ERR(ptr: dentry))
458	return PTR_ERR(ptr: dentry);
459
460	error = xfs_ioc_attr_list(dp: XFS_I(inode: d_inode(dentry)), ubuf: al_hreq.buffer,
461	bufsize: al_hreq.buflen, flags: al_hreq.flags, ucursor: &p->pos);
462	dput(dentry);
463	return error;
464	}
465
466	static int
467	xfs_attrmulti_attr_get(
468	struct inode *inode,
469	unsigned char *name,
470	unsigned char __user *ubuf,
471	uint32_t *len,
472	uint32_t flags)
473	{
474	struct xfs_da_args args = {
475	.dp = XFS_I(inode),
476	.attr_filter = xfs_attr_filter(flags),
477	.attr_flags = xfs_attr_flags(flags),
478	.name = name,
479	.namelen = strlen(name),
480	.valuelen = *len,
481	};
482	int error;
483
484	if (*len > XFS_XATTR_SIZE_MAX)
485	return -EINVAL;
486
487	error = xfs_attr_get(&args);
488	if (error)
489	goto out_kfree;
490
491	*len = args.valuelen;
492	if (copy_to_user(to: ubuf, from: args.value, n: args.valuelen))
493	error = -EFAULT;
494
495	out_kfree:
496	kvfree(addr: args.value);
497	return error;
498	}
499
500	static int
501	xfs_attrmulti_attr_set(
502	struct inode *inode,
503	unsigned char *name,
504	const unsigned char __user *ubuf,
505	uint32_t len,
506	uint32_t flags)
507	{
508	struct xfs_da_args args = {
509	.dp = XFS_I(inode),
510	.attr_filter = xfs_attr_filter(flags),
511	.attr_flags = xfs_attr_flags(flags),
512	.name = name,
513	.namelen = strlen(name),
514	};
515	int error;
516
517	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
518	return -EPERM;
519
520	if (ubuf) {
521	if (len > XFS_XATTR_SIZE_MAX)
522	return -EINVAL;
523	args.value = memdup_user(ubuf, len);
524	if (IS_ERR(ptr: args.value))
525	return PTR_ERR(ptr: args.value);
526	args.valuelen = len;
527	}
528
529	error = xfs_attr_change(args: &args);
530	if (!error && (flags & XFS_IOC_ATTR_ROOT))
531	xfs_forget_acl(inode, name);
532	kfree(objp: args.value);
533	return error;
534	}
535
536	int
537	xfs_ioc_attrmulti_one(
538	struct file *parfilp,
539	struct inode *inode,
540	uint32_t opcode,
541	void __user *uname,
542	void __user *value,
543	uint32_t *len,
544	uint32_t flags)
545	{
546	unsigned char *name;
547	int error;
548
549	if ((flags & XFS_IOC_ATTR_ROOT) && (flags & XFS_IOC_ATTR_SECURE))
550	return -EINVAL;
551
552	name = strndup_user(uname, MAXNAMELEN);
553	if (IS_ERR(ptr: name))
554	return PTR_ERR(ptr: name);
555
556	switch (opcode) {
557	case ATTR_OP_GET:
558	error = xfs_attrmulti_attr_get(inode, name, ubuf: value, len, flags);
559	break;
560	case ATTR_OP_REMOVE:
561	value = NULL;
562	*len = 0;
563	fallthrough;
564	case ATTR_OP_SET:
565	error = mnt_want_write_file(file: parfilp);
566	if (error)
567	break;
568	error = xfs_attrmulti_attr_set(inode, name, ubuf: value, len: *len, flags);
569	mnt_drop_write_file(file: parfilp);
570	break;
571	default:
572	error = -EINVAL;
573	break;
574	}
575
576	kfree(objp: name);
577	return error;
578	}
579
580	STATIC int
581	xfs_attrmulti_by_handle(
582	struct file *parfilp,
583	void __user *arg)
584	{
585	int error;
586	xfs_attr_multiop_t *ops;
587	xfs_fsop_attrmulti_handlereq_t am_hreq;
588	struct dentry *dentry;
589	unsigned int i, size;
590
591	if (!capable(CAP_SYS_ADMIN))
592	return -EPERM;
593	if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
594	return -EFAULT;
595
596	/* overflow check */
597	if (am_hreq.opcount >= INT_MAX / sizeof(xfs_attr_multiop_t))
598	return -E2BIG;
599
600	dentry = xfs_handlereq_to_dentry(parfilp, &am_hreq.hreq);
601	if (IS_ERR(ptr: dentry))
602	return PTR_ERR(ptr: dentry);
603
604	error = -E2BIG;
605	size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);
606	if (!size || size > 16 * PAGE_SIZE)
607	goto out_dput;
608
609	ops = memdup_user(am_hreq.ops, size);
610	if (IS_ERR(ops)) {
611	error = PTR_ERR(ops);
612	goto out_dput;
613	}
614
615	error = 0;
616	for (i = 0; i < am_hreq.opcount; i++) {
617	ops[i].am_error = xfs_ioc_attrmulti_one(parfilp,
618	d_inode(dentry), ops[i].am_opcode,
619	ops[i].am_attrname, ops[i].am_attrvalue,
620	&ops[i].am_length, ops[i].am_flags);
621	}
622
623	if (copy_to_user(am_hreq.ops, ops, size))
624	error = -EFAULT;
625
626	kfree(ops);
627	out_dput:
628	dput(dentry);
629	return error;
630	}
631
632	/* Return 0 on success or positive error */
633	int
634	xfs_fsbulkstat_one_fmt(
635	struct xfs_ibulk *breq,
636	const struct xfs_bulkstat *bstat)
637	{
638	struct xfs_bstat bs1;
639
640	xfs_bulkstat_to_bstat(mp: breq->mp, bs1: &bs1, bstat);
641	if (copy_to_user(to: breq->ubuffer, from: &bs1, n: sizeof(bs1)))
642	return -EFAULT;
643	return xfs_ibulk_advance(breq, sizeof(struct xfs_bstat));
644	}
645
646	int
647	xfs_fsinumbers_fmt(
648	struct xfs_ibulk *breq,
649	const struct xfs_inumbers *igrp)
650	{
651	struct xfs_inogrp ig1;
652
653	xfs_inumbers_to_inogrp(ig1: &ig1, ig: igrp);
654	if (copy_to_user(breq->ubuffer, &ig1, sizeof(struct xfs_inogrp)))
655	return -EFAULT;
656	return xfs_ibulk_advance(breq, sizeof(struct xfs_inogrp));
657	}
658
659	STATIC int
660	xfs_ioc_fsbulkstat(
661	struct file *file,
662	unsigned int cmd,
663	void __user *arg)
664	{
665	struct xfs_mount *mp = XFS_I(inode: file_inode(f: file))->i_mount;
666	struct xfs_fsop_bulkreq bulkreq;
667	struct xfs_ibulk breq = {
668	.mp = mp,
669	.idmap = file_mnt_idmap(file),
670	.ocount = 0,
671	};
672	xfs_ino_t lastino;
673	int error;
674
675	/* done = 1 if there are more stats to get and if bulkstat */
676	/* should be called again (unused here, but used in dmapi) */
677
678	if (!capable(CAP_SYS_ADMIN))
679	return -EPERM;
680
681	if (xfs_is_shutdown(mp))
682	return -EIO;
683
684	if (copy_from_user(&bulkreq, arg, sizeof(struct xfs_fsop_bulkreq)))
685	return -EFAULT;
686
687	if (copy_from_user(to: &lastino, from: bulkreq.lastip, n: sizeof(__s64)))
688	return -EFAULT;
689
690	if (bulkreq.icount <= 0)
691	return -EINVAL;
692
693	if (bulkreq.ubuffer == NULL)
694	return -EINVAL;
695
696	breq.ubuffer = bulkreq.ubuffer;
697	breq.icount = bulkreq.icount;
698
699	/*
700	* FSBULKSTAT_SINGLE expects that *lastip contains the inode number
701	* that we want to stat. However, FSINUMBERS and FSBULKSTAT expect
702	* that *lastip contains either zero or the number of the last inode to
703	* be examined by the previous call and return results starting with
704	* the next inode after that. The new bulk request back end functions
705	* take the inode to start with, so we have to compute the startino
706	* parameter from lastino to maintain correct function. lastino == 0
707	* is a special case because it has traditionally meant "first inode
708	* in filesystem".
709	*/
710	if (cmd == XFS_IOC_FSINUMBERS) {
711	breq.startino = lastino ? lastino + 1 : 0;
712	error = xfs_inumbers(breq: &breq, formatter: xfs_fsinumbers_fmt);
713	lastino = breq.startino - 1;
714	} else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE) {
715	breq.startino = lastino;
716	breq.icount = 1;
717	error = xfs_bulkstat_one(breq: &breq, formatter: xfs_fsbulkstat_one_fmt);
718	} else { /* XFS_IOC_FSBULKSTAT */
719	breq.startino = lastino ? lastino + 1 : 0;
720	error = xfs_bulkstat(breq: &breq, formatter: xfs_fsbulkstat_one_fmt);
721	lastino = breq.startino - 1;
722	}
723
724	if (error)
725	return error;
726
727	if (bulkreq.lastip != NULL &&
728	copy_to_user(to: bulkreq.lastip, from: &lastino, n: sizeof(xfs_ino_t)))
729	return -EFAULT;
730
731	if (bulkreq.ocount != NULL &&
732	copy_to_user(to: bulkreq.ocount, from: &breq.ocount, n: sizeof(__s32)))
733	return -EFAULT;
734
735	return 0;
736	}
737
738	/* Return 0 on success or positive error */
739	static int
740	xfs_bulkstat_fmt(
741	struct xfs_ibulk *breq,
742	const struct xfs_bulkstat *bstat)
743	{
744	if (copy_to_user(breq->ubuffer, bstat, sizeof(struct xfs_bulkstat)))
745	return -EFAULT;
746	return xfs_ibulk_advance(breq, sizeof(struct xfs_bulkstat));
747	}
748
749	/*
750	* Check the incoming bulk request @hdr from userspace and initialize the
751	* internal @breq bulk request appropriately. Returns 0 if the bulk request
752	* should proceed; -ECANCELED if there's nothing to do; or the usual
753	* negative error code.
754	*/
755	static int
756	xfs_bulk_ireq_setup(
757	struct xfs_mount *mp,
758	const struct xfs_bulk_ireq *hdr,
759	struct xfs_ibulk *breq,
760	void __user *ubuffer)
761	{
762	if (hdr->icount == 0 ||
763	(hdr->flags & ~XFS_BULK_IREQ_FLAGS_ALL) ||
764	memchr_inv(hdr->reserved, 0, sizeof(hdr->reserved)))
765	return -EINVAL;
766
767	breq->startino = hdr->ino;
768	breq->ubuffer = ubuffer;
769	breq->icount = hdr->icount;
770	breq->ocount = 0;
771	breq->flags = 0;
772
773	/*
774	* The @ino parameter is a special value, so we must look it up here.
775	* We're not allowed to have IREQ_AGNO, and we only return one inode
776	* worth of data.
777	*/
778	if (hdr->flags & XFS_BULK_IREQ_SPECIAL) {
779	if (hdr->flags & XFS_BULK_IREQ_AGNO)
780	return -EINVAL;
781
782	switch (hdr->ino) {
783	case XFS_BULK_IREQ_SPECIAL_ROOT:
784	breq->startino = mp->m_sb.sb_rootino;
785	break;
786	default:
787	return -EINVAL;
788	}
789	breq->icount = 1;
790	}
791
792	/*
793	* The IREQ_AGNO flag means that we only want results from a given AG.
794	* If @hdr->ino is zero, we start iterating in that AG. If @hdr->ino is
795	* beyond the specified AG then we return no results.
796	*/
797	if (hdr->flags & XFS_BULK_IREQ_AGNO) {
798	if (hdr->agno >= mp->m_sb.sb_agcount)
799	return -EINVAL;
800
801	if (breq->startino == 0)
802	breq->startino = XFS_AGINO_TO_INO(mp, hdr->agno, 0);
803	else if (XFS_INO_TO_AGNO(mp, breq->startino) < hdr->agno)
804	return -EINVAL;
805
806	breq->flags |= XFS_IBULK_SAME_AG;
807
808	/* Asking for an inode past the end of the AG? We're done! */
809	if (XFS_INO_TO_AGNO(mp, breq->startino) > hdr->agno)
810	return -ECANCELED;
811	} else if (hdr->agno)
812	return -EINVAL;
813
814	/* Asking for an inode past the end of the FS? We're done! */
815	if (XFS_INO_TO_AGNO(mp, breq->startino) >= mp->m_sb.sb_agcount)
816	return -ECANCELED;
817
818	if (hdr->flags & XFS_BULK_IREQ_NREXT64)
819	breq->flags |= XFS_IBULK_NREXT64;
820
821	return 0;
822	}
823
824	/*
825	* Update the userspace bulk request @hdr to reflect the end state of the
826	* internal bulk request @breq.
827	*/
828	static void
829	xfs_bulk_ireq_teardown(
830	struct xfs_bulk_ireq *hdr,
831	struct xfs_ibulk *breq)
832	{
833	hdr->ino = breq->startino;
834	hdr->ocount = breq->ocount;
835	}
836
837	/* Handle the v5 bulkstat ioctl. */
838	STATIC int
839	xfs_ioc_bulkstat(
840	struct file *file,
841	unsigned int cmd,
842	struct xfs_bulkstat_req __user *arg)
843	{
844	struct xfs_mount *mp = XFS_I(inode: file_inode(f: file))->i_mount;
845	struct xfs_bulk_ireq hdr;
846	struct xfs_ibulk breq = {
847	.mp = mp,
848	.idmap = file_mnt_idmap(file),
849	};
850	int error;
851
852	if (!capable(CAP_SYS_ADMIN))
853	return -EPERM;
854
855	if (xfs_is_shutdown(mp))
856	return -EIO;
857
858	if (copy_from_user(to: &hdr, from: &arg->hdr, n: sizeof(hdr)))
859	return -EFAULT;
860
861	error = xfs_bulk_ireq_setup(mp, hdr: &hdr, breq: &breq, ubuffer: arg->bulkstat);
862	if (error == -ECANCELED)
863	goto out_teardown;
864	if (error < 0)
865	return error;
866
867	error = xfs_bulkstat(breq: &breq, formatter: xfs_bulkstat_fmt);
868	if (error)
869	return error;
870
871	out_teardown:
872	xfs_bulk_ireq_teardown(hdr: &hdr, breq: &breq);
873	if (copy_to_user(to: &arg->hdr, from: &hdr, n: sizeof(hdr)))
874	return -EFAULT;
875
876	return 0;
877	}
878
879	STATIC int
880	xfs_inumbers_fmt(
881	struct xfs_ibulk *breq,
882	const struct xfs_inumbers *igrp)
883	{
884	if (copy_to_user(breq->ubuffer, igrp, sizeof(struct xfs_inumbers)))
885	return -EFAULT;
886	return xfs_ibulk_advance(breq, sizeof(struct xfs_inumbers));
887	}
888
889	/* Handle the v5 inumbers ioctl. */
890	STATIC int
891	xfs_ioc_inumbers(
892	struct xfs_mount *mp,
893	unsigned int cmd,
894	struct xfs_inumbers_req __user *arg)
895	{
896	struct xfs_bulk_ireq hdr;
897	struct xfs_ibulk breq = {
898	.mp = mp,
899	};
900	int error;
901
902	if (!capable(CAP_SYS_ADMIN))
903	return -EPERM;
904
905	if (xfs_is_shutdown(mp))
906	return -EIO;
907
908	if (copy_from_user(to: &hdr, from: &arg->hdr, n: sizeof(hdr)))
909	return -EFAULT;
910
911	error = xfs_bulk_ireq_setup(mp, hdr: &hdr, breq: &breq, ubuffer: arg->inumbers);
912	if (error == -ECANCELED)
913	goto out_teardown;
914	if (error < 0)
915	return error;
916
917	error = xfs_inumbers(breq: &breq, formatter: xfs_inumbers_fmt);
918	if (error)
919	return error;
920
921	out_teardown:
922	xfs_bulk_ireq_teardown(hdr: &hdr, breq: &breq);
923	if (copy_to_user(to: &arg->hdr, from: &hdr, n: sizeof(hdr)))
924	return -EFAULT;
925
926	return 0;
927	}
928
929	STATIC int
930	xfs_ioc_fsgeometry(
931	struct xfs_mount *mp,
932	void __user *arg,
933	int struct_version)
934	{
935	struct xfs_fsop_geom fsgeo;
936	size_t len;
937
938	xfs_fs_geometry(mp, &fsgeo, struct_version);
939
940	if (struct_version <= 3)
941	len = sizeof(struct xfs_fsop_geom_v1);
942	else if (struct_version == 4)
943	len = sizeof(struct xfs_fsop_geom_v4);
944	else {
945	xfs_fsop_geom_health(mp, &fsgeo);
946	len = sizeof(fsgeo);
947	}
948
949	if (copy_to_user(to: arg, from: &fsgeo, n: len))
950	return -EFAULT;
951	return 0;
952	}
953
954	STATIC int
955	xfs_ioc_ag_geometry(
956	struct xfs_mount *mp,
957	void __user *arg)
958	{
959	struct xfs_perag *pag;
960	struct xfs_ag_geometry ageo;
961	int error;
962
963	if (copy_from_user(to: &ageo, from: arg, n: sizeof(ageo)))
964	return -EFAULT;
965	if (ageo.ag_flags)
966	return -EINVAL;
967	if (memchr_inv(&ageo.ag_reserved, 0, sizeof(ageo.ag_reserved)))
968	return -EINVAL;
969
970	pag = xfs_perag_get(mp, ageo.ag_number);
971	if (!pag)
972	return -EINVAL;
973
974	error = xfs_ag_get_geometry(pag, &ageo);
975	xfs_perag_put(pag);
976	if (error)
977	return error;
978
979	if (copy_to_user(to: arg, from: &ageo, n: sizeof(ageo)))
980	return -EFAULT;
981	return 0;
982	}
983
984	/*
985	* Linux extended inode flags interface.
986	*/
987
988	static void
989	xfs_fill_fsxattr(
990	struct xfs_inode *ip,
991	int whichfork,
992	struct fileattr *fa)
993	{
994	struct xfs_mount *mp = ip->i_mount;
995	struct xfs_ifork *ifp = xfs_ifork_ptr(ip, whichfork);
996
997	fileattr_fill_xflags(fa, xflags: xfs_ip2xflags(ip));
998
999	if (ip->i_diflags & XFS_DIFLAG_EXTSIZE) {
1000	fa->fsx_extsize = XFS_FSB_TO_B(mp, ip->i_extsize);
1001	} else if (ip->i_diflags & XFS_DIFLAG_EXTSZINHERIT) {
1002	/*
1003	* Don't let a misaligned extent size hint on a directory
1004	* escape to userspace if it won't pass the setattr checks
1005	* later.
1006	*/
1007	if ((ip->i_diflags & XFS_DIFLAG_RTINHERIT) &&
1008	xfs_extlen_to_rtxmod(mp, ip->i_extsize) > 0) {
1009	fa->fsx_xflags &= ~(FS_XFLAG_EXTSIZE |
1010	FS_XFLAG_EXTSZINHERIT);
1011	fa->fsx_extsize = 0;
1012	} else {
1013	fa->fsx_extsize = XFS_FSB_TO_B(mp, ip->i_extsize);
1014	}
1015	}
1016
1017	if (ip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE)
1018	fa->fsx_cowextsize = XFS_FSB_TO_B(mp, ip->i_cowextsize);
1019	fa->fsx_projid = ip->i_projid;
1020	if (ifp && !xfs_need_iread_extents(ifp))
1021	fa->fsx_nextents = xfs_iext_count(ifp);
1022	else
1023	fa->fsx_nextents = xfs_ifork_nextents(ifp);
1024	}
1025
1026	STATIC int
1027	xfs_ioc_fsgetxattra(
1028	xfs_inode_t *ip,
1029	void __user *arg)
1030	{
1031	struct fileattr fa;
1032
1033	xfs_ilock(ip, XFS_ILOCK_SHARED);
1034	xfs_fill_fsxattr(ip, XFS_ATTR_FORK, &fa);
1035	xfs_iunlock(ip, XFS_ILOCK_SHARED);
1036
1037	return copy_fsxattr_to_user(fa: &fa, ufa: arg);
1038	}
1039
1040	int
1041	xfs_fileattr_get(
1042	struct dentry *dentry,
1043	struct fileattr *fa)
1044	{
1045	struct xfs_inode *ip = XFS_I(inode: d_inode(dentry));
1046
1047	if (d_is_special(dentry))
1048	return -ENOTTY;
1049
1050	xfs_ilock(ip, XFS_ILOCK_SHARED);
1051	xfs_fill_fsxattr(ip, XFS_DATA_FORK, fa);
1052	xfs_iunlock(ip, XFS_ILOCK_SHARED);
1053
1054	return 0;
1055	}
1056
1057	STATIC uint16_t
1058	xfs_flags2diflags(
1059	struct xfs_inode *ip,
1060	unsigned int xflags)
1061	{
1062	/* can't set PREALLOC this way, just preserve it */
1063	uint16_t di_flags =
1064	(ip->i_diflags & XFS_DIFLAG_PREALLOC);
1065
1066	if (xflags & FS_XFLAG_IMMUTABLE)
1067	di_flags |= XFS_DIFLAG_IMMUTABLE;
1068	if (xflags & FS_XFLAG_APPEND)
1069	di_flags |= XFS_DIFLAG_APPEND;
1070	if (xflags & FS_XFLAG_SYNC)
1071	di_flags |= XFS_DIFLAG_SYNC;
1072	if (xflags & FS_XFLAG_NOATIME)
1073	di_flags |= XFS_DIFLAG_NOATIME;
1074	if (xflags & FS_XFLAG_NODUMP)
1075	di_flags |= XFS_DIFLAG_NODUMP;
1076	if (xflags & FS_XFLAG_NODEFRAG)
1077	di_flags |= XFS_DIFLAG_NODEFRAG;
1078	if (xflags & FS_XFLAG_FILESTREAM)
1079	di_flags |= XFS_DIFLAG_FILESTREAM;
1080	if (S_ISDIR(VFS_I(ip)->i_mode)) {
1081	if (xflags & FS_XFLAG_RTINHERIT)
1082	di_flags |= XFS_DIFLAG_RTINHERIT;
1083	if (xflags & FS_XFLAG_NOSYMLINKS)
1084	di_flags |= XFS_DIFLAG_NOSYMLINKS;
1085	if (xflags & FS_XFLAG_EXTSZINHERIT)
1086	di_flags |= XFS_DIFLAG_EXTSZINHERIT;
1087	if (xflags & FS_XFLAG_PROJINHERIT)
1088	di_flags |= XFS_DIFLAG_PROJINHERIT;
1089	} else if (S_ISREG(VFS_I(ip)->i_mode)) {
1090	if (xflags & FS_XFLAG_REALTIME)
1091	di_flags |= XFS_DIFLAG_REALTIME;
1092	if (xflags & FS_XFLAG_EXTSIZE)
1093	di_flags |= XFS_DIFLAG_EXTSIZE;
1094	}
1095
1096	return di_flags;
1097	}
1098
1099	STATIC uint64_t
1100	xfs_flags2diflags2(
1101	struct xfs_inode *ip,
1102	unsigned int xflags)
1103	{
1104	uint64_t di_flags2 =
1105	(ip->i_diflags2 & (XFS_DIFLAG2_REFLINK |
1106	XFS_DIFLAG2_BIGTIME |
1107	XFS_DIFLAG2_NREXT64));
1108
1109	if (xflags & FS_XFLAG_DAX)
1110	di_flags2 |= XFS_DIFLAG2_DAX;
1111	if (xflags & FS_XFLAG_COWEXTSIZE)
1112	di_flags2 |= XFS_DIFLAG2_COWEXTSIZE;
1113
1114	return di_flags2;
1115	}
1116
1117	static int
1118	xfs_ioctl_setattr_xflags(
1119	struct xfs_trans *tp,
1120	struct xfs_inode *ip,
1121	struct fileattr *fa)
1122	{
1123	struct xfs_mount *mp = ip->i_mount;
1124	bool rtflag = (fa->fsx_xflags & FS_XFLAG_REALTIME);
1125	uint64_t i_flags2;
1126
1127	if (rtflag != XFS_IS_REALTIME_INODE(ip)) {
1128	/* Can't change realtime flag if any extents are allocated. */
1129	if (ip->i_df.if_nextents || ip->i_delayed_blks)
1130	return -EINVAL;
1131	}
1132
1133	if (rtflag) {
1134	/* If realtime flag is set then must have realtime device */
1135	if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 ||
1136	xfs_extlen_to_rtxmod(mp, ip->i_extsize))
1137	return -EINVAL;
1138
1139	/* Clear reflink if we are actually able to set the rt flag. */
1140	if (xfs_is_reflink_inode(ip))
1141	ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
1142	}
1143
1144	/* diflags2 only valid for v3 inodes. */
1145	i_flags2 = xfs_flags2diflags2(ip, xflags: fa->fsx_xflags);
1146	if (i_flags2 && !xfs_has_v3inodes(mp))
1147	return -EINVAL;
1148
1149	ip->i_diflags = xfs_flags2diflags(ip, xflags: fa->fsx_xflags);
1150	ip->i_diflags2 = i_flags2;
1151
1152	xfs_diflags_to_iflags(ip, init: false);
1153
1154	/*
1155	* Make the stable writes flag match that of the device the inode
1156	* resides on when flipping the RT flag.
1157	*/
1158	if (rtflag != XFS_IS_REALTIME_INODE(ip) && S_ISREG(VFS_I(ip)->i_mode))
1159	xfs_update_stable_writes(ip);
1160
1161	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1162	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1163	XFS_STATS_INC(mp, xs_ig_attrchg);
1164	return 0;
1165	}
1166
1167	static void
1168	xfs_ioctl_setattr_prepare_dax(
1169	struct xfs_inode *ip,
1170	struct fileattr *fa)
1171	{
1172	struct xfs_mount *mp = ip->i_mount;
1173	struct inode *inode = VFS_I(ip);
1174
1175	if (S_ISDIR(inode->i_mode))
1176	return;
1177
1178	if (xfs_has_dax_always(mp) || xfs_has_dax_never(mp))
1179	return;
1180
1181	if (((fa->fsx_xflags & FS_XFLAG_DAX) &&
1182	!(ip->i_diflags2 & XFS_DIFLAG2_DAX)) ||
1183	(!(fa->fsx_xflags & FS_XFLAG_DAX) &&
1184	(ip->i_diflags2 & XFS_DIFLAG2_DAX)))
1185	d_mark_dontcache(inode);
1186	}
1187
1188	/*
1189	* Set up the transaction structure for the setattr operation, checking that we
1190	* have permission to do so. On success, return a clean transaction and the
1191	* inode locked exclusively ready for further operation specific checks. On
1192	* failure, return an error without modifying or locking the inode.
1193	*/
1194	static struct xfs_trans *
1195	xfs_ioctl_setattr_get_trans(
1196	struct xfs_inode *ip,
1197	struct xfs_dquot *pdqp)
1198	{
1199	struct xfs_mount *mp = ip->i_mount;
1200	struct xfs_trans *tp;
1201	int error = -EROFS;
1202
1203	if (xfs_is_readonly(mp))
1204	goto out_error;
1205	error = -EIO;
1206	if (xfs_is_shutdown(mp))
1207	goto out_error;
1208
1209	error = xfs_trans_alloc_ichange(ip, NULL, NULL, pdqp,
1210	force: has_capability_noaudit(current, CAP_FOWNER), tpp: &tp);
1211	if (error)
1212	goto out_error;
1213
1214	if (xfs_has_wsync(mp))
1215	xfs_trans_set_sync(tp);
1216
1217	return tp;
1218
1219	out_error:
1220	return ERR_PTR(error);
1221	}
1222
1223	/*
1224	* Validate a proposed extent size hint. For regular files, the hint can only
1225	* be changed if no extents are allocated.
1226	*/
1227	static int
1228	xfs_ioctl_setattr_check_extsize(
1229	struct xfs_inode *ip,
1230	struct fileattr *fa)
1231	{
1232	struct xfs_mount *mp = ip->i_mount;
1233	xfs_failaddr_t failaddr;
1234	uint16_t new_diflags;
1235
1236	if (!fa->fsx_valid)
1237	return 0;
1238
1239	if (S_ISREG(VFS_I(ip)->i_mode) && ip->i_df.if_nextents &&
1240	XFS_FSB_TO_B(mp, ip->i_extsize) != fa->fsx_extsize)
1241	return -EINVAL;
1242
1243	if (fa->fsx_extsize & mp->m_blockmask)
1244	return -EINVAL;
1245
1246	new_diflags = xfs_flags2diflags(ip, xflags: fa->fsx_xflags);
1247
1248	/*
1249	* Inode verifiers do not check that the extent size hint is an integer
1250	* multiple of the rt extent size on a directory with both rtinherit
1251	* and extszinherit flags set. Don't let sysadmins misconfigure
1252	* directories.
1253	*/
1254	if ((new_diflags & XFS_DIFLAG_RTINHERIT) &&
1255	(new_diflags & XFS_DIFLAG_EXTSZINHERIT)) {
1256	unsigned int rtextsize_bytes;
1257
1258	rtextsize_bytes = XFS_FSB_TO_B(mp, mp->m_sb.sb_rextsize);
1259	if (fa->fsx_extsize % rtextsize_bytes)
1260	return -EINVAL;
1261	}
1262
1263	failaddr = xfs_inode_validate_extsize(ip->i_mount,
1264	XFS_B_TO_FSB(mp, fa->fsx_extsize),
1265	VFS_I(ip)->i_mode, new_diflags);
1266	return failaddr != NULL ? -EINVAL : 0;
1267	}
1268
1269	static int
1270	xfs_ioctl_setattr_check_cowextsize(
1271	struct xfs_inode *ip,
1272	struct fileattr *fa)
1273	{
1274	struct xfs_mount *mp = ip->i_mount;
1275	xfs_failaddr_t failaddr;
1276	uint64_t new_diflags2;
1277	uint16_t new_diflags;
1278
1279	if (!fa->fsx_valid)
1280	return 0;
1281
1282	if (fa->fsx_cowextsize & mp->m_blockmask)
1283	return -EINVAL;
1284
1285	new_diflags = xfs_flags2diflags(ip, xflags: fa->fsx_xflags);
1286	new_diflags2 = xfs_flags2diflags2(ip, xflags: fa->fsx_xflags);
1287
1288	failaddr = xfs_inode_validate_cowextsize(ip->i_mount,
1289	XFS_B_TO_FSB(mp, fa->fsx_cowextsize),
1290	VFS_I(ip)->i_mode, new_diflags, new_diflags2);
1291	return failaddr != NULL ? -EINVAL : 0;
1292	}
1293
1294	static int
1295	xfs_ioctl_setattr_check_projid(
1296	struct xfs_inode *ip,
1297	struct fileattr *fa)
1298	{
1299	if (!fa->fsx_valid)
1300	return 0;
1301
1302	/* Disallow 32bit project ids if 32bit IDs are not enabled. */
1303	if (fa->fsx_projid > (uint16_t)-1 &&
1304	!xfs_has_projid32(mp: ip->i_mount))
1305	return -EINVAL;
1306	return 0;
1307	}
1308
1309	int
1310	xfs_fileattr_set(
1311	struct mnt_idmap *idmap,
1312	struct dentry *dentry,
1313	struct fileattr *fa)
1314	{
1315	struct xfs_inode *ip = XFS_I(inode: d_inode(dentry));
1316	struct xfs_mount *mp = ip->i_mount;
1317	struct xfs_trans *tp;
1318	struct xfs_dquot *pdqp = NULL;
1319	struct xfs_dquot *olddquot = NULL;
1320	int error;
1321
1322	trace_xfs_ioctl_setattr(ip);
1323
1324	if (d_is_special(dentry))
1325	return -ENOTTY;
1326
1327	if (!fa->fsx_valid) {
1328	if (fa->flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL |
1329	FS_NOATIME_FL | FS_NODUMP_FL |
1330	FS_SYNC_FL | FS_DAX_FL | FS_PROJINHERIT_FL))
1331	return -EOPNOTSUPP;
1332	}
1333
1334	error = xfs_ioctl_setattr_check_projid(ip, fa);
1335	if (error)
1336	return error;
1337
1338	/*
1339	* If disk quotas is on, we make sure that the dquots do exist on disk,
1340	* before we start any other transactions. Trying to do this later
1341	* is messy. We don't care to take a readlock to look at the ids
1342	* in inode here, because we can't hold it across the trans_reserve.
1343	* If the IDs do change before we take the ilock, we're covered
1344	* because the i_*dquot fields will get updated anyway.
1345	*/
1346	if (fa->fsx_valid && XFS_IS_QUOTA_ON(mp)) {
1347	error = xfs_qm_vop_dqalloc(ip, VFS_I(ip)->i_uid,
1348	VFS_I(ip)->i_gid, fa->fsx_projid,
1349	XFS_QMOPT_PQUOTA, NULL, NULL, &pdqp);
1350	if (error)
1351	return error;
1352	}
1353
1354	xfs_ioctl_setattr_prepare_dax(ip, fa);
1355
1356	tp = xfs_ioctl_setattr_get_trans(ip, pdqp);
1357	if (IS_ERR(ptr: tp)) {
1358	error = PTR_ERR(ptr: tp);
1359	goto error_free_dquots;
1360	}
1361
1362	error = xfs_ioctl_setattr_check_extsize(ip, fa);
1363	if (error)
1364	goto error_trans_cancel;
1365
1366	error = xfs_ioctl_setattr_check_cowextsize(ip, fa);
1367	if (error)
1368	goto error_trans_cancel;
1369
1370	error = xfs_ioctl_setattr_xflags(tp, ip, fa);
1371	if (error)
1372	goto error_trans_cancel;
1373
1374	if (!fa->fsx_valid)
1375	goto skip_xattr;
1376	/*
1377	* Change file ownership. Must be the owner or privileged. CAP_FSETID
1378	* overrides the following restrictions:
1379	*
1380	* The set-user-ID and set-group-ID bits of a file will be cleared upon
1381	* successful return from chown()
1382	*/
1383
1384	if ((VFS_I(ip)->i_mode & (S_ISUID|S_ISGID)) &&
1385	!capable_wrt_inode_uidgid(idmap, inode: VFS_I(ip), CAP_FSETID))
1386	VFS_I(ip)->i_mode &= ~(S_ISUID|S_ISGID);
1387
1388	/* Change the ownerships and register project quota modifications */
1389	if (ip->i_projid != fa->fsx_projid) {
1390	if (XFS_IS_PQUOTA_ON(mp)) {
1391	olddquot = xfs_qm_vop_chown(tp, ip,
1392	&ip->i_pdquot, pdqp);
1393	}
1394	ip->i_projid = fa->fsx_projid;
1395	}
1396
1397	/*
1398	* Only set the extent size hint if we've already determined that the
1399	* extent size hint should be set on the inode. If no extent size flags
1400	* are set on the inode then unconditionally clear the extent size hint.
1401	*/
1402	if (ip->i_diflags & (XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT))
1403	ip->i_extsize = XFS_B_TO_FSB(mp, fa->fsx_extsize);
1404	else
1405	ip->i_extsize = 0;
1406
1407	if (xfs_has_v3inodes(mp)) {
1408	if (ip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE)
1409	ip->i_cowextsize = XFS_B_TO_FSB(mp, fa->fsx_cowextsize);
1410	else
1411	ip->i_cowextsize = 0;
1412	}
1413
1414	skip_xattr:
1415	error = xfs_trans_commit(tp);
1416
1417	/*
1418	* Release any dquot(s) the inode had kept before chown.
1419	*/
1420	xfs_qm_dqrele(olddquot);
1421	xfs_qm_dqrele(pdqp);
1422
1423	return error;
1424
1425	error_trans_cancel:
1426	xfs_trans_cancel(tp);
1427	error_free_dquots:
1428	xfs_qm_dqrele(pdqp);
1429	return error;
1430	}
1431
1432	static bool
1433	xfs_getbmap_format(
1434	struct kgetbmap *p,
1435	struct getbmapx __user *u,
1436	size_t recsize)
1437	{
1438	if (put_user(p->bmv_offset, &u->bmv_offset) ||
1439	put_user(p->bmv_block, &u->bmv_block) ||
1440	put_user(p->bmv_length, &u->bmv_length) ||
1441	put_user(0, &u->bmv_count) ||
1442	put_user(0, &u->bmv_entries))
1443	return false;
1444	if (recsize < sizeof(struct getbmapx))
1445	return true;
1446	if (put_user(0, &u->bmv_iflags) ||
1447	put_user(p->bmv_oflags, &u->bmv_oflags) ||
1448	put_user(0, &u->bmv_unused1) ||
1449	put_user(0, &u->bmv_unused2))
1450	return false;
1451	return true;
1452	}
1453
1454	STATIC int
1455	xfs_ioc_getbmap(
1456	struct file *file,
1457	unsigned int cmd,
1458	void __user *arg)
1459	{
1460	struct getbmapx bmx = { 0 };
1461	struct kgetbmap *buf;
1462	size_t recsize;
1463	int error, i;
1464
1465	switch (cmd) {
1466	case XFS_IOC_GETBMAPA:
1467	bmx.bmv_iflags = BMV_IF_ATTRFORK;
1468	fallthrough;
1469	case XFS_IOC_GETBMAP:
1470	/* struct getbmap is a strict subset of struct getbmapx. */
1471	recsize = sizeof(struct getbmap);
1472	break;
1473	case XFS_IOC_GETBMAPX:
1474	recsize = sizeof(struct getbmapx);
1475	break;
1476	default:
1477	return -EINVAL;
1478	}
1479
1480	if (copy_from_user(to: &bmx, from: arg, n: recsize))
1481	return -EFAULT;
1482
1483	if (bmx.bmv_count < 2)
1484	return -EINVAL;
1485	if (bmx.bmv_count >= INT_MAX / recsize)
1486	return -ENOMEM;
1487
1488	buf = kvcalloc(n: bmx.bmv_count, size: sizeof(*buf), GFP_KERNEL);
1489	if (!buf)
1490	return -ENOMEM;
1491
1492	error = xfs_getbmap(ip: XFS_I(inode: file_inode(f: file)), bmv: &bmx, out: buf);
1493	if (error)
1494	goto out_free_buf;
1495
1496	error = -EFAULT;
1497	if (copy_to_user(to: arg, from: &bmx, n: recsize))
1498	goto out_free_buf;
1499	arg += recsize;
1500
1501	for (i = 0; i < bmx.bmv_entries; i++) {
1502	if (!xfs_getbmap_format(p: buf + i, u: arg, recsize))
1503	goto out_free_buf;
1504	arg += recsize;
1505	}
1506
1507	error = 0;
1508	out_free_buf:
1509	kvfree(addr: buf);
1510	return error;
1511	}
1512
1513	STATIC int
1514	xfs_ioc_getfsmap(
1515	struct xfs_inode *ip,
1516	struct fsmap_head __user *arg)
1517	{
1518	struct xfs_fsmap_head xhead = {0};
1519	struct fsmap_head head;
1520	struct fsmap *recs;
1521	unsigned int count;
1522	__u32 last_flags = 0;
1523	bool done = false;
1524	int error;
1525
1526	if (copy_from_user(to: &head, from: arg, n: sizeof(struct fsmap_head)))
1527	return -EFAULT;
1528	if (memchr_inv(p: head.fmh_reserved, c: 0, size: sizeof(head.fmh_reserved)) ||
1529	memchr_inv(p: head.fmh_keys[0].fmr_reserved, c: 0,
1530	size: sizeof(head.fmh_keys[0].fmr_reserved)) ||
1531	memchr_inv(p: head.fmh_keys[1].fmr_reserved, c: 0,
1532	size: sizeof(head.fmh_keys[1].fmr_reserved)))
1533	return -EINVAL;
1534
1535	/*
1536	* Use an internal memory buffer so that we don't have to copy fsmap
1537	* data to userspace while holding locks. Start by trying to allocate
1538	* up to 128k for the buffer, but fall back to a single page if needed.
1539	*/
1540	count = min_t(unsigned int, head.fmh_count,
1541	131072 / sizeof(struct fsmap));
1542	recs = kvcalloc(n: count, size: sizeof(struct fsmap), GFP_KERNEL);
1543	if (!recs) {
1544	count = min_t(unsigned int, head.fmh_count,
1545	PAGE_SIZE / sizeof(struct fsmap));
1546	recs = kvcalloc(n: count, size: sizeof(struct fsmap), GFP_KERNEL);
1547	if (!recs)
1548	return -ENOMEM;
1549	}
1550
1551	xhead.fmh_iflags = head.fmh_iflags;
1552	xfs_fsmap_to_internal(dest: &xhead.fmh_keys[0], src: &head.fmh_keys[0]);
1553	xfs_fsmap_to_internal(dest: &xhead.fmh_keys[1], src: &head.fmh_keys[1]);
1554
1555	trace_xfs_getfsmap_low_key(mp: ip->i_mount, fsmap: &xhead.fmh_keys[0]);
1556	trace_xfs_getfsmap_high_key(mp: ip->i_mount, fsmap: &xhead.fmh_keys[1]);
1557
1558	head.fmh_entries = 0;
1559	do {
1560	struct fsmap __user *user_recs;
1561	struct fsmap *last_rec;
1562
1563	user_recs = &arg->fmh_recs[head.fmh_entries];
1564	xhead.fmh_entries = 0;
1565	xhead.fmh_count = min_t(unsigned int, count,
1566	head.fmh_count - head.fmh_entries);
1567
1568	/* Run query, record how many entries we got. */
1569	error = xfs_getfsmap(mp: ip->i_mount, head: &xhead, out_recs: recs);
1570	switch (error) {
1571	case 0:
1572	/*
1573	* There are no more records in the result set. Copy
1574	* whatever we got to userspace and break out.
1575	*/
1576	done = true;
1577	break;
1578	case -ECANCELED:
1579	/*
1580	* The internal memory buffer is full. Copy whatever
1581	* records we got to userspace and go again if we have
1582	* not yet filled the userspace buffer.
1583	*/
1584	error = 0;
1585	break;
1586	default:
1587	goto out_free;
1588	}
1589	head.fmh_entries += xhead.fmh_entries;
1590	head.fmh_oflags = xhead.fmh_oflags;
1591
1592	/*
1593	* If the caller wanted a record count or there aren't any
1594	* new records to return, we're done.
1595	*/
1596	if (head.fmh_count == 0 || xhead.fmh_entries == 0)
1597	break;
1598
1599	/* Copy all the records we got out to userspace. */
1600	if (copy_to_user(to: user_recs, from: recs,
1601	n: xhead.fmh_entries * sizeof(struct fsmap))) {
1602	error = -EFAULT;
1603	goto out_free;
1604	}
1605
1606	/* Remember the last record flags we copied to userspace. */
1607	last_rec = &recs[xhead.fmh_entries - 1];
1608	last_flags = last_rec->fmr_flags;
1609
1610	/* Set up the low key for the next iteration. */
1611	xfs_fsmap_to_internal(dest: &xhead.fmh_keys[0], src: last_rec);
1612	trace_xfs_getfsmap_low_key(mp: ip->i_mount, fsmap: &xhead.fmh_keys[0]);
1613	} while (!done && head.fmh_entries < head.fmh_count);
1614
1615	/*
1616	* If there are no more records in the query result set and we're not
1617	* in counting mode, mark the last record returned with the LAST flag.
1618	*/
1619	if (done && head.fmh_count > 0 && head.fmh_entries > 0) {
1620	struct fsmap __user *user_rec;
1621
1622	last_flags |= FMR_OF_LAST;
1623	user_rec = &arg->fmh_recs[head.fmh_entries - 1];
1624
1625	if (copy_to_user(to: &user_rec->fmr_flags, from: &last_flags,
1626	n: sizeof(last_flags))) {
1627	error = -EFAULT;
1628	goto out_free;
1629	}
1630	}
1631
1632	/* copy back header */
1633	if (copy_to_user(to: arg, from: &head, n: sizeof(struct fsmap_head))) {
1634	error = -EFAULT;
1635	goto out_free;
1636	}
1637
1638	out_free:
1639	kvfree(addr: recs);
1640	return error;
1641	}
1642
1643	STATIC int
1644	xfs_ioc_scrub_metadata(
1645	struct file *file,
1646	void __user *arg)
1647	{
1648	struct xfs_scrub_metadata scrub;
1649	int error;
1650
1651	if (!capable(CAP_SYS_ADMIN))
1652	return -EPERM;
1653
1654	if (copy_from_user(to: &scrub, from: arg, n: sizeof(scrub)))
1655	return -EFAULT;
1656
1657	error = xfs_scrub_metadata(file, sm: &scrub);
1658	if (error)
1659	return error;
1660
1661	if (copy_to_user(to: arg, from: &scrub, n: sizeof(scrub)))
1662	return -EFAULT;
1663
1664	return 0;
1665	}
1666
1667	int
1668	xfs_ioc_swapext(
1669	xfs_swapext_t *sxp)
1670	{
1671	xfs_inode_t *ip, *tip;
1672	struct fd f, tmp;
1673	int error = 0;
1674
1675	/* Pull information for the target fd */
1676	f = fdget(fd: (int)sxp->sx_fdtarget);
1677	if (!f.file) {
1678	error = -EINVAL;
1679	goto out;
1680	}
1681
1682	if (!(f.file->f_mode & FMODE_WRITE) ||
1683	!(f.file->f_mode & FMODE_READ) ||
1684	(f.file->f_flags & O_APPEND)) {
1685	error = -EBADF;
1686	goto out_put_file;
1687	}
1688
1689	tmp = fdget(fd: (int)sxp->sx_fdtmp);
1690	if (!tmp.file) {
1691	error = -EINVAL;
1692	goto out_put_file;
1693	}
1694
1695	if (!(tmp.file->f_mode & FMODE_WRITE) ||
1696	!(tmp.file->f_mode & FMODE_READ) ||
1697	(tmp.file->f_flags & O_APPEND)) {
1698	error = -EBADF;
1699	goto out_put_tmp_file;
1700	}
1701
1702	if (IS_SWAPFILE(file_inode(f.file)) ||
1703	IS_SWAPFILE(file_inode(tmp.file))) {
1704	error = -EINVAL;
1705	goto out_put_tmp_file;
1706	}
1707
1708	/*
1709	* We need to ensure that the fds passed in point to XFS inodes
1710	* before we cast and access them as XFS structures as we have no
1711	* control over what the user passes us here.
1712	*/
1713	if (f.file->f_op != &xfs_file_operations ||
1714	tmp.file->f_op != &xfs_file_operations) {
1715	error = -EINVAL;
1716	goto out_put_tmp_file;
1717	}
1718
1719	ip = XFS_I(inode: file_inode(f: f.file));
1720	tip = XFS_I(inode: file_inode(f: tmp.file));
1721
1722	if (ip->i_mount != tip->i_mount) {
1723	error = -EINVAL;
1724	goto out_put_tmp_file;
1725	}
1726
1727	if (ip->i_ino == tip->i_ino) {
1728	error = -EINVAL;
1729	goto out_put_tmp_file;
1730	}
1731
1732	if (xfs_is_shutdown(mp: ip->i_mount)) {
1733	error = -EIO;
1734	goto out_put_tmp_file;
1735	}
1736
1737	error = xfs_swap_extents(ip, tip, sx: sxp);
1738
1739	out_put_tmp_file:
1740	fdput(fd: tmp);
1741	out_put_file:
1742	fdput(fd: f);
1743	out:
1744	return error;
1745	}
1746
1747	static int
1748	xfs_ioc_getlabel(
1749	struct xfs_mount *mp,
1750	char __user *user_label)
1751	{
1752	struct xfs_sb *sbp = &mp->m_sb;
1753	char label[XFSLABEL_MAX + 1];
1754
1755	/* Paranoia */
1756	BUILD_BUG_ON(sizeof(sbp->sb_fname) > FSLABEL_MAX);
1757
1758	/* 1 larger than sb_fname, so this ensures a trailing NUL char */
1759	memset(label, 0, sizeof(label));
1760	spin_lock(lock: &mp->m_sb_lock);
1761	strncpy(label, sbp->sb_fname, XFSLABEL_MAX);
1762	spin_unlock(lock: &mp->m_sb_lock);
1763
1764	if (copy_to_user(to: user_label, from: label, n: sizeof(label)))
1765	return -EFAULT;
1766	return 0;
1767	}
1768
1769	static int
1770	xfs_ioc_setlabel(
1771	struct file *filp,
1772	struct xfs_mount *mp,
1773	char __user *newlabel)
1774	{
1775	struct xfs_sb *sbp = &mp->m_sb;
1776	char label[XFSLABEL_MAX + 1];
1777	size_t len;
1778	int error;
1779
1780	if (!capable(CAP_SYS_ADMIN))
1781	return -EPERM;
1782	/*
1783	* The generic ioctl allows up to FSLABEL_MAX chars, but XFS is much
1784	* smaller, at 12 bytes. We copy one more to be sure we find the
1785	* (required) NULL character to test the incoming label length.
1786	* NB: The on disk label doesn't need to be null terminated.
1787	*/
1788	if (copy_from_user(label, newlabel, XFSLABEL_MAX + 1))
1789	return -EFAULT;
1790	len = strnlen(label, XFSLABEL_MAX + 1);
1791	if (len > sizeof(sbp->sb_fname))
1792	return -EINVAL;
1793
1794	error = mnt_want_write_file(file: filp);
1795	if (error)
1796	return error;
1797
1798	spin_lock(lock: &mp->m_sb_lock);
1799	memset(sbp->sb_fname, 0, sizeof(sbp->sb_fname));
1800	memcpy(sbp->sb_fname, label, len);
1801	spin_unlock(lock: &mp->m_sb_lock);
1802
1803	/*
1804	* Now we do several things to satisfy userspace.
1805	* In addition to normal logging of the primary superblock, we also
1806	* immediately write these changes to sector zero for the primary, then
1807	* update all backup supers (as xfs_db does for a label change), then
1808	* invalidate the block device page cache. This is so that any prior
1809	* buffered reads from userspace (i.e. from blkid) are invalidated,
1810	* and userspace will see the newly-written label.
1811	*/
1812	error = xfs_sync_sb_buf(mp);
1813	if (error)
1814	goto out;
1815	/*
1816	* growfs also updates backup supers so lock against that.
1817	*/
1818	mutex_lock(&mp->m_growlock);
1819	error = xfs_update_secondary_sbs(mp);
1820	mutex_unlock(lock: &mp->m_growlock);
1821
1822	invalidate_bdev(bdev: mp->m_ddev_targp->bt_bdev);
1823
1824	out:
1825	mnt_drop_write_file(file: filp);
1826	return error;
1827	}
1828
1829	static inline int
1830	xfs_fs_eofblocks_from_user(
1831	struct xfs_fs_eofblocks *src,
1832	struct xfs_icwalk *dst)
1833	{
1834	if (src->eof_version != XFS_EOFBLOCKS_VERSION)
1835	return -EINVAL;
1836
1837	if (src->eof_flags & ~XFS_EOF_FLAGS_VALID)
1838	return -EINVAL;
1839
1840	if (memchr_inv(&src->pad32, 0, sizeof(src->pad32)) ||
1841	memchr_inv(src->pad64, 0, sizeof(src->pad64)))
1842	return -EINVAL;
1843
1844	dst->icw_flags = 0;
1845	if (src->eof_flags & XFS_EOF_FLAGS_SYNC)
1846	dst->icw_flags |= XFS_ICWALK_FLAG_SYNC;
1847	if (src->eof_flags & XFS_EOF_FLAGS_UID)
1848	dst->icw_flags |= XFS_ICWALK_FLAG_UID;
1849	if (src->eof_flags & XFS_EOF_FLAGS_GID)
1850	dst->icw_flags |= XFS_ICWALK_FLAG_GID;
1851	if (src->eof_flags & XFS_EOF_FLAGS_PRID)
1852	dst->icw_flags |= XFS_ICWALK_FLAG_PRID;
1853	if (src->eof_flags & XFS_EOF_FLAGS_MINFILESIZE)
1854	dst->icw_flags |= XFS_ICWALK_FLAG_MINFILESIZE;
1855
1856	dst->icw_prid = src->eof_prid;
1857	dst->icw_min_file_size = src->eof_min_file_size;
1858
1859	dst->icw_uid = INVALID_UID;
1860	if (src->eof_flags & XFS_EOF_FLAGS_UID) {
1861	dst->icw_uid = make_kuid(current_user_ns(), uid: src->eof_uid);
1862	if (!uid_valid(uid: dst->icw_uid))
1863	return -EINVAL;
1864	}
1865
1866	dst->icw_gid = INVALID_GID;
1867	if (src->eof_flags & XFS_EOF_FLAGS_GID) {
1868	dst->icw_gid = make_kgid(current_user_ns(), gid: src->eof_gid);
1869	if (!gid_valid(gid: dst->icw_gid))
1870	return -EINVAL;
1871	}
1872	return 0;
1873	}
1874
1875	static int
1876	xfs_ioctl_getset_resblocks(
1877	struct file *filp,
1878	unsigned int cmd,
1879	void __user *arg)
1880	{
1881	struct xfs_mount *mp = XFS_I(inode: file_inode(f: filp))->i_mount;
1882	struct xfs_fsop_resblks fsop = { };
1883	int error;
1884
1885	if (!capable(CAP_SYS_ADMIN))
1886	return -EPERM;
1887
1888	if (cmd == XFS_IOC_SET_RESBLKS) {
1889	if (xfs_is_readonly(mp))
1890	return -EROFS;
1891
1892	if (copy_from_user(to: &fsop, from: arg, n: sizeof(fsop)))
1893	return -EFAULT;
1894
1895	error = mnt_want_write_file(file: filp);
1896	if (error)
1897	return error;
1898	error = xfs_reserve_blocks(mp, request: fsop.resblks);
1899	mnt_drop_write_file(file: filp);
1900	if (error)
1901	return error;
1902	}
1903
1904	spin_lock(lock: &mp->m_sb_lock);
1905	fsop.resblks = mp->m_resblks;
1906	fsop.resblks_avail = mp->m_resblks_avail;
1907	spin_unlock(lock: &mp->m_sb_lock);
1908
1909	if (copy_to_user(to: arg, from: &fsop, n: sizeof(fsop)))
1910	return -EFAULT;
1911	return 0;
1912	}
1913
1914	static int
1915	xfs_ioctl_fs_counts(
1916	struct xfs_mount *mp,
1917	struct xfs_fsop_counts __user *uarg)
1918	{
1919	struct xfs_fsop_counts out = {
1920	.allocino = percpu_counter_read_positive(&mp->m_icount),
1921	.freeino = percpu_counter_read_positive(&mp->m_ifree),
1922	.freedata = percpu_counter_read_positive(&mp->m_fdblocks) -
1923	xfs_fdblocks_unavailable(mp),
1924	.freertx = percpu_counter_read_positive(&mp->m_frextents),
1925	};
1926
1927	if (copy_to_user(to: uarg, from: &out, n: sizeof(out)))
1928	return -EFAULT;
1929	return 0;
1930	}
1931
1932	/*
1933	* These long-unused ioctls were removed from the official ioctl API in 5.17,
1934	* but retain these definitions so that we can log warnings about them.
1935	*/
1936	#define XFS_IOC_ALLOCSP _IOW ('X', 10, struct xfs_flock64)
1937	#define XFS_IOC_FREESP _IOW ('X', 11, struct xfs_flock64)
1938	#define XFS_IOC_ALLOCSP64 _IOW ('X', 36, struct xfs_flock64)
1939	#define XFS_IOC_FREESP64 _IOW ('X', 37, struct xfs_flock64)
1940
1941	/*
1942	* Note: some of the ioctl's return positive numbers as a
1943	* byte count indicating success, such as readlink_by_handle.
1944	* So we don't "sign flip" like most other routines. This means
1945	* true errors need to be returned as a negative value.
1946	*/
1947	long
1948	xfs_file_ioctl(
1949	struct file *filp,
1950	unsigned int cmd,
1951	unsigned long p)
1952	{
1953	struct inode *inode = file_inode(f: filp);
1954	struct xfs_inode *ip = XFS_I(inode);
1955	struct xfs_mount *mp = ip->i_mount;
1956	void __user *arg = (void __user *)p;
1957	int error;
1958
1959	trace_xfs_file_ioctl(ip);
1960
1961	switch (cmd) {
1962	case FITRIM:
1963	return xfs_ioc_trim(mp, fstrim: arg);
1964	case FS_IOC_GETFSLABEL:
1965	return xfs_ioc_getlabel(mp, user_label: arg);
1966	case FS_IOC_SETFSLABEL:
1967	return xfs_ioc_setlabel(filp, mp, newlabel: arg);
1968	case XFS_IOC_ALLOCSP:
1969	case XFS_IOC_FREESP:
1970	case XFS_IOC_ALLOCSP64:
1971	case XFS_IOC_FREESP64:
1972	xfs_warn_once(mp,
1973	"%s should use fallocate; XFS_IOC_{ALLOC,FREE}SP ioctl unsupported",
1974	current->comm);
1975	return -ENOTTY;
1976	case XFS_IOC_DIOINFO: {
1977	struct xfs_buftarg *target = xfs_inode_buftarg(ip);
1978	struct dioattr da;
1979
1980	da.d_mem = da.d_miniosz = target->bt_logical_sectorsize;
1981	da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1982
1983	if (copy_to_user(to: arg, from: &da, n: sizeof(da)))
1984	return -EFAULT;
1985	return 0;
1986	}
1987
1988	case XFS_IOC_FSBULKSTAT_SINGLE:
1989	case XFS_IOC_FSBULKSTAT:
1990	case XFS_IOC_FSINUMBERS:
1991	return xfs_ioc_fsbulkstat(file: filp, cmd, arg);
1992
1993	case XFS_IOC_BULKSTAT:
1994	return xfs_ioc_bulkstat(file: filp, cmd, arg);
1995	case XFS_IOC_INUMBERS:
1996	return xfs_ioc_inumbers(mp, cmd, arg);
1997
1998	case XFS_IOC_FSGEOMETRY_V1:
1999	return xfs_ioc_fsgeometry(mp, arg, struct_version: 3);
2000	case XFS_IOC_FSGEOMETRY_V4:
2001	return xfs_ioc_fsgeometry(mp, arg, struct_version: 4);
2002	case XFS_IOC_FSGEOMETRY:
2003	return xfs_ioc_fsgeometry(mp, arg, struct_version: 5);
2004
2005	case XFS_IOC_AG_GEOMETRY:
2006	return xfs_ioc_ag_geometry(mp, arg);
2007
2008	case XFS_IOC_GETVERSION:
2009	return put_user(inode->i_generation, (int __user *)arg);
2010
2011	case XFS_IOC_FSGETXATTRA:
2012	return xfs_ioc_fsgetxattra(ip, arg);
2013
2014	case XFS_IOC_GETBMAP:
2015	case XFS_IOC_GETBMAPA:
2016	case XFS_IOC_GETBMAPX:
2017	return xfs_ioc_getbmap(file: filp, cmd, arg);
2018
2019	case FS_IOC_GETFSMAP:
2020	return xfs_ioc_getfsmap(ip, arg);
2021
2022	case XFS_IOC_SCRUB_METADATA:
2023	return xfs_ioc_scrub_metadata(file: filp, arg);
2024
2025	case XFS_IOC_FD_TO_HANDLE:
2026	case XFS_IOC_PATH_TO_HANDLE:
2027	case XFS_IOC_PATH_TO_FSHANDLE: {
2028	xfs_fsop_handlereq_t hreq;
2029
2030	if (copy_from_user(&hreq, arg, sizeof(hreq)))
2031	return -EFAULT;
2032	return xfs_find_handle(cmd, &hreq);
2033	}
2034	case XFS_IOC_OPEN_BY_HANDLE: {
2035	xfs_fsop_handlereq_t hreq;
2036
2037	if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
2038	return -EFAULT;
2039	return xfs_open_by_handle(filp, &hreq);
2040	}
2041
2042	case XFS_IOC_READLINK_BY_HANDLE: {
2043	xfs_fsop_handlereq_t hreq;
2044
2045	if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
2046	return -EFAULT;
2047	return xfs_readlink_by_handle(filp, &hreq);
2048	}
2049	case XFS_IOC_ATTRLIST_BY_HANDLE:
2050	return xfs_attrlist_by_handle(parfilp: filp, p: arg);
2051
2052	case XFS_IOC_ATTRMULTI_BY_HANDLE:
2053	return xfs_attrmulti_by_handle(parfilp: filp, arg);
2054
2055	case XFS_IOC_SWAPEXT: {
2056	struct xfs_swapext sxp;
2057
2058	if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
2059	return -EFAULT;
2060	error = mnt_want_write_file(file: filp);
2061	if (error)
2062	return error;
2063	error = xfs_ioc_swapext(&sxp);
2064	mnt_drop_write_file(file: filp);
2065	return error;
2066	}
2067
2068	case XFS_IOC_FSCOUNTS:
2069	return xfs_ioctl_fs_counts(mp, uarg: arg);
2070
2071	case XFS_IOC_SET_RESBLKS:
2072	case XFS_IOC_GET_RESBLKS:
2073	return xfs_ioctl_getset_resblocks(filp, cmd, arg);
2074
2075	case XFS_IOC_FSGROWFSDATA: {
2076	struct xfs_growfs_data in;
2077
2078	if (copy_from_user(to: &in, from: arg, n: sizeof(in)))
2079	return -EFAULT;
2080
2081	error = mnt_want_write_file(file: filp);
2082	if (error)
2083	return error;
2084	error = xfs_growfs_data(mp, in: &in);
2085	mnt_drop_write_file(file: filp);
2086	return error;
2087	}
2088
2089	case XFS_IOC_FSGROWFSLOG: {
2090	struct xfs_growfs_log in;
2091
2092	if (copy_from_user(to: &in, from: arg, n: sizeof(in)))
2093	return -EFAULT;
2094
2095	error = mnt_want_write_file(file: filp);
2096	if (error)
2097	return error;
2098	error = xfs_growfs_log(mp, in: &in);
2099	mnt_drop_write_file(file: filp);
2100	return error;
2101	}
2102
2103	case XFS_IOC_FSGROWFSRT: {
2104	xfs_growfs_rt_t in;
2105
2106	if (copy_from_user(&in, arg, sizeof(in)))
2107	return -EFAULT;
2108
2109	error = mnt_want_write_file(file: filp);
2110	if (error)
2111	return error;
2112	error = xfs_growfs_rt(mp, &in);
2113	mnt_drop_write_file(file: filp);
2114	return error;
2115	}
2116
2117	case XFS_IOC_GOINGDOWN: {
2118	uint32_t in;
2119
2120	if (!capable(CAP_SYS_ADMIN))
2121	return -EPERM;
2122
2123	if (get_user(in, (uint32_t __user *)arg))
2124	return -EFAULT;
2125
2126	return xfs_fs_goingdown(mp, inflags: in);
2127	}
2128
2129	case XFS_IOC_ERROR_INJECTION: {
2130	xfs_error_injection_t in;
2131
2132	if (!capable(CAP_SYS_ADMIN))
2133	return -EPERM;
2134
2135	if (copy_from_user(&in, arg, sizeof(in)))
2136	return -EFAULT;
2137
2138	return xfs_errortag_add(mp, in.errtag);
2139	}
2140
2141	case XFS_IOC_ERROR_CLEARALL:
2142	if (!capable(CAP_SYS_ADMIN))
2143	return -EPERM;
2144
2145	return xfs_errortag_clearall(mp);
2146
2147	case XFS_IOC_FREE_EOFBLOCKS: {
2148	struct xfs_fs_eofblocks eofb;
2149	struct xfs_icwalk icw;
2150
2151	if (!capable(CAP_SYS_ADMIN))
2152	return -EPERM;
2153
2154	if (xfs_is_readonly(mp))
2155	return -EROFS;
2156
2157	if (copy_from_user(to: &eofb, from: arg, n: sizeof(eofb)))
2158	return -EFAULT;
2159
2160	error = xfs_fs_eofblocks_from_user(src: &eofb, dst: &icw);
2161	if (error)
2162	return error;
2163
2164	trace_xfs_ioc_free_eofblocks(mp, icw: &icw, _RET_IP_);
2165
2166	sb_start_write(sb: mp->m_super);
2167	error = xfs_blockgc_free_space(mp, icm: &icw);
2168	sb_end_write(sb: mp->m_super);
2169	return error;
2170	}
2171
2172	default:
2173	return -ENOTTY;
2174	}
2175	}
2176