1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
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_ioctl.h"
15 #include "xfs_alloc.h"
16 #include "xfs_rtalloc.h"
17 #include "xfs_itable.h"
18 #include "xfs_error.h"
21 #include "xfs_bmap_util.h"
22 #include "xfs_fsops.h"
23 #include "xfs_discard.h"
24 #include "xfs_quota.h"
25 #include "xfs_export.h"
26 #include "xfs_trace.h"
27 #include "xfs_icache.h"
28 #include "xfs_symlink.h"
29 #include "xfs_trans.h"
31 #include "xfs_btree.h"
32 #include <linux/fsmap.h>
33 #include "xfs_fsmap.h"
34 #include "scrub/xfs_scrub.h"
37 #include <linux/capability.h>
38 #include <linux/cred.h>
39 #include <linux/dcache.h>
40 #include <linux/mount.h>
41 #include <linux/namei.h>
42 #include <linux/pagemap.h>
43 #include <linux/slab.h>
44 #include <linux/exportfs.h>
47 * xfs_find_handle maps from userspace xfs_fsop_handlereq structure to
48 * a file or fs handle.
50 * XFS_IOC_PATH_TO_FSHANDLE
51 * returns fs handle for a mount point or path within that mount point
52 * XFS_IOC_FD_TO_HANDLE
53 * returns full handle for a FD opened in user space
54 * XFS_IOC_PATH_TO_HANDLE
55 * returns full handle for a path
60 xfs_fsop_handlereq_t *hreq)
70 if (cmd == XFS_IOC_FD_TO_HANDLE) {
74 inode = file_inode(f.file);
76 error = user_lpath((const char __user *)hreq->path, &path);
79 inode = d_inode(path.dentry);
84 * We can only generate handles for inodes residing on a XFS filesystem,
85 * and only for regular files, directories or symbolic links.
88 if (inode->i_sb->s_magic != XFS_SB_MAGIC)
92 if (!S_ISREG(inode->i_mode) &&
93 !S_ISDIR(inode->i_mode) &&
94 !S_ISLNK(inode->i_mode))
98 memcpy(&handle.ha_fsid, ip->i_mount->m_fixedfsid, sizeof(xfs_fsid_t));
100 if (cmd == XFS_IOC_PATH_TO_FSHANDLE) {
102 * This handle only contains an fsid, zero the rest.
104 memset(&handle.ha_fid, 0, sizeof(handle.ha_fid));
105 hsize = sizeof(xfs_fsid_t);
107 handle.ha_fid.fid_len = sizeof(xfs_fid_t) -
108 sizeof(handle.ha_fid.fid_len);
109 handle.ha_fid.fid_pad = 0;
110 handle.ha_fid.fid_gen = inode->i_generation;
111 handle.ha_fid.fid_ino = ip->i_ino;
112 hsize = sizeof(xfs_handle_t);
116 if (copy_to_user(hreq->ohandle, &handle, hsize) ||
117 copy_to_user(hreq->ohandlen, &hsize, sizeof(__s32)))
123 if (cmd == XFS_IOC_FD_TO_HANDLE)
131 * No need to do permission checks on the various pathname components
132 * as the handle operations are privileged.
135 xfs_handle_acceptable(
137 struct dentry *dentry)
143 * Convert userspace handle data into a dentry.
146 xfs_handle_to_dentry(
147 struct file *parfilp,
148 void __user *uhandle,
152 struct xfs_fid64 fid;
155 * Only allow handle opens under a directory.
157 if (!S_ISDIR(file_inode(parfilp)->i_mode))
158 return ERR_PTR(-ENOTDIR);
160 if (hlen != sizeof(xfs_handle_t))
161 return ERR_PTR(-EINVAL);
162 if (copy_from_user(&handle, uhandle, hlen))
163 return ERR_PTR(-EFAULT);
164 if (handle.ha_fid.fid_len !=
165 sizeof(handle.ha_fid) - sizeof(handle.ha_fid.fid_len))
166 return ERR_PTR(-EINVAL);
168 memset(&fid, 0, sizeof(struct fid));
169 fid.ino = handle.ha_fid.fid_ino;
170 fid.gen = handle.ha_fid.fid_gen;
172 return exportfs_decode_fh(parfilp->f_path.mnt, (struct fid *)&fid, 3,
173 FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG,
174 xfs_handle_acceptable, NULL);
177 STATIC struct dentry *
178 xfs_handlereq_to_dentry(
179 struct file *parfilp,
180 xfs_fsop_handlereq_t *hreq)
182 return xfs_handle_to_dentry(parfilp, hreq->ihandle, hreq->ihandlen);
187 struct file *parfilp,
188 xfs_fsop_handlereq_t *hreq)
190 const struct cred *cred = current_cred();
196 struct dentry *dentry;
200 if (!capable(CAP_SYS_ADMIN))
203 dentry = xfs_handlereq_to_dentry(parfilp, hreq);
205 return PTR_ERR(dentry);
206 inode = d_inode(dentry);
208 /* Restrict xfs_open_by_handle to directories & regular files. */
209 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
214 #if BITS_PER_LONG != 32
215 hreq->oflags |= O_LARGEFILE;
218 permflag = hreq->oflags;
219 fmode = OPEN_FMODE(permflag);
220 if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&
221 (fmode & FMODE_WRITE) && IS_APPEND(inode)) {
226 if ((fmode & FMODE_WRITE) && IS_IMMUTABLE(inode)) {
231 /* Can't write directories. */
232 if (S_ISDIR(inode->i_mode) && (fmode & FMODE_WRITE)) {
237 fd = get_unused_fd_flags(0);
243 path.mnt = parfilp->f_path.mnt;
244 path.dentry = dentry;
245 filp = dentry_open(&path, hreq->oflags, cred);
249 return PTR_ERR(filp);
252 if (S_ISREG(inode->i_mode)) {
253 filp->f_flags |= O_NOATIME;
254 filp->f_mode |= FMODE_NOCMTIME;
257 fd_install(fd, filp);
266 xfs_readlink_by_handle(
267 struct file *parfilp,
268 xfs_fsop_handlereq_t *hreq)
270 struct dentry *dentry;
274 if (!capable(CAP_SYS_ADMIN))
277 dentry = xfs_handlereq_to_dentry(parfilp, hreq);
279 return PTR_ERR(dentry);
281 /* Restrict this handle operation to symlinks only. */
282 if (!d_is_symlink(dentry)) {
287 if (copy_from_user(&olen, hreq->ohandlen, sizeof(__u32))) {
292 error = vfs_readlink(dentry, hreq->ohandle, olen);
305 xfs_mount_t *mp = ip->i_mount;
309 if (!capable(CAP_SYS_ADMIN))
312 if (XFS_FORCED_SHUTDOWN(mp))
315 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
319 xfs_ilock(ip, XFS_ILOCK_EXCL);
320 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
322 ip->i_d.di_dmevmask = evmask;
323 ip->i_d.di_dmstate = state;
325 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
326 error = xfs_trans_commit(tp);
332 xfs_fssetdm_by_handle(
333 struct file *parfilp,
337 struct fsdmidata fsd;
338 xfs_fsop_setdm_handlereq_t dmhreq;
339 struct dentry *dentry;
341 if (!capable(CAP_MKNOD))
343 if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))
346 error = mnt_want_write_file(parfilp);
350 dentry = xfs_handlereq_to_dentry(parfilp, &dmhreq.hreq);
351 if (IS_ERR(dentry)) {
352 mnt_drop_write_file(parfilp);
353 return PTR_ERR(dentry);
356 if (IS_IMMUTABLE(d_inode(dentry)) || IS_APPEND(d_inode(dentry))) {
361 if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {
366 error = xfs_set_dmattrs(XFS_I(d_inode(dentry)), fsd.fsd_dmevmask,
370 mnt_drop_write_file(parfilp);
376 xfs_attrlist_by_handle(
377 struct file *parfilp,
381 attrlist_cursor_kern_t *cursor;
382 struct xfs_fsop_attrlist_handlereq __user *p = arg;
383 xfs_fsop_attrlist_handlereq_t al_hreq;
384 struct dentry *dentry;
387 if (!capable(CAP_SYS_ADMIN))
389 if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))
391 if (al_hreq.buflen < sizeof(struct attrlist) ||
392 al_hreq.buflen > XFS_XATTR_LIST_MAX)
396 * Reject flags, only allow namespaces.
398 if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
401 dentry = xfs_handlereq_to_dentry(parfilp, &al_hreq.hreq);
403 return PTR_ERR(dentry);
405 kbuf = kmem_zalloc_large(al_hreq.buflen, KM_SLEEP);
409 cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
410 error = xfs_attr_list(XFS_I(d_inode(dentry)), kbuf, al_hreq.buflen,
411 al_hreq.flags, cursor);
415 if (copy_to_user(&p->pos, cursor, sizeof(attrlist_cursor_kern_t))) {
420 if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))
431 xfs_attrmulti_attr_get(
434 unsigned char __user *ubuf,
441 if (*len > XFS_XATTR_SIZE_MAX)
443 kbuf = kmem_zalloc_large(*len, KM_SLEEP);
447 error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
451 if (copy_to_user(ubuf, kbuf, *len))
460 xfs_attrmulti_attr_set(
463 const unsigned char __user *ubuf,
470 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
472 if (len > XFS_XATTR_SIZE_MAX)
475 kbuf = memdup_user(ubuf, len);
477 return PTR_ERR(kbuf);
479 error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
481 xfs_forget_acl(inode, name, flags);
487 xfs_attrmulti_attr_remove(
494 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
496 error = xfs_attr_remove(XFS_I(inode), name, flags);
498 xfs_forget_acl(inode, name, flags);
503 xfs_attrmulti_by_handle(
504 struct file *parfilp,
508 xfs_attr_multiop_t *ops;
509 xfs_fsop_attrmulti_handlereq_t am_hreq;
510 struct dentry *dentry;
511 unsigned int i, size;
512 unsigned char *attr_name;
514 if (!capable(CAP_SYS_ADMIN))
516 if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
520 if (am_hreq.opcount >= INT_MAX / sizeof(xfs_attr_multiop_t))
523 dentry = xfs_handlereq_to_dentry(parfilp, &am_hreq.hreq);
525 return PTR_ERR(dentry);
528 size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);
529 if (!size || size > 16 * PAGE_SIZE)
532 ops = memdup_user(am_hreq.ops, size);
534 error = PTR_ERR(ops);
539 attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
544 for (i = 0; i < am_hreq.opcount; i++) {
545 ops[i].am_error = strncpy_from_user((char *)attr_name,
546 ops[i].am_attrname, MAXNAMELEN);
547 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
549 if (ops[i].am_error < 0)
552 switch (ops[i].am_opcode) {
554 ops[i].am_error = xfs_attrmulti_attr_get(
555 d_inode(dentry), attr_name,
556 ops[i].am_attrvalue, &ops[i].am_length,
560 ops[i].am_error = mnt_want_write_file(parfilp);
563 ops[i].am_error = xfs_attrmulti_attr_set(
564 d_inode(dentry), attr_name,
565 ops[i].am_attrvalue, ops[i].am_length,
567 mnt_drop_write_file(parfilp);
570 ops[i].am_error = mnt_want_write_file(parfilp);
573 ops[i].am_error = xfs_attrmulti_attr_remove(
574 d_inode(dentry), attr_name,
576 mnt_drop_write_file(parfilp);
579 ops[i].am_error = -EINVAL;
583 if (copy_to_user(am_hreq.ops, ops, size))
600 struct inode *inode = file_inode(filp);
601 struct xfs_inode *ip = XFS_I(inode);
603 enum xfs_prealloc_flags flags = 0;
604 uint iolock = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
607 if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
610 if (!(filp->f_mode & FMODE_WRITE))
613 if (!S_ISREG(inode->i_mode))
616 if (filp->f_flags & O_DSYNC)
617 flags |= XFS_PREALLOC_SYNC;
618 if (filp->f_mode & FMODE_NOCMTIME)
619 flags |= XFS_PREALLOC_INVISIBLE;
621 error = mnt_want_write_file(filp);
625 xfs_ilock(ip, iolock);
626 error = xfs_break_layouts(inode, &iolock, BREAK_UNMAP);
630 switch (bf->l_whence) {
634 bf->l_start += filp->f_pos;
637 bf->l_start += XFS_ISIZE(ip);
645 * length of <= 0 for resv/unresv/zero is invalid. length for
646 * alloc/free is ignored completely and we have no idea what userspace
647 * might have set it to, so set it to zero to allow range
651 case XFS_IOC_ZERO_RANGE:
653 case XFS_IOC_RESVSP64:
654 case XFS_IOC_UNRESVSP:
655 case XFS_IOC_UNRESVSP64:
656 if (bf->l_len <= 0) {
666 if (bf->l_start < 0 ||
667 bf->l_start > inode->i_sb->s_maxbytes ||
668 bf->l_start + bf->l_len < 0 ||
669 bf->l_start + bf->l_len >= inode->i_sb->s_maxbytes) {
675 case XFS_IOC_ZERO_RANGE:
676 flags |= XFS_PREALLOC_SET;
677 error = xfs_zero_file_space(ip, bf->l_start, bf->l_len);
680 case XFS_IOC_RESVSP64:
681 flags |= XFS_PREALLOC_SET;
682 error = xfs_alloc_file_space(ip, bf->l_start, bf->l_len,
685 case XFS_IOC_UNRESVSP:
686 case XFS_IOC_UNRESVSP64:
687 error = xfs_free_file_space(ip, bf->l_start, bf->l_len);
689 case XFS_IOC_ALLOCSP:
690 case XFS_IOC_ALLOCSP64:
692 case XFS_IOC_FREESP64:
693 flags |= XFS_PREALLOC_CLEAR;
694 if (bf->l_start > XFS_ISIZE(ip)) {
695 error = xfs_alloc_file_space(ip, XFS_ISIZE(ip),
696 bf->l_start - XFS_ISIZE(ip), 0);
701 iattr.ia_valid = ATTR_SIZE;
702 iattr.ia_size = bf->l_start;
704 error = xfs_vn_setattr_size(file_dentry(filp), &iattr);
714 error = xfs_update_prealloc_flags(ip, flags);
717 xfs_iunlock(ip, iolock);
718 mnt_drop_write_file(filp);
728 xfs_fsop_bulkreq_t bulkreq;
729 int count; /* # of records returned */
730 xfs_ino_t inlast; /* last inode number */
734 /* done = 1 if there are more stats to get and if bulkstat */
735 /* should be called again (unused here, but used in dmapi) */
737 if (!capable(CAP_SYS_ADMIN))
740 if (XFS_FORCED_SHUTDOWN(mp))
743 if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
746 if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
749 if ((count = bulkreq.icount) <= 0)
752 if (bulkreq.ubuffer == NULL)
755 if (cmd == XFS_IOC_FSINUMBERS)
756 error = xfs_inumbers(mp, &inlast, &count,
757 bulkreq.ubuffer, xfs_inumbers_fmt);
758 else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
759 error = xfs_bulkstat_one(mp, inlast, bulkreq.ubuffer,
760 sizeof(xfs_bstat_t), NULL, &done);
761 else /* XFS_IOC_FSBULKSTAT */
762 error = xfs_bulkstat(mp, &inlast, &count, xfs_bulkstat_one,
763 sizeof(xfs_bstat_t), bulkreq.ubuffer,
769 if (bulkreq.ocount != NULL) {
770 if (copy_to_user(bulkreq.lastip, &inlast,
774 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
782 xfs_ioc_fsgeometry_v1(
786 xfs_fsop_geom_t fsgeo;
789 error = xfs_fs_geometry(&mp->m_sb, &fsgeo, 3);
794 * Caller should have passed an argument of type
795 * xfs_fsop_geom_v1_t. This is a proper subset of the
796 * xfs_fsop_geom_t that xfs_fs_geometry() fills in.
798 if (copy_to_user(arg, &fsgeo, sizeof(xfs_fsop_geom_v1_t)))
808 xfs_fsop_geom_t fsgeo;
811 error = xfs_fs_geometry(&mp->m_sb, &fsgeo, 4);
815 if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
821 * Linux extended inode flags interface.
825 xfs_merge_ioc_xflags(
829 unsigned int xflags = start;
831 if (flags & FS_IMMUTABLE_FL)
832 xflags |= FS_XFLAG_IMMUTABLE;
834 xflags &= ~FS_XFLAG_IMMUTABLE;
835 if (flags & FS_APPEND_FL)
836 xflags |= FS_XFLAG_APPEND;
838 xflags &= ~FS_XFLAG_APPEND;
839 if (flags & FS_SYNC_FL)
840 xflags |= FS_XFLAG_SYNC;
842 xflags &= ~FS_XFLAG_SYNC;
843 if (flags & FS_NOATIME_FL)
844 xflags |= FS_XFLAG_NOATIME;
846 xflags &= ~FS_XFLAG_NOATIME;
847 if (flags & FS_NODUMP_FL)
848 xflags |= FS_XFLAG_NODUMP;
850 xflags &= ~FS_XFLAG_NODUMP;
859 unsigned int flags = 0;
861 if (di_flags & XFS_DIFLAG_IMMUTABLE)
862 flags |= FS_IMMUTABLE_FL;
863 if (di_flags & XFS_DIFLAG_APPEND)
864 flags |= FS_APPEND_FL;
865 if (di_flags & XFS_DIFLAG_SYNC)
867 if (di_flags & XFS_DIFLAG_NOATIME)
868 flags |= FS_NOATIME_FL;
869 if (di_flags & XFS_DIFLAG_NODUMP)
870 flags |= FS_NODUMP_FL;
882 memset(&fa, 0, sizeof(struct fsxattr));
884 xfs_ilock(ip, XFS_ILOCK_SHARED);
885 fa.fsx_xflags = xfs_ip2xflags(ip);
886 fa.fsx_extsize = ip->i_d.di_extsize << ip->i_mount->m_sb.sb_blocklog;
887 fa.fsx_cowextsize = ip->i_d.di_cowextsize <<
888 ip->i_mount->m_sb.sb_blocklog;
889 fa.fsx_projid = xfs_get_projid(ip);
893 if (ip->i_afp->if_flags & XFS_IFEXTENTS)
894 fa.fsx_nextents = xfs_iext_count(ip->i_afp);
896 fa.fsx_nextents = ip->i_d.di_anextents;
900 if (ip->i_df.if_flags & XFS_IFEXTENTS)
901 fa.fsx_nextents = xfs_iext_count(&ip->i_df);
903 fa.fsx_nextents = ip->i_d.di_nextents;
905 xfs_iunlock(ip, XFS_ILOCK_SHARED);
907 if (copy_to_user(arg, &fa, sizeof(fa)))
914 struct xfs_inode *ip,
917 /* can't set PREALLOC this way, just preserve it */
919 (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC);
921 if (xflags & FS_XFLAG_IMMUTABLE)
922 di_flags |= XFS_DIFLAG_IMMUTABLE;
923 if (xflags & FS_XFLAG_APPEND)
924 di_flags |= XFS_DIFLAG_APPEND;
925 if (xflags & FS_XFLAG_SYNC)
926 di_flags |= XFS_DIFLAG_SYNC;
927 if (xflags & FS_XFLAG_NOATIME)
928 di_flags |= XFS_DIFLAG_NOATIME;
929 if (xflags & FS_XFLAG_NODUMP)
930 di_flags |= XFS_DIFLAG_NODUMP;
931 if (xflags & FS_XFLAG_NODEFRAG)
932 di_flags |= XFS_DIFLAG_NODEFRAG;
933 if (xflags & FS_XFLAG_FILESTREAM)
934 di_flags |= XFS_DIFLAG_FILESTREAM;
935 if (S_ISDIR(VFS_I(ip)->i_mode)) {
936 if (xflags & FS_XFLAG_RTINHERIT)
937 di_flags |= XFS_DIFLAG_RTINHERIT;
938 if (xflags & FS_XFLAG_NOSYMLINKS)
939 di_flags |= XFS_DIFLAG_NOSYMLINKS;
940 if (xflags & FS_XFLAG_EXTSZINHERIT)
941 di_flags |= XFS_DIFLAG_EXTSZINHERIT;
942 if (xflags & FS_XFLAG_PROJINHERIT)
943 di_flags |= XFS_DIFLAG_PROJINHERIT;
944 } else if (S_ISREG(VFS_I(ip)->i_mode)) {
945 if (xflags & FS_XFLAG_REALTIME)
946 di_flags |= XFS_DIFLAG_REALTIME;
947 if (xflags & FS_XFLAG_EXTSIZE)
948 di_flags |= XFS_DIFLAG_EXTSIZE;
956 struct xfs_inode *ip,
960 (ip->i_d.di_flags2 & XFS_DIFLAG2_REFLINK);
962 if (xflags & FS_XFLAG_DAX)
963 di_flags2 |= XFS_DIFLAG2_DAX;
964 if (xflags & FS_XFLAG_COWEXTSIZE)
965 di_flags2 |= XFS_DIFLAG2_COWEXTSIZE;
971 xfs_diflags_to_linux(
972 struct xfs_inode *ip)
974 struct inode *inode = VFS_I(ip);
975 unsigned int xflags = xfs_ip2xflags(ip);
977 if (xflags & FS_XFLAG_IMMUTABLE)
978 inode->i_flags |= S_IMMUTABLE;
980 inode->i_flags &= ~S_IMMUTABLE;
981 if (xflags & FS_XFLAG_APPEND)
982 inode->i_flags |= S_APPEND;
984 inode->i_flags &= ~S_APPEND;
985 if (xflags & FS_XFLAG_SYNC)
986 inode->i_flags |= S_SYNC;
988 inode->i_flags &= ~S_SYNC;
989 if (xflags & FS_XFLAG_NOATIME)
990 inode->i_flags |= S_NOATIME;
992 inode->i_flags &= ~S_NOATIME;
993 #if 0 /* disabled until the flag switching races are sorted out */
994 if (xflags & FS_XFLAG_DAX)
995 inode->i_flags |= S_DAX;
997 inode->i_flags &= ~S_DAX;
1002 xfs_ioctl_setattr_xflags(
1003 struct xfs_trans *tp,
1004 struct xfs_inode *ip,
1007 struct xfs_mount *mp = ip->i_mount;
1010 /* Can't change realtime flag if any extents are allocated. */
1011 if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
1012 XFS_IS_REALTIME_INODE(ip) != (fa->fsx_xflags & FS_XFLAG_REALTIME))
1015 /* If realtime flag is set then must have realtime device */
1016 if (fa->fsx_xflags & FS_XFLAG_REALTIME) {
1017 if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 ||
1018 (ip->i_d.di_extsize % mp->m_sb.sb_rextsize))
1022 /* Clear reflink if we are actually able to set the rt flag. */
1023 if ((fa->fsx_xflags & FS_XFLAG_REALTIME) && xfs_is_reflink_inode(ip))
1024 ip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK;
1026 /* Don't allow us to set DAX mode for a reflinked file for now. */
1027 if ((fa->fsx_xflags & FS_XFLAG_DAX) && xfs_is_reflink_inode(ip))
1031 * Can't modify an immutable/append-only file unless
1032 * we have appropriate permission.
1034 if (((ip->i_d.di_flags & (XFS_DIFLAG_IMMUTABLE | XFS_DIFLAG_APPEND)) ||
1035 (fa->fsx_xflags & (FS_XFLAG_IMMUTABLE | FS_XFLAG_APPEND))) &&
1036 !capable(CAP_LINUX_IMMUTABLE))
1039 /* diflags2 only valid for v3 inodes. */
1040 di_flags2 = xfs_flags2diflags2(ip, fa->fsx_xflags);
1041 if (di_flags2 && ip->i_d.di_version < 3)
1044 ip->i_d.di_flags = xfs_flags2diflags(ip, fa->fsx_xflags);
1045 ip->i_d.di_flags2 = di_flags2;
1047 xfs_diflags_to_linux(ip);
1048 xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1049 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1050 XFS_STATS_INC(mp, xs_ig_attrchg);
1055 * If we are changing DAX flags, we have to ensure the file is clean and any
1056 * cached objects in the address space are invalidated and removed. This
1057 * requires us to lock out other IO and page faults similar to a truncate
1058 * operation. The locks need to be held until the transaction has been committed
1059 * so that the cache invalidation is atomic with respect to the DAX flag
1063 xfs_ioctl_setattr_dax_invalidate(
1064 struct xfs_inode *ip,
1068 struct inode *inode = VFS_I(ip);
1069 struct super_block *sb = inode->i_sb;
1075 * It is only valid to set the DAX flag on regular files and
1076 * directories on filesystems where the block size is equal to the page
1077 * size. On directories it serves as an inherited hint so we don't
1078 * have to check the device for dax support or flush pagecache.
1080 if (fa->fsx_xflags & FS_XFLAG_DAX) {
1081 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))
1083 if (S_ISREG(inode->i_mode) &&
1084 !bdev_dax_supported(xfs_find_bdev_for_inode(VFS_I(ip)),
1089 /* If the DAX state is not changing, we have nothing to do here. */
1090 if ((fa->fsx_xflags & FS_XFLAG_DAX) && IS_DAX(inode))
1092 if (!(fa->fsx_xflags & FS_XFLAG_DAX) && !IS_DAX(inode))
1095 if (S_ISDIR(inode->i_mode))
1098 /* lock, flush and invalidate mapping in preparation for flag change */
1099 xfs_ilock(ip, XFS_MMAPLOCK_EXCL | XFS_IOLOCK_EXCL);
1100 error = filemap_write_and_wait(inode->i_mapping);
1103 error = invalidate_inode_pages2(inode->i_mapping);
1107 *join_flags = XFS_MMAPLOCK_EXCL | XFS_IOLOCK_EXCL;
1111 xfs_iunlock(ip, XFS_MMAPLOCK_EXCL | XFS_IOLOCK_EXCL);
1117 * Set up the transaction structure for the setattr operation, checking that we
1118 * have permission to do so. On success, return a clean transaction and the
1119 * inode locked exclusively ready for further operation specific checks. On
1120 * failure, return an error without modifying or locking the inode.
1122 * The inode might already be IO locked on call. If this is the case, it is
1123 * indicated in @join_flags and we take full responsibility for ensuring they
1124 * are unlocked from now on. Hence if we have an error here, we still have to
1125 * unlock them. Otherwise, once they are joined to the transaction, they will
1126 * be unlocked on commit/cancel.
1128 static struct xfs_trans *
1129 xfs_ioctl_setattr_get_trans(
1130 struct xfs_inode *ip,
1133 struct xfs_mount *mp = ip->i_mount;
1134 struct xfs_trans *tp;
1137 if (mp->m_flags & XFS_MOUNT_RDONLY)
1140 if (XFS_FORCED_SHUTDOWN(mp))
1143 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
1145 return ERR_PTR(error);
1147 xfs_ilock(ip, XFS_ILOCK_EXCL);
1148 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | join_flags);
1152 * CAP_FOWNER overrides the following restrictions:
1154 * The user ID of the calling process must be equal to the file owner
1155 * ID, except in cases where the CAP_FSETID capability is applicable.
1157 if (!inode_owner_or_capable(VFS_I(ip))) {
1162 if (mp->m_flags & XFS_MOUNT_WSYNC)
1163 xfs_trans_set_sync(tp);
1168 xfs_trans_cancel(tp);
1171 xfs_iunlock(ip, join_flags);
1172 return ERR_PTR(error);
1176 * extent size hint validation is somewhat cumbersome. Rules are:
1178 * 1. extent size hint is only valid for directories and regular files
1179 * 2. FS_XFLAG_EXTSIZE is only valid for regular files
1180 * 3. FS_XFLAG_EXTSZINHERIT is only valid for directories.
1181 * 4. can only be changed on regular files if no extents are allocated
1182 * 5. can be changed on directories at any time
1183 * 6. extsize hint of 0 turns off hints, clears inode flags.
1184 * 7. Extent size must be a multiple of the appropriate block size.
1185 * 8. for non-realtime files, the extent size hint must be limited
1186 * to half the AG size to avoid alignment extending the extent beyond the
1189 * Please keep this function in sync with xfs_scrub_inode_extsize.
1192 xfs_ioctl_setattr_check_extsize(
1193 struct xfs_inode *ip,
1196 struct xfs_mount *mp = ip->i_mount;
1198 if ((fa->fsx_xflags & FS_XFLAG_EXTSIZE) && !S_ISREG(VFS_I(ip)->i_mode))
1201 if ((fa->fsx_xflags & FS_XFLAG_EXTSZINHERIT) &&
1202 !S_ISDIR(VFS_I(ip)->i_mode))
1205 if (S_ISREG(VFS_I(ip)->i_mode) && ip->i_d.di_nextents &&
1206 ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) != fa->fsx_extsize))
1209 if (fa->fsx_extsize != 0) {
1211 xfs_fsblock_t extsize_fsb;
1213 extsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_extsize);
1214 if (extsize_fsb > MAXEXTLEN)
1217 if (XFS_IS_REALTIME_INODE(ip) ||
1218 (fa->fsx_xflags & FS_XFLAG_REALTIME)) {
1219 size = mp->m_sb.sb_rextsize << mp->m_sb.sb_blocklog;
1221 size = mp->m_sb.sb_blocksize;
1222 if (extsize_fsb > mp->m_sb.sb_agblocks / 2)
1226 if (fa->fsx_extsize % size)
1229 fa->fsx_xflags &= ~(FS_XFLAG_EXTSIZE | FS_XFLAG_EXTSZINHERIT);
1235 * CoW extent size hint validation rules are:
1237 * 1. CoW extent size hint can only be set if reflink is enabled on the fs.
1238 * The inode does not have to have any shared blocks, but it must be a v3.
1239 * 2. FS_XFLAG_COWEXTSIZE is only valid for directories and regular files;
1240 * for a directory, the hint is propagated to new files.
1241 * 3. Can be changed on files & directories at any time.
1242 * 4. CoW extsize hint of 0 turns off hints, clears inode flags.
1243 * 5. Extent size must be a multiple of the appropriate block size.
1244 * 6. The extent size hint must be limited to half the AG size to avoid
1245 * alignment extending the extent beyond the limits of the AG.
1247 * Please keep this function in sync with xfs_scrub_inode_cowextsize.
1250 xfs_ioctl_setattr_check_cowextsize(
1251 struct xfs_inode *ip,
1254 struct xfs_mount *mp = ip->i_mount;
1256 if (!(fa->fsx_xflags & FS_XFLAG_COWEXTSIZE))
1259 if (!xfs_sb_version_hasreflink(&ip->i_mount->m_sb) ||
1260 ip->i_d.di_version != 3)
1263 if (!S_ISREG(VFS_I(ip)->i_mode) && !S_ISDIR(VFS_I(ip)->i_mode))
1266 if (fa->fsx_cowextsize != 0) {
1268 xfs_fsblock_t cowextsize_fsb;
1270 cowextsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_cowextsize);
1271 if (cowextsize_fsb > MAXEXTLEN)
1274 size = mp->m_sb.sb_blocksize;
1275 if (cowextsize_fsb > mp->m_sb.sb_agblocks / 2)
1278 if (fa->fsx_cowextsize % size)
1281 fa->fsx_xflags &= ~FS_XFLAG_COWEXTSIZE;
1287 xfs_ioctl_setattr_check_projid(
1288 struct xfs_inode *ip,
1291 /* Disallow 32bit project ids if projid32bit feature is not enabled. */
1292 if (fa->fsx_projid > (uint16_t)-1 &&
1293 !xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb))
1297 * Project Quota ID state is only allowed to change from within the init
1298 * namespace. Enforce that restriction only if we are trying to change
1299 * the quota ID state. Everything else is allowed in user namespaces.
1301 if (current_user_ns() == &init_user_ns)
1304 if (xfs_get_projid(ip) != fa->fsx_projid)
1306 if ((fa->fsx_xflags & FS_XFLAG_PROJINHERIT) !=
1307 (ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT))
1318 struct xfs_mount *mp = ip->i_mount;
1319 struct xfs_trans *tp;
1320 struct xfs_dquot *udqp = NULL;
1321 struct xfs_dquot *pdqp = NULL;
1322 struct xfs_dquot *olddquot = NULL;
1326 trace_xfs_ioctl_setattr(ip);
1328 code = xfs_ioctl_setattr_check_projid(ip, fa);
1333 * If disk quotas is on, we make sure that the dquots do exist on disk,
1334 * before we start any other transactions. Trying to do this later
1335 * is messy. We don't care to take a readlock to look at the ids
1336 * in inode here, because we can't hold it across the trans_reserve.
1337 * If the IDs do change before we take the ilock, we're covered
1338 * because the i_*dquot fields will get updated anyway.
1340 if (XFS_IS_QUOTA_ON(mp)) {
1341 code = xfs_qm_vop_dqalloc(ip, ip->i_d.di_uid,
1342 ip->i_d.di_gid, fa->fsx_projid,
1343 XFS_QMOPT_PQUOTA, &udqp, NULL, &pdqp);
1349 * Changing DAX config may require inode locking for mapping
1350 * invalidation. These need to be held all the way to transaction commit
1351 * or cancel time, so need to be passed through to
1352 * xfs_ioctl_setattr_get_trans() so it can apply them to the join call
1355 code = xfs_ioctl_setattr_dax_invalidate(ip, fa, &join_flags);
1357 goto error_free_dquots;
1359 tp = xfs_ioctl_setattr_get_trans(ip, join_flags);
1362 goto error_free_dquots;
1366 if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp) &&
1367 xfs_get_projid(ip) != fa->fsx_projid) {
1368 code = xfs_qm_vop_chown_reserve(tp, ip, udqp, NULL, pdqp,
1369 capable(CAP_FOWNER) ? XFS_QMOPT_FORCE_RES : 0);
1370 if (code) /* out of quota */
1371 goto error_trans_cancel;
1374 code = xfs_ioctl_setattr_check_extsize(ip, fa);
1376 goto error_trans_cancel;
1378 code = xfs_ioctl_setattr_check_cowextsize(ip, fa);
1380 goto error_trans_cancel;
1382 code = xfs_ioctl_setattr_xflags(tp, ip, fa);
1384 goto error_trans_cancel;
1387 * Change file ownership. Must be the owner or privileged. CAP_FSETID
1388 * overrides the following restrictions:
1390 * The set-user-ID and set-group-ID bits of a file will be cleared upon
1391 * successful return from chown()
1394 if ((VFS_I(ip)->i_mode & (S_ISUID|S_ISGID)) &&
1395 !capable_wrt_inode_uidgid(VFS_I(ip), CAP_FSETID))
1396 VFS_I(ip)->i_mode &= ~(S_ISUID|S_ISGID);
1398 /* Change the ownerships and register project quota modifications */
1399 if (xfs_get_projid(ip) != fa->fsx_projid) {
1400 if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp)) {
1401 olddquot = xfs_qm_vop_chown(tp, ip,
1402 &ip->i_pdquot, pdqp);
1404 ASSERT(ip->i_d.di_version > 1);
1405 xfs_set_projid(ip, fa->fsx_projid);
1409 * Only set the extent size hint if we've already determined that the
1410 * extent size hint should be set on the inode. If no extent size flags
1411 * are set on the inode then unconditionally clear the extent size hint.
1413 if (ip->i_d.di_flags & (XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT))
1414 ip->i_d.di_extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;
1416 ip->i_d.di_extsize = 0;
1417 if (ip->i_d.di_version == 3 &&
1418 (ip->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE))
1419 ip->i_d.di_cowextsize = fa->fsx_cowextsize >>
1420 mp->m_sb.sb_blocklog;
1422 ip->i_d.di_cowextsize = 0;
1424 code = xfs_trans_commit(tp);
1427 * Release any dquot(s) the inode had kept before chown.
1429 xfs_qm_dqrele(olddquot);
1430 xfs_qm_dqrele(udqp);
1431 xfs_qm_dqrele(pdqp);
1436 xfs_trans_cancel(tp);
1438 xfs_qm_dqrele(udqp);
1439 xfs_qm_dqrele(pdqp);
1452 if (copy_from_user(&fa, arg, sizeof(fa)))
1455 error = mnt_want_write_file(filp);
1458 error = xfs_ioctl_setattr(ip, &fa);
1459 mnt_drop_write_file(filp);
1470 flags = xfs_di2lxflags(ip->i_d.di_flags);
1471 if (copy_to_user(arg, &flags, sizeof(flags)))
1478 struct xfs_inode *ip,
1482 struct xfs_trans *tp;
1488 if (copy_from_user(&flags, arg, sizeof(flags)))
1491 if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
1492 FS_NOATIME_FL | FS_NODUMP_FL | \
1496 fa.fsx_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip));
1498 error = mnt_want_write_file(filp);
1503 * Changing DAX config may require inode locking for mapping
1504 * invalidation. These need to be held all the way to transaction commit
1505 * or cancel time, so need to be passed through to
1506 * xfs_ioctl_setattr_get_trans() so it can apply them to the join call
1509 error = xfs_ioctl_setattr_dax_invalidate(ip, &fa, &join_flags);
1511 goto out_drop_write;
1513 tp = xfs_ioctl_setattr_get_trans(ip, join_flags);
1515 error = PTR_ERR(tp);
1516 goto out_drop_write;
1519 error = xfs_ioctl_setattr_xflags(tp, ip, &fa);
1521 xfs_trans_cancel(tp);
1522 goto out_drop_write;
1525 error = xfs_trans_commit(tp);
1527 mnt_drop_write_file(filp);
1534 struct getbmapx __user *u,
1537 if (put_user(p->bmv_offset, &u->bmv_offset) ||
1538 put_user(p->bmv_block, &u->bmv_block) ||
1539 put_user(p->bmv_length, &u->bmv_length) ||
1540 put_user(0, &u->bmv_count) ||
1541 put_user(0, &u->bmv_entries))
1543 if (recsize < sizeof(struct getbmapx))
1545 if (put_user(0, &u->bmv_iflags) ||
1546 put_user(p->bmv_oflags, &u->bmv_oflags) ||
1547 put_user(0, &u->bmv_unused1) ||
1548 put_user(0, &u->bmv_unused2))
1559 struct getbmapx bmx = { 0 };
1560 struct kgetbmap *buf;
1565 case XFS_IOC_GETBMAPA:
1566 bmx.bmv_iflags = BMV_IF_ATTRFORK;
1568 case XFS_IOC_GETBMAP:
1569 if (file->f_mode & FMODE_NOCMTIME)
1570 bmx.bmv_iflags |= BMV_IF_NO_DMAPI_READ;
1571 /* struct getbmap is a strict subset of struct getbmapx. */
1572 recsize = sizeof(struct getbmap);
1574 case XFS_IOC_GETBMAPX:
1575 recsize = sizeof(struct getbmapx);
1581 if (copy_from_user(&bmx, arg, recsize))
1584 if (bmx.bmv_count < 2)
1586 if (bmx.bmv_count > ULONG_MAX / recsize)
1589 buf = kmem_zalloc_large(bmx.bmv_count * sizeof(*buf), 0);
1593 error = xfs_getbmap(XFS_I(file_inode(file)), &bmx, buf);
1598 if (copy_to_user(arg, &bmx, recsize))
1602 for (i = 0; i < bmx.bmv_entries; i++) {
1603 if (!xfs_getbmap_format(buf + i, arg, recsize))
1614 struct getfsmap_info {
1615 struct xfs_mount *mp;
1616 struct fsmap_head __user *data;
1622 xfs_getfsmap_format(struct xfs_fsmap *xfm, void *priv)
1624 struct getfsmap_info *info = priv;
1627 trace_xfs_getfsmap_mapping(info->mp, xfm);
1629 info->last_flags = xfm->fmr_flags;
1630 xfs_fsmap_from_internal(&fm, xfm);
1631 if (copy_to_user(&info->data->fmh_recs[info->idx++], &fm,
1632 sizeof(struct fsmap)))
1640 struct xfs_inode *ip,
1641 struct fsmap_head __user *arg)
1643 struct getfsmap_info info = { NULL };
1644 struct xfs_fsmap_head xhead = {0};
1645 struct fsmap_head head;
1646 bool aborted = false;
1649 if (copy_from_user(&head, arg, sizeof(struct fsmap_head)))
1651 if (memchr_inv(head.fmh_reserved, 0, sizeof(head.fmh_reserved)) ||
1652 memchr_inv(head.fmh_keys[0].fmr_reserved, 0,
1653 sizeof(head.fmh_keys[0].fmr_reserved)) ||
1654 memchr_inv(head.fmh_keys[1].fmr_reserved, 0,
1655 sizeof(head.fmh_keys[1].fmr_reserved)))
1658 xhead.fmh_iflags = head.fmh_iflags;
1659 xhead.fmh_count = head.fmh_count;
1660 xfs_fsmap_to_internal(&xhead.fmh_keys[0], &head.fmh_keys[0]);
1661 xfs_fsmap_to_internal(&xhead.fmh_keys[1], &head.fmh_keys[1]);
1663 trace_xfs_getfsmap_low_key(ip->i_mount, &xhead.fmh_keys[0]);
1664 trace_xfs_getfsmap_high_key(ip->i_mount, &xhead.fmh_keys[1]);
1666 info.mp = ip->i_mount;
1668 error = xfs_getfsmap(ip->i_mount, &xhead, xfs_getfsmap_format, &info);
1669 if (error == XFS_BTREE_QUERY_RANGE_ABORT) {
1675 /* If we didn't abort, set the "last" flag in the last fmx */
1676 if (!aborted && info.idx) {
1677 info.last_flags |= FMR_OF_LAST;
1678 if (copy_to_user(&info.data->fmh_recs[info.idx - 1].fmr_flags,
1679 &info.last_flags, sizeof(info.last_flags)))
1683 /* copy back header */
1684 head.fmh_entries = xhead.fmh_entries;
1685 head.fmh_oflags = xhead.fmh_oflags;
1686 if (copy_to_user(arg, &head, sizeof(struct fsmap_head)))
1693 xfs_ioc_scrub_metadata(
1694 struct xfs_inode *ip,
1697 struct xfs_scrub_metadata scrub;
1700 if (!capable(CAP_SYS_ADMIN))
1703 if (copy_from_user(&scrub, arg, sizeof(scrub)))
1706 error = xfs_scrub_metadata(ip, &scrub);
1710 if (copy_to_user(arg, &scrub, sizeof(scrub)))
1720 xfs_inode_t *ip, *tip;
1724 /* Pull information for the target fd */
1725 f = fdget((int)sxp->sx_fdtarget);
1731 if (!(f.file->f_mode & FMODE_WRITE) ||
1732 !(f.file->f_mode & FMODE_READ) ||
1733 (f.file->f_flags & O_APPEND)) {
1738 tmp = fdget((int)sxp->sx_fdtmp);
1744 if (!(tmp.file->f_mode & FMODE_WRITE) ||
1745 !(tmp.file->f_mode & FMODE_READ) ||
1746 (tmp.file->f_flags & O_APPEND)) {
1748 goto out_put_tmp_file;
1751 if (IS_SWAPFILE(file_inode(f.file)) ||
1752 IS_SWAPFILE(file_inode(tmp.file))) {
1754 goto out_put_tmp_file;
1758 * We need to ensure that the fds passed in point to XFS inodes
1759 * before we cast and access them as XFS structures as we have no
1760 * control over what the user passes us here.
1762 if (f.file->f_op != &xfs_file_operations ||
1763 tmp.file->f_op != &xfs_file_operations) {
1765 goto out_put_tmp_file;
1768 ip = XFS_I(file_inode(f.file));
1769 tip = XFS_I(file_inode(tmp.file));
1771 if (ip->i_mount != tip->i_mount) {
1773 goto out_put_tmp_file;
1776 if (ip->i_ino == tip->i_ino) {
1778 goto out_put_tmp_file;
1781 if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
1783 goto out_put_tmp_file;
1786 error = xfs_swap_extents(ip, tip, sxp);
1798 struct xfs_mount *mp,
1799 char __user *user_label)
1801 struct xfs_sb *sbp = &mp->m_sb;
1802 char label[XFSLABEL_MAX + 1];
1805 BUILD_BUG_ON(sizeof(sbp->sb_fname) > FSLABEL_MAX);
1807 /* 1 larger than sb_fname, so this ensures a trailing NUL char */
1808 memset(label, 0, sizeof(label));
1809 spin_lock(&mp->m_sb_lock);
1810 strncpy(label, sbp->sb_fname, XFSLABEL_MAX);
1811 spin_unlock(&mp->m_sb_lock);
1813 if (copy_to_user(user_label, label, sizeof(label)))
1821 struct xfs_mount *mp,
1822 char __user *newlabel)
1824 struct xfs_sb *sbp = &mp->m_sb;
1825 char label[XFSLABEL_MAX + 1];
1829 if (!capable(CAP_SYS_ADMIN))
1832 * The generic ioctl allows up to FSLABEL_MAX chars, but XFS is much
1833 * smaller, at 12 bytes. We copy one more to be sure we find the
1834 * (required) NULL character to test the incoming label length.
1835 * NB: The on disk label doesn't need to be null terminated.
1837 if (copy_from_user(label, newlabel, XFSLABEL_MAX + 1))
1839 len = strnlen(label, XFSLABEL_MAX + 1);
1840 if (len > sizeof(sbp->sb_fname))
1843 error = mnt_want_write_file(filp);
1847 spin_lock(&mp->m_sb_lock);
1848 memset(sbp->sb_fname, 0, sizeof(sbp->sb_fname));
1849 memcpy(sbp->sb_fname, label, len);
1850 spin_unlock(&mp->m_sb_lock);
1853 * Now we do several things to satisfy userspace.
1854 * In addition to normal logging of the primary superblock, we also
1855 * immediately write these changes to sector zero for the primary, then
1856 * update all backup supers (as xfs_db does for a label change), then
1857 * invalidate the block device page cache. This is so that any prior
1858 * buffered reads from userspace (i.e. from blkid) are invalidated,
1859 * and userspace will see the newly-written label.
1861 error = xfs_sync_sb_buf(mp);
1865 * growfs also updates backup supers so lock against that.
1867 mutex_lock(&mp->m_growlock);
1868 error = xfs_update_secondary_sbs(mp);
1869 mutex_unlock(&mp->m_growlock);
1871 invalidate_bdev(mp->m_ddev_targp->bt_bdev);
1874 mnt_drop_write_file(filp);
1879 * Note: some of the ioctl's return positive numbers as a
1880 * byte count indicating success, such as readlink_by_handle.
1881 * So we don't "sign flip" like most other routines. This means
1882 * true errors need to be returned as a negative value.
1890 struct inode *inode = file_inode(filp);
1891 struct xfs_inode *ip = XFS_I(inode);
1892 struct xfs_mount *mp = ip->i_mount;
1893 void __user *arg = (void __user *)p;
1896 trace_xfs_file_ioctl(ip);
1900 return xfs_ioc_trim(mp, arg);
1901 case FS_IOC_GETFSLABEL:
1902 return xfs_ioc_getlabel(mp, arg);
1903 case FS_IOC_SETFSLABEL:
1904 return xfs_ioc_setlabel(filp, mp, arg);
1905 case XFS_IOC_ALLOCSP:
1906 case XFS_IOC_FREESP:
1907 case XFS_IOC_RESVSP:
1908 case XFS_IOC_UNRESVSP:
1909 case XFS_IOC_ALLOCSP64:
1910 case XFS_IOC_FREESP64:
1911 case XFS_IOC_RESVSP64:
1912 case XFS_IOC_UNRESVSP64:
1913 case XFS_IOC_ZERO_RANGE: {
1916 if (copy_from_user(&bf, arg, sizeof(bf)))
1918 return xfs_ioc_space(filp, cmd, &bf);
1920 case XFS_IOC_DIOINFO: {
1922 xfs_buftarg_t *target =
1923 XFS_IS_REALTIME_INODE(ip) ?
1924 mp->m_rtdev_targp : mp->m_ddev_targp;
1926 da.d_mem = da.d_miniosz = target->bt_logical_sectorsize;
1927 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1929 if (copy_to_user(arg, &da, sizeof(da)))
1934 case XFS_IOC_FSBULKSTAT_SINGLE:
1935 case XFS_IOC_FSBULKSTAT:
1936 case XFS_IOC_FSINUMBERS:
1937 return xfs_ioc_bulkstat(mp, cmd, arg);
1939 case XFS_IOC_FSGEOMETRY_V1:
1940 return xfs_ioc_fsgeometry_v1(mp, arg);
1942 case XFS_IOC_FSGEOMETRY:
1943 return xfs_ioc_fsgeometry(mp, arg);
1945 case XFS_IOC_GETVERSION:
1946 return put_user(inode->i_generation, (int __user *)arg);
1948 case XFS_IOC_FSGETXATTR:
1949 return xfs_ioc_fsgetxattr(ip, 0, arg);
1950 case XFS_IOC_FSGETXATTRA:
1951 return xfs_ioc_fsgetxattr(ip, 1, arg);
1952 case XFS_IOC_FSSETXATTR:
1953 return xfs_ioc_fssetxattr(ip, filp, arg);
1954 case XFS_IOC_GETXFLAGS:
1955 return xfs_ioc_getxflags(ip, arg);
1956 case XFS_IOC_SETXFLAGS:
1957 return xfs_ioc_setxflags(ip, filp, arg);
1959 case XFS_IOC_FSSETDM: {
1960 struct fsdmidata dmi;
1962 if (copy_from_user(&dmi, arg, sizeof(dmi)))
1965 error = mnt_want_write_file(filp);
1969 error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
1971 mnt_drop_write_file(filp);
1975 case XFS_IOC_GETBMAP:
1976 case XFS_IOC_GETBMAPA:
1977 case XFS_IOC_GETBMAPX:
1978 return xfs_ioc_getbmap(filp, cmd, arg);
1980 case FS_IOC_GETFSMAP:
1981 return xfs_ioc_getfsmap(ip, arg);
1983 case XFS_IOC_SCRUB_METADATA:
1984 return xfs_ioc_scrub_metadata(ip, arg);
1986 case XFS_IOC_FD_TO_HANDLE:
1987 case XFS_IOC_PATH_TO_HANDLE:
1988 case XFS_IOC_PATH_TO_FSHANDLE: {
1989 xfs_fsop_handlereq_t hreq;
1991 if (copy_from_user(&hreq, arg, sizeof(hreq)))
1993 return xfs_find_handle(cmd, &hreq);
1995 case XFS_IOC_OPEN_BY_HANDLE: {
1996 xfs_fsop_handlereq_t hreq;
1998 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
2000 return xfs_open_by_handle(filp, &hreq);
2002 case XFS_IOC_FSSETDM_BY_HANDLE:
2003 return xfs_fssetdm_by_handle(filp, arg);
2005 case XFS_IOC_READLINK_BY_HANDLE: {
2006 xfs_fsop_handlereq_t hreq;
2008 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
2010 return xfs_readlink_by_handle(filp, &hreq);
2012 case XFS_IOC_ATTRLIST_BY_HANDLE:
2013 return xfs_attrlist_by_handle(filp, arg);
2015 case XFS_IOC_ATTRMULTI_BY_HANDLE:
2016 return xfs_attrmulti_by_handle(filp, arg);
2018 case XFS_IOC_SWAPEXT: {
2019 struct xfs_swapext sxp;
2021 if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
2023 error = mnt_want_write_file(filp);
2026 error = xfs_ioc_swapext(&sxp);
2027 mnt_drop_write_file(filp);
2031 case XFS_IOC_FSCOUNTS: {
2032 xfs_fsop_counts_t out;
2034 error = xfs_fs_counts(mp, &out);
2038 if (copy_to_user(arg, &out, sizeof(out)))
2043 case XFS_IOC_SET_RESBLKS: {
2044 xfs_fsop_resblks_t inout;
2047 if (!capable(CAP_SYS_ADMIN))
2050 if (mp->m_flags & XFS_MOUNT_RDONLY)
2053 if (copy_from_user(&inout, arg, sizeof(inout)))
2056 error = mnt_want_write_file(filp);
2060 /* input parameter is passed in resblks field of structure */
2062 error = xfs_reserve_blocks(mp, &in, &inout);
2063 mnt_drop_write_file(filp);
2067 if (copy_to_user(arg, &inout, sizeof(inout)))
2072 case XFS_IOC_GET_RESBLKS: {
2073 xfs_fsop_resblks_t out;
2075 if (!capable(CAP_SYS_ADMIN))
2078 error = xfs_reserve_blocks(mp, NULL, &out);
2082 if (copy_to_user(arg, &out, sizeof(out)))
2088 case XFS_IOC_FSGROWFSDATA: {
2089 xfs_growfs_data_t in;
2091 if (copy_from_user(&in, arg, sizeof(in)))
2094 error = mnt_want_write_file(filp);
2097 error = xfs_growfs_data(mp, &in);
2098 mnt_drop_write_file(filp);
2102 case XFS_IOC_FSGROWFSLOG: {
2103 xfs_growfs_log_t in;
2105 if (copy_from_user(&in, arg, sizeof(in)))
2108 error = mnt_want_write_file(filp);
2111 error = xfs_growfs_log(mp, &in);
2112 mnt_drop_write_file(filp);
2116 case XFS_IOC_FSGROWFSRT: {
2119 if (copy_from_user(&in, arg, sizeof(in)))
2122 error = mnt_want_write_file(filp);
2125 error = xfs_growfs_rt(mp, &in);
2126 mnt_drop_write_file(filp);
2130 case XFS_IOC_GOINGDOWN: {
2133 if (!capable(CAP_SYS_ADMIN))
2136 if (get_user(in, (uint32_t __user *)arg))
2139 return xfs_fs_goingdown(mp, in);
2142 case XFS_IOC_ERROR_INJECTION: {
2143 xfs_error_injection_t in;
2145 if (!capable(CAP_SYS_ADMIN))
2148 if (copy_from_user(&in, arg, sizeof(in)))
2151 return xfs_errortag_add(mp, in.errtag);
2154 case XFS_IOC_ERROR_CLEARALL:
2155 if (!capable(CAP_SYS_ADMIN))
2158 return xfs_errortag_clearall(mp);
2160 case XFS_IOC_FREE_EOFBLOCKS: {
2161 struct xfs_fs_eofblocks eofb;
2162 struct xfs_eofblocks keofb;
2164 if (!capable(CAP_SYS_ADMIN))
2167 if (mp->m_flags & XFS_MOUNT_RDONLY)
2170 if (copy_from_user(&eofb, arg, sizeof(eofb)))
2173 error = xfs_fs_eofblocks_from_user(&eofb, &keofb);
2177 return xfs_icache_free_eofblocks(mp, &keofb);