4. Dynamic Structures

Dynamic metadata are created on the fly when files and blocks are allocated to files.

4.1. Index Nodes

In a regular UNIX filesystem, the inode stores all the metadata pertaining to the file (time stamps, block maps, extended attributes, etc), not the directory entry. To find the information associated with a file, one must traverse the directory files to find the directory entry associated with a file, then load the inode to find the metadata for that file. ext4 appears to cheat (for performance reasons) a little bit by storing a copy of the file type (normally stored in the inode) in the directory entry. (Compare all this to FAT, which stores all the file information directly in the directory entry, but does not support hard links and is in general more seek-happy than ext4 due to its simpler block allocator and extensive use of linked lists.)

The inode table is a linear array of struct ext4_inode. The table is sized to have enough blocks to store at least sb.s_inode_size * sb.s_inodes_per_group bytes. The number of the block group containing an inode can be calculated as (inode_number - 1) / sb.s_inodes_per_group, and the offset into the group's table is (inode_number - 1) % sb.s_inodes_per_group. There is no inode 0.

The inode checksum is calculated against the FS UUID, the inode number, and the inode structure itself.

The inode table entry is laid out in struct ext4_inode.

Offset

Size

Name

Description

0x0

__le16

i_mode

File mode. See the table i_mode below.

0x2

__le16

i_uid

Lower 16-bits of Owner UID.

0x4

__le32

i_size_lo

Lower 32-bits of size in bytes.

0x8

__le32

i_atime

Last access time, in seconds since the epoch. However, if the EA_INODE inode flag is set, this inode stores an extended attribute value and this field contains the checksum of the value.

0xC

__le32

i_ctime

Last inode change time, in seconds since the epoch. However, if the EA_INODE inode flag is set, this inode stores an extended attribute value and this field contains the lower 32 bits of the attribute value's reference count.

0x10

__le32

i_mtime

Last data modification time, in seconds since the epoch. However, if the EA_INODE inode flag is set, this inode stores an extended attribute value and this field contains the number of the inode that owns the extended attribute.

0x14

__le32

i_dtime

Deletion Time, in seconds since the epoch.

0x18

__le16

i_gid

Lower 16-bits of GID.

0x1A

__le16

i_links_count

