/* xfs.c - XFS. */ /* * VAS_EBOOT -- GRand Unified Bootloader * Copyright (C) 2005,2006,2007,2008,2009 Free Software Foundation, Inc. * * VAS_EBOOT is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * VAS_EBOOT is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with VAS_EBOOT. If not, see . */ #include #include #include #include #include #include #include #include #include #include VAS_EBOOT_MOD_LICENSE ("GPLv3+"); #define XFS_INODE_EXTENTS 9 #define XFS_INODE_FORMAT_INO 1 #define XFS_INODE_FORMAT_EXT 2 #define XFS_INODE_FORMAT_BTREE 3 /* Superblock version field flags */ #define XFS_SB_VERSION_NUMBITS 0x000f #define XFS_SB_VERSION_ATTRBIT 0x0010 #define XFS_SB_VERSION_NLINKBIT 0x0020 #define XFS_SB_VERSION_QUOTABIT 0x0040 #define XFS_SB_VERSION_ALIGNBIT 0x0080 #define XFS_SB_VERSION_DALIGNBIT 0x0100 #define XFS_SB_VERSION_LOGV2BIT 0x0400 #define XFS_SB_VERSION_SECTORBIT 0x0800 #define XFS_SB_VERSION_EXTFLGBIT 0x1000 #define XFS_SB_VERSION_DIRV2BIT 0x2000 #define XFS_SB_VERSION_MOREBITSBIT 0x8000 #define XFS_SB_VERSION_BITS_SUPPORTED \ (XFS_SB_VERSION_NUMBITS | \ XFS_SB_VERSION_ATTRBIT | \ XFS_SB_VERSION_NLINKBIT | \ XFS_SB_VERSION_QUOTABIT | \ XFS_SB_VERSION_ALIGNBIT | \ XFS_SB_VERSION_DALIGNBIT | \ XFS_SB_VERSION_LOGV2BIT | \ XFS_SB_VERSION_SECTORBIT | \ XFS_SB_VERSION_EXTFLGBIT | \ XFS_SB_VERSION_DIRV2BIT | \ XFS_SB_VERSION_MOREBITSBIT) /* Recognized xfs format versions */ #define XFS_SB_VERSION_4 4 /* Good old XFS filesystem */ #define XFS_SB_VERSION_5 5 /* CRC enabled filesystem */ /* features2 field flags */ #define XFS_SB_VERSION2_LAZYSBCOUNTBIT 0x00000002 /* Superblk counters */ #define XFS_SB_VERSION2_ATTR2BIT 0x00000008 /* Inline attr rework */ #define XFS_SB_VERSION2_PROJID32BIT 0x00000080 /* 32-bit project ids */ #define XFS_SB_VERSION2_FTYPE 0x00000200 /* inode type in dir */ #define XFS_SB_VERSION2_BITS_SUPPORTED \ (XFS_SB_VERSION2_LAZYSBCOUNTBIT | \ XFS_SB_VERSION2_ATTR2BIT | \ XFS_SB_VERSION2_PROJID32BIT | \ XFS_SB_VERSION2_FTYPE) /* Inode flags2 flags */ #define XFS_DIFLAG2_BIGTIME_BIT 3 #define XFS_DIFLAG2_BIGTIME (1 << XFS_DIFLAG2_BIGTIME_BIT) #define XFS_DIFLAG2_NREXT64_BIT 4 #define XFS_DIFLAG2_NREXT64 (1 << XFS_DIFLAG2_NREXT64_BIT) /* incompat feature flags */ #define XFS_SB_FEAT_INCOMPAT_FTYPE (1 << 0) /* filetype in dirent */ #define XFS_SB_FEAT_INCOMPAT_SPINODES (1 << 1) /* sparse inode chunks */ #define XFS_SB_FEAT_INCOMPAT_META_UUID (1 << 2) /* metadata UUID */ #define XFS_SB_FEAT_INCOMPAT_BIGTIME (1 << 3) /* large timestamps */ #define XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR (1 << 4) /* needs xfs_repair */ #define XFS_SB_FEAT_INCOMPAT_NREXT64 (1 << 5) /* large extent counters */ #define XFS_SB_FEAT_INCOMPAT_EXCHRANGE (1 << 6) /* exchangerange supported */ #define XFS_SB_FEAT_INCOMPAT_PARENT (1 << 7) /* parent pointers */ #define XFS_SB_FEAT_INCOMPAT_METADIR (1 << 8) /* metadata dir tree */ /* * Directory entries with ftype are explicitly handled by VAS_EBOOT code. * * We do not currently read the inode btrees, so it is safe to read filesystems * with the XFS_SB_FEAT_INCOMPAT_SPINODES feature. * * We do not currently verify metadata UUID, so it is safe to read filesystems * with the XFS_SB_FEAT_INCOMPAT_META_UUID feature. * * We do not currently replay the log, so it is safe to read filesystems * with the XFS_SB_FEAT_INCOMPAT_EXCHRANGE feature. * * We do not currently read directory parent pointers, so it is safe to read * filesystems with the XFS_SB_FEAT_INCOMPAT_PARENT feature. * * We do not currently look at realtime or quota metadata, so it is safe to * read filesystems with the XFS_SB_FEAT_INCOMPAT_METADIR feature. */ #define XFS_SB_FEAT_INCOMPAT_SUPPORTED \ (XFS_SB_FEAT_INCOMPAT_FTYPE | \ XFS_SB_FEAT_INCOMPAT_SPINODES | \ XFS_SB_FEAT_INCOMPAT_META_UUID | \ XFS_SB_FEAT_INCOMPAT_BIGTIME | \ XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR | \ XFS_SB_FEAT_INCOMPAT_NREXT64 | \ XFS_SB_FEAT_INCOMPAT_EXCHRANGE | \ XFS_SB_FEAT_INCOMPAT_PARENT | \ XFS_SB_FEAT_INCOMPAT_METADIR) struct VasEBoot_xfs_sblock { VasEBoot_uint8_t magic[4]; VasEBoot_uint32_t bsize; VasEBoot_uint8_t unused1[24]; VasEBoot_uint16_t uuid[8]; VasEBoot_uint8_t unused2[8]; VasEBoot_uint64_t rootino; VasEBoot_uint8_t unused3[20]; VasEBoot_uint32_t agsize; VasEBoot_uint8_t unused4[12]; VasEBoot_uint16_t version; VasEBoot_uint8_t unused5[6]; VasEBoot_uint8_t label[12]; VasEBoot_uint8_t log2_bsize; VasEBoot_uint8_t log2_sect; VasEBoot_uint8_t log2_inode; VasEBoot_uint8_t log2_inop; VasEBoot_uint8_t log2_agblk; VasEBoot_uint8_t unused6[67]; VasEBoot_uint8_t log2_dirblk; VasEBoot_uint8_t unused7[7]; VasEBoot_uint32_t features2; VasEBoot_uint8_t unused8[4]; VasEBoot_uint32_t sb_features_compat; VasEBoot_uint32_t sb_features_ro_compat; VasEBoot_uint32_t sb_features_incompat; VasEBoot_uint32_t sb_features_log_incompat; } VAS_EBOOT_PACKED; struct VasEBoot_xfs_dir_header { VasEBoot_uint8_t count; VasEBoot_uint8_t largeino; union { VasEBoot_uint32_t i4; VasEBoot_uint64_t i8; } VAS_EBOOT_PACKED parent; } VAS_EBOOT_PACKED; /* Structure for directory entry inlined in the inode */ struct VasEBoot_xfs_dir_entry { VasEBoot_uint8_t len; VasEBoot_uint16_t offset; char name[1]; /* Inode number follows, 32 / 64 bits. */ } VAS_EBOOT_PACKED; /* Structure for directory entry in a block */ struct VasEBoot_xfs_dir2_entry { VasEBoot_uint64_t inode; VasEBoot_uint8_t len; } VAS_EBOOT_PACKED; struct VasEBoot_xfs_extent { /* This should be a bitfield but bietfields are unportable, so just have a raw array and functions extracting useful info from it. */ VasEBoot_uint32_t raw[4]; } VAS_EBOOT_PACKED; struct VasEBoot_xfs_btree_node { VasEBoot_uint8_t magic[4]; VasEBoot_uint16_t level; VasEBoot_uint16_t numrecs; VasEBoot_uint64_t left; VasEBoot_uint64_t right; /* In V5 here follow crc, uuid, etc. */ /* Then follow keys and block pointers */ } VAS_EBOOT_PACKED; struct VasEBoot_xfs_btree_root { VasEBoot_uint16_t level; VasEBoot_uint16_t numrecs; VasEBoot_uint64_t keys[1]; } VAS_EBOOT_PACKED; struct VasEBoot_xfs_time_legacy { VasEBoot_uint32_t sec; VasEBoot_uint32_t nanosec; } VAS_EBOOT_PACKED; /* * The struct VasEBoot_xfs_inode layout was taken from the * struct xfs_dinode_core which is described here: * https://mirrors.edge.kernel.org/pub/linux/utils/fs/xfs/docs/xfs_filesystem_structure.pdf */ struct VasEBoot_xfs_inode { VasEBoot_uint8_t magic[2]; VasEBoot_uint16_t mode; VasEBoot_uint8_t version; VasEBoot_uint8_t format; VasEBoot_uint8_t unused2[18]; VasEBoot_uint64_t nextents_big; VasEBoot_uint64_t atime; VasEBoot_uint64_t mtime; VasEBoot_uint64_t ctime; VasEBoot_uint64_t size; VasEBoot_uint64_t nblocks; VasEBoot_uint32_t extsize; VasEBoot_uint32_t nextents; VasEBoot_uint16_t unused3; VasEBoot_uint8_t fork_offset; VasEBoot_uint8_t unused4[17]; /* Last member of inode v2. */ VasEBoot_uint8_t unused5[20]; /* First member of inode v3. */ VasEBoot_uint64_t flags2; VasEBoot_uint8_t unused6[48]; /* Last member of inode v3. */ } VAS_EBOOT_PACKED; #define XFS_V3_INODE_SIZE sizeof(struct VasEBoot_xfs_inode) /* Size of struct VasEBoot_xfs_inode v2, up to unused4 member included. */ #define XFS_V2_INODE_SIZE (XFS_V3_INODE_SIZE - 76) struct VasEBoot_xfs_dir_leaf_entry { VasEBoot_uint32_t hashval; VasEBoot_uint32_t address; } VAS_EBOOT_PACKED; struct VasEBoot_xfs_dirblock_tail { VasEBoot_uint32_t leaf_count; VasEBoot_uint32_t leaf_stale; } VAS_EBOOT_PACKED; struct VasEBoot_fshelp_node { struct VasEBoot_xfs_data *data; VasEBoot_uint64_t ino; int inode_read; struct VasEBoot_xfs_inode inode; }; struct VasEBoot_xfs_data { VasEBoot_size_t data_size; struct VasEBoot_xfs_sblock sblock; VasEBoot_disk_t disk; int pos; int bsize; VasEBoot_uint32_t agsize; unsigned int hasftype:1; unsigned int hascrc:1; struct VasEBoot_fshelp_node diropen; }; static VasEBoot_dl_t my_mod; static int VasEBoot_xfs_sb_hascrc(struct VasEBoot_xfs_data *data) { return (data->sblock.version & VasEBoot_cpu_to_be16_compile_time(XFS_SB_VERSION_NUMBITS)) == VasEBoot_cpu_to_be16_compile_time(XFS_SB_VERSION_5); } static int VasEBoot_xfs_sb_hasftype(struct VasEBoot_xfs_data *data) { if ((data->sblock.version & VasEBoot_cpu_to_be16_compile_time(XFS_SB_VERSION_NUMBITS)) == VasEBoot_cpu_to_be16_compile_time(XFS_SB_VERSION_5) && data->sblock.sb_features_incompat & VasEBoot_cpu_to_be32_compile_time(XFS_SB_FEAT_INCOMPAT_FTYPE)) return 1; if (data->sblock.version & VasEBoot_cpu_to_be16_compile_time(XFS_SB_VERSION_MOREBITSBIT) && data->sblock.features2 & VasEBoot_cpu_to_be32_compile_time(XFS_SB_VERSION2_FTYPE)) return 1; return 0; } static int VasEBoot_xfs_sb_valid(struct VasEBoot_xfs_data *data) { VasEBoot_dprintf("xfs", "Validating superblock\n"); if (VasEBoot_strncmp ((char *) (data->sblock.magic), "XFSB", 4) || data->sblock.log2_bsize < VAS_EBOOT_DISK_SECTOR_BITS || ((int) data->sblock.log2_bsize + (int) data->sblock.log2_dirblk) >= 27) { VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "not a XFS filesystem"); return 0; } if ((data->sblock.version & VasEBoot_cpu_to_be16_compile_time(XFS_SB_VERSION_NUMBITS)) == VasEBoot_cpu_to_be16_compile_time(XFS_SB_VERSION_5)) { VasEBoot_dprintf("xfs", "XFS v5 superblock detected\n"); if (data->sblock.sb_features_incompat & VasEBoot_cpu_to_be32_compile_time(~XFS_SB_FEAT_INCOMPAT_SUPPORTED)) { VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "XFS filesystem has unsupported " "incompatible features"); return 0; } return 1; } else if ((data->sblock.version & VasEBoot_cpu_to_be16_compile_time(XFS_SB_VERSION_NUMBITS)) == VasEBoot_cpu_to_be16_compile_time(XFS_SB_VERSION_4)) { VasEBoot_dprintf("xfs", "XFS v4 superblock detected\n"); if (!(data->sblock.version & VasEBoot_cpu_to_be16_compile_time(XFS_SB_VERSION_DIRV2BIT))) { VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "XFS filesystem without V2 directories " "is unsupported"); return 0; } if (data->sblock.version & VasEBoot_cpu_to_be16_compile_time(~XFS_SB_VERSION_BITS_SUPPORTED) || (data->sblock.version & VasEBoot_cpu_to_be16_compile_time(XFS_SB_VERSION_MOREBITSBIT) && data->sblock.features2 & VasEBoot_cpu_to_be16_compile_time(~XFS_SB_VERSION2_BITS_SUPPORTED))) { VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "XFS filesystem has unsupported version " "bits"); return 0; } return 1; } VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "unsupported XFS filesystem version"); return 0; } static int VasEBoot_xfs_sb_needs_repair (struct VasEBoot_xfs_data *data) { return ((data->sblock.version & VasEBoot_cpu_to_be16_compile_time (XFS_SB_VERSION_NUMBITS)) == VasEBoot_cpu_to_be16_compile_time (XFS_SB_VERSION_5) && (data->sblock.sb_features_incompat & VasEBoot_cpu_to_be32_compile_time (XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR))); } /* Filetype information as used in inodes. */ #define FILETYPE_INO_MASK 0170000 #define FILETYPE_INO_REG 0100000 #define FILETYPE_INO_DIRECTORY 0040000 #define FILETYPE_INO_SYMLINK 0120000 static inline int VAS_EBOOT_XFS_INO_AGBITS(struct VasEBoot_xfs_data *data) { return ((data)->sblock.log2_agblk + (data)->sblock.log2_inop); } static inline VasEBoot_uint64_t VAS_EBOOT_XFS_INO_INOINAG (struct VasEBoot_xfs_data *data, VasEBoot_uint64_t ino) { return (ino & ((1LL << VAS_EBOOT_XFS_INO_AGBITS (data)) - 1)); } static inline VasEBoot_uint64_t VAS_EBOOT_XFS_INO_AG (struct VasEBoot_xfs_data *data, VasEBoot_uint64_t ino) { return (ino >> VAS_EBOOT_XFS_INO_AGBITS (data)); } static inline VasEBoot_disk_addr_t VAS_EBOOT_XFS_FSB_TO_BLOCK (struct VasEBoot_xfs_data *data, VasEBoot_disk_addr_t fsb) { return ((fsb >> data->sblock.log2_agblk) * data->agsize + (fsb & ((1LL << data->sblock.log2_agblk) - 1))); } static inline VasEBoot_uint64_t VAS_EBOOT_XFS_EXTENT_OFFSET (struct VasEBoot_xfs_extent *exts, int ex) { return ((VasEBoot_be_to_cpu32 (exts[ex].raw[0]) & ~(1 << 31)) << 23 | VasEBoot_be_to_cpu32 (exts[ex].raw[1]) >> 9); } static inline VasEBoot_uint64_t VAS_EBOOT_XFS_EXTENT_BLOCK (struct VasEBoot_xfs_extent *exts, int ex) { return ((VasEBoot_uint64_t) (VasEBoot_be_to_cpu32 (exts[ex].raw[1]) & (0x1ff)) << 43 | (VasEBoot_uint64_t) VasEBoot_be_to_cpu32 (exts[ex].raw[2]) << 11 | VasEBoot_be_to_cpu32 (exts[ex].raw[3]) >> 21); } static inline VasEBoot_uint64_t VAS_EBOOT_XFS_EXTENT_SIZE (struct VasEBoot_xfs_extent *exts, int ex) { return (VasEBoot_be_to_cpu32 (exts[ex].raw[3]) & ((1 << 21) - 1)); } static inline VasEBoot_uint64_t VasEBoot_xfs_inode_block (struct VasEBoot_xfs_data *data, VasEBoot_uint64_t ino) { long long int inoinag = VAS_EBOOT_XFS_INO_INOINAG (data, ino); long long ag = VAS_EBOOT_XFS_INO_AG (data, ino); long long block; block = (inoinag >> data->sblock.log2_inop) + ag * data->agsize; block <<= (data->sblock.log2_bsize - VAS_EBOOT_DISK_SECTOR_BITS); return block; } static inline int VasEBoot_xfs_inode_offset (struct VasEBoot_xfs_data *data, VasEBoot_uint64_t ino) { int inoag = VAS_EBOOT_XFS_INO_INOINAG (data, ino); return ((inoag & ((1 << data->sblock.log2_inop) - 1)) << data->sblock.log2_inode); } static inline VasEBoot_size_t VasEBoot_xfs_inode_size(struct VasEBoot_xfs_data *data) { return (VasEBoot_size_t)1 << data->sblock.log2_inode; } /* * Returns size occupied by XFS inode stored in memory - we store struct * VasEBoot_fshelp_node there but on disk inode size may be actually larger than * struct VasEBoot_xfs_inode so we need to account for that so that we can read * from disk directly into in-memory structure. */ static inline VasEBoot_size_t VasEBoot_xfs_fshelp_size(struct VasEBoot_xfs_data *data) { return sizeof (struct VasEBoot_fshelp_node) - sizeof (struct VasEBoot_xfs_inode) + VasEBoot_xfs_inode_size(data); } /* This should return void * but XFS code is error-prone with alignment, so return char to retain cast-align. */ static char * VasEBoot_xfs_inode_data(struct VasEBoot_xfs_inode *inode) { if (inode->version <= 2) return ((char *)inode) + XFS_V2_INODE_SIZE; return ((char *)inode) + XFS_V3_INODE_SIZE; } static struct VasEBoot_xfs_dir_entry * VasEBoot_xfs_inline_de(struct VasEBoot_xfs_dir_header *head) { /* With small inode numbers the header is 4 bytes smaller because of smaller parent pointer */ return (struct VasEBoot_xfs_dir_entry *) (((char *) head) + sizeof(struct VasEBoot_xfs_dir_header) - (head->largeino ? 0 : sizeof(VasEBoot_uint32_t))); } static VasEBoot_uint8_t * VasEBoot_xfs_inline_de_inopos(struct VasEBoot_xfs_data *data, struct VasEBoot_xfs_dir_entry *de) { return ((VasEBoot_uint8_t *)(de + 1)) + de->len - 1 + (data->hasftype ? 1 : 0); } static struct VasEBoot_xfs_dir_entry * VasEBoot_xfs_inline_next_de(struct VasEBoot_xfs_data *data, struct VasEBoot_xfs_dir_header *head, struct VasEBoot_xfs_dir_entry *de) { char *p = (char *)de + sizeof(struct VasEBoot_xfs_dir_entry) - 1 + de->len; p += head->largeino ? sizeof(VasEBoot_uint64_t) : sizeof(VasEBoot_uint32_t); if (data->hasftype) p++; return (struct VasEBoot_xfs_dir_entry *)p; } static struct VasEBoot_xfs_dirblock_tail * VasEBoot_xfs_dir_tail(struct VasEBoot_xfs_data *data, void *dirblock) { int dirblksize = 1 << (data->sblock.log2_bsize + data->sblock.log2_dirblk); return (struct VasEBoot_xfs_dirblock_tail *) ((char *)dirblock + dirblksize - sizeof (struct VasEBoot_xfs_dirblock_tail)); } static struct VasEBoot_xfs_dir2_entry * VasEBoot_xfs_first_de(struct VasEBoot_xfs_data *data, void *dirblock) { if (data->hascrc) return (struct VasEBoot_xfs_dir2_entry *)((char *)dirblock + 64); return (struct VasEBoot_xfs_dir2_entry *)((char *)dirblock + 16); } static struct VasEBoot_xfs_dir2_entry * VasEBoot_xfs_next_de(struct VasEBoot_xfs_data *data, struct VasEBoot_xfs_dir2_entry *de) { int size = sizeof (struct VasEBoot_xfs_dir2_entry) + de->len + 2 /* Tag */; if (data->hasftype) size++; /* File type */ return (struct VasEBoot_xfs_dir2_entry *)(((char *)de) + ALIGN_UP(size, 8)); } /* This should return void * but XFS code is error-prone with alignment, so return char to retain cast-align. */ static char * VasEBoot_xfs_btree_keys(struct VasEBoot_xfs_data *data, struct VasEBoot_xfs_btree_node *leaf) { char *keys = (char *)(leaf + 1); if (data->hascrc) keys += 48; /* skip crc, uuid, ... */ return keys; } static VasEBoot_err_t VasEBoot_xfs_read_inode (struct VasEBoot_xfs_data *data, VasEBoot_uint64_t ino, struct VasEBoot_xfs_inode *inode) { VasEBoot_uint64_t block = VasEBoot_xfs_inode_block (data, ino); int offset = VasEBoot_xfs_inode_offset (data, ino); VasEBoot_dprintf("xfs", "Reading inode (%" PRIuVAS_EBOOT_UINT64_T ") - %" PRIuVAS_EBOOT_UINT64_T ", %d\n", ino, block, offset); /* Read the inode. */ if (VasEBoot_disk_read (data->disk, block, offset, VasEBoot_xfs_inode_size(data), inode)) return VasEBoot_errno; if (VasEBoot_strncmp ((char *) inode->magic, "IN", 2)) return VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "not a correct XFS inode"); return 0; } static VasEBoot_uint64_t get_fsb (const void *keys, int idx) { const char *p = (const char *) keys + sizeof(VasEBoot_uint64_t) * idx; return VasEBoot_be_to_cpu64 (VasEBoot_get_unaligned64 (p)); } static int VasEBoot_xfs_inode_has_large_extent_counts (const struct VasEBoot_xfs_inode *inode) { return inode->version >= 3 && (inode->flags2 & VasEBoot_cpu_to_be64_compile_time (XFS_DIFLAG2_NREXT64)); } static VasEBoot_uint64_t VasEBoot_xfs_get_inode_nextents (struct VasEBoot_xfs_inode *inode) { return (VasEBoot_xfs_inode_has_large_extent_counts (inode)) ? VasEBoot_be_to_cpu64 (inode->nextents_big) : VasEBoot_be_to_cpu32 (inode->nextents); } static VasEBoot_disk_addr_t VasEBoot_xfs_read_block (VasEBoot_fshelp_node_t node, VasEBoot_disk_addr_t fileblock) { struct VasEBoot_xfs_btree_node *leaf = 0; VasEBoot_uint64_t ex, nrec; struct VasEBoot_xfs_extent *exts; VasEBoot_uint64_t ret = 0; if (node->inode.format == XFS_INODE_FORMAT_BTREE) { struct VasEBoot_xfs_btree_root *root; const char *keys; int recoffset; leaf = VasEBoot_malloc (node->data->bsize); if (leaf == 0) return 0; root = (struct VasEBoot_xfs_btree_root *) VasEBoot_xfs_inode_data(&node->inode); nrec = VasEBoot_be_to_cpu16 (root->numrecs); keys = (char *) &root->keys[0]; if (node->inode.fork_offset) recoffset = (node->inode.fork_offset - 1) / 2; else recoffset = (VasEBoot_xfs_inode_size(node->data) - ((char *) keys - (char *) &node->inode)) / (2 * sizeof (VasEBoot_uint64_t)); do { VasEBoot_uint64_t i; VasEBoot_addr_t keys_end, data_end; if (VasEBoot_mul (sizeof (VasEBoot_uint64_t), nrec, &keys_end) || VasEBoot_add ((VasEBoot_addr_t) keys, keys_end, &keys_end) || VasEBoot_add ((VasEBoot_addr_t) node->data, node->data->data_size, &data_end) || keys_end > data_end) { VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "invalid number of XFS root keys"); VasEBoot_free (leaf); return 0; } for (i = 0; i < nrec; i++) { if (fileblock < get_fsb(keys, i)) break; } /* Sparse block. */ if (i == 0) { VasEBoot_free (leaf); return 0; } if (VasEBoot_disk_read (node->data->disk, VAS_EBOOT_XFS_FSB_TO_BLOCK (node->data, get_fsb (keys, i - 1 + recoffset)) << (node->data->sblock.log2_bsize - VAS_EBOOT_DISK_SECTOR_BITS), 0, node->data->bsize, leaf)) { VasEBoot_free (leaf); return 0; } if ((!node->data->hascrc && VasEBoot_strncmp ((char *) leaf->magic, "BMAP", 4)) || (node->data->hascrc && VasEBoot_strncmp ((char *) leaf->magic, "BMA3", 4))) { VasEBoot_free (leaf); VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "not a correct XFS BMAP node"); return 0; } nrec = VasEBoot_be_to_cpu16 (leaf->numrecs); keys = VasEBoot_xfs_btree_keys(node->data, leaf); recoffset = ((node->data->bsize - ((char *) keys - (char *) leaf)) / (2 * sizeof (VasEBoot_uint64_t))); } while (leaf->level); exts = (struct VasEBoot_xfs_extent *) keys; } else if (node->inode.format == XFS_INODE_FORMAT_EXT) { VasEBoot_addr_t exts_end = 0; VasEBoot_addr_t data_end = 0; nrec = VasEBoot_xfs_get_inode_nextents (&node->inode); exts = (struct VasEBoot_xfs_extent *) VasEBoot_xfs_inode_data(&node->inode); if (VasEBoot_mul (sizeof (struct VasEBoot_xfs_extent), nrec, &exts_end) || VasEBoot_add ((VasEBoot_addr_t) node->data, exts_end, &exts_end) || VasEBoot_add ((VasEBoot_addr_t) node->data, node->data->data_size, &data_end) || exts_end > data_end) { VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "invalid number of XFS extents"); return 0; } } else { VasEBoot_error (VAS_EBOOT_ERR_NOT_IMPLEMENTED_YET, "XFS does not support inode format %d yet", node->inode.format); return 0; } /* Iterate over each extent to figure out which extent has the block we are looking for. */ for (ex = 0; ex < nrec; ex++) { VasEBoot_uint64_t start = VAS_EBOOT_XFS_EXTENT_BLOCK (exts, ex); VasEBoot_uint64_t offset = VAS_EBOOT_XFS_EXTENT_OFFSET (exts, ex); VasEBoot_uint64_t size = VAS_EBOOT_XFS_EXTENT_SIZE (exts, ex); /* Sparse block. */ if (fileblock < offset) break; else if (fileblock < offset + size) { ret = (fileblock - offset + start); break; } } VasEBoot_free (leaf); return VAS_EBOOT_XFS_FSB_TO_BLOCK(node->data, ret); } /* Read LEN bytes from the file described by DATA starting with byte POS. Return the amount of read bytes in READ. */ static VasEBoot_ssize_t VasEBoot_xfs_read_file (VasEBoot_fshelp_node_t node, VasEBoot_disk_read_hook_t read_hook, void *read_hook_data, VasEBoot_off_t pos, VasEBoot_size_t len, char *buf, VasEBoot_uint32_t header_size) { return VasEBoot_fshelp_read_file (node->data->disk, node, read_hook, read_hook_data, pos, len, buf, VasEBoot_xfs_read_block, VasEBoot_be_to_cpu64 (node->inode.size) + header_size, node->data->sblock.log2_bsize - VAS_EBOOT_DISK_SECTOR_BITS, 0); } static char * VasEBoot_xfs_read_symlink (VasEBoot_fshelp_node_t node) { VasEBoot_ssize_t size = VasEBoot_be_to_cpu64 (node->inode.size); VasEBoot_size_t sz; if (size < 0) { VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "invalid symlink"); return 0; } switch (node->inode.format) { case XFS_INODE_FORMAT_INO: return VasEBoot_strndup (VasEBoot_xfs_inode_data(&node->inode), size); case XFS_INODE_FORMAT_EXT: { char *symlink; VasEBoot_ssize_t numread; int off = 0; if (node->data->hascrc) off = 56; if (VasEBoot_add (size, 1, &sz)) { VasEBoot_error (VAS_EBOOT_ERR_OUT_OF_RANGE, N_("symlink size overflow")); return 0; } symlink = VasEBoot_malloc (sz); if (!symlink) return 0; node->inode.size = VasEBoot_be_to_cpu64 (size + off); numread = VasEBoot_xfs_read_file (node, 0, 0, off, size, symlink, off); if (numread != size) { VasEBoot_free (symlink); return 0; } symlink[size] = '\0'; return symlink; } } return 0; } static enum VasEBoot_fshelp_filetype VasEBoot_xfs_mode_to_filetype (VasEBoot_uint16_t mode) { if ((VasEBoot_be_to_cpu16 (mode) & FILETYPE_INO_MASK) == FILETYPE_INO_DIRECTORY) return VAS_EBOOT_FSHELP_DIR; else if ((VasEBoot_be_to_cpu16 (mode) & FILETYPE_INO_MASK) == FILETYPE_INO_SYMLINK) return VAS_EBOOT_FSHELP_SYMLINK; else if ((VasEBoot_be_to_cpu16 (mode) & FILETYPE_INO_MASK) == FILETYPE_INO_REG) return VAS_EBOOT_FSHELP_REG; return VAS_EBOOT_FSHELP_UNKNOWN; } /* Context for VasEBoot_xfs_iterate_dir. */ struct VasEBoot_xfs_iterate_dir_ctx { VasEBoot_fshelp_iterate_dir_hook_t hook; void *hook_data; struct VasEBoot_fshelp_node *diro; }; /* Helper for VasEBoot_xfs_iterate_dir. */ static int iterate_dir_call_hook (VasEBoot_uint64_t ino, const char *filename, struct VasEBoot_xfs_iterate_dir_ctx *ctx) { struct VasEBoot_fshelp_node *fdiro; VasEBoot_err_t err; VasEBoot_size_t sz; if (VasEBoot_add (VasEBoot_xfs_fshelp_size(ctx->diro->data), 1, &sz)) { VasEBoot_error (VAS_EBOOT_ERR_OUT_OF_RANGE, N_("directory data size overflow")); VasEBoot_print_error (); return 0; } fdiro = VasEBoot_malloc (sz); if (!fdiro) { VasEBoot_print_error (); return 0; } /* The inode should be read, otherwise the filetype can not be determined. */ fdiro->ino = ino; fdiro->inode_read = 1; fdiro->data = ctx->diro->data; err = VasEBoot_xfs_read_inode (ctx->diro->data, ino, &fdiro->inode); if (err) { VasEBoot_print_error (); VasEBoot_free (fdiro); return 0; } return ctx->hook (filename, VasEBoot_xfs_mode_to_filetype (fdiro->inode.mode), fdiro, ctx->hook_data); } static int VasEBoot_xfs_iterate_dir (VasEBoot_fshelp_node_t dir, VasEBoot_fshelp_iterate_dir_hook_t hook, void *hook_data) { struct VasEBoot_fshelp_node *diro = (struct VasEBoot_fshelp_node *) dir; struct VasEBoot_xfs_iterate_dir_ctx ctx = { .hook = hook, .hook_data = hook_data, .diro = diro }; switch (diro->inode.format) { case XFS_INODE_FORMAT_INO: { struct VasEBoot_xfs_dir_header *head = (struct VasEBoot_xfs_dir_header *) VasEBoot_xfs_inode_data(&diro->inode); struct VasEBoot_xfs_dir_entry *de = VasEBoot_xfs_inline_de(head); int smallino = !head->largeino; int i; VasEBoot_uint64_t parent; /* If small inode numbers are used to pack the direntry, the parent inode number is small too. */ if (smallino) parent = VasEBoot_be_to_cpu32 (head->parent.i4); else parent = VasEBoot_be_to_cpu64 (head->parent.i8); /* Synthesize the direntries for `.' and `..'. */ if (iterate_dir_call_hook (diro->ino, ".", &ctx)) return 1; if (iterate_dir_call_hook (parent, "..", &ctx)) return 1; for (i = 0; i < head->count && (VasEBoot_uint8_t *) de < ((VasEBoot_uint8_t *) dir + VasEBoot_xfs_fshelp_size (dir->data)); i++) { VasEBoot_uint64_t ino; VasEBoot_uint8_t *inopos = VasEBoot_xfs_inline_de_inopos(dir->data, de); VasEBoot_uint8_t c; if ((inopos + (smallino ? 4 : 8)) > (VasEBoot_uint8_t *) dir + VasEBoot_xfs_fshelp_size (dir->data)) { VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "invalid XFS inode"); return 0; } /* inopos might be unaligned. */ if (smallino) ino = (((VasEBoot_uint32_t) inopos[0]) << 24) | (((VasEBoot_uint32_t) inopos[1]) << 16) | (((VasEBoot_uint32_t) inopos[2]) << 8) | (((VasEBoot_uint32_t) inopos[3]) << 0); else ino = (((VasEBoot_uint64_t) inopos[0]) << 56) | (((VasEBoot_uint64_t) inopos[1]) << 48) | (((VasEBoot_uint64_t) inopos[2]) << 40) | (((VasEBoot_uint64_t) inopos[3]) << 32) | (((VasEBoot_uint64_t) inopos[4]) << 24) | (((VasEBoot_uint64_t) inopos[5]) << 16) | (((VasEBoot_uint64_t) inopos[6]) << 8) | (((VasEBoot_uint64_t) inopos[7]) << 0); c = de->name[de->len]; de->name[de->len] = '\0'; if (iterate_dir_call_hook (ino, de->name, &ctx)) { de->name[de->len] = c; return 1; } de->name[de->len] = c; de = VasEBoot_xfs_inline_next_de(dir->data, head, de); } break; } case XFS_INODE_FORMAT_BTREE: case XFS_INODE_FORMAT_EXT: { VasEBoot_ssize_t numread; char *dirblock; VasEBoot_uint64_t blk; int dirblk_size, dirblk_log2; dirblk_log2 = (dir->data->sblock.log2_bsize + dir->data->sblock.log2_dirblk); dirblk_size = 1 << dirblk_log2; dirblock = VasEBoot_malloc (dirblk_size); if (! dirblock) return 0; /* Iterate over every block the directory has. */ for (blk = 0; blk < (VasEBoot_be_to_cpu64 (dir->inode.size) >> dirblk_log2); blk++) { struct VasEBoot_xfs_dir2_entry *direntry = VasEBoot_xfs_first_de(dir->data, dirblock); int entries = -1; char *end = dirblock + dirblk_size; VasEBoot_uint32_t magic; numread = VasEBoot_xfs_read_file (dir, 0, 0, blk << dirblk_log2, dirblk_size, dirblock, 0); if (numread != dirblk_size) { VasEBoot_free (dirblock); return 0; } /* * If this data block isn't actually part of the extent list then * VasEBoot_xfs_read_file() returns a block of zeros. So, if the magic * number field is all zeros then this block should be skipped. */ magic = *(VasEBoot_uint32_t *)(void *) dirblock; if (!magic) continue; /* * Leaf and tail information are only in the data block if the number * of extents is 1. */ if (VasEBoot_xfs_get_inode_nextents (&dir->inode) == 1) { struct VasEBoot_xfs_dirblock_tail *tail = VasEBoot_xfs_dir_tail (dir->data, dirblock); end = (char *) tail; /* Subtract the space used by leaf nodes. */ end -= VasEBoot_be_to_cpu32 (tail->leaf_count) * sizeof (struct VasEBoot_xfs_dir_leaf_entry); entries = VasEBoot_be_to_cpu32 (tail->leaf_count) - VasEBoot_be_to_cpu32 (tail->leaf_stale); if (!entries) continue; } /* Iterate over all entries within this block. */ while ((char *) direntry < (char *) end) { VasEBoot_uint8_t *freetag; char *filename; freetag = (VasEBoot_uint8_t *) direntry; if (VasEBoot_get_unaligned16 (freetag) == 0XFFFF) { VasEBoot_uint8_t *skip = (freetag + sizeof (VasEBoot_uint16_t)); /* This entry is not used, go to the next one. */ direntry = (struct VasEBoot_xfs_dir2_entry *) (((char *)direntry) + VasEBoot_be_to_cpu16 (VasEBoot_get_unaligned16 (skip))); continue; } filename = (char *)(direntry + 1); if (filename + direntry->len + 1 > (char *) end) { VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "invalid XFS directory entry"); return 0; } /* The byte after the filename is for the filetype, padding, or tag, which is not used by VAS_EBOOT. So it can be overwritten. */ filename[direntry->len] = '\0'; if (iterate_dir_call_hook (VasEBoot_be_to_cpu64(direntry->inode), filename, &ctx)) { VasEBoot_free (dirblock); return 1; } /* * The expected number of directory entries is only tracked for the * single extent case. */ if (VasEBoot_xfs_get_inode_nextents (&dir->inode) == 1) { /* Check if last direntry in this block is reached. */ entries--; if (!entries) break; } /* Select the next directory entry. */ direntry = VasEBoot_xfs_next_de(dir->data, direntry); } } VasEBoot_free (dirblock); break; } default: VasEBoot_error (VAS_EBOOT_ERR_NOT_IMPLEMENTED_YET, "XFS does not support inode format %d yet", diro->inode.format); } return 0; } static struct VasEBoot_xfs_data * VasEBoot_xfs_mount (VasEBoot_disk_t disk) { struct VasEBoot_xfs_data *data = 0; VasEBoot_size_t sz; data = VasEBoot_zalloc (sizeof (struct VasEBoot_xfs_data)); if (!data) return 0; data->data_size = sizeof (struct VasEBoot_xfs_data); VasEBoot_dprintf("xfs", "Reading sb\n"); /* Read the superblock. */ if (VasEBoot_disk_read (disk, 0, 0, sizeof (struct VasEBoot_xfs_sblock), &data->sblock)) goto fail; if (!VasEBoot_xfs_sb_valid(data)) goto fail; if (VasEBoot_xfs_sb_needs_repair (data)) VasEBoot_dprintf ("xfs", "XFS filesystem needs repair, boot may fail\n"); if (VasEBoot_add (VasEBoot_xfs_inode_size (data), sizeof (struct VasEBoot_xfs_data) - sizeof (struct VasEBoot_xfs_inode) + 1, &sz)) goto fail; data = VasEBoot_realloc (data, sz); if (! data) goto fail; data->data_size = sz; data->diropen.data = data; data->diropen.ino = VasEBoot_be_to_cpu64(data->sblock.rootino); data->diropen.inode_read = 1; data->bsize = VasEBoot_be_to_cpu32 (data->sblock.bsize); data->agsize = VasEBoot_be_to_cpu32 (data->sblock.agsize); data->hasftype = VasEBoot_xfs_sb_hasftype(data); data->hascrc = VasEBoot_xfs_sb_hascrc(data); data->disk = disk; data->pos = 0; VasEBoot_dprintf("xfs", "Reading root ino %" PRIuVAS_EBOOT_UINT64_T "\n", VasEBoot_cpu_to_be64(data->sblock.rootino)); VasEBoot_xfs_read_inode (data, data->diropen.ino, &data->diropen.inode); return data; fail: if (VasEBoot_errno == VAS_EBOOT_ERR_OUT_OF_RANGE || VasEBoot_errno == VAS_EBOOT_ERR_NONE) VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "not an XFS filesystem"); VasEBoot_free (data); return 0; } /* Context for VasEBoot_xfs_dir. */ struct VasEBoot_xfs_dir_ctx { VasEBoot_fs_dir_hook_t hook; void *hook_data; }; /* Bigtime inodes helpers. */ #define XFS_BIGTIME_EPOCH_OFFSET (-(VasEBoot_int64_t) VAS_EBOOT_INT32_MIN) static int VasEBoot_xfs_inode_has_bigtime (const struct VasEBoot_xfs_inode *inode) { return inode->version >= 3 && (inode->flags2 & VasEBoot_cpu_to_be64_compile_time (XFS_DIFLAG2_BIGTIME)); } static VasEBoot_int64_t VasEBoot_xfs_get_inode_time (struct VasEBoot_xfs_inode *inode) { struct VasEBoot_xfs_time_legacy *lts; if (VasEBoot_xfs_inode_has_bigtime (inode)) return VasEBoot_divmod64 (VasEBoot_be_to_cpu64 (inode->mtime), NSEC_PER_SEC, NULL) - XFS_BIGTIME_EPOCH_OFFSET; lts = (struct VasEBoot_xfs_time_legacy *) &inode->mtime; return VasEBoot_be_to_cpu32 (lts->sec); } /* Helper for VasEBoot_xfs_dir. */ static int VasEBoot_xfs_dir_iter (const char *filename, enum VasEBoot_fshelp_filetype filetype, VasEBoot_fshelp_node_t node, void *data) { struct VasEBoot_xfs_dir_ctx *ctx = data; struct VasEBoot_dirhook_info info; VasEBoot_memset (&info, 0, sizeof (info)); if (node->inode_read) { info.mtimeset = 1; info.mtime = VasEBoot_xfs_get_inode_time (&node->inode); } info.dir = ((filetype & VAS_EBOOT_FSHELP_TYPE_MASK) == VAS_EBOOT_FSHELP_DIR); VasEBoot_free (node); return ctx->hook (filename, &info, ctx->hook_data); } static VasEBoot_err_t VasEBoot_xfs_dir (VasEBoot_device_t device, const char *path, VasEBoot_fs_dir_hook_t hook, void *hook_data) { struct VasEBoot_xfs_dir_ctx ctx = { hook, hook_data }; struct VasEBoot_xfs_data *data = 0; struct VasEBoot_fshelp_node *fdiro = 0; VasEBoot_dl_ref (my_mod); data = VasEBoot_xfs_mount (device->disk); if (!data) goto mount_fail; VasEBoot_fshelp_find_file (path, &data->diropen, &fdiro, VasEBoot_xfs_iterate_dir, VasEBoot_xfs_read_symlink, VAS_EBOOT_FSHELP_DIR); if (VasEBoot_errno) goto fail; VasEBoot_xfs_iterate_dir (fdiro, VasEBoot_xfs_dir_iter, &ctx); fail: if (fdiro != &data->diropen) VasEBoot_free (fdiro); VasEBoot_free (data); mount_fail: VasEBoot_dl_unref (my_mod); return VasEBoot_errno; } /* Open a file named NAME and initialize FILE. */ static VasEBoot_err_t VasEBoot_xfs_open (struct VasEBoot_file *file, const char *name) { struct VasEBoot_xfs_data *data; struct VasEBoot_fshelp_node *fdiro = 0; VasEBoot_dl_ref (my_mod); data = VasEBoot_xfs_mount (file->device->disk); if (!data) goto mount_fail; VasEBoot_fshelp_find_file (name, &data->diropen, &fdiro, VasEBoot_xfs_iterate_dir, VasEBoot_xfs_read_symlink, VAS_EBOOT_FSHELP_REG); if (VasEBoot_errno) goto fail; if (!fdiro->inode_read) { VasEBoot_xfs_read_inode (data, fdiro->ino, &fdiro->inode); if (VasEBoot_errno) goto fail; } if (fdiro != &data->diropen) { VasEBoot_memcpy (&data->diropen, fdiro, VasEBoot_xfs_fshelp_size(data)); VasEBoot_free (fdiro); } file->size = VasEBoot_be_to_cpu64 (data->diropen.inode.size); file->data = data; file->offset = 0; return 0; fail: if (fdiro != &data->diropen) VasEBoot_free (fdiro); VasEBoot_free (data); mount_fail: VasEBoot_dl_unref (my_mod); return VasEBoot_errno; } static VasEBoot_ssize_t VasEBoot_xfs_read (VasEBoot_file_t file, char *buf, VasEBoot_size_t len) { struct VasEBoot_xfs_data *data = (struct VasEBoot_xfs_data *) file->data; return VasEBoot_xfs_read_file (&data->diropen, file->read_hook, file->read_hook_data, file->offset, len, buf, 0); } static VasEBoot_err_t VasEBoot_xfs_close (VasEBoot_file_t file) { VasEBoot_free (file->data); VasEBoot_dl_unref (my_mod); return VAS_EBOOT_ERR_NONE; } static VasEBoot_err_t VasEBoot_xfs_label (VasEBoot_device_t device, char **label) { struct VasEBoot_xfs_data *data; VasEBoot_disk_t disk = device->disk; VasEBoot_dl_ref (my_mod); data = VasEBoot_xfs_mount (disk); if (data) *label = VasEBoot_strndup ((char *) (data->sblock.label), 12); else *label = 0; VasEBoot_dl_unref (my_mod); VasEBoot_free (data); return VasEBoot_errno; } static VasEBoot_err_t VasEBoot_xfs_uuid (VasEBoot_device_t device, char **uuid) { struct VasEBoot_xfs_data *data; VasEBoot_disk_t disk = device->disk; VasEBoot_dl_ref (my_mod); data = VasEBoot_xfs_mount (disk); if (data) { *uuid = VasEBoot_xasprintf ("%04x%04x-%04x-%04x-%04x-%04x%04x%04x", VasEBoot_be_to_cpu16 (data->sblock.uuid[0]), VasEBoot_be_to_cpu16 (data->sblock.uuid[1]), VasEBoot_be_to_cpu16 (data->sblock.uuid[2]), VasEBoot_be_to_cpu16 (data->sblock.uuid[3]), VasEBoot_be_to_cpu16 (data->sblock.uuid[4]), VasEBoot_be_to_cpu16 (data->sblock.uuid[5]), VasEBoot_be_to_cpu16 (data->sblock.uuid[6]), VasEBoot_be_to_cpu16 (data->sblock.uuid[7])); } else *uuid = NULL; VasEBoot_dl_unref (my_mod); VasEBoot_free (data); return VasEBoot_errno; } static struct VasEBoot_fs VasEBoot_xfs_fs = { .name = "xfs", .fs_dir = VasEBoot_xfs_dir, .fs_open = VasEBoot_xfs_open, .fs_read = VasEBoot_xfs_read, .fs_close = VasEBoot_xfs_close, .fs_label = VasEBoot_xfs_label, .fs_uuid = VasEBoot_xfs_uuid, #ifdef VAS_EBOOT_UTIL .reserved_first_sector = 0, .blocklist_install = 1, #endif .next = 0 }; VAS_EBOOT_MOD_INIT(xfs) { VasEBoot_xfs_fs.mod = mod; VasEBoot_fs_register (&VasEBoot_xfs_fs); my_mod = mod; } VAS_EBOOT_MOD_FINI(xfs) { VasEBoot_fs_unregister (&VasEBoot_xfs_fs); }