Merge branch 'xfs-setxattr-promotion' into for-next

+9 -2

fs/xfs/libxfs/xfs_format.h

··· 984 984 985 985 /* 986 986 * Values for di_flags 987 - * There should be a one-to-one correspondence between these flags and the 988 - * XFS_XFLAG_s. 989 987 */ 990 988 #define XFS_DIFLAG_REALTIME_BIT 0 /* file's blocks come from rt area */ 991 989 #define XFS_DIFLAG_PREALLOC_BIT 1 /* file space has been preallocated */ ··· 1022 1024 XFS_DIFLAG_NOATIME | XFS_DIFLAG_NODUMP | XFS_DIFLAG_RTINHERIT | \ 1023 1025 XFS_DIFLAG_PROJINHERIT | XFS_DIFLAG_NOSYMLINKS | XFS_DIFLAG_EXTSIZE | \ 1024 1026 XFS_DIFLAG_EXTSZINHERIT | XFS_DIFLAG_NODEFRAG | XFS_DIFLAG_FILESTREAM) 1027 + 1028 + /* 1029 + * Values for di_flags2 These start by being exposed to userspace in the upper 1030 + * 16 bits of the XFS_XFLAG_s range. 1031 + */ 1032 + #define XFS_DIFLAG2_DAX_BIT 0 /* use DAX for this inode */ 1033 + #define XFS_DIFLAG2_DAX (1 << XFS_DIFLAG2_DAX_BIT) 1034 + 1035 + #define XFS_DIFLAG2_ANY (XFS_DIFLAG2_DAX) 1025 1036 1026 1037 /* 1027 1038 * Inode number format:

+2 -36

fs/xfs/libxfs/xfs_fs.h

··· 36 36 #endif 37 37 38 38 /* 39 - * Structure for XFS_IOC_FSGETXATTR[A] and XFS_IOC_FSSETXATTR. 40 - */ 41 - #ifndef HAVE_FSXATTR 42 - struct fsxattr { 43 - __u32 fsx_xflags; /* xflags field value (get/set) */ 44 - __u32 fsx_extsize; /* extsize field value (get/set)*/ 45 - __u32 fsx_nextents; /* nextents field value (get) */ 46 - __u32 fsx_projid; /* project identifier (get/set) */ 47 - unsigned char fsx_pad[12]; 48 - }; 49 - #endif 50 - 51 - /* 52 - * Flags for the bs_xflags/fsx_xflags field 53 - * There should be a one-to-one correspondence between these flags and the 54 - * XFS_DIFLAG_s. 55 - */ 56 - #define XFS_XFLAG_REALTIME 0x00000001 /* data in realtime volume */ 57 - #define XFS_XFLAG_PREALLOC 0x00000002 /* preallocated file extents */ 58 - #define XFS_XFLAG_IMMUTABLE 0x00000008 /* file cannot be modified */ 59 - #define XFS_XFLAG_APPEND 0x00000010 /* all writes append */ 60 - #define XFS_XFLAG_SYNC 0x00000020 /* all writes synchronous */ 61 - #define XFS_XFLAG_NOATIME 0x00000040 /* do not update access time */ 62 - #define XFS_XFLAG_NODUMP 0x00000080 /* do not include in backups */ 63 - #define XFS_XFLAG_RTINHERIT 0x00000100 /* create with rt bit set */ 64 - #define XFS_XFLAG_PROJINHERIT 0x00000200 /* create with parents projid */ 65 - #define XFS_XFLAG_NOSYMLINKS 0x00000400 /* disallow symlink creation */ 66 - #define XFS_XFLAG_EXTSIZE 0x00000800 /* extent size allocator hint */ 67 - #define XFS_XFLAG_EXTSZINHERIT 0x00001000 /* inherit inode extent size */ 68 - #define XFS_XFLAG_NODEFRAG 0x00002000 /* do not defragment */ 69 - #define XFS_XFLAG_FILESTREAM 0x00004000 /* use filestream allocator */ 70 - #define XFS_XFLAG_HASATTR 0x80000000 /* no DIFLAG for this */ 71 - 72 - /* 73 39 * Structure for XFS_IOC_GETBMAP. 74 40 * On input, fill in bmv_offset and bmv_length of the first structure 75 41 * to indicate the area of interest in the file, and bmv_entries with ··· 480 514 #define XFS_IOC_ALLOCSP _IOW ('X', 10, struct xfs_flock64) 481 515 #define XFS_IOC_FREESP _IOW ('X', 11, struct xfs_flock64) 482 516 #define XFS_IOC_DIOINFO _IOR ('X', 30, struct dioattr) 483 - #define XFS_IOC_FSGETXATTR _IOR ('X', 31, struct fsxattr) 484 - #define XFS_IOC_FSSETXATTR _IOW ('X', 32, struct fsxattr) 517 + #define XFS_IOC_FSGETXATTR FS_IOC_FSGETXATTR 518 + #define XFS_IOC_FSSETXATTR FS_IOC_FSSETXATTR 485 519 #define XFS_IOC_ALLOCSP64 _IOW ('X', 36, struct xfs_flock64) 486 520 #define XFS_IOC_FREESP64 _IOW ('X', 37, struct xfs_flock64) 487 521 #define XFS_IOC_GETBMAP _IOWR('X', 38, struct getbmap)

