F2FS

Last updated
F2FS
Developer(s) Samsung Electronics, Motorola Mobility, Huawei and Google
Full nameFlash-Friendly File System
Introducedv3.8, 2012-12-20 [1] with Linux
Structures
Directory contentsmulti-level hash table
File allocationbitmap (free space), table
BootableYes, starting from GRUB 2.04 (2019-07-05)
Limits
Max volume size16 TB
Max file size3.94 TB
Max no. of filesDepends on volume size
Max filename length255 bytes [2]
Features
Dates recordedmodification (mtime), attribute modification (ctime), access (atime)
Date resolution1 ns
AttributesPOSIX, extended attributes
File system
permissions 		POSIX, ACL
Transparent
compression		LZO, LZ4 (since Linux 5.6), [3] zstd (since Linux 5.7) [4]
Transparent
encryption 		Yes
Other
Supported
operating systems 		Linux and Android
Website www.kernel.org/doc/html/latest/filesystems/f2fs.html

F2FS (Flash-Friendly File System) is a flash file system initially developed by Samsung Electronics for the Linux kernel. [5]

Contents

The motive for F2FS was to build a file system that, from the start, takes into account the characteristics of NAND flash memory-based storage devices (such as solid-state disks, eMMC, and SD cards), which are widely used in computer systems ranging from mobile devices to servers.

F2FS was designed on a basis of a log-structured file system approach, which is adapted to newer forms of storage. Jaegeuk Kim, the principal F2FS author, has stated that it remedies some known issues [5] of the older log-structured file systems, such as the snowball effect of wandering trees and high cleaning overhead. In addition, since a NAND-based storage device shows different characteristics according to its internal geometry or flash memory management scheme (such as the Flash Translation Layer or FTL), it supports various parameters not only for configuring on-disk layout, but also for selecting allocation and cleaning algorithms.

Note, that by default F2FS uses "posix" fsync scheme, which carries higher risks of leaving the file system in dirty state during unclean shutdown (as it does not guarantee atomicity of write operations) at the benefit of better performance. There is a more stringent method that respects hardware limitations for greater security at the expense of performance; see the "fsync_mode" option in the manual for details. [6]

Features

Design

On-disk layout

F2FS divides the whole volume into a number of segments, each of which is fixed at 2 MB. A section is composed of consecutive segments, and a zone consists of a set of sections. By default, section and zone sizes are set to the same size, but users can easily modify the size with mkfs.

F2FS splits the entire volume into six areas, and all except the superblock area consist of multiple segments as described below.

Superblock (SB)
The SB is located at the beginning of the partition. There are two copies to avoid file-system corruption. It contains basic partition information and some default F2FS parameters.
Checkpoint (CP)
The CP contains file system information, bitmaps for valid NAT/SIT sets, orphan inode lists, and summary entries of current active segments.
Segment Information Table (SIT)
The SIT contains the valid block count and validity bitmap of all the Main Area blocks.
Node Address Table (NAT)
The NAT is an address table for the Main Area node blocks.
Segment Summary Area (SSA)
The SSA contains entries which contain the owner information of the Main Area data and node blocks.
Main Area
The main area contains file and directory data and their indices.

In order to avoid misalignment between file system and flash storage, F2FS aligns the start block address of the CP with the segment size. It also aligns the Main Area start block address with the zone size by reserving some segments in the SSA area.

Metadata structure

F2FS uses the checkpoint scheme to maintain file system integrity. At mount time, F2FS first tries to find the last valid checkpoint data by scanning the CP area. In order to reduce the scanning time, F2FS uses only two copies of the CP. One of them always indicates the last valid data, which is called a shadow copy mechanism. In addition to the CP, the NAT and SIT also use the shadow copy mechanism. For file system consistency, each CP points to which NAT and SIT copies are valid.

Index structure

The key data structure is the "node". Similar to traditional file structures, F2FS has three types of nodes: inode, direct node, indirect node. F2FS assigns 4 KB to an inode block which contains 923 data block indices, two direct node pointers, two indirect node pointers, and one double indirect node pointer as described below. A direct node block contains 1018 data block indices, and an indirect node block contains 1018 node block indices. Thus, one inode block (i.e., a file) covers:

