Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Nathan Scott | 7b71876 | 2005-11-02 14:58:39 +1100 | [diff] [blame] | 2 | * Copyright (c) 1995-2005 Silicon Graphics, Inc. |
| 3 | * All Rights Reserved. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | * |
Nathan Scott | 7b71876 | 2005-11-02 14:58:39 +1100 | [diff] [blame] | 5 | * This program is free software; you can redistribute it and/or |
Nathan Scott | 3ddb8fa | 2006-01-11 15:33:02 +1100 | [diff] [blame] | 6 | * modify it under the terms of the GNU Lesser General Public License |
| 7 | * as published by the Free Software Foundation. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 8 | * |
Nathan Scott | 7b71876 | 2005-11-02 14:58:39 +1100 | [diff] [blame] | 9 | * This program is distributed in the hope that it would be useful, |
| 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
Nathan Scott | 3ddb8fa | 2006-01-11 15:33:02 +1100 | [diff] [blame] | 12 | * GNU Lesser General Public License for more details. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | * |
Nathan Scott | 3ddb8fa | 2006-01-11 15:33:02 +1100 | [diff] [blame] | 14 | * You should have received a copy of the GNU Lesser General Public License |
Nathan Scott | 7b71876 | 2005-11-02 14:58:39 +1100 | [diff] [blame] | 15 | * along with this program; if not, write the Free Software Foundation, |
| 16 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | */ |
| 18 | #ifndef __XFS_FS_H__ |
| 19 | #define __XFS_FS_H__ |
| 20 | |
| 21 | /* |
| 22 | * SGI's XFS filesystem's major stuff (constants, structures) |
| 23 | */ |
| 24 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 25 | /* |
| 26 | * Direct I/O attribute record used with XFS_IOC_DIOINFO |
| 27 | * d_miniosz is the min xfer size, xfer size multiple and file seek offset |
| 28 | * alignment. |
| 29 | */ |
| 30 | #ifndef HAVE_DIOATTR |
| 31 | struct dioattr { |
| 32 | __u32 d_mem; /* data buffer memory alignment */ |
| 33 | __u32 d_miniosz; /* min xfer size */ |
| 34 | __u32 d_maxiosz; /* max xfer size */ |
| 35 | }; |
| 36 | #endif |
| 37 | |
| 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) */ |
Nathan Scott | 77bc5be | 2005-06-21 15:48:04 +1000 | [diff] [blame] | 46 | __u32 fsx_projid; /* project identifier (get/set) */ |
| 47 | unsigned char fsx_pad[12]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 */ |
Nathan Scott | dd9f438 | 2006-01-11 15:28:28 +1100 | [diff] [blame] | 66 | #define XFS_XFLAG_EXTSIZE 0x00000800 /* extent size allocator hint */ |
| 67 | #define XFS_XFLAG_EXTSZINHERIT 0x00001000 /* inherit inode extent size */ |
Barry Naujok | d3446ea | 2006-06-09 14:54:19 +1000 | [diff] [blame] | 68 | #define XFS_XFLAG_NODEFRAG 0x00002000 /* do not defragment */ |
David Chinner | 2a82b8b | 2007-07-11 11:09:12 +1000 | [diff] [blame] | 69 | #define XFS_XFLAG_FILESTREAM 0x00004000 /* use filestream allocator */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 70 | #define XFS_XFLAG_HASATTR 0x80000000 /* no DIFLAG for this */ |
| 71 | |
| 72 | /* |
| 73 | * Structure for XFS_IOC_GETBMAP. |
| 74 | * On input, fill in bmv_offset and bmv_length of the first structure |
Nathan Scott | ba0b92d | 2006-06-09 14:52:00 +1000 | [diff] [blame] | 75 | * to indicate the area of interest in the file, and bmv_entries with |
| 76 | * the number of array elements given back. The first structure is |
| 77 | * updated on return to give the offset and length for the next call. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | */ |
| 79 | #ifndef HAVE_GETBMAP |
| 80 | struct getbmap { |
| 81 | __s64 bmv_offset; /* file offset of segment in blocks */ |
| 82 | __s64 bmv_block; /* starting block (64-bit daddr_t) */ |
| 83 | __s64 bmv_length; /* length of segment, blocks */ |
| 84 | __s32 bmv_count; /* # of entries in array incl. 1st */ |
| 85 | __s32 bmv_entries; /* # of entries filled in (output) */ |
| 86 | }; |
| 87 | #endif |
| 88 | |
| 89 | /* |
| 90 | * Structure for XFS_IOC_GETBMAPX. Fields bmv_offset through bmv_entries |
| 91 | * are used exactly as in the getbmap structure. The getbmapx structure |
| 92 | * has additional bmv_iflags and bmv_oflags fields. The bmv_iflags field |
| 93 | * is only used for the first structure. It contains input flags |
| 94 | * specifying XFS_IOC_GETBMAPX actions. The bmv_oflags field is filled |
| 95 | * in by the XFS_IOC_GETBMAPX command for each returned structure after |
| 96 | * the first. |
| 97 | */ |
| 98 | #ifndef HAVE_GETBMAPX |
| 99 | struct getbmapx { |
| 100 | __s64 bmv_offset; /* file offset of segment in blocks */ |
| 101 | __s64 bmv_block; /* starting block (64-bit daddr_t) */ |
| 102 | __s64 bmv_length; /* length of segment, blocks */ |
| 103 | __s32 bmv_count; /* # of entries in array incl. 1st */ |
| 104 | __s32 bmv_entries; /* # of entries filled in (output). */ |
| 105 | __s32 bmv_iflags; /* input flags (1st structure) */ |
| 106 | __s32 bmv_oflags; /* output flags (after 1st structure)*/ |
| 107 | __s32 bmv_unused1; /* future use */ |
| 108 | __s32 bmv_unused2; /* future use */ |
| 109 | }; |
| 110 | #endif |
| 111 | |
| 112 | /* bmv_iflags values - set by XFS_IOC_GETBMAPX caller. */ |
| 113 | #define BMV_IF_ATTRFORK 0x1 /* return attr fork rather than data */ |
| 114 | #define BMV_IF_NO_DMAPI_READ 0x2 /* Do not generate DMAPI read event */ |
| 115 | #define BMV_IF_PREALLOC 0x4 /* rtn status BMV_OF_PREALLOC if req */ |
Eric Sandeen | 5af317c | 2008-11-28 14:23:35 +1100 | [diff] [blame] | 116 | #define BMV_IF_DELALLOC 0x8 /* rtn status BMV_OF_DELALLOC if req */ |
Tao Ma | 9af2546 | 2010-08-30 02:44:03 +0000 | [diff] [blame] | 117 | #define BMV_IF_NO_HOLES 0x10 /* Do not return holes */ |
Eric Sandeen | 5af317c | 2008-11-28 14:23:35 +1100 | [diff] [blame] | 118 | #define BMV_IF_VALID \ |
Tao Ma | 9af2546 | 2010-08-30 02:44:03 +0000 | [diff] [blame] | 119 | (BMV_IF_ATTRFORK|BMV_IF_NO_DMAPI_READ|BMV_IF_PREALLOC| \ |
| 120 | BMV_IF_DELALLOC|BMV_IF_NO_HOLES) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | |
Anand Gadiyar | 411c940 | 2009-07-07 15:24:23 +0530 | [diff] [blame] | 122 | /* bmv_oflags values - returned for each non-header segment */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 123 | #define BMV_OF_PREALLOC 0x1 /* segment = unwritten pre-allocation */ |
Eric Sandeen | 5af317c | 2008-11-28 14:23:35 +1100 | [diff] [blame] | 124 | #define BMV_OF_DELALLOC 0x2 /* segment = delayed allocation */ |
| 125 | #define BMV_OF_LAST 0x4 /* segment is the last in the file */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 127 | /* |
| 128 | * Structure for XFS_IOC_FSSETDM. |
| 129 | * For use by backup and restore programs to set the XFS on-disk inode |
| 130 | * fields di_dmevmask and di_dmstate. These must be set to exactly and |
| 131 | * only values previously obtained via xfs_bulkstat! (Specifically the |
| 132 | * xfs_bstat_t fields bs_dmevmask and bs_dmstate.) |
| 133 | */ |
| 134 | #ifndef HAVE_FSDMIDATA |
| 135 | struct fsdmidata { |
| 136 | __u32 fsd_dmevmask; /* corresponds to di_dmevmask */ |
| 137 | __u16 fsd_padding; |
| 138 | __u16 fsd_dmstate; /* corresponds to di_dmstate */ |
| 139 | }; |
| 140 | #endif |
| 141 | |
| 142 | /* |
| 143 | * File segment locking set data type for 64 bit access. |
| 144 | * Also used for all the RESV/FREE interfaces. |
| 145 | */ |
| 146 | typedef struct xfs_flock64 { |
| 147 | __s16 l_type; |
| 148 | __s16 l_whence; |
| 149 | __s64 l_start; |
| 150 | __s64 l_len; /* len == 0 means until end of file */ |
| 151 | __s32 l_sysid; |
| 152 | __u32 l_pid; |
| 153 | __s32 l_pad[4]; /* reserve area */ |
| 154 | } xfs_flock64_t; |
| 155 | |
| 156 | /* |
| 157 | * Output for XFS_IOC_FSGEOMETRY_V1 |
| 158 | */ |
| 159 | typedef struct xfs_fsop_geom_v1 { |
| 160 | __u32 blocksize; /* filesystem (data) block size */ |
| 161 | __u32 rtextsize; /* realtime extent size */ |
| 162 | __u32 agblocks; /* fsblocks in an AG */ |
| 163 | __u32 agcount; /* number of allocation groups */ |
| 164 | __u32 logblocks; /* fsblocks in the log */ |
| 165 | __u32 sectsize; /* (data) sector size, bytes */ |
| 166 | __u32 inodesize; /* inode size in bytes */ |
| 167 | __u32 imaxpct; /* max allowed inode space(%) */ |
| 168 | __u64 datablocks; /* fsblocks in data subvolume */ |
| 169 | __u64 rtblocks; /* fsblocks in realtime subvol */ |
| 170 | __u64 rtextents; /* rt extents in realtime subvol*/ |
| 171 | __u64 logstart; /* starting fsblock of the log */ |
| 172 | unsigned char uuid[16]; /* unique id of the filesystem */ |
| 173 | __u32 sunit; /* stripe unit, fsblocks */ |
| 174 | __u32 swidth; /* stripe width, fsblocks */ |
| 175 | __s32 version; /* structure version */ |
| 176 | __u32 flags; /* superblock version flags */ |
| 177 | __u32 logsectsize; /* log sector size, bytes */ |
| 178 | __u32 rtsectsize; /* realtime sector size, bytes */ |
| 179 | __u32 dirblocksize; /* directory block size, bytes */ |
| 180 | } xfs_fsop_geom_v1_t; |
| 181 | |
| 182 | /* |
| 183 | * Output for XFS_IOC_FSGEOMETRY |
| 184 | */ |
| 185 | typedef struct xfs_fsop_geom { |
| 186 | __u32 blocksize; /* filesystem (data) block size */ |
| 187 | __u32 rtextsize; /* realtime extent size */ |
| 188 | __u32 agblocks; /* fsblocks in an AG */ |
| 189 | __u32 agcount; /* number of allocation groups */ |
| 190 | __u32 logblocks; /* fsblocks in the log */ |
| 191 | __u32 sectsize; /* (data) sector size, bytes */ |
| 192 | __u32 inodesize; /* inode size in bytes */ |
| 193 | __u32 imaxpct; /* max allowed inode space(%) */ |
| 194 | __u64 datablocks; /* fsblocks in data subvolume */ |
| 195 | __u64 rtblocks; /* fsblocks in realtime subvol */ |
| 196 | __u64 rtextents; /* rt extents in realtime subvol*/ |
| 197 | __u64 logstart; /* starting fsblock of the log */ |
| 198 | unsigned char uuid[16]; /* unique id of the filesystem */ |
| 199 | __u32 sunit; /* stripe unit, fsblocks */ |
| 200 | __u32 swidth; /* stripe width, fsblocks */ |
| 201 | __s32 version; /* structure version */ |
| 202 | __u32 flags; /* superblock version flags */ |
| 203 | __u32 logsectsize; /* log sector size, bytes */ |
| 204 | __u32 rtsectsize; /* realtime sector size, bytes */ |
| 205 | __u32 dirblocksize; /* directory block size, bytes */ |
| 206 | __u32 logsunit; /* log stripe unit, bytes */ |
| 207 | } xfs_fsop_geom_t; |
| 208 | |
| 209 | /* Output for XFS_FS_COUNTS */ |
| 210 | typedef struct xfs_fsop_counts { |
| 211 | __u64 freedata; /* free data section blocks */ |
| 212 | __u64 freertx; /* free rt extents */ |
| 213 | __u64 freeino; /* free inodes */ |
| 214 | __u64 allocino; /* total allocated inodes */ |
| 215 | } xfs_fsop_counts_t; |
| 216 | |
| 217 | /* Input/Output for XFS_GET_RESBLKS and XFS_SET_RESBLKS */ |
| 218 | typedef struct xfs_fsop_resblks { |
| 219 | __u64 resblks; |
| 220 | __u64 resblks_avail; |
| 221 | } xfs_fsop_resblks_t; |
| 222 | |
| 223 | #define XFS_FSOP_GEOM_VERSION 0 |
| 224 | |
| 225 | #define XFS_FSOP_GEOM_FLAGS_ATTR 0x0001 /* attributes in use */ |
| 226 | #define XFS_FSOP_GEOM_FLAGS_NLINK 0x0002 /* 32-bit nlink values */ |
| 227 | #define XFS_FSOP_GEOM_FLAGS_QUOTA 0x0004 /* quotas enabled */ |
| 228 | #define XFS_FSOP_GEOM_FLAGS_IALIGN 0x0008 /* inode alignment */ |
| 229 | #define XFS_FSOP_GEOM_FLAGS_DALIGN 0x0010 /* large data alignment */ |
| 230 | #define XFS_FSOP_GEOM_FLAGS_SHARED 0x0020 /* read-only shared */ |
| 231 | #define XFS_FSOP_GEOM_FLAGS_EXTFLG 0x0040 /* special extent flag */ |
| 232 | #define XFS_FSOP_GEOM_FLAGS_DIRV2 0x0080 /* directory version 2 */ |
| 233 | #define XFS_FSOP_GEOM_FLAGS_LOGV2 0x0100 /* log format version 2 */ |
| 234 | #define XFS_FSOP_GEOM_FLAGS_SECTOR 0x0200 /* sector sizes >1BB */ |
Nathan Scott | d8cc890 | 2005-11-02 10:34:53 +1100 | [diff] [blame] | 235 | #define XFS_FSOP_GEOM_FLAGS_ATTR2 0x0400 /* inline attributes rework */ |
Mark Tinguely | 2900a57 | 2013-10-02 16:00:06 -0500 | [diff] [blame] | 236 | #define XFS_FSOP_GEOM_FLAGS_PROJID32 0x0800 /* 32-bit project IDs */ |
Eric Sandeen | 69a58a4 | 2012-10-09 14:11:45 -0500 | [diff] [blame] | 237 | #define XFS_FSOP_GEOM_FLAGS_DIRV2CI 0x1000 /* ASCII only CI names */ |
David Chinner | 92821e2 | 2007-05-24 15:26:31 +1000 | [diff] [blame] | 238 | #define XFS_FSOP_GEOM_FLAGS_LAZYSB 0x4000 /* lazy superblock counters */ |
Dave Chinner | e7927e8 | 2013-05-27 16:38:26 +1000 | [diff] [blame] | 239 | #define XFS_FSOP_GEOM_FLAGS_V5SB 0x8000 /* version 5 superblock */ |
Mark Tinguely | 2900a57 | 2013-10-02 16:00:06 -0500 | [diff] [blame] | 240 | #define XFS_FSOP_GEOM_FLAGS_FTYPE 0x10000 /* inode directory types */ |
Brian Foster | 0c153c1 | 2014-04-24 16:01:41 +1000 | [diff] [blame] | 241 | #define XFS_FSOP_GEOM_FLAGS_FINOBT 0x20000 /* free inode btree */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 242 | |
| 243 | /* |
Jie Liu | 3e7b91c | 2013-08-12 20:50:03 +1000 | [diff] [blame] | 244 | * Minimum and maximum sizes need for growth checks. |
| 245 | * |
| 246 | * Block counts are in units of filesystem blocks, not basic blocks. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | */ |
| 248 | #define XFS_MIN_AG_BLOCKS 64 |
Christoph Hellwig | e169683 | 2009-06-08 15:32:59 +0200 | [diff] [blame] | 249 | #define XFS_MIN_LOG_BLOCKS 512ULL |
| 250 | #define XFS_MAX_LOG_BLOCKS (1024 * 1024ULL) |
| 251 | #define XFS_MIN_LOG_BYTES (10 * 1024 * 1024ULL) |
| 252 | |
| 253 | /* keep the maximum size under 2^31 by a small amount */ |
| 254 | #define XFS_MAX_LOG_BYTES \ |
| 255 | ((2 * 1024 * 1024 * 1024ULL) - XFS_MIN_LOG_BYTES) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | |
Eric Sandeen | c0e090c | 2011-05-20 21:52:17 +0000 | [diff] [blame] | 257 | /* Used for sanity checks on superblock */ |
| 258 | #define XFS_MAX_DBLOCKS(s) ((xfs_drfsbno_t)(s)->sb_agcount * (s)->sb_agblocks) |
| 259 | #define XFS_MIN_DBLOCKS(s) ((xfs_drfsbno_t)((s)->sb_agcount - 1) * \ |
| 260 | (s)->sb_agblocks + XFS_MIN_AG_BLOCKS) |
| 261 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 262 | /* |
| 263 | * Structures for XFS_IOC_FSGROWFSDATA, XFS_IOC_FSGROWFSLOG & XFS_IOC_FSGROWFSRT |
| 264 | */ |
| 265 | typedef struct xfs_growfs_data { |
| 266 | __u64 newblocks; /* new data subvol size, fsblocks */ |
| 267 | __u32 imaxpct; /* new inode space percentage limit */ |
| 268 | } xfs_growfs_data_t; |
| 269 | |
| 270 | typedef struct xfs_growfs_log { |
| 271 | __u32 newblocks; /* new log size, fsblocks */ |
| 272 | __u32 isint; /* 1 if new log is internal */ |
| 273 | } xfs_growfs_log_t; |
| 274 | |
| 275 | typedef struct xfs_growfs_rt { |
| 276 | __u64 newblocks; /* new realtime size, fsblocks */ |
| 277 | __u32 extsize; /* new realtime extent size, fsblocks */ |
| 278 | } xfs_growfs_rt_t; |
| 279 | |
| 280 | |
| 281 | /* |
| 282 | * Structures returned from ioctl XFS_IOC_FSBULKSTAT & XFS_IOC_FSBULKSTAT_SINGLE |
| 283 | */ |
| 284 | typedef struct xfs_bstime { |
| 285 | time_t tv_sec; /* seconds */ |
| 286 | __s32 tv_nsec; /* and nanoseconds */ |
| 287 | } xfs_bstime_t; |
| 288 | |
| 289 | typedef struct xfs_bstat { |
| 290 | __u64 bs_ino; /* inode number */ |
| 291 | __u16 bs_mode; /* type and mode */ |
| 292 | __u16 bs_nlink; /* number of links */ |
| 293 | __u32 bs_uid; /* user id */ |
| 294 | __u32 bs_gid; /* group id */ |
| 295 | __u32 bs_rdev; /* device value */ |
| 296 | __s32 bs_blksize; /* block size */ |
| 297 | __s64 bs_size; /* file size */ |
| 298 | xfs_bstime_t bs_atime; /* access time */ |
| 299 | xfs_bstime_t bs_mtime; /* modify time */ |
| 300 | xfs_bstime_t bs_ctime; /* inode change time */ |
| 301 | int64_t bs_blocks; /* number of blocks */ |
| 302 | __u32 bs_xflags; /* extended flags */ |
| 303 | __s32 bs_extsize; /* extent size */ |
| 304 | __s32 bs_extents; /* number of extents */ |
| 305 | __u32 bs_gen; /* generation count */ |
Arkadiusz Mi?kiewicz | 6743099 | 2010-09-26 06:10:18 +0000 | [diff] [blame] | 306 | __u16 bs_projid_lo; /* lower part of project id */ |
| 307 | #define bs_projid bs_projid_lo /* (previously just bs_projid) */ |
Dave Chinner | 07000ee | 2010-03-05 04:41:14 +0000 | [diff] [blame] | 308 | __u16 bs_forkoff; /* inode fork offset in bytes */ |
Arkadiusz Mi?kiewicz | 6743099 | 2010-09-26 06:10:18 +0000 | [diff] [blame] | 309 | __u16 bs_projid_hi; /* higher part of project id */ |
| 310 | unsigned char bs_pad[10]; /* pad space, unused */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 311 | __u32 bs_dmevmask; /* DMIG event mask */ |
| 312 | __u16 bs_dmstate; /* DMIG state info */ |
| 313 | __u16 bs_aextents; /* attribute number of extents */ |
| 314 | } xfs_bstat_t; |
| 315 | |
| 316 | /* |
Dave Chinner | d386b32 | 2013-08-12 20:49:31 +1000 | [diff] [blame] | 317 | * Project quota id helpers (previously projid was 16bit only |
| 318 | * and using two 16bit values to hold new 32bit projid was choosen |
| 319 | * to retain compatibility with "old" filesystems). |
| 320 | */ |
| 321 | static inline __uint32_t |
| 322 | bstat_get_projid(struct xfs_bstat *bs) |
| 323 | { |
| 324 | return (__uint32_t)bs->bs_projid_hi << 16 | bs->bs_projid_lo; |
| 325 | } |
| 326 | |
| 327 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 328 | * The user-level BulkStat Request interface structure. |
| 329 | */ |
| 330 | typedef struct xfs_fsop_bulkreq { |
| 331 | __u64 __user *lastip; /* last inode # pointer */ |
| 332 | __s32 icount; /* count of entries in buffer */ |
| 333 | void __user *ubuffer;/* user buffer for inode desc. */ |
| 334 | __s32 __user *ocount; /* output count pointer */ |
| 335 | } xfs_fsop_bulkreq_t; |
| 336 | |
| 337 | |
| 338 | /* |
| 339 | * Structures returned from xfs_inumbers routine (XFS_IOC_FSINUMBERS). |
| 340 | */ |
| 341 | typedef struct xfs_inogrp { |
| 342 | __u64 xi_startino; /* starting inode number */ |
| 343 | __s32 xi_alloccount; /* # bits set in allocmask */ |
| 344 | __u64 xi_allocmask; /* mask of allocated inodes */ |
| 345 | } xfs_inogrp_t; |
| 346 | |
| 347 | |
| 348 | /* |
| 349 | * Error injection. |
| 350 | */ |
| 351 | typedef struct xfs_error_injection { |
| 352 | __s32 fd; |
| 353 | __s32 errtag; |
| 354 | } xfs_error_injection_t; |
| 355 | |
| 356 | |
| 357 | /* |
Brian Foster | 8ca149d | 2012-11-07 12:21:12 -0500 | [diff] [blame] | 358 | * Speculative preallocation trimming. |
| 359 | */ |
| 360 | #define XFS_EOFBLOCKS_VERSION 1 |
Dwight Engen | b9fe505 | 2013-08-15 14:08:02 -0400 | [diff] [blame] | 361 | struct xfs_fs_eofblocks { |
Brian Foster | 8ca149d | 2012-11-07 12:21:12 -0500 | [diff] [blame] | 362 | __u32 eof_version; |
| 363 | __u32 eof_flags; |
Brian Foster | 3e3f9f5 | 2012-11-07 12:21:13 -0500 | [diff] [blame] | 364 | uid_t eof_uid; |
| 365 | gid_t eof_gid; |
| 366 | prid_t eof_prid; |
| 367 | __u32 pad32; |
Brian Foster | 00ca79a | 2012-11-07 12:21:14 -0500 | [diff] [blame] | 368 | __u64 eof_min_file_size; |
| 369 | __u64 pad64[12]; |
Brian Foster | 8ca149d | 2012-11-07 12:21:12 -0500 | [diff] [blame] | 370 | }; |
| 371 | |
| 372 | /* eof_flags values */ |
| 373 | #define XFS_EOF_FLAGS_SYNC (1 << 0) /* sync/wait mode scan */ |
Brian Foster | 3e3f9f5 | 2012-11-07 12:21:13 -0500 | [diff] [blame] | 374 | #define XFS_EOF_FLAGS_UID (1 << 1) /* filter by uid */ |
| 375 | #define XFS_EOF_FLAGS_GID (1 << 2) /* filter by gid */ |
| 376 | #define XFS_EOF_FLAGS_PRID (1 << 3) /* filter by project id */ |
Brian Foster | 00ca79a | 2012-11-07 12:21:14 -0500 | [diff] [blame] | 377 | #define XFS_EOF_FLAGS_MINFILESIZE (1 << 4) /* filter by min file size */ |
Brian Foster | f452639 | 2014-07-24 19:44:28 +1000 | [diff] [blame^] | 378 | #define XFS_EOF_FLAGS_UNION (1 << 5) /* union filter algorithm; |
| 379 | * kernel only, not included in |
| 380 | * valid mask */ |
Brian Foster | 8ca149d | 2012-11-07 12:21:12 -0500 | [diff] [blame] | 381 | #define XFS_EOF_FLAGS_VALID \ |
Brian Foster | 3e3f9f5 | 2012-11-07 12:21:13 -0500 | [diff] [blame] | 382 | (XFS_EOF_FLAGS_SYNC | \ |
| 383 | XFS_EOF_FLAGS_UID | \ |
| 384 | XFS_EOF_FLAGS_GID | \ |
Brian Foster | 00ca79a | 2012-11-07 12:21:14 -0500 | [diff] [blame] | 385 | XFS_EOF_FLAGS_PRID | \ |
| 386 | XFS_EOF_FLAGS_MINFILESIZE) |
Brian Foster | 8ca149d | 2012-11-07 12:21:12 -0500 | [diff] [blame] | 387 | |
| 388 | |
| 389 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 390 | * The user-level Handle Request interface structure. |
| 391 | */ |
| 392 | typedef struct xfs_fsop_handlereq { |
| 393 | __u32 fd; /* fd for FD_TO_HANDLE */ |
| 394 | void __user *path; /* user pathname */ |
| 395 | __u32 oflags; /* open flags */ |
| 396 | void __user *ihandle;/* user supplied handle */ |
| 397 | __u32 ihandlen; /* user supplied length */ |
| 398 | void __user *ohandle;/* user buffer for handle */ |
| 399 | __u32 __user *ohandlen;/* user buffer length */ |
| 400 | } xfs_fsop_handlereq_t; |
| 401 | |
| 402 | /* |
| 403 | * Compound structures for passing args through Handle Request interfaces |
| 404 | * xfs_fssetdm_by_handle, xfs_attrlist_by_handle, xfs_attrmulti_by_handle |
| 405 | * - ioctls: XFS_IOC_FSSETDM_BY_HANDLE, XFS_IOC_ATTRLIST_BY_HANDLE, and |
| 406 | * XFS_IOC_ATTRMULTI_BY_HANDLE |
| 407 | */ |
| 408 | |
| 409 | typedef struct xfs_fsop_setdm_handlereq { |
| 410 | struct xfs_fsop_handlereq hreq; /* handle information */ |
| 411 | struct fsdmidata __user *data; /* DMAPI data */ |
| 412 | } xfs_fsop_setdm_handlereq_t; |
| 413 | |
| 414 | typedef struct xfs_attrlist_cursor { |
| 415 | __u32 opaque[4]; |
| 416 | } xfs_attrlist_cursor_t; |
| 417 | |
| 418 | typedef struct xfs_fsop_attrlist_handlereq { |
| 419 | struct xfs_fsop_handlereq hreq; /* handle interface structure */ |
| 420 | struct xfs_attrlist_cursor pos; /* opaque cookie, list offset */ |
| 421 | __u32 flags; /* which namespace to use */ |
| 422 | __u32 buflen; /* length of buffer supplied */ |
| 423 | void __user *buffer; /* returned names */ |
| 424 | } xfs_fsop_attrlist_handlereq_t; |
| 425 | |
| 426 | typedef struct xfs_attr_multiop { |
| 427 | __u32 am_opcode; |
Christoph Hellwig | e182f57 | 2008-06-27 13:32:31 +1000 | [diff] [blame] | 428 | #define ATTR_OP_GET 1 /* return the indicated attr's value */ |
| 429 | #define ATTR_OP_SET 2 /* set/create the indicated attr/value pair */ |
| 430 | #define ATTR_OP_REMOVE 3 /* remove the indicated attr */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 431 | __s32 am_error; |
| 432 | void __user *am_attrname; |
| 433 | void __user *am_attrvalue; |
| 434 | __u32 am_length; |
| 435 | __u32 am_flags; |
| 436 | } xfs_attr_multiop_t; |
| 437 | |
| 438 | typedef struct xfs_fsop_attrmulti_handlereq { |
| 439 | struct xfs_fsop_handlereq hreq; /* handle interface structure */ |
| 440 | __u32 opcount;/* count of following multiop */ |
| 441 | struct xfs_attr_multiop __user *ops; /* attr_multi data */ |
| 442 | } xfs_fsop_attrmulti_handlereq_t; |
| 443 | |
| 444 | /* |
| 445 | * per machine unique filesystem identifier types. |
| 446 | */ |
| 447 | typedef struct { __u32 val[2]; } xfs_fsid_t; /* file system id type */ |
| 448 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 449 | typedef struct xfs_fid { |
Christoph Hellwig | c614391 | 2007-09-14 15:22:37 +1000 | [diff] [blame] | 450 | __u16 fid_len; /* length of remainder */ |
| 451 | __u16 fid_pad; |
| 452 | __u32 fid_gen; /* generation number */ |
| 453 | __u64 fid_ino; /* 64 bits inode number */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 454 | } xfs_fid_t; |
| 455 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 456 | typedef struct xfs_handle { |
| 457 | union { |
| 458 | __s64 align; /* force alignment of ha_fid */ |
| 459 | xfs_fsid_t _ha_fsid; /* unique file system identifier */ |
| 460 | } ha_u; |
| 461 | xfs_fid_t ha_fid; /* file system specific file ID */ |
| 462 | } xfs_handle_t; |
| 463 | #define ha_fsid ha_u._ha_fsid |
| 464 | |
Christoph Hellwig | c614391 | 2007-09-14 15:22:37 +1000 | [diff] [blame] | 465 | #define XFS_HSIZE(handle) (((char *) &(handle).ha_fid.fid_pad \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 466 | - (char *) &(handle)) \ |
Christoph Hellwig | c614391 | 2007-09-14 15:22:37 +1000 | [diff] [blame] | 467 | + (handle).ha_fid.fid_len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 468 | |
Eric Sandeen | 3f89243 | 2006-09-28 11:02:57 +1000 | [diff] [blame] | 469 | /* |
Dave Chinner | a133d95 | 2013-08-12 20:49:48 +1000 | [diff] [blame] | 470 | * Structure passed to XFS_IOC_SWAPEXT |
| 471 | */ |
| 472 | typedef struct xfs_swapext |
| 473 | { |
| 474 | __int64_t sx_version; /* version */ |
| 475 | #define XFS_SX_VERSION 0 |
| 476 | __int64_t sx_fdtarget; /* fd of target file */ |
| 477 | __int64_t sx_fdtmp; /* fd of tmp file */ |
| 478 | xfs_off_t sx_offset; /* offset into file */ |
| 479 | xfs_off_t sx_length; /* leng from offset */ |
| 480 | char sx_pad[16]; /* pad space, unused */ |
| 481 | xfs_bstat_t sx_stat; /* stat of target b4 copy */ |
| 482 | } xfs_swapext_t; |
| 483 | |
| 484 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 485 | * Flags for going down operation |
| 486 | */ |
| 487 | #define XFS_FSOP_GOING_FLAGS_DEFAULT 0x0 /* going down */ |
| 488 | #define XFS_FSOP_GOING_FLAGS_LOGFLUSH 0x1 /* flush log but not data */ |
| 489 | #define XFS_FSOP_GOING_FLAGS_NOLOGFLUSH 0x2 /* don't flush log nor data */ |
| 490 | |
| 491 | /* |
| 492 | * ioctl commands that are used by Linux filesystems |
| 493 | */ |
Eric Sandeen | bc58f9b | 2007-10-12 11:13:22 +1000 | [diff] [blame] | 494 | #define XFS_IOC_GETXFLAGS FS_IOC_GETFLAGS |
| 495 | #define XFS_IOC_SETXFLAGS FS_IOC_SETFLAGS |
| 496 | #define XFS_IOC_GETVERSION FS_IOC_GETVERSION |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 497 | |
| 498 | /* |
| 499 | * ioctl commands that replace IRIX fcntl()'s |
| 500 | * For 'documentation' purposed more than anything else, |
| 501 | * the "cmd #" field reflects the IRIX fcntl number. |
| 502 | */ |
| 503 | #define XFS_IOC_ALLOCSP _IOW ('X', 10, struct xfs_flock64) |
| 504 | #define XFS_IOC_FREESP _IOW ('X', 11, struct xfs_flock64) |
| 505 | #define XFS_IOC_DIOINFO _IOR ('X', 30, struct dioattr) |
| 506 | #define XFS_IOC_FSGETXATTR _IOR ('X', 31, struct fsxattr) |
| 507 | #define XFS_IOC_FSSETXATTR _IOW ('X', 32, struct fsxattr) |
| 508 | #define XFS_IOC_ALLOCSP64 _IOW ('X', 36, struct xfs_flock64) |
| 509 | #define XFS_IOC_FREESP64 _IOW ('X', 37, struct xfs_flock64) |
| 510 | #define XFS_IOC_GETBMAP _IOWR('X', 38, struct getbmap) |
| 511 | #define XFS_IOC_FSSETDM _IOW ('X', 39, struct fsdmidata) |
| 512 | #define XFS_IOC_RESVSP _IOW ('X', 40, struct xfs_flock64) |
| 513 | #define XFS_IOC_UNRESVSP _IOW ('X', 41, struct xfs_flock64) |
| 514 | #define XFS_IOC_RESVSP64 _IOW ('X', 42, struct xfs_flock64) |
| 515 | #define XFS_IOC_UNRESVSP64 _IOW ('X', 43, struct xfs_flock64) |
| 516 | #define XFS_IOC_GETBMAPA _IOWR('X', 44, struct getbmap) |
| 517 | #define XFS_IOC_FSGETXATTRA _IOR ('X', 45, struct fsxattr) |
| 518 | /* XFS_IOC_SETBIOSIZE ---- deprecated 46 */ |
| 519 | /* XFS_IOC_GETBIOSIZE ---- deprecated 47 */ |
| 520 | #define XFS_IOC_GETBMAPX _IOWR('X', 56, struct getbmap) |
Dave Chinner | 4472235 | 2010-08-24 12:02:11 +1000 | [diff] [blame] | 521 | #define XFS_IOC_ZERO_RANGE _IOW ('X', 57, struct xfs_flock64) |
Dave Chinner | b771af2 | 2013-09-24 16:01:15 +1000 | [diff] [blame] | 522 | #define XFS_IOC_FREE_EOFBLOCKS _IOR ('X', 58, struct xfs_fs_eofblocks) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 523 | |
| 524 | /* |
| 525 | * ioctl commands that replace IRIX syssgi()'s |
| 526 | */ |
| 527 | #define XFS_IOC_FSGEOMETRY_V1 _IOR ('X', 100, struct xfs_fsop_geom_v1) |
| 528 | #define XFS_IOC_FSBULKSTAT _IOWR('X', 101, struct xfs_fsop_bulkreq) |
| 529 | #define XFS_IOC_FSBULKSTAT_SINGLE _IOWR('X', 102, struct xfs_fsop_bulkreq) |
| 530 | #define XFS_IOC_FSINUMBERS _IOWR('X', 103, struct xfs_fsop_bulkreq) |
| 531 | #define XFS_IOC_PATH_TO_FSHANDLE _IOWR('X', 104, struct xfs_fsop_handlereq) |
| 532 | #define XFS_IOC_PATH_TO_HANDLE _IOWR('X', 105, struct xfs_fsop_handlereq) |
| 533 | #define XFS_IOC_FD_TO_HANDLE _IOWR('X', 106, struct xfs_fsop_handlereq) |
| 534 | #define XFS_IOC_OPEN_BY_HANDLE _IOWR('X', 107, struct xfs_fsop_handlereq) |
| 535 | #define XFS_IOC_READLINK_BY_HANDLE _IOWR('X', 108, struct xfs_fsop_handlereq) |
| 536 | #define XFS_IOC_SWAPEXT _IOWR('X', 109, struct xfs_swapext) |
| 537 | #define XFS_IOC_FSGROWFSDATA _IOW ('X', 110, struct xfs_growfs_data) |
| 538 | #define XFS_IOC_FSGROWFSLOG _IOW ('X', 111, struct xfs_growfs_log) |
| 539 | #define XFS_IOC_FSGROWFSRT _IOW ('X', 112, struct xfs_growfs_rt) |
| 540 | #define XFS_IOC_FSCOUNTS _IOR ('X', 113, struct xfs_fsop_counts) |
| 541 | #define XFS_IOC_SET_RESBLKS _IOWR('X', 114, struct xfs_fsop_resblks) |
| 542 | #define XFS_IOC_GET_RESBLKS _IOR ('X', 115, struct xfs_fsop_resblks) |
| 543 | #define XFS_IOC_ERROR_INJECTION _IOW ('X', 116, struct xfs_error_injection) |
| 544 | #define XFS_IOC_ERROR_CLEARALL _IOW ('X', 117, struct xfs_error_injection) |
| 545 | /* XFS_IOC_ATTRCTL_BY_HANDLE -- deprecated 118 */ |
Dave Chinner | d386b32 | 2013-08-12 20:49:31 +1000 | [diff] [blame] | 546 | |
Takashi Sato | 8e96187 | 2009-01-09 16:41:00 -0800 | [diff] [blame] | 547 | /* XFS_IOC_FREEZE -- FIFREEZE 119 */ |
| 548 | /* XFS_IOC_THAW -- FITHAW 120 */ |
Dave Chinner | d386b32 | 2013-08-12 20:49:31 +1000 | [diff] [blame] | 549 | #ifndef FIFREEZE |
| 550 | #define XFS_IOC_FREEZE _IOWR('X', 119, int) |
| 551 | #define XFS_IOC_THAW _IOWR('X', 120, int) |
| 552 | #endif |
| 553 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 554 | #define XFS_IOC_FSSETDM_BY_HANDLE _IOW ('X', 121, struct xfs_fsop_setdm_handlereq) |
| 555 | #define XFS_IOC_ATTRLIST_BY_HANDLE _IOW ('X', 122, struct xfs_fsop_attrlist_handlereq) |
| 556 | #define XFS_IOC_ATTRMULTI_BY_HANDLE _IOW ('X', 123, struct xfs_fsop_attrmulti_handlereq) |
| 557 | #define XFS_IOC_FSGEOMETRY _IOR ('X', 124, struct xfs_fsop_geom) |
| 558 | #define XFS_IOC_GOINGDOWN _IOR ('X', 125, __uint32_t) |
| 559 | /* XFS_IOC_GETFSUUID ---------- deprecated 140 */ |
| 560 | |
| 561 | |
| 562 | #ifndef HAVE_BBMACROS |
| 563 | /* |
| 564 | * Block I/O parameterization. A basic block (BB) is the lowest size of |
| 565 | * filesystem allocation, and must equal 512. Length units given to bio |
| 566 | * routines are in BB's. |
| 567 | */ |
| 568 | #define BBSHIFT 9 |
| 569 | #define BBSIZE (1<<BBSHIFT) |
| 570 | #define BBMASK (BBSIZE-1) |
| 571 | #define BTOBB(bytes) (((__u64)(bytes) + BBSIZE - 1) >> BBSHIFT) |
| 572 | #define BTOBBT(bytes) ((__u64)(bytes) >> BBSHIFT) |
| 573 | #define BBTOB(bbs) ((bbs) << BBSHIFT) |
| 574 | #endif |
| 575 | |
| 576 | #endif /* __XFS_FS_H__ */ |