Editing Ext2 (section)

==ext2 data structures==
{{More citations needed section|date=January 2017}}
The space in ext2 is split up into [[block (data storage)|block]]s.  These blocks are grouped into block groups, analogous to [[cylinder group]]s in the [[Unix File System]]. There are typically thousands of blocks on a large file system.  Data for any given file is typically contained within a single block group where possible.  This is done to minimize the number of disk seeks when reading large amounts of contiguous data.

Each block group contains a copy of the superblock and block group descriptor table, and all block groups contain a  block bitmap, an inode bitmap, an inode table, and finally the actual data blocks.

The superblock contains important information that is crucial to the booting of the [[operating system]]. Thus backup copies are made in multiple block groups in the file system. However, typically only the first copy of it, which is found at the first block of the file system, is used in the booting.

The group descriptor stores the location of the block bitmap, inode bitmap, and the start of the inode table for every block group. These, in turn, are stored in a group descriptor table.<ref>{{Cite web |title=The Second Extended Filesystem — The Linux Kernel documentation |url=https://docs.kernel.org/filesystems/ext2.html |access-date=2025-02-28 |website=docs.kernel.org}}</ref>

===Inodes===
Every file or directory is represented by an [[inode]]. The term "inode" comes from "index node" (over time, it became i-node and then inode).<ref>"Programmer's Journal", Volume 5, 1987, p. 174</ref> The inode includes data about the size, permission, ownership, and location on disk of the file or directory.

Example of ext2 inode structure:

<div align="center">[[File:Ext2-inode.svg|Estructure]]</div>

Quote from the Linux kernel documentation for ext2:<ref>{{Cite web |title=The Second Extended File System |url=https://www.nongnu.org/ext2-doc/ext2.html |access-date=2019-12-11 |website=www.nongnu.org}}</ref>
{{blockquote|There are pointers to the first 12 blocks which contain the file's data in the inode.  There is a pointer to an indirect block (which contains pointers to the next set of blocks), a pointer to a doubly indirect block and a pointer to a trebly indirect block.}}

Thus, there is a structure in ext2 that has 15 pointers. Pointers 1 to 12 point to direct blocks, pointer 13 points to an indirect block, pointer 14 points to a doubly indirect block, and pointer 15 points to a triply indirect block.

===Directories===
Each directory is a list of directory entries. Each directory entry associates one file name with one inode number, and consists of the inode number, the length of the file name, and the actual text of the file name.  To find a file, the directory is searched front-to-back for the associated filename.  For reasonable directory sizes, this is fine.  But for very large directories this is inefficient, and ext3 offers a second way of storing directories ([[HTree]]) that is more efficient than just a list of filenames.

The root directory is always stored in inode number two, so that the file system code can find it at mount time. Subdirectories are implemented by storing the name of the subdirectory in the name field, and the inode number of the subdirectory in the inode field. Hard links are implemented by storing the same inode number with more than one file name. Accessing the file by either name results in the same inode number, and therefore the same data.

The special directories "." (current directory) and ".." (parent directory) are implemented by storing the names "." and ".." in the directory, and the inode number of the current and parent directories in the inode field. The only special treatment these two entries receive is that they are automatically created when any new directory is made, and they cannot be deleted.

===Allocating data===
When a new file or directory is created, ext2 must decide where to store the data. If the disk is mostly empty, then data can be stored almost anywhere. However, clustering the data with related data will minimize seek times and maximize performance.

ext2 attempts to allocate each new directory in the group containing its parent directory, on the theory that accesses to parent and children directories are likely to be closely related. ext2 also attempts to place files in the same group as their directory entries, because directory accesses often lead to file accesses. However, if the group is full, then the new file or new directory is placed in some other non-full group.

The data blocks needed to store directories and files can be found by looking in the data allocation bitmap. Any needed space in the inode table can be found by looking in the inode allocation bitmap.