4 KiB × (923 + 2×1018 + 2×10182 + 10183) = 4,228,213,756 KiB = 4,129,114.996 MiB = 4,032.338863 GiB = 3.937830921 TiB

Note that all the node blocks are mapped by the NAT, which means that the location of each node is translated by the NAT. To mitigate the wandering tree problem, F2FS is able to cut off the propagation of node updates caused by leaf data writes.

Directory structure

A directory entry (dentry) occupies 11 bytes, which consists of the following attributes.

A directory entry structure
hashHash value of the file name
ino Inode number
lenThe length of file name
typeFile type such as directory, symlink, etc.

A dentry block consists of 214 dentry slots and file names. A bitmap is used to represent whether each dentry is valid or not. A dentry block occupies 4 KB and has the following composition:

Dentry Block (4 K) = bitmap (27 bytes) + reserved (3 bytes) + dentries (11 * 214 bytes) + file name (8 * 214 bytes)

F2FS implements multi-level hash tables for the directory structure. Each level has a hash table with a dedicated number of hash buckets as shown below. Note that "A(2B)" means a bucket includes 2 data blocks.

Term
A indicates bucket
B indicates block
N indicates MAX_DIR_HASH_DEPTH
level #0    A(2B) level #1    A(2B) - A(2B) level #2    A(2B) - A(2B) - A(2B) - A(2B)     ... level #N/2  A(2B) - A(2B) - A(2B) - A(2B) - A(2B) - ... - A(2B)     ... level #N    A(4B) - A(4B) - A(4B) - A(4B) - A(4B) - ... - A(4B)

When F2FS finds a file name in a directory, first a hash value of the file name is calculated. Then, F2FS scans the hash table in level #0 to find the dentry consisting of the file name and its inode number. If not found, F2FS scans the next hash table in level #1. In this way, F2FS scans hash tables in each level incrementally from 1 to N. In each level F2FS needs to scan only one bucket determined by the following equation, which shows O(log(# of files)) complexity.

 bucket number to scan in level #n = (hash value) % (# of buckets in level #n)

In the case of file creation, F2FS finds empty consecutive slots that cover the file name. F2FS searches the empty slots in the hash tables of whole levels from 1 to N in the same way as the lookup operation.

Default block allocation

At runtime, F2FS manages six active logs inside the "Main Area:" Hot/Warm/Cold node and Hot/Warm/Cold data.

Block allocation policy
Hot nodeContains direct node blocks of directories.
Warm nodeContains direct node blocks except hot node blocks.
Cold nodeContains indirect node blocks.
Hot dataContains dentry blocks.
Warm dataContains data blocks except hot and cold data blocks.
Cold dataContains multimedia data or migrated data blocks.

LFS has two schemes for free space management: threaded log and copy-and-compaction. The copy-and-compaction scheme which is known as cleaning, is well-suited for devices showing very good sequential write performance, since free segments are served all the time for writing new data. However, it suffers from cleaning overhead during high utilization. Conversely, the threaded log scheme suffers from random writes, but no cleaning process is needed. F2FS adopts a hybrid scheme where the copy-and-compaction scheme is adopted by default, but the policy is dynamically changed to the threaded log scheme according to the file system status.

In order to align F2FS with underlying flash-based storage, F2FS allocates a segment in a unit of a section. F2FS expects the section size to be the same as the garbage collection unit size in FTL. With respect to the mapping granularity in FTL, F2FS allocates each section of the active logs to as many different zones as possible. FTL can write the active log data into one allocation unit according to its mapping granularity.

Cleaning process

F2FS does cleaning both on demand, and in the background. On-demand cleaning is triggered when there are not enough free segments to serve VFS calls. The background cleaner is executed by a kernel thread, and triggers the cleaning job when the system is idle.

F2FS supports two victim selection policies: greedy, and cost-benefit algorithms. In the greedy algorithm, F2FS selects a victim segment having the smallest number of valid blocks. In the cost-benefit algorithm, F2FS selects a victim segment according to the segment age and the number of valid blocks in order to address the log block thrashing problem present in the greedy algorithm. F2FS uses the greedy algorithm for on-demand cleaning, the background cleaner uses the cost-benefit algorithm.

