1 /* 2 * Copyright (c) 2012-2013 Paulo Alcantara <pcacjr (at) zytor.com> 3 * 4 * Some parts borrowed from Linux kernel tree (linux/fs/xfs): 5 * 6 * Copyright (c) 2000-2005 Silicon Graphics, Inc. 7 * All Rights Reserved. 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License as 11 * published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it would be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write the Free Software Foundation, 20 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 21 */ 22 23 #ifndef XFS_H_ 24 #define XFS_H_ 25 26 #include <disk.h> 27 #include <fs.h> 28 #include <dprintf.h> 29 30 #include "xfs_types.h" 31 #include "xfs_ag.h" 32 33 #define xfs_error(fmt, args...) \ 34 ({ \ 35 printf("%s:%u: xfs - [ERROR] " fmt "\n", __func__, __LINE__, ## args); \ 36 }) 37 38 #define xfs_debug(fmt, args...) \ 39 ({ \ 40 dprintf("%s:%u: xfs - [DEBUG] " fmt "\n", __func__, __LINE__, \ 41 ## args); \ 42 }) 43 44 struct xfs_fs_info; 45 46 #define XFS_INFO(fs) ((struct xfs_fs_info *)((fs)->fs_info)) 47 #define XFS_PVT(ino) ((struct xfs_inode *)((ino)->pvt)) 48 49 #define XFS_INO_MASK(k) (uint32_t)((1ULL << (k)) - 1) 50 #define XFS_INO_OFFSET_BITS(fs) (fs)->inopb_shift 51 #define XFS_INO_AGINO_BITS(fs) \ 52 (XFS_INFO((fs))->inopb_shift + XFS_INFO((fs))->agblk_shift) 53 54 #define XFS_INO_TO_AGINO(fs, i) \ 55 ((xfs_agino_t)(i) & XFS_INO_MASK(XFS_INO_AGINO_BITS(fs))) 56 57 #define XFS_INO_TO_AGNO(fs, ino) \ 58 ((xfs_agnumber_t)((ino) >> (XFS_INFO((fs))->inopb_shift + \ 59 XFS_INFO((fs))->agblk_shift))) 60 61 #define XFS_INO_TO_OFFSET(fs, i) \ 62 ((int)(i) & XFS_INO_MASK(XFS_INO_OFFSET_BITS(fs))) 63 64 #define XFS_AGNO_TO_FSB(fs, agno) \ 65 ((block_t)((agno) << XFS_INFO((fs))->agblocks_shift)) 66 67 #define XFS_AGI_OFFS(fs, mp) \ 68 ((xfs_agi_t *)((uint8_t *)(mp) + 2 * SECTOR_SIZE((fs)))) 69 70 #define XFS_GET_DIR_INO4(di) \ 71 (((uint32_t)(di).i[0] << 24) | ((di).i[1] << 16) | ((di).i[2] << 8) | \ 72 ((di).i[3])) 73 74 #define XFS_DI_HI(di) \ 75 (((uint32_t)(di).i[1] << 16) | ((di).i[2] << 8) | ((di).i[3])) 76 77 #define XFS_DI_LO(di) \ 78 (((uint32_t)(di).i[4] << 24) | ((di).i[5] << 16) | ((di).i[6] << 8) | \ 79 ((di).i[7])) 80 81 #define XFS_GET_DIR_INO8(di) \ 82 (((xfs_ino_t)XFS_DI_LO(di) & 0xffffffffULL) | \ 83 ((xfs_ino_t)XFS_DI_HI(di) << 32)) 84 85 #define XFS_FSB_TO_AGNO(fs, fsbno) \ 86 ((xfs_agnumber_t)((fsbno) >> XFS_INFO((fs))->agblk_shift)) 87 #define XFS_FSB_TO_AGBNO(fs, fsbno) \ 88 ((xfs_agblock_t)((fsbno) & (uint32_t)((1ULL << \ 89 XFS_INFO((fs))->agblk_shift) - 1))) 90 91 #define agblock_to_bytes(fs, x) \ 92 ((uint64_t)(x) << BLOCK_SHIFT((fs))) 93 #define agino_to_bytes(fs, x) \ 94 ((uint64_t)(x) << XFS_INFO((fs))->inode_shift) 95 #define agnumber_to_bytes(fs, x) \ 96 agblock_to_bytes(fs, (uint64_t)(x) * XFS_INFO((fs))->agblocks) 97 #define fsblock_to_bytes(fs,x) \ 98 (agnumber_to_bytes(fs, XFS_FSB_TO_AGNO(fs, (x))) + \ 99 agblock_to_bytes(fs, XFS_FSB_TO_AGBNO(fs, (x)))) 100 #define ino_to_bytes(fs, x) \ 101 (agnumber_to_bytes(fs, XFS_INO_TO_AGNO(fs, (x))) + \ 102 agino_to_bytes(fs, XFS_INO_TO_AGINO(fs, (x)))) 103 104 /* Superblock's LBA */ 105 #define XFS_SB_DADDR ((xfs_daddr_t)0) /* daddr in filesystem/ag */ 106 107 /* Magic numbers */ 108 #define XFS_AGI_MAGIC "XAGI" 109 #define XFS_IBT_MAGIC "IABT" 110 #define XFS_DINODE_MAGIC "IN" 111 112 #define XFS_DIR2_BLOCK_MAGIC 0x58443242U /* XD2B: single block dirs */ 113 #define XFS_DIR2_DATA_MAGIC 0x58443244U /* XD2D: multiblock dirs */ 114 #define XFS_DIR2_FREE_MAGIC 0x58443246U /* XD2F: free index blocks */ 115 116 #define XFS_DIR2_NULL_DATAPTR ((uint32_t)0) 117 118 /* File types and modes */ 119 #define S_IFMT 00170000 120 #define S_IFSOCK 0140000 121 #define S_IFLNK 0120000 122 #define S_IFREG 0100000 123 #define S_IFBLK 0060000 124 #define S_IFDIR 0040000 125 #define S_IFCHR 0020000 126 #define S_IFIFO 0010000 127 #define S_ISUID 0004000 128 #define S_ISGID 0002000 129 #define S_ISVTX 0001000 130 131 #define MAXPATHLEN 1024 132 /* 133 * NOTE: The fields in the superblock are stored in big-endian format on disk. 134 */ 135 typedef struct xfs_sb { 136 uint32_t sb_magicnum; /* magic number == XFS_SB_MAGIC */ 137 uint32_t sb_blocksize; /* logical block size, bytes */ 138 xfs_drfsbno_t sb_dblocks; /* number of data blocks */ 139 xfs_drfsbno_t sb_rblocks; /* number of realtime blocks */ 140 xfs_drtbno_t sb_rextents; /* number of realtime extents */ 141 uuid_t sb_uuid; /* file system unique id */ 142 xfs_dfsbno_t sb_logstart; /* starting block of log if internal */ 143 xfs_ino_t sb_rootino; /* root inode number */ 144 xfs_ino_t sb_rbmino; /* bitmap inode for realtime extents */ 145 xfs_ino_t sb_rsumino; /* summary inode for rt bitmap */ 146 xfs_agblock_t sb_rextsize; /* realtime extent size, blocks */ 147 xfs_agblock_t sb_agblocks; /* size of an allocation group */ 148 xfs_agnumber_t sb_agcount; /* number of allocation groups */ 149 xfs_extlen_t sb_rbmblocks; /* number of rt bitmap blocks */ 150 xfs_extlen_t sb_logblocks; /* number of log blocks */ 151 uint16_t sb_versionnum; /* header version == XFS_SB_VERSION */ 152 uint16_t sb_sectsize; /* volume sector size, bytes */ 153 uint16_t sb_inodesize; /* inode size, bytes */ 154 uint16_t sb_inopblock; /* inodes per block */ 155 char sb_fname[12]; /* file system name */ 156 uint8_t sb_blocklog; /* log2 of sb_blocksize */ 157 uint8_t sb_sectlog; /* log2 of sb_sectsize */ 158 uint8_t sb_inodelog; /* log2 of sb_inodesize */ 159 uint8_t sb_inopblog; /* log2 of sb_inopblock */ 160 uint8_t sb_agblklog; /* log2 of sb_agblocks (rounded up) */ 161 uint8_t sb_rextslog; /* log2 of sb_rextents */ 162 uint8_t sb_inprogress; /* mkfs is in progress, don't mount */ 163 uint8_t sb_imax_pct; /* max % of fs for inode space */ 164 /* statistics */ 165 /* 166 * These fields must remain contiguous. If you really 167 * want to change their layout, make sure you fix the 168 * code in xfs_trans_apply_sb_deltas(). 169 */ 170 uint64_t sb_icount; /* allocated inodes */ 171 uint64_t sb_ifree; /* free inodes */ 172 uint64_t sb_fdblocks; /* free data blocks */ 173 uint64_t sb_frextents; /* free realtime extents */ 174 /* 175 * End contiguous fields. 176 */ 177 xfs_ino_t sb_uquotino; /* user quota inode */ 178 xfs_ino_t sb_gquotino; /* group quota inode */ 179 uint16_t sb_qflags; /* quota flags */ 180 uint8_t sb_flags; /* misc. flags */ 181 uint8_t sb_shared_vn; /* shared version number */ 182 xfs_extlen_t sb_inoalignmt; /* inode chunk alignment, fsblocks */ 183 uint32_t sb_unit; /* stripe or raid unit */ 184 uint32_t sb_width; /* stripe or raid width */ 185 uint8_t sb_dirblklog; /* log2 of dir block size (fsbs) */ 186 uint8_t sb_logsectlog; /* log2 of the log sector size */ 187 uint16_t sb_logsectsize; /* sector size for the log, bytes */ 188 uint32_t sb_logsunit; /* stripe unit size for the log */ 189 uint32_t sb_features2; /* additional feature bits */ 190 191 /* 192 * bad features2 field as a result of failing to pad the sb 193 * structure to 64 bits. Some machines will be using this field 194 * for features2 bits. Easiest just to mark it bad and not use 195 * it for anything else. 196 */ 197 uint32_t sb_bad_features2; 198 uint8_t pad[304]; /* must be padded to a sector boundary */ 199 } __attribute__((__packed__)) xfs_sb_t; 200 201 /* In-memory structure that stores filesystem-specific information. 202 * The information stored is basically retrieved from the XFS superblock 203 * to be used statically around the driver. 204 */ 205 struct xfs_fs_info { 206 uint32_t blocksize; /* Filesystem block size */ 207 uint8_t block_shift; /* Filesystem block size in bits */ 208 uint32_t dirblksize; 209 uint8_t dirblklog; 210 uint8_t inopb_shift; 211 uint8_t agblk_shift; 212 uint32_t dirleafblk; 213 214 /* AG number bits (MSB of the inode number) */ 215 uint8_t ag_number_ino_shift; 216 217 xfs_ino_t rootino; /* Root inode number for the filesystem */ 218 xfs_agblock_t agblocks; /* Size of each AG in blocks */ 219 uint8_t agblocks_shift; /* agblocks in bits */ 220 xfs_agnumber_t agcount; /* Number of AGs in the filesytem */ 221 uint16_t inodesize; /* Size of the inode in bytes */ 222 uint8_t inode_shift; /* Inode size in bits */ 223 } __attribute__((__packed__)); 224 225 typedef struct xfs_agi { 226 /* 227 * Common allocation group header information 228 */ 229 uint32_t agi_magicnum; /* magic number == XFS_AGI_MAGIC */ 230 uint32_t agi_versionnum; /* header version == XFS_AGI_VERSION */ 231 uint32_t agi_seqno; /* sequence # starting from 0 */ 232 uint32_t agi_length; /* size in blocks of a.g. */ 233 /* 234 * Inode information 235 * Inodes are mapped by interpreting the inode number, so no 236 * mapping data is needed here. 237 */ 238 uint32_t agi_count; /* count of allocated inodes */ 239 uint32_t agi_root; /* root of inode btree */ 240 uint32_t agi_level; /* levels in inode btree */ 241 uint32_t agi_freecount; /* number of free inodes */ 242 uint32_t agi_newino; /* new inode just allocated */ 243 uint32_t agi_dirino; /* last directory inode chunk */ 244 /* 245 * Hash table of inodes which have been unlinked but are 246 * still being referenced. 247 */ 248 uint32_t agi_unlinked[XFS_AGI_UNLINKED_BUCKETS]; 249 } __attribute__((__packed__)) xfs_agi_t; 250 251 /* 252 * Bmap btree record and extent descriptor. 253 * l0:63 is an extent flag (value 1 indicates non-normal). 254 * l0:9-62 are startoff. 255 * l0:0-8 and l1:21-63 are startblock. 256 * l1:0-20 are blockcount. 257 */ 258 typedef struct xfs_bmbt_rec { 259 uint64_t l0; 260 uint64_t l1; 261 } __attribute__((__packed__)) xfs_bmbt_rec_t; 262 263 typedef xfs_bmbt_rec_t xfs_bmdr_rec_t; 264 265 /* 266 * Possible extent states. 267 */ 268 typedef enum { 269 XFS_EXT_NORM, 270 XFS_EXT_UNWRITTEN, 271 XFS_EXT_DMAPI_OFFLINE, 272 XFS_EXT_INVALID, 273 } xfs_exntst_t; 274 275 typedef struct xfs_bmbt_irec 276 { 277 xfs_fileoff_t br_startoff; /* starting file offset */ 278 xfs_fsblock_t br_startblock; /* starting block number */ 279 xfs_filblks_t br_blockcount; /* number of blocks */ 280 xfs_exntst_t br_state; /* extent state */ 281 } __attribute__((__packed__)) xfs_bmbt_irec_t; 282 283 static inline void bmbt_irec_get(xfs_bmbt_irec_t *dest, 284 const xfs_bmbt_rec_t *src) 285 { 286 uint64_t l0, l1; 287 288 l0 = be64_to_cpu(src->l0); 289 l1 = be64_to_cpu(src->l1); 290 291 dest->br_startoff = ((xfs_fileoff_t)l0 & 0x7ffffffffffffe00ULL) >> 9; 292 dest->br_startblock = (((xfs_fsblock_t)l0 & 0x00000000000001ffULL) << 43) | 293 (((xfs_fsblock_t)l1) >> 21); 294 dest->br_blockcount = (xfs_filblks_t)(l1 & 0x00000000001fffffULL); 295 dest->br_state = (l0 & 0x8000000000000000ULL) ? 296 XFS_EXT_UNWRITTEN : XFS_EXT_NORM; 297 } 298 299 typedef struct xfs_timestamp { 300 int32_t t_sec; 301 int32_t t_nsec; 302 } __attribute__((__packed__)) xfs_timestamp_t; 303 304 /* 305 * Fork identifiers. 306 */ 307 #define XFS_DATA_FORK 0 308 #define xFS_ATTR_FORK 1 309 310 typedef enum xfs_dinode_fmt { 311 XFS_DINODE_FMT_DEV, 312 XFS_DINODE_FMT_LOCAL, 313 XFS_DINODE_FMT_EXTENTS, 314 XFS_DINODE_FMT_BTREE, 315 XFS_DINODE_FMT_UUID, 316 } xfs_dinode_fmt_t; 317 318 typedef struct xfs_dinode { 319 uint16_t di_magic; /* inode magic # = XFS_DINODE_MAGIC */ 320 uint16_t di_mode; /* mode and type of file */ 321 uint8_t di_version; /* inode version */ 322 uint8_t di_format; /* format of di_c data */ 323 uint16_t di_onlink; /* old number of links to file */ 324 uint32_t di_uid; /* owner's user id */ 325 uint32_t di_gid; /* owner's group id */ 326 uint32_t di_nlink; /* number of links to file */ 327 uint16_t di_projid_lo; /* lower part of owner's project id */ 328 uint16_t di_projid_hi; /* higher part owner's project id */ 329 uint8_t di_pad[6]; /* unused, zeroed space */ 330 uint16_t di_flushiter; /* incremented on flush */ 331 xfs_timestamp_t di_atime; /* time last accessed */ 332 xfs_timestamp_t di_mtime; /* time last modified */ 333 xfs_timestamp_t di_ctime; /* time created/inode modified */ 334 uint64_t di_size; /* number of bytes in file */ 335 uint64_t di_nblocks; /* # of direct & btree blocks used */ 336 uint32_t di_extsize; /* basic/minimum extent size for file */ 337 uint32_t di_nextents; /* number of extents in data fork */ 338 uint16_t di_anextents; /* number of extents in attribute fork*/ 339 uint8_t di_forkoff; /* attr fork offs, <<3 for 64b align */ 340 int8_t di_aformat; /* format of attr fork's data */ 341 uint32_t di_dmevmask; /* DMIG event mask */ 342 uint16_t di_dmstate; /* DMIG state info */ 343 uint16_t di_flags; /* random flags, XFS_DIFLAG_... */ 344 uint32_t di_gen; /* generation number */ 345 346 /* di_next_unlinked is the only non-core field in the old dinode */ 347 uint32_t di_next_unlinked;/* agi unlinked list ptr */ 348 uint8_t di_literal_area[1]; 349 } __attribute__((packed)) xfs_dinode_t; 350 351 /* 352 * Inode size for given fs. 353 */ 354 #define XFS_LITINO(fs) \ 355 ((int)((XFS_INFO(fs)->inodesize) - sizeof(struct xfs_dinode) - 1)) 356 357 #define XFS_BROOT_SIZE_ADJ \ 358 (XFS_BTREE_LBLOCK_LEN - sizeof(xfs_bmdr_block_t)) 359 360 /* 361 * Inode data & attribute fork sizes, per inode. 362 */ 363 #define XFS_DFORK_Q(dip) ((dip)->di_forkoff != 0) 364 #define XFS_DFORK_BOFF(dip) ((int)((dip)->di_forkoff << 3)) 365 366 #define XFS_DFORK_DSIZE(dip, fs) \ 367 (XFS_DFORK_Q(dip) ? \ 368 XFS_DFORK_BOFF(dip) : \ 369 XFS_LITINO(fs)) 370 #define XFS_DFORK_ASIZE(dip, fs) \ 371 (XFS_DFORK_Q(dip) ? \ 372 XFS_LITINO(fs) - XFS_DFORK_BOFF(dip) : \ 373 0) 374 #define XFS_DFORK_SIZE(dip, fs, w) \ 375 ((w) == XFS_DATA_FORK ? \ 376 XFS_DFORK_DSIZE(dip, fs) : \ 377 XFS_DFORK_ASIZE(dip, fs)) 378 379 struct xfs_inode { 380 xfs_agblock_t i_agblock; 381 block_t i_ino_blk; 382 uint64_t i_block_offset; 383 uint64_t i_offset; 384 uint32_t i_cur_extent; 385 uint32_t i_btree_offset; 386 uint16_t i_leaf_ent_offset; 387 }; 388 389 typedef struct { uint8_t i[8]; } __attribute__((__packed__)) xfs_dir2_ino8_t; 390 typedef struct { uint8_t i[4]; } __attribute__((__packed__)) xfs_dir2_ino4_t; 391 392 typedef union { 393 xfs_dir2_ino8_t i8; 394 xfs_dir2_ino4_t i4; 395 } __attribute__((__packed__)) xfs_dir2_inou_t; 396 397 typedef struct { uint8_t i[2]; } __attribute__((__packed__)) xfs_dir2_sf_off_t; 398 399 typedef struct xfs_dir2_sf_hdr { 400 uint8_t count; /* count of entries */ 401 uint8_t i8count; /* count of 8-byte inode #s */ 402 xfs_dir2_inou_t parent; /* parent dir inode number */ 403 } __attribute__((__packed__)) xfs_dir2_sf_hdr_t; 404 405 typedef struct xfs_dir2_sf_entry { 406 uint8_t namelen; /* actual name length */ 407 xfs_dir2_sf_off_t offset; /* saved offset */ 408 uint8_t name[1]; /* name, variable size */ 409 xfs_dir2_inou_t inumber; /* inode number, var. offset */ 410 } __attribute__((__packed__)) xfs_dir2_sf_entry_t; 411 412 typedef struct xfs_dir2_sf { 413 xfs_dir2_sf_hdr_t hdr; /* shortform header */ 414 xfs_dir2_sf_entry_t list[1]; /* shortform entries */ 415 } __attribute__((__packed__)) xfs_dir2_sf_t; 416 417 typedef xfs_ino_t xfs_intino_t; 418 419 static inline xfs_intino_t xfs_dir2_sf_get_inumber(xfs_dir2_sf_t *sfp, 420 xfs_dir2_inou_t *from) 421 { 422 return ((sfp)->hdr.i8count == 0 ? \ 423 (xfs_intino_t)XFS_GET_DIR_INO4((from)->i4) : \ 424 (xfs_intino_t)XFS_GET_DIR_INO8((from)->i8)); 425 } 426 427 /* 428 * DIR2 Data block structures. 429 * 430 * A pure data block looks like the following drawing on disk: 431 * 432 * +-------------------------------------------------+ 433 * | xfs_dir2_data_hdr_t | 434 * +-------------------------------------------------+ 435 * | xfs_dir2_data_entry_t OR xfs_dir2_data_unused_t | 436 * | xfs_dir2_data_entry_t OR xfs_dir2_data_unused_t | 437 * | xfs_dir2_data_entry_t OR xfs_dir2_data_unused_t | 438 * | ... | 439 * +-------------------------------------------------+ 440 * | unused space | 441 * +-------------------------------------------------+ 442 * 443 * As all the entries are variable size structure the accessors below should 444 * be used to iterate over them. 445 * 446 * In addition to the pure data blocks for the data and node formats. 447 * most structures are also used for the combined data/freespace "block" 448 * format below. 449 */ 450 #define XFS_DIR2_DATA_ALIGN_LOG 3 451 #define XFS_DIR2_DATA_ALIGN (1 << XFS_DIR2_DATA_ALIGN_LOG) 452 #define XFS_DIR2_DATA_FREE_TAG 0xffff 453 #define XFS_DIR2_DATA_FD_COUNT 3 454 455 /* 456 * Directory address space divided into sections. 457 * spaces separated by 32GB. 458 */ 459 #define XFS_DIR2_SPACE_SIZE (1ULL << (32 + XFS_DIR2_DATA_ALIGN_LOG)) 460 461 typedef struct xfs_dir2_data_free { 462 uint16_t offset; 463 uint16_t length; 464 } __attribute__((__packed__)) xfs_dir2_data_free_t; 465 466 typedef struct xfs_dir2_data_hdr { 467 uint32_t magic; 468 xfs_dir2_data_free_t bestfree[XFS_DIR2_DATA_FD_COUNT]; 469 } __attribute__((__packed__)) xfs_dir2_data_hdr_t; 470 471 typedef struct xfs_dir2_data_entry { 472 uint64_t inumber; /* inode number */ 473 uint8_t namelen; /* name length */ 474 uint8_t name[]; /* name types, no null */ 475 /* uint16_t tag; */ /* starting offset of us */ 476 } __attribute__((__packed__)) xfs_dir2_data_entry_t; 477 478 typedef struct xfs_dir2_data_unused { 479 uint16_t freetag; /* XFS_DIR2_DATA_FREE_TAG */ 480 uint16_t length; /* total free length */ 481 /* variable offset */ 482 /* uint16_t tag; */ /* starting offset of us */ 483 } __attribute__((__packed__)) xfs_dir2_data_unused_t; 484 485 /** 486 * rol32 - rotate a 32-bit value left 487 * @word: value to rotate 488 * @shift: bits to roll 489 */ 490 static inline uint32_t rol32(uint32_t word, signed int shift) 491 { 492 return (word << shift) | (word >> (32 - shift)); 493 } 494 495 #define roundup(x, y) ( \ 496 { \ 497 const typeof(y) __y = y; \ 498 (((x) + (__y - 1)) / __y) * __y; \ 499 } \ 500 ) 501 502 static inline int xfs_dir2_data_entsize(int n) 503 { 504 return (int)roundup(offsetof(struct xfs_dir2_data_entry, name[0]) + n + 505 (unsigned int)sizeof(uint16_t), XFS_DIR2_DATA_ALIGN); 506 } 507 508 static inline uint16_t * 509 xfs_dir2_data_entry_tag_p(struct xfs_dir2_data_entry *dep) 510 { 511 return (uint16_t *)((char *)dep + 512 xfs_dir2_data_entsize(dep->namelen) - sizeof(uint16_t)); 513 } 514 515 static inline uint16_t * 516 xfs_dir2_data_unused_tag_p(struct xfs_dir2_data_unused *dup) 517 { 518 return (uint16_t *)((char *)dup + 519 be16_to_cpu(dup->length) - sizeof(uint16_t)); 520 } 521 522 typedef struct xfs_dir2_block_tail { 523 uint32_t count; /* count of leaf entries */ 524 uint32_t stale; /* count of stale lf entries */ 525 } __attribute__((__packed__)) xfs_dir2_block_tail_t; 526 527 static inline struct xfs_dir2_block_tail * 528 xfs_dir2_block_tail_p(struct xfs_fs_info *fs_info, struct xfs_dir2_data_hdr *hdr) 529 { 530 return ((struct xfs_dir2_block_tail *) 531 ((char *)hdr + fs_info->dirblksize)) - 1; 532 } 533 534 static inline uint32_t 535 xfs_dir2_db_to_da(struct fs_info *fs, uint32_t db) 536 { 537 return db << XFS_INFO(fs)->dirblklog; 538 } 539 540 static inline int64_t 541 xfs_dir2_dataptr_to_byte(uint32_t dp) 542 { 543 return (int64_t)dp << XFS_DIR2_DATA_ALIGN_LOG; 544 } 545 546 static inline uint32_t 547 xfs_dir2_byte_to_db(struct fs_info *fs, int64_t by) 548 { 549 return (uint32_t) 550 (by >> (XFS_INFO(fs)->block_shift + XFS_INFO(fs)->dirblklog)); 551 } 552 553 static inline uint32_t 554 xfs_dir2_dataptr_to_db(struct fs_info *fs, uint32_t dp) 555 { 556 return xfs_dir2_byte_to_db(fs, xfs_dir2_dataptr_to_byte(dp)); 557 } 558 559 static inline unsigned int 560 xfs_dir2_byte_to_off(struct fs_info *fs, int64_t by) 561 { 562 return (unsigned int)(by & 563 (( 1 << (XFS_INFO(fs)->block_shift + XFS_INFO(fs)->dirblklog)) - 1)); 564 } 565 566 static inline unsigned int 567 xfs_dir2_dataptr_to_off(struct fs_info *fs, uint32_t dp) 568 { 569 return xfs_dir2_byte_to_off(fs, xfs_dir2_dataptr_to_byte(dp)); 570 } 571 572 #define XFS_DIR2_LEAF_SPACE 1 573 #define XFS_DIR2_LEAF_OFFSET (XFS_DIR2_LEAF_SPACE * XFS_DIR2_SPACE_SIZE) 574 #define XFS_DIR2_LEAF_FIRSTDB(fs) \ 575 xfs_dir2_byte_to_db(fs, XFS_DIR2_LEAF_OFFSET) 576 577 typedef struct xfs_da_blkinfo { 578 uint32_t forw; 579 uint32_t back; 580 uint16_t magic; 581 uint16_t pad; 582 } __attribute__((__packed__)) xfs_da_blkinfo_t; 583 584 typedef struct xfs_dir2_leaf_hdr { 585 xfs_da_blkinfo_t info; 586 uint16_t count; 587 uint16_t stale; 588 } __attribute__((__packed__)) xfs_dir2_leaf_hdr_t; 589 590 typedef struct xfs_dir2_leaf_entry { 591 uint32_t hashval; /* hash value of name */ 592 uint32_t address; /* address of data entry */ 593 } __attribute__((__packed__)) xfs_dir2_leaf_entry_t; 594 595 typedef struct xfs_dir2_leaf { 596 xfs_dir2_leaf_hdr_t hdr; /* leaf header */ 597 xfs_dir2_leaf_entry_t ents[]; /* entries */ 598 } __attribute__((__packed__)) xfs_dir2_leaf_t; 599 600 #define XFS_DA_NODE_MAGIC 0xfebeU /* magic number: non-leaf blocks */ 601 #define XFS_ATTR_LEAF_MAGIC 0xfbeeU /* magic number: attribute leaf blks */ 602 #define XFS_DIR2_LEAF1_MAGIC 0xd2f1U /* magic number: v2 dirlf single blks */ 603 #define XFS_DIR2_LEAFN_MAGIC 0xd2ffU /* magic number: V2 dirlf multi blks */ 604 605 typedef struct xfs_da_intnode { 606 struct xfs_da_node_hdr { /* constant-structure header block */ 607 xfs_da_blkinfo_t info; /* block type, links, etc. */ 608 uint16_t count; /* count of active entries */ 609 uint16_t level; /* level above leaves (leaf == 0) */ 610 } hdr; 611 struct xfs_da_node_entry { 612 uint32_t hashval; /* hash value for this descendant */ 613 uint32_t before; /* Btree block before this key */ 614 } btree[1]; 615 } __attribute__((__packed__)) xfs_da_intnode_t; 616 617 typedef struct xfs_da_node_hdr xfs_da_node_hdr_t; 618 typedef struct xfs_da_node_entry xfs_da_node_entry_t; 619 620 static inline bool xfs_is_valid_magicnum(const xfs_sb_t *sb) 621 { 622 return sb->sb_magicnum == *(uint32_t *)XFS_SB_MAGIC; 623 } 624 625 static inline bool xfs_is_valid_agi(xfs_agi_t *agi) 626 { 627 return agi->agi_magicnum == *(uint32_t *)XFS_AGI_MAGIC; 628 } 629 630 static inline struct inode *xfs_new_inode(struct fs_info *fs) 631 { 632 struct inode *inode; 633 634 inode = alloc_inode(fs, 0, sizeof(struct xfs_inode)); 635 if (!inode) 636 malloc_error("xfs_inode structure"); 637 638 return inode; 639 } 640 641 static inline void fill_xfs_inode_pvt(struct fs_info *fs, struct inode *inode, 642 xfs_ino_t ino) 643 { 644 XFS_PVT(inode)->i_agblock = 645 agnumber_to_bytes(fs, XFS_INO_TO_AGNO(fs, ino)) >> BLOCK_SHIFT(fs); 646 XFS_PVT(inode)->i_ino_blk = ino_to_bytes(fs, ino) >> BLOCK_SHIFT(fs); 647 XFS_PVT(inode)->i_block_offset = XFS_INO_TO_OFFSET(XFS_INFO(fs), ino) << 648 XFS_INFO(fs)->inode_shift; 649 } 650 651 /* 652 * Generic btree header. 653 * 654 * This is a combination of the actual format used on disk for short and long 655 * format btrees. The first three fields are shared by both format, but 656 * the pointers are different and should be used with care. 657 * 658 * To get the size of the actual short or long form headers please use 659 * the size macros belows. Never use sizeof(xfs_btree_block); 660 */ 661 typedef struct xfs_btree_block { 662 uint32_t bb_magic; /* magic number for block type */ 663 uint16_t bb_level; /* 0 is a leaf */ 664 uint16_t bb_numrecs; /* current # of data records */ 665 union { 666 struct { 667 uint32_t bb_leftsib; 668 uint32_t bb_rightsib; 669 } s; /* short form pointers */ 670 struct { 671 uint64_t bb_leftsib; 672 uint64_t bb_rightsib; 673 } l; /* long form pointers */ 674 } bb_u; /* rest */ 675 } xfs_btree_block_t; 676 677 #define XFS_BTREE_SBLOCK_LEN 16 /* size of a short form block */ 678 #define XFS_BTREE_LBLOCK_LEN 24 /* size of a long form block */ 679 680 /* 681 * Bmap root header, on-disk form only. 682 */ 683 typedef struct xfs_bmdr_block { 684 uint16_t bb_level; /* 0 is a leaf */ 685 uint16_t bb_numrecs; /* current # of data records */ 686 } xfs_bmdr_block_t; 687 688 /* 689 * Key structure for non-leaf levels of the tree. 690 */ 691 typedef struct xfs_bmbt_key { 692 uint64_t br_startoff; /* starting file offset */ 693 } xfs_bmbt_key_t, xfs_bmdr_key_t; 694 695 /* btree pointer type */ 696 typedef uint64_t xfs_bmbt_ptr_t, xfs_bmdr_ptr_t; 697 698 /* 699 * Btree block header size depends on a superblock flag. 700 * 701 * (not quite yet, but soon) 702 */ 703 #define XFS_BMBT_BLOCK_LEN(fs) XFS_BTREE_LBLOCK_LEN 704 705 #define XFS_BMBT_REC_ADDR(fs, block, index) \ 706 ((xfs_bmbt_rec_t *) \ 707 ((char *)(block) + \ 708 XFS_BMBT_BLOCK_LEN(fs) + \ 709 ((index) - 1) * sizeof(xfs_bmbt_rec_t))) 710 711 #define XFS_BMBT_KEY_ADDR(fs, block, index) \ 712 ((xfs_bmbt_key_t *) \ 713 ((char *)(block) + \ 714 XFS_BMBT_BLOCK_LEN(fs) + \ 715 ((index) - 1) * sizeof(xfs_bmbt_key_t))) 716 717 #define XFS_BMBT_PTR_ADDR(fs, block, index, maxrecs) \ 718 ((xfs_bmbt_ptr_t *) \ 719 ((char *)(block) + \ 720 XFS_BMBT_BLOCK_LEN(fs) + \ 721 (maxrecs) * sizeof(xfs_bmbt_key_t) + \ 722 ((index) - 1) * sizeof(xfs_bmbt_ptr_t))) 723 724 #define XFS_BMDR_REC_ADDR(block, index) \ 725 ((xfs_bmdr_rec_t *) \ 726 ((char *)(block) + \ 727 sizeof(struct xfs_bmdr_block) + \ 728 ((index) - 1) * sizeof(xfs_bmdr_rec_t))) 729 730 #define XFS_BMDR_KEY_ADDR(block, index) \ 731 ((xfs_bmdr_key_t *) \ 732 ((char *)(block) + \ 733 sizeof(struct xfs_bmdr_block) + \ 734 ((index) - 1) * sizeof(xfs_bmdr_key_t))) 735 736 #define XFS_BMDR_PTR_ADDR(block, index, maxrecs) \ 737 ((xfs_bmdr_ptr_t *) \ 738 ((char *)(block) + \ 739 sizeof(struct xfs_bmdr_block) + \ 740 (maxrecs) * sizeof(xfs_bmdr_key_t) + \ 741 ((index) - 1) * sizeof(xfs_bmdr_ptr_t))) 742 743 /* 744 * Calculate number of records in a bmap btree inode root. 745 */ 746 static inline int 747 xfs_bmdr_maxrecs(int blocklen, int leaf) 748 { 749 blocklen -= sizeof(xfs_bmdr_block_t); 750 751 if (leaf) 752 return blocklen / sizeof(xfs_bmdr_rec_t); 753 754 return blocklen / (sizeof(xfs_bmdr_key_t) + sizeof(xfs_bmdr_ptr_t)); 755 } 756 757 #endif /* XFS_H_ */ 758
