908 lines · c
1/* SPDX-License-Identifier: GPL-2.0 */2/*3 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.4 * Copyright (c) 2013 Red Hat, Inc.5 * All Rights Reserved.6 */7#ifndef __XFS_DA_FORMAT_H__8#define __XFS_DA_FORMAT_H__9 10/*11 * This structure is common to both leaf nodes and non-leaf nodes in the Btree.12 *13 * It is used to manage a doubly linked list of all blocks at the same14 * level in the Btree, and to identify which type of block this is.15 */16#define XFS_DA_NODE_MAGIC 0xfebe /* magic number: non-leaf blocks */17#define XFS_ATTR_LEAF_MAGIC 0xfbee /* magic number: attribute leaf blks */18#define XFS_DIR2_LEAF1_MAGIC 0xd2f1 /* magic number: v2 dirlf single blks */19#define XFS_DIR2_LEAFN_MAGIC 0xd2ff /* magic number: v2 dirlf multi blks */20 21typedef struct xfs_da_blkinfo {22 __be32 forw; /* previous block in list */23 __be32 back; /* following block in list */24 __be16 magic; /* validity check on block */25 __be16 pad; /* unused */26} xfs_da_blkinfo_t;27 28/*29 * CRC enabled directory structure types30 *31 * The headers change size for the additional verification information, but32 * otherwise the tree layouts and contents are unchanged. Hence the da btree33 * code can use the struct xfs_da_blkinfo for manipulating the tree links and34 * magic numbers without modification for both v2 and v3 nodes.35 */36#define XFS_DA3_NODE_MAGIC 0x3ebe /* magic number: non-leaf blocks */37#define XFS_ATTR3_LEAF_MAGIC 0x3bee /* magic number: attribute leaf blks */38#define XFS_DIR3_LEAF1_MAGIC 0x3df1 /* magic number: v3 dirlf single blks */39#define XFS_DIR3_LEAFN_MAGIC 0x3dff /* magic number: v3 dirlf multi blks */40 41struct xfs_da3_blkinfo {42 /*43 * the node link manipulation code relies on the fact that the first44 * element of this structure is the struct xfs_da_blkinfo so it can45 * ignore the differences in the rest of the structures.46 */47 struct xfs_da_blkinfo hdr;48 __be32 crc; /* CRC of block */49 __be64 blkno; /* first block of the buffer */50 __be64 lsn; /* sequence number of last write */51 uuid_t uuid; /* filesystem we belong to */52 __be64 owner; /* inode that owns the block */53};54 55/*56 * This is the structure of the root and intermediate nodes in the Btree.57 * The leaf nodes are defined above.58 *59 * Entries are not packed.60 *61 * Since we have duplicate keys, use a binary search but always follow62 * all match in the block, not just the first match found.63 */64#define XFS_DA_NODE_MAXDEPTH 5 /* max depth of Btree */65 66typedef struct xfs_da_node_hdr {67 struct xfs_da_blkinfo info; /* block type, links, etc. */68 __be16 __count; /* count of active entries */69 __be16 __level; /* level above leaves (leaf == 0) */70} xfs_da_node_hdr_t;71 72struct xfs_da3_node_hdr {73 struct xfs_da3_blkinfo info; /* block type, links, etc. */74 __be16 __count; /* count of active entries */75 __be16 __level; /* level above leaves (leaf == 0) */76 __be32 __pad32;77};78 79#define XFS_DA3_NODE_CRC_OFF (offsetof(struct xfs_da3_node_hdr, info.crc))80 81typedef struct xfs_da_node_entry {82 __be32 hashval; /* hash value for this descendant */83 __be32 before; /* Btree block before this key */84} xfs_da_node_entry_t;85 86typedef struct xfs_da_intnode {87 struct xfs_da_node_hdr hdr;88 struct xfs_da_node_entry __btree[];89} xfs_da_intnode_t;90 91struct xfs_da3_intnode {92 struct xfs_da3_node_hdr hdr;93 struct xfs_da_node_entry __btree[];94};95 96/*97 * Directory version 2.98 *99 * There are 4 possible formats:100 * - shortform - embedded into the inode101 * - single block - data with embedded leaf at the end102 * - multiple data blocks, single leaf+freeindex block103 * - data blocks, node and leaf blocks (btree), freeindex blocks104 *105 * Note: many node blocks structures and constants are shared with the attr106 * code and defined in xfs_da_btree.h.107 */108 109#define XFS_DIR2_BLOCK_MAGIC 0x58443242 /* XD2B: single block dirs */110#define XFS_DIR2_DATA_MAGIC 0x58443244 /* XD2D: multiblock dirs */111#define XFS_DIR2_FREE_MAGIC 0x58443246 /* XD2F: free index blocks */112 113/*114 * Directory Version 3 With CRCs.115 *116 * The tree formats are the same as for version 2 directories. The difference117 * is in the block header and dirent formats. In many cases the v3 structures118 * use v2 definitions as they are no different and this makes code sharing much119 * easier.120 *121 * Also, the xfs_dir3_*() functions handle both v2 and v3 formats - if the122 * format is v2 then they switch to the existing v2 code, or the format is v3123 * they implement the v3 functionality. This means the existing dir2 is a mix of124 * xfs_dir2/xfs_dir3 calls and functions. The xfs_dir3 functions are called125 * where there is a difference in the formats, otherwise the code is unchanged.126 *127 * Where it is possible, the code decides what to do based on the magic numbers128 * in the blocks rather than feature bits in the superblock. This means the code129 * is as independent of the external XFS code as possible as doesn't require130 * passing struct xfs_mount pointers into places where it isn't really131 * necessary.132 *133 * Version 3 includes:134 *135 * - a larger block header for CRC and identification purposes and so the136 * offsets of all the structures inside the blocks are different.137 *138 * - new magic numbers to be able to detect the v2/v3 types on the fly.139 */140 141#define XFS_DIR3_BLOCK_MAGIC 0x58444233 /* XDB3: single block dirs */142#define XFS_DIR3_DATA_MAGIC 0x58444433 /* XDD3: multiblock dirs */143#define XFS_DIR3_FREE_MAGIC 0x58444633 /* XDF3: free index blocks */144 145/*146 * Dirents in version 3 directories have a file type field. Additions to this147 * list are an on-disk format change, requiring feature bits. Valid values148 * are as follows:149 */150#define XFS_DIR3_FT_UNKNOWN 0151#define XFS_DIR3_FT_REG_FILE 1152#define XFS_DIR3_FT_DIR 2153#define XFS_DIR3_FT_CHRDEV 3154#define XFS_DIR3_FT_BLKDEV 4155#define XFS_DIR3_FT_FIFO 5156#define XFS_DIR3_FT_SOCK 6157#define XFS_DIR3_FT_SYMLINK 7158#define XFS_DIR3_FT_WHT 8159 160#define XFS_DIR3_FT_MAX 9161 162#define XFS_DIR3_FTYPE_STR \163 { XFS_DIR3_FT_UNKNOWN, "unknown" }, \164 { XFS_DIR3_FT_REG_FILE, "file" }, \165 { XFS_DIR3_FT_DIR, "directory" }, \166 { XFS_DIR3_FT_CHRDEV, "char" }, \167 { XFS_DIR3_FT_BLKDEV, "block" }, \168 { XFS_DIR3_FT_FIFO, "fifo" }, \169 { XFS_DIR3_FT_SOCK, "sock" }, \170 { XFS_DIR3_FT_SYMLINK, "symlink" }, \171 { XFS_DIR3_FT_WHT, "whiteout" }172 173/*174 * Byte offset in data block and shortform entry.175 */176typedef uint16_t xfs_dir2_data_off_t;177#define NULLDATAOFF 0xffffU178typedef uint xfs_dir2_data_aoff_t; /* argument form */179 180/*181 * Offset in data space of a data entry.182 */183typedef uint32_t xfs_dir2_dataptr_t;184#define XFS_DIR2_MAX_DATAPTR ((xfs_dir2_dataptr_t)0xffffffff)185#define XFS_DIR2_NULL_DATAPTR ((xfs_dir2_dataptr_t)0)186 187/*188 * Byte offset in a directory.189 */190typedef xfs_off_t xfs_dir2_off_t;191 192/*193 * Directory block number (logical dirblk in file)194 */195typedef uint32_t xfs_dir2_db_t;196 197#define XFS_INO32_SIZE 4198#define XFS_INO64_SIZE 8199#define XFS_INO64_DIFF (XFS_INO64_SIZE - XFS_INO32_SIZE)200 201#define XFS_DIR2_MAX_SHORT_INUM ((xfs_ino_t)0xffffffffULL)202 203/*204 * Directory layout when stored internal to an inode.205 *206 * Small directories are packed as tightly as possible so as to fit into the207 * literal area of the inode. These "shortform" directories consist of a208 * single xfs_dir2_sf_hdr header followed by zero or more xfs_dir2_sf_entry209 * structures. Due the different inode number storage size and the variable210 * length name field in the xfs_dir2_sf_entry all these structure are211 * variable length, and the accessors in this file should be used to iterate212 * over them.213 */214typedef struct xfs_dir2_sf_hdr {215 uint8_t count; /* count of entries */216 uint8_t i8count; /* count of 8-byte inode #s */217 uint8_t parent[8]; /* parent dir inode number */218} __packed xfs_dir2_sf_hdr_t;219 220typedef struct xfs_dir2_sf_entry {221 __u8 namelen; /* actual name length */222 __u8 offset[2]; /* saved offset */223 __u8 name[]; /* name, variable size */224 /*225 * A single byte containing the file type field follows the inode226 * number for version 3 directory entries.227 *228 * A 64-bit or 32-bit inode number follows here, at a variable offset229 * after the name.230 */231} __packed xfs_dir2_sf_entry_t;232 233static inline int xfs_dir2_sf_hdr_size(int i8count)234{235 return sizeof(struct xfs_dir2_sf_hdr) -236 (i8count == 0) * XFS_INO64_DIFF;237}238 239static inline xfs_dir2_data_aoff_t240xfs_dir2_sf_get_offset(xfs_dir2_sf_entry_t *sfep)241{242 return get_unaligned_be16(sfep->offset);243}244 245static inline void246xfs_dir2_sf_put_offset(xfs_dir2_sf_entry_t *sfep, xfs_dir2_data_aoff_t off)247{248 put_unaligned_be16(off, sfep->offset);249}250 251static inline struct xfs_dir2_sf_entry *252xfs_dir2_sf_firstentry(struct xfs_dir2_sf_hdr *hdr)253{254 return (struct xfs_dir2_sf_entry *)255 ((char *)hdr + xfs_dir2_sf_hdr_size(hdr->i8count));256}257 258/*259 * Data block structures.260 *261 * A pure data block looks like the following drawing on disk:262 *263 * +-------------------------------------------------+264 * | xfs_dir2_data_hdr_t |265 * +-------------------------------------------------+266 * | xfs_dir2_data_entry_t OR xfs_dir2_data_unused_t |267 * | xfs_dir2_data_entry_t OR xfs_dir2_data_unused_t |268 * | xfs_dir2_data_entry_t OR xfs_dir2_data_unused_t |269 * | ... |270 * +-------------------------------------------------+271 * | unused space |272 * +-------------------------------------------------+273 *274 * As all the entries are variable size structures the accessors below should275 * be used to iterate over them.276 *277 * In addition to the pure data blocks for the data and node formats,278 * most structures are also used for the combined data/freespace "block"279 * format below.280 */281 282#define XFS_DIR2_DATA_ALIGN_LOG 3 /* i.e., 8 bytes */283#define XFS_DIR2_DATA_ALIGN (1 << XFS_DIR2_DATA_ALIGN_LOG)284#define XFS_DIR2_DATA_FREE_TAG 0xffff285#define XFS_DIR2_DATA_FD_COUNT 3286 287/*288 * Directory address space divided into sections,289 * spaces separated by 32GB.290 */291#define XFS_DIR2_MAX_SPACES 3292#define XFS_DIR2_SPACE_SIZE (1ULL << (32 + XFS_DIR2_DATA_ALIGN_LOG))293#define XFS_DIR2_DATA_SPACE 0294#define XFS_DIR2_DATA_OFFSET (XFS_DIR2_DATA_SPACE * XFS_DIR2_SPACE_SIZE)295 296/*297 * Describe a free area in the data block.298 *299 * The freespace will be formatted as a xfs_dir2_data_unused_t.300 */301typedef struct xfs_dir2_data_free {302 __be16 offset; /* start of freespace */303 __be16 length; /* length of freespace */304} xfs_dir2_data_free_t;305 306/*307 * Header for the data blocks.308 *309 * The code knows that XFS_DIR2_DATA_FD_COUNT is 3.310 */311typedef struct xfs_dir2_data_hdr {312 __be32 magic; /* XFS_DIR2_DATA_MAGIC or */313 /* XFS_DIR2_BLOCK_MAGIC */314 xfs_dir2_data_free_t bestfree[XFS_DIR2_DATA_FD_COUNT];315} xfs_dir2_data_hdr_t;316 317/*318 * define a structure for all the verification fields we are adding to the319 * directory block structures. This will be used in several structures.320 * The magic number must be the first entry to align with all the dir2321 * structures so we determine how to decode them just by the magic number.322 */323struct xfs_dir3_blk_hdr {324 __be32 magic; /* magic number */325 __be32 crc; /* CRC of block */326 __be64 blkno; /* first block of the buffer */327 __be64 lsn; /* sequence number of last write */328 uuid_t uuid; /* filesystem we belong to */329 __be64 owner; /* inode that owns the block */330};331 332struct xfs_dir3_data_hdr {333 struct xfs_dir3_blk_hdr hdr;334 xfs_dir2_data_free_t best_free[XFS_DIR2_DATA_FD_COUNT];335 __be32 pad; /* 64 bit alignment */336};337 338#define XFS_DIR3_DATA_CRC_OFF offsetof(struct xfs_dir3_data_hdr, hdr.crc)339 340/*341 * Active entry in a data block.342 *343 * Aligned to 8 bytes. After the variable length name field there is a344 * 2 byte tag field, which can be accessed using xfs_dir3_data_entry_tag_p.345 *346 * For dir3 structures, there is file type field between the name and the tag.347 * This can only be manipulated by helper functions. It is packed hard against348 * the end of the name so any padding for rounding is between the file type and349 * the tag.350 */351typedef struct xfs_dir2_data_entry {352 __be64 inumber; /* inode number */353 __u8 namelen; /* name length */354 __u8 name[]; /* name bytes, no null */355 /* __u8 filetype; */ /* type of inode we point to */356 /* __be16 tag; */ /* starting offset of us */357} xfs_dir2_data_entry_t;358 359/*360 * Unused entry in a data block.361 *362 * Aligned to 8 bytes. Tag appears as the last 2 bytes and must be accessed363 * using xfs_dir2_data_unused_tag_p.364 */365typedef struct xfs_dir2_data_unused {366 __be16 freetag; /* XFS_DIR2_DATA_FREE_TAG */367 __be16 length; /* total free length */368 /* variable offset */369 __be16 tag; /* starting offset of us */370} xfs_dir2_data_unused_t;371 372/*373 * Pointer to a freespace's tag word.374 */375static inline __be16 *376xfs_dir2_data_unused_tag_p(struct xfs_dir2_data_unused *dup)377{378 return (__be16 *)((char *)dup +379 be16_to_cpu(dup->length) - sizeof(__be16));380}381 382/*383 * Leaf block structures.384 *385 * A pure leaf block looks like the following drawing on disk:386 *387 * +---------------------------+388 * | xfs_dir2_leaf_hdr_t |389 * +---------------------------+390 * | xfs_dir2_leaf_entry_t |391 * | xfs_dir2_leaf_entry_t |392 * | xfs_dir2_leaf_entry_t |393 * | xfs_dir2_leaf_entry_t |394 * | ... |395 * +---------------------------+396 * | xfs_dir2_data_off_t |397 * | xfs_dir2_data_off_t |398 * | xfs_dir2_data_off_t |399 * | ... |400 * +---------------------------+401 * | xfs_dir2_leaf_tail_t |402 * +---------------------------+403 *404 * The xfs_dir2_data_off_t members (bests) and tail are at the end of the block405 * for single-leaf (magic = XFS_DIR2_LEAF1_MAGIC) blocks only, but not present406 * for directories with separate leaf nodes and free space blocks407 * (magic = XFS_DIR2_LEAFN_MAGIC).408 *409 * As all the entries are variable size structures the accessors below should410 * be used to iterate over them.411 */412 413/*414 * Offset of the leaf/node space. First block in this space415 * is the btree root.416 */417#define XFS_DIR2_LEAF_SPACE 1418#define XFS_DIR2_LEAF_OFFSET (XFS_DIR2_LEAF_SPACE * XFS_DIR2_SPACE_SIZE)419 420/*421 * Leaf block header.422 */423typedef struct xfs_dir2_leaf_hdr {424 xfs_da_blkinfo_t info; /* header for da routines */425 __be16 count; /* count of entries */426 __be16 stale; /* count of stale entries */427} xfs_dir2_leaf_hdr_t;428 429struct xfs_dir3_leaf_hdr {430 struct xfs_da3_blkinfo info; /* header for da routines */431 __be16 count; /* count of entries */432 __be16 stale; /* count of stale entries */433 __be32 pad; /* 64 bit alignment */434};435 436/*437 * Leaf block entry.438 */439typedef struct xfs_dir2_leaf_entry {440 __be32 hashval; /* hash value of name */441 __be32 address; /* address of data entry */442} xfs_dir2_leaf_entry_t;443 444/*445 * Leaf block tail.446 */447typedef struct xfs_dir2_leaf_tail {448 __be32 bestcount;449} xfs_dir2_leaf_tail_t;450 451/*452 * Leaf block.453 */454typedef struct xfs_dir2_leaf {455 xfs_dir2_leaf_hdr_t hdr; /* leaf header */456 xfs_dir2_leaf_entry_t __ents[]; /* entries */457} xfs_dir2_leaf_t;458 459struct xfs_dir3_leaf {460 struct xfs_dir3_leaf_hdr hdr; /* leaf header */461 struct xfs_dir2_leaf_entry __ents[]; /* entries */462};463 464#define XFS_DIR3_LEAF_CRC_OFF offsetof(struct xfs_dir3_leaf_hdr, info.crc)465 466/*467 * Get address of the bests array in the single-leaf block.468 */469static inline __be16 *470xfs_dir2_leaf_bests_p(struct xfs_dir2_leaf_tail *ltp)471{472 return (__be16 *)ltp - be32_to_cpu(ltp->bestcount);473}474 475/*476 * Free space block definitions for the node format.477 */478 479/*480 * Offset of the freespace index.481 */482#define XFS_DIR2_FREE_SPACE 2483#define XFS_DIR2_FREE_OFFSET (XFS_DIR2_FREE_SPACE * XFS_DIR2_SPACE_SIZE)484 485typedef struct xfs_dir2_free_hdr {486 __be32 magic; /* XFS_DIR2_FREE_MAGIC */487 __be32 firstdb; /* db of first entry */488 __be32 nvalid; /* count of valid entries */489 __be32 nused; /* count of used entries */490} xfs_dir2_free_hdr_t;491 492typedef struct xfs_dir2_free {493 xfs_dir2_free_hdr_t hdr; /* block header */494 __be16 bests[]; /* best free counts */495 /* unused entries are -1 */496} xfs_dir2_free_t;497 498struct xfs_dir3_free_hdr {499 struct xfs_dir3_blk_hdr hdr;500 __be32 firstdb; /* db of first entry */501 __be32 nvalid; /* count of valid entries */502 __be32 nused; /* count of used entries */503 __be32 pad; /* 64 bit alignment */504};505 506struct xfs_dir3_free {507 struct xfs_dir3_free_hdr hdr;508 __be16 bests[]; /* best free counts */509 /* unused entries are -1 */510};511 512#define XFS_DIR3_FREE_CRC_OFF offsetof(struct xfs_dir3_free, hdr.hdr.crc)513 514/*515 * Single block format.516 *517 * The single block format looks like the following drawing on disk:518 *519 * +-------------------------------------------------+520 * | xfs_dir2_data_hdr_t |521 * +-------------------------------------------------+522 * | xfs_dir2_data_entry_t OR xfs_dir2_data_unused_t |523 * | xfs_dir2_data_entry_t OR xfs_dir2_data_unused_t |524 * | xfs_dir2_data_entry_t OR xfs_dir2_data_unused_t :525 * | ... |526 * +-------------------------------------------------+527 * | unused space |528 * +-------------------------------------------------+529 * | ... |530 * | xfs_dir2_leaf_entry_t |531 * | xfs_dir2_leaf_entry_t |532 * +-------------------------------------------------+533 * | xfs_dir2_block_tail_t |534 * +-------------------------------------------------+535 *536 * As all the entries are variable size structures the accessors below should537 * be used to iterate over them.538 */539 540typedef struct xfs_dir2_block_tail {541 __be32 count; /* count of leaf entries */542 __be32 stale; /* count of stale lf entries */543} xfs_dir2_block_tail_t;544 545/*546 * Pointer to the leaf entries embedded in a data block (1-block format)547 */548static inline struct xfs_dir2_leaf_entry *549xfs_dir2_block_leaf_p(struct xfs_dir2_block_tail *btp)550{551 return ((struct xfs_dir2_leaf_entry *)btp) - be32_to_cpu(btp->count);552}553 554 555/*556 * Attribute storage layout557 *558 * Attribute lists are structured around Btrees where all the data559 * elements are in the leaf nodes. Attribute names are hashed into an int,560 * then that int is used as the index into the Btree. Since the hashval561 * of an attribute name may not be unique, we may have duplicate keys. The562 * internal links in the Btree are logical block offsets into the file.563 *564 * Struct leaf_entry's are packed from the top. Name/values grow from the565 * bottom but are not packed. The freemap contains run-length-encoded entries566 * for the free bytes after the leaf_entry's, but only the N largest such,567 * smaller runs are dropped. When the freemap doesn't show enough space568 * for an allocation, we compact the name/value area and try again. If we569 * still don't have enough space, then we have to split the block. The570 * name/value structs (both local and remote versions) must be 32bit aligned.571 *572 * Since we have duplicate hash keys, for each key that matches, compare573 * the actual name string. The root and intermediate node search always574 * takes the first-in-the-block key match found, so we should only have575 * to work "forw"ard. If none matches, continue with the "forw"ard leaf576 * nodes until the hash key changes or the attribute name is found.577 *578 * We store the fact that an attribute is a ROOT/USER/SECURE attribute in579 * the leaf_entry. The namespaces are independent only because we also look580 * at the namespace bit when we are looking for a matching attribute name.581 *582 * We also store an "incomplete" bit in the leaf_entry. It shows that an583 * attribute is in the middle of being created and should not be shown to584 * the user if we crash during the time that the bit is set. We clear the585 * bit when we have finished setting up the attribute. We do this because586 * we cannot create some large attributes inside a single transaction, and we587 * need some indication that we weren't finished if we crash in the middle.588 */589#define XFS_ATTR_LEAF_MAPSIZE 3 /* how many freespace slots */590 591/*592 * Attribute storage when stored inside the inode.593 *594 * Small attribute lists are packed as tightly as possible so as to fit into the595 * literal area of the inode.596 *597 * These "shortform" attribute forks consist of a single xfs_attr_sf_hdr header598 * followed by zero or more xfs_attr_sf_entry structures.599 */600struct xfs_attr_sf_hdr { /* constant-structure header block */601 __be16 totsize; /* total bytes in shortform list */602 __u8 count; /* count of active entries */603 __u8 padding;604};605 606struct xfs_attr_sf_entry {607 __u8 namelen; /* actual length of name (no NULL) */608 __u8 valuelen; /* actual length of value (no NULL) */609 __u8 flags; /* flags bits (XFS_ATTR_*) */610 __u8 nameval[]; /* name & value bytes concatenated */611};612 613typedef struct xfs_attr_leaf_map { /* RLE map of free bytes */614 __be16 base; /* base of free region */615 __be16 size; /* length of free region */616} xfs_attr_leaf_map_t;617 618typedef struct xfs_attr_leaf_hdr { /* constant-structure header block */619 xfs_da_blkinfo_t info; /* block type, links, etc. */620 __be16 count; /* count of active leaf_entry's */621 __be16 usedbytes; /* num bytes of names/values stored */622 __be16 firstused; /* first used byte in name area */623 __u8 holes; /* != 0 if blk needs compaction */624 __u8 pad1;625 xfs_attr_leaf_map_t freemap[XFS_ATTR_LEAF_MAPSIZE];626 /* N largest free regions */627} xfs_attr_leaf_hdr_t;628 629typedef struct xfs_attr_leaf_entry { /* sorted on key, not name */630 __be32 hashval; /* hash value of name */631 __be16 nameidx; /* index into buffer of name/value */632 __u8 flags; /* LOCAL/ROOT/SECURE/INCOMPLETE flag */633 __u8 pad2; /* unused pad byte */634} xfs_attr_leaf_entry_t;635 636typedef struct xfs_attr_leaf_name_local {637 __be16 valuelen; /* number of bytes in value */638 __u8 namelen; /* length of name bytes */639 /*640 * In Linux 6.5 this flex array was converted from nameval[1] to641 * nameval[]. Be very careful here about extra padding at the end;642 * see xfs_attr_leaf_entsize_local() for details.643 */644 __u8 nameval[]; /* name/value bytes */645} xfs_attr_leaf_name_local_t;646 647typedef struct xfs_attr_leaf_name_remote {648 __be32 valueblk; /* block number of value bytes */649 __be32 valuelen; /* number of bytes in value */650 __u8 namelen; /* length of name bytes */651 /*652 * In Linux 6.5 this flex array was converted from name[1] to name[].653 * Be very careful here about extra padding at the end; see654 * xfs_attr_leaf_entsize_remote() for details.655 */656 __u8 name[]; /* name bytes */657} xfs_attr_leaf_name_remote_t;658 659typedef struct xfs_attr_leafblock {660 xfs_attr_leaf_hdr_t hdr; /* constant-structure header block */661 xfs_attr_leaf_entry_t entries[]; /* sorted on key, not name */662 /*663 * The rest of the block contains the following structures after the664 * leaf entries, growing from the bottom up. The variables are never665 * referenced and definining them can actually make gcc optimize away666 * accesses to the 'entries' array above index 0 so don't do that.667 *668 * xfs_attr_leaf_name_local_t namelist;669 * xfs_attr_leaf_name_remote_t valuelist;670 */671} xfs_attr_leafblock_t;672 673/*674 * CRC enabled leaf structures. Called "version 3" structures to match the675 * version number of the directory and dablk structures for this feature, and676 * attr2 is already taken by the variable inode attribute fork size feature.677 */678struct xfs_attr3_leaf_hdr {679 struct xfs_da3_blkinfo info;680 __be16 count;681 __be16 usedbytes;682 __be16 firstused;683 __u8 holes;684 __u8 pad1;685 struct xfs_attr_leaf_map freemap[XFS_ATTR_LEAF_MAPSIZE];686 __be32 pad2; /* 64 bit alignment */687};688 689#define XFS_ATTR3_LEAF_CRC_OFF (offsetof(struct xfs_attr3_leaf_hdr, info.crc))690 691struct xfs_attr3_leafblock {692 struct xfs_attr3_leaf_hdr hdr;693 struct xfs_attr_leaf_entry entries[];694 695 /*696 * The rest of the block contains the following structures after the697 * leaf entries, growing from the bottom up. The variables are never698 * referenced, the locations accessed purely from helper functions.699 *700 * struct xfs_attr_leaf_name_local701 * struct xfs_attr_leaf_name_remote702 */703};704 705/*706 * Special value to represent fs block size in the leaf header firstused field.707 * Only used when block size overflows the 2-bytes available on disk.708 */709#define XFS_ATTR3_LEAF_NULLOFF 0710 711/*712 * Flags used in the leaf_entry[i].flags field.713 */714#define XFS_ATTR_LOCAL_BIT 0 /* attr is stored locally */715#define XFS_ATTR_ROOT_BIT 1 /* limit access to trusted attrs */716#define XFS_ATTR_SECURE_BIT 2 /* limit access to secure attrs */717#define XFS_ATTR_PARENT_BIT 3 /* parent pointer attrs */718#define XFS_ATTR_INCOMPLETE_BIT 7 /* attr in middle of create/delete */719#define XFS_ATTR_LOCAL (1u << XFS_ATTR_LOCAL_BIT)720#define XFS_ATTR_ROOT (1u << XFS_ATTR_ROOT_BIT)721#define XFS_ATTR_SECURE (1u << XFS_ATTR_SECURE_BIT)722#define XFS_ATTR_PARENT (1u << XFS_ATTR_PARENT_BIT)723#define XFS_ATTR_INCOMPLETE (1u << XFS_ATTR_INCOMPLETE_BIT)724 725#define XFS_ATTR_NSP_ONDISK_MASK (XFS_ATTR_ROOT | \726 XFS_ATTR_SECURE | \727 XFS_ATTR_PARENT)728 729/* Private attr namespaces not exposed to userspace */730#define XFS_ATTR_PRIVATE_NSP_MASK (XFS_ATTR_PARENT)731 732#define XFS_ATTR_ONDISK_MASK (XFS_ATTR_NSP_ONDISK_MASK | \733 XFS_ATTR_LOCAL | \734 XFS_ATTR_INCOMPLETE)735 736#define XFS_ATTR_NAMESPACE_STR \737 { XFS_ATTR_LOCAL, "local" }, \738 { XFS_ATTR_ROOT, "root" }, \739 { XFS_ATTR_SECURE, "secure" }, \740 { XFS_ATTR_PARENT, "parent" }741 742/*743 * Alignment for namelist and valuelist entries (since they are mixed744 * there can be only one alignment value)745 */746#define XFS_ATTR_LEAF_NAME_ALIGN ((uint)sizeof(xfs_dablk_t))747 748static inline int749xfs_attr3_leaf_hdr_size(struct xfs_attr_leafblock *leafp)750{751 if (leafp->hdr.info.magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC))752 return sizeof(struct xfs_attr3_leaf_hdr);753 return sizeof(struct xfs_attr_leaf_hdr);754}755 756static inline struct xfs_attr_leaf_entry *757xfs_attr3_leaf_entryp(xfs_attr_leafblock_t *leafp)758{759 if (leafp->hdr.info.magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC))760 return &((struct xfs_attr3_leafblock *)leafp)->entries[0];761 return &leafp->entries[0];762}763 764/*765 * Cast typed pointers for "local" and "remote" name/value structs.766 */767static inline char *768xfs_attr3_leaf_name(xfs_attr_leafblock_t *leafp, int idx)769{770 struct xfs_attr_leaf_entry *entries = xfs_attr3_leaf_entryp(leafp);771 772 return &((char *)leafp)[be16_to_cpu(entries[idx].nameidx)];773}774 775static inline xfs_attr_leaf_name_remote_t *776xfs_attr3_leaf_name_remote(xfs_attr_leafblock_t *leafp, int idx)777{778 return (xfs_attr_leaf_name_remote_t *)xfs_attr3_leaf_name(leafp, idx);779}780 781static inline xfs_attr_leaf_name_local_t *782xfs_attr3_leaf_name_local(xfs_attr_leafblock_t *leafp, int idx)783{784 return (xfs_attr_leaf_name_local_t *)xfs_attr3_leaf_name(leafp, idx);785}786 787/*788 * Calculate total bytes used (including trailing pad for alignment) for789 * a "local" name/value structure, a "remote" name/value structure, and790 * a pointer which might be either.791 */792static inline int xfs_attr_leaf_entsize_remote(int nlen)793{794 /*795 * Prior to Linux 6.5, struct xfs_attr_leaf_name_remote ended with796 * name[1], which was used as a flexarray. The layout of this struct797 * is 9 bytes of fixed-length fields followed by a __u8 flex array at798 * offset 9.799 *800 * On most architectures, struct xfs_attr_leaf_name_remote had two801 * bytes of implicit padding at the end of the struct to make the802 * struct length 12. After converting name[1] to name[], there are803 * three implicit padding bytes and the struct size remains 12.804 * However, there are compiler configurations that do not add implicit805 * padding at all (m68k) and have been broken for years.806 *807 * This entsize computation historically added (the xattr name length)808 * to (the padded struct length - 1) and rounded that sum up to the809 * nearest multiple of 4 (NAME_ALIGN). IOWs, round_up(11 + nlen, 4).810 * This is encoded in the ondisk format, so we cannot change this.811 *812 * Compute the entsize from offsetof of the flexarray and manually813 * adding bytes for the implicit padding.814 */815 const size_t remotesize =816 offsetof(struct xfs_attr_leaf_name_remote, name) + 2;817 818 return round_up(remotesize + nlen, XFS_ATTR_LEAF_NAME_ALIGN);819}820 821static inline int xfs_attr_leaf_entsize_local(int nlen, int vlen)822{823 /*824 * Prior to Linux 6.5, struct xfs_attr_leaf_name_local ended with825 * nameval[1], which was used as a flexarray. The layout of this826 * struct is 3 bytes of fixed-length fields followed by a __u8 flex827 * array at offset 3.828 *829 * struct xfs_attr_leaf_name_local had zero bytes of implicit padding830 * at the end of the struct to make the struct length 4. On most831 * architectures, after converting nameval[1] to nameval[], there is832 * one implicit padding byte and the struct size remains 4. However,833 * there are compiler configurations that do not add implicit padding834 * at all (m68k) and would break.835 *836 * This entsize computation historically added (the xattr name and837 * value length) to (the padded struct length - 1) and rounded that sum838 * up to the nearest multiple of 4 (NAME_ALIGN). IOWs, the formula is839 * round_up(3 + nlen + vlen, 4). This is encoded in the ondisk format,840 * so we cannot change this.841 *842 * Compute the entsize from offsetof of the flexarray and manually843 * adding bytes for the implicit padding.844 */845 const size_t localsize =846 offsetof(struct xfs_attr_leaf_name_local, nameval);847 848 return round_up(localsize + nlen + vlen, XFS_ATTR_LEAF_NAME_ALIGN);849}850 851static inline int xfs_attr_leaf_entsize_local_max(int bsize)852{853 return (((bsize) >> 1) + ((bsize) >> 2));854}855 856 857 858/*859 * Remote attribute block format definition860 *861 * There is one of these headers per filesystem block in a remote attribute.862 * This is done to ensure there is a 1:1 mapping between the attribute value863 * length and the number of blocks needed to store the attribute. This makes the864 * verification of a buffer a little more complex, but greatly simplifies the865 * allocation, reading and writing of these attributes as we don't have to guess866 * the number of blocks needed to store the attribute data.867 */868#define XFS_ATTR3_RMT_MAGIC 0x5841524d /* XARM */869 870struct xfs_attr3_rmt_hdr {871 __be32 rm_magic;872 __be32 rm_offset;873 __be32 rm_bytes;874 __be32 rm_crc;875 uuid_t rm_uuid;876 __be64 rm_owner;877 __be64 rm_blkno;878 __be64 rm_lsn;879};880 881#define XFS_ATTR3_RMT_CRC_OFF offsetof(struct xfs_attr3_rmt_hdr, rm_crc)882 883unsigned int xfs_attr3_rmt_buf_space(struct xfs_mount *mp);884 885/* Number of bytes in a directory block. */886static inline unsigned int xfs_dir2_dirblock_bytes(struct xfs_sb *sbp)887{888 return 1 << (sbp->sb_blocklog + sbp->sb_dirblklog);889}890 891xfs_failaddr_t xfs_da3_blkinfo_verify(struct xfs_buf *bp,892 struct xfs_da3_blkinfo *hdr3);893 894/*895 * Parent pointer attribute format definition896 *897 * The xattr name contains the dirent name.898 * The xattr value encodes the parent inode number and generation to ease899 * opening parents by handle.900 * The xattr hashval is xfs_dir2_namehash() ^ p_ino901 */902struct xfs_parent_rec {903 __be64 p_ino;904 __be32 p_gen;905} __packed;906 907#endif /* __XFS_DA_FORMAT_H__ */908