In order to identify whether the data in the victim segment are valid or not, F2FS manages a bitmap. Each bit represents the validity of a block, and the bitmap is composed of a bit stream covering whole blocks in the Main Area.

Adoption

Phone manufacturers

Google first used F2FS in their Nexus 9 in 2014. [18] However Google's other products didn't adopt F2FS until the Pixel 3 when F2FS was updated with inline crypto hardware support. [19]

Huawei has used F2FS since the Huawei P9 in 2016. [20] [21] OnePlus has used F2FS in the OnePlus 3T. [22]

Motorola Mobility has used F2FS in their Moto G/E/X and Droid phones since 2012.

ZTE has used F2FS since the ZTE Axon 10 Pro in 2019. [23]

Linux distributions

F2FS has been merged into Linux kernel in late 2012. [24] Many distributions support it. [25] [26] [27]

Detailed features description

Feature nameDescriptionKernel versionF2FS tools versionKernel commitF2FS tools commit
Lost parent inode number (pino) bitIf a file is linked, F2FS may loose its parent inode number so that fsync calls for the linked file need to perform the checkpoint every time. But, if the pino can be recovered after the checkpoint, roll-forward mechanism for the further fsync calls can be adjusted, which improves the fsync performance significantly.3.11N/A354a3399dc6f ("f2fs: recover wrong pino after checkpoint during fsync")N/A
Inline extended attributesAdd a mount option inline_xattr, which is enabled when xattr is set, if the mount option is enabled, all the files are marked with the inline_xattrs flag.3.121.2.0444c580f7e9a ("f2fs: add flags for inline xattrs")cd1e470 ("fsck, lib: support inline xattr")
Inline dataSupport inline data in regular/symlink inode via inline_data mount option.3.141.3.01001b3479ce9 ("f2fs: add flags and helpers to support inline data")061ee67 ("f2fs-tools: add inline data check")
Large directoryAdd a parameter to adjust structure of large directory for lookup performance tuning.3.151.4.03843154598a0 ("f2fs: introduce large directory support")99250ec ("mkfs: support large directory")
Large volumeSupport for large volumes over around 3TB.3.161.4.01dbe4152168d ("f2fs: large volume support")092e3d9 ("mkfs.f2fs: large volume support")
Fsck flagAdds "need fsck" flag to superblock to conduct fsck.f2fs later, this flag can only be removed by fsck.f2fs.3.181.4.02ae4c673e3cb ("f2fs: retain inconsistency information to initiate fsck.f2fs")7eb6c5a ("fsck.f2fs: add auto_fix feature")
Fastboot flagAllow checkpoint write node summaries to speed up boot after a sudden poweroff.3.21.4.1119ee9144534 ("f2fs: split UMOUNT and FASTBOOT flags")b57708a ("dump.f2fs: show checkpoint flag")
Inline data (fix)Enhance stability of inline_data feature (changes disk layout).3.191.4.1b3d208f96d6b ("f2fs: revisit inline_data to avoid data races and potential bugs")7279f03 ("fsck.f2fs: fix DATA_EXIST flag for old partition")
Inline dentrySupport storing of directory entries in the directory inode.3.191.4.134d67debe02b ("f2fs: add infra struct and helper for inline dir")6d88640 ("fsck.f2fs: support inline_dentry")
Version infoStores current kernel version, updated on fsck.4.21.4.10040b933187b ("f2fs: add missing version info in superblock")6fa2547 ("fsck.f2fs: trigger fsck.f2fs when new change was made")
Initial version infoIdentifies the Linux kernel version when the format was done.4.21.4.10040b933187b ("f2fs: add missing version info in superblock")762eedf ("mkfs.f2fs: give a kernel version for initial format")
Keep size bitEnsures preallocated (with fallocate) file size does not change during roll-forward recovery.
If a file needs to keep its i_size set by fallocate, autorecovery needs to be turned off during roll-forward recovery		4.1N/A26787236b366 ("f2fs: do not activate auto_recovery for fallocated i_size")N/A
Inline dotsSupport to fix directory which has no '.' or '..' dentries, it changes disk layout4.11.5.0510022a85839 ("f2fs: add F2FS_INLINE_DOTS to recover missing dot dentries")f1e4f9c ("fsck.f2fs: fix missing dentries")
EncryptionEnables support for filesystem level encryption.4.21.5.0cde4de120577 ("f2fs crypto: declare some definitions for f2fs encryption feature")6e6c713 ("mkfs.f2fs: set encryption feature")
Block zonedSpecify F2FS filesystem to support the block zoned feature. It depends on multiple devices feature.4.81.7.052763a4b7a21 ("f2fs: detect host-managed SMR by feature flag")70a8fc3 ("mkfs/fsck: add host-managed smr feature")
Multiple devicesEnable support for multiple physical storage devices to be treated as a single logical volume4.11.8.03c62be17d4f5 ("f2fs: support multiple devices")de7e07e ("f2fs-tools: support multiple devices")
Trimmed flagOptimizes the handling of discarded blocks. This flag (CP_TRIMMED_FLAG) allows the F2FS kernel module to record that all invalid blocks were trimmed before umount, so on the next mount these operations can be skipped.4.121.9.01f43e2ad7bff ("f2fs: introduce CP_TRIMMED_FLAG to avoid unneeded discard")f642b24 ("f2fs-tools: support to set and recognize CP_TRIMMED_FLAG")
NAT bitsAdds bitmaps to represent empty/full NAT blocks containing all used/free nid entries to optimize the management of NAT blocks.4.111.9.022ad0b6ab466 ("f2fs: add bitmaps for empty or full NAT blocks")191573e ("mkfs.f2fs: support nat_bits feature")
CRC recoveryUse CRC in addition to checkpoint version during roll-forward recovery. This allows for a more robust and reliable way to determine which version of the file to recover.
Introduces new flag (CP_CRC_RECOVERY_FLAG) to indicate when the new mechanism is used.		4.91.9.0a468f0ef516f ("f2fs: use crc and cp version to determine roll-forward recovery")a0bd5b9 ("f2fs-tools: catch up up-to-date checkpoint flag")
Atomic writeAtomic write feature, this feature does not change disk layout.4.141.9.0e65ef20781cb ("f2fs: add ioctl to expose current features")8721519 ("f2fs-tools: add atomic_write feature flag")
Extra attributesEnable extra attributes feature, required for some of the other features (see below).4.141.9.07a2af766af15 ("f2fs: enhance on-disk inode structure scalability")dad33a1 ("f2fs-tools: enhance on-disk inode structure scalability")
Project quotaEnable project ID tracking for projet quota accounting. Uses extra attributes.4.141.9.05c57132eaf52 ("f2fs: support project quota")a3d9db1 ("f2fs-tools: support project quota")
Inode checksumEnable inode checksum. Uses extra attributes.4.141.9.0704956ecf5bc ("f2fs: support inode checksum")7457726 ("f2fs-tools: support inode checksum")
Nocrc recoveryDisables the use of CRC during the checkpoint recovery process relying solely on the checkpoint version.4.161.10.0f236792311f4 ("f2fs: allow to recover node blocks given updated checkpoint")f789444 ("fsck.f2fs: allow roll-forward for small checkpoint fix")
Flexible inline xattrEnable flexible inline xattr size. Uses extra attributes.4.151.10.06afc662e68b5 ("f2fs: support flexible inline xattr size")8d46072 ("f2fs-tools: support flexible inline xattr size")
Quota sysfileEnable quota feature (it allows F2FS to maintain an inner sysfile for disk quota data recording).4.151.10.0234a96896142 ("f2fs: add quota_ino feature infra")23a872f ("mkfs.f2fs: support quota option in mkfs")
PinfileSupport pinfile to avoid migration of its physical data blocks.4.161.12.01ad71a27124c ("f2fs: add an ioctl to disable GC for specific file")"91bb7b2 (""f2fs-tools: fix to reset i_gc_failures offline"")
820b5e3 (""sload.f2fs: use F2FS_COMPRESS_RELEASED instead of IMMUTABLE bit"") added the F2FS_PIN_FILE flag w/o any use."
Inode creation timeEnable inode creation time feature. Requires extra attributes.4.161.10.01c1d35df7110 ("f2fs: support inode creation time")4862080 ("f2fs-tools: support inode creation time")
Extended node bitmapEnable extended node bitmap to increase upper boundary limitation of node block count.4.171.11.0199bc3fef29c ("f2fs: support large nat bitmap")baaa076 ("mkfs.f2fs: expand scalability of nat bitmap")
Hot file extensionsAllows specifying a list of file extensions that F2FS will treat as hot files. The data of files with those extensions will be stored in the hot log.4.171.11.0b6a06cbbb5f7 ("f2fs: support hot file extension")6fdc37f ("mkfs.f2fs: support hot file extension")
lost+foundEnable lost+found feature.4.171.11.0b7c409deda6b ("f2fs: introduce F2FS_FEATURE_LOST_FOUND feature")ff37829 ("mkfs.f2fs: create lost+found directory")
fs-verityEnable support for verity protected files (a.k.a. fs-verity).5.41.11.095ae251fe828 ("f2fs: add fs-verity support")76cd377 ("mkfs.f2fs: support fsverity feature")
Checkpoint disable flagIndicate checkpoint is disabled.4.21.12.04354994f097d ("f2fs: checkpoint disabling")a48bda0 ("fsck.f2fs: support checkpoint=disable")
Quota needs fsckAdd a global state SBI_QUOTA_NEED_REPAIR to indicate that quota operation failed due to -EIO or -ENOSPC, so later,
a) checkpoint will skip syncing dquot metadata.
b) CP_QUOTA_NEED_FSCK_FLAG will be set in last cp pack to give a hint for fsck repairing.		4.21.12.0af033b2aa8a8 ("f2fs: guarantee journalled quota data by checkpoint")dfede78 ("fsck.f2fs: detect and recover corrupted quota file")
Superblock checksumEnable superblock checksum.4.21.12.0d440c52d3151 ("f2fs: support superblock checksum")886a924 ("f2fs-tools: introduce sb checksum")
Checkpoint disable quickAdd a quick method of checkpoint disabling.5.1N/Adb610a640eee ("f2fs: add quick mode of checkpoint=disable for QA")N/A
CasefoldingEnable casefolding support in the filesystem. Optional flags can be passed with -C.5.41.13.05aba54302a46 ("f2fs: include charset encoding information in the superblock")ce64ea0 ("f2fs-tools: Add support for Casefolding")
CompressionEnable support for filesystem level compression. Requires extra attributes.5.61.14.04c8ff7095bef ("f2fs: support data compression")fdd47b2 ("f2fs-tools: support data compression")
Resize FS flagIntroduces a new checkpoint flag, CP_RESIZEFS_FLAG, to help fsck fix issues related to online resizing.5.71.14.0c84ef3c5e65c ("f2fs: Add a new CP flag to help fsck fix resize SPO issues")9a31cef ("fsck.f2fs: allow fsck to fix issues with online resize due to SPO")
Compression (fix)This change introduces a new flag (F2FS_COMPRESS_RELEASED) to represent the status of the released compressed blocks. Previously used IMMUTABLE bit prevented all operations on the released block.5.141.15.0c61404153eb6 ("f2fs: introduce FI_COMPRESS_RELEASED instead of using IMMUTABLE bit")820b5e3 ("sload.f2fs: use F2FS_COMPRESS_RELEASED instead of IMMUTABLE bit")
Readonly imageEnable readonly feature to eliminate OVP/SSA on-disk layout for small readonly partition.5.141.15.0a7d9fe3c3388 ("f2fs: support RO feature")1d2683f ("f2fs-tools: support small RO partition")
Trunc bit"Direct IO (DIO) preallocates physical blocks before writing actual data, but if an error occurrs or a power-cut happens, the unwritten blocks' contents can be accessed by the user. This patch fixes it by:
1) turning to buffered writes for DIO into holes
2) truncating unwritten blocks from error or power-cut."		5.17N/Ad4dd19ec1ea0 ("f2fs: do not expose unwritten blocks to user by DIO")N/A
CP error recordingSupports recording the detailed stop checkpoint error into f2fs_super_block.s_stop_reason[].6.11.16.0a9cfee0ef98e ("f2fs: support recording stop_checkpoint reason into super_block")2f1dde2 ("fsck.f2fs: trigger repairing if filesystem was forced to stop")
FS error recordingSupports recording the detailed reason of FSCORRUPTED error into f2fs_super_block.s_errors[].6.11.16.095fa90c9e5a7 ("f2fs: support recording errors into superblock")8cbe34e ("fsck.f2fs: trigger repairing if filesystem has inconsistent errors")
Device aliasEnables device aliasing feature.6.13Not released yet128d333f0dff ("f2fs: introduce device aliasing file")8cc4e25 ("mkfs.f2fs: add device aliasing feature")