Hard link count. Normally, ext4 does not permit an inode to have more than 65,000 hard links. This applies to files as well as directories, which means that there cannot be more than 64,998 subdirectories in a directory (each subdirectory's '..' entry counts as a hard link, as does the '.' entry in the directory itself). With the DIR_NLINK feature enabled, ext4 supports more than 64,998 subdirectories by setting this field to 1 to indicate that the number of hard links is not known.

0x1C

__le32

i_blocks_lo

Lower 32-bits of “block” count. If the huge_file feature flag is not set on the filesystem, the file consumes i_blocks_lo 512-byte blocks on disk. If huge_file is set and EXT4_HUGE_FILE_FL is NOT set in inode.i_flags, then the file consumes i_blocks_lo + (i_blocks_hi << 32) 512-byte blocks on disk. If huge_file is set and EXT4_HUGE_FILE_FL IS set in inode.i_flags, then this file consumes (i_blocks_lo + i_blocks_hi << 32) filesystem blocks on disk.

0x20

__le32

i_flags

Inode flags. See the table i_flags below.

0x24

4 bytes

i_osd1

See the table i_osd1 for more details.

0x28

60 bytes

i_block[EXT4_N_BLOCKS=15]

Block map or extent tree. See the section “The Contents of inode.i_block”.

0x64

__le32

i_generation

File version (for NFS).

0x68

__le32

i_file_acl_lo

Lower 32-bits of extended attribute block. ACLs are of course one of many possible extended attributes; I think the name of this field is a result of the first use of extended attributes being for ACLs.

0x6C

__le32

i_size_high / i_dir_acl

Upper 32-bits of file/directory size. In ext2/3 this field was named i_dir_acl, though it was usually set to zero and never used.

0x70

__le32

i_obso_faddr

(Obsolete) fragment address.

0x74

12 bytes

i_osd2

See the table i_osd2 for more details.

0x80

__le16

i_extra_isize

Size of this inode - 128. Alternately, the size of the extended inode fields beyond the original ext2 inode, including this field.

0x82

__le16

i_checksum_hi

Upper 16-bits of the inode checksum.

0x84

__le32

i_ctime_extra

Extra change time bits. This provides sub-second precision. See Inode Timestamps section.

0x88

__le32

i_mtime_extra

Extra modification time bits. This provides sub-second precision.

0x8C

__le32

i_atime_extra

Extra access time bits. This provides sub-second precision.

0x90

__le32

i_crtime

File creation time, in seconds since the epoch.

0x94

__le32

i_crtime_extra

Extra file creation time bits. This provides sub-second precision.

0x98

__le32

i_version_hi

Upper 32-bits for version number.

0x9C

__le32

i_projid

Project ID.

The i_mode value is a combination of the following flags:

Value

Description

0x1

S_IXOTH (Others may execute)

0x2

S_IWOTH (Others may write)

0x4

S_IROTH (Others may read)

0x8

S_IXGRP (Group members may execute)

0x10

S_IWGRP (Group members may write)

0x20

S_IRGRP (Group members may read)

0x40

S_IXUSR (Owner may execute)

0x80

S_IWUSR (Owner may write)

0x100

S_IRUSR (Owner may read)

0x200

S_ISVTX (Sticky bit)

0x400

S_ISGID (Set GID)

0x800

S_ISUID (Set UID)

These are mutually-exclusive file types:

0x1000

S_IFIFO (FIFO)

0x2000

S_IFCHR (Character device)

0x4000

S_IFDIR (Directory)

0x6000

S_IFBLK (Block device)

0x8000

S_IFREG (Regular file)

0xA000

S_IFLNK (Symbolic link)

0xC000

S_IFSOCK (Socket)

The i_flags field is a combination of these values:

Value

Description

0x1

This file requires secure deletion (EXT4_SECRM_FL). (not implemented)

0x2

This file should be preserved, should undeletion be desired (EXT4_UNRM_FL). (not implemented)

0x4

File is compressed (EXT4_COMPR_FL). (not really implemented)

0x8

All writes to the file must be synchronous (EXT4_SYNC_FL).

0x10

File is immutable (EXT4_IMMUTABLE_FL).

0x20

File can only be appended (EXT4_APPEND_FL).

0x40

The dump(1) utility should not dump this file (EXT4_NODUMP_FL).

0x80

Do not update access time (EXT4_NOATIME_FL).

0x100

Dirty compressed file (EXT4_DIRTY_FL). (not used)

0x200

File has one or more compressed clusters (EXT4_COMPRBLK_FL). (not used)

0x400

Do not compress file (EXT4_NOCOMPR_FL). (not used)

0x800

Encrypted inode (EXT4_ENCRYPT_FL). This bit value previously was EXT4_ECOMPR_FL (compression error), which was never used.

0x1000

Directory has hashed indexes (EXT4_INDEX_FL).

0x2000

AFS magic directory (EXT4_IMAGIC_FL).

0x4000

File data must always be written through the journal (EXT4_JOURNAL_DATA_FL).

0x8000

File tail should not be merged (EXT4_NOTAIL_FL). (not used by ext4)

0x10000

All directory entry data should be written synchronously (see dirsync) (EXT4_DIRSYNC_FL).

0x20000

Top of directory hierarchy (EXT4_TOPDIR_FL).

0x40000

This is a huge file (EXT4_HUGE_FILE_FL).

0x80000

Inode uses extents (EXT4_EXTENTS_FL).

0x200000

Inode stores a large extended attribute value in its data blocks (EXT4_EA_INODE_FL).

0x400000

This file has blocks allocated past EOF (EXT4_EOFBLOCKS_FL). (deprecated)

0x01000000

Inode is a snapshot (EXT4_SNAPFILE_FL). (not in mainline)

0x04000000

Snapshot is being deleted (EXT4_SNAPFILE_DELETED_FL). (not in mainline)

0x08000000

Snapshot shrink has completed (EXT4_SNAPFILE_SHRUNK_FL). (not in mainline)

0x10000000

Inode has inline data (EXT4_INLINE_DATA_FL).

0x20000000

Create children with the same project ID (EXT4_PROJINHERIT_FL).

0x80000000

Reserved for ext4 library (EXT4_RESERVED_FL).

Aggregate flags:

0x4BDFFF

User-visible flags.

0x4B80FF

User-modifiable flags. Note that while EXT4_JOURNAL_DATA_FL and EXT4_EXTENTS_FL can be set with setattr, they are not in the kernel's EXT4_FL_USER_MODIFIABLE mask, since it needs to handle the setting of these flags in a special manner and they are masked out of the set of flags that are saved directly to i_flags.

The osd1 field has multiple meanings depending on the creator:

Linux:

Offset

Size

Name

Description

0x0

__le32

l_i_version

Inode version. However, if the EA_INODE inode flag is set, this inode stores an extended attribute value and this field contains the upper 32 bits of the attribute value's reference count.

Hurd:

Offset

Size

Name

Description

0x0

__le32

h_i_translator

??

Masix:

Offset

Size

Name

Description

0x0

__le32

m_i_reserved

??

The osd2 field has multiple meanings depending on the filesystem creator:

Linux:

Offset

Size

Name

Description

0x0

__le16

l_i_blocks_high

Upper 16-bits of the block count. Please see the note attached to i_blocks_lo.

0x2

__le16

l_i_file_acl_high

Upper 16-bits of the extended attribute block (historically, the file ACL location). See the Extended Attributes section below.

0x4

__le16

l_i_uid_high

Upper 16-bits of the Owner UID.

0x6

__le16

l_i_gid_high

Upper 16-bits of the GID.

0x8

__le16

l_i_checksum_lo

Lower 16-bits of the inode checksum.

0xA

__le16

l_i_reserved

Unused.

Hurd:

Offset

Size

Name

Description

0x0

__le16

h_i_reserved1

??

0x2

__u16

h_i_mode_high

Upper 16-bits of the file mode.

0x4

__le16

h_i_uid_high

Upper 16-bits of the Owner UID.

0x6

__le16

h_i_gid_high

Upper 16-bits of the GID.

0x8

__u32

h_i_author

Author code?

Masix:

Offset

Size

Name

Description

0x0

__le16

h_i_reserved1

??

0x2

__u16

m_i_file_acl_high

Upper 16-bits of the extended attribute block (historically, the file ACL location).

0x4

__u32

m_i_reserved2[2]

??

4.1.1. Inode Size

In ext2 and ext3, the inode structure size was fixed at 128 bytes (EXT2_GOOD_OLD_INODE_SIZE) and each inode had a disk record size of 128 bytes. Starting with ext4, it is possible to allocate a larger on-disk inode at format time for all inodes in the filesystem to provide space beyond the end of the original ext2 inode. The on-disk inode record size is recorded in the superblock as s_inode_size. The number of bytes actually used by struct ext4_inode beyond the original 128-byte ext2 inode is recorded in the i_extra_isize field for each inode, which allows struct ext4_inode to grow for a new kernel without having to upgrade all of the on-disk inodes. Access to fields beyond EXT2_GOOD_OLD_INODE_SIZE should be verified to be within i_extra_isize. By default, ext4 inode records are 256 bytes, and (as of October 2013) the inode structure is 156 bytes (i_extra_isize = 28). The extra space between the end of the inode structure and the end of the inode record can be used to store extended attributes. Each inode record can be as large as the filesystem block size, though this is not terribly efficient.

4.1.2. Finding an Inode

Each block group contains sb->s_inodes_per_group inodes. Because inode 0 is defined not to exist, this formula can be used to find the block group that an inode lives in: bg = (inode_num - 1) / sb->s_inodes_per_group. The particular inode can be found within the block group's inode table at index = (inode_num - 1) % sb->s_inodes_per_group. To get the byte address within the inode table, use offset = index * sb->s_inode_size.

4.1.3. Inode Timestamps

Four timestamps are recorded in the lower 128 bytes of the inode structure -- inode change time (ctime), access time (atime), data modification time (mtime), and deletion time (dtime). The four fields are 32-bit signed integers that represent seconds since the Unix epoch (1970-01-01 00:00:00 GMT), which means that the fields will overflow in January 2038. For inodes that are not linked from any directory but are still open (orphan inodes), the dtime field is overloaded for use with the orphan list. The superblock field s_last_orphan points to the first inode in the orphan list; dtime is then the number of the next orphaned inode, or zero if there are no more orphans.

If the inode structure size sb->s_inode_size is larger than 128 bytes and the i_inode_extra field is large enough to encompass the respective i_[cma]time_extra field, the ctime, atime, and mtime inode fields are widened to 64 bits. Within this “extra” 32-bit field, the lower two bits are used to extend the 32-bit seconds field to be 34 bit wide; the upper 30 bits are used to provide nanosecond timestamp accuracy. Therefore, timestamps should not overflow until May 2446. dtime was not widened. There is also a fifth timestamp to record inode creation time (crtime); this field is 64-bits wide and decoded in the same manner as 64-bit [cma]time. Neither crtime nor dtime are accessible through the regular stat() interface, though debugfs will report them.

We use the 32-bit signed time value plus (2^32 * (extra epoch bits)). In other words:

Extra epoch bits

MSB of 32-bit time

Adjustment for signed 32-bit to 64-bit tv_sec

Decoded 64-bit tv_sec

valid time range

0 0

1

0

-0x80000000 - -0x00000001

1901-12-13 to 1969-12-31

0 0

0

0

0x000000000 - 0x07fffffff

1970-01-01 to 2038-01-19

0 1

1

0x100000000

0x080000000 - 0x0ffffffff

2038-01-19 to 2106-02-07

0 1

0

0x100000000

0x100000000 - 0x17fffffff

2106-02-07 to 2174-02-25

1 0

1

0x200000000

0x180000000 - 0x1ffffffff

2174-02-25 to 2242-03-16

1 0

0

0x200000000

0x200000000 - 0x27fffffff

2242-03-16 to 2310-04-04

1 1

1

0x300000000

0x280000000 - 0x2ffffffff

2310-04-04 to 2378-04-22

1 1

0

0x300000000

0x300000000 - 0x37fffffff

2378-04-22 to 2446-05-10

This is a somewhat odd encoding since there are effectively seven times as many positive values as negative values. There have also been long-standing bugs decoding and encoding dates beyond 2038, which don't seem to be fixed as of kernel 3.12 and e2fsprogs 1.42.8. 64-bit kernels incorrectly use the extra epoch bits 1,1 for dates between 1901 and 1970. At some point the kernel will be fixed and e2fsck will fix this situation, assuming that it is run before 2310.

4.2. The Contents of inode.i_block

Depending on the type of file an inode describes, the 60 bytes of storage in inode.i_block can be used in different ways. In general, regular files and directories will use it for file block indexing information, and special files will use it for special purposes.

4.2.2. Direct/Indirect Block Addressing

In ext2/3, file block numbers were mapped to logical block numbers by means of an (up to) three level 1-1 block map. To find the logical block that stores a particular file block, the code would navigate through this increasingly complicated structure. Notice that there is neither a magic number nor a checksum to provide any level of confidence that the block isn't full of garbage.

i.i_block Offset

Where It Points

0 to 11

Direct map to file blocks 0 to 11.

12

Indirect block: (file blocks 12 to ($block_size / 4) + 11, or 12 to 1035 if 4KiB blocks)

Indirect Block Offset

Where It Points

0 to ($block_size / 4)

Direct map to ($block_size / 4) blocks (1024 if 4KiB blocks)

13

Double-indirect block: (file blocks $block_size/4 + 12 to ($block_size / 4) ^ 2 + ($block_size / 4) + 11, or 1036 to 1049611 if 4KiB blocks)

Double Indirect Block Offset

Where It Points

0 to ($block_size / 4)

Map to ($block_size / 4) indirect blocks (1024 if 4KiB blocks)

Indirect Block Offset

Where It Points

0 to ($block_size / 4)

Direct map to ($block_size / 4) blocks (1024 if 4KiB blocks)

14

Triple-indirect block: (file blocks ($block_size / 4) ^ 2 + ($block_size / 4) + 12 to ($block_size / 4) ^ 3 + ($block_size / 4) ^ 2 + ($block_size / 4) + 12, or 1049612 to 1074791436 if 4KiB blocks)

Triple Indirect Block Offset

Where It Points

0 to ($block_size / 4)

Map to ($block_size / 4) double indirect blocks (1024 if 4KiB blocks)

Double Indirect Block Offset

Where It Points

0 to ($block_size / 4)

Map to ($block_size / 4) indirect blocks (1024 if 4KiB blocks)

Indirect Block Offset

Where It Points

0 to ($block_size / 4)

Direct map to ($block_size / 4) blocks (1024 if 4KiB blocks)

Note that with this block mapping scheme, it is necessary to fill out a lot of mapping data even for a large contiguous file! This inefficiency led to the creation of the extent mapping scheme, discussed below.

Notice also that a file using this mapping scheme cannot be placed higher than 2^32 blocks.

4.2.3. Extent Tree

In ext4, the file to logical block map has been replaced with an extent tree. Under the old scheme, allocating a contiguous run of 1,000 blocks requires an indirect block to map all 1,000 entries; with extents, the mapping is reduced to a single struct ext4_extent with ee_len = 1000. If flex_bg is enabled, it is possible to allocate very large files with a single extent, at a considerable reduction in metadata block use, and some improvement in disk efficiency. The inode must have the extents flag (0x80000) flag set for this feature to be in use.

Extents are arranged as a tree. Each node of the tree begins with a struct ext4_extent_header. If the node is an interior node (eh.eh_depth > 0), the header is followed by eh.eh_entries instances of struct ext4_extent_idx; each of these index entries points to a block containing more nodes in the extent tree. If the node is a leaf node (eh.eh_depth == 0), then the header is followed by eh.eh_entries instances of struct ext4_extent; these instances point to the file's data blocks. The root node of the extent tree is stored in inode.i_block, which allows for the first four extents to be recorded without the use of extra metadata blocks.

The extent tree header is recorded in struct ext4_extent_header, which is 12 bytes long:

Offset

Size

Name

Description

0x0

__le16

eh_magic

Magic number, 0xF30A.

0x2

__le16

eh_entries

Number of valid entries following the header.

0x4

__le16

eh_max

Maximum number of entries that could follow the header.

0x6

__le16

eh_depth

Depth of this extent node in the extent tree. 0 = this extent node points to data blocks; otherwise, this extent node points to other extent nodes. The extent tree can be at most 5 levels deep: a logical block number can be at most 2^32, and the smallest n that satisfies 4*(((blocksize - 12)/12)^n) >= 2^32 is 5.

0x8

__le32

eh_generation

Generation of the tree. (Used by Lustre, but not standard ext4).

Internal nodes of the extent tree, also known as index nodes, are recorded as struct ext4_extent_idx, and are 12 bytes long:

Offset

Size

Name

Description

0x0

__le32

ei_block

This index node covers file blocks from 'block' onward.

0x4

__le32

ei_leaf_lo

Lower 32-bits of the block number of the extent node that is the next level lower in the tree. The tree node pointed to can be either another internal node or a leaf node, described below.

0x8

__le16

ei_leaf_hi

Upper 16-bits of the previous field.

0xA

__u16

ei_unused

Leaf nodes of the extent tree are recorded as struct ext4_extent, and are also 12 bytes long:

Offset

Size

Name

Description

0x0

__le32

ee_block

First file block number that this extent covers.

0x4

__le16

ee_len

Number of blocks covered by extent. If the value of this field is <= 32768, the extent is initialized. If the value of the field is > 32768, the extent is uninitialized and the actual extent length is ee_len - 32768. Therefore, the maximum length of a initialized extent is 32768 blocks, and the maximum length of an uninitialized extent is 32767.

0x6

__le16

ee_start_hi

Upper 16-bits of the block number to which this extent points.

0x8

__le32

ee_start_lo

Lower 32-bits of the block number to which this extent points.

Prior to the introduction of metadata checksums, the extent header + extent entries always left at least 4 bytes of unallocated space at the end of each extent tree data block (because (2^x % 12) >= 4). Therefore, the 32-bit checksum is inserted into this space. The 4 extents in the inode do not need checksumming, since the inode is already checksummed. The checksum is calculated against the FS UUID, the inode number, the inode generation, and the entire extent block leading up to (but not including) the checksum itself.

struct ext4_extent_tail is 4 bytes long:

Offset

Size

Name

Description

0x0

__le32

eb_checksum

Checksum of the extent block, crc32c(uuid+inum+igeneration+extentblock)

4.2.4. Inline Data

If the inline data feature is enabled for the filesystem and the flag is set for the inode, it is possible that the first 60 bytes of the file data are stored here.

4.3. Directory Entries

In an ext4 filesystem, a directory is more or less a flat file that maps an arbitrary byte string (usually ASCII) to an inode number on the filesystem. There can be many directory entries across the filesystem that reference the same inode number--these are known as hard links, and that is why hard links cannot reference files on other filesystems. As such, directory entries are found by reading the data block(s) associated with a directory file for the particular directory entry that is desired.

4.3.1. Linear (Classic) Directories

By default, each directory lists its entries in an “almost-linear” array. I write “almost” because it's not a linear array in the memory sense because directory entries are not split across filesystem blocks. Therefore, it is more accurate to say that a directory is a series of data blocks and that each block contains a linear array of directory entries. The end of each per-block array is signified by reaching the end of the block; the last entry in the block has a record length that takes it all the way to the end of the block. The end of the entire directory is of course signified by reaching the end of the file. Unused directory entries are signified by inode = 0. By default the filesystem uses struct ext4_dir_entry_2 for directory entries unless the “filetype” feature flag is not set, in which case it uses struct ext4_dir_entry.

The original directory entry format is struct ext4_dir_entry, which is at most 263 bytes long, though on disk you'll need to reference dirent.rec_len to know for sure.

Offset

Size

Name

Description

0x0

__le32

inode

Number of the inode that this directory entry points to.

0x4

__le16

rec_len

Length of this directory entry. Must be a multiple of 4.

0x6

__le16

name_len

Length of the file name.

0x8

char

name[EXT4_NAME_LEN]

File name.

Since file names cannot be longer than 255 bytes, the new directory entry format shortens the rec_len field and uses the space for a file type flag, probably to avoid having to load every inode during directory tree traversal. This format is ext4_dir_entry_2, which is at most 263 bytes long, though on disk you'll need to reference dirent.rec_len to know for sure.

Offset

Size

Name

Description

0x0

__le32

inode

Number of the inode that this directory entry points to.

0x4

__le16

rec_len

Length of this directory entry.

0x6

__u8

name_len

Length of the file name.

0x7

__u8

file_type

File type code, see ftype table below.

0x8

char

name[EXT4_NAME_LEN]

File name.

The directory file type is one of the following values:

Value

Description

0x0

Unknown.

0x1

Regular file.

0x2

Directory.

0x3

Character device file.

0x4

Block device file.

0x5

FIFO.

0x6

Socket.

0x7

Symbolic link.

In order to add checksums to these classic directory blocks, a phony struct ext4_dir_entry is placed at the end of each leaf block to hold the checksum. The directory entry is 12 bytes long. The inode number and name_len fields are set to zero to fool old software into ignoring an apparently empty directory entry, and the checksum is stored in the place where the name normally goes. The structure is struct ext4_dir_entry_tail:

Offset

Size

Name

Description

0x0

__le32

det_reserved_zero1

Inode number, which must be zero.

0x4

__le16

det_rec_len

Length of this directory entry, which must be 12.

0x6

__u8

det_reserved_zero2

Length of the file name, which must be zero.

0x7

__u8

det_reserved_ft

File type, which must be 0xDE.

0x8

__le32

det_checksum

Directory leaf block checksum.

The leaf directory block checksum is calculated against the FS UUID, the directory's inode number, the directory's inode generation number, and the entire directory entry block up to (but not including) the fake directory entry.

4.3.2. Hash Tree Directories

A linear array of directory entries isn't great for performance, so a new feature was added to ext3 to provide a faster (but peculiar) balanced tree keyed off a hash of the directory entry name. If the EXT4_INDEX_FL (0x1000) flag is set in the inode, this directory uses a hashed btree (htree) to organize and find directory entries. For backwards read-only compatibility with ext2, this tree is actually hidden inside the directory file, masquerading as “empty” directory data blocks! It was stated previously that the end of the linear directory entry table was signified with an entry pointing to inode 0; this is (ab)used to fool the old linear-scan algorithm into thinking that the rest of the directory block is empty so that it moves on.

The root of the tree always lives in the first data block of the directory. By ext2 custom, the '.' and '..' entries must appear at the beginning of this first block, so they are put here as two struct ext4_dir_entry_2s and not stored in the tree. The rest of the root node contains metadata about the tree and finally a hash->block map to find nodes that are lower in the htree. If dx_root.info.indirect_levels is non-zero then the htree has two levels; the data block pointed to by the root node's map is an interior node, which is indexed by a minor hash. Interior nodes in this tree contains a zeroed out struct ext4_dir_entry_2 followed by a minor_hash->block map to find leafe nodes. Leaf nodes contain a linear array of all struct ext4_dir_entry_2; all of these entries (presumably) hash to the same value. If there is an overflow, the entries simply overflow into the next leaf node, and the least-significant bit of the hash (in the interior node map) that gets us to this next leaf node is set.

To traverse the directory as a htree, the code calculates the hash of the desired file name and uses it to find the corresponding block number. If the tree is flat, the block is a linear array of directory entries that can be searched; otherwise, the minor hash of the file name is computed and used against this second block to find the corresponding third block number. That third block number will be a linear array of directory entries.

To traverse the directory as a linear array (such as the old code does), the code simply reads every data block in the directory. The blocks used for the htree will appear to have no entries (aside from '.' and '..') and so only the leaf nodes will appear to have any interesting content.

The root of the htree is in struct dx_root, which is the full length of a data block:

Offset

Type

Name

Description

0x0

__le32

dot.inode

inode number of this directory.

0x4

__le16

dot.rec_len

Length of this record, 12.

0x6

u8

dot.name_len

Length of the name, 1.

0x7

u8

dot.file_type

File type of this entry, 0x2 (directory) (if the feature flag is set).

0x8

char

dot.name[4]

“.\0\0\0”

0xC

__le32

dotdot.inode

inode number of parent directory.

0x10

__le16

dotdot.rec_len

block_size - 12. The record length is long enough to cover all htree data.

0x12

u8

dotdot.name_len

Length of the name, 2.

0x13

u8

dotdot.file_type

File type of this entry, 0x2 (directory) (if the feature flag is set).

0x14

char

dotdot_name[4]

“..\0\0”

0x18

__le32

struct dx_root_info.reserved_zero

Zero.

0x1C

u8

struct dx_root_info.hash_version

Hash type, see dirhash table below.

0x1D

u8

struct dx_root_info.info_length

Length of the tree information, 0x8.

0x1E

u8

struct dx_root_info.indirect_levels

Depth of the htree. Cannot be larger than 3 if the INCOMPAT_LARGEDIR feature is set; cannot be larger than 2 otherwise.

0x1F

u8

struct dx_root_info.unused_flags

0x20

__le16

limit

Maximum number of dx_entries that can follow this header, plus 1 for the header itself.

0x22

__le16

count

Actual number of dx_entries that follow this header, plus 1 for the header itself.

0x24

__le32

block

The block number (within the directory file) that goes with hash=0.

0x28

struct dx_entry

entries[0]

As many 8-byte struct dx_entry as fits in the rest of the data block.

The directory hash is one of the following values:

Value

Description

0x0

Legacy.

0x1

Half MD4.

0x2

Tea.

0x3

Legacy, unsigned.

0x4

Half MD4, unsigned.

0x5

Tea, unsigned.

Interior nodes of an htree are recorded as struct dx_node, which is also the full length of a data block:

Offset

Type

Name

Description

0x0

__le32

fake.inode

Zero, to make it look like this entry is not in use.

0x4

__le16

fake.rec_len

The size of the block, in order to hide all of the dx_node data.

0x6

u8

name_len

Zero. There is no name for this “unused” directory entry.

0x7

u8

file_type

Zero. There is no file type for this “unused” directory entry.

0x8

__le16

limit

Maximum number of dx_entries that can follow this header, plus 1 for the header itself.

0xA

__le16

count

Actual number of dx_entries that follow this header, plus 1 for the header itself.

0xE

__le32

block

The block number (within the directory file) that goes with the lowest hash value of this block. This value is stored in the parent block.

0x12

struct dx_entry

entries[0]

As many 8-byte struct dx_entry as fits in the rest of the data block.

The hash maps that exist in both struct dx_root and struct dx_node are recorded as struct dx_entry, which is 8 bytes long:

Offset

Type

Name

Description

0x0

__le32

hash

Hash code.

0x4

__le32

block

Block number (within the directory file, not filesystem blocks) of the next node in the htree.

(If you think this is all quite clever and peculiar, so does the author.)

If metadata checksums are enabled, the last 8 bytes of the directory block (precisely the length of one dx_entry) are used to store a struct dx_tail, which contains the checksum. The limit and count entries in the dx_root/dx_node structures are adjusted as necessary to fit the dx_tail into the block. If there is no space for the dx_tail, the user is notified to run e2fsck -D to rebuild the directory index (which will ensure that there's space for the checksum. The dx_tail structure is 8 bytes long and looks like this:

Offset

Type

Name

Description

0x0

u32

dt_reserved

Zero.

0x4

__le32

dt_checksum

Checksum of the htree directory block.

The checksum is calculated against the FS UUID, the htree index header (dx_root or dx_node), all of the htree indices (dx_entry) that are in use, and the tail block (dx_tail).

4.4. Extended Attributes

Extended attributes (xattrs) are typically stored in a separate data block on the disk and referenced from inodes via inode.i_file_acl*. The first use of extended attributes seems to have been for storing file ACLs and other security data (selinux). With the user_xattr mount option it is possible for users to store extended attributes so long as all attribute names begin with “user”; this restriction seems to have disappeared as of Linux 3.0.

There are two places where extended attributes can be found. The first place is between the end of each inode entry and the beginning of the next inode entry. For example, if inode.i_extra_isize = 28 and sb.inode_size = 256, then there are 256 - (128 + 28) = 100 bytes available for in-inode extended attribute storage. The second place where extended attributes can be found is in the block pointed to by inode.i_file_acl. As of Linux 3.11, it is not possible for this block to contain a pointer to a second extended attribute block (or even the remaining blocks of a cluster). In theory it is possible for each attribute's value to be stored in a separate data block, though as of Linux 3.11 the code does not permit this.

Keys are generally assumed to be ASCIIZ strings, whereas values can be strings or binary data.

Extended attributes, when stored after the inode, have a header ext4_xattr_ibody_header that is 4 bytes long:

Offset

Type

Name

Description

0x0

__le32

h_magic

Magic number for identification, 0xEA020000. This value is set by the Linux driver, though e2fsprogs doesn't seem to check it(?)

The beginning of an extended attribute block is in struct ext4_xattr_header, which is 32 bytes long:

Offset

Type

Name

Description

0x0

__le32

h_magic

Magic number for identification, 0xEA020000.

0x4

__le32

h_refcount

Reference count.

0x8

__le32

h_blocks

Number of disk blocks used.

0xC

__le32

h_hash

Hash value of all attributes.

0x10

__le32

h_checksum

Checksum of the extended attribute block.

0x14

__u32

h_reserved[2]

Zero.

The checksum is calculated against the FS UUID, the 64-bit block number of the extended attribute block, and the entire block (header + entries).

Following the struct ext4_xattr_header or struct ext4_xattr_ibody_header is an array of struct ext4_xattr_entry; each of these entries is at least 16 bytes long. When stored in an external block, the struct ext4_xattr_entry entries must be stored in sorted order. The sort order is e_name_index, then e_name_len, and finally e_name. Attributes stored inside an inode do not need be stored in sorted order.

Offset

Type

Name

Description

0x0

__u8

e_name_len

Length of name.

0x1

__u8

e_name_index

Attribute name index. There is a discussion of this below.

0x2

__le16

e_value_offs

Location of this attribute's value on the disk block where it is stored. Multiple attributes can share the same value. For an inode attribute this value is relative to the start of the first entry; for a block this value is relative to the start of the block (i.e. the header).

0x4

__le32

e_value_inum

The inode where the value is stored. Zero indicates the value is in the same block as this entry. This field is only used if the INCOMPAT_EA_INODE feature is enabled.

0x8

__le32

e_value_size

Length of attribute value.

0xC

__le32

e_hash

Hash value of attribute name and attribute value. The kernel doesn't update the hash for in-inode attributes, so for that case this value must be zero, because e2fsck validates any non-zero hash regardless of where the xattr lives.

0x10

char

e_name[e_name_len]

Attribute name. Does not include trailing NULL.

Attribute values can follow the end of the entry table. There appears to be a requirement that they be aligned to 4-byte boundaries. The values are stored starting at the end of the block and grow towards the xattr_header/xattr_entry table. When the two collide, the overflow is put into a separate disk block. If the disk block fills up, the filesystem returns -ENOSPC.

The first four fields of the ext4_xattr_entry are set to zero to mark the end of the key list.

4.4.1. Attribute Name Indices

Logically speaking, extended attributes are a series of key=value pairs. The keys are assumed to be NULL-terminated strings. To reduce the amount of on-disk space that the keys consume, the beginning of the key string is matched against the attribute name index. If a match is found, the attribute name index field is set, and matching string is removed from the key name. Here is a map of name index values to key prefixes:

Name Index

Key Prefix

0

(no prefix)

1

“user.”

2

“system.posix_acl_access”

3

“system.posix_acl_default”

4

“trusted.”

6

“security.”

7

“system.” (inline_data only?)

8

“system.richacl” (SuSE kernels only?)

For example, if the attribute key is “user.fubar”, the attribute name index is set to 1 and the “fubar” name is recorded on disk.

4.4.2. POSIX ACLs

POSIX ACLs are stored in a reduced version of the Linux kernel (and libacl's) internal ACL format. The key difference is that the version number is different (1) and the e_id field is only stored for named user and group ACLs.