From ArchWiki
Jump to navigation Jump to search

F2FS (Flash-Friendly File System) is a file system intended for NAND-based flash memory equipped with Flash Translation Layer. Unlike JFFS or UBIFS it relies on FTL to handle write distribution. It is supported from kernel 3.8 onwards.

An FTL is found in all flash memory with a SCSI/SATA/PCIe/NVMe interface [1], opposed to bare NAND Flash and SmartMediaCards [2].

Creating a F2FS file system

In order to create a F2FS file system, install f2fs-tools.

Create the file system:

# mkfs.f2fs -l mylabel /dev/sdxY

where /dev/sdxY is the target volume to format in F2FS. See mkfs.f2fs(8) for all available options.


If you want to use compression, you must provide extra_attr and compression options at filesystem creation. Example:

# mkfs.f2fs -l mylabel -O extra_attr,compression /dev/sdxY

When mounting the filesystem, you will have to specify compress_algorithm=(lzo|lz4|zstd|lzo-rle). Using compress_extension=txt will cause all txt files to be compressed by default.

In order to tell F2FS to compress a file or a directory, use :

$ chattr -R +c [FOLDER]

Inode and superblock checksums

Some filesystem options can be used to help f2fs.fsck do its job in case of a corrupted filesystem. These are especially useful if you use filesystem compression. Theses options are inode_checksum and sb_checksum. Add them in the options list given to mkfs.f2fs when creating your partition.

If enabled, these options allow f2fs.fsck to easily detect corrupted inodes and in some cases it can fix them.

File-based encryption support

Since Linux 4.2, F2FS natively supports file encryption. Encryption is applied at the directory level, and different directories can use different encryption keys. This is different from both dm-crypt, which is block-device level encryption, and from eCryptfs, which is a stacked cryptographic filesystem. To use F2FS's native encryption support, see the fscrypt article. Create the file system with

 # mkfs.f2fs -l mylabel -O encrypt /dev/sdxY

or add encryption capability at a later time with fsck.f2fs -O encrypt /dev/sdxY.

Mounting a F2FS file system

The file system can then be mounted manually or via other mechanisms:

# mount /dev/sdxY /mnt/foo

Implementation of discard

By default, F2FS partitions are mounted using a hybrid TRIM mode which behaves as continuous TRIM. This implementation creates asynchronous discard threads to alleviate long discarding latency among RW IOs. It keeps candidates in memory, and the thread issues them in idle time [3]. As a result of this, users wanting periodic TRIM will need to implicitly set the nodiscard mount option in /etc/fstab or pass it to mount if mounting manually.

Checking and repair

Checking and repairs to f2fs file systems are accomplished with fsck.f2fs provided by f2fs-tools. See fsck.f2fs(8) for available switches.

Grow an F2FS file system

When the filesystem is unmounted, it can be grown if the partition is expanded. Shrinking is not currently supported.

First use a partition tool to resize the partition: for example, suppose the output of the print command in the parted console for your disk is the following:

Number  Start   End     Size        File system     Name                  Flag
 1      1049kB  106MB   105MB       fat32           EFI system partition  boot, esp
 2      106MB   11,0GB  10,9GB      ext4
 3      11,0GB  12,3GB  1322MB      f2fs
 4      31,0GB  31,3GB  261MB       ext4

To resize the f2fs partition to occupy all the space up to the fourth one, just give resizepart 3 31GB and exit. You can now expand the filesystem to fill the new partition using:

# resize.f2fs /dev/sdxY

where /dev/sdxY is the target F2FS volume to grow. See resize.f2fs(8) for supported options.

Note: If you're using GPT, the partition's GUID (seen in /dev/disk/by-partuuid/) might change, but the filesystem UUID (seen in /dev/disk/by-uuid/) should stay the same.

Known issues

Long running fsck delays boot

If the kernel version has changed between boots, the fsck.f2fs utility will perform a full file system check which will take longer to finish[4].

This may be mitigated in the future thanks to a recent commit [5]