See also

References

  1. ↑ Michael Larabel (2012-12-22). "F2FS File-System Merged Into Linux 3.8 Kernel". Phoronix . Retrieved 2016-05-25.
  2. ↑ Jaegeuk Kim (2013-03-18). "f2fs: align f2fs maximum name length to linux based filesystem". GitHub . Retrieved 2023-05-16.
  3. 1 2 Michael Larabel (2019-12-23). "F2FS Data Compression Using LZO/LZ4 + Selective File Extension Handling To Land In 2020". Phoronix. Retrieved 2020-04-07.
  4. 1 2 Michael Larabel (2020-04-07). "F2FS Introduces Zstd Compression Support With The Linux 5.7 Kernel". Phoronix. Retrieved 2020-04-07.
  5. 1 2 Jaegeuk Kim (2012-10-05). "f2fs: introduce flash-friendly file system" . Retrieved 2016-05-25.
  6. ↑ f2fs: fix to force keeping write barrier for strict fsync mode.
  7. ↑ Jaegeuk Kim (2014-09-22). "f2fs: introduce FITRIM in f2fs_ioctl". Linux kernel mailing list (Mailing list). Retrieved 2025-01-02.
  8. ↑ Chao Yu (2015-10-26). "f2fs: support file defragment".
  9. ↑ Jaegeuk Kim (2013-08-26). "f2fs: add flags for inline xattrs".
  10. ↑ Huajun Li (2013-11-10). "f2fs: Enable f2fs support inline data".
  11. ↑ Chao Yu (2014-09-24). "f2fs: support inline dir".
  12. ↑ Jaegeuk Kim (2014-09-20). "f2fs-tools: release 1.4.0".
  13. ↑ Jaegeuk Kim (2014-09-25). "f2fs: support atomic_write feature for database".
  14. ↑ Jaegeuk Kim (2015-06-24). "f2fs updates for v4.2".
  15. ↑ Jaegeuk Kim (2016-04-25). "resize.f2fs: support to expand partition size".
  16. ↑ Chao Yu (2015-12-17). "f2fs: support data flush in background".
  17. ↑ Chao Yu (2015-01-25). "f2fs: enable rb-tree extent cache".
  18. ↑ Ho, Joshua; Smith, Ryan. "The Google Nexus 9 Review". www.anandtech.com. Retrieved 2019-05-10.
  19. ↑ Frumusanu, Andrei (2018-11-02). "The Google Pixel 3 Review". www.anandtech.com. Retrieved 2019-05-11.
  20. ↑ Larabel, Michael (2018-12-28). "F2FS Gets More Fixes In Linux 4.21 With The File-System Now Supported By Google's Pixel". www.phoronix.com. Retrieved 2019-05-10.
  21. ↑ Humrick, Matt (2017-05-12). "Huawei P10 and P10 Plus". www.anandtech.com. Retrieved 2019-05-11.
  22. ↑ Chester, Brandon. "The OnePlus 3T Review". www.anandtech.com. Retrieved 2019-05-10.
  23. ↑ "ZTE Axon 10 Pro Officially Uncovered: The First To Use F2FS". Gizchina.com. 2019-05-06. Retrieved 2019-05-10.
  24. ↑ "Pull new F2FS filesystem from Jaegeuk Kim commit". git.kernel.org.
  25. ↑ "Arch Linux Wiki". wiki.archlinux.org. Retrieved 27 June 2021.
  26. ↑ "Debian Wiki". wiki.debian.org. Retrieved 27 June 2021.
  27. ↑ "Gentoo Wiki". wiki.gentoo.org. Retrieved 27 June 2021.


This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.