PK!sVVbitops.hnu[/* * bitops.h --- Bitmap frobbing code. The byte swapping routines are * also included here. * * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o. * * %Begin-Header% * This file may be redistributed under the terms of the GNU Library * General Public License, version 2. * %End-Header% */ #ifdef WORDS_BIGENDIAN #define ext2fs_cpu_to_le64(x) ((__force __le64)ext2fs_swab64((__u64)(x))) #define ext2fs_le64_to_cpu(x) ext2fs_swab64((__force __u64)(__le64)(x)) #define ext2fs_cpu_to_le32(x) ((__force __le32)ext2fs_swab32((__u32)(x))) #define ext2fs_le32_to_cpu(x) ext2fs_swab32((__force __u32)(__le32)(x)) #define ext2fs_cpu_to_le16(x) ((__force __le16)ext2fs_swab16((__u16)(x))) #define ext2fs_le16_to_cpu(x) ext2fs_swab16((__force __u16)(__le16)(x)) #define ext2fs_cpu_to_be64(x) ((__force __be64)(__u64)(x)) #define ext2fs_be64_to_cpu(x) ((__force __u64)(__be64)(x)) #define ext2fs_cpu_to_be32(x) ((__force __be32)(__u32)(x)) #define ext2fs_be32_to_cpu(x) ((__force __u32)(__be32)(x)) #define ext2fs_cpu_to_be16(x) ((__force __be16)(__u16)(x)) #define ext2fs_be16_to_cpu(x) ((__force __u16)(__be16)(x)) #else #define ext2fs_cpu_to_le64(x) ((__force __le64)(__u64)(x)) #define ext2fs_le64_to_cpu(x) ((__force __u64)(__le64)(x)) #define ext2fs_cpu_to_le32(x) ((__force __le32)(__u32)(x)) #define ext2fs_le32_to_cpu(x) ((__force __u32)(__le32)(x)) #define ext2fs_cpu_to_le16(x) ((__force __le16)(__u16)(x)) #define ext2fs_le16_to_cpu(x) ((__force __u16)(__le16)(x)) #define ext2fs_cpu_to_be64(x) ((__force __be64)ext2fs_swab64((__u64)(x))) #define ext2fs_be64_to_cpu(x) ext2fs_swab64((__force __u64)(__be64)(x)) #define ext2fs_cpu_to_be32(x) ((__force __be32)ext2fs_swab32((__u32)(x))) #define ext2fs_be32_to_cpu(x) ext2fs_swab32((__force __u32)(__be32)(x)) #define ext2fs_cpu_to_be16(x) ((__force __be16)ext2fs_swab16((__u16)(x))) #define ext2fs_be16_to_cpu(x) ext2fs_swab16((__force __u16)(__be16)(x)) #endif /* * EXT2FS bitmap manipulation routines. */ /* Support for sending warning messages from the inline subroutines */ extern const char *ext2fs_block_string; extern const char *ext2fs_inode_string; extern const char *ext2fs_mark_string; extern const char *ext2fs_unmark_string; extern const char *ext2fs_test_string; extern void ext2fs_warn_bitmap(errcode_t errcode, unsigned long arg, const char *description); extern void ext2fs_warn_bitmap2(ext2fs_generic_bitmap bitmap, int code, unsigned long arg); #ifdef NO_INLINE_FUNCS extern void ext2fs_fast_set_bit(unsigned int nr,void * addr); extern void ext2fs_fast_clear_bit(unsigned int nr, void * addr); extern void ext2fs_fast_set_bit64(__u64 nr,void * addr); extern void ext2fs_fast_clear_bit64(__u64 nr, void * addr); extern __u16 ext2fs_swab16(__u16 val); extern __u32 ext2fs_swab32(__u32 val); extern __u64 ext2fs_swab64(__u64 val); extern int ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block); extern int ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block); extern int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block); extern int ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode); extern int ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode); extern int ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode); extern void ext2fs_fast_mark_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block); extern void ext2fs_fast_unmark_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block); extern int ext2fs_fast_test_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block); extern void ext2fs_fast_mark_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode); extern void ext2fs_fast_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode); extern int ext2fs_fast_test_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode); extern blk_t ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap); extern ext2_ino_t ext2fs_get_inode_bitmap_start(ext2fs_inode_bitmap bitmap); extern blk_t ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap); extern ext2_ino_t ext2fs_get_inode_bitmap_end(ext2fs_inode_bitmap bitmap); extern void ext2fs_fast_mark_block_bitmap_range(ext2fs_block_bitmap bitmap, blk_t block, int num); extern void ext2fs_fast_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap, blk_t block, int num); extern int ext2fs_fast_test_block_bitmap_range(ext2fs_block_bitmap bitmap, blk_t block, int num); #endif /* These functions routines moved to gen_bitmap.c */ extern void ext2fs_mark_block_bitmap_range(ext2fs_block_bitmap bitmap, blk_t block, int num); extern void ext2fs_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap, blk_t block, int num); extern int ext2fs_test_block_bitmap_range(ext2fs_block_bitmap bitmap, blk_t block, int num); extern int ext2fs_test_inode_bitmap_range(ext2fs_inode_bitmap bitmap, ext2_ino_t inode, int num); extern int ext2fs_mark_generic_bitmap(ext2fs_generic_bitmap bitmap, __u32 bitno); extern int ext2fs_unmark_generic_bitmap(ext2fs_generic_bitmap bitmap, blk_t bitno); extern int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap, blk_t bitno); extern int ext2fs_test_block_bitmap_range(ext2fs_block_bitmap bitmap, blk_t block, int num); extern void ext2fs_set_bitmap_padding(ext2fs_generic_bitmap map); extern __u32 ext2fs_get_generic_bitmap_start(ext2fs_generic_bitmap bitmap); extern __u32 ext2fs_get_generic_bitmap_end(ext2fs_generic_bitmap bitmap); /* 64-bit versions */ #ifdef NO_INLINE_FUNCS extern int ext2fs_mark_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t block); extern int ext2fs_unmark_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t block); extern int ext2fs_test_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t block); extern int ext2fs_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t inode); extern int ext2fs_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t inode); extern int ext2fs_test_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t inode); extern void ext2fs_fast_mark_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t block); extern void ext2fs_fast_unmark_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t block); extern int ext2fs_fast_test_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t block); extern void ext2fs_fast_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t inode); extern void ext2fs_fast_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t inode); extern int ext2fs_fast_test_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t inode); extern errcode_t ext2fs_find_first_zero_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t start, blk64_t end, blk64_t *out); extern errcode_t ext2fs_find_first_zero_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t start, ext2_ino_t end, ext2_ino_t *out); extern errcode_t ext2fs_find_first_set_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t start, blk64_t end, blk64_t *out); extern errcode_t ext2fs_find_first_set_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t start, ext2_ino_t end, ext2_ino_t *out); extern blk64_t ext2fs_get_block_bitmap_start2(ext2fs_block_bitmap bitmap); extern ext2_ino_t ext2fs_get_inode_bitmap_start2(ext2fs_inode_bitmap bitmap); extern blk64_t ext2fs_get_block_bitmap_end2(ext2fs_block_bitmap bitmap); extern ext2_ino_t ext2fs_get_inode_bitmap_end2(ext2fs_inode_bitmap bitmap); extern int ext2fs_fast_test_block_bitmap_range2(ext2fs_block_bitmap bitmap, blk64_t block, unsigned int num); extern void ext2fs_fast_mark_block_bitmap_range2(ext2fs_block_bitmap bitmap, blk64_t block, unsigned int num); extern void ext2fs_fast_unmark_block_bitmap_range2(ext2fs_block_bitmap bitmap, blk64_t block, unsigned int num); #endif /* These routines moved to gen_bitmap64.c */ extern void ext2fs_clear_generic_bmap(ext2fs_generic_bitmap bitmap); extern errcode_t ext2fs_compare_generic_bmap(errcode_t neq, ext2fs_generic_bitmap bm1, ext2fs_generic_bitmap bm2); extern void ext2fs_set_generic_bmap_padding(ext2fs_generic_bitmap bmap); extern int ext2fs_mark_generic_bmap(ext2fs_generic_bitmap bitmap, blk64_t bitno); extern int ext2fs_unmark_generic_bmap(ext2fs_generic_bitmap bitmap, blk64_t bitno); extern int ext2fs_test_generic_bmap(ext2fs_generic_bitmap bitmap, blk64_t bitno); extern int ext2fs_test_block_bitmap_range2(ext2fs_block_bitmap bitmap, blk64_t block, unsigned int num); extern __u64 ext2fs_get_generic_bmap_start(ext2fs_generic_bitmap bitmap); extern __u64 ext2fs_get_generic_bmap_end(ext2fs_generic_bitmap bitmap); extern int ext2fs_test_block_bitmap_range2(ext2fs_block_bitmap bitmap, blk64_t block, unsigned int num); extern void ext2fs_mark_block_bitmap_range2(ext2fs_block_bitmap bitmap, blk64_t block, unsigned int num); extern void ext2fs_unmark_block_bitmap_range2(ext2fs_block_bitmap bitmap, blk64_t block, unsigned int num); extern errcode_t ext2fs_find_first_zero_generic_bmap(ext2fs_generic_bitmap bitmap, __u64 start, __u64 end, __u64 *out); extern errcode_t ext2fs_find_first_set_generic_bmap(ext2fs_generic_bitmap bitmap, __u64 start, __u64 end, __u64 *out); /* * The inline routines themselves... * * If NO_INLINE_FUNCS is defined, then we won't try to do inline * functions at all; they will be included as normal functions in * inline.c */ #ifdef NO_INLINE_FUNCS #if (defined(__GNUC__) && (defined(__i386__) || defined(__i486__) || \ defined(__i586__))) /* This prevents bitops.c from trying to include the C */ /* function version of these functions */ #define _EXT2_HAVE_ASM_BITOPS_ #endif #endif /* NO_INLINE_FUNCS */ #if (defined(INCLUDE_INLINE_FUNCS) || !defined(NO_INLINE_FUNCS)) #ifdef INCLUDE_INLINE_FUNCS #if (__STDC_VERSION__ >= 199901L) #define _INLINE_ extern inline #else #define _INLINE_ inline #endif #else /* !INCLUDE_INLINE FUNCS */ #if (__STDC_VERSION__ >= 199901L) #define _INLINE_ inline #else /* not C99 */ #ifdef __GNUC__ #define _INLINE_ extern __inline__ #else /* For Watcom C */ #define _INLINE_ extern inline #endif /* __GNUC__ */ #endif /* __STDC_VERSION__ >= 199901L */ #endif /* INCLUDE_INLINE_FUNCS */ /* * Fast bit set/clear functions that doesn't need to return the * previous bit value. */ _INLINE_ void ext2fs_fast_set_bit(unsigned int nr,void * addr) { unsigned char *ADDR = (unsigned char *) addr; ADDR += nr >> 3; *ADDR |= (unsigned char) (1 << (nr & 0x07)); } _INLINE_ void ext2fs_fast_clear_bit(unsigned int nr, void * addr) { unsigned char *ADDR = (unsigned char *) addr; ADDR += nr >> 3; *ADDR &= (unsigned char) ~(1 << (nr & 0x07)); } _INLINE_ void ext2fs_fast_set_bit64(__u64 nr, void * addr) { unsigned char *ADDR = (unsigned char *) addr; ADDR += nr >> 3; *ADDR |= (unsigned char) (1 << (nr & 0x07)); } _INLINE_ void ext2fs_fast_clear_bit64(__u64 nr, void * addr) { unsigned char *ADDR = (unsigned char *) addr; ADDR += nr >> 3; *ADDR &= (unsigned char) ~(1 << (nr & 0x07)); } #if ((defined __GNUC__) && !defined(_EXT2_USE_C_VERSIONS_) && \ (defined(__i386__) || defined(__i486__) || defined(__i586__))) #define _EXT2_HAVE_ASM_BITOPS_ #define _EXT2_HAVE_ASM_SWAB_ /* * These are done by inline assembly for speed reasons..... * * All bitoperations return 0 if the bit was cleared before the * operation and != 0 if it was not. Bit 0 is the LSB of addr; bit 32 * is the LSB of (addr+1). */ /* * Some hacks to defeat gcc over-optimizations.. */ struct __dummy_h { unsigned long a[100]; }; #define EXT2FS_ADDR (*(struct __dummy_h *) addr) #define EXT2FS_CONST_ADDR (*(const struct __dummy_h *) addr) _INLINE_ int ext2fs_set_bit(unsigned int nr, void * addr) { int oldbit; addr = (void *) (((unsigned char *) addr) + (nr >> 3)); __asm__ __volatile__("btsl %2,%1\n\tsbbl %0,%0" :"=r" (oldbit),"+m" (EXT2FS_ADDR) :"r" (nr & 7)); return oldbit; } _INLINE_ int ext2fs_clear_bit(unsigned int nr, void * addr) { int oldbit; addr = (void *) (((unsigned char *) addr) + (nr >> 3)); __asm__ __volatile__("btrl %2,%1\n\tsbbl %0,%0" :"=r" (oldbit),"+m" (EXT2FS_ADDR) :"r" (nr & 7)); return oldbit; } _INLINE_ int ext2fs_test_bit(unsigned int nr, const void * addr) { int oldbit; addr = (const void *) (((const unsigned char *) addr) + (nr >> 3)); __asm__ __volatile__("btl %2,%1\n\tsbbl %0,%0" :"=r" (oldbit) :"m" (EXT2FS_CONST_ADDR),"r" (nr & 7)); return oldbit; } _INLINE_ __u32 ext2fs_swab32(__u32 val) { #ifdef EXT2FS_REQUIRE_486 __asm__("bswap %0" : "=r" (val) : "0" (val)); #else __asm__("xchgb %b0,%h0\n\t" /* swap lower bytes */ "rorl $16,%0\n\t" /* swap words */ "xchgb %b0,%h0" /* swap higher bytes */ :"=q" (val) : "0" (val)); #endif return val; } _INLINE_ __u16 ext2fs_swab16(__u16 val) { __asm__("xchgb %b0,%h0" /* swap bytes */ \ : "=q" (val) \ : "0" (val)); \ return val; } #undef EXT2FS_ADDR #endif /* i386 */ #if !defined(_EXT2_HAVE_ASM_SWAB_) _INLINE_ __u16 ext2fs_swab16(__u16 val) { return (val >> 8) | (__u16) (val << 8); } _INLINE_ __u32 ext2fs_swab32(__u32 val) { return ((val>>24) | ((val>>8)&0xFF00) | ((val<<8)&0xFF0000) | (val<<24)); } #endif /* !_EXT2_HAVE_ASM_SWAB */ _INLINE_ __u64 ext2fs_swab64(__u64 val) { return (ext2fs_swab32((__u32) (val >> 32)) | (((__u64)ext2fs_swab32(val & 0xFFFFFFFFUL)) << 32)); } _INLINE_ int ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block) { return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, block); } _INLINE_ int ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block) { return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, block); } _INLINE_ int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block) { return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, block); } _INLINE_ int ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode) { return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, inode); } _INLINE_ int ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode) { return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, inode); } _INLINE_ int ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode) { return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, inode); } _INLINE_ void ext2fs_fast_mark_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block) { ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, block); } _INLINE_ void ext2fs_fast_unmark_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block) { ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, block); } _INLINE_ int ext2fs_fast_test_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block) { return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, block); } _INLINE_ void ext2fs_fast_mark_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode) { ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, inode); } _INLINE_ void ext2fs_fast_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode) { ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, inode); } _INLINE_ int ext2fs_fast_test_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode) { return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, inode); } _INLINE_ blk_t ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap) { return ext2fs_get_generic_bitmap_start((ext2fs_generic_bitmap) bitmap); } _INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_start(ext2fs_inode_bitmap bitmap) { return ext2fs_get_generic_bitmap_start((ext2fs_generic_bitmap) bitmap); } _INLINE_ blk_t ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap) { return ext2fs_get_generic_bitmap_end((ext2fs_generic_bitmap) bitmap); } _INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_end(ext2fs_inode_bitmap bitmap) { return ext2fs_get_generic_bitmap_end((ext2fs_generic_bitmap) bitmap); } _INLINE_ int ext2fs_fast_test_block_bitmap_range(ext2fs_block_bitmap bitmap, blk_t block, int num) { return ext2fs_test_block_bitmap_range(bitmap, block, num); } _INLINE_ void ext2fs_fast_mark_block_bitmap_range(ext2fs_block_bitmap bitmap, blk_t block, int num) { ext2fs_mark_block_bitmap_range(bitmap, block, num); } _INLINE_ void ext2fs_fast_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap, blk_t block, int num) { ext2fs_unmark_block_bitmap_range(bitmap, block, num); } /* 64-bit versions */ _INLINE_ int ext2fs_mark_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t block) { return ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, block); } _INLINE_ int ext2fs_unmark_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t block) { return ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, block); } _INLINE_ int ext2fs_test_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t block) { return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap, block); } _INLINE_ int ext2fs_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t inode) { return ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, inode); } _INLINE_ int ext2fs_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t inode) { return ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, inode); } _INLINE_ int ext2fs_test_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t inode) { return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap, inode); } _INLINE_ void ext2fs_fast_mark_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t block) { ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, block); } _INLINE_ void ext2fs_fast_unmark_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t block) { ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, block); } _INLINE_ int ext2fs_fast_test_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t block) { return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap, block); } _INLINE_ void ext2fs_fast_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t inode) { ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, inode); } _INLINE_ void ext2fs_fast_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t inode) { ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, inode); } _INLINE_ int ext2fs_fast_test_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t inode) { return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap, inode); } _INLINE_ errcode_t ext2fs_find_first_zero_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t start, blk64_t end, blk64_t *out) { __u64 o; errcode_t rv; rv = ext2fs_find_first_zero_generic_bmap((ext2fs_generic_bitmap) bitmap, start, end, &o); if (!rv) *out = o; return rv; } _INLINE_ errcode_t ext2fs_find_first_zero_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t start, ext2_ino_t end, ext2_ino_t *out) { __u64 o; errcode_t rv; rv = ext2fs_find_first_zero_generic_bmap((ext2fs_generic_bitmap) bitmap, start, end, &o); if (!rv) *out = (ext2_ino_t) o; return rv; } _INLINE_ errcode_t ext2fs_find_first_set_block_bitmap2(ext2fs_block_bitmap bitmap, blk64_t start, blk64_t end, blk64_t *out) { __u64 o; errcode_t rv; rv = ext2fs_find_first_set_generic_bmap((ext2fs_generic_bitmap) bitmap, start, end, &o); if (!rv) *out = o; return rv; } _INLINE_ errcode_t ext2fs_find_first_set_inode_bitmap2(ext2fs_inode_bitmap bitmap, ext2_ino_t start, ext2_ino_t end, ext2_ino_t *out) { __u64 o; errcode_t rv; rv = ext2fs_find_first_set_generic_bmap((ext2fs_generic_bitmap) bitmap, start, end, &o); if (!rv) *out = (ext2_ino_t) o; return rv; } _INLINE_ blk64_t ext2fs_get_block_bitmap_start2(ext2fs_block_bitmap bitmap) { return ext2fs_get_generic_bmap_start((ext2fs_generic_bitmap) bitmap); } _INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_start2(ext2fs_inode_bitmap bitmap) { return (ext2_ino_t) ext2fs_get_generic_bmap_start((ext2fs_generic_bitmap) bitmap); } _INLINE_ blk64_t ext2fs_get_block_bitmap_end2(ext2fs_block_bitmap bitmap) { return ext2fs_get_generic_bmap_end((ext2fs_generic_bitmap) bitmap); } _INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_end2(ext2fs_inode_bitmap bitmap) { return (ext2_ino_t) ext2fs_get_generic_bmap_end((ext2fs_generic_bitmap) bitmap); } _INLINE_ int ext2fs_fast_test_block_bitmap_range2(ext2fs_block_bitmap bitmap, blk64_t block, unsigned int num) { return ext2fs_test_block_bitmap_range2(bitmap, block, num); } _INLINE_ void ext2fs_fast_mark_block_bitmap_range2(ext2fs_block_bitmap bitmap, blk64_t block, unsigned int num) { ext2fs_mark_block_bitmap_range2(bitmap, block, num); } _INLINE_ void ext2fs_fast_unmark_block_bitmap_range2(ext2fs_block_bitmap bitmap, blk64_t block, unsigned int num) { ext2fs_unmark_block_bitmap_range2(bitmap, block, num); } #undef _INLINE_ #endif #ifndef _EXT2_HAVE_ASM_BITOPS_ extern int ext2fs_set_bit(unsigned int nr,void * addr); extern int ext2fs_clear_bit(unsigned int nr, void * addr); extern int ext2fs_test_bit(unsigned int nr, const void * addr); #endif extern int ext2fs_set_bit64(__u64 nr,void * addr); extern int ext2fs_clear_bit64(__u64 nr, void * addr); extern int ext2fs_test_bit64(__u64 nr, const void * addr); extern unsigned int ext2fs_bitcount(const void *addr, unsigned int nbytes); PK!SI.. ext2_err.hnu[/* * ext2_err.h: * This file is automatically generated; please do not edit it. */ #include #define EXT2_ET_BASE (2133571328L) #define EXT2_ET_MAGIC_EXT2FS_FILSYS (2133571329L) #define EXT2_ET_MAGIC_BADBLOCKS_LIST (2133571330L) #define EXT2_ET_MAGIC_BADBLOCKS_ITERATE (2133571331L) #define EXT2_ET_MAGIC_INODE_SCAN (2133571332L) #define EXT2_ET_MAGIC_IO_CHANNEL (2133571333L) #define EXT2_ET_MAGIC_UNIX_IO_CHANNEL (2133571334L) #define EXT2_ET_MAGIC_IO_MANAGER (2133571335L) #define EXT2_ET_MAGIC_BLOCK_BITMAP (2133571336L) #define EXT2_ET_MAGIC_INODE_BITMAP (2133571337L) #define EXT2_ET_MAGIC_GENERIC_BITMAP (2133571338L) #define EXT2_ET_MAGIC_TEST_IO_CHANNEL (2133571339L) #define EXT2_ET_MAGIC_DBLIST (2133571340L) #define EXT2_ET_MAGIC_ICOUNT (2133571341L) #define EXT2_ET_MAGIC_PQ_IO_CHANNEL (2133571342L) #define EXT2_ET_MAGIC_EXT2_FILE (2133571343L) #define EXT2_ET_MAGIC_E2IMAGE (2133571344L) #define EXT2_ET_MAGIC_INODE_IO_CHANNEL (2133571345L) #define EXT2_ET_MAGIC_EXTENT_HANDLE (2133571346L) #define EXT2_ET_BAD_MAGIC (2133571347L) #define EXT2_ET_REV_TOO_HIGH (2133571348L) #define EXT2_ET_RO_FILSYS (2133571349L) #define EXT2_ET_GDESC_READ (2133571350L) #define EXT2_ET_GDESC_WRITE (2133571351L) #define EXT2_ET_GDESC_BAD_BLOCK_MAP (2133571352L) #define EXT2_ET_GDESC_BAD_INODE_MAP (2133571353L) #define EXT2_ET_GDESC_BAD_INODE_TABLE (2133571354L) #define EXT2_ET_INODE_BITMAP_WRITE (2133571355L) #define EXT2_ET_INODE_BITMAP_READ (2133571356L) #define EXT2_ET_BLOCK_BITMAP_WRITE (2133571357L) #define EXT2_ET_BLOCK_BITMAP_READ (2133571358L) #define EXT2_ET_INODE_TABLE_WRITE (2133571359L) #define EXT2_ET_INODE_TABLE_READ (2133571360L) #define EXT2_ET_NEXT_INODE_READ (2133571361L) #define EXT2_ET_UNEXPECTED_BLOCK_SIZE (2133571362L) #define EXT2_ET_DIR_CORRUPTED (2133571363L) #define EXT2_ET_SHORT_READ (2133571364L) #define EXT2_ET_SHORT_WRITE (2133571365L) #define EXT2_ET_DIR_NO_SPACE (2133571366L) #define EXT2_ET_NO_INODE_BITMAP (2133571367L) #define EXT2_ET_NO_BLOCK_BITMAP (2133571368L) #define EXT2_ET_BAD_INODE_NUM (2133571369L) #define EXT2_ET_BAD_BLOCK_NUM (2133571370L) #define EXT2_ET_EXPAND_DIR_ERR (2133571371L) #define EXT2_ET_TOOSMALL (2133571372L) #define EXT2_ET_BAD_BLOCK_MARK (2133571373L) #define EXT2_ET_BAD_BLOCK_UNMARK (2133571374L) #define EXT2_ET_BAD_BLOCK_TEST (2133571375L) #define EXT2_ET_BAD_INODE_MARK (2133571376L) #define EXT2_ET_BAD_INODE_UNMARK (2133571377L) #define EXT2_ET_BAD_INODE_TEST (2133571378L) #define EXT2_ET_FUDGE_BLOCK_BITMAP_END (2133571379L) #define EXT2_ET_FUDGE_INODE_BITMAP_END (2133571380L) #define EXT2_ET_BAD_IND_BLOCK (2133571381L) #define EXT2_ET_BAD_DIND_BLOCK (2133571382L) #define EXT2_ET_BAD_TIND_BLOCK (2133571383L) #define EXT2_ET_NEQ_BLOCK_BITMAP (2133571384L) #define EXT2_ET_NEQ_INODE_BITMAP (2133571385L) #define EXT2_ET_BAD_DEVICE_NAME (2133571386L) #define EXT2_ET_MISSING_INODE_TABLE (2133571387L) #define EXT2_ET_CORRUPT_SUPERBLOCK (2133571388L) #define EXT2_ET_BAD_GENERIC_MARK (2133571389L) #define EXT2_ET_BAD_GENERIC_UNMARK (2133571390L) #define EXT2_ET_BAD_GENERIC_TEST (2133571391L) #define EXT2_ET_SYMLINK_LOOP (2133571392L) #define EXT2_ET_CALLBACK_NOTHANDLED (2133571393L) #define EXT2_ET_BAD_BLOCK_IN_INODE_TABLE (2133571394L) #define EXT2_ET_UNSUPP_FEATURE (2133571395L) #define EXT2_ET_RO_UNSUPP_FEATURE (2133571396L) #define EXT2_ET_LLSEEK_FAILED (2133571397L) #define EXT2_ET_NO_MEMORY (2133571398L) #define EXT2_ET_INVALID_ARGUMENT (2133571399L) #define EXT2_ET_BLOCK_ALLOC_FAIL (2133571400L) #define EXT2_ET_INODE_ALLOC_FAIL (2133571401L) #define EXT2_ET_NO_DIRECTORY (2133571402L) #define EXT2_ET_TOO_MANY_REFS (2133571403L) #define EXT2_ET_FILE_NOT_FOUND (2133571404L) #define EXT2_ET_FILE_RO (2133571405L) #define EXT2_ET_DB_NOT_FOUND (2133571406L) #define EXT2_ET_DIR_EXISTS (2133571407L) #define EXT2_ET_UNIMPLEMENTED (2133571408L) #define EXT2_ET_CANCEL_REQUESTED (2133571409L) #define EXT2_ET_FILE_TOO_BIG (2133571410L) #define EXT2_ET_JOURNAL_NOT_BLOCK (2133571411L) #define EXT2_ET_NO_JOURNAL_SB (2133571412L) #define EXT2_ET_JOURNAL_TOO_SMALL (2133571413L) #define EXT2_ET_JOURNAL_UNSUPP_VERSION (2133571414L) #define EXT2_ET_LOAD_EXT_JOURNAL (2133571415L) #define EXT2_ET_NO_JOURNAL (2133571416L) #define EXT2_ET_DIRHASH_UNSUPP (2133571417L) #define EXT2_ET_BAD_EA_BLOCK_NUM (2133571418L) #define EXT2_ET_TOO_MANY_INODES (2133571419L) #define EXT2_ET_NOT_IMAGE_FILE (2133571420L) #define EXT2_ET_RES_GDT_BLOCKS (2133571421L) #define EXT2_ET_RESIZE_INODE_CORRUPT (2133571422L) #define EXT2_ET_SET_BMAP_NO_IND (2133571423L) #define EXT2_ET_TDB_SUCCESS (2133571424L) #define EXT2_ET_TDB_ERR_CORRUPT (2133571425L) #define EXT2_ET_TDB_ERR_IO (2133571426L) #define EXT2_ET_TDB_ERR_LOCK (2133571427L) #define EXT2_ET_TDB_ERR_OOM (2133571428L) #define EXT2_ET_TDB_ERR_EXISTS (2133571429L) #define EXT2_ET_TDB_ERR_NOLOCK (2133571430L) #define EXT2_ET_TDB_ERR_EINVAL (2133571431L) #define EXT2_ET_TDB_ERR_NOEXIST (2133571432L) #define EXT2_ET_TDB_ERR_RDONLY (2133571433L) #define EXT2_ET_DBLIST_EMPTY (2133571434L) #define EXT2_ET_RO_BLOCK_ITERATE (2133571435L) #define EXT2_ET_MAGIC_EXTENT_PATH (2133571436L) #define EXT2_ET_MAGIC_GENERIC_BITMAP64 (2133571437L) #define EXT2_ET_MAGIC_BLOCK_BITMAP64 (2133571438L) #define EXT2_ET_MAGIC_INODE_BITMAP64 (2133571439L) #define EXT2_ET_MAGIC_RESERVED_13 (2133571440L) #define EXT2_ET_MAGIC_RESERVED_14 (2133571441L) #define EXT2_ET_MAGIC_RESERVED_15 (2133571442L) #define EXT2_ET_MAGIC_RESERVED_16 (2133571443L) #define EXT2_ET_MAGIC_RESERVED_17 (2133571444L) #define EXT2_ET_MAGIC_RESERVED_18 (2133571445L) #define EXT2_ET_MAGIC_RESERVED_19 (2133571446L) #define EXT2_ET_EXTENT_HEADER_BAD (2133571447L) #define EXT2_ET_EXTENT_INDEX_BAD (2133571448L) #define EXT2_ET_EXTENT_LEAF_BAD (2133571449L) #define EXT2_ET_EXTENT_NO_SPACE (2133571450L) #define EXT2_ET_INODE_NOT_EXTENT (2133571451L) #define EXT2_ET_EXTENT_NO_NEXT (2133571452L) #define EXT2_ET_EXTENT_NO_PREV (2133571453L) #define EXT2_ET_EXTENT_NO_UP (2133571454L) #define EXT2_ET_EXTENT_NO_DOWN (2133571455L) #define EXT2_ET_NO_CURRENT_NODE (2133571456L) #define EXT2_ET_OP_NOT_SUPPORTED (2133571457L) #define EXT2_ET_CANT_INSERT_EXTENT (2133571458L) #define EXT2_ET_CANT_SPLIT_EXTENT (2133571459L) #define EXT2_ET_EXTENT_NOT_FOUND (2133571460L) #define EXT2_ET_EXTENT_NOT_SUPPORTED (2133571461L) #define EXT2_ET_EXTENT_INVALID_LENGTH (2133571462L) #define EXT2_ET_IO_CHANNEL_NO_SUPPORT_64 (2133571463L) #define EXT2_ET_NO_MTAB_FILE (2133571464L) #define EXT2_ET_CANT_USE_LEGACY_BITMAPS (2133571465L) #define EXT2_ET_MMP_MAGIC_INVALID (2133571466L) #define EXT2_ET_MMP_FAILED (2133571467L) #define EXT2_ET_MMP_FSCK_ON (2133571468L) #define EXT2_ET_MMP_BAD_BLOCK (2133571469L) #define EXT2_ET_MMP_UNKNOWN_SEQ (2133571470L) #define EXT2_ET_MMP_CHANGE_ABORT (2133571471L) #define EXT2_ET_MMP_OPEN_DIRECT (2133571472L) #define EXT2_ET_BAD_DESC_SIZE (2133571473L) #define EXT2_ET_INODE_CSUM_INVALID (2133571474L) #define EXT2_ET_INODE_BITMAP_CSUM_INVALID (2133571475L) #define EXT2_ET_EXTENT_CSUM_INVALID (2133571476L) #define EXT2_ET_DIR_NO_SPACE_FOR_CSUM (2133571477L) #define EXT2_ET_DIR_CSUM_INVALID (2133571478L) #define EXT2_ET_EXT_ATTR_CSUM_INVALID (2133571479L) #define EXT2_ET_SB_CSUM_INVALID (2133571480L) #define EXT2_ET_UNKNOWN_CSUM (2133571481L) #define EXT2_ET_MMP_CSUM_INVALID (2133571482L) #define EXT2_ET_FILE_EXISTS (2133571483L) #define EXT2_ET_BLOCK_BITMAP_CSUM_INVALID (2133571484L) #define EXT2_ET_INLINE_DATA_CANT_ITERATE (2133571485L) #define EXT2_ET_EA_BAD_NAME_LEN (2133571486L) #define EXT2_ET_EA_BAD_VALUE_SIZE (2133571487L) #define EXT2_ET_BAD_EA_HASH (2133571488L) #define EXT2_ET_BAD_EA_HEADER (2133571489L) #define EXT2_ET_EA_KEY_NOT_FOUND (2133571490L) #define EXT2_ET_EA_NO_SPACE (2133571491L) #define EXT2_ET_MISSING_EA_FEATURE (2133571492L) #define EXT2_ET_NO_INLINE_DATA (2133571493L) #define EXT2_ET_INLINE_DATA_NO_BLOCK (2133571494L) #define EXT2_ET_INLINE_DATA_NO_SPACE (2133571495L) #define EXT2_ET_MAGIC_EA_HANDLE (2133571496L) #define EXT2_ET_INODE_IS_GARBAGE (2133571497L) #define EXT2_ET_EA_BAD_VALUE_OFFSET (2133571498L) #define EXT2_ET_JOURNAL_FLAGS_WRONG (2133571499L) #define EXT2_ET_UNDO_FILE_CORRUPT (2133571500L) #define EXT2_ET_UNDO_FILE_WRONG (2133571501L) #define EXT2_ET_FILESYSTEM_CORRUPTED (2133571502L) #define EXT2_ET_BAD_CRC (2133571503L) #define EXT2_ET_CORRUPT_JOURNAL_SB (2133571504L) #define EXT2_ET_INODE_CORRUPTED (2133571505L) #define EXT2_ET_EA_INODE_CORRUPTED (2133571506L) #define EXT2_ET_NO_GDESC (2133571507L) #define EXT2_FILSYS_CORRUPTED (2133571508L) extern const struct error_table et_ext2_error_table; extern void initialize_ext2_error_table(void); /* For compatibility with Heimdal */ extern void initialize_ext2_error_table_r(struct et_list **list); #define ERROR_TABLE_BASE_ext2 (2133571328L) /* for compatibility with older versions... */ #define init_ext2_err_tbl initialize_ext2_error_table #define ext2_err_base ERROR_TABLE_BASE_ext2 PK!gKT T ext2_ext_attr.hnu[/* File: linux/ext2_ext_attr.h On-disk format of extended attributes for the ext2 filesystem. (C) 2000 Andreas Gruenbacher, */ #ifndef _EXT2_EXT_ATTR_H #define _EXT2_EXT_ATTR_H /* Magic value in attribute blocks */ #define EXT2_EXT_ATTR_MAGIC_v1 0xEA010000 #define EXT2_EXT_ATTR_MAGIC 0xEA020000 /* Maximum number of references to one attribute block */ #define EXT2_EXT_ATTR_REFCOUNT_MAX 1024 struct ext2_ext_attr_header { __u32 h_magic; /* magic number for identification */ __u32 h_refcount; /* reference count */ __u32 h_blocks; /* number of disk blocks used */ __u32 h_hash; /* hash value of all attributes */ __u32 h_checksum; /* crc32c(uuid+id+xattrs) */ /* id = inum if refcount = 1, else blknum */ __u32 h_reserved[3]; /* zero right now */ }; struct ext2_ext_attr_entry { __u8 e_name_len; /* length of name */ __u8 e_name_index; /* attribute name index */ __u16 e_value_offs; /* offset in disk block of value */ __u32 e_value_inum; /* inode in which the value is stored */ __u32 e_value_size; /* size of attribute value */ __u32 e_hash; /* hash value of name and value */ #if 0 char e_name[0]; /* attribute name */ #endif }; #define EXT2_EXT_ATTR_PAD_BITS 2 #define EXT2_EXT_ATTR_PAD ((unsigned) 1<e_name_len)) ) #define EXT2_EXT_ATTR_SIZE(size) \ (((size) + EXT2_EXT_ATTR_ROUND) & ~EXT2_EXT_ATTR_ROUND) #define EXT2_EXT_IS_LAST_ENTRY(entry) (*((__u32 *)(entry)) == 0UL) #define EXT2_EXT_ATTR_NAME(entry) \ (((char *) (entry)) + sizeof(struct ext2_ext_attr_entry)) #define EXT2_XATTR_LEN(name_len) \ (((name_len) + EXT2_EXT_ATTR_ROUND + \ sizeof(struct ext2_xattr_entry)) & ~EXT2_EXT_ATTR_ROUND) #define EXT2_XATTR_SIZE(size) \ (((size) + EXT2_EXT_ATTR_ROUND) & ~EXT2_EXT_ATTR_ROUND) #ifdef __KERNEL__ # ifdef CONFIG_EXT2_FS_EXT_ATTR extern int ext2_get_ext_attr(struct inode *, const char *, char *, size_t, int); extern int ext2_set_ext_attr(struct inode *, const char *, char *, size_t, int); extern void ext2_ext_attr_free_inode(struct inode *inode); extern void ext2_ext_attr_put_super(struct super_block *sb); extern int ext2_ext_attr_init(void); extern void ext2_ext_attr_done(void); # else # define ext2_get_ext_attr NULL # define ext2_set_ext_attr NULL # endif #endif /* __KERNEL__ */ #endif /* _EXT2_EXT_ATTR_H */ PK!S@[[ ext2_fs.hnu[/* * linux/include/linux/ext2_fs.h * * Copyright (C) 1992, 1993, 1994, 1995 * Remy Card (card@masi.ibp.fr) * Laboratoire MASI - Institut Blaise Pascal * Universite Pierre et Marie Curie (Paris VI) * * from * * linux/include/linux/minix_fs.h * * Copyright (C) 1991, 1992 Linus Torvalds */ #ifndef _LINUX_EXT2_FS_H #define _LINUX_EXT2_FS_H #include /* Changed from linux/types.h */ #ifndef __GNUC_PREREQ #if defined(__GNUC__) && defined(__GNUC_MINOR__) #define __GNUC_PREREQ(maj, min) \ ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) #else #define __GNUC_PREREQ(maj, min) 0 #endif #endif /* * The second extended filesystem constants/structures */ /* * Define EXT2FS_DEBUG to produce debug messages */ #undef EXT2FS_DEBUG /* * Define EXT2_PREALLOCATE to preallocate data blocks for expanding files */ #define EXT2_PREALLOCATE #define EXT2_DEFAULT_PREALLOC_BLOCKS 8 /* * The second extended file system version */ #define EXT2FS_DATE "95/08/09" #define EXT2FS_VERSION "0.5b" /* * Special inode numbers */ #define EXT2_BAD_INO 1 /* Bad blocks inode */ #define EXT2_ROOT_INO 2 /* Root inode */ #define EXT4_USR_QUOTA_INO 3 /* User quota inode */ #define EXT4_GRP_QUOTA_INO 4 /* Group quota inode */ #define EXT2_BOOT_LOADER_INO 5 /* Boot loader inode */ #define EXT2_UNDEL_DIR_INO 6 /* Undelete directory inode */ #define EXT2_RESIZE_INO 7 /* Reserved group descriptors inode */ #define EXT2_JOURNAL_INO 8 /* Journal inode */ #define EXT2_EXCLUDE_INO 9 /* The "exclude" inode, for snapshots */ #define EXT4_REPLICA_INO 10 /* Used by non-upstream feature */ /* First non-reserved inode for old ext2 filesystems */ #define EXT2_GOOD_OLD_FIRST_INO 11 /* * The second extended file system magic number */ #define EXT2_SUPER_MAGIC 0xEF53 #ifdef __KERNEL__ #define EXT2_SB(sb) (&((sb)->u.ext2_sb)) #else /* Assume that user mode programs are passing in an ext2fs superblock, not * a kernel struct super_block. This will allow us to call the feature-test * macros from user land. */ #define EXT2_SB(sb) (sb) #endif /* * Maximal count of links to a file */ #define EXT2_LINK_MAX 65000 /* * Macro-instructions used to manage several block sizes */ #define EXT2_MIN_BLOCK_LOG_SIZE 10 /* 1024 */ #define EXT2_MAX_BLOCK_LOG_SIZE 16 /* 65536 */ #define EXT2_MIN_BLOCK_SIZE (1 << EXT2_MIN_BLOCK_LOG_SIZE) #define EXT2_MAX_BLOCK_SIZE (1 << EXT2_MAX_BLOCK_LOG_SIZE) #ifdef __KERNEL__ #define EXT2_BLOCK_SIZE(s) ((s)->s_blocksize) #define EXT2_BLOCK_SIZE_BITS(s) ((s)->s_blocksize_bits) #define EXT2_ADDR_PER_BLOCK_BITS(s) (EXT2_SB(s)->addr_per_block_bits) #define EXT2_INODE_SIZE(s) (EXT2_SB(s)->s_inode_size) #define EXT2_FIRST_INO(s) (EXT2_SB(s)->s_first_ino) #else #define EXT2_BLOCK_SIZE(s) (EXT2_MIN_BLOCK_SIZE << (s)->s_log_block_size) #define EXT2_BLOCK_SIZE_BITS(s) ((s)->s_log_block_size + 10) #define EXT2_INODE_SIZE(s) (((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \ EXT2_GOOD_OLD_INODE_SIZE : (s)->s_inode_size) #define EXT2_FIRST_INO(s) (((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \ EXT2_GOOD_OLD_FIRST_INO : (s)->s_first_ino) #endif #define EXT2_ADDR_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / sizeof(__u32)) /* * Macro-instructions used to manage allocation clusters */ #define EXT2_MIN_CLUSTER_LOG_SIZE EXT2_MIN_BLOCK_LOG_SIZE #define EXT2_MAX_CLUSTER_LOG_SIZE 29 /* 512MB */ #define EXT2_MIN_CLUSTER_SIZE EXT2_MIN_BLOCK_SIZE #define EXT2_MAX_CLUSTER_SIZE (1 << EXT2_MAX_CLUSTER_LOG_SIZE) #define EXT2_CLUSTER_SIZE(s) (EXT2_MIN_BLOCK_SIZE << \ (s)->s_log_cluster_size) #define EXT2_CLUSTER_SIZE_BITS(s) ((s)->s_log_cluster_size + 10) /* * Macro-instructions used to manage fragments * * Note: for backwards compatibility only, for the dump program. * Ext2/3/4 will never support fragments.... */ #define EXT2_MIN_FRAG_SIZE EXT2_MIN_BLOCK_SIZE #define EXT2_MAX_FRAG_SIZE EXT2_MAX_BLOCK_SIZE #define EXT2_MIN_FRAG_LOG_SIZE EXT2_MIN_BLOCK_LOG_SIZE #define EXT2_FRAG_SIZE(s) EXT2_BLOCK_SIZE(s) #define EXT2_FRAGS_PER_BLOCK(s) 1 /* * ACL structures */ struct ext2_acl_header /* Header of Access Control Lists */ { __u32 aclh_size; __u32 aclh_file_count; __u32 aclh_acle_count; __u32 aclh_first_acle; }; struct ext2_acl_entry /* Access Control List Entry */ { __u32 acle_size; __u16 acle_perms; /* Access permissions */ __u16 acle_type; /* Type of entry */ __u16 acle_tag; /* User or group identity */ __u16 acle_pad1; __u32 acle_next; /* Pointer on next entry for the */ /* same inode or on next free entry */ }; /* * Structure of a blocks group descriptor */ struct ext2_group_desc { __u32 bg_block_bitmap; /* Blocks bitmap block */ __u32 bg_inode_bitmap; /* Inodes bitmap block */ __u32 bg_inode_table; /* Inodes table block */ __u16 bg_free_blocks_count; /* Free blocks count */ __u16 bg_free_inodes_count; /* Free inodes count */ __u16 bg_used_dirs_count; /* Directories count */ __u16 bg_flags; __u32 bg_exclude_bitmap_lo; /* Exclude bitmap for snapshots */ __u16 bg_block_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+bitmap) LSB */ __u16 bg_inode_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+bitmap) LSB */ __u16 bg_itable_unused; /* Unused inodes count */ __u16 bg_checksum; /* crc16(s_uuid+group_num+group_desc)*/ }; /* * Structure of a blocks group descriptor */ struct ext4_group_desc { __u32 bg_block_bitmap; /* Blocks bitmap block */ __u32 bg_inode_bitmap; /* Inodes bitmap block */ __u32 bg_inode_table; /* Inodes table block */ __u16 bg_free_blocks_count; /* Free blocks count */ __u16 bg_free_inodes_count; /* Free inodes count */ __u16 bg_used_dirs_count; /* Directories count */ __u16 bg_flags; /* EXT4_BG_flags (INODE_UNINIT, etc) */ __u32 bg_exclude_bitmap_lo; /* Exclude bitmap for snapshots */ __u16 bg_block_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+bitmap) LSB */ __u16 bg_inode_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+bitmap) LSB */ __u16 bg_itable_unused; /* Unused inodes count */ __u16 bg_checksum; /* crc16(sb_uuid+group+desc) */ __u32 bg_block_bitmap_hi; /* Blocks bitmap block MSB */ __u32 bg_inode_bitmap_hi; /* Inodes bitmap block MSB */ __u32 bg_inode_table_hi; /* Inodes table block MSB */ __u16 bg_free_blocks_count_hi;/* Free blocks count MSB */ __u16 bg_free_inodes_count_hi;/* Free inodes count MSB */ __u16 bg_used_dirs_count_hi; /* Directories count MSB */ __u16 bg_itable_unused_hi; /* Unused inodes count MSB */ __u32 bg_exclude_bitmap_hi; /* Exclude bitmap block MSB */ __u16 bg_block_bitmap_csum_hi;/* crc32c(s_uuid+grp_num+bitmap) MSB */ __u16 bg_inode_bitmap_csum_hi;/* crc32c(s_uuid+grp_num+bitmap) MSB */ __u32 bg_reserved; }; #define EXT4_BG_INODE_BITMAP_CSUM_HI_END \ (offsetof(struct ext4_group_desc, bg_inode_bitmap_csum_hi) + \ sizeof(__u16)) #define EXT4_BG_BLOCK_BITMAP_CSUM_HI_LOCATION \ (offsetof(struct ext4_group_desc, bg_block_bitmap_csum_hi) + \ sizeof(__u16)) #define EXT2_BG_INODE_UNINIT 0x0001 /* Inode table/bitmap not initialized */ #define EXT2_BG_BLOCK_UNINIT 0x0002 /* Block bitmap not initialized */ #define EXT2_BG_INODE_ZEROED 0x0004 /* On-disk itable initialized to zero */ /* * Data structures used by the directory indexing feature * * Note: all of the multibyte integer fields are little endian. */ /* * Note: dx_root_info is laid out so that if it should somehow get * overlaid by a dirent the two low bits of the hash version will be * zero. Therefore, the hash version mod 4 should never be 0. * Sincerely, the paranoia department. */ struct ext2_dx_root_info { __u32 reserved_zero; __u8 hash_version; /* 0 now, 1 at release */ __u8 info_length; /* 8 */ __u8 indirect_levels; __u8 unused_flags; }; #define EXT2_HASH_LEGACY 0 #define EXT2_HASH_HALF_MD4 1 #define EXT2_HASH_TEA 2 #define EXT2_HASH_LEGACY_UNSIGNED 3 /* reserved for userspace lib */ #define EXT2_HASH_HALF_MD4_UNSIGNED 4 /* reserved for userspace lib */ #define EXT2_HASH_TEA_UNSIGNED 5 /* reserved for userspace lib */ #define EXT2_HASH_FLAG_INCOMPAT 0x1 #define EXT4_DX_BLOCK_MASK 0x0fffffff struct ext2_dx_entry { __le32 hash; __le32 block; }; struct ext2_dx_countlimit { __le16 limit; __le16 count; }; /* * This goes at the end of each htree block. */ struct ext2_dx_tail { __le32 dt_reserved; __le32 dt_checksum; /* crc32c(uuid+inum+dxblock) */ }; /* * Macro-instructions used to manage group descriptors */ #define EXT2_MIN_DESC_SIZE 32 #define EXT2_MIN_DESC_SIZE_64BIT 64 #define EXT2_MAX_DESC_SIZE EXT2_MIN_BLOCK_SIZE #define EXT2_DESC_SIZE(s) \ ((EXT2_SB(s)->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) ? \ (s)->s_desc_size : EXT2_MIN_DESC_SIZE) #define EXT2_BLOCKS_PER_GROUP(s) (EXT2_SB(s)->s_blocks_per_group) #define EXT2_INODES_PER_GROUP(s) (EXT2_SB(s)->s_inodes_per_group) #define EXT2_CLUSTERS_PER_GROUP(s) (EXT2_SB(s)->s_clusters_per_group) #define EXT2_INODES_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s)/EXT2_INODE_SIZE(s)) /* limits imposed by 16-bit value gd_free_{blocks,inode}_count */ #define EXT2_MAX_BLOCKS_PER_GROUP(s) ((((unsigned) 1 << 16) - 8) * \ (EXT2_CLUSTER_SIZE(s) / \ EXT2_BLOCK_SIZE(s))) #define EXT2_MAX_CLUSTERS_PER_GROUP(s) (((unsigned) 1 << 16) - 8) #define EXT2_MAX_INODES_PER_GROUP(s) (((unsigned) 1 << 16) - \ EXT2_INODES_PER_BLOCK(s)) #ifdef __KERNEL__ #define EXT2_DESC_PER_BLOCK(s) (EXT2_SB(s)->s_desc_per_block) #define EXT2_DESC_PER_BLOCK_BITS(s) (EXT2_SB(s)->s_desc_per_block_bits) #else #define EXT2_DESC_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / EXT2_DESC_SIZE(s)) #endif #define EXT2_GROUPS_TO_BLOCKS(s, g) ((blk64_t) EXT2_BLOCKS_PER_GROUP(s) * \ (g)) #define EXT2_GROUPS_TO_CLUSTERS(s, g) ((blk64_t) EXT2_CLUSTERS_PER_GROUP(s) * \ (g)) /* * Constants relative to the data blocks */ #define EXT2_NDIR_BLOCKS 12 #define EXT2_IND_BLOCK EXT2_NDIR_BLOCKS #define EXT2_DIND_BLOCK (EXT2_IND_BLOCK + 1) #define EXT2_TIND_BLOCK (EXT2_DIND_BLOCK + 1) #define EXT2_N_BLOCKS (EXT2_TIND_BLOCK + 1) /* * Inode flags */ #define EXT2_SECRM_FL 0x00000001 /* Secure deletion */ #define EXT2_UNRM_FL 0x00000002 /* Undelete */ #define EXT2_COMPR_FL 0x00000004 /* Compress file */ #define EXT2_SYNC_FL 0x00000008 /* Synchronous updates */ #define EXT2_IMMUTABLE_FL 0x00000010 /* Immutable file */ #define EXT2_APPEND_FL 0x00000020 /* writes to file may only append */ #define EXT2_NODUMP_FL 0x00000040 /* do not dump file */ #define EXT2_NOATIME_FL 0x00000080 /* do not update atime */ /* Reserved for compression usage... */ #define EXT2_DIRTY_FL 0x00000100 #define EXT2_COMPRBLK_FL 0x00000200 /* One or more compressed clusters */ #define EXT2_NOCOMPR_FL 0x00000400 /* Access raw compressed data */ /* nb: was previously EXT2_ECOMPR_FL */ #define EXT4_ENCRYPT_FL 0x00000800 /* encrypted inode */ /* End compression flags --- maybe not all used */ #define EXT2_BTREE_FL 0x00001000 /* btree format dir */ #define EXT2_INDEX_FL 0x00001000 /* hash-indexed directory */ #define EXT2_IMAGIC_FL 0x00002000 #define EXT3_JOURNAL_DATA_FL 0x00004000 /* file data should be journaled */ #define EXT2_NOTAIL_FL 0x00008000 /* file tail should not be merged */ #define EXT2_DIRSYNC_FL 0x00010000 /* Synchronous directory modifications */ #define EXT2_TOPDIR_FL 0x00020000 /* Top of directory hierarchies*/ #define EXT4_HUGE_FILE_FL 0x00040000 /* Set to each huge file */ #define EXT4_EXTENTS_FL 0x00080000 /* Inode uses extents */ #define EXT4_VERITY_FL 0x00100000 /* Verity protected inode */ #define EXT4_EA_INODE_FL 0x00200000 /* Inode used for large EA */ /* EXT4_EOFBLOCKS_FL 0x00400000 was here */ #define FS_NOCOW_FL 0x00800000 /* Do not cow file */ #define EXT4_SNAPFILE_FL 0x01000000 /* Inode is a snapshot */ #define EXT4_SNAPFILE_DELETED_FL 0x04000000 /* Snapshot is being deleted */ #define EXT4_SNAPFILE_SHRUNK_FL 0x08000000 /* Snapshot shrink has completed */ #define EXT4_INLINE_DATA_FL 0x10000000 /* Inode has inline data */ #define EXT4_PROJINHERIT_FL 0x20000000 /* Create with parents projid */ #define EXT4_CASEFOLD_FL 0x40000000 /* Casefolded file */ #define EXT2_RESERVED_FL 0x80000000 /* reserved for ext2 lib */ #define EXT2_FL_USER_VISIBLE 0x604BDFFF /* User visible flags */ #define EXT2_FL_USER_MODIFIABLE 0x604B80FF /* User modifiable flags */ /* * ioctl commands */ /* Used for online resize */ struct ext2_new_group_input { __u32 group; /* Group number for this data */ __u32 block_bitmap; /* Absolute block number of block bitmap */ __u32 inode_bitmap; /* Absolute block number of inode bitmap */ __u32 inode_table; /* Absolute block number of inode table start */ __u32 blocks_count; /* Total number of blocks in this group */ __u16 reserved_blocks; /* Number of reserved blocks in this group */ __u16 unused; /* Number of reserved GDT blocks in group */ }; struct ext4_new_group_input { __u32 group; /* Group number for this data */ __u64 block_bitmap; /* Absolute block number of block bitmap */ __u64 inode_bitmap; /* Absolute block number of inode bitmap */ __u64 inode_table; /* Absolute block number of inode table start */ __u32 blocks_count; /* Total number of blocks in this group */ __u16 reserved_blocks; /* Number of reserved blocks in this group */ __u16 unused; }; #ifdef __GNU__ /* Needed for the Hurd */ #define _IOT_ext2_new_group_input _IOT (_IOTS(__u32), 5, _IOTS(__u16), 2, 0, 0) #endif #define EXT2_IOC_GETFLAGS _IOR('f', 1, long) #define EXT2_IOC_SETFLAGS _IOW('f', 2, long) #define EXT2_IOC_GETVERSION _IOR('v', 1, long) #define EXT2_IOC_SETVERSION _IOW('v', 2, long) #define EXT2_IOC_GETVERSION_NEW _IOR('f', 3, long) #define EXT2_IOC_SETVERSION_NEW _IOW('f', 4, long) #define EXT2_IOC_GROUP_EXTEND _IOW('f', 7, unsigned long) #define EXT2_IOC_GROUP_ADD _IOW('f', 8,struct ext2_new_group_input) #define EXT4_IOC_GROUP_ADD _IOW('f', 8,struct ext4_new_group_input) #define EXT4_IOC_RESIZE_FS _IOW('f', 16, __u64) /* * Structure of an inode on the disk */ struct ext2_inode { /*00*/ __u16 i_mode; /* File mode */ __u16 i_uid; /* Low 16 bits of Owner Uid */ __u32 i_size; /* Size in bytes */ __u32 i_atime; /* Access time */ __u32 i_ctime; /* Inode change time */ /*10*/ __u32 i_mtime; /* Modification time */ __u32 i_dtime; /* Deletion Time */ __u16 i_gid; /* Low 16 bits of Group Id */ __u16 i_links_count; /* Links count */ __u32 i_blocks; /* Blocks count */ /*20*/ __u32 i_flags; /* File flags */ union { struct { __u32 l_i_version; /* was l_i_reserved1 */ } linux1; struct { __u32 h_i_translator; } hurd1; } osd1; /* OS dependent 1 */ /*28*/ __u32 i_block[EXT2_N_BLOCKS];/* Pointers to blocks */ /*64*/ __u32 i_generation; /* File version (for NFS) */ __u32 i_file_acl; /* File ACL */ __u32 i_size_high; /*70*/ __u32 i_faddr; /* Fragment address */ union { struct { __u16 l_i_blocks_hi; __u16 l_i_file_acl_high; __u16 l_i_uid_high; /* these 2 fields */ __u16 l_i_gid_high; /* were reserved2[0] */ __u16 l_i_checksum_lo; /* crc32c(uuid+inum+inode) */ __u16 l_i_reserved; } linux2; struct { __u8 h_i_frag; /* Fragment number */ __u8 h_i_fsize; /* Fragment size */ __u16 h_i_mode_high; __u16 h_i_uid_high; __u16 h_i_gid_high; __u32 h_i_author; } hurd2; } osd2; /* OS dependent 2 */ }; /* * Permanent part of an large inode on the disk */ struct ext2_inode_large { /*00*/ __u16 i_mode; /* File mode */ __u16 i_uid; /* Low 16 bits of Owner Uid */ __u32 i_size; /* Size in bytes */ __u32 i_atime; /* Access time */ __u32 i_ctime; /* Inode Change time */ /*10*/ __u32 i_mtime; /* Modification time */ __u32 i_dtime; /* Deletion Time */ __u16 i_gid; /* Low 16 bits of Group Id */ __u16 i_links_count; /* Links count */ __u32 i_blocks; /* Blocks count */ /*20*/ __u32 i_flags; /* File flags */ union { struct { __u32 l_i_version; /* was l_i_reserved1 */ } linux1; struct { __u32 h_i_translator; } hurd1; } osd1; /* OS dependent 1 */ /*28*/ __u32 i_block[EXT2_N_BLOCKS];/* Pointers to blocks */ /*64*/ __u32 i_generation; /* File version (for NFS) */ __u32 i_file_acl; /* File ACL */ __u32 i_size_high; /*70*/ __u32 i_faddr; /* Fragment address */ union { struct { __u16 l_i_blocks_hi; __u16 l_i_file_acl_high; __u16 l_i_uid_high; /* these 2 fields */ __u16 l_i_gid_high; /* were reserved2[0] */ __u16 l_i_checksum_lo; /* crc32c(uuid+inum+inode) */ __u16 l_i_reserved; } linux2; struct { __u8 h_i_frag; /* Fragment number */ __u8 h_i_fsize; /* Fragment size */ __u16 h_i_mode_high; __u16 h_i_uid_high; __u16 h_i_gid_high; __u32 h_i_author; } hurd2; } osd2; /* OS dependent 2 */ /*80*/ __u16 i_extra_isize; __u16 i_checksum_hi; /* crc32c(uuid+inum+inode) */ __u32 i_ctime_extra; /* extra Change time (nsec << 2 | epoch) */ __u32 i_mtime_extra; /* extra Modification time (nsec << 2 | epoch) */ __u32 i_atime_extra; /* extra Access time (nsec << 2 | epoch) */ /*90*/ __u32 i_crtime; /* File creation time */ __u32 i_crtime_extra; /* extra File creation time (nsec << 2 | epoch)*/ __u32 i_version_hi; /* high 32 bits for 64-bit version */ /*9c*/ __u32 i_projid; /* Project ID */ }; #define EXT4_INODE_CSUM_HI_EXTRA_END \ (offsetof(struct ext2_inode_large, i_checksum_hi) + sizeof(__u16) - \ EXT2_GOOD_OLD_INODE_SIZE) #define EXT4_EPOCH_BITS 2 #define EXT4_EPOCH_MASK ((1 << EXT4_EPOCH_BITS) - 1) #define i_checksum_lo osd2.linux2.l_i_checksum_lo #define inode_includes(size, field) \ (size >= (sizeof(((struct ext2_inode_large *)0)->field) + \ offsetof(struct ext2_inode_large, field))) #if defined(__KERNEL__) || defined(__linux__) #define i_reserved1 osd1.linux1.l_i_reserved1 #define i_frag osd2.linux2.l_i_frag #define i_fsize osd2.linux2.l_i_fsize #define i_uid_low i_uid #define i_gid_low i_gid #define i_uid_high osd2.linux2.l_i_uid_high #define i_gid_high osd2.linux2.l_i_gid_high #else #if defined(__GNU__) #define i_translator osd1.hurd1.h_i_translator #define i_frag osd2.hurd2.h_i_frag; #define i_fsize osd2.hurd2.h_i_fsize; #define i_uid_high osd2.hurd2.h_i_uid_high #define i_gid_high osd2.hurd2.h_i_gid_high #define i_author osd2.hurd2.h_i_author #endif /* __GNU__ */ #endif /* defined(__KERNEL__) || defined(__linux__) */ #define inode_uid(inode) ((inode).i_uid | (inode).osd2.linux2.l_i_uid_high << 16) #define inode_gid(inode) ((inode).i_gid | (inode).osd2.linux2.l_i_gid_high << 16) #define inode_projid(inode) ((inode).i_projid) #define ext2fs_set_i_uid_high(inode,x) ((inode).osd2.linux2.l_i_uid_high = (x)) #define ext2fs_set_i_gid_high(inode,x) ((inode).osd2.linux2.l_i_gid_high = (x)) static inline struct ext2_inode *EXT2_INODE(struct ext2_inode_large *large_inode) { return (struct ext2_inode *) large_inode; } /* * File system states */ #define EXT2_VALID_FS 0x0001 /* Unmounted cleanly */ #define EXT2_ERROR_FS 0x0002 /* Errors detected */ #define EXT3_ORPHAN_FS 0x0004 /* Orphans being recovered */ /* * Misc. filesystem flags */ #define EXT2_FLAGS_SIGNED_HASH 0x0001 /* Signed dirhash in use */ #define EXT2_FLAGS_UNSIGNED_HASH 0x0002 /* Unsigned dirhash in use */ #define EXT2_FLAGS_TEST_FILESYS 0x0004 /* OK for use on development code */ #define EXT2_FLAGS_IS_SNAPSHOT 0x0010 /* This is a snapshot image */ #define EXT2_FLAGS_FIX_SNAPSHOT 0x0020 /* Snapshot inodes corrupted */ #define EXT2_FLAGS_FIX_EXCLUDE 0x0040 /* Exclude bitmaps corrupted */ /* * Mount flags */ #define EXT2_MOUNT_CHECK 0x0001 /* Do mount-time checks */ #define EXT2_MOUNT_GRPID 0x0004 /* Create files with directory's group */ #define EXT2_MOUNT_DEBUG 0x0008 /* Some debugging messages */ #define EXT2_MOUNT_ERRORS_CONT 0x0010 /* Continue on errors */ #define EXT2_MOUNT_ERRORS_RO 0x0020 /* Remount fs ro on errors */ #define EXT2_MOUNT_ERRORS_PANIC 0x0040 /* Panic on errors */ #define EXT2_MOUNT_MINIX_DF 0x0080 /* Mimics the Minix statfs */ #define EXT2_MOUNT_NO_UID32 0x0200 /* Disable 32-bit UIDs */ #define clear_opt(o, opt) o &= ~EXT2_MOUNT_##opt #define set_opt(o, opt) o |= EXT2_MOUNT_##opt #define test_opt(sb, opt) (EXT2_SB(sb)->s_mount_opt & \ EXT2_MOUNT_##opt) /* * Maximal mount counts between two filesystem checks */ #define EXT2_DFL_MAX_MNT_COUNT 20 /* Allow 20 mounts */ #define EXT2_DFL_CHECKINTERVAL 0 /* Don't use interval check */ /* * Behaviour when detecting errors */ #define EXT2_ERRORS_CONTINUE 1 /* Continue execution */ #define EXT2_ERRORS_RO 2 /* Remount fs read-only */ #define EXT2_ERRORS_PANIC 3 /* Panic */ #define EXT2_ERRORS_DEFAULT EXT2_ERRORS_CONTINUE #if (__GNUC__ >= 4) #define ext4_offsetof(TYPE,MEMBER) __builtin_offsetof(TYPE,MEMBER) #else #define ext4_offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) #endif /* Metadata checksum algorithms */ #define EXT2_CRC32C_CHKSUM 1 /* Encryption algorithms, key size and key reference len */ #define EXT4_ENCRYPTION_MODE_INVALID 0 #define EXT4_ENCRYPTION_MODE_AES_256_XTS 1 #define EXT4_ENCRYPTION_MODE_AES_256_GCM 2 #define EXT4_ENCRYPTION_MODE_AES_256_CBC 3 #define EXT4_ENCRYPTION_MODE_AES_256_CTS 4 #define EXT4_AES_256_XTS_KEY_SIZE 64 #define EXT4_AES_256_GCM_KEY_SIZE 32 #define EXT4_AES_256_CBC_KEY_SIZE 32 #define EXT4_AES_256_CTS_KEY_SIZE 32 #define EXT4_MAX_KEY_SIZE 64 #define EXT4_KEY_DESCRIPTOR_SIZE 8 #define EXT4_CRYPTO_BLOCK_SIZE 16 /* Password derivation constants */ #define EXT4_MAX_PASSPHRASE_SIZE 1024 #define EXT4_MAX_SALT_SIZE 256 #define EXT4_PBKDF2_ITERATIONS 0xFFFF #define EXT2_LABEL_LEN 16 /* * Policy provided via an ioctl on the topmost directory. This * structure is also in the kernel. */ struct ext4_encryption_policy { char version; char contents_encryption_mode; char filenames_encryption_mode; char flags; char master_key_descriptor[EXT4_KEY_DESCRIPTOR_SIZE]; } __attribute__((__packed__)); struct ext4_encryption_key { __u32 mode; char raw[EXT4_MAX_KEY_SIZE]; __u32 size; } __attribute__((__packed__)); /* * Structure of the super block */ struct ext2_super_block { /*000*/ __u32 s_inodes_count; /* Inodes count */ __u32 s_blocks_count; /* Blocks count */ __u32 s_r_blocks_count; /* Reserved blocks count */ __u32 s_free_blocks_count; /* Free blocks count */ /*010*/ __u32 s_free_inodes_count; /* Free inodes count */ __u32 s_first_data_block; /* First Data Block */ __u32 s_log_block_size; /* Block size */ __u32 s_log_cluster_size; /* Allocation cluster size */ /*020*/ __u32 s_blocks_per_group; /* # Blocks per group */ __u32 s_clusters_per_group; /* # Fragments per group */ __u32 s_inodes_per_group; /* # Inodes per group */ __u32 s_mtime; /* Mount time */ /*030*/ __u32 s_wtime; /* Write time */ __u16 s_mnt_count; /* Mount count */ __s16 s_max_mnt_count; /* Maximal mount count */ __u16 s_magic; /* Magic signature */ __u16 s_state; /* File system state */ __u16 s_errors; /* Behaviour when detecting errors */ __u16 s_minor_rev_level; /* minor revision level */ /*040*/ __u32 s_lastcheck; /* time of last check */ __u32 s_checkinterval; /* max. time between checks */ __u32 s_creator_os; /* OS */ __u32 s_rev_level; /* Revision level */ /*050*/ __u16 s_def_resuid; /* Default uid for reserved blocks */ __u16 s_def_resgid; /* Default gid for reserved blocks */ /* * These fields are for EXT2_DYNAMIC_REV superblocks only. * * Note: the difference between the compatible feature set and * the incompatible feature set is that if there is a bit set * in the incompatible feature set that the kernel doesn't * know about, it should refuse to mount the filesystem. * * e2fsck's requirements are more strict; if it doesn't know * about a feature in either the compatible or incompatible * feature set, it must abort and not try to meddle with * things it doesn't understand... */ __u32 s_first_ino; /* First non-reserved inode */ __u16 s_inode_size; /* size of inode structure */ __u16 s_block_group_nr; /* block group # of this superblock */ __u32 s_feature_compat; /* compatible feature set */ /*060*/ __u32 s_feature_incompat; /* incompatible feature set */ __u32 s_feature_ro_compat; /* readonly-compatible feature set */ /*068*/ __u8 s_uuid[16]; /* 128-bit uuid for volume */ /*078*/ __u8 s_volume_name[EXT2_LABEL_LEN]; /* volume name, no NUL? */ /*088*/ __u8 s_last_mounted[64]; /* directory last mounted on, no NUL? */ /*0c8*/ __u32 s_algorithm_usage_bitmap; /* For compression */ /* * Performance hints. Directory preallocation should only * happen if the EXT2_FEATURE_COMPAT_DIR_PREALLOC flag is on. */ __u8 s_prealloc_blocks; /* Nr of blocks to try to preallocate*/ __u8 s_prealloc_dir_blocks; /* Nr to preallocate for dirs */ __u16 s_reserved_gdt_blocks; /* Per group table for online growth */ /* * Journaling support valid if EXT2_FEATURE_COMPAT_HAS_JOURNAL set. */ /*0d0*/ __u8 s_journal_uuid[16]; /* uuid of journal superblock */ /*0e0*/ __u32 s_journal_inum; /* inode number of journal file */ __u32 s_journal_dev; /* device number of journal file */ __u32 s_last_orphan; /* start of list of inodes to delete */ /*0ec*/ __u32 s_hash_seed[4]; /* HTREE hash seed */ /*0fc*/ __u8 s_def_hash_version; /* Default hash version to use */ __u8 s_jnl_backup_type; /* Default type of journal backup */ __u16 s_desc_size; /* Group desc. size: INCOMPAT_64BIT */ /*100*/ __u32 s_default_mount_opts; /* default EXT2_MOUNT_* flags used */ __u32 s_first_meta_bg; /* First metablock group */ __u32 s_mkfs_time; /* When the filesystem was created */ /*10c*/ __u32 s_jnl_blocks[17]; /* Backup of the journal inode */ /*150*/ __u32 s_blocks_count_hi; /* Blocks count high 32bits */ __u32 s_r_blocks_count_hi; /* Reserved blocks count high 32 bits*/ __u32 s_free_blocks_hi; /* Free blocks count */ __u16 s_min_extra_isize; /* All inodes have at least # bytes */ __u16 s_want_extra_isize; /* New inodes should reserve # bytes */ /*160*/ __u32 s_flags; /* Miscellaneous flags */ __u16 s_raid_stride; /* RAID stride in blocks */ __u16 s_mmp_update_interval; /* # seconds to wait in MMP checking */ __u64 s_mmp_block; /* Block for multi-mount protection */ /*170*/ __u32 s_raid_stripe_width; /* blocks on all data disks (N*stride)*/ __u8 s_log_groups_per_flex; /* FLEX_BG group size */ __u8 s_checksum_type; /* metadata checksum algorithm */ __u8 s_encryption_level; /* versioning level for encryption */ __u8 s_reserved_pad; /* Padding to next 32bits */ __u64 s_kbytes_written; /* nr of lifetime kilobytes written */ /*180*/ __u32 s_snapshot_inum; /* Inode number of active snapshot */ __u32 s_snapshot_id; /* sequential ID of active snapshot */ __u64 s_snapshot_r_blocks_count; /* active snapshot reserved blocks */ /*190*/ __u32 s_snapshot_list; /* inode number of disk snapshot list */ #define EXT4_S_ERR_START ext4_offsetof(struct ext2_super_block, s_error_count) __u32 s_error_count; /* number of fs errors */ __u32 s_first_error_time; /* first time an error happened */ __u32 s_first_error_ino; /* inode involved in first error */ /*1a0*/ __u64 s_first_error_block; /* block involved in first error */ __u8 s_first_error_func[32]; /* function where error hit, no NUL? */ /*1c8*/ __u32 s_first_error_line; /* line number where error happened */ __u32 s_last_error_time; /* most recent time of an error */ /*1d0*/ __u32 s_last_error_ino; /* inode involved in last error */ __u32 s_last_error_line; /* line number where error happened */ __u64 s_last_error_block; /* block involved of last error */ /*1e0*/ __u8 s_last_error_func[32]; /* function where error hit, no NUL? */ #define EXT4_S_ERR_END ext4_offsetof(struct ext2_super_block, s_mount_opts) /*200*/ __u8 s_mount_opts[64]; /* default mount options, no NUL? */ /*240*/ __u32 s_usr_quota_inum; /* inode number of user quota file */ __u32 s_grp_quota_inum; /* inode number of group quota file */ __u32 s_overhead_blocks; /* overhead blocks/clusters in fs */ /*24c*/ __u32 s_backup_bgs[2]; /* If sparse_super2 enabled */ /*254*/ __u8 s_encrypt_algos[4]; /* Encryption algorithms in use */ /*258*/ __u8 s_encrypt_pw_salt[16]; /* Salt used for string2key algorithm */ /*268*/ __le32 s_lpf_ino; /* Location of the lost+found inode */ __le32 s_prj_quota_inum; /* inode for tracking project quota */ /*270*/ __le32 s_checksum_seed; /* crc32c(orig_uuid) if csum_seed set */ /*274*/ __u8 s_wtime_hi; __u8 s_mtime_hi; __u8 s_mkfs_time_hi; __u8 s_lastcheck_hi; __u8 s_first_error_time_hi; __u8 s_last_error_time_hi; __u8 s_pad[2]; /*27c*/ __le16 s_encoding; /* Filename charset encoding */ __le16 s_encoding_flags; /* Filename charset encoding flags */ __le32 s_reserved[95]; /* Padding to the end of the block */ /*3fc*/ __u32 s_checksum; /* crc32c(superblock) */ }; #define EXT4_S_ERR_LEN (EXT4_S_ERR_END - EXT4_S_ERR_START) #define EXT2_LEN_STR(buf) (int)sizeof(buf), (char *)buf /* * Codes for operating systems */ #define EXT2_OS_LINUX 0 #define EXT2_OS_HURD 1 #define EXT2_OBSO_OS_MASIX 2 #define EXT2_OS_FREEBSD 3 #define EXT2_OS_LITES 4 /* * Revision levels */ #define EXT2_GOOD_OLD_REV 0 /* The good old (original) format */ #define EXT2_DYNAMIC_REV 1 /* V2 format w/ dynamic inode sizes */ #define EXT2_CURRENT_REV EXT2_GOOD_OLD_REV #define EXT2_MAX_SUPP_REV EXT2_DYNAMIC_REV #define EXT2_GOOD_OLD_INODE_SIZE 128 /* * Journal inode backup types */ #define EXT3_JNL_BACKUP_BLOCKS 1 /* * Feature set definitions */ #define EXT2_HAS_COMPAT_FEATURE(sb,mask) \ ( EXT2_SB(sb)->s_feature_compat & (mask) ) #define EXT2_HAS_RO_COMPAT_FEATURE(sb,mask) \ ( EXT2_SB(sb)->s_feature_ro_compat & (mask) ) #define EXT2_HAS_INCOMPAT_FEATURE(sb,mask) \ ( EXT2_SB(sb)->s_feature_incompat & (mask) ) #define EXT2_FEATURE_COMPAT_DIR_PREALLOC 0x0001 #define EXT2_FEATURE_COMPAT_IMAGIC_INODES 0x0002 #define EXT3_FEATURE_COMPAT_HAS_JOURNAL 0x0004 #define EXT2_FEATURE_COMPAT_EXT_ATTR 0x0008 #define EXT2_FEATURE_COMPAT_RESIZE_INODE 0x0010 #define EXT2_FEATURE_COMPAT_DIR_INDEX 0x0020 #define EXT2_FEATURE_COMPAT_LAZY_BG 0x0040 /* #define EXT2_FEATURE_COMPAT_EXCLUDE_INODE 0x0080 not used, legacy */ #define EXT2_FEATURE_COMPAT_EXCLUDE_BITMAP 0x0100 #define EXT4_FEATURE_COMPAT_SPARSE_SUPER2 0x0200 #define EXT4_FEATURE_COMPAT_FAST_COMMIT 0x0400 #define EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER 0x0001 #define EXT2_FEATURE_RO_COMPAT_LARGE_FILE 0x0002 /* #define EXT2_FEATURE_RO_COMPAT_BTREE_DIR 0x0004 not used */ #define EXT4_FEATURE_RO_COMPAT_HUGE_FILE 0x0008 #define EXT4_FEATURE_RO_COMPAT_GDT_CSUM 0x0010 #define EXT4_FEATURE_RO_COMPAT_DIR_NLINK 0x0020 #define EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE 0x0040 #define EXT4_FEATURE_RO_COMPAT_HAS_SNAPSHOT 0x0080 #define EXT4_FEATURE_RO_COMPAT_QUOTA 0x0100 #define EXT4_FEATURE_RO_COMPAT_BIGALLOC 0x0200 /* * METADATA_CSUM implies GDT_CSUM. When METADATA_CSUM is set, group * descriptor checksums use the same algorithm as all other data * structures' checksums. */ #define EXT4_FEATURE_RO_COMPAT_METADATA_CSUM 0x0400 #define EXT4_FEATURE_RO_COMPAT_REPLICA 0x0800 #define EXT4_FEATURE_RO_COMPAT_READONLY 0x1000 #define EXT4_FEATURE_RO_COMPAT_PROJECT 0x2000 /* Project quota */ #define EXT4_FEATURE_RO_COMPAT_SHARED_BLOCKS 0x4000 #define EXT4_FEATURE_RO_COMPAT_VERITY 0x8000 #define EXT2_FEATURE_INCOMPAT_COMPRESSION 0x0001 #define EXT2_FEATURE_INCOMPAT_FILETYPE 0x0002 #define EXT3_FEATURE_INCOMPAT_RECOVER 0x0004 /* Needs recovery */ #define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV 0x0008 /* Journal device */ #define EXT2_FEATURE_INCOMPAT_META_BG 0x0010 #define EXT3_FEATURE_INCOMPAT_EXTENTS 0x0040 #define EXT4_FEATURE_INCOMPAT_64BIT 0x0080 #define EXT4_FEATURE_INCOMPAT_MMP 0x0100 #define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200 #define EXT4_FEATURE_INCOMPAT_EA_INODE 0x0400 #define EXT4_FEATURE_INCOMPAT_DIRDATA 0x1000 #define EXT4_FEATURE_INCOMPAT_CSUM_SEED 0x2000 #define EXT4_FEATURE_INCOMPAT_LARGEDIR 0x4000 /* >2GB or 3-lvl htree */ #define EXT4_FEATURE_INCOMPAT_INLINE_DATA 0x8000 /* data in inode */ #define EXT4_FEATURE_INCOMPAT_ENCRYPT 0x10000 #define EXT4_FEATURE_INCOMPAT_CASEFOLD 0x20000 #define EXT4_FEATURE_COMPAT_FUNCS(name, ver, flagname) \ static inline int ext2fs_has_feature_##name(struct ext2_super_block *sb) \ { \ return ((EXT2_SB(sb)->s_feature_compat & \ EXT##ver##_FEATURE_COMPAT_##flagname) != 0); \ } \ static inline void ext2fs_set_feature_##name(struct ext2_super_block *sb) \ { \ EXT2_SB(sb)->s_feature_compat |= \ EXT##ver##_FEATURE_COMPAT_##flagname; \ } \ static inline void ext2fs_clear_feature_##name(struct ext2_super_block *sb) \ { \ EXT2_SB(sb)->s_feature_compat &= \ ~EXT##ver##_FEATURE_COMPAT_##flagname; \ } #define EXT4_FEATURE_RO_COMPAT_FUNCS(name, ver, flagname) \ static inline int ext2fs_has_feature_##name(struct ext2_super_block *sb) \ { \ return ((EXT2_SB(sb)->s_feature_ro_compat & \ EXT##ver##_FEATURE_RO_COMPAT_##flagname) != 0); \ } \ static inline void ext2fs_set_feature_##name(struct ext2_super_block *sb) \ { \ EXT2_SB(sb)->s_feature_ro_compat |= \ EXT##ver##_FEATURE_RO_COMPAT_##flagname; \ } \ static inline void ext2fs_clear_feature_##name(struct ext2_super_block *sb) \ { \ EXT2_SB(sb)->s_feature_ro_compat &= \ ~EXT##ver##_FEATURE_RO_COMPAT_##flagname; \ } #define EXT4_FEATURE_INCOMPAT_FUNCS(name, ver, flagname) \ static inline int ext2fs_has_feature_##name(struct ext2_super_block *sb) \ { \ return ((EXT2_SB(sb)->s_feature_incompat & \ EXT##ver##_FEATURE_INCOMPAT_##flagname) != 0); \ } \ static inline void ext2fs_set_feature_##name(struct ext2_super_block *sb) \ { \ EXT2_SB(sb)->s_feature_incompat |= \ EXT##ver##_FEATURE_INCOMPAT_##flagname; \ } \ static inline void ext2fs_clear_feature_##name(struct ext2_super_block *sb) \ { \ EXT2_SB(sb)->s_feature_incompat &= \ ~EXT##ver##_FEATURE_INCOMPAT_##flagname; \ } EXT4_FEATURE_COMPAT_FUNCS(dir_prealloc, 2, DIR_PREALLOC) EXT4_FEATURE_COMPAT_FUNCS(imagic_inodes, 2, IMAGIC_INODES) EXT4_FEATURE_COMPAT_FUNCS(journal, 3, HAS_JOURNAL) EXT4_FEATURE_COMPAT_FUNCS(xattr, 2, EXT_ATTR) EXT4_FEATURE_COMPAT_FUNCS(resize_inode, 2, RESIZE_INODE) EXT4_FEATURE_COMPAT_FUNCS(dir_index, 2, DIR_INDEX) EXT4_FEATURE_COMPAT_FUNCS(lazy_bg, 2, LAZY_BG) EXT4_FEATURE_COMPAT_FUNCS(exclude_bitmap, 2, EXCLUDE_BITMAP) EXT4_FEATURE_COMPAT_FUNCS(sparse_super2, 4, SPARSE_SUPER2) EXT4_FEATURE_COMPAT_FUNCS(fast_commit, 4, FAST_COMMIT) EXT4_FEATURE_RO_COMPAT_FUNCS(sparse_super, 2, SPARSE_SUPER) EXT4_FEATURE_RO_COMPAT_FUNCS(large_file, 2, LARGE_FILE) EXT4_FEATURE_RO_COMPAT_FUNCS(huge_file, 4, HUGE_FILE) EXT4_FEATURE_RO_COMPAT_FUNCS(gdt_csum, 4, GDT_CSUM) EXT4_FEATURE_RO_COMPAT_FUNCS(dir_nlink, 4, DIR_NLINK) EXT4_FEATURE_RO_COMPAT_FUNCS(extra_isize, 4, EXTRA_ISIZE) EXT4_FEATURE_RO_COMPAT_FUNCS(has_snapshot, 4, HAS_SNAPSHOT) EXT4_FEATURE_RO_COMPAT_FUNCS(quota, 4, QUOTA) EXT4_FEATURE_RO_COMPAT_FUNCS(bigalloc, 4, BIGALLOC) EXT4_FEATURE_RO_COMPAT_FUNCS(metadata_csum, 4, METADATA_CSUM) EXT4_FEATURE_RO_COMPAT_FUNCS(replica, 4, REPLICA) EXT4_FEATURE_RO_COMPAT_FUNCS(readonly, 4, READONLY) EXT4_FEATURE_RO_COMPAT_FUNCS(project, 4, PROJECT) EXT4_FEATURE_RO_COMPAT_FUNCS(shared_blocks, 4, SHARED_BLOCKS) EXT4_FEATURE_RO_COMPAT_FUNCS(verity, 4, VERITY) EXT4_FEATURE_INCOMPAT_FUNCS(compression, 2, COMPRESSION) EXT4_FEATURE_INCOMPAT_FUNCS(filetype, 2, FILETYPE) EXT4_FEATURE_INCOMPAT_FUNCS(journal_needs_recovery, 3, RECOVER) EXT4_FEATURE_INCOMPAT_FUNCS(journal_dev, 3, JOURNAL_DEV) EXT4_FEATURE_INCOMPAT_FUNCS(meta_bg, 2, META_BG) EXT4_FEATURE_INCOMPAT_FUNCS(extents, 3, EXTENTS) EXT4_FEATURE_INCOMPAT_FUNCS(64bit, 4, 64BIT) EXT4_FEATURE_INCOMPAT_FUNCS(mmp, 4, MMP) EXT4_FEATURE_INCOMPAT_FUNCS(flex_bg, 4, FLEX_BG) EXT4_FEATURE_INCOMPAT_FUNCS(ea_inode, 4, EA_INODE) EXT4_FEATURE_INCOMPAT_FUNCS(dirdata, 4, DIRDATA) EXT4_FEATURE_INCOMPAT_FUNCS(csum_seed, 4, CSUM_SEED) EXT4_FEATURE_INCOMPAT_FUNCS(largedir, 4, LARGEDIR) EXT4_FEATURE_INCOMPAT_FUNCS(inline_data, 4, INLINE_DATA) EXT4_FEATURE_INCOMPAT_FUNCS(encrypt, 4, ENCRYPT) EXT4_FEATURE_INCOMPAT_FUNCS(casefold, 4, CASEFOLD) #define EXT2_FEATURE_COMPAT_SUPP 0 #define EXT2_FEATURE_INCOMPAT_SUPP (EXT2_FEATURE_INCOMPAT_FILETYPE| \ EXT4_FEATURE_INCOMPAT_MMP| \ EXT4_FEATURE_INCOMPAT_LARGEDIR| \ EXT4_FEATURE_INCOMPAT_EA_INODE) #define EXT2_FEATURE_RO_COMPAT_SUPP (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER| \ EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \ EXT4_FEATURE_RO_COMPAT_DIR_NLINK| \ EXT2_FEATURE_RO_COMPAT_BTREE_DIR| \ EXT4_FEATURE_RO_COMPAT_VERITY) /* * Default values for user and/or group using reserved blocks */ #define EXT2_DEF_RESUID 0 #define EXT2_DEF_RESGID 0 /* * Default mount options */ #define EXT2_DEFM_DEBUG 0x0001 #define EXT2_DEFM_BSDGROUPS 0x0002 #define EXT2_DEFM_XATTR_USER 0x0004 #define EXT2_DEFM_ACL 0x0008 #define EXT2_DEFM_UID16 0x0010 #define EXT3_DEFM_JMODE 0x0060 #define EXT3_DEFM_JMODE_DATA 0x0020 #define EXT3_DEFM_JMODE_ORDERED 0x0040 #define EXT3_DEFM_JMODE_WBACK 0x0060 #define EXT4_DEFM_NOBARRIER 0x0100 #define EXT4_DEFM_BLOCK_VALIDITY 0x0200 #define EXT4_DEFM_DISCARD 0x0400 #define EXT4_DEFM_NODELALLOC 0x0800 /* * Structure of a directory entry */ #define EXT2_NAME_LEN 255 struct ext2_dir_entry { __u32 inode; /* Inode number */ __u16 rec_len; /* Directory entry length */ __u16 name_len; /* Name length */ char name[EXT2_NAME_LEN]; /* File name */ }; /* * The new version of the directory entry. Since EXT2 structures are * stored in intel byte order, and the name_len field could never be * bigger than 255 chars, it's safe to reclaim the extra byte for the * file_type field. * * This structure is deprecated due to endian issues. Please use struct * ext2_dir_entry and accessor functions * ext2fs_dirent_name_len * ext2fs_dirent_set_name_len * ext2fs_dirent_file_type * ext2fs_dirent_set_file_type * to get and set name_len and file_type fields. */ struct ext2_dir_entry_2 { __u32 inode; /* Inode number */ __u16 rec_len; /* Directory entry length */ __u8 name_len; /* Name length */ __u8 file_type; char name[EXT2_NAME_LEN]; /* File name */ }; /* * This is a bogus directory entry at the end of each leaf block that * records checksums. */ struct ext2_dir_entry_tail { __u32 det_reserved_zero1; /* Pretend to be unused */ __u16 det_rec_len; /* 12 */ __u16 det_reserved_name_len; /* 0xDE00, fake namelen/filetype */ __u32 det_checksum; /* crc32c(uuid+inode+dirent) */ }; /* * Ext2 directory file types. Only the low 3 bits are used. The * other bits are reserved for now. */ #define EXT2_FT_UNKNOWN 0 #define EXT2_FT_REG_FILE 1 #define EXT2_FT_DIR 2 #define EXT2_FT_CHRDEV 3 #define EXT2_FT_BLKDEV 4 #define EXT2_FT_FIFO 5 #define EXT2_FT_SOCK 6 #define EXT2_FT_SYMLINK 7 #define EXT2_FT_MAX 8 /* * Annoyingly, e2fsprogs always swab16s ext2_dir_entry.name_len, so we * have to build ext2_dir_entry_tail with that assumption too. This * constant helps to build the dir_entry_tail to look like it has an * "invalid" file type. */ #define EXT2_DIR_NAME_LEN_CSUM 0xDE00 /* * EXT2_DIR_PAD defines the directory entries boundaries * * NOTE: It must be a multiple of 4 */ #define EXT2_DIR_ENTRY_HEADER_LEN 8 #define EXT2_DIR_PAD 4 #define EXT2_DIR_ROUND (EXT2_DIR_PAD - 1) #define EXT2_DIR_REC_LEN(name_len) (((name_len) + \ EXT2_DIR_ENTRY_HEADER_LEN + \ EXT2_DIR_ROUND) & \ ~EXT2_DIR_ROUND) /* * Constants for ext4's extended time encoding */ #define EXT4_EPOCH_BITS 2 #define EXT4_EPOCH_MASK ((1 << EXT4_EPOCH_BITS) - 1) #define EXT4_NSEC_MASK (~0UL << EXT4_EPOCH_BITS) /* * This structure is used for multiple mount protection. It is written * into the block number saved in the s_mmp_block field in the superblock. * Programs that check MMP should assume that if SEQ_FSCK (or any unknown * code above SEQ_MAX) is present then it is NOT safe to use the filesystem, * regardless of how old the timestamp is. * * The timestamp in the MMP structure will be updated by e2fsck at some * arbitrary intervals (start of passes, after every few groups of inodes * in pass1 and pass1b). There is no guarantee that e2fsck is updating * the MMP block in a timely manner, and the updates it does are purely * for the convenience of the sysadmin and not for automatic validation. * * Note: Only the mmp_seq value is used to determine whether the MMP block * is being updated. The mmp_time, mmp_nodename, and mmp_bdevname * fields are only for informational purposes for the administrator, * due to clock skew between nodes and hostname HA service takeover. */ #define EXT4_MMP_MAGIC 0x004D4D50U /* ASCII for MMP */ #define EXT4_MMP_SEQ_CLEAN 0xFF4D4D50U /* mmp_seq value for clean unmount */ #define EXT4_MMP_SEQ_FSCK 0xE24D4D50U /* mmp_seq value when being fscked */ #define EXT4_MMP_SEQ_MAX 0xE24D4D4FU /* maximum valid mmp_seq value */ /* Not endian-annotated; it's swapped at read/write time */ struct mmp_struct { __u32 mmp_magic; /* Magic number for MMP */ __u32 mmp_seq; /* Sequence no. updated periodically */ __u64 mmp_time; /* Time last updated (seconds) */ __u8 mmp_nodename[64]; /* Node updating MMP block, no NUL? */ __u8 mmp_bdevname[32]; /* Bdev updating MMP block, no NUL? */ __u16 mmp_check_interval; /* Changed mmp_check_interval */ __u16 mmp_pad1; __u32 mmp_pad2[226]; __u32 mmp_checksum; /* crc32c(uuid+mmp_block) */ }; /* * Default interval for MMP update in seconds. */ #define EXT4_MMP_UPDATE_INTERVAL 5 /* * Maximum interval for MMP update in seconds. */ #define EXT4_MMP_MAX_UPDATE_INTERVAL 300 /* * Minimum interval for MMP checking in seconds. */ #define EXT4_MMP_MIN_CHECK_INTERVAL 5 /* * Minimum size of inline data. */ #define EXT4_MIN_INLINE_DATA_SIZE ((sizeof(__u32) * EXT2_N_BLOCKS)) /* * Size of a parent inode in inline data directory. */ #define EXT4_INLINE_DATA_DOTDOT_SIZE (4) #define EXT4_ENC_UTF8_12_1 1 #define EXT4_ENC_STRICT_MODE_FL (1 << 0) /* Reject invalid sequences */ #endif /* _LINUX_EXT2_FS_H */ PK!f ext2_io.hnu[/* * io.h --- the I/O manager abstraction * * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o. * * %Begin-Header% * This file may be redistributed under the terms of the GNU Library * General Public License, version 2. * %End-Header% */ #ifndef _EXT2FS_EXT2_IO_H #define _EXT2FS_EXT2_IO_H #include /* * ext2_loff_t is defined here since unix_io.c needs it. */ #if defined(__GNUC__) || defined(HAS_LONG_LONG) typedef long long ext2_loff_t; #else typedef long ext2_loff_t; #endif /* llseek.c */ ext2_loff_t ext2fs_llseek (int, ext2_loff_t, int); typedef struct struct_io_manager *io_manager; typedef struct struct_io_channel *io_channel; typedef struct struct_io_stats *io_stats; #define CHANNEL_FLAGS_WRITETHROUGH 0x01 #define CHANNEL_FLAGS_DISCARD_ZEROES 0x02 #define CHANNEL_FLAGS_BLOCK_DEVICE 0x04 #define io_channel_discard_zeroes_data(i) (i->flags & CHANNEL_FLAGS_DISCARD_ZEROES) struct struct_io_channel { errcode_t magic; io_manager manager; char *name; int block_size; errcode_t (*read_error)(io_channel channel, unsigned long block, int count, void *data, size_t size, int actual_bytes_read, errcode_t error); errcode_t (*write_error)(io_channel channel, unsigned long block, int count, const void *data, size_t size, int actual_bytes_written, errcode_t error); int refcount; int flags; long reserved[14]; void *private_data; void *app_data; int align; }; struct struct_io_stats { int num_fields; int reserved; unsigned long long bytes_read; unsigned long long bytes_written; }; struct struct_io_manager { errcode_t magic; const char *name; errcode_t (*open)(const char *name, int flags, io_channel *channel); errcode_t (*close)(io_channel channel); errcode_t (*set_blksize)(io_channel channel, int blksize); errcode_t (*read_blk)(io_channel channel, unsigned long block, int count, void *data); errcode_t (*write_blk)(io_channel channel, unsigned long block, int count, const void *data); errcode_t (*flush)(io_channel channel); errcode_t (*write_byte)(io_channel channel, unsigned long offset, int count, const void *data); errcode_t (*set_option)(io_channel channel, const char *option, const char *arg); errcode_t (*get_stats)(io_channel channel, io_stats *io_stats); errcode_t (*read_blk64)(io_channel channel, unsigned long long block, int count, void *data); errcode_t (*write_blk64)(io_channel channel, unsigned long long block, int count, const void *data); errcode_t (*discard)(io_channel channel, unsigned long long block, unsigned long long count); errcode_t (*cache_readahead)(io_channel channel, unsigned long long block, unsigned long long count); errcode_t (*zeroout)(io_channel channel, unsigned long long block, unsigned long long count); long reserved[14]; }; #define IO_FLAG_RW 0x0001 #define IO_FLAG_EXCLUSIVE 0x0002 #define IO_FLAG_DIRECT_IO 0x0004 #define IO_FLAG_FORCE_BOUNCE 0x0008 /* * Convenience functions.... */ #define io_channel_close(c) ((c)->manager->close((c))) #define io_channel_set_blksize(c,s) ((c)->manager->set_blksize((c),s)) #define io_channel_read_blk(c,b,n,d) ((c)->manager->read_blk((c),b,n,d)) #define io_channel_write_blk(c,b,n,d) ((c)->manager->write_blk((c),b,n,d)) #define io_channel_flush(c) ((c)->manager->flush((c))) #define io_channel_bumpcount(c) ((c)->refcount++) /* io_manager.c */ extern errcode_t io_channel_set_options(io_channel channel, const char *options); extern errcode_t io_channel_write_byte(io_channel channel, unsigned long offset, int count, const void *data); extern errcode_t io_channel_read_blk64(io_channel channel, unsigned long long block, int count, void *data); extern errcode_t io_channel_write_blk64(io_channel channel, unsigned long long block, int count, const void *data); extern errcode_t io_channel_discard(io_channel channel, unsigned long long block, unsigned long long count); extern errcode_t io_channel_zeroout(io_channel channel, unsigned long long block, unsigned long long count); extern errcode_t io_channel_alloc_buf(io_channel channel, int count, void *ptr); extern errcode_t io_channel_cache_readahead(io_channel io, unsigned long long block, unsigned long long count); /* unix_io.c */ extern io_manager unix_io_manager; extern io_manager unixfd_io_manager; /* sparse_io.c */ extern io_manager sparse_io_manager; extern io_manager sparsefd_io_manager; /* undo_io.c */ extern io_manager undo_io_manager; extern errcode_t set_undo_io_backing_manager(io_manager manager); extern errcode_t set_undo_io_backup_file(char *file_name); /* test_io.c */ extern io_manager test_io_manager, test_io_backing_manager; extern void (*test_io_cb_read_blk) (unsigned long block, int count, errcode_t err); extern void (*test_io_cb_write_blk) (unsigned long block, int count, errcode_t err); extern void (*test_io_cb_read_blk64) (unsigned long long block, int count, errcode_t err); extern void (*test_io_cb_write_blk64) (unsigned long long block, int count, errcode_t err); extern void (*test_io_cb_set_blksize) (int blksize, errcode_t err); #endif /* _EXT2FS_EXT2_IO_H */ PK!+ttext2_types-x86_64.hnu[/* * If linux/types.h is already been included, assume it has defined * everything we need. (cross fingers) Other header files may have * also defined the types that we need. */ #if (!defined(_LINUX_TYPES_H) && !defined(_BLKID_TYPES_H) && \ !defined(_EXT2_TYPES_H)) #define _EXT2_TYPES_H #define __S8_TYPEDEF __signed__ char #define __U8_TYPEDEF unsigned char #define __S16_TYPEDEF __signed__ short #define __U16_TYPEDEF unsigned short #define __S32_TYPEDEF __signed__ int #define __U32_TYPEDEF unsigned int #define __S64_TYPEDEF __signed__ long long #define __U64_TYPEDEF unsigned long long #ifndef HAVE___U8 #define HAVE___U8 #ifdef __U8_TYPEDEF typedef __U8_TYPEDEF __u8; #else typedef unsigned char __u8; #endif #endif /* HAVE___U8 */ #ifndef HAVE___S8 #define HAVE___S8 #ifdef __S8_TYPEDEF typedef __S8_TYPEDEF __s8; #else typedef signed char __s8; #endif #endif /* HAVE___S8 */ #ifndef HAVE___U16 #define HAVE___U16 #ifdef __U16_TYPEDEF typedef __U16_TYPEDEF __u16; #else #if (4 == 2) typedef unsigned int __u16; #else #if (2 == 2) typedef unsigned short __u16; #else #undef HAVE___U16 ?==error: undefined 16 bit type #endif /* SIZEOF_SHORT == 2 */ #endif /* SIZEOF_INT == 2 */ #endif /* __U16_TYPEDEF */ #endif /* HAVE___U16 */ #ifndef HAVE___S16 #define HAVE___S16 #ifdef __S16_TYPEDEF typedef __S16_TYPEDEF __s16; #else #if (4 == 2) typedef int __s16; #else #if (2 == 2) typedef short __s16; #else #undef HAVE___S16 ?==error: undefined 16 bit type #endif /* SIZEOF_SHORT == 2 */ #endif /* SIZEOF_INT == 2 */ #endif /* __S16_TYPEDEF */ #endif /* HAVE___S16 */ #ifndef HAVE___U32 #define HAVE___U32 #ifdef __U32_TYPEDEF typedef __U32_TYPEDEF __u32; #else #if (4 == 4) typedef unsigned int __u32; #else #if (8 == 4) typedef unsigned long __u32; #else #if (2 == 4) typedef unsigned short __u32; #else #undef HAVE___U32 ?== error: undefined 32 bit type #endif /* SIZEOF_SHORT == 4 */ #endif /* SIZEOF_LONG == 4 */ #endif /* SIZEOF_INT == 4 */ #endif /* __U32_TYPEDEF */ #endif /* HAVE___U32 */ #ifndef HAVE___S32 #define HAVE___S32 #ifdef __S32_TYPEDEF typedef __S32_TYPEDEF __s32; #else #if (4 == 4) typedef int __s32; #else #if (8 == 4) typedef long __s32; #else #if (2 == 4) typedef short __s32; #else #undef HAVE___S32 ?== error: undefined 32 bit type #endif /* SIZEOF_SHORT == 4 */ #endif /* SIZEOF_LONG == 4 */ #endif /* SIZEOF_INT == 4 */ #endif /* __S32_TYPEDEF */ #endif /* HAVE___S32 */ #ifndef HAVE___U64 #define HAVE___U64 #ifdef __U64_TYPEDEF typedef __U64_TYPEDEF __u64; #else #if (4 == 8) typedef unsigned int __u64; #else #if (8 == 8) typedef unsigned long long __u64; #else #if (8 == 8) typedef unsigned long __u64; #else #undef HAVE___U64 ?== error: undefined 64 bit type #endif /* SIZEOF_LONG_LONG == 8 */ #endif /* SIZEOF_LONG == 8 */ #endif /* SIZEOF_INT == 8 */ #endif /* __U64_TYPEDEF */ #endif /* HAVE___U64 */ #ifndef HAVE___S64 #define HAVE___S64 #ifdef __S64_TYPEDEF typedef __S64_TYPEDEF __s64; #else #if (4 == 8) typedef int __s64; #else #if (8 == 8) #if defined(__GNUC__) typedef __signed__ long long __s64; #else typedef signed long long __s64; #endif /* __GNUC__ */ #else #if (8 == 8) typedef long __s64; #else #undef HAVE___S64 ?== error: undefined 64 bit type #endif /* SIZEOF_LONG_LONG == 8 */ #endif /* SIZEOF_LONG == 8 */ #endif /* SIZEOF_INT == 8 */ #endif /* __S64_TYPEDEF */ #endif /* HAVE___S64 */ #undef __S8_TYPEDEF #undef __U8_TYPEDEF #undef __S16_TYPEDEF #undef __U16_TYPEDEF #undef __S32_TYPEDEF #undef __U32_TYPEDEF #undef __S64_TYPEDEF #undef __U64_TYPEDEF #endif /* _*_TYPES_H */ #include /* endian checking stuff */ #ifndef EXT2_ENDIAN_H_ #define EXT2_ENDIAN_H_ #ifdef __CHECKER__ # ifndef __bitwise # define __bitwise __attribute__((bitwise)) # endif #define __force __attribute__((force)) #else # ifndef __bitwise # define __bitwise # endif #define __force #endif typedef __u16 __bitwise __le16; typedef __u32 __bitwise __le32; typedef __u64 __bitwise __le64; typedef __u16 __bitwise __be16; typedef __u32 __bitwise __be32; typedef __u64 __bitwise __be64; #endif /* EXT2_ENDIAN_H_ */ /* These defines are needed for the public ext2fs.h header file */ #define HAVE_SYS_TYPES_H 1 #undef WORDS_BIGENDIAN PK!a ext2_types.hnu[/* * Kluge to support multilib installation of both 32- and 64-bit RPMS: * we need to arrange that header files that appear in both RPMs are * identical. Hence, this file is architecture-independent and calls * in an arch-dependent file that will appear in just one RPM. * * To avoid breaking arches not explicitly supported by Red Hat, we * use this indirection file *only* on known multilib arches. * * We pay attention to include _only_ the original multilib-unclean * header file. Including any other system-header file could cause * unpredictable include-ordering issues (rhbz#1412274, comment #16). * * Note: this may well fail if user tries to use gcc's -I- option. * But that option is deprecated anyway. */ #if defined(__x86_64__) #include "ext2_types-x86_64.h" #elif defined(__i386__) #include "ext2_types-i386.h" #elif defined(__ppc64__) || defined(__powerpc64__) #include "ext2_types-ppc64.h" #elif defined(__ppc__) || defined(__powerpc__) #include "ext2_types-ppc.h" #elif defined(__s390x__) #include "ext2_types-s390x.h" #elif defined(__s390__) #include "ext2_types-s390.h" #elif defined(__sparc__) && defined(__arch64__) #include "ext2_types-sparc64.h" #elif defined(__sparc__) #include "ext2_types-sparc.h" #endif PK!3ext2fs.hnu[/* * ext2fs.h --- ext2fs * * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o. * * %Begin-Header% * This file may be redistributed under the terms of the GNU Library * General Public License, version 2. * %End-Header% */ #ifndef _EXT2FS_EXT2FS_H #define _EXT2FS_EXT2FS_H #ifdef __GNUC__ #define EXT2FS_ATTR(x) __attribute__(x) #else #define EXT2FS_ATTR(x) #endif #ifdef CONFIG_TDB #define EXT2FS_NO_TDB_UNUSED #else #define EXT2FS_NO_TDB_UNUSED EXT2FS_ATTR((unused)) #endif #ifdef __cplusplus extern "C" { #endif /* * Non-GNU C compilers won't necessarily understand inline */ #if (!defined(__GNUC__) && !defined(__WATCOMC__)) #define NO_INLINE_FUNCS #endif /* * Where the master copy of the superblock is located, and how big * superblocks are supposed to be. We define SUPERBLOCK_SIZE because * the size of the superblock structure is not necessarily trustworthy * (some versions have the padding set up so that the superblock is * 1032 bytes long). */ #define SUPERBLOCK_OFFSET 1024 #define SUPERBLOCK_SIZE 1024 #define UUID_STR_SIZE 37 /* * The last ext2fs revision level that this version of the library is * able to support. */ #define EXT2_LIB_CURRENT_REV EXT2_DYNAMIC_REV #ifdef HAVE_SYS_TYPES_H #include #endif #include #include #include #include #include #if EXT2_FLAT_INCLUDES #include "e2_types.h" #include "ext2_fs.h" #include "ext3_extents.h" #else #include #include #include #endif /* EXT2_FLAT_INCLUDES */ typedef __u32 __bitwise ext2_ino_t; typedef __u32 __bitwise blk_t; typedef __u64 __bitwise blk64_t; typedef __u32 __bitwise dgrp_t; typedef __s32 __bitwise ext2_off_t; typedef __s64 __bitwise ext2_off64_t; typedef __s64 __bitwise e2_blkcnt_t; typedef __u32 __bitwise ext2_dirhash_t; #if EXT2_FLAT_INCLUDES #include "com_err.h" #include "ext2_io.h" #include "ext2_err.h" #include "ext2_ext_attr.h" #else #include #include #include #include #endif #include "hashmap.h" /* * Portability help for Microsoft Visual C++ */ #ifdef _MSC_VER #define EXT2_QSORT_TYPE int __cdecl #else #define EXT2_QSORT_TYPE int #endif typedef struct struct_ext2_filsys *ext2_filsys; #define EXT2FS_MARK_ERROR 0 #define EXT2FS_UNMARK_ERROR 1 #define EXT2FS_TEST_ERROR 2 typedef struct ext2fs_struct_generic_bitmap *ext2fs_generic_bitmap; typedef struct ext2fs_struct_generic_bitmap *ext2fs_inode_bitmap; typedef struct ext2fs_struct_generic_bitmap *ext2fs_block_bitmap; #define EXT2_FIRST_INODE(s) EXT2_FIRST_INO(s) /* * Badblocks list definitions */ typedef struct ext2_struct_u32_list *ext2_badblocks_list; typedef struct ext2_struct_u32_iterate *ext2_badblocks_iterate; typedef struct ext2_struct_u32_list *ext2_u32_list; typedef struct ext2_struct_u32_iterate *ext2_u32_iterate; /* old */ typedef struct ext2_struct_u32_list *badblocks_list; typedef struct ext2_struct_u32_iterate *badblocks_iterate; #define BADBLOCKS_FLAG_DIRTY 1 /* * ext2_dblist structure and abstractions (see dblist.c) */ struct ext2_db_entry2 { ext2_ino_t ino; blk64_t blk; e2_blkcnt_t blockcnt; }; /* Ye Olde 32-bit version */ struct ext2_db_entry { ext2_ino_t ino; blk_t blk; int blockcnt; }; typedef struct ext2_struct_dblist *ext2_dblist; #define DBLIST_ABORT 1 /* * ext2_fileio definitions */ #define EXT2_FILE_WRITE 0x0001 #define EXT2_FILE_CREATE 0x0002 #define EXT2_FILE_MASK 0x00FF #define EXT2_FILE_BUF_DIRTY 0x4000 #define EXT2_FILE_BUF_VALID 0x2000 typedef struct ext2_file *ext2_file_t; #define EXT2_SEEK_SET 0 #define EXT2_SEEK_CUR 1 #define EXT2_SEEK_END 2 /* * Flags for the ext2_filsys structure and for ext2fs_open() */ #define EXT2_FLAG_RW 0x01 #define EXT2_FLAG_CHANGED 0x02 #define EXT2_FLAG_DIRTY 0x04 #define EXT2_FLAG_VALID 0x08 #define EXT2_FLAG_IB_DIRTY 0x10 #define EXT2_FLAG_BB_DIRTY 0x20 #define EXT2_FLAG_SWAP_BYTES 0x40 #define EXT2_FLAG_SWAP_BYTES_READ 0x80 #define EXT2_FLAG_SWAP_BYTES_WRITE 0x100 #define EXT2_FLAG_MASTER_SB_ONLY 0x200 #define EXT2_FLAG_FORCE 0x400 #define EXT2_FLAG_SUPER_ONLY 0x800 #define EXT2_FLAG_JOURNAL_DEV_OK 0x1000 #define EXT2_FLAG_IMAGE_FILE 0x2000 #define EXT2_FLAG_EXCLUSIVE 0x4000 #define EXT2_FLAG_SOFTSUPP_FEATURES 0x8000 #define EXT2_FLAG_NOFREE_ON_ERROR 0x10000 #define EXT2_FLAG_64BITS 0x20000 #define EXT2_FLAG_PRINT_PROGRESS 0x40000 #define EXT2_FLAG_DIRECT_IO 0x80000 #define EXT2_FLAG_SKIP_MMP 0x100000 #define EXT2_FLAG_IGNORE_CSUM_ERRORS 0x200000 #define EXT2_FLAG_SHARE_DUP 0x400000 #define EXT2_FLAG_IGNORE_SB_ERRORS 0x800000 #define EXT2_FLAG_BBITMAP_TAIL_PROBLEM 0x1000000 #define EXT2_FLAG_IBITMAP_TAIL_PROBLEM 0x2000000 /* * Special flag in the ext2 inode i_flag field that means that this is * a new inode. (So that ext2_write_inode() can clear extra fields.) */ #define EXT2_NEW_INODE_FL 0x80000000 /* * Flags for mkjournal */ #define EXT2_MKJOURNAL_V1_SUPER 0x0000001 /* create V1 superblock (deprecated) */ #define EXT2_MKJOURNAL_LAZYINIT 0x0000002 /* don't zero journal inode before use*/ #define EXT2_MKJOURNAL_NO_MNT_CHECK 0x0000004 /* don't check mount status */ struct blk_alloc_ctx; struct opaque_ext2_group_desc; struct struct_ext2_filsys { errcode_t magic; io_channel io; int flags; char * device_name; struct ext2_super_block * super; unsigned int blocksize; int fragsize; dgrp_t group_desc_count; unsigned long desc_blocks; struct opaque_ext2_group_desc * group_desc; unsigned int inode_blocks_per_group; ext2fs_inode_bitmap inode_map; ext2fs_block_bitmap block_map; /* XXX FIXME-64: not 64-bit safe, but not used? */ errcode_t (*get_blocks)(ext2_filsys fs, ext2_ino_t ino, blk_t *blocks); errcode_t (*check_directory)(ext2_filsys fs, ext2_ino_t ino); errcode_t (*write_bitmaps)(ext2_filsys fs); errcode_t (*read_inode)(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode); errcode_t (*write_inode)(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode); ext2_badblocks_list badblocks; ext2_dblist dblist; __u32 stride; /* for mke2fs */ struct ext2_super_block * orig_super; struct ext2_image_hdr * image_header; __u32 umask; time_t now; int cluster_ratio_bits; __u16 default_bitmap_type; __u16 pad; /* * RedHat specific change to prevent ABI change by using 8 * reserved bytes */ const struct ext2fs_nls_table *encoding; /* * Reserved for future expansion */ __u32 reserved[5 - (sizeof(long int)/4)]; /* * Reserved for the use of the calling application. */ void * priv_data; /* * Inode cache */ struct ext2_inode_cache *icache; io_channel image_io; /* * More callback functions */ errcode_t (*get_alloc_block)(ext2_filsys fs, blk64_t goal, blk64_t *ret); errcode_t (*get_alloc_block2)(ext2_filsys fs, blk64_t goal, blk64_t *ret, struct blk_alloc_ctx *ctx); void (*block_alloc_stats)(ext2_filsys fs, blk64_t blk, int inuse); /* * Buffers for Multiple mount protection(MMP) block. */ void *mmp_buf; void *mmp_cmp; int mmp_fd; /* * Time at which e2fsck last updated the MMP block. */ long mmp_last_written; /* progress operation functions */ struct ext2fs_progress_ops *progress_ops; /* Precomputed FS UUID checksum for seeding other checksums */ __u32 csum_seed; io_channel journal_io; char *journal_name; /* New block range allocation hooks */ errcode_t (*new_range)(ext2_filsys fs, int flags, blk64_t goal, blk64_t len, blk64_t *pblk, blk64_t *plen); void (*block_alloc_stats_range)(ext2_filsys fs, blk64_t blk, blk_t num, int inuse); /* hashmap for SHA of data blocks */ struct ext2fs_hashmap* block_sha_map; }; #if EXT2_FLAT_INCLUDES #include "e2_bitops.h" #else #include #endif /* * 64-bit bitmap backend types */ #define EXT2FS_BMAP64_BITARRAY 1 #define EXT2FS_BMAP64_RBTREE 2 #define EXT2FS_BMAP64_AUTODIR 3 /* * Return flags for the block iterator functions */ #define BLOCK_CHANGED 1 #define BLOCK_ABORT 2 #define BLOCK_ERROR 4 #define BLOCK_INLINE_DATA_CHANGED 8 /* * Block interate flags * * BLOCK_FLAG_APPEND, or BLOCK_FLAG_HOLE, indicates that the interator * function should be called on blocks where the block number is zero. * This is used by ext2fs_expand_dir() to be able to add a new block * to an inode. It can also be used for programs that want to be able * to deal with files that contain "holes". * * BLOCK_FLAG_DEPTH_TRAVERSE indicates that the iterator function for * the indirect, doubly indirect, etc. blocks should be called after * all of the blocks contained in the indirect blocks are processed. * This is useful if you are going to be deallocating blocks from an * inode. * * BLOCK_FLAG_DATA_ONLY indicates that the iterator function should be * called for data blocks only. * * BLOCK_FLAG_READ_ONLY is a promise by the caller that it will not * modify returned block number. * * BLOCK_FLAG_NO_LARGE is for internal use only. It informs * ext2fs_block_iterate2 that large files won't be accepted. */ #define BLOCK_FLAG_APPEND 1 #define BLOCK_FLAG_HOLE 1 #define BLOCK_FLAG_DEPTH_TRAVERSE 2 #define BLOCK_FLAG_DATA_ONLY 4 #define BLOCK_FLAG_READ_ONLY 8 #define BLOCK_FLAG_NO_LARGE 0x1000 /* * Magic "block count" return values for the block iterator function. */ #define BLOCK_COUNT_IND (-1) #define BLOCK_COUNT_DIND (-2) #define BLOCK_COUNT_TIND (-3) #define BLOCK_COUNT_TRANSLATOR (-4) #define BLOCK_ALLOC_UNKNOWN 0 #define BLOCK_ALLOC_DATA 1 #define BLOCK_ALLOC_METADATA 2 struct blk_alloc_ctx { ext2_ino_t ino; struct ext2_inode *inode; blk64_t lblk; int flags; }; #if 0 /* * Flags for ext2fs_move_blocks */ #define EXT2_BMOVE_GET_DBLIST 0x0001 #define EXT2_BMOVE_DEBUG 0x0002 #endif /* * Generic (non-filesystem layout specific) extents structure */ #define EXT2_EXTENT_FLAGS_LEAF 0x0001 #define EXT2_EXTENT_FLAGS_UNINIT 0x0002 #define EXT2_EXTENT_FLAGS_SECOND_VISIT 0x0004 struct ext2fs_extent { blk64_t e_pblk; /* first physical block */ blk64_t e_lblk; /* first logical block extent covers */ __u32 e_len; /* number of blocks covered by extent */ __u32 e_flags; /* extent flags */ }; typedef struct ext2_extent_handle *ext2_extent_handle_t; typedef struct ext2_extent_path *ext2_extent_path_t; /* * Flags used by ext2fs_extent_get() */ #define EXT2_EXTENT_CURRENT 0x0000 #define EXT2_EXTENT_MOVE_MASK 0x000F #define EXT2_EXTENT_ROOT 0x0001 #define EXT2_EXTENT_LAST_LEAF 0x0002 #define EXT2_EXTENT_FIRST_SIB 0x0003 #define EXT2_EXTENT_LAST_SIB 0x0004 #define EXT2_EXTENT_NEXT_SIB 0x0005 #define EXT2_EXTENT_PREV_SIB 0x0006 #define EXT2_EXTENT_NEXT_LEAF 0x0007 #define EXT2_EXTENT_PREV_LEAF 0x0008 #define EXT2_EXTENT_NEXT 0x0009 #define EXT2_EXTENT_PREV 0x000A #define EXT2_EXTENT_UP 0x000B #define EXT2_EXTENT_DOWN 0x000C #define EXT2_EXTENT_DOWN_AND_LAST 0x000D /* * Flags used by ext2fs_extent_insert() */ #define EXT2_EXTENT_INSERT_AFTER 0x0001 /* insert after handle loc'n */ #define EXT2_EXTENT_INSERT_NOSPLIT 0x0002 /* insert may not cause split */ /* * Flags used by ext2fs_extent_delete() */ #define EXT2_EXTENT_DELETE_KEEP_EMPTY 0x001 /* keep node if last extent gone */ /* * Flags used by ext2fs_extent_set_bmap() */ #define EXT2_EXTENT_SET_BMAP_UNINIT 0x0001 /* * Data structure returned by ext2fs_extent_get_info() */ struct ext2_extent_info { int curr_entry; int curr_level; int num_entries; int max_entries; int max_depth; int bytes_avail; blk64_t max_lblk; blk64_t max_pblk; __u32 max_len; __u32 max_uninit_len; }; /* * Flags for directory block reading and writing functions */ #define EXT2_DIRBLOCK_V2_STRUCT 0x0001 /* * Return flags for the directory iterator functions */ #define DIRENT_CHANGED 1 #define DIRENT_ABORT 2 #define DIRENT_ERROR 3 /* * Directory iterator flags */ #define DIRENT_FLAG_INCLUDE_EMPTY 1 #define DIRENT_FLAG_INCLUDE_REMOVED 2 #define DIRENT_FLAG_INCLUDE_CSUM 4 #define DIRENT_FLAG_INCLUDE_INLINE_DATA 8 #define DIRENT_DOT_FILE 1 #define DIRENT_DOT_DOT_FILE 2 #define DIRENT_OTHER_FILE 3 #define DIRENT_DELETED_FILE 4 #define DIRENT_CHECKSUM 5 /* * Inode scan definitions */ typedef struct ext2_struct_inode_scan *ext2_inode_scan; /* * ext2fs_scan flags */ #define EXT2_SF_CHK_BADBLOCKS 0x0001 #define EXT2_SF_BAD_INODE_BLK 0x0002 #define EXT2_SF_BAD_EXTRA_BYTES 0x0004 #define EXT2_SF_SKIP_MISSING_ITABLE 0x0008 #define EXT2_SF_DO_LAZY 0x0010 #define EXT2_SF_WARN_GARBAGE_INODES 0x0020 /* * ext2fs_check_if_mounted flags */ #define EXT2_MF_MOUNTED 1 #define EXT2_MF_ISROOT 2 #define EXT2_MF_READONLY 4 #define EXT2_MF_SWAP 8 #define EXT2_MF_BUSY 16 /* * Ext2/linux mode flags. We define them here so that we don't need * to depend on the OS's sys/stat.h, since we may be compiling on a * non-Linux system. */ #define LINUX_S_IFMT 00170000 #define LINUX_S_IFSOCK 0140000 #define LINUX_S_IFLNK 0120000 #define LINUX_S_IFREG 0100000 #define LINUX_S_IFBLK 0060000 #define LINUX_S_IFDIR 0040000 #define LINUX_S_IFCHR 0020000 #define LINUX_S_IFIFO 0010000 #define LINUX_S_ISUID 0004000 #define LINUX_S_ISGID 0002000 #define LINUX_S_ISVTX 0001000 #define LINUX_S_IRWXU 00700 #define LINUX_S_IRUSR 00400 #define LINUX_S_IWUSR 00200 #define LINUX_S_IXUSR 00100 #define LINUX_S_IRWXG 00070 #define LINUX_S_IRGRP 00040 #define LINUX_S_IWGRP 00020 #define LINUX_S_IXGRP 00010 #define LINUX_S_IRWXO 00007 #define LINUX_S_IROTH 00004 #define LINUX_S_IWOTH 00002 #define LINUX_S_IXOTH 00001 #define LINUX_S_ISLNK(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFLNK) #define LINUX_S_ISREG(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFREG) #define LINUX_S_ISDIR(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFDIR) #define LINUX_S_ISCHR(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFCHR) #define LINUX_S_ISBLK(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFBLK) #define LINUX_S_ISFIFO(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFIFO) #define LINUX_S_ISSOCK(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFSOCK) /* * ext2 size of an inode */ #define EXT2_I_SIZE(i) ((i)->i_size | ((__u64) (i)->i_size_high << 32)) /* * ext2_icount_t abstraction */ #define EXT2_ICOUNT_OPT_INCREMENT 0x01 #define EXT2_ICOUNT_OPT_FULLMAP 0x02 typedef struct ext2_icount *ext2_icount_t; /* * Flags for ext2fs_bmap */ #define BMAP_ALLOC 0x0001 #define BMAP_SET 0x0002 #define BMAP_UNINIT 0x0004 #define BMAP_ZERO 0x0008 /* * Returned flags from ext2fs_bmap */ #define BMAP_RET_UNINIT 0x0001 /* * Flags for ext2fs_read_inode2 */ #define READ_INODE_NOCSUM 0x0001 /* * Flags for ext2fs_write_inode2 */ #define WRITE_INODE_NOCSUM 0x0001 /* * Flags for imager.c functions */ #define IMAGER_FLAG_INODEMAP 1 #define IMAGER_FLAG_SPARSEWRITE 2 /* * For checking structure magic numbers... */ #define EXT2_CHECK_MAGIC(struct, code) \ if ((struct)->magic != (code)) return (code) /* * Features supported by this version of the library */ #define EXT2_LIB_FEATURE_COMPAT_SUPP (EXT2_FEATURE_COMPAT_DIR_PREALLOC|\ EXT2_FEATURE_COMPAT_IMAGIC_INODES|\ EXT3_FEATURE_COMPAT_HAS_JOURNAL|\ EXT2_FEATURE_COMPAT_RESIZE_INODE|\ EXT2_FEATURE_COMPAT_DIR_INDEX|\ EXT2_FEATURE_COMPAT_EXT_ATTR|\ EXT4_FEATURE_COMPAT_SPARSE_SUPER2) #ifdef CONFIG_MMP #define EXT4_LIB_INCOMPAT_MMP EXT4_FEATURE_INCOMPAT_MMP #else #define EXT4_LIB_INCOMPAT_MMP (0) #endif #define EXT2_LIB_FEATURE_INCOMPAT_SUPP (EXT2_FEATURE_INCOMPAT_FILETYPE|\ EXT3_FEATURE_INCOMPAT_JOURNAL_DEV|\ EXT2_FEATURE_INCOMPAT_META_BG|\ EXT3_FEATURE_INCOMPAT_RECOVER|\ EXT3_FEATURE_INCOMPAT_EXTENTS|\ EXT4_FEATURE_INCOMPAT_FLEX_BG|\ EXT4_FEATURE_INCOMPAT_EA_INODE|\ EXT4_LIB_INCOMPAT_MMP|\ EXT4_FEATURE_INCOMPAT_64BIT|\ EXT4_FEATURE_INCOMPAT_INLINE_DATA|\ EXT4_FEATURE_INCOMPAT_ENCRYPT|\ EXT4_FEATURE_INCOMPAT_CASEFOLD|\ EXT4_FEATURE_INCOMPAT_CSUM_SEED|\ EXT4_FEATURE_INCOMPAT_LARGEDIR) #define EXT2_LIB_FEATURE_RO_COMPAT_SUPP (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER|\ EXT4_FEATURE_RO_COMPAT_HUGE_FILE|\ EXT2_FEATURE_RO_COMPAT_LARGE_FILE|\ EXT4_FEATURE_RO_COMPAT_DIR_NLINK|\ EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE|\ EXT4_FEATURE_RO_COMPAT_GDT_CSUM|\ EXT4_FEATURE_RO_COMPAT_BIGALLOC|\ EXT4_FEATURE_RO_COMPAT_QUOTA|\ EXT4_FEATURE_RO_COMPAT_METADATA_CSUM|\ EXT4_FEATURE_RO_COMPAT_READONLY |\ EXT4_FEATURE_RO_COMPAT_PROJECT |\ EXT4_FEATURE_RO_COMPAT_SHARED_BLOCKS |\ EXT4_FEATURE_RO_COMPAT_VERITY) /* * These features are only allowed if EXT2_FLAG_SOFTSUPP_FEATURES is passed * to ext2fs_openfs() */ #define EXT2_LIB_SOFTSUPP_INCOMPAT (0) #define EXT2_LIB_SOFTSUPP_RO_COMPAT (EXT4_FEATURE_RO_COMPAT_REPLICA) /* Translate a block number to a cluster number */ #define EXT2FS_CLUSTER_RATIO(fs) (1 << (fs)->cluster_ratio_bits) #define EXT2FS_CLUSTER_MASK(fs) (EXT2FS_CLUSTER_RATIO(fs) - 1) #define EXT2FS_B2C(fs, blk) ((blk) >> (fs)->cluster_ratio_bits) /* Translate a cluster number to a block number */ #define EXT2FS_C2B(fs, cluster) ((cluster) << (fs)->cluster_ratio_bits) /* Translate # of blks to # of clusters */ #define EXT2FS_NUM_B2C(fs, blks) (((blks) + EXT2FS_CLUSTER_MASK(fs)) >> \ (fs)->cluster_ratio_bits) #if defined(HAVE_FSTAT64) && !defined(__OSX_AVAILABLE_BUT_DEPRECATED) typedef struct stat64 ext2fs_struct_stat; #else typedef struct stat ext2fs_struct_stat; #endif /* * For ext2fs_close2() and ext2fs_flush2(), this flag allows you to * avoid the fsync call. */ #define EXT2_FLAG_FLUSH_NO_SYNC 1 /* * Modify and iterate extended attributes */ struct ext2_xattr_handle; #define XATTR_ABORT 1 #define XATTR_CHANGED 2 /* * function prototypes */ static inline int ext2fs_has_group_desc_csum(ext2_filsys fs) { return ext2fs_has_feature_metadata_csum(fs->super) || ext2fs_has_feature_gdt_csum(fs->super); } /* The LARGE_FILE feature should be set if we have stored files 2GB+ in size */ static inline int ext2fs_needs_large_file_feature(unsigned long long file_size) { return file_size >= 0x80000000ULL; } /* alloc.c */ extern void ext2fs_clear_block_uninit(ext2_filsys fs, dgrp_t group); extern errcode_t ext2fs_new_inode(ext2_filsys fs, ext2_ino_t dir, int mode, ext2fs_inode_bitmap map, ext2_ino_t *ret); extern errcode_t ext2fs_new_block(ext2_filsys fs, blk_t goal, ext2fs_block_bitmap map, blk_t *ret); extern errcode_t ext2fs_new_block2(ext2_filsys fs, blk64_t goal, ext2fs_block_bitmap map, blk64_t *ret); extern errcode_t ext2fs_new_block3(ext2_filsys fs, blk64_t goal, ext2fs_block_bitmap map, blk64_t *ret, struct blk_alloc_ctx *ctx); extern errcode_t ext2fs_get_free_blocks(ext2_filsys fs, blk_t start, blk_t finish, int num, ext2fs_block_bitmap map, blk_t *ret); extern errcode_t ext2fs_get_free_blocks2(ext2_filsys fs, blk64_t start, blk64_t finish, int num, ext2fs_block_bitmap map, blk64_t *ret); extern errcode_t ext2fs_alloc_block(ext2_filsys fs, blk_t goal, char *block_buf, blk_t *ret); extern errcode_t ext2fs_alloc_block2(ext2_filsys fs, blk64_t goal, char *block_buf, blk64_t *ret); extern errcode_t ext2fs_alloc_block3(ext2_filsys fs, blk64_t goal, char *block_buf, blk64_t *ret, struct blk_alloc_ctx *ctx); extern void ext2fs_set_alloc_block_callback(ext2_filsys fs, errcode_t (*func)(ext2_filsys fs, blk64_t goal, blk64_t *ret), errcode_t (**old)(ext2_filsys fs, blk64_t goal, blk64_t *ret)); blk64_t ext2fs_find_inode_goal(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode, blk64_t lblk); extern void ext2fs_set_new_range_callback(ext2_filsys fs, errcode_t (*func)(ext2_filsys fs, int flags, blk64_t goal, blk64_t len, blk64_t *pblk, blk64_t *plen), errcode_t (**old)(ext2_filsys fs, int flags, blk64_t goal, blk64_t len, blk64_t *pblk, blk64_t *plen)); extern void ext2fs_set_block_alloc_stats_range_callback(ext2_filsys fs, void (*func)(ext2_filsys fs, blk64_t blk, blk_t num, int inuse), void (**old)(ext2_filsys fs, blk64_t blk, blk_t num, int inuse)); #define EXT2_NEWRANGE_FIXED_GOAL (0x1) #define EXT2_NEWRANGE_MIN_LENGTH (0x2) #define EXT2_NEWRANGE_ALL_FLAGS (0x3) errcode_t ext2fs_new_range(ext2_filsys fs, int flags, blk64_t goal, blk64_t len, ext2fs_block_bitmap map, blk64_t *pblk, blk64_t *plen); #define EXT2_ALLOCRANGE_FIXED_GOAL (0x1) #define EXT2_ALLOCRANGE_ZERO_BLOCKS (0x2) #define EXT2_ALLOCRANGE_ALL_FLAGS (0x3) errcode_t ext2fs_alloc_range(ext2_filsys fs, int flags, blk64_t goal, blk_t len, blk64_t *ret); /* alloc_sb.c */ extern int ext2fs_reserve_super_and_bgd(ext2_filsys fs, dgrp_t group, ext2fs_block_bitmap bmap); extern void ext2fs_set_block_alloc_stats_callback(ext2_filsys fs, void (*func)(ext2_filsys fs, blk64_t blk, int inuse), void (**old)(ext2_filsys fs, blk64_t blk, int inuse)); /* alloc_stats.c */ void ext2fs_inode_alloc_stats(ext2_filsys fs, ext2_ino_t ino, int inuse); void ext2fs_inode_alloc_stats2(ext2_filsys fs, ext2_ino_t ino, int inuse, int isdir); void ext2fs_block_alloc_stats(ext2_filsys fs, blk_t blk, int inuse); void ext2fs_block_alloc_stats2(ext2_filsys fs, blk64_t blk, int inuse); void ext2fs_block_alloc_stats_range(ext2_filsys fs, blk64_t blk, blk_t num, int inuse); /* alloc_tables.c */ extern errcode_t ext2fs_allocate_tables(ext2_filsys fs); extern errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group, ext2fs_block_bitmap bmap); /* badblocks.c */ extern errcode_t ext2fs_u32_list_create(ext2_u32_list *ret, int size); extern errcode_t ext2fs_u32_list_add(ext2_u32_list bb, __u32 blk); extern int ext2fs_u32_list_find(ext2_u32_list bb, __u32 blk); extern int ext2fs_u32_list_test(ext2_u32_list bb, blk_t blk); extern errcode_t ext2fs_u32_list_iterate_begin(ext2_u32_list bb, ext2_u32_iterate *ret); extern int ext2fs_u32_list_iterate(ext2_u32_iterate iter, blk_t *blk); extern void ext2fs_u32_list_iterate_end(ext2_u32_iterate iter); extern errcode_t ext2fs_u32_copy(ext2_u32_list src, ext2_u32_list *dest); extern int ext2fs_u32_list_equal(ext2_u32_list bb1, ext2_u32_list bb2); extern errcode_t ext2fs_badblocks_list_create(ext2_badblocks_list *ret, int size); extern errcode_t ext2fs_badblocks_list_add(ext2_badblocks_list bb, blk_t blk); extern int ext2fs_badblocks_list_test(ext2_badblocks_list bb, blk_t blk); extern int ext2fs_u32_list_del(ext2_u32_list bb, __u32 blk); extern void ext2fs_badblocks_list_del(ext2_u32_list bb, __u32 blk); extern errcode_t ext2fs_badblocks_list_iterate_begin(ext2_badblocks_list bb, ext2_badblocks_iterate *ret); extern int ext2fs_badblocks_list_iterate(ext2_badblocks_iterate iter, blk_t *blk); extern void ext2fs_badblocks_list_iterate_end(ext2_badblocks_iterate iter); extern errcode_t ext2fs_badblocks_copy(ext2_badblocks_list src, ext2_badblocks_list *dest); extern int ext2fs_badblocks_equal(ext2_badblocks_list bb1, ext2_badblocks_list bb2); extern int ext2fs_u32_list_count(ext2_u32_list bb); /* bb_compat */ extern errcode_t badblocks_list_create(badblocks_list *ret, int size); extern errcode_t badblocks_list_add(badblocks_list bb, blk_t blk); extern int badblocks_list_test(badblocks_list bb, blk_t blk); extern errcode_t badblocks_list_iterate_begin(badblocks_list bb, badblocks_iterate *ret); extern int badblocks_list_iterate(badblocks_iterate iter, blk_t *blk); extern void badblocks_list_iterate_end(badblocks_iterate iter); extern void badblocks_list_free(badblocks_list bb); /* bb_inode.c */ extern errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list); /* bitmaps.c */ extern void ext2fs_free_block_bitmap(ext2fs_block_bitmap bitmap); extern void ext2fs_free_inode_bitmap(ext2fs_inode_bitmap bitmap); extern errcode_t ext2fs_copy_bitmap(ext2fs_generic_bitmap src, ext2fs_generic_bitmap *dest); extern errcode_t ext2fs_write_inode_bitmap(ext2_filsys fs); extern errcode_t ext2fs_write_block_bitmap (ext2_filsys fs); extern errcode_t ext2fs_read_inode_bitmap (ext2_filsys fs); extern errcode_t ext2fs_read_block_bitmap(ext2_filsys fs); extern errcode_t ext2fs_allocate_block_bitmap(ext2_filsys fs, const char *descr, ext2fs_block_bitmap *ret); extern errcode_t ext2fs_allocate_subcluster_bitmap(ext2_filsys fs, const char *descr, ext2fs_block_bitmap *ret); extern int ext2fs_get_bitmap_granularity(ext2fs_block_bitmap bitmap); extern errcode_t ext2fs_allocate_inode_bitmap(ext2_filsys fs, const char *descr, ext2fs_inode_bitmap *ret); extern errcode_t ext2fs_fudge_inode_bitmap_end(ext2fs_inode_bitmap bitmap, ext2_ino_t end, ext2_ino_t *oend); extern errcode_t ext2fs_fudge_block_bitmap_end(ext2fs_block_bitmap bitmap, blk_t end, blk_t *oend); extern errcode_t ext2fs_fudge_block_bitmap_end2(ext2fs_block_bitmap bitmap, blk64_t end, blk64_t *oend); extern void ext2fs_clear_inode_bitmap(ext2fs_inode_bitmap bitmap); extern void ext2fs_clear_block_bitmap(ext2fs_block_bitmap bitmap); extern errcode_t ext2fs_read_bitmaps(ext2_filsys fs); extern errcode_t ext2fs_write_bitmaps(ext2_filsys fs); extern errcode_t ext2fs_resize_inode_bitmap(__u32 new_end, __u32 new_real_end, ext2fs_inode_bitmap bmap); extern errcode_t ext2fs_resize_inode_bitmap2(__u64 new_end, __u64 new_real_end, ext2fs_inode_bitmap bmap); extern errcode_t ext2fs_resize_block_bitmap(__u32 new_end, __u32 new_real_end, ext2fs_block_bitmap bmap); extern errcode_t ext2fs_resize_block_bitmap2(__u64 new_end, __u64 new_real_end, ext2fs_block_bitmap bmap); extern errcode_t ext2fs_compare_block_bitmap(ext2fs_block_bitmap bm1, ext2fs_block_bitmap bm2); extern errcode_t ext2fs_compare_inode_bitmap(ext2fs_inode_bitmap bm1, ext2fs_inode_bitmap bm2); extern errcode_t ext2fs_set_inode_bitmap_range(ext2fs_inode_bitmap bmap, ext2_ino_t start, unsigned int num, void *in); extern errcode_t ext2fs_set_inode_bitmap_range2(ext2fs_inode_bitmap bmap, __u64 start, size_t num, void *in); extern errcode_t ext2fs_get_inode_bitmap_range(ext2fs_inode_bitmap bmap, ext2_ino_t start, unsigned int num, void *out); extern errcode_t ext2fs_get_inode_bitmap_range2(ext2fs_inode_bitmap bmap, __u64 start, size_t num, void *out); extern errcode_t ext2fs_set_block_bitmap_range(ext2fs_block_bitmap bmap, blk_t start, unsigned int num, void *in); extern errcode_t ext2fs_set_block_bitmap_range2(ext2fs_block_bitmap bmap, blk64_t start, size_t num, void *in); extern errcode_t ext2fs_get_block_bitmap_range(ext2fs_block_bitmap bmap, blk_t start, unsigned int num, void *out); extern errcode_t ext2fs_get_block_bitmap_range2(ext2fs_block_bitmap bmap, blk64_t start, size_t num, void *out); /* blknum.c */ extern __u32 ext2fs_inode_bitmap_checksum(ext2_filsys fs, dgrp_t group); extern __u32 ext2fs_block_bitmap_checksum(ext2_filsys fs, dgrp_t group); extern dgrp_t ext2fs_group_of_blk2(ext2_filsys fs, blk64_t); extern blk64_t ext2fs_group_first_block2(ext2_filsys fs, dgrp_t group); extern blk64_t ext2fs_group_last_block2(ext2_filsys fs, dgrp_t group); extern int ext2fs_group_blocks_count(ext2_filsys fs, dgrp_t group); extern blk64_t ext2fs_inode_data_blocks2(ext2_filsys fs, struct ext2_inode *inode); extern blk64_t ext2fs_inode_i_blocks(ext2_filsys fs, struct ext2_inode *inode); extern blk64_t ext2fs_get_stat_i_blocks(ext2_filsys fs, struct ext2_inode *inode); extern blk64_t ext2fs_blocks_count(struct ext2_super_block *super); extern void ext2fs_blocks_count_set(struct ext2_super_block *super, blk64_t blk); extern void ext2fs_blocks_count_add(struct ext2_super_block *super, blk64_t blk); extern blk64_t ext2fs_r_blocks_count(struct ext2_super_block *super); extern void ext2fs_r_blocks_count_set(struct ext2_super_block *super, blk64_t blk); extern void ext2fs_r_blocks_count_add(struct ext2_super_block *super, blk64_t blk); extern blk64_t ext2fs_free_blocks_count(struct ext2_super_block *super); extern void ext2fs_free_blocks_count_set(struct ext2_super_block *super, blk64_t blk); extern void ext2fs_free_blocks_count_add(struct ext2_super_block *super, blk64_t blk); /* Block group descriptor accessor functions */ extern struct ext2_group_desc *ext2fs_group_desc(ext2_filsys fs, struct opaque_ext2_group_desc *gdp, dgrp_t group); extern blk64_t ext2fs_block_bitmap_csum(ext2_filsys fs, dgrp_t group); extern blk64_t ext2fs_block_bitmap_loc(ext2_filsys fs, dgrp_t group); extern void ext2fs_block_bitmap_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk); extern __u32 ext2fs_inode_bitmap_csum(ext2_filsys fs, dgrp_t group); extern blk64_t ext2fs_inode_bitmap_loc(ext2_filsys fs, dgrp_t group); extern void ext2fs_inode_bitmap_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk); extern blk64_t ext2fs_inode_table_loc(ext2_filsys fs, dgrp_t group); extern void ext2fs_inode_table_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk); extern __u32 ext2fs_bg_free_blocks_count(ext2_filsys fs, dgrp_t group); extern void ext2fs_bg_free_blocks_count_set(ext2_filsys fs, dgrp_t group, __u32 n); extern __u32 ext2fs_bg_free_inodes_count(ext2_filsys fs, dgrp_t group); extern void ext2fs_bg_free_inodes_count_set(ext2_filsys fs, dgrp_t group, __u32 n); extern __u32 ext2fs_bg_used_dirs_count(ext2_filsys fs, dgrp_t group); extern void ext2fs_bg_used_dirs_count_set(ext2_filsys fs, dgrp_t group, __u32 n); extern __u32 ext2fs_bg_itable_unused(ext2_filsys fs, dgrp_t group); extern void ext2fs_bg_itable_unused_set(ext2_filsys fs, dgrp_t group, __u32 n); extern __u16 ext2fs_bg_flags(ext2_filsys fs, dgrp_t group); extern void ext2fs_bg_flags_zap(ext2_filsys fs, dgrp_t group); extern int ext2fs_bg_flags_test(ext2_filsys fs, dgrp_t group, __u16 bg_flag); extern void ext2fs_bg_flags_set(ext2_filsys fs, dgrp_t group, __u16 bg_flags); extern void ext2fs_bg_flags_clear(ext2_filsys fs, dgrp_t group, __u16 bg_flags); extern __u16 ext2fs_bg_checksum(ext2_filsys fs, dgrp_t group); extern void ext2fs_bg_checksum_set(ext2_filsys fs, dgrp_t group, __u16 checksum); extern blk64_t ext2fs_file_acl_block(ext2_filsys fs, const struct ext2_inode *inode); extern void ext2fs_file_acl_block_set(ext2_filsys fs, struct ext2_inode *inode, blk64_t blk); extern errcode_t ext2fs_inode_size_set(ext2_filsys fs, struct ext2_inode *inode, ext2_off64_t size); /* block.c */ extern errcode_t ext2fs_block_iterate(ext2_filsys fs, ext2_ino_t ino, int flags, char *block_buf, int (*func)(ext2_filsys fs, blk_t *blocknr, int blockcnt, void *priv_data), void *priv_data); errcode_t ext2fs_block_iterate2(ext2_filsys fs, ext2_ino_t ino, int flags, char *block_buf, int (*func)(ext2_filsys fs, blk_t *blocknr, e2_blkcnt_t blockcnt, blk_t ref_blk, int ref_offset, void *priv_data), void *priv_data); errcode_t ext2fs_block_iterate3(ext2_filsys fs, ext2_ino_t ino, int flags, char *block_buf, int (*func)(ext2_filsys fs, blk64_t *blocknr, e2_blkcnt_t blockcnt, blk64_t ref_blk, int ref_offset, void *priv_data), void *priv_data); /* bmap.c */ extern errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode, char *block_buf, int bmap_flags, blk_t block, blk_t *phys_blk); extern errcode_t ext2fs_bmap2(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode, char *block_buf, int bmap_flags, blk64_t block, int *ret_flags, blk64_t *phys_blk); errcode_t ext2fs_map_cluster_block(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode, blk64_t lblk, blk64_t *pblk); #if 0 /* bmove.c */ extern errcode_t ext2fs_move_blocks(ext2_filsys fs, ext2fs_block_bitmap reserve, ext2fs_block_bitmap alloc_map, int flags); #endif /* check_desc.c */ extern errcode_t ext2fs_check_desc(ext2_filsys fs); /* closefs.c */ extern errcode_t ext2fs_close(ext2_filsys fs); extern errcode_t ext2fs_close2(ext2_filsys fs, int flags); extern errcode_t ext2fs_close_free(ext2_filsys *fs); extern errcode_t ext2fs_flush(ext2_filsys fs); extern errcode_t ext2fs_flush2(ext2_filsys fs, int flags); extern int ext2fs_bg_has_super(ext2_filsys fs, dgrp_t group_block); extern errcode_t ext2fs_super_and_bgd_loc2(ext2_filsys fs, dgrp_t group, blk64_t *ret_super_blk, blk64_t *ret_old_desc_blk, blk64_t *ret_new_desc_blk, blk_t *ret_used_blks); extern int ext2fs_super_and_bgd_loc(ext2_filsys fs, dgrp_t group, blk_t *ret_super_blk, blk_t *ret_old_desc_blk, blk_t *ret_new_desc_blk, int *ret_meta_bg); extern void ext2fs_update_dynamic_rev(ext2_filsys fs); /* crc32c.c */ extern __u32 ext2fs_crc32_be(__u32 crc, unsigned char const *p, size_t len); extern __u32 ext2fs_crc32c_le(__u32 crc, unsigned char const *p, size_t len); /* csum.c */ extern void ext2fs_init_csum_seed(ext2_filsys fs); extern errcode_t ext2fs_mmp_csum_set(ext2_filsys fs, struct mmp_struct *mmp); extern int ext2fs_mmp_csum_verify(ext2_filsys, struct mmp_struct *mmp); extern int ext2fs_verify_csum_type(ext2_filsys fs, struct ext2_super_block *sb); extern errcode_t ext2fs_superblock_csum_set(ext2_filsys fs, struct ext2_super_block *sb); extern int ext2fs_superblock_csum_verify(ext2_filsys fs, struct ext2_super_block *sb); extern errcode_t ext2fs_ext_attr_block_csum_set(ext2_filsys fs, ext2_ino_t inum, blk64_t block, struct ext2_ext_attr_header *hdr); extern int ext2fs_ext_attr_block_csum_verify(ext2_filsys fs, ext2_ino_t inum, blk64_t block, struct ext2_ext_attr_header *hdr); #define EXT2_DIRENT_TAIL(block, blocksize) \ ((struct ext2_dir_entry_tail *)(((char *)(block)) + \ (blocksize) - sizeof(struct ext2_dir_entry_tail))) extern void ext2fs_initialize_dirent_tail(ext2_filsys fs, struct ext2_dir_entry_tail *t); extern int ext2fs_dirent_has_tail(ext2_filsys fs, struct ext2_dir_entry *dirent); extern int ext2fs_dirent_csum_verify(ext2_filsys fs, ext2_ino_t inum, struct ext2_dir_entry *dirent); extern int ext2fs_dir_block_csum_verify(ext2_filsys fs, ext2_ino_t inum, struct ext2_dir_entry *dirent); extern errcode_t ext2fs_dir_block_csum_set(ext2_filsys fs, ext2_ino_t inum, struct ext2_dir_entry *dirent); extern errcode_t ext2fs_get_dx_countlimit(ext2_filsys fs, struct ext2_dir_entry *dirent, struct ext2_dx_countlimit **cc, int *offset); extern errcode_t ext2fs_extent_block_csum_set(ext2_filsys fs, ext2_ino_t inum, struct ext3_extent_header *eh); extern int ext2fs_extent_block_csum_verify(ext2_filsys fs, ext2_ino_t inum, struct ext3_extent_header *eh); extern errcode_t ext2fs_block_bitmap_csum_set(ext2_filsys fs, dgrp_t group, char *bitmap, int size); extern int ext2fs_block_bitmap_csum_verify(ext2_filsys fs, dgrp_t group, char *bitmap, int size); extern errcode_t ext2fs_inode_bitmap_csum_set(ext2_filsys fs, dgrp_t group, char *bitmap, int size); extern int ext2fs_inode_bitmap_csum_verify(ext2_filsys fs, dgrp_t group, char *bitmap, int size); extern errcode_t ext2fs_inode_csum_set(ext2_filsys fs, ext2_ino_t inum, struct ext2_inode_large *inode); extern int ext2fs_inode_csum_verify(ext2_filsys fs, ext2_ino_t inum, struct ext2_inode_large *inode); extern void ext2fs_group_desc_csum_set(ext2_filsys fs, dgrp_t group); extern int ext2fs_group_desc_csum_verify(ext2_filsys fs, dgrp_t group); extern errcode_t ext2fs_set_gdt_csum(ext2_filsys fs); extern __u16 ext2fs_group_desc_csum(ext2_filsys fs, dgrp_t group); /* dblist.c */ extern errcode_t ext2fs_init_dblist(ext2_filsys fs, ext2_dblist *ret_dblist); extern errcode_t ext2fs_add_dir_block(ext2_dblist dblist, ext2_ino_t ino, blk_t blk, int blockcnt); extern errcode_t ext2fs_add_dir_block2(ext2_dblist dblist, ext2_ino_t ino, blk64_t blk, e2_blkcnt_t blockcnt); extern void ext2fs_dblist_sort(ext2_dblist dblist, EXT2_QSORT_TYPE (*sortfunc)(const void *, const void *)); extern void ext2fs_dblist_sort2(ext2_dblist dblist, EXT2_QSORT_TYPE (*sortfunc)(const void *, const void *)); extern errcode_t ext2fs_dblist_iterate(ext2_dblist dblist, int (*func)(ext2_filsys fs, struct ext2_db_entry *db_info, void *priv_data), void *priv_data); extern errcode_t ext2fs_dblist_iterate2(ext2_dblist dblist, int (*func)(ext2_filsys fs, struct ext2_db_entry2 *db_info, void *priv_data), void *priv_data); extern errcode_t ext2fs_dblist_iterate3(ext2_dblist dblist, int (*func)(ext2_filsys fs, struct ext2_db_entry2 *db_info, void *priv_data), unsigned long long start, unsigned long long count, void *priv_data); extern errcode_t ext2fs_set_dir_block(ext2_dblist dblist, ext2_ino_t ino, blk_t blk, int blockcnt); extern errcode_t ext2fs_set_dir_block2(ext2_dblist dblist, ext2_ino_t ino, blk64_t blk, e2_blkcnt_t blockcnt); extern errcode_t ext2fs_copy_dblist(ext2_dblist src, ext2_dblist *dest); extern int ext2fs_dblist_count(ext2_dblist dblist); extern blk64_t ext2fs_dblist_count2(ext2_dblist dblist); extern errcode_t ext2fs_dblist_get_last(ext2_dblist dblist, struct ext2_db_entry **entry); extern errcode_t ext2fs_dblist_get_last2(ext2_dblist dblist, struct ext2_db_entry2 **entry); extern errcode_t ext2fs_dblist_drop_last(ext2_dblist dblist); /* dblist_dir.c */ extern errcode_t ext2fs_dblist_dir_iterate(ext2_dblist dblist, int flags, char *block_buf, int (*func)(ext2_ino_t dir, int entry, struct ext2_dir_entry *dirent, int offset, int blocksize, char *buf, void *priv_data), void *priv_data); #if 0 /* digest_encode.c */ #define EXT2FS_DIGEST_SIZE EXT2FS_SHA256_LENGTH extern int ext2fs_digest_encode(const char *src, int len, char *dst); extern int ext2fs_digest_decode(const char *src, int len, char *dst); #endif /* dirblock.c */ extern errcode_t ext2fs_read_dir_block(ext2_filsys fs, blk_t block, void *buf); extern errcode_t ext2fs_read_dir_block2(ext2_filsys fs, blk_t block, void *buf, int flags); extern errcode_t ext2fs_read_dir_block3(ext2_filsys fs, blk64_t block, void *buf, int flags); extern errcode_t ext2fs_read_dir_block4(ext2_filsys fs, blk64_t block, void *buf, int flags, ext2_ino_t ino); extern errcode_t ext2fs_write_dir_block(ext2_filsys fs, blk_t block, void *buf); extern errcode_t ext2fs_write_dir_block2(ext2_filsys fs, blk_t block, void *buf, int flags); extern errcode_t ext2fs_write_dir_block3(ext2_filsys fs, blk64_t block, void *buf, int flags); extern errcode_t ext2fs_write_dir_block4(ext2_filsys fs, blk64_t block, void *buf, int flags, ext2_ino_t ino); /* dirhash.c */ extern errcode_t ext2fs_dirhash(int version, const char *name, int len, const __u32 *seed, ext2_dirhash_t *ret_hash, ext2_dirhash_t *ret_minor_hash); extern errcode_t ext2fs_dirhash2(int version, const char *name, int len, const struct ext2fs_nls_table *charset, int hash_flags, const __u32 *seed, ext2_dirhash_t *ret_hash, ext2_dirhash_t *ret_minor_hash); /* dir_iterate.c */ extern errcode_t ext2fs_get_rec_len(ext2_filsys fs, struct ext2_dir_entry *dirent, unsigned int *rec_len); extern errcode_t ext2fs_set_rec_len(ext2_filsys fs, unsigned int len, struct ext2_dir_entry *dirent); extern errcode_t ext2fs_dir_iterate(ext2_filsys fs, ext2_ino_t dir, int flags, char *block_buf, int (*func)(struct ext2_dir_entry *dirent, int offset, int blocksize, char *buf, void *priv_data), void *priv_data); extern errcode_t ext2fs_dir_iterate2(ext2_filsys fs, ext2_ino_t dir, int flags, char *block_buf, int (*func)(ext2_ino_t dir, int entry, struct ext2_dir_entry *dirent, int offset, int blocksize, char *buf, void *priv_data), void *priv_data); /* dupfs.c */ extern errcode_t ext2fs_dup_handle(ext2_filsys src, ext2_filsys *dest); /* expanddir.c */ extern errcode_t ext2fs_expand_dir(ext2_filsys fs, ext2_ino_t dir); /* ext_attr.c */ extern __u32 ext2fs_ext_attr_hash_entry(struct ext2_ext_attr_entry *entry, void *data); extern errcode_t ext2fs_ext_attr_hash_entry2(ext2_filsys fs, struct ext2_ext_attr_entry *entry, void *data, __u32 *hash); extern errcode_t ext2fs_read_ext_attr(ext2_filsys fs, blk_t block, void *buf); extern errcode_t ext2fs_read_ext_attr2(ext2_filsys fs, blk64_t block, void *buf); extern errcode_t ext2fs_read_ext_attr3(ext2_filsys fs, blk64_t block, void *buf, ext2_ino_t inum); extern errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block, void *buf); extern errcode_t ext2fs_write_ext_attr2(ext2_filsys fs, blk64_t block, void *buf); extern errcode_t ext2fs_write_ext_attr3(ext2_filsys fs, blk64_t block, void *buf, ext2_ino_t inum); extern errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk, char *block_buf, int adjust, __u32 *newcount); extern errcode_t ext2fs_adjust_ea_refcount2(ext2_filsys fs, blk64_t blk, char *block_buf, int adjust, __u32 *newcount); extern errcode_t ext2fs_adjust_ea_refcount3(ext2_filsys fs, blk64_t blk, char *block_buf, int adjust, __u32 *newcount, ext2_ino_t inum); errcode_t ext2fs_xattrs_write(struct ext2_xattr_handle *handle); errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle); errcode_t ext2fs_xattrs_iterate(struct ext2_xattr_handle *h, int (*func)(char *name, char *value, size_t value_len, void *data), void *data); errcode_t ext2fs_xattr_get(struct ext2_xattr_handle *h, const char *key, void **value, size_t *value_len); errcode_t ext2fs_xattr_set(struct ext2_xattr_handle *handle, const char *key, const void *value, size_t value_len); errcode_t ext2fs_xattr_remove(struct ext2_xattr_handle *handle, const char *key); errcode_t ext2fs_xattrs_open(ext2_filsys fs, ext2_ino_t ino, struct ext2_xattr_handle **handle); errcode_t ext2fs_xattrs_close(struct ext2_xattr_handle **handle); errcode_t ext2fs_free_ext_attr(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode_large *inode); errcode_t ext2fs_xattrs_count(struct ext2_xattr_handle *handle, size_t *count); errcode_t ext2fs_xattr_inode_max_size(ext2_filsys fs, ext2_ino_t ino, size_t *size); #define XATTR_HANDLE_FLAG_RAW 0x0001 errcode_t ext2fs_xattrs_flags(struct ext2_xattr_handle *handle, unsigned int *new_flags, unsigned int *old_flags); extern void ext2fs_ext_attr_block_rehash(struct ext2_ext_attr_header *header, struct ext2_ext_attr_entry *end); extern __u32 ext2fs_get_ea_inode_hash(struct ext2_inode *inode); extern void ext2fs_set_ea_inode_hash(struct ext2_inode *inode, __u32 hash); extern __u64 ext2fs_get_ea_inode_ref(struct ext2_inode *inode); extern void ext2fs_set_ea_inode_ref(struct ext2_inode *inode, __u64 ref_count); /* extent.c */ extern errcode_t ext2fs_extent_header_verify(void *ptr, int size); extern errcode_t ext2fs_extent_open(ext2_filsys fs, ext2_ino_t ino, ext2_extent_handle_t *handle); extern errcode_t ext2fs_extent_open2(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode, ext2_extent_handle_t *ret_handle); extern void ext2fs_extent_free(ext2_extent_handle_t handle); extern errcode_t ext2fs_extent_get(ext2_extent_handle_t handle, int flags, struct ext2fs_extent *extent); extern errcode_t ext2fs_extent_node_split(ext2_extent_handle_t handle); extern errcode_t ext2fs_extent_replace(ext2_extent_handle_t handle, int flags, struct ext2fs_extent *extent); extern errcode_t ext2fs_extent_insert(ext2_extent_handle_t handle, int flags, struct ext2fs_extent *extent); extern errcode_t ext2fs_extent_set_bmap(ext2_extent_handle_t handle, blk64_t logical, blk64_t physical, int flags); extern errcode_t ext2fs_extent_delete(ext2_extent_handle_t handle, int flags); extern errcode_t ext2fs_extent_get_info(ext2_extent_handle_t handle, struct ext2_extent_info *info); extern errcode_t ext2fs_extent_goto(ext2_extent_handle_t handle, blk64_t blk); extern errcode_t ext2fs_extent_goto2(ext2_extent_handle_t handle, int leaf_level, blk64_t blk); extern errcode_t ext2fs_extent_fix_parents(ext2_extent_handle_t handle); extern size_t ext2fs_max_extent_depth(ext2_extent_handle_t handle); extern errcode_t ext2fs_fix_extents_checksums(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode); /* fallocate.c */ #define EXT2_FALLOCATE_ZERO_BLOCKS (0x1) #define EXT2_FALLOCATE_FORCE_INIT (0x2) #define EXT2_FALLOCATE_FORCE_UNINIT (0x4) #define EXT2_FALLOCATE_INIT_BEYOND_EOF (0x8) #define EXT2_FALLOCATE_ALL_FLAGS (0xF) errcode_t ext2fs_fallocate(ext2_filsys fs, int flags, ext2_ino_t ino, struct ext2_inode *inode, blk64_t goal, blk64_t start, blk64_t len); /* fileio.c */ extern errcode_t ext2fs_file_open2(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode, int flags, ext2_file_t *ret); extern errcode_t ext2fs_file_open(ext2_filsys fs, ext2_ino_t ino, int flags, ext2_file_t *ret); extern ext2_filsys ext2fs_file_get_fs(ext2_file_t file); struct ext2_inode *ext2fs_file_get_inode(ext2_file_t file); extern ext2_ino_t ext2fs_file_get_inode_num(ext2_file_t file); extern errcode_t ext2fs_file_close(ext2_file_t file); extern errcode_t ext2fs_file_flush(ext2_file_t file); extern errcode_t ext2fs_file_read(ext2_file_t file, void *buf, unsigned int wanted, unsigned int *got); extern errcode_t ext2fs_file_write(ext2_file_t file, const void *buf, unsigned int nbytes, unsigned int *written); extern errcode_t ext2fs_file_llseek(ext2_file_t file, __u64 offset, int whence, __u64 *ret_pos); extern errcode_t ext2fs_file_lseek(ext2_file_t file, ext2_off_t offset, int whence, ext2_off_t *ret_pos); errcode_t ext2fs_file_get_lsize(ext2_file_t file, __u64 *ret_size); extern ext2_off_t ext2fs_file_get_size(ext2_file_t file); extern errcode_t ext2fs_file_set_size(ext2_file_t file, ext2_off_t size); extern errcode_t ext2fs_file_set_size2(ext2_file_t file, ext2_off64_t size); /* finddev.c */ extern char *ext2fs_find_block_device(dev_t device); /* flushb.c */ extern errcode_t ext2fs_sync_device(int fd, int flushb); /* freefs.c */ extern void ext2fs_free(ext2_filsys fs); extern void ext2fs_free_dblist(ext2_dblist dblist); extern void ext2fs_badblocks_list_free(ext2_badblocks_list bb); extern void ext2fs_u32_list_free(ext2_u32_list bb); /* gen_bitmap.c */ extern void ext2fs_free_generic_bitmap(ext2fs_inode_bitmap bitmap); extern errcode_t ext2fs_make_generic_bitmap(errcode_t magic, ext2_filsys fs, __u32 start, __u32 end, __u32 real_end, const char *descr, char *init_map, ext2fs_generic_bitmap *ret); extern errcode_t ext2fs_allocate_generic_bitmap(__u32 start, __u32 end, __u32 real_end, const char *descr, ext2fs_generic_bitmap *ret); extern errcode_t ext2fs_copy_generic_bitmap(ext2fs_generic_bitmap src, ext2fs_generic_bitmap *dest); extern void ext2fs_clear_generic_bitmap(ext2fs_generic_bitmap bitmap); extern errcode_t ext2fs_fudge_generic_bitmap_end(ext2fs_inode_bitmap bitmap, errcode_t magic, errcode_t neq, ext2_ino_t end, ext2_ino_t *oend); extern void ext2fs_set_generic_bitmap_padding(ext2fs_generic_bitmap map); extern errcode_t ext2fs_resize_generic_bitmap(errcode_t magic, __u32 new_end, __u32 new_real_end, ext2fs_generic_bitmap bmap); extern errcode_t ext2fs_compare_generic_bitmap(errcode_t magic, errcode_t neq, ext2fs_generic_bitmap bm1, ext2fs_generic_bitmap bm2); extern errcode_t ext2fs_get_generic_bitmap_range(ext2fs_generic_bitmap bmap, errcode_t magic, __u32 start, __u32 num, void *out); extern errcode_t ext2fs_set_generic_bitmap_range(ext2fs_generic_bitmap bmap, errcode_t magic, __u32 start, __u32 num, void *in); extern errcode_t ext2fs_find_first_zero_generic_bitmap(ext2fs_generic_bitmap bitmap, __u32 start, __u32 end, __u32 *out); extern errcode_t ext2fs_find_first_set_generic_bitmap(ext2fs_generic_bitmap bitmap, __u32 start, __u32 end, __u32 *out); /* gen_bitmap64.c */ void ext2fs_free_generic_bmap(ext2fs_generic_bitmap bmap); errcode_t ext2fs_alloc_generic_bmap(ext2_filsys fs, errcode_t magic, int type, __u64 start, __u64 end, __u64 real_end, const char *descr, ext2fs_generic_bitmap *ret); errcode_t ext2fs_copy_generic_bmap(ext2fs_generic_bitmap src, ext2fs_generic_bitmap *dest); void ext2fs_clear_generic_bmap(ext2fs_generic_bitmap bitmap); errcode_t ext2fs_fudge_generic_bmap_end(ext2fs_generic_bitmap bitmap, errcode_t neq, __u64 end, __u64 *oend); void ext2fs_set_generic_bmap_padding(ext2fs_generic_bitmap bmap); errcode_t ext2fs_resize_generic_bmap(ext2fs_generic_bitmap bmap, __u64 new_end, __u64 new_real_end); errcode_t ext2fs_compare_generic_bmap(errcode_t neq, ext2fs_generic_bitmap bm1, ext2fs_generic_bitmap bm2); errcode_t ext2fs_get_generic_bmap_range(ext2fs_generic_bitmap bmap, __u64 start, unsigned int num, void *out); errcode_t ext2fs_set_generic_bmap_range(ext2fs_generic_bitmap bmap, __u64 start, unsigned int num, void *in); errcode_t ext2fs_convert_subcluster_bitmap(ext2_filsys fs, ext2fs_block_bitmap *bitmap); /* get_num_dirs.c */ extern errcode_t ext2fs_get_num_dirs(ext2_filsys fs, ext2_ino_t *ret_num_dirs); /* getsize.c */ extern errcode_t ext2fs_get_device_size(const char *file, int blocksize, blk_t *retblocks); extern errcode_t ext2fs_get_device_size2(const char *file, int blocksize, blk64_t *retblocks); /* getsectsize.c */ extern int ext2fs_get_dio_alignment(int fd); errcode_t ext2fs_get_device_sectsize(const char *file, int *sectsize); errcode_t ext2fs_get_device_phys_sectsize(const char *file, int *sectsize); /* i_block.c */ errcode_t ext2fs_iblk_add_blocks(ext2_filsys fs, struct ext2_inode *inode, blk64_t num_blocks); errcode_t ext2fs_iblk_sub_blocks(ext2_filsys fs, struct ext2_inode *inode, blk64_t num_blocks); errcode_t ext2fs_iblk_set(ext2_filsys fs, struct ext2_inode *inode, blk64_t b); /* imager.c */ extern errcode_t ext2fs_image_inode_write(ext2_filsys fs, int fd, int flags); extern errcode_t ext2fs_image_inode_read(ext2_filsys fs, int fd, int flags); extern errcode_t ext2fs_image_super_write(ext2_filsys fs, int fd, int flags); extern errcode_t ext2fs_image_super_read(ext2_filsys fs, int fd, int flags); extern errcode_t ext2fs_image_bitmap_write(ext2_filsys fs, int fd, int flags); extern errcode_t ext2fs_image_bitmap_read(ext2_filsys fs, int fd, int flags); /* ind_block.c */ errcode_t ext2fs_read_ind_block(ext2_filsys fs, blk_t blk, void *buf); errcode_t ext2fs_write_ind_block(ext2_filsys fs, blk_t blk, void *buf); /* initialize.c */ extern errcode_t ext2fs_initialize(const char *name, int flags, struct ext2_super_block *param, io_manager manager, ext2_filsys *ret_fs); /* icount.c */ extern void ext2fs_free_icount(ext2_icount_t icount); extern errcode_t ext2fs_create_icount_tdb(ext2_filsys fs, char *tdb_dir, int flags, ext2_icount_t *ret); extern errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags, unsigned int size, ext2_icount_t hint, ext2_icount_t *ret); extern errcode_t ext2fs_create_icount(ext2_filsys fs, int flags, unsigned int size, ext2_icount_t *ret); extern errcode_t ext2fs_icount_fetch(ext2_icount_t icount, ext2_ino_t ino, __u16 *ret); extern errcode_t ext2fs_icount_increment(ext2_icount_t icount, ext2_ino_t ino, __u16 *ret); extern errcode_t ext2fs_icount_decrement(ext2_icount_t icount, ext2_ino_t ino, __u16 *ret); extern errcode_t ext2fs_icount_store(ext2_icount_t icount, ext2_ino_t ino, __u16 count); extern ext2_ino_t ext2fs_get_icount_size(ext2_icount_t icount); errcode_t ext2fs_icount_validate(ext2_icount_t icount, FILE *); /* inline.c */ extern errcode_t ext2fs_get_memalign(unsigned long size, unsigned long align, void *ptr); /* inline_data.c */ extern errcode_t ext2fs_inline_data_init(ext2_filsys fs, ext2_ino_t ino); extern errcode_t ext2fs_inline_data_size(ext2_filsys fs, ext2_ino_t ino, size_t *size); extern errcode_t ext2fs_inline_data_get(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode, void *buf, size_t *size); extern errcode_t ext2fs_inline_data_set(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode, void *buf, size_t size); /* inode.c */ extern errcode_t ext2fs_create_inode_cache(ext2_filsys fs, unsigned int cache_size); extern void ext2fs_free_inode_cache(struct ext2_inode_cache *icache); extern errcode_t ext2fs_flush_icache(ext2_filsys fs); extern errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, ext2_ino_t *ino, struct ext2_inode *inode, int bufsize); #define EXT2_INODE_SCAN_DEFAULT_BUFFER_BLOCKS 8 extern errcode_t ext2fs_open_inode_scan(ext2_filsys fs, int buffer_blocks, ext2_inode_scan *ret_scan); extern void ext2fs_close_inode_scan(ext2_inode_scan scan); extern errcode_t ext2fs_get_next_inode(ext2_inode_scan scan, ext2_ino_t *ino, struct ext2_inode *inode); extern errcode_t ext2fs_inode_scan_goto_blockgroup(ext2_inode_scan scan, int group); extern void ext2fs_set_inode_callback (ext2_inode_scan scan, errcode_t (*done_group)(ext2_filsys fs, ext2_inode_scan scan, dgrp_t group, void * priv_data), void *done_group_data); extern int ext2fs_inode_scan_flags(ext2_inode_scan scan, int set_flags, int clear_flags); extern errcode_t ext2fs_read_inode_full(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode * inode, int bufsize); extern errcode_t ext2fs_read_inode(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode * inode); extern errcode_t ext2fs_read_inode2(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode * inode, int bufsize, int flags); extern errcode_t ext2fs_write_inode_full(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode * inode, int bufsize); extern errcode_t ext2fs_write_inode(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode * inode); extern errcode_t ext2fs_write_inode2(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode * inode, int bufsize, int flags); extern errcode_t ext2fs_write_new_inode(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode * inode); extern errcode_t ext2fs_get_blocks(ext2_filsys fs, ext2_ino_t ino, blk_t *blocks); extern errcode_t ext2fs_check_directory(ext2_filsys fs, ext2_ino_t ino); /* inode_io.c */ extern io_manager inode_io_manager; extern errcode_t ext2fs_inode_io_intern(ext2_filsys fs, ext2_ino_t ino, char **name); extern errcode_t ext2fs_inode_io_intern2(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode, char **name); /* ismounted.c */ extern errcode_t ext2fs_check_if_mounted(const char *file, int *mount_flags); extern errcode_t ext2fs_check_mount_point(const char *device, int *mount_flags, char *mtpt, int mtlen); /* punch.c */ /* * NOTE: This function removes from an inode the blocks "start", "end", and * every block in between. */ extern errcode_t ext2fs_punch(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode, char *block_buf, blk64_t start, blk64_t end); /* namei.c */ extern errcode_t ext2fs_lookup(ext2_filsys fs, ext2_ino_t dir, const char *name, int namelen, char *buf, ext2_ino_t *inode); extern errcode_t ext2fs_namei(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd, const char *name, ext2_ino_t *inode); errcode_t ext2fs_namei_follow(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd, const char *name, ext2_ino_t *inode); extern errcode_t ext2fs_follow_link(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd, ext2_ino_t inode, ext2_ino_t *res_inode); /* native.c */ int ext2fs_native_flag(void); /* newdir.c */ extern errcode_t ext2fs_new_dir_block(ext2_filsys fs, ext2_ino_t dir_ino, ext2_ino_t parent_ino, char **block); extern errcode_t ext2fs_new_dir_inline_data(ext2_filsys fs, ext2_ino_t dir_ino, ext2_ino_t parent_ino, __u32 *iblock); /* nls_utf8.c */ extern const struct ext2fs_nls_table *ext2fs_load_nls_table(int encoding); /* mkdir.c */ extern errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum, const char *name); /* mkjournal.c */ extern errcode_t ext2fs_zero_blocks(ext2_filsys fs, blk_t blk, int num, blk_t *ret_blk, int *ret_count); extern errcode_t ext2fs_zero_blocks2(ext2_filsys fs, blk64_t blk, int num, blk64_t *ret_blk, int *ret_count); extern errcode_t ext2fs_create_journal_superblock(ext2_filsys fs, __u32 num_blocks, int flags, char **ret_jsb); extern errcode_t ext2fs_add_journal_device(ext2_filsys fs, ext2_filsys journal_dev); extern errcode_t ext2fs_add_journal_inode(ext2_filsys fs, blk_t num_blocks, int flags); extern errcode_t ext2fs_add_journal_inode2(ext2_filsys fs, blk_t num_blocks, blk64_t goal, int flags); extern int ext2fs_default_journal_size(__u64 num_blocks); extern int ext2fs_journal_sb_start(int blocksize); /* openfs.c */ extern errcode_t ext2fs_open(const char *name, int flags, int superblock, unsigned int block_size, io_manager manager, ext2_filsys *ret_fs); extern errcode_t ext2fs_open2(const char *name, const char *io_options, int flags, int superblock, unsigned int block_size, io_manager manager, ext2_filsys *ret_fs); /* * The dgrp_t argument to these two functions is not actually a group number * but a block number offset within a group table! Convert with the formula * (group_number / groups_per_block). */ extern blk64_t ext2fs_descriptor_block_loc2(ext2_filsys fs, blk64_t group_block, dgrp_t i); extern blk_t ext2fs_descriptor_block_loc(ext2_filsys fs, blk_t group_block, dgrp_t i); errcode_t ext2fs_get_data_io(ext2_filsys fs, io_channel *old_io); errcode_t ext2fs_set_data_io(ext2_filsys fs, io_channel new_io); errcode_t ext2fs_rewrite_to_io(ext2_filsys fs, io_channel new_io); /* get_pathname.c */ extern errcode_t ext2fs_get_pathname(ext2_filsys fs, ext2_ino_t dir, ext2_ino_t ino, char **name); /* link.c */ errcode_t ext2fs_link(ext2_filsys fs, ext2_ino_t dir, const char *name, ext2_ino_t ino, int flags); errcode_t ext2fs_unlink(ext2_filsys fs, ext2_ino_t dir, const char *name, ext2_ino_t ino, int flags); /* symlink.c */ errcode_t ext2fs_symlink(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t ino, const char *name, const char *target); int ext2fs_is_fast_symlink(struct ext2_inode *inode); /* mmp.c */ errcode_t ext2fs_mmp_read(ext2_filsys fs, blk64_t mmp_blk, void *buf); errcode_t ext2fs_mmp_write(ext2_filsys fs, blk64_t mmp_blk, void *buf); errcode_t ext2fs_mmp_clear(ext2_filsys fs); errcode_t ext2fs_mmp_init(ext2_filsys fs); errcode_t ext2fs_mmp_start(ext2_filsys fs); errcode_t ext2fs_mmp_update(ext2_filsys fs); errcode_t ext2fs_mmp_update2(ext2_filsys fs, int immediately); errcode_t ext2fs_mmp_stop(ext2_filsys fs); unsigned ext2fs_mmp_new_seq(void); /* read_bb.c */ extern errcode_t ext2fs_read_bb_inode(ext2_filsys fs, ext2_badblocks_list *bb_list); /* read_bb_file.c */ extern errcode_t ext2fs_read_bb_FILE2(ext2_filsys fs, FILE *f, ext2_badblocks_list *bb_list, void *priv_data, void (*invalid)(ext2_filsys fs, blk_t blk, char *badstr, void *priv_data)); extern errcode_t ext2fs_read_bb_FILE(ext2_filsys fs, FILE *f, ext2_badblocks_list *bb_list, void (*invalid)(ext2_filsys fs, blk_t blk)); /* res_gdt.c */ extern errcode_t ext2fs_create_resize_inode(ext2_filsys fs); /*sha256.c */ #define EXT2FS_SHA256_LENGTH 32 #if 0 extern void ext2fs_sha256(const unsigned char *in, unsigned long in_size, unsigned char out[EXT2FS_SHA256_LENGTH]); #endif /* sha512.c */ #define EXT2FS_SHA512_LENGTH 64 extern void ext2fs_sha512(const unsigned char *in, unsigned long in_size, unsigned char out[EXT2FS_SHA512_LENGTH]); /* swapfs.c */ extern errcode_t ext2fs_dirent_swab_in2(ext2_filsys fs, char *buf, size_t size, int flags); extern errcode_t ext2fs_dirent_swab_in(ext2_filsys fs, char *buf, int flags); extern errcode_t ext2fs_dirent_swab_out2(ext2_filsys fs, char *buf, size_t size, int flags); extern errcode_t ext2fs_dirent_swab_out(ext2_filsys fs, char *buf, int flags); extern void ext2fs_swap_ext_attr(char *to, char *from, int bufsize, int has_header); extern void ext2fs_swap_ext_attr_header(struct ext2_ext_attr_header *to_header, struct ext2_ext_attr_header *from_hdr); extern void ext2fs_swap_ext_attr_entry(struct ext2_ext_attr_entry *to_entry, struct ext2_ext_attr_entry *from_entry); extern void ext2fs_swap_super(struct ext2_super_block * super); extern void ext2fs_swap_group_desc(struct ext2_group_desc *gdp); extern void ext2fs_swap_group_desc2(ext2_filsys, struct ext2_group_desc *gdp); extern void ext2fs_swap_inode_full(ext2_filsys fs, struct ext2_inode_large *t, struct ext2_inode_large *f, int hostorder, int bufsize); extern void ext2fs_swap_inode(ext2_filsys fs,struct ext2_inode *t, struct ext2_inode *f, int hostorder); extern void ext2fs_swap_mmp(struct mmp_struct *mmp); /* unix_io.c */ extern int ext2fs_open_file(const char *pathname, int flags, mode_t mode); extern int ext2fs_stat(const char *path, ext2fs_struct_stat *buf); extern int ext2fs_fstat(int fd, ext2fs_struct_stat *buf); /* valid_blk.c */ extern int ext2fs_inode_has_valid_blocks(struct ext2_inode *inode); extern int ext2fs_inode_has_valid_blocks2(ext2_filsys fs, struct ext2_inode *inode); /* version.c */ extern int ext2fs_parse_version_string(const char *ver_string); extern int ext2fs_get_library_version(const char **ver_string, const char **date_string); /* write_bb_file.c */ extern errcode_t ext2fs_write_bb_FILE(ext2_badblocks_list bb_list, unsigned int flags, FILE *f); /* inline functions */ #ifdef NO_INLINE_FUNCS extern errcode_t ext2fs_get_mem(unsigned long size, void *ptr); extern errcode_t ext2fs_get_memzero(unsigned long size, void *ptr); extern errcode_t ext2fs_get_array(unsigned long count, unsigned long size, void *ptr); extern errcode_t ext2fs_get_arrayzero(unsigned long count, unsigned long size, void *ptr); extern errcode_t ext2fs_free_mem(void *ptr); extern errcode_t ext2fs_resize_mem(unsigned long old_size, unsigned long size, void *ptr); extern errcode_t ext2fs_resize_array(unsigned long old_count, unsigned long count, unsigned long size, void *ptr); extern void ext2fs_mark_super_dirty(ext2_filsys fs); extern void ext2fs_mark_changed(ext2_filsys fs); extern int ext2fs_test_changed(ext2_filsys fs); extern void ext2fs_mark_valid(ext2_filsys fs); extern void ext2fs_unmark_valid(ext2_filsys fs); extern int ext2fs_test_valid(ext2_filsys fs); extern void ext2fs_mark_ib_dirty(ext2_filsys fs); extern void ext2fs_mark_bb_dirty(ext2_filsys fs); extern int ext2fs_test_ib_dirty(ext2_filsys fs); extern int ext2fs_test_bb_dirty(ext2_filsys fs); extern dgrp_t ext2fs_group_of_blk(ext2_filsys fs, blk_t blk); extern dgrp_t ext2fs_group_of_ino(ext2_filsys fs, ext2_ino_t ino); extern blk_t ext2fs_group_first_block(ext2_filsys fs, dgrp_t group); extern blk_t ext2fs_group_last_block(ext2_filsys fs, dgrp_t group); extern blk_t ext2fs_inode_data_blocks(ext2_filsys fs, struct ext2_inode *inode); extern int ext2fs_htree_intnode_maxrecs(ext2_filsys fs, int blocks); extern unsigned int ext2fs_div_ceil(unsigned int a, unsigned int b); extern __u64 ext2fs_div64_ceil(__u64 a, __u64 b); extern int ext2fs_dirent_name_len(const struct ext2_dir_entry *entry); extern void ext2fs_dirent_set_name_len(struct ext2_dir_entry *entry, int len); extern int ext2fs_dirent_file_type(const struct ext2_dir_entry *entry); extern void ext2fs_dirent_set_file_type(struct ext2_dir_entry *entry, int type); extern struct ext2_inode *ext2fs_inode(struct ext2_inode_large * large_inode); extern const struct ext2_inode *ext2fs_const_inode(const struct ext2_inode_large * large_inode); #endif /* * The actual inlined functions definitions themselves... * * If NO_INLINE_FUNCS is defined, then we won't try to do inline * functions at all! */ #if (defined(INCLUDE_INLINE_FUNCS) || !defined(NO_INLINE_FUNCS)) #ifdef INCLUDE_INLINE_FUNCS #define _INLINE_ extern #else #if (__STDC_VERSION__ >= 199901L) #define _INLINE_ inline #else #ifdef __GNUC__ #define _INLINE_ extern __inline__ #else /* For Watcom C */ #define _INLINE_ extern inline #endif /* __GNUC__ */ #endif /* __STDC_VERSION__ >= 199901L */ #endif #ifndef EXT2_CUSTOM_MEMORY_ROUTINES #include /* * Allocate memory. The 'ptr' arg must point to a pointer. */ _INLINE_ errcode_t ext2fs_get_mem(unsigned long size, void *ptr) { void *pp; pp = malloc(size); if (!pp) return EXT2_ET_NO_MEMORY; memcpy(ptr, &pp, sizeof (pp)); return 0; } _INLINE_ errcode_t ext2fs_get_memzero(unsigned long size, void *ptr) { void *pp; pp = malloc(size); if (!pp) return EXT2_ET_NO_MEMORY; memset(pp, 0, size); memcpy(ptr, &pp, sizeof(pp)); return 0; } _INLINE_ errcode_t ext2fs_get_array(unsigned long count, unsigned long size, void *ptr) { if (count && (~0UL)/count < size) return EXT2_ET_NO_MEMORY; return ext2fs_get_mem(count*size, ptr); } _INLINE_ errcode_t ext2fs_get_arrayzero(unsigned long count, unsigned long size, void *ptr) { if (count && (~0UL)/count < size) return EXT2_ET_NO_MEMORY; return ext2fs_get_memzero((size_t)count * size, ptr); } /* * Free memory. The 'ptr' arg must point to a pointer. */ _INLINE_ errcode_t ext2fs_free_mem(void *ptr) { void *p; memcpy(&p, ptr, sizeof(p)); free(p); p = 0; memcpy(ptr, &p, sizeof(p)); return 0; } /* * Resize memory. The 'ptr' arg must point to a pointer. */ _INLINE_ errcode_t ext2fs_resize_mem(unsigned long EXT2FS_ATTR((unused)) old_size, unsigned long size, void *ptr) { void *p; /* Use "memcpy" for pointer assignments here to avoid problems * with C99 strict type aliasing rules. */ memcpy(&p, ptr, sizeof(p)); p = realloc(p, size); if (!p) return EXT2_ET_NO_MEMORY; memcpy(ptr, &p, sizeof(p)); return 0; } /* * Resize array. The 'ptr' arg must point to a pointer. */ _INLINE_ errcode_t ext2fs_resize_array(unsigned long size, unsigned long old_count, unsigned long count, void *ptr) { unsigned long old_size; errcode_t retval; if (count && (~0UL)/count < size) return EXT2_ET_NO_MEMORY; size *= count; old_size = size * old_count; retval = ext2fs_resize_mem(old_size, size, ptr); if (retval) return retval; if (size > old_size) { void *p; memcpy(&p, ptr, sizeof(p)); memset((char *)p + old_size, 0, size - old_size); memcpy(ptr, &p, sizeof(p)); } return 0; } #endif /* Custom memory routines */ /* * Mark a filesystem superblock as dirty */ _INLINE_ void ext2fs_mark_super_dirty(ext2_filsys fs) { fs->flags |= EXT2_FLAG_DIRTY | EXT2_FLAG_CHANGED; } /* * Mark a filesystem as changed */ _INLINE_ void ext2fs_mark_changed(ext2_filsys fs) { fs->flags |= EXT2_FLAG_CHANGED; } /* * Check to see if a filesystem has changed */ _INLINE_ int ext2fs_test_changed(ext2_filsys fs) { return (fs->flags & EXT2_FLAG_CHANGED); } /* * Mark a filesystem as valid */ _INLINE_ void ext2fs_mark_valid(ext2_filsys fs) { fs->flags |= EXT2_FLAG_VALID; } /* * Mark a filesystem as NOT valid */ _INLINE_ void ext2fs_unmark_valid(ext2_filsys fs) { fs->flags &= ~EXT2_FLAG_VALID; } /* * Check to see if a filesystem is valid */ _INLINE_ int ext2fs_test_valid(ext2_filsys fs) { return (fs->flags & EXT2_FLAG_VALID); } /* * Mark the inode bitmap as dirty */ _INLINE_ void ext2fs_mark_ib_dirty(ext2_filsys fs) { fs->flags |= EXT2_FLAG_IB_DIRTY | EXT2_FLAG_CHANGED; } /* * Mark the block bitmap as dirty */ _INLINE_ void ext2fs_mark_bb_dirty(ext2_filsys fs) { fs->flags |= EXT2_FLAG_BB_DIRTY | EXT2_FLAG_CHANGED; } /* * Check to see if a filesystem's inode bitmap is dirty */ _INLINE_ int ext2fs_test_ib_dirty(ext2_filsys fs) { return (fs->flags & EXT2_FLAG_IB_DIRTY); } /* * Check to see if a filesystem's block bitmap is dirty */ _INLINE_ int ext2fs_test_bb_dirty(ext2_filsys fs) { return (fs->flags & EXT2_FLAG_BB_DIRTY); } /* * Return the group # of a block */ _INLINE_ dgrp_t ext2fs_group_of_blk(ext2_filsys fs, blk_t blk) { return ext2fs_group_of_blk2(fs, blk); } /* * Return the group # of an inode number */ _INLINE_ dgrp_t ext2fs_group_of_ino(ext2_filsys fs, ext2_ino_t ino) { return (ino - 1) / fs->super->s_inodes_per_group; } /* * Return the first block (inclusive) in a group */ _INLINE_ blk_t ext2fs_group_first_block(ext2_filsys fs, dgrp_t group) { return (blk_t) ext2fs_group_first_block2(fs, group); } /* * Return the last block (inclusive) in a group */ _INLINE_ blk_t ext2fs_group_last_block(ext2_filsys fs, dgrp_t group) { return (blk_t) ext2fs_group_last_block2(fs, group); } _INLINE_ blk_t ext2fs_inode_data_blocks(ext2_filsys fs, struct ext2_inode *inode) { return (blk_t) ext2fs_inode_data_blocks2(fs, inode); } _INLINE_ int ext2fs_htree_intnode_maxrecs(ext2_filsys fs, int blocks) { int csum_size = 0; if ((EXT2_SB(fs->super)->s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) != 0) csum_size = sizeof(struct ext2_dx_tail); return blocks * ((fs->blocksize - (8 + csum_size)) / sizeof(struct ext2_dx_entry)); } /* * This is an efficient, overflow safe way of calculating ceil((1.0 * a) / b) */ _INLINE_ unsigned int ext2fs_div_ceil(unsigned int a, unsigned int b) { if (!a) return 0; return ((a - 1) / b) + 1; } _INLINE_ __u64 ext2fs_div64_ceil(__u64 a, __u64 b) { if (!a) return 0; return ((a - 1) / b) + 1; } _INLINE_ int ext2fs_dirent_name_len(const struct ext2_dir_entry *entry) { return entry->name_len & 0xff; } _INLINE_ void ext2fs_dirent_set_name_len(struct ext2_dir_entry *entry, int len) { entry->name_len = (entry->name_len & 0xff00) | (len & 0xff); } _INLINE_ int ext2fs_dirent_file_type(const struct ext2_dir_entry *entry) { return entry->name_len >> 8; } _INLINE_ void ext2fs_dirent_set_file_type(struct ext2_dir_entry *entry, int type) { entry->name_len = (entry->name_len & 0xff) | (type << 8); } _INLINE_ struct ext2_inode *ext2fs_inode(struct ext2_inode_large * large_inode) { /* It is always safe to convert large inode to a small inode */ return (struct ext2_inode *) large_inode; } _INLINE_ const struct ext2_inode * ext2fs_const_inode(const struct ext2_inode_large * large_inode) { /* It is always safe to convert large inode to a small inode */ return (const struct ext2_inode *) large_inode; } #undef _INLINE_ #endif /* htree levels for ext4 */ #define EXT4_HTREE_LEVEL_COMPAT 2 #define EXT4_HTREE_LEVEL 3 static inline unsigned int ext2_dir_htree_level(ext2_filsys fs) { if (ext2fs_has_feature_largedir(fs->super)) return EXT4_HTREE_LEVEL; return EXT4_HTREE_LEVEL_COMPAT; } #ifdef __cplusplus } #endif #endif /* _EXT2FS_EXT2FS_H */ PK!Yext3_extents.hnu[/* * Copyright (c) 2003,2004 Cluster File Systems, Inc, info@clusterfs.com * Written by Alex Tomas * * %Begin-Header% * This file may be redistributed under the terms of the GNU Library * General Public License, version 2. * %End-Header% */ #ifndef _LINUX_EXT3_EXTENTS #define _LINUX_EXT3_EXTENTS /* * ext3_inode has i_block array (total 60 bytes) * first 4 bytes are used to store: * - tree depth (0 mean there is no tree yet. all extents in the inode) * - number of alive extents in the inode */ /* * This is extent tail on-disk structure. * All other extent structures are 12 bytes long. It turns out that * block_size % 12 >= 4 for at least all powers of 2 greater than 512, which * covers all valid ext4 block sizes. Therefore, this tail structure can be * crammed into the end of the block without having to rebalance the tree. */ struct ext3_extent_tail { __le32 et_checksum; /* crc32c(uuid+inum+extent_block) */ }; /* * this is extent on-disk structure * it's used at the bottom of the tree */ struct ext3_extent { __le32 ee_block; /* first logical block extent covers */ __le16 ee_len; /* number of blocks covered by extent */ __le16 ee_start_hi; /* high 16 bits of physical block */ __le32 ee_start; /* low 32 bigs of physical block */ }; /* * this is index on-disk structure * it's used at all the levels, but the bottom */ struct ext3_extent_idx { __le32 ei_block; /* index covers logical blocks from 'block' */ __le32 ei_leaf; /* pointer to the physical block of the next * * level. leaf or next index could bet here */ __le16 ei_leaf_hi; /* high 16 bits of physical block */ __le16 ei_unused; }; /* * each block (leaves and indexes), even inode-stored has header */ struct ext3_extent_header { __le16 eh_magic; /* probably will support different formats */ __le16 eh_entries; /* number of valid entries */ __le16 eh_max; /* capacity of store in entries */ __le16 eh_depth; /* has tree real underlying blocks? */ __le32 eh_generation; /* generation of the tree */ }; #define EXT3_EXT_MAGIC 0xf30a /* * array of ext3_ext_path contains path to some extent * creation/lookup routines use it for traversal/splitting/etc * truncate uses it to simulate recursive walking */ struct ext3_ext_path { __u32 p_block; __u16 p_depth; struct ext3_extent *p_ext; struct ext3_extent_idx *p_idx; struct ext3_extent_header *p_hdr; struct buffer_head *p_bh; }; /* * EXT_INIT_MAX_LEN is the maximum number of blocks we can have in an * initialized extent. This is 2^15 and not (2^16 - 1), since we use the * MSB of ee_len field in the extent datastructure to signify if this * particular extent is an initialized extent or an uninitialized (i.e. * preallocated). * EXT_UNINIT_MAX_LEN is the maximum number of blocks we can have in an * uninitialized extent. * If ee_len is <= 0x8000, it is an initialized extent. Otherwise, it is an * uninitialized one. In other words, if MSB of ee_len is set, it is an * uninitialized extent with only one special scenario when ee_len = 0x8000. * In this case we can not have an uninitialized extent of zero length and * thus we make it as a special case of initialized extent with 0x8000 length. * This way we get better extent-to-group alignment for initialized extents. * Hence, the maximum number of blocks we can have in an *initialized* * extent is 2^15 (32768) and in an *uninitialized* extent is 2^15-1 (32767). */ #define EXT_INIT_MAX_LEN (1UL << 15) #define EXT_UNINIT_MAX_LEN (EXT_INIT_MAX_LEN - 1) #define EXT_MAX_EXTENT_LBLK (((__u64) 1 << 32) - 1) #define EXT_MAX_EXTENT_PBLK (((__u64) 1 << 48) - 1) #define EXT_FIRST_EXTENT(__hdr__) \ ((struct ext3_extent *) (((char *) (__hdr__)) + \ sizeof(struct ext3_extent_header))) #define EXT_FIRST_INDEX(__hdr__) \ ((struct ext3_extent_idx *) (((char *) (__hdr__)) + \ sizeof(struct ext3_extent_header))) #define EXT_HAS_FREE_INDEX(__path__) \ (ext2fs_le16_to_cpu((__path__)->p_hdr->eh_entries) < \ ext2fs_le16_to_cpu((__path__)->p_hdr->eh_max)) #define EXT_LAST_EXTENT(__hdr__) \ (EXT_FIRST_EXTENT((__hdr__)) + \ ext2fs_le16_to_cpu((__hdr__)->eh_entries) - 1) #define EXT_LAST_INDEX(__hdr__) \ (EXT_FIRST_INDEX((__hdr__)) + \ ext2fs_le16_to_cpu((__hdr__)->eh_entries) - 1) #define EXT_MAX_EXTENT(__hdr__) \ (EXT_FIRST_EXTENT((__hdr__)) + \ ext2fs_le16_to_cpu((__hdr__)->eh_max) - 1) #define EXT_MAX_INDEX(__hdr__) \ (EXT_FIRST_INDEX((__hdr__)) + \ ext2fs_le16_to_cpu((__hdr__)->eh_max) - 1) #endif /* _LINUX_EXT3_EXTENTS */ PK![r hashmap.hnu[#ifndef HASHMAP_H # define HASHMAP_H # include # include #ifndef __GNUC_PREREQ #if defined(__GNUC__) && defined(__GNUC_MINOR__) #define __GNUC_PREREQ(maj, min) \ ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) #else #define __GNUC_PREREQ(maj, min) 0 #endif #endif struct ext2fs_hashmap { uint32_t size; uint32_t(*hash)(const void *key, size_t len); void(*free)(void*); struct ext2fs_hashmap_entry *first; struct ext2fs_hashmap_entry *last; struct ext2fs_hashmap_entry { void *data; const void *key; size_t key_len; struct ext2fs_hashmap_entry *next; struct ext2fs_hashmap_entry *list_next; struct ext2fs_hashmap_entry *list_prev; #if __GNUC_PREREQ (4, 8) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wpedantic" #endif } *entries[0]; #if __GNUC_PREREQ (4, 8) #pragma GCC diagnostic pop #endif }; struct ext2fs_hashmap *ext2fs_hashmap_create( uint32_t(*hash_fct)(const void*, size_t), void(*free_fct)(void*), size_t size); void ext2fs_hashmap_add(struct ext2fs_hashmap *h, void *data, const void *key, size_t key_len); void *ext2fs_hashmap_lookup(struct ext2fs_hashmap *h, const void *key, size_t key_len); void *ext2fs_hashmap_iter_in_order(struct ext2fs_hashmap *h, struct ext2fs_hashmap_entry **it); void ext2fs_hashmap_del(struct ext2fs_hashmap *h, struct ext2fs_hashmap_entry *e); void ext2fs_hashmap_free(struct ext2fs_hashmap *h); uint32_t ext2fs_djb2_hash(const void *str, size_t size); #endif /* !HASHMAP_H */ PK!7@  qcow2.hnu[/* * qcow2.h --- structures and function prototypes for qcow2.c to generate * qcow2 formatted disk images. This format is used originally by QEMU * for virtual machines, and stores the filesystem data on disk in a * packed format to avoid creating sparse image files that need lots of * seeking to read and write. * * The qcow2 format supports zlib compression, but that is not yet * implemented. * * It is possible to directly mount a qcow2 image using qemu-nbd: * * [root]# modprobe nbd max_part=63 * [root]# qemu-nbd -c /dev/nbd0 image.img * [root]# mount /dev/nbd0p1 /mnt/qemu * * Format details at http://people.gnome.org/~markmc/qcow-image-format.html * * Copyright (C) 2010 Red Hat, Inc., Lukas Czerner * * %Begin-Header% * This file may be redistributed under the terms of the GNU Public * License. * %End-Header% */ /* Number of l2 tables in memory before writeback */ #define L2_CACHE_PREALLOC 512 #define QCOW_MAGIC (('Q' << 24) | ('F' << 16) | ('I' << 8) | 0xfb) #define QCOW_VERSION 2 #define QCOW_OFLAG_COPIED (1ULL << 63) #define QCOW_OFLAG_COMPRESSED (1ULL << 62) #define QCOW_COMPRESSED 1 #define QCOW_ENCRYPTED 2 #define QCOW_CORRUPTED 3 struct ext2_qcow2_hdr { __u32 magic; __u32 version; __u64 backing_file_offset; __u32 backing_file_size; __u32 cluster_bits; __u64 size; __u32 crypt_method; __u32 l1_size; __u64 l1_table_offset; __u64 refcount_table_offset; __u32 refcount_table_clusters; __u32 nb_snapshots; __u64 snapshots_offset; }; typedef struct ext2_qcow2_l2_table L2_CACHE_HEAD; struct ext2_qcow2_l2_table { __u32 l1_index; __u64 offset; __u64 *data; L2_CACHE_HEAD *next; }; struct ext2_qcow2_l2_cache { L2_CACHE_HEAD *used_head; L2_CACHE_HEAD *used_tail; L2_CACHE_HEAD *free_head; __u32 free; __u32 count; __u64 next_offset; }; struct ext2_qcow2_refcount { __u64 *refcount_table; __u64 refcount_table_offset; __u64 refcount_block_offset; __u32 refcount_table_clusters; __u32 refcount_table_index; __u32 refcount_block_index; __u16 *refcount_block; }; struct ext2_qcow2_image { int fd; struct ext2_qcow2_hdr *hdr; struct ext2_qcow2_l2_cache *l2_cache; struct ext2_qcow2_refcount refcount; __u32 cluster_size; __u32 cluster_bits; __u32 l1_size; __u32 l2_size; __u64 *l1_table; __u64 l2_offset; __u64 l1_offset; __u64 image_size; }; /* Function prototypes */ /* qcow2.c */ /* Functions for converting qcow2 image into raw image */ struct ext2_qcow2_hdr *qcow2_read_header(int); int qcow2_write_raw_image(int, int, struct ext2_qcow2_hdr *); PK!@""tdb.hnu[#ifndef __TDB_H__ #define __TDB_H__ /* Unix SMB/CIFS implementation. trivial database library Copyright (C) Andrew Tridgell 1999-2004 ** NOTE! The following LGPL license applies to the tdb ** library. This does NOT imply that all of Samba is released ** under the LGPL This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifdef __cplusplus extern "C" { #endif /* flags to tdb_store() */ #define TDB_REPLACE 1 #define TDB_INSERT 2 #define TDB_MODIFY 3 /* flags for tdb_open() */ #define TDB_DEFAULT 0 /* just a readability place holder */ #define TDB_CLEAR_IF_FIRST 1 #define TDB_INTERNAL 2 /* don't store on disk */ #define TDB_NOLOCK 4 /* don't do any locking */ #define TDB_NOMMAP 8 /* don't use mmap */ #define TDB_CONVERT 16 /* convert endian (internal use) */ #define TDB_BIGENDIAN 32 /* header is big-endian (internal use) */ #define TDB_NOSYNC 64 /* don't use synchronous transactions */ #define TDB_SEQNUM 128 /* maintain a sequence number */ #define TDB_ERRCODE(code, ret) ((tdb->ecode = (code)), ret) /* error codes */ enum TDB_ERROR {TDB_SUCCESS=0, TDB_ERR_CORRUPT, TDB_ERR_IO, TDB_ERR_LOCK, TDB_ERR_OOM, TDB_ERR_EXISTS, TDB_ERR_NOLOCK, TDB_ERR_LOCK_TIMEOUT, TDB_ERR_NOEXIST, TDB_ERR_EINVAL, TDB_ERR_RDONLY}; /* debugging uses one of the following levels */ enum tdb_debug_level {TDB_DEBUG_FATAL = 0, TDB_DEBUG_ERROR, TDB_DEBUG_WARNING, TDB_DEBUG_TRACE}; typedef struct TDB_DATA { unsigned char *dptr; size_t dsize; } TDB_DATA; #ifndef PRINTF_ATTRIBUTE #if (__GNUC__ >= 3) /** Use gcc attribute to check printf fns. a1 is the 1-based index of * the parameter containing the format, and a2 the index of the first * argument. Note that some gcc 2.x versions don't handle this * properly **/ #define PRINTF_ATTRIBUTE(a1, a2) __attribute__ ((format (__printf__, a1, a2))) #else #define PRINTF_ATTRIBUTE(a1, a2) #endif #endif /* ext2fs tdb renames */ #define tdb_open ext2fs_tdb_open #define tdb_open_ex ext2fs_tdb_open_ex #define tdb_set_max_dead ext2fs_tdb_set_max_dead #define tdb_reopen ext2fs_tdb_reopen #define tdb_reopen_all ext2fs_tdb_reopen_all #define tdb_set_logging_function ext2fs_tdb_set_logging_function #define tdb_error ext2fs_tdb_error #define tdb_errorstr ext2fs_tdb_errorstr #define tdb_fetch ext2fs_tdb_fetch #define tdb_parse_record ext2fs_tdb_parse_record #define tdb_delete ext2fs_tdb_delete #define tdb_store ext2fs_tdb_store #define tdb_append ext2fs_tdb_append #define tdb_close ext2fs_tdb_close #define tdb_firstkey ext2fs_tdb_firstkey #define tdb_nextkey ext2fs_tdb_nextkey #define tdb_traverse ext2fs_tdb_traverse #define tdb_traverse_read ext2fs_tdb_traverse_read #define tdb_exists ext2fs_tdb_exists #define tdb_lockall ext2fs_tdb_lockall #define tdb_unlockall ext2fs_tdb_unlockall #define tdb_lockall_read ext2fs_tdb_lockall_read #define tdb_unlockall_read ext2fs_tdb_unlockall_read #define tdb_name ext2fs_tdb_name #define tdb_fd ext2fs_tdb_fd #define tdb_log_fn ext2fs_tdb_log_fn #define tdb_get_logging_private ext2fs_tdb_get_logging_private #define tdb_transaction_start ext2fs_tdb_transaction_start #define tdb_transaction_commit ext2fs_tdb_transaction_commit #define tdb_transaction_cancel ext2fs_tdb_transaction_cancel #define tdb_transaction_recover ext2fs_tdb_transaction_recover #define tdb_get_seqnum ext2fs_tdb_get_seqnum #define tdb_hash_size ext2fs_tdb_hash_size #define tdb_map_size ext2fs_tdb_map_size #define tdb_get_flags ext2fs_tdb_get_flags #define tdb_chainlock ext2fs_tdb_chainlock #define tdb_chainunlock ext2fs_tdb_chainunlock #define tdb_chainlock_read ext2fs_tdb_chainlock_read #define tdb_chainunlock_read ext2fs_tdb_chainunlock_read #define tdb_dump_all ext2fs_tdb_dump_all #define tdb_printfreelist ext2fs_tdb_printfreelist #define tdb_validate_freelist ext2fs_tdb_validate_freelist #define tdb_chainlock_mark ext2fs_tdb_chainlock_mark #define tdb_chainlock_nonblock ext2fs_tdb_chainlock_nonblock #define tdb_chainlock_unmark ext2fs_tdb_chainlock_unmark #define tdb_enable_seqnum ext2fs_tdb_enable_seqnum #define tdb_increment_seqnum_nonblock ext2fs_tdb_increment_seqnum_nonblock #define tdb_lock_nonblock ext2fs_tdb_lock_nonblock #define tdb_lockall_mark ext2fs_tdb_lockall_mark #define tdb_lockall_nonblock ext2fs_tdb_lockall_nonblock #define tdb_lockall_read_nonblock ext2fs_tdb_lockall_read_nonblock #define tdb_lockall_unmark ext2fs_tdb_lockall_unmark #define tdb_flush ext2fs_tdb_flush /* this is the context structure that is returned from a db open */ typedef struct tdb_context TDB_CONTEXT; typedef int (*tdb_traverse_func)(struct tdb_context *, TDB_DATA, TDB_DATA, void *); typedef void (*tdb_log_func)(struct tdb_context *, enum tdb_debug_level, const char *, ...) PRINTF_ATTRIBUTE(3, 4); typedef unsigned int (*tdb_hash_func)(TDB_DATA *key); struct tdb_logging_context { tdb_log_func log_fn; void *log_private; }; struct tdb_context *tdb_open(const char *name, int hash_size, int tdb_flags, int open_flags, mode_t mode); struct tdb_context *tdb_open_ex(const char *name, int hash_size, int tdb_flags, int open_flags, mode_t mode, const struct tdb_logging_context *log_ctx, tdb_hash_func hash_fn); void tdb_set_max_dead(struct tdb_context *tdb, int max_dead); int tdb_reopen(struct tdb_context *tdb); int tdb_reopen_all(int parent_longlived); void tdb_set_logging_function(struct tdb_context *tdb, const struct tdb_logging_context *log_ctx); enum TDB_ERROR tdb_error(struct tdb_context *tdb); const char *tdb_errorstr(struct tdb_context *tdb); TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key); int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key, int (*parser)(TDB_DATA key, TDB_DATA data, void *private_data), void *private_data); int tdb_delete(struct tdb_context *tdb, TDB_DATA key); int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag); int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf); int tdb_close(struct tdb_context *tdb); TDB_DATA tdb_firstkey(struct tdb_context *tdb); TDB_DATA tdb_nextkey(struct tdb_context *tdb, TDB_DATA key); int tdb_traverse(struct tdb_context *tdb, tdb_traverse_func fn, void *); int tdb_traverse_read(struct tdb_context *tdb, tdb_traverse_func fn, void *); int tdb_exists(struct tdb_context *tdb, TDB_DATA key); int tdb_lockall(struct tdb_context *tdb); int tdb_lockall_nonblock(struct tdb_context *tdb); int tdb_unlockall(struct tdb_context *tdb); int tdb_lockall_read(struct tdb_context *tdb); int tdb_lockall_read_nonblock(struct tdb_context *tdb); int tdb_unlockall_read(struct tdb_context *tdb); int tdb_lockall_mark(struct tdb_context *tdb); int tdb_lockall_unmark(struct tdb_context *tdb); const char *tdb_name(struct tdb_context *tdb); int tdb_fd(struct tdb_context *tdb); tdb_log_func tdb_log_fn(struct tdb_context *tdb); void *tdb_get_logging_private(struct tdb_context *tdb); int tdb_transaction_start(struct tdb_context *tdb); int tdb_transaction_commit(struct tdb_context *tdb); int tdb_transaction_cancel(struct tdb_context *tdb); int tdb_transaction_recover(struct tdb_context *tdb); int tdb_get_seqnum(struct tdb_context *tdb); int tdb_hash_size(struct tdb_context *tdb); size_t tdb_map_size(struct tdb_context *tdb); int tdb_get_flags(struct tdb_context *tdb); void tdb_enable_seqnum(struct tdb_context *tdb); void tdb_increment_seqnum_nonblock(struct tdb_context *tdb); int tdb_flush(struct tdb_context *tdb); /* Low level locking functions: use with care */ int tdb_chainlock(struct tdb_context *tdb, TDB_DATA key); int tdb_chainlock_nonblock(struct tdb_context *tdb, TDB_DATA key); int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key); int tdb_chainlock_read(struct tdb_context *tdb, TDB_DATA key); int tdb_chainunlock_read(struct tdb_context *tdb, TDB_DATA key); int tdb_chainlock_mark(struct tdb_context *tdb, TDB_DATA key); int tdb_chainlock_unmark(struct tdb_context *tdb, TDB_DATA key); /* Debug functions. Not used in production. */ void tdb_dump_all(struct tdb_context *tdb); int tdb_printfreelist(struct tdb_context *tdb); int tdb_validate_freelist(struct tdb_context *tdb, int *pnum_entries); #ifdef __cplusplus } #endif #endif /* tdb.h */ PK!sVVbitops.hnu[PK!SI.. Vext2_err.hnu[PK!gKT T |ext2_ext_attr.hnu[PK!S@[[ ext2_fs.hnu[PK!f 4ext2_io.hnu[PK!+ttIext2_types-x86_64.hnu[PK!a Zext2_types.hnu[PK!3_ext2fs.hnu[PK!Yzext3_extents.hnu[PK![r ӌhashmap.hnu[PK!7@  qcow2.hnu[PK!@""Qtdb.hnu[PK }-