Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 1 | /* |
| 2 | * nilfs2_fs.h - NILFS2 on-disk structures and common declarations. |
| 3 | * |
| 4 | * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation. |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 19 | * |
| 20 | * Written by Koji Sato <koji@osrg.net> |
| 21 | * Ryusuke Konishi <ryusuke@osrg.net> |
| 22 | */ |
| 23 | /* |
| 24 | * linux/include/linux/ext2_fs.h |
| 25 | * |
| 26 | * Copyright (C) 1992, 1993, 1994, 1995 |
| 27 | * Remy Card (card@masi.ibp.fr) |
| 28 | * Laboratoire MASI - Institut Blaise Pascal |
| 29 | * Universite Pierre et Marie Curie (Paris VI) |
| 30 | * |
| 31 | * from |
| 32 | * |
| 33 | * linux/include/linux/minix_fs.h |
| 34 | * |
| 35 | * Copyright (C) 1991, 1992 Linus Torvalds |
| 36 | */ |
| 37 | |
| 38 | #ifndef _LINUX_NILFS_FS_H |
| 39 | #define _LINUX_NILFS_FS_H |
| 40 | |
| 41 | #include <linux/types.h> |
| 42 | #include <linux/ioctl.h> |
| 43 | |
| 44 | /* |
| 45 | * Inode flags stored in nilfs_inode and on-memory nilfs inode |
| 46 | * |
| 47 | * We define these flags based on ext2-fs because of the |
| 48 | * compatibility reason; to avoid problems in chattr(1) |
| 49 | */ |
| 50 | #define NILFS_SECRM_FL 0x00000001 /* Secure deletion */ |
| 51 | #define NILFS_UNRM_FL 0x00000002 /* Undelete */ |
| 52 | #define NILFS_SYNC_FL 0x00000008 /* Synchronous updates */ |
| 53 | #define NILFS_IMMUTABLE_FL 0x00000010 /* Immutable file */ |
| 54 | #define NILFS_APPEND_FL 0x00000020 /* writes to file may only append */ |
| 55 | #define NILFS_NODUMP_FL 0x00000040 /* do not dump file */ |
| 56 | #define NILFS_NOATIME_FL 0x00000080 /* do not update atime */ |
| 57 | /* Reserved for compression usage... */ |
| 58 | #define NILFS_NOTAIL_FL 0x00008000 /* file tail should not be merged */ |
| 59 | #define NILFS_DIRSYNC_FL 0x00010000 /* dirsync behaviour */ |
| 60 | |
| 61 | #define NILFS_FL_USER_VISIBLE 0x0003DFFF /* User visible flags */ |
| 62 | #define NILFS_FL_USER_MODIFIABLE 0x000380FF /* User modifiable flags */ |
| 63 | |
| 64 | |
| 65 | #define NILFS_INODE_BMAP_SIZE 7 |
| 66 | /** |
| 67 | * struct nilfs_inode - structure of an inode on disk |
| 68 | * @i_blocks: blocks count |
| 69 | * @i_size: size in bytes |
Ryusuke Konishi | 6123923 | 2009-04-06 19:02:00 -0700 | [diff] [blame] | 70 | * @i_ctime: creation time (seconds) |
| 71 | * @i_mtime: modification time (seconds) |
| 72 | * @i_ctime_nsec: creation time (nano seconds) |
| 73 | * @i_mtime_nsec: modification time (nano seconds) |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 74 | * @i_uid: user id |
| 75 | * @i_gid: group id |
| 76 | * @i_mode: file mode |
| 77 | * @i_links_count: links count |
| 78 | * @i_flags: file flags |
| 79 | * @i_bmap: block mapping |
| 80 | * @i_xattr: extended attributes |
| 81 | * @i_generation: file generation (for NFS) |
| 82 | * @i_pad: padding |
| 83 | */ |
| 84 | struct nilfs_inode { |
| 85 | __le64 i_blocks; |
| 86 | __le64 i_size; |
| 87 | __le64 i_ctime; |
| 88 | __le64 i_mtime; |
Ryusuke Konishi | 6123923 | 2009-04-06 19:02:00 -0700 | [diff] [blame] | 89 | __le32 i_ctime_nsec; |
| 90 | __le32 i_mtime_nsec; |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 91 | __le32 i_uid; |
| 92 | __le32 i_gid; |
| 93 | __le16 i_mode; |
| 94 | __le16 i_links_count; |
| 95 | __le32 i_flags; |
| 96 | __le64 i_bmap[NILFS_INODE_BMAP_SIZE]; |
| 97 | #define i_device_code i_bmap[0] |
| 98 | __le64 i_xattr; |
| 99 | __le32 i_generation; |
| 100 | __le32 i_pad; |
| 101 | }; |
| 102 | |
| 103 | /** |
| 104 | * struct nilfs_super_root - structure of super root |
| 105 | * @sr_sum: check sum |
| 106 | * @sr_bytes: byte count of the structure |
| 107 | * @sr_flags: flags (reserved) |
| 108 | * @sr_nongc_ctime: write time of the last segment not for cleaner operation |
| 109 | * @sr_dat: DAT file inode |
| 110 | * @sr_cpfile: checkpoint file inode |
| 111 | * @sr_sufile: segment usage file inode |
| 112 | */ |
| 113 | struct nilfs_super_root { |
| 114 | __le32 sr_sum; |
| 115 | __le16 sr_bytes; |
| 116 | __le16 sr_flags; |
| 117 | __le64 sr_nongc_ctime; |
| 118 | struct nilfs_inode sr_dat; |
| 119 | struct nilfs_inode sr_cpfile; |
| 120 | struct nilfs_inode sr_sufile; |
| 121 | }; |
| 122 | |
| 123 | #define NILFS_SR_MDT_OFFSET(inode_size, i) \ |
| 124 | ((unsigned long)&((struct nilfs_super_root *)0)->sr_dat + \ |
| 125 | (inode_size) * (i)) |
| 126 | #define NILFS_SR_DAT_OFFSET(inode_size) NILFS_SR_MDT_OFFSET(inode_size, 0) |
| 127 | #define NILFS_SR_CPFILE_OFFSET(inode_size) NILFS_SR_MDT_OFFSET(inode_size, 1) |
| 128 | #define NILFS_SR_SUFILE_OFFSET(inode_size) NILFS_SR_MDT_OFFSET(inode_size, 2) |
| 129 | #define NILFS_SR_BYTES (sizeof(struct nilfs_super_root)) |
| 130 | |
| 131 | /* |
| 132 | * Maximal mount counts |
| 133 | */ |
| 134 | #define NILFS_DFL_MAX_MNT_COUNT 50 /* 50 mounts */ |
| 135 | |
| 136 | /* |
| 137 | * File system states (sbp->s_state, nilfs->ns_mount_state) |
| 138 | */ |
| 139 | #define NILFS_VALID_FS 0x0001 /* Unmounted cleanly */ |
| 140 | #define NILFS_ERROR_FS 0x0002 /* Errors detected */ |
| 141 | #define NILFS_RESIZE_FS 0x0004 /* Resize required */ |
| 142 | |
| 143 | /* |
| 144 | * Mount flags (sbi->s_mount_opt) |
| 145 | */ |
| 146 | #define NILFS_MOUNT_ERROR_MODE 0x0070 /* Error mode mask */ |
| 147 | #define NILFS_MOUNT_ERRORS_CONT 0x0010 /* Continue on errors */ |
| 148 | #define NILFS_MOUNT_ERRORS_RO 0x0020 /* Remount fs ro on errors */ |
| 149 | #define NILFS_MOUNT_ERRORS_PANIC 0x0040 /* Panic on errors */ |
| 150 | #define NILFS_MOUNT_SNAPSHOT 0x0080 /* Snapshot flag */ |
| 151 | #define NILFS_MOUNT_BARRIER 0x1000 /* Use block barriers */ |
| 152 | #define NILFS_MOUNT_STRICT_ORDER 0x2000 /* Apply strict in-order |
| 153 | semantics also for data */ |
Ryusuke Konishi | 0234576 | 2009-11-20 03:28:01 +0900 | [diff] [blame] | 154 | #define NILFS_MOUNT_NORECOVERY 0x4000 /* Disable write access during |
| 155 | mount-time recovery */ |
Jiro SEKIBA | e902ec9 | 2010-01-30 18:06:35 +0900 | [diff] [blame] | 156 | #define NILFS_MOUNT_DISCARD 0x8000 /* Issue DISCARD requests */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 157 | |
| 158 | |
| 159 | /** |
| 160 | * struct nilfs_super_block - structure of super block on disk |
| 161 | */ |
| 162 | struct nilfs_super_block { |
Ryusuke Konishi | 2f1b7cd | 2010-07-22 03:22:18 +0900 | [diff] [blame] | 163 | /*00*/ __le32 s_rev_level; /* Revision level */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 164 | __le16 s_minor_rev_level; /* minor revision level */ |
| 165 | __le16 s_magic; /* Magic signature */ |
| 166 | |
| 167 | __le16 s_bytes; /* Bytes count of CRC calculation |
| 168 | for this structure. s_reserved |
| 169 | is excluded. */ |
| 170 | __le16 s_flags; /* flags */ |
| 171 | __le32 s_crc_seed; /* Seed value of CRC calculation */ |
Ryusuke Konishi | 2f1b7cd | 2010-07-22 03:22:18 +0900 | [diff] [blame] | 172 | /*10*/ __le32 s_sum; /* Check sum of super block */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 173 | |
| 174 | __le32 s_log_block_size; /* Block size represented as follows |
| 175 | blocksize = |
| 176 | 1 << (s_log_block_size + 10) */ |
| 177 | __le64 s_nsegments; /* Number of segments in filesystem */ |
Ryusuke Konishi | 2f1b7cd | 2010-07-22 03:22:18 +0900 | [diff] [blame] | 178 | /*20*/ __le64 s_dev_size; /* block device size in bytes */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 179 | __le64 s_first_data_block; /* 1st seg disk block number */ |
Ryusuke Konishi | 2f1b7cd | 2010-07-22 03:22:18 +0900 | [diff] [blame] | 180 | /*30*/ __le32 s_blocks_per_segment; /* number of blocks per full segment */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 181 | __le32 s_r_segments_percentage; /* Reserved segments percentage */ |
| 182 | |
| 183 | __le64 s_last_cno; /* Last checkpoint number */ |
Ryusuke Konishi | 2f1b7cd | 2010-07-22 03:22:18 +0900 | [diff] [blame] | 184 | /*40*/ __le64 s_last_pseg; /* disk block addr pseg written last */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 185 | __le64 s_last_seq; /* seq. number of seg written last */ |
Ryusuke Konishi | 2f1b7cd | 2010-07-22 03:22:18 +0900 | [diff] [blame] | 186 | /*50*/ __le64 s_free_blocks_count; /* Free blocks count */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 187 | |
| 188 | __le64 s_ctime; /* Creation time (execution time of |
| 189 | newfs) */ |
Ryusuke Konishi | 2f1b7cd | 2010-07-22 03:22:18 +0900 | [diff] [blame] | 190 | /*60*/ __le64 s_mtime; /* Mount time */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 191 | __le64 s_wtime; /* Write time */ |
Ryusuke Konishi | 2f1b7cd | 2010-07-22 03:22:18 +0900 | [diff] [blame] | 192 | /*70*/ __le16 s_mnt_count; /* Mount count */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 193 | __le16 s_max_mnt_count; /* Maximal mount count */ |
| 194 | __le16 s_state; /* File system state */ |
| 195 | __le16 s_errors; /* Behaviour when detecting errors */ |
| 196 | __le64 s_lastcheck; /* time of last check */ |
| 197 | |
Ryusuke Konishi | 2f1b7cd | 2010-07-22 03:22:18 +0900 | [diff] [blame] | 198 | /*80*/ __le32 s_checkinterval; /* max. time between checks */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 199 | __le32 s_creator_os; /* OS */ |
| 200 | __le16 s_def_resuid; /* Default uid for reserved blocks */ |
| 201 | __le16 s_def_resgid; /* Default gid for reserved blocks */ |
Ryusuke Konishi | 0d9cc23 | 2010-04-26 01:17:48 +0900 | [diff] [blame] | 202 | __le32 s_first_ino; /* First non-reserved inode */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 203 | |
Ryusuke Konishi | 2f1b7cd | 2010-07-22 03:22:18 +0900 | [diff] [blame] | 204 | /*90*/ __le16 s_inode_size; /* Size of an inode */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 205 | __le16 s_dat_entry_size; /* Size of a dat entry */ |
| 206 | __le16 s_checkpoint_size; /* Size of a checkpoint */ |
| 207 | __le16 s_segment_usage_size; /* Size of a segment usage */ |
| 208 | |
Ryusuke Konishi | 2f1b7cd | 2010-07-22 03:22:18 +0900 | [diff] [blame] | 209 | /*98*/ __u8 s_uuid[16]; /* 128-bit uuid for volume */ |
| 210 | /*A8*/ char s_volume_name[80]; /* volume name */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 211 | |
Ryusuke Konishi | 2f1b7cd | 2010-07-22 03:22:18 +0900 | [diff] [blame] | 212 | /*F8*/ __le32 s_c_interval; /* Commit interval of segment */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 213 | __le32 s_c_block_max; /* Threshold of data amount for |
| 214 | the segment construction */ |
Ryusuke Konishi | 1a80a17 | 2010-07-22 03:22:19 +0900 | [diff] [blame] | 215 | /*100*/ __le64 s_feature_compat; /* Compatible feature set */ |
| 216 | __le64 s_feature_compat_ro; /* Read-only compatible feature set */ |
| 217 | __le64 s_feature_incompat; /* Incompatible feature set */ |
| 218 | __u32 s_reserved[186]; /* padding to the end of the block */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 219 | }; |
| 220 | |
| 221 | /* |
| 222 | * Codes for operating systems |
| 223 | */ |
| 224 | #define NILFS_OS_LINUX 0 |
| 225 | /* Codes from 1 to 4 are reserved to keep compatibility with ext2 creator-OS */ |
| 226 | |
| 227 | /* |
| 228 | * Revision levels |
| 229 | */ |
| 230 | #define NILFS_CURRENT_REV 2 /* current major revision */ |
| 231 | #define NILFS_MINOR_REV 0 /* minor revision */ |
Ryusuke Konishi | 9566a7a | 2010-08-10 00:58:41 +0900 | [diff] [blame] | 232 | #define NILFS_MIN_SUPP_REV 2 /* minimum supported revision */ |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 233 | |
| 234 | /* |
Ryusuke Konishi | 1a80a17 | 2010-07-22 03:22:19 +0900 | [diff] [blame] | 235 | * Feature set definitions |
| 236 | * |
| 237 | * If there is a bit set in the incompatible feature set that the kernel |
| 238 | * doesn't know about, it should refuse to mount the filesystem. |
| 239 | */ |
| 240 | #define NILFS_FEATURE_COMPAT_SUPP 0ULL |
| 241 | #define NILFS_FEATURE_COMPAT_RO_SUPP 0ULL |
| 242 | #define NILFS_FEATURE_INCOMPAT_SUPP 0ULL |
| 243 | |
| 244 | /* |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 245 | * Bytes count of super_block for CRC-calculation |
| 246 | */ |
| 247 | #define NILFS_SB_BYTES \ |
| 248 | ((long)&((struct nilfs_super_block *)0)->s_reserved) |
| 249 | |
| 250 | /* |
| 251 | * Special inode number |
| 252 | */ |
| 253 | #define NILFS_ROOT_INO 2 /* Root file inode */ |
| 254 | #define NILFS_DAT_INO 3 /* DAT file */ |
| 255 | #define NILFS_CPFILE_INO 4 /* checkpoint file */ |
| 256 | #define NILFS_SUFILE_INO 5 /* segment usage file */ |
| 257 | #define NILFS_IFILE_INO 6 /* ifile */ |
| 258 | #define NILFS_ATIME_INO 7 /* Atime file (reserved) */ |
| 259 | #define NILFS_XATTR_INO 8 /* Xattribute file (reserved) */ |
| 260 | #define NILFS_SKETCH_INO 10 /* Sketch file */ |
| 261 | #define NILFS_USER_INO 11 /* Fisrt user's file inode number */ |
| 262 | |
| 263 | #define NILFS_SB_OFFSET_BYTES 1024 /* byte offset of nilfs superblock */ |
| 264 | #define NILFS_SUPER_MAGIC 0x3434 /* NILFS filesystem magic number */ |
| 265 | |
| 266 | #define NILFS_SEG_MIN_BLOCKS 16 /* Minimum number of blocks in |
| 267 | a full segment */ |
| 268 | #define NILFS_PSEG_MIN_BLOCKS 2 /* Minimum number of blocks in |
| 269 | a partial segment */ |
| 270 | #define NILFS_MIN_NRSVSEGS 8 /* Minimum number of reserved |
| 271 | segments */ |
| 272 | |
Ryusuke Konishi | e339ad3 | 2009-04-06 19:01:59 -0700 | [diff] [blame] | 273 | /* |
Ryusuke Konishi | 6c43f41 | 2010-08-20 20:10:38 +0900 | [diff] [blame^] | 274 | * We call DAT, cpfile, and sufile root metadata files. Inodes of |
| 275 | * these files are written in super root block instead of ifile, and |
| 276 | * garbage collector doesn't keep any past versions of these files. |
| 277 | */ |
| 278 | #define NILFS_ROOT_METADATA_FILE(ino) \ |
| 279 | ((ino) >= NILFS_DAT_INO && (ino) <= NILFS_SUFILE_INO) |
| 280 | |
| 281 | /* |
Ryusuke Konishi | e339ad3 | 2009-04-06 19:01:59 -0700 | [diff] [blame] | 282 | * bytes offset of secondary super block |
| 283 | */ |
| 284 | #define NILFS_SB2_OFFSET_BYTES(devsize) ((((devsize) >> 12) - 1) << 12) |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 285 | |
| 286 | /* |
| 287 | * Maximal count of links to a file |
| 288 | */ |
| 289 | #define NILFS_LINK_MAX 32000 |
| 290 | |
| 291 | /* |
| 292 | * Structure of a directory entry |
| 293 | * (Same as ext2) |
| 294 | */ |
| 295 | |
| 296 | #define NILFS_NAME_LEN 255 |
| 297 | |
| 298 | /* |
Ryusuke Konishi | 89c0fd0 | 2010-07-25 22:44:53 +0900 | [diff] [blame] | 299 | * Block size limitations |
| 300 | */ |
| 301 | #define NILFS_MIN_BLOCK_SIZE 1024 |
| 302 | #define NILFS_MAX_BLOCK_SIZE 65536 |
| 303 | |
| 304 | /* |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 305 | * The new version of the directory entry. Since V0 structures are |
| 306 | * stored in intel byte order, and the name_len field could never be |
| 307 | * bigger than 255 chars, it's safe to reclaim the extra byte for the |
| 308 | * file_type field. |
| 309 | */ |
| 310 | struct nilfs_dir_entry { |
| 311 | __le64 inode; /* Inode number */ |
| 312 | __le16 rec_len; /* Directory entry length */ |
| 313 | __u8 name_len; /* Name length */ |
| 314 | __u8 file_type; |
| 315 | char name[NILFS_NAME_LEN]; /* File name */ |
| 316 | char pad; |
| 317 | }; |
| 318 | |
| 319 | /* |
| 320 | * NILFS directory file types. Only the low 3 bits are used. The |
| 321 | * other bits are reserved for now. |
| 322 | */ |
| 323 | enum { |
| 324 | NILFS_FT_UNKNOWN, |
| 325 | NILFS_FT_REG_FILE, |
| 326 | NILFS_FT_DIR, |
| 327 | NILFS_FT_CHRDEV, |
| 328 | NILFS_FT_BLKDEV, |
| 329 | NILFS_FT_FIFO, |
| 330 | NILFS_FT_SOCK, |
| 331 | NILFS_FT_SYMLINK, |
| 332 | NILFS_FT_MAX |
| 333 | }; |
| 334 | |
| 335 | /* |
| 336 | * NILFS_DIR_PAD defines the directory entries boundaries |
| 337 | * |
| 338 | * NOTE: It must be a multiple of 8 |
| 339 | */ |
| 340 | #define NILFS_DIR_PAD 8 |
| 341 | #define NILFS_DIR_ROUND (NILFS_DIR_PAD - 1) |
| 342 | #define NILFS_DIR_REC_LEN(name_len) (((name_len) + 12 + NILFS_DIR_ROUND) & \ |
| 343 | ~NILFS_DIR_ROUND) |
Ryusuke Konishi | 6cda9fa | 2010-07-25 20:39:03 +0900 | [diff] [blame] | 344 | #define NILFS_MAX_REC_LEN ((1<<16)-1) |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 345 | |
Ryusuke Konishi | 6cda9fa | 2010-07-25 20:39:03 +0900 | [diff] [blame] | 346 | static inline unsigned nilfs_rec_len_from_disk(__le16 dlen) |
| 347 | { |
| 348 | unsigned len = le16_to_cpu(dlen); |
| 349 | |
| 350 | if (len == NILFS_MAX_REC_LEN) |
| 351 | return 1 << 16; |
| 352 | return len; |
| 353 | } |
| 354 | |
| 355 | static inline __le16 nilfs_rec_len_to_disk(unsigned len) |
| 356 | { |
| 357 | if (len == (1 << 16)) |
| 358 | return cpu_to_le16(NILFS_MAX_REC_LEN); |
| 359 | else if (len > (1 << 16)) |
| 360 | BUG(); |
| 361 | return cpu_to_le16(len); |
| 362 | } |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 363 | |
| 364 | /** |
| 365 | * struct nilfs_finfo - file information |
| 366 | * @fi_ino: inode number |
| 367 | * @fi_cno: checkpoint number |
| 368 | * @fi_nblocks: number of blocks (including intermediate blocks) |
| 369 | * @fi_ndatablk: number of file data blocks |
| 370 | */ |
| 371 | struct nilfs_finfo { |
| 372 | __le64 fi_ino; |
| 373 | __le64 fi_cno; |
| 374 | __le32 fi_nblocks; |
| 375 | __le32 fi_ndatablk; |
| 376 | /* array of virtual block numbers */ |
| 377 | }; |
| 378 | |
| 379 | /** |
| 380 | * struct nilfs_binfo_v - information for the block to which a virtual block number is assigned |
| 381 | * @bi_vblocknr: virtual block number |
| 382 | * @bi_blkoff: block offset |
| 383 | */ |
| 384 | struct nilfs_binfo_v { |
| 385 | __le64 bi_vblocknr; |
| 386 | __le64 bi_blkoff; |
| 387 | }; |
| 388 | |
| 389 | /** |
| 390 | * struct nilfs_binfo_dat - information for the block which belongs to the DAT file |
| 391 | * @bi_blkoff: block offset |
| 392 | * @bi_level: level |
| 393 | * @bi_pad: padding |
| 394 | */ |
| 395 | struct nilfs_binfo_dat { |
| 396 | __le64 bi_blkoff; |
| 397 | __u8 bi_level; |
| 398 | __u8 bi_pad[7]; |
| 399 | }; |
| 400 | |
| 401 | /** |
| 402 | * union nilfs_binfo: block information |
| 403 | * @bi_v: nilfs_binfo_v structure |
| 404 | * @bi_dat: nilfs_binfo_dat structure |
| 405 | */ |
| 406 | union nilfs_binfo { |
| 407 | struct nilfs_binfo_v bi_v; |
| 408 | struct nilfs_binfo_dat bi_dat; |
| 409 | }; |
| 410 | |
| 411 | /** |
| 412 | * struct nilfs_segment_summary - segment summary |
| 413 | * @ss_datasum: checksum of data |
| 414 | * @ss_sumsum: checksum of segment summary |
| 415 | * @ss_magic: magic number |
| 416 | * @ss_bytes: size of this structure in bytes |
| 417 | * @ss_flags: flags |
| 418 | * @ss_seq: sequence number |
| 419 | * @ss_create: creation timestamp |
| 420 | * @ss_next: next segment |
| 421 | * @ss_nblocks: number of blocks |
| 422 | * @ss_nfinfo: number of finfo structures |
| 423 | * @ss_sumbytes: total size of segment summary in bytes |
| 424 | * @ss_pad: padding |
Ryusuke Konishi | 50614bc | 2010-04-10 17:59:15 +0900 | [diff] [blame] | 425 | * @ss_cno: checkpoint number |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 426 | */ |
| 427 | struct nilfs_segment_summary { |
| 428 | __le32 ss_datasum; |
| 429 | __le32 ss_sumsum; |
| 430 | __le32 ss_magic; |
| 431 | __le16 ss_bytes; |
| 432 | __le16 ss_flags; |
| 433 | __le64 ss_seq; |
| 434 | __le64 ss_create; |
| 435 | __le64 ss_next; |
| 436 | __le32 ss_nblocks; |
| 437 | __le32 ss_nfinfo; |
| 438 | __le32 ss_sumbytes; |
| 439 | __le32 ss_pad; |
Ryusuke Konishi | 50614bc | 2010-04-10 17:59:15 +0900 | [diff] [blame] | 440 | __le64 ss_cno; |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 441 | /* array of finfo structures */ |
| 442 | }; |
| 443 | |
| 444 | #define NILFS_SEGSUM_MAGIC 0x1eaffa11 /* segment summary magic number */ |
| 445 | |
| 446 | /* |
| 447 | * Segment summary flags |
| 448 | */ |
| 449 | #define NILFS_SS_LOGBGN 0x0001 /* begins a logical segment */ |
| 450 | #define NILFS_SS_LOGEND 0x0002 /* ends a logical segment */ |
| 451 | #define NILFS_SS_SR 0x0004 /* has super root */ |
| 452 | #define NILFS_SS_SYNDT 0x0008 /* includes data only updates */ |
| 453 | #define NILFS_SS_GC 0x0010 /* segment written for cleaner operation */ |
| 454 | |
| 455 | /** |
Jiro SEKIBA | 6600b9d | 2009-11-09 19:10:11 +0900 | [diff] [blame] | 456 | * struct nilfs_btree_node - B-tree node |
| 457 | * @bn_flags: flags |
| 458 | * @bn_level: level |
| 459 | * @bn_nchildren: number of children |
| 460 | * @bn_pad: padding |
| 461 | */ |
| 462 | struct nilfs_btree_node { |
| 463 | __u8 bn_flags; |
| 464 | __u8 bn_level; |
| 465 | __le16 bn_nchildren; |
| 466 | __le32 bn_pad; |
| 467 | }; |
| 468 | |
| 469 | /* flags */ |
| 470 | #define NILFS_BTREE_NODE_ROOT 0x01 |
| 471 | |
| 472 | /* level */ |
| 473 | #define NILFS_BTREE_LEVEL_DATA 0 |
| 474 | #define NILFS_BTREE_LEVEL_NODE_MIN (NILFS_BTREE_LEVEL_DATA + 1) |
| 475 | #define NILFS_BTREE_LEVEL_MAX 14 |
| 476 | |
| 477 | /** |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 478 | * struct nilfs_palloc_group_desc - block group descriptor |
| 479 | * @pg_nfrees: number of free entries in block group |
| 480 | */ |
| 481 | struct nilfs_palloc_group_desc { |
| 482 | __le32 pg_nfrees; |
| 483 | }; |
| 484 | |
| 485 | /** |
| 486 | * struct nilfs_dat_entry - disk address translation entry |
Qinghuang Feng | 37e11f3 | 2010-04-25 20:17:25 +0800 | [diff] [blame] | 487 | * @de_blocknr: block number |
| 488 | * @de_start: start checkpoint number |
| 489 | * @de_end: end checkpoint number |
| 490 | * @de_rsv: reserved for future use |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 491 | */ |
| 492 | struct nilfs_dat_entry { |
| 493 | __le64 de_blocknr; |
| 494 | __le64 de_start; |
| 495 | __le64 de_end; |
| 496 | __le64 de_rsv; |
| 497 | }; |
| 498 | |
| 499 | /** |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 500 | * struct nilfs_snapshot_list - snapshot list |
| 501 | * @ssl_next: next checkpoint number on snapshot list |
| 502 | * @ssl_prev: previous checkpoint number on snapshot list |
| 503 | */ |
| 504 | struct nilfs_snapshot_list { |
| 505 | __le64 ssl_next; |
| 506 | __le64 ssl_prev; |
| 507 | }; |
| 508 | |
| 509 | /** |
| 510 | * struct nilfs_checkpoint - checkpoint structure |
| 511 | * @cp_flags: flags |
| 512 | * @cp_checkpoints_count: checkpoints count in a block |
| 513 | * @cp_snapshot_list: snapshot list |
| 514 | * @cp_cno: checkpoint number |
| 515 | * @cp_create: creation timestamp |
| 516 | * @cp_nblk_inc: number of blocks incremented by this checkpoint |
| 517 | * @cp_inodes_count: inodes count |
| 518 | * @cp_blocks_count: blocks count |
| 519 | * @cp_ifile_inode: inode of ifile |
| 520 | */ |
| 521 | struct nilfs_checkpoint { |
| 522 | __le32 cp_flags; |
| 523 | __le32 cp_checkpoints_count; |
| 524 | struct nilfs_snapshot_list cp_snapshot_list; |
| 525 | __le64 cp_cno; |
| 526 | __le64 cp_create; |
| 527 | __le64 cp_nblk_inc; |
| 528 | __le64 cp_inodes_count; |
| 529 | __le64 cp_blocks_count; /* Reserved (might be deleted) */ |
| 530 | |
| 531 | /* Do not change the byte offset of ifile inode. |
| 532 | To keep the compatibility of the disk format, |
| 533 | additional fields should be added behind cp_ifile_inode. */ |
| 534 | struct nilfs_inode cp_ifile_inode; |
| 535 | }; |
| 536 | |
| 537 | /* checkpoint flags */ |
| 538 | enum { |
| 539 | NILFS_CHECKPOINT_SNAPSHOT, |
| 540 | NILFS_CHECKPOINT_INVALID, |
| 541 | NILFS_CHECKPOINT_SKETCH, |
Ryusuke Konishi | c96fa46 | 2009-04-06 19:01:57 -0700 | [diff] [blame] | 542 | NILFS_CHECKPOINT_MINOR, |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 543 | }; |
| 544 | |
| 545 | #define NILFS_CHECKPOINT_FNS(flag, name) \ |
| 546 | static inline void \ |
| 547 | nilfs_checkpoint_set_##name(struct nilfs_checkpoint *cp) \ |
| 548 | { \ |
| 549 | cp->cp_flags = cpu_to_le32(le32_to_cpu(cp->cp_flags) | \ |
| 550 | (1UL << NILFS_CHECKPOINT_##flag)); \ |
| 551 | } \ |
| 552 | static inline void \ |
| 553 | nilfs_checkpoint_clear_##name(struct nilfs_checkpoint *cp) \ |
| 554 | { \ |
| 555 | cp->cp_flags = cpu_to_le32(le32_to_cpu(cp->cp_flags) & \ |
| 556 | ~(1UL << NILFS_CHECKPOINT_##flag)); \ |
| 557 | } \ |
| 558 | static inline int \ |
| 559 | nilfs_checkpoint_##name(const struct nilfs_checkpoint *cp) \ |
| 560 | { \ |
| 561 | return !!(le32_to_cpu(cp->cp_flags) & \ |
| 562 | (1UL << NILFS_CHECKPOINT_##flag)); \ |
| 563 | } |
| 564 | |
| 565 | NILFS_CHECKPOINT_FNS(SNAPSHOT, snapshot) |
| 566 | NILFS_CHECKPOINT_FNS(INVALID, invalid) |
Ryusuke Konishi | c96fa46 | 2009-04-06 19:01:57 -0700 | [diff] [blame] | 567 | NILFS_CHECKPOINT_FNS(MINOR, minor) |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 568 | |
| 569 | /** |
| 570 | * struct nilfs_cpinfo - checkpoint information |
| 571 | * @ci_flags: flags |
Ryusuke Konishi | dc498d0 | 2009-04-06 19:01:52 -0700 | [diff] [blame] | 572 | * @ci_pad: padding |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 573 | * @ci_cno: checkpoint number |
| 574 | * @ci_create: creation timestamp |
| 575 | * @ci_nblk_inc: number of blocks incremented by this checkpoint |
| 576 | * @ci_inodes_count: inodes count |
| 577 | * @ci_blocks_count: blocks count |
| 578 | * @ci_next: next checkpoint number in snapshot list |
| 579 | */ |
| 580 | struct nilfs_cpinfo { |
| 581 | __u32 ci_flags; |
Ryusuke Konishi | dc498d0 | 2009-04-06 19:01:52 -0700 | [diff] [blame] | 582 | __u32 ci_pad; |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 583 | __u64 ci_cno; |
| 584 | __u64 ci_create; |
| 585 | __u64 ci_nblk_inc; |
| 586 | __u64 ci_inodes_count; |
| 587 | __u64 ci_blocks_count; |
| 588 | __u64 ci_next; |
| 589 | }; |
| 590 | |
| 591 | #define NILFS_CPINFO_FNS(flag, name) \ |
| 592 | static inline int \ |
| 593 | nilfs_cpinfo_##name(const struct nilfs_cpinfo *cpinfo) \ |
| 594 | { \ |
| 595 | return !!(cpinfo->ci_flags & (1UL << NILFS_CHECKPOINT_##flag)); \ |
| 596 | } |
| 597 | |
| 598 | NILFS_CPINFO_FNS(SNAPSHOT, snapshot) |
| 599 | NILFS_CPINFO_FNS(INVALID, invalid) |
Ryusuke Konishi | c96fa46 | 2009-04-06 19:01:57 -0700 | [diff] [blame] | 600 | NILFS_CPINFO_FNS(MINOR, minor) |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 601 | |
| 602 | |
| 603 | /** |
| 604 | * struct nilfs_cpfile_header - checkpoint file header |
| 605 | * @ch_ncheckpoints: number of checkpoints |
| 606 | * @ch_nsnapshots: number of snapshots |
| 607 | * @ch_snapshot_list: snapshot list |
| 608 | */ |
| 609 | struct nilfs_cpfile_header { |
| 610 | __le64 ch_ncheckpoints; |
| 611 | __le64 ch_nsnapshots; |
| 612 | struct nilfs_snapshot_list ch_snapshot_list; |
| 613 | }; |
| 614 | |
| 615 | #define NILFS_CPFILE_FIRST_CHECKPOINT_OFFSET \ |
| 616 | ((sizeof(struct nilfs_cpfile_header) + \ |
| 617 | sizeof(struct nilfs_checkpoint) - 1) / \ |
| 618 | sizeof(struct nilfs_checkpoint)) |
| 619 | |
| 620 | /** |
| 621 | * struct nilfs_segment_usage - segment usage |
| 622 | * @su_lastmod: last modified timestamp |
| 623 | * @su_nblocks: number of blocks in segment |
| 624 | * @su_flags: flags |
| 625 | */ |
| 626 | struct nilfs_segment_usage { |
| 627 | __le64 su_lastmod; |
| 628 | __le32 su_nblocks; |
| 629 | __le32 su_flags; |
| 630 | }; |
| 631 | |
| 632 | /* segment usage flag */ |
| 633 | enum { |
| 634 | NILFS_SEGMENT_USAGE_ACTIVE, |
| 635 | NILFS_SEGMENT_USAGE_DIRTY, |
| 636 | NILFS_SEGMENT_USAGE_ERROR, |
| 637 | |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 638 | /* ... */ |
| 639 | }; |
| 640 | |
| 641 | #define NILFS_SEGMENT_USAGE_FNS(flag, name) \ |
| 642 | static inline void \ |
| 643 | nilfs_segment_usage_set_##name(struct nilfs_segment_usage *su) \ |
| 644 | { \ |
| 645 | su->su_flags = cpu_to_le32(le32_to_cpu(su->su_flags) | \ |
| 646 | (1UL << NILFS_SEGMENT_USAGE_##flag));\ |
| 647 | } \ |
| 648 | static inline void \ |
| 649 | nilfs_segment_usage_clear_##name(struct nilfs_segment_usage *su) \ |
| 650 | { \ |
| 651 | su->su_flags = \ |
| 652 | cpu_to_le32(le32_to_cpu(su->su_flags) & \ |
| 653 | ~(1UL << NILFS_SEGMENT_USAGE_##flag)); \ |
| 654 | } \ |
| 655 | static inline int \ |
| 656 | nilfs_segment_usage_##name(const struct nilfs_segment_usage *su) \ |
| 657 | { \ |
| 658 | return !!(le32_to_cpu(su->su_flags) & \ |
| 659 | (1UL << NILFS_SEGMENT_USAGE_##flag)); \ |
| 660 | } |
| 661 | |
| 662 | NILFS_SEGMENT_USAGE_FNS(ACTIVE, active) |
| 663 | NILFS_SEGMENT_USAGE_FNS(DIRTY, dirty) |
| 664 | NILFS_SEGMENT_USAGE_FNS(ERROR, error) |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 665 | |
| 666 | static inline void |
| 667 | nilfs_segment_usage_set_clean(struct nilfs_segment_usage *su) |
| 668 | { |
| 669 | su->su_lastmod = cpu_to_le64(0); |
| 670 | su->su_nblocks = cpu_to_le32(0); |
| 671 | su->su_flags = cpu_to_le32(0); |
| 672 | } |
| 673 | |
| 674 | static inline int |
| 675 | nilfs_segment_usage_clean(const struct nilfs_segment_usage *su) |
| 676 | { |
| 677 | return !le32_to_cpu(su->su_flags); |
| 678 | } |
| 679 | |
| 680 | /** |
| 681 | * struct nilfs_sufile_header - segment usage file header |
| 682 | * @sh_ncleansegs: number of clean segments |
| 683 | * @sh_ndirtysegs: number of dirty segments |
| 684 | * @sh_last_alloc: last allocated segment number |
| 685 | */ |
| 686 | struct nilfs_sufile_header { |
| 687 | __le64 sh_ncleansegs; |
| 688 | __le64 sh_ndirtysegs; |
| 689 | __le64 sh_last_alloc; |
| 690 | /* ... */ |
| 691 | }; |
| 692 | |
| 693 | #define NILFS_SUFILE_FIRST_SEGMENT_USAGE_OFFSET \ |
| 694 | ((sizeof(struct nilfs_sufile_header) + \ |
| 695 | sizeof(struct nilfs_segment_usage) - 1) / \ |
| 696 | sizeof(struct nilfs_segment_usage)) |
| 697 | |
| 698 | /** |
| 699 | * nilfs_suinfo - segment usage information |
| 700 | * @sui_lastmod: |
| 701 | * @sui_nblocks: |
| 702 | * @sui_flags: |
| 703 | */ |
| 704 | struct nilfs_suinfo { |
| 705 | __u64 sui_lastmod; |
| 706 | __u32 sui_nblocks; |
| 707 | __u32 sui_flags; |
| 708 | }; |
| 709 | |
| 710 | #define NILFS_SUINFO_FNS(flag, name) \ |
| 711 | static inline int \ |
| 712 | nilfs_suinfo_##name(const struct nilfs_suinfo *si) \ |
| 713 | { \ |
| 714 | return si->sui_flags & (1UL << NILFS_SEGMENT_USAGE_##flag); \ |
| 715 | } |
| 716 | |
| 717 | NILFS_SUINFO_FNS(ACTIVE, active) |
| 718 | NILFS_SUINFO_FNS(DIRTY, dirty) |
| 719 | NILFS_SUINFO_FNS(ERROR, error) |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 720 | |
| 721 | static inline int nilfs_suinfo_clean(const struct nilfs_suinfo *si) |
| 722 | { |
| 723 | return !si->sui_flags; |
| 724 | } |
| 725 | |
| 726 | /* ioctl */ |
| 727 | enum { |
| 728 | NILFS_CHECKPOINT, |
| 729 | NILFS_SNAPSHOT, |
| 730 | }; |
| 731 | |
| 732 | /** |
| 733 | * struct nilfs_cpmode - |
| 734 | * @cc_cno: |
| 735 | * @cc_mode: |
| 736 | */ |
| 737 | struct nilfs_cpmode { |
| 738 | __u64 cm_cno; |
Ryusuke Konishi | dc498d0 | 2009-04-06 19:01:52 -0700 | [diff] [blame] | 739 | __u32 cm_mode; |
| 740 | __u32 cm_pad; |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 741 | }; |
| 742 | |
| 743 | /** |
| 744 | * struct nilfs_argv - argument vector |
| 745 | * @v_base: |
| 746 | * @v_nmembs: |
| 747 | * @v_size: |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 748 | * @v_flags: |
Ryusuke Konishi | dc498d0 | 2009-04-06 19:01:52 -0700 | [diff] [blame] | 749 | * @v_index: |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 750 | */ |
| 751 | struct nilfs_argv { |
Ryusuke Konishi | dc498d0 | 2009-04-06 19:01:52 -0700 | [diff] [blame] | 752 | __u64 v_base; |
| 753 | __u32 v_nmembs; /* number of members */ |
| 754 | __u16 v_size; /* size of members */ |
| 755 | __u16 v_flags; |
| 756 | __u64 v_index; |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 757 | }; |
| 758 | |
| 759 | /** |
| 760 | * struct nilfs_period - |
| 761 | * @p_start: |
| 762 | * @p_end: |
| 763 | */ |
| 764 | struct nilfs_period { |
| 765 | __u64 p_start; |
| 766 | __u64 p_end; |
| 767 | }; |
| 768 | |
| 769 | /** |
| 770 | * struct nilfs_cpstat - |
| 771 | * @cs_cno: checkpoint number |
| 772 | * @cs_ncps: number of checkpoints |
| 773 | * @cs_nsss: number of snapshots |
| 774 | */ |
| 775 | struct nilfs_cpstat { |
| 776 | __u64 cs_cno; |
| 777 | __u64 cs_ncps; |
| 778 | __u64 cs_nsss; |
| 779 | }; |
| 780 | |
| 781 | /** |
| 782 | * struct nilfs_sustat - |
| 783 | * @ss_nsegs: number of segments |
| 784 | * @ss_ncleansegs: number of clean segments |
| 785 | * @ss_ndirtysegs: number of dirty segments |
Ryusuke Konishi | 2c2e52f | 2009-04-06 19:01:54 -0700 | [diff] [blame] | 786 | * @ss_ctime: creation time of the last segment |
| 787 | * @ss_nongc_ctime: creation time of the last segment not for GC |
| 788 | * @ss_prot_seq: least sequence number of segments which must not be reclaimed |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 789 | */ |
| 790 | struct nilfs_sustat { |
| 791 | __u64 ss_nsegs; |
| 792 | __u64 ss_ncleansegs; |
| 793 | __u64 ss_ndirtysegs; |
Ryusuke Konishi | dc498d0 | 2009-04-06 19:01:52 -0700 | [diff] [blame] | 794 | __u64 ss_ctime; |
| 795 | __u64 ss_nongc_ctime; |
Ryusuke Konishi | 2c2e52f | 2009-04-06 19:01:54 -0700 | [diff] [blame] | 796 | __u64 ss_prot_seq; |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 797 | }; |
| 798 | |
| 799 | /** |
| 800 | * struct nilfs_vinfo - virtual block number information |
| 801 | * @vi_vblocknr: |
| 802 | * @vi_start: |
| 803 | * @vi_end: |
| 804 | * @vi_blocknr: |
| 805 | */ |
| 806 | struct nilfs_vinfo { |
| 807 | __u64 vi_vblocknr; |
| 808 | __u64 vi_start; |
| 809 | __u64 vi_end; |
| 810 | __u64 vi_blocknr; |
| 811 | }; |
| 812 | |
| 813 | /** |
| 814 | * struct nilfs_vdesc - |
| 815 | */ |
| 816 | struct nilfs_vdesc { |
| 817 | __u64 vd_ino; |
| 818 | __u64 vd_cno; |
| 819 | __u64 vd_vblocknr; |
| 820 | struct nilfs_period vd_period; |
| 821 | __u64 vd_blocknr; |
| 822 | __u64 vd_offset; |
| 823 | __u32 vd_flags; |
Ryusuke Konishi | dc498d0 | 2009-04-06 19:01:52 -0700 | [diff] [blame] | 824 | __u32 vd_pad; |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 825 | }; |
| 826 | |
| 827 | /** |
| 828 | * struct nilfs_bdesc - |
| 829 | */ |
| 830 | struct nilfs_bdesc { |
| 831 | __u64 bd_ino; |
| 832 | __u64 bd_oblocknr; |
| 833 | __u64 bd_blocknr; |
| 834 | __u64 bd_offset; |
| 835 | __u32 bd_level; |
Ryusuke Konishi | dc498d0 | 2009-04-06 19:01:52 -0700 | [diff] [blame] | 836 | __u32 bd_pad; |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 837 | }; |
| 838 | |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 839 | #define NILFS_IOCTL_IDENT 'n' |
| 840 | |
| 841 | #define NILFS_IOCTL_CHANGE_CPMODE \ |
| 842 | _IOW(NILFS_IOCTL_IDENT, 0x80, struct nilfs_cpmode) |
| 843 | #define NILFS_IOCTL_DELETE_CHECKPOINT \ |
| 844 | _IOW(NILFS_IOCTL_IDENT, 0x81, __u64) |
| 845 | #define NILFS_IOCTL_GET_CPINFO \ |
| 846 | _IOR(NILFS_IOCTL_IDENT, 0x82, struct nilfs_argv) |
| 847 | #define NILFS_IOCTL_GET_CPSTAT \ |
| 848 | _IOR(NILFS_IOCTL_IDENT, 0x83, struct nilfs_cpstat) |
| 849 | #define NILFS_IOCTL_GET_SUINFO \ |
| 850 | _IOR(NILFS_IOCTL_IDENT, 0x84, struct nilfs_argv) |
| 851 | #define NILFS_IOCTL_GET_SUSTAT \ |
| 852 | _IOR(NILFS_IOCTL_IDENT, 0x85, struct nilfs_sustat) |
| 853 | #define NILFS_IOCTL_GET_VINFO \ |
| 854 | _IOWR(NILFS_IOCTL_IDENT, 0x86, struct nilfs_argv) |
| 855 | #define NILFS_IOCTL_GET_BDESCS \ |
| 856 | _IOWR(NILFS_IOCTL_IDENT, 0x87, struct nilfs_argv) |
| 857 | #define NILFS_IOCTL_CLEAN_SEGMENTS \ |
| 858 | _IOW(NILFS_IOCTL_IDENT, 0x88, struct nilfs_argv[5]) |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 859 | #define NILFS_IOCTL_SYNC \ |
| 860 | _IOR(NILFS_IOCTL_IDENT, 0x8A, __u64) |
| 861 | #define NILFS_IOCTL_RESIZE \ |
| 862 | _IOW(NILFS_IOCTL_IDENT, 0x8B, __u64) |
| 863 | |
Koji Sato | eed10e3 | 2009-04-06 19:01:21 -0700 | [diff] [blame] | 864 | #endif /* _LINUX_NILFS_FS_H */ |