+37 -23

fs/xfs/xfs_inode.c

··· 610 610 611 611 STATIC uint 612 612 _xfs_dic2xflags( 613 - __uint16_t di_flags) 613 + __uint16_t di_flags, 614 + uint64_t di_flags2, 615 + bool has_attr) 614 616 { 615 617 uint flags = 0; 616 618 617 619 if (di_flags & XFS_DIFLAG_ANY) { 618 620 if (di_flags & XFS_DIFLAG_REALTIME) 619 - flags |= XFS_XFLAG_REALTIME; 621 + flags |= FS_XFLAG_REALTIME; 620 622 if (di_flags & XFS_DIFLAG_PREALLOC) 621 - flags |= XFS_XFLAG_PREALLOC; 623 + flags |= FS_XFLAG_PREALLOC; 622 624 if (di_flags & XFS_DIFLAG_IMMUTABLE) 623 - flags |= XFS_XFLAG_IMMUTABLE; 625 + flags |= FS_XFLAG_IMMUTABLE; 624 626 if (di_flags & XFS_DIFLAG_APPEND) 625 - flags |= XFS_XFLAG_APPEND; 627 + flags |= FS_XFLAG_APPEND; 626 628 if (di_flags & XFS_DIFLAG_SYNC) 627 - flags |= XFS_XFLAG_SYNC; 629 + flags |= FS_XFLAG_SYNC; 628 630 if (di_flags & XFS_DIFLAG_NOATIME) 629 - flags |= XFS_XFLAG_NOATIME; 631 + flags |= FS_XFLAG_NOATIME; 630 632 if (di_flags & XFS_DIFLAG_NODUMP) 631 - flags |= XFS_XFLAG_NODUMP; 633 + flags |= FS_XFLAG_NODUMP; 632 634 if (di_flags & XFS_DIFLAG_RTINHERIT) 633 - flags |= XFS_XFLAG_RTINHERIT; 635 + flags |= FS_XFLAG_RTINHERIT; 634 636 if (di_flags & XFS_DIFLAG_PROJINHERIT) 635 - flags |= XFS_XFLAG_PROJINHERIT; 637 + flags |= FS_XFLAG_PROJINHERIT; 636 638 if (di_flags & XFS_DIFLAG_NOSYMLINKS) 637 - flags |= XFS_XFLAG_NOSYMLINKS; 639 + flags |= FS_XFLAG_NOSYMLINKS; 638 640 if (di_flags & XFS_DIFLAG_EXTSIZE) 639 - flags |= XFS_XFLAG_EXTSIZE; 641 + flags |= FS_XFLAG_EXTSIZE; 640 642 if (di_flags & XFS_DIFLAG_EXTSZINHERIT) 641 - flags |= XFS_XFLAG_EXTSZINHERIT; 643 + flags |= FS_XFLAG_EXTSZINHERIT; 642 644 if (di_flags & XFS_DIFLAG_NODEFRAG) 643 - flags |= XFS_XFLAG_NODEFRAG; 645 + flags |= FS_XFLAG_NODEFRAG; 644 646 if (di_flags & XFS_DIFLAG_FILESTREAM) 645 - flags |= XFS_XFLAG_FILESTREAM; 647 + flags |= FS_XFLAG_FILESTREAM; 646 648 } 649 + 650 + if (di_flags2 & XFS_DIFLAG2_ANY) { 651 + if (di_flags2 & XFS_DIFLAG2_DAX) 652 + flags |= FS_XFLAG_DAX; 653 + } 654 + 655 + if (has_attr) 656 + flags |= FS_XFLAG_HASATTR; 647 657 648 658 return flags; 649 659 } 650 660 651 661 uint 652 662 xfs_ip2xflags( 653 - xfs_inode_t *ip) 663 + struct xfs_inode *ip) 654 664 { 655 - xfs_icdinode_t *dic = &ip->i_d; 665 + struct xfs_icdinode *dic = &ip->i_d; 656 666 657 - return _xfs_dic2xflags(dic->di_flags) | 658 - (XFS_IFORK_Q(ip) ? XFS_XFLAG_HASATTR : 0); 667 + return _xfs_dic2xflags(dic->di_flags, dic->di_flags2, XFS_IFORK_Q(ip)); 659 668 } 660 669 661 670 uint 662 671 xfs_dic2xflags( 663 - xfs_dinode_t *dip) 672 + struct xfs_dinode *dip) 664 673 { 665 - return _xfs_dic2xflags(be16_to_cpu(dip->di_flags)) | 666 - (XFS_DFORK_Q(dip) ? XFS_XFLAG_HASATTR : 0); 674 + return _xfs_dic2xflags(be16_to_cpu(dip->di_flags), 675 + be64_to_cpu(dip->di_flags2), XFS_DFORK_Q(dip)); 667 676 } 668 677 669 678 /* ··· 871 862 case S_IFREG: 872 863 case S_IFDIR: 873 864 if (pip && (pip->i_d.di_flags & XFS_DIFLAG_ANY)) { 874 - uint di_flags = 0; 865 + uint64_t di_flags2 = 0; 866 + uint di_flags = 0; 875 867 876 868 if (S_ISDIR(mode)) { 877 869 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT) ··· 908 898 di_flags |= XFS_DIFLAG_NODEFRAG; 909 899 if (pip->i_d.di_flags & XFS_DIFLAG_FILESTREAM) 910 900 di_flags |= XFS_DIFLAG_FILESTREAM; 901 + if (pip->i_d.di_flags2 & XFS_DIFLAG2_DAX) 902 + di_flags2 |= XFS_DIFLAG2_DAX; 903 + 911 904 ip->i_d.di_flags |= di_flags; 905 + ip->i_d.di_flags2 |= di_flags2; 912 906 } 913 907 /* FALLTHROUGH */ 914 908 case S_IFLNK:

+54 -38

fs/xfs/xfs_ioctl.c

··· 859 859 unsigned int xflags = start; 860 860 861 861 if (flags & FS_IMMUTABLE_FL) 862 - xflags |= XFS_XFLAG_IMMUTABLE; 862 + xflags |= FS_XFLAG_IMMUTABLE; 863 863 else 864 - xflags &= ~XFS_XFLAG_IMMUTABLE; 864 + xflags &= ~FS_XFLAG_IMMUTABLE; 865 865 if (flags & FS_APPEND_FL) 866 - xflags |= XFS_XFLAG_APPEND; 866 + xflags |= FS_XFLAG_APPEND; 867 867 else 868 - xflags &= ~XFS_XFLAG_APPEND; 868 + xflags &= ~FS_XFLAG_APPEND; 869 869 if (flags & FS_SYNC_FL) 870 - xflags |= XFS_XFLAG_SYNC; 870 + xflags |= FS_XFLAG_SYNC; 871 871 else 872 - xflags &= ~XFS_XFLAG_SYNC; 872 + xflags &= ~FS_XFLAG_SYNC; 873 873 if (flags & FS_NOATIME_FL) 874 - xflags |= XFS_XFLAG_NOATIME; 874 + xflags |= FS_XFLAG_NOATIME; 875 875 else 876 - xflags &= ~XFS_XFLAG_NOATIME; 876 + xflags &= ~FS_XFLAG_NOATIME; 877 877 if (flags & FS_NODUMP_FL) 878 - xflags |= XFS_XFLAG_NODUMP; 878 + xflags |= FS_XFLAG_NODUMP; 879 879 else 880 - xflags &= ~XFS_XFLAG_NODUMP; 880 + xflags &= ~FS_XFLAG_NODUMP; 881 881 882 882 return xflags; 883 883 } ··· 945 945 unsigned int xflags) 946 946 { 947 947 unsigned int di_flags; 948 + uint64_t di_flags2; 948 949 949 950 /* can't set PREALLOC this way, just preserve it */ 950 951 di_flags = (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC); 951 - if (xflags & XFS_XFLAG_IMMUTABLE) 952 + if (xflags & FS_XFLAG_IMMUTABLE) 952 953 di_flags |= XFS_DIFLAG_IMMUTABLE; 953 - if (xflags & XFS_XFLAG_APPEND) 954 + if (xflags & FS_XFLAG_APPEND) 954 955 di_flags |= XFS_DIFLAG_APPEND; 955 - if (xflags & XFS_XFLAG_SYNC) 956 + if (xflags & FS_XFLAG_SYNC) 956 957 di_flags |= XFS_DIFLAG_SYNC; 957 - if (xflags & XFS_XFLAG_NOATIME) 958 + if (xflags & FS_XFLAG_NOATIME) 958 959 di_flags |= XFS_DIFLAG_NOATIME; 959 - if (xflags & XFS_XFLAG_NODUMP) 960 + if (xflags & FS_XFLAG_NODUMP) 960 961 di_flags |= XFS_DIFLAG_NODUMP; 961 - if (xflags & XFS_XFLAG_NODEFRAG) 962 + if (xflags & FS_XFLAG_NODEFRAG) 962 963 di_flags |= XFS_DIFLAG_NODEFRAG; 963 - if (xflags & XFS_XFLAG_FILESTREAM) 964 + if (xflags & FS_XFLAG_FILESTREAM) 964 965 di_flags |= XFS_DIFLAG_FILESTREAM; 965 966 if (S_ISDIR(ip->i_d.di_mode)) { 966 - if (xflags & XFS_XFLAG_RTINHERIT) 967 + if (xflags & FS_XFLAG_RTINHERIT) 967 968 di_flags |= XFS_DIFLAG_RTINHERIT; 968 - if (xflags & XFS_XFLAG_NOSYMLINKS) 969 + if (xflags & FS_XFLAG_NOSYMLINKS) 969 970 di_flags |= XFS_DIFLAG_NOSYMLINKS; 970 - if (xflags & XFS_XFLAG_EXTSZINHERIT) 971 + if (xflags & FS_XFLAG_EXTSZINHERIT) 971 972 di_flags |= XFS_DIFLAG_EXTSZINHERIT; 972 - if (xflags & XFS_XFLAG_PROJINHERIT) 973 + if (xflags & FS_XFLAG_PROJINHERIT) 973 974 di_flags |= XFS_DIFLAG_PROJINHERIT; 974 975 } else if (S_ISREG(ip->i_d.di_mode)) { 975 - if (xflags & XFS_XFLAG_REALTIME) 976 + if (xflags & FS_XFLAG_REALTIME) 976 977 di_flags |= XFS_DIFLAG_REALTIME; 977 - if (xflags & XFS_XFLAG_EXTSIZE) 978 + if (xflags & FS_XFLAG_EXTSIZE) 978 979 di_flags |= XFS_DIFLAG_EXTSIZE; 979 980 } 980 - 981 981 ip->i_d.di_flags = di_flags; 982 + 983 + /* diflags2 only valid for v3 inodes. */ 984 + if (ip->i_d.di_version < 3) 985 + return; 986 + 987 + di_flags2 = 0; 988 + if (xflags & FS_XFLAG_DAX) 989 + di_flags2 |= XFS_DIFLAG2_DAX; 990 + 991 + ip->i_d.di_flags2 = di_flags2; 992 + 982 993 } 983 994 984 995 STATIC void ··· 999 988 struct inode *inode = VFS_I(ip); 1000 989 unsigned int xflags = xfs_ip2xflags(ip); 1001 990 1002 - if (xflags & XFS_XFLAG_IMMUTABLE) 991 + if (xflags & FS_XFLAG_IMMUTABLE) 1003 992 inode->i_flags |= S_IMMUTABLE; 1004 993 else 1005 994 inode->i_flags &= ~S_IMMUTABLE; 1006 - if (xflags & XFS_XFLAG_APPEND) 995 + if (xflags & FS_XFLAG_APPEND) 1007 996 inode->i_flags |= S_APPEND; 1008 997 else 1009 998 inode->i_flags &= ~S_APPEND; 1010 - if (xflags & XFS_XFLAG_SYNC) 999 + if (xflags & FS_XFLAG_SYNC) 1011 1000 inode->i_flags |= S_SYNC; 1012 1001 else 1013 1002 inode->i_flags &= ~S_SYNC; 1014 - if (xflags & XFS_XFLAG_NOATIME) 1003 + if (xflags & FS_XFLAG_NOATIME) 1015 1004 inode->i_flags |= S_NOATIME; 1016 1005 else 1017 1006 inode->i_flags &= ~S_NOATIME; 1007 + if (xflags & FS_XFLAG_DAX) 1008 + inode->i_flags |= S_DAX; 1009 + else 1010 + inode->i_flags &= ~S_DAX; 1011 + 1018 1012 } 1019 1013 1020 1014 static int ··· 1032 1016 1033 1017 /* Can't change realtime flag if any extents are allocated. */ 1034 1018 if ((ip->i_d.di_nextents || ip->i_delayed_blks) && 1035 - XFS_IS_REALTIME_INODE(ip) != (fa->fsx_xflags & XFS_XFLAG_REALTIME)) 1019 + XFS_IS_REALTIME_INODE(ip) != (fa->fsx_xflags & FS_XFLAG_REALTIME)) 1036 1020 return -EINVAL; 1037 1021 1038 1022 /* If realtime flag is set then must have realtime device */ 1039 - if (fa->fsx_xflags & XFS_XFLAG_REALTIME) { 1023 + if (fa->fsx_xflags & FS_XFLAG_REALTIME) { 1040 1024 if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 || 1041 1025 (ip->i_d.di_extsize % mp->m_sb.sb_rextsize)) 1042 1026 return -EINVAL; ··· 1047 1031 * we have appropriate permission. 1048 1032 */ 1049 1033 if (((ip->i_d.di_flags & (XFS_DIFLAG_IMMUTABLE | XFS_DIFLAG_APPEND)) || 1050 - (fa->fsx_xflags & (XFS_XFLAG_IMMUTABLE | XFS_XFLAG_APPEND))) && 1034 + (fa->fsx_xflags & (FS_XFLAG_IMMUTABLE | FS_XFLAG_APPEND))) && 1051 1035 !capable(CAP_LINUX_IMMUTABLE)) 1052 1036 return -EPERM; 1053 1037 ··· 1111 1095 * extent size hint validation is somewhat cumbersome. Rules are: 1112 1096 * 1113 1097 * 1. extent size hint is only valid for directories and regular files 1114 - * 2. XFS_XFLAG_EXTSIZE is only valid for regular files 1115 - * 3. XFS_XFLAG_EXTSZINHERIT is only valid for directories. 1098 + * 2. FS_XFLAG_EXTSIZE is only valid for regular files 1099 + * 3. FS_XFLAG_EXTSZINHERIT is only valid for directories. 1116 1100 * 4. can only be changed on regular files if no extents are allocated 1117 1101 * 5. can be changed on directories at any time 1118 1102 * 6. extsize hint of 0 turns off hints, clears inode flags. ··· 1128 1112 { 1129 1113 struct xfs_mount *mp = ip->i_mount; 1130 1114 1131 - if ((fa->fsx_xflags & XFS_XFLAG_EXTSIZE) && !S_ISREG(ip->i_d.di_mode)) 1115 + if ((fa->fsx_xflags & FS_XFLAG_EXTSIZE) && !S_ISREG(ip->i_d.di_mode)) 1132 1116 return -EINVAL; 1133 1117 1134 - if ((fa->fsx_xflags & XFS_XFLAG_EXTSZINHERIT) && 1118 + if ((fa->fsx_xflags & FS_XFLAG_EXTSZINHERIT) && 1135 1119 !S_ISDIR(ip->i_d.di_mode)) 1136 1120 return -EINVAL; 1137 1121 ··· 1148 1132 return -EINVAL; 1149 1133 1150 1134 if (XFS_IS_REALTIME_INODE(ip) || 1151 - (fa->fsx_xflags & XFS_XFLAG_REALTIME)) { 1135 + (fa->fsx_xflags & FS_XFLAG_REALTIME)) { 1152 1136 size = mp->m_sb.sb_rextsize << mp->m_sb.sb_blocklog; 1153 1137 } else { 1154 1138 size = mp->m_sb.sb_blocksize; ··· 1159 1143 if (fa->fsx_extsize % size) 1160 1144 return -EINVAL; 1161 1145 } else 1162 - fa->fsx_xflags &= ~(XFS_XFLAG_EXTSIZE | XFS_XFLAG_EXTSZINHERIT); 1146 + fa->fsx_xflags &= ~(FS_XFLAG_EXTSIZE | FS_XFLAG_EXTSZINHERIT); 1163 1147 1164 1148 return 0; 1165 1149 } ··· 1184 1168 1185 1169 if (xfs_get_projid(ip) != fa->fsx_projid) 1186 1170 return -EINVAL; 1187 - if ((fa->fsx_xflags & XFS_XFLAG_PROJINHERIT) != 1171 + if ((fa->fsx_xflags & FS_XFLAG_PROJINHERIT) != 1188 1172 (ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)) 1189 1173 return -EINVAL; 1190 1174

+2 -2

fs/xfs/xfs_iops.c

··· 1201 1201 inode->i_flags |= S_SYNC; 1202 1202 if (flags & XFS_DIFLAG_NOATIME) 1203 1203 inode->i_flags |= S_NOATIME; 1204 - /* XXX: Also needs an on-disk per inode flag! */ 1205 - if (ip->i_mount->m_flags & XFS_MOUNT_DAX) 1204 + if (ip->i_mount->m_flags & XFS_MOUNT_DAX || 1205 + ip->i_d.di_flags2 & XFS_DIFLAG2_DAX) 1206 1206 inode->i_flags |= S_DAX; 1207 1207 } 1208 1208

+33

include/uapi/linux/fs.h

··· 110 110 #define MS_MGC_VAL 0xC0ED0000 111 111 #define MS_MGC_MSK 0xffff0000 112 112 113 + /* 114 + * Structure for FS_IOC_FSGETXATTR[A] and FS_IOC_FSSETXATTR. 115 + */ 116 + struct fsxattr { 117 + __u32 fsx_xflags; /* xflags field value (get/set) */ 118 + __u32 fsx_extsize; /* extsize field value (get/set)*/ 119 + __u32 fsx_nextents; /* nextents field value (get) */ 120 + __u32 fsx_projid; /* project identifier (get/set) */ 121 + unsigned char fsx_pad[12]; 122 + }; 123 + 124 + /* 125 + * Flags for the fsx_xflags field 126 + */ 127 + #define FS_XFLAG_REALTIME 0x00000001 /* data in realtime volume */ 128 + #define FS_XFLAG_PREALLOC 0x00000002 /* preallocated file extents */ 129 + #define FS_XFLAG_IMMUTABLE 0x00000008 /* file cannot be modified */ 130 + #define FS_XFLAG_APPEND 0x00000010 /* all writes append */ 131 + #define FS_XFLAG_SYNC 0x00000020 /* all writes synchronous */ 132 + #define FS_XFLAG_NOATIME 0x00000040 /* do not update access time */ 133 + #define FS_XFLAG_NODUMP 0x00000080 /* do not include in backups */ 134 + #define FS_XFLAG_RTINHERIT 0x00000100 /* create with rt bit set */ 135 + #define FS_XFLAG_PROJINHERIT 0x00000200 /* create with parents projid */ 136 + #define FS_XFLAG_NOSYMLINKS 0x00000400 /* disallow symlink creation */ 137 + #define FS_XFLAG_EXTSIZE 0x00000800 /* extent size allocator hint */ 138 + #define FS_XFLAG_EXTSZINHERIT 0x00001000 /* inherit inode extent size */ 139 + #define FS_XFLAG_NODEFRAG 0x00002000 /* do not defragment */ 140 + #define FS_XFLAG_FILESTREAM 0x00004000 /* use filestream allocator */ 141 + #define FS_XFLAG_DAX 0x00008000 /* use DAX for IO */ 142 + #define FS_XFLAG_HASATTR 0x80000000 /* no DIFLAG for this */ 143 + 113 144 /* the read-only stuff doesn't really belong here, but any other place is 114 145 probably as bad and I don't want to create yet another include file. */ 115 146 ··· 200 169 #define FS_IOC32_SETFLAGS _IOW('f', 2, int) 201 170 #define FS_IOC32_GETVERSION _IOR('v', 1, int) 202 171 #define FS_IOC32_SETVERSION _IOW('v', 2, int) 172 + #define FS_IOC_FSGETXATTR _IOR ('X', 31, struct fsxattr) 173 + #define FS_IOC_FSSETXATTR _IOW ('X', 32, struct fsxattr) 203 174 204 175 /* 205 176 * Inode flags (FS_IOC_GETFLAGS / FS_IOC_SETFLAGS)