Commit | Line | Data |
---|---|---|
89272ca1 MCC |
1 | .. SPDX-License-Identifier: GPL-2.0 |
2 | ||
3 | ========================================== | |
98e4da8c | 4 | WHAT IS Flash-Friendly File System (F2FS)? |
89272ca1 | 5 | ========================================== |
98e4da8c JK |
6 | |
7 | NAND flash memory-based storage devices, such as SSD, eMMC, and SD cards, have | |
8 | been equipped on a variety systems ranging from mobile to server systems. Since | |
9 | they are known to have different characteristics from the conventional rotating | |
10 | disks, a file system, an upper layer to the storage device, should adapt to the | |
11 | changes from the sketch in the design level. | |
12 | ||
13 | F2FS is a file system exploiting NAND flash memory-based storage devices, which | |
14 | is based on Log-structured File System (LFS). The design has been focused on | |
15 | addressing the fundamental issues in LFS, which are snowball effect of wandering | |
16 | tree and high cleaning overhead. | |
17 | ||
18 | Since a NAND flash memory-based storage device shows different characteristic | |
19 | according to its internal geometry or flash memory management scheme, namely FTL, | |
20 | F2FS and its tools support various parameters not only for configuring on-disk | |
21 | layout, but also for selecting allocation and cleaning algorithms. | |
22 | ||
d51a7fba CL |
23 | The following git tree provides the file system formatting tool (mkfs.f2fs), |
24 | a consistency checking tool (fsck.f2fs), and a debugging tool (dump.f2fs). | |
89272ca1 MCC |
25 | |
26 | - git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs-tools.git | |
5bb446a2 | 27 | |
398bb30d | 28 | For sending patches, please use the following mailing list: |
98e4da8c | 29 | |
89272ca1 MCC |
30 | - linux-f2fs-devel@lists.sourceforge.net |
31 | ||
398bb30d CY |
32 | For reporting bugs, please use the following f2fs bug tracker link: |
33 | ||
34 | - https://bugzilla.kernel.org/enter_bug.cgi?product=File%20System&component=f2fs | |
35 | ||
89272ca1 MCC |
36 | Background and Design issues |
37 | ============================ | |
98e4da8c JK |
38 | |
39 | Log-structured File System (LFS) | |
40 | -------------------------------- | |
41 | "A log-structured file system writes all modifications to disk sequentially in | |
42 | a log-like structure, thereby speeding up both file writing and crash recovery. | |
43 | The log is the only structure on disk; it contains indexing information so that | |
44 | files can be read back from the log efficiently. In order to maintain large free | |
45 | areas on disk for fast writing, we divide the log into segments and use a | |
46 | segment cleaner to compress the live information from heavily fragmented | |
47 | segments." from Rosenblum, M. and Ousterhout, J. K., 1992, "The design and | |
48 | implementation of a log-structured file system", ACM Trans. Computer Systems | |
49 | 10, 1, 26–52. | |
50 | ||
51 | Wandering Tree Problem | |
52 | ---------------------- | |
53 | In LFS, when a file data is updated and written to the end of log, its direct | |
54 | pointer block is updated due to the changed location. Then the indirect pointer | |
55 | block is also updated due to the direct pointer block update. In this manner, | |
56 | the upper index structures such as inode, inode map, and checkpoint block are | |
57 | also updated recursively. This problem is called as wandering tree problem [1], | |
58 | and in order to enhance the performance, it should eliminate or relax the update | |
59 | propagation as much as possible. | |
60 | ||
61 | [1] Bityutskiy, A. 2005. JFFS3 design issues. http://www.linux-mtd.infradead.org/ | |
62 | ||
63 | Cleaning Overhead | |
64 | ----------------- | |
65 | Since LFS is based on out-of-place writes, it produces so many obsolete blocks | |
66 | scattered across the whole storage. In order to serve new empty log space, it | |
67 | needs to reclaim these obsolete blocks seamlessly to users. This job is called | |
68 | as a cleaning process. | |
69 | ||
70 | The process consists of three operations as follows. | |
89272ca1 | 71 | |
98e4da8c JK |
72 | 1. A victim segment is selected through referencing segment usage table. |
73 | 2. It loads parent index structures of all the data in the victim identified by | |
74 | segment summary blocks. | |
75 | 3. It checks the cross-reference between the data and its parent index structure. | |
76 | 4. It moves valid data selectively. | |
77 | ||
78 | This cleaning job may cause unexpected long delays, so the most important goal | |
79 | is to hide the latencies to users. And also definitely, it should reduce the | |
80 | amount of valid data to be moved, and move them quickly as well. | |
81 | ||
89272ca1 MCC |
82 | Key Features |
83 | ============ | |
98e4da8c JK |
84 | |
85 | Flash Awareness | |
86 | --------------- | |
87 | - Enlarge the random write area for better performance, but provide the high | |
88 | spatial locality | |
89 | - Align FS data structures to the operational units in FTL as best efforts | |
90 | ||
91 | Wandering Tree Problem | |
92 | ---------------------- | |
93 | - Use a term, “node”, that represents inodes as well as various pointer blocks | |
94 | - Introduce Node Address Table (NAT) containing the locations of all the “node” | |
95 | blocks; this will cut off the update propagation. | |
96 | ||
97 | Cleaning Overhead | |
98 | ----------------- | |
99 | - Support a background cleaning process | |
100 | - Support greedy and cost-benefit algorithms for victim selection policies | |
101 | - Support multi-head logs for static/dynamic hot and cold data separation | |
102 | - Introduce adaptive logging for efficient block allocation | |
103 | ||
89272ca1 MCC |
104 | Mount Options |
105 | ============= | |
98e4da8c | 106 | |
89272ca1 | 107 | |
9aa1ccb4 JC |
108 | ======================== ============================================================ |
109 | background_gc=%s Turn on/off cleaning operations, namely garbage | |
110 | collection, triggered in background when I/O subsystem is | |
111 | idle. If background_gc=on, it will turn on the garbage | |
112 | collection and if background_gc=off, garbage collection | |
113 | will be turned off. If background_gc=sync, it will turn | |
114 | on synchronous garbage collection running in background. | |
115 | Default value for this option is on. So garbage | |
116 | collection is on by default. | |
5911d2d1 CY |
117 | gc_merge When background_gc is on, this option can be enabled to |
118 | let background GC thread to handle foreground GC requests, | |
119 | it can eliminate the sluggish issue caused by slow foreground | |
120 | GC operation when GC is triggered from a process with limited | |
121 | I/O and CPU resources. | |
122 | nogc_merge Disable GC merge feature. | |
9aa1ccb4 JC |
123 | disable_roll_forward Disable the roll-forward recovery routine |
124 | norecovery Disable the roll-forward recovery routine, mounted read- | |
125 | only (i.e., -o ro,disable_roll_forward) | |
126 | discard/nodiscard Enable/disable real-time discard in f2fs, if discard is | |
127 | enabled, f2fs will issue discard/TRIM commands when a | |
128 | segment is cleaned. | |
129 | no_heap Disable heap-style segment allocation which finds free | |
130 | segments for data from the beginning of main area, while | |
131 | for node from the end of main area. | |
132 | nouser_xattr Disable Extended User Attributes. Note: xattr is enabled | |
133 | by default if CONFIG_F2FS_FS_XATTR is selected. | |
134 | noacl Disable POSIX Access Control List. Note: acl is enabled | |
135 | by default if CONFIG_F2FS_FS_POSIX_ACL is selected. | |
136 | active_logs=%u Support configuring the number of active logs. In the | |
137 | current design, f2fs supports only 2, 4, and 6 logs. | |
138 | Default number is 6. | |
139 | disable_ext_identify Disable the extension list configured by mkfs, so f2fs | |
ca313c82 | 140 | is not aware of cold files such as media files. |
9aa1ccb4 JC |
141 | inline_xattr Enable the inline xattrs feature. |
142 | noinline_xattr Disable the inline xattrs feature. | |
143 | inline_xattr_size=%u Support configuring inline xattr size, it depends on | |
144 | flexible inline xattr feature. | |
ca313c82 | 145 | inline_data Enable the inline data feature: Newly created small (<~3.4k) |
9aa1ccb4 | 146 | files can be written into inode block. |
ca313c82 | 147 | inline_dentry Enable the inline dir feature: data in newly created |
9aa1ccb4 JC |
148 | directory entries can be written into inode block. The |
149 | space of inode block which is used to store inline | |
150 | dentries is limited to ~3.4k. | |
151 | noinline_dentry Disable the inline dentry feature. | |
152 | flush_merge Merge concurrent cache_flush commands as much as possible | |
153 | to eliminate redundant command issues. If the underlying | |
154 | device handles the cache_flush command relatively slowly, | |
155 | recommend to enable this option. | |
156 | nobarrier This option can be used if underlying storage guarantees | |
157 | its cached data should be written to the novolatile area. | |
158 | If this option is set, no cache_flush commands are issued | |
159 | but f2fs still guarantees the write ordering of all the | |
160 | data writes. | |
a9e292f2 | 161 | barrier If this option is set, cache_flush commands are allowed to be |
6047de54 | 162 | issued. |
9aa1ccb4 JC |
163 | fastboot This option is used when a system wants to reduce mount |
164 | time as much as possible, even though normal performance | |
165 | can be sacrificed. | |
166 | extent_cache Enable an extent cache based on rb-tree, it can cache | |
167 | as many as extent which map between contiguous logical | |
168 | address and physical address per inode, resulting in | |
169 | increasing the cache hit ratio. Set by default. | |
170 | noextent_cache Disable an extent cache based on rb-tree explicitly, see | |
171 | the above extent_cache mount option. | |
172 | noinline_data Disable the inline data feature, inline data feature is | |
173 | enabled by default. | |
174 | data_flush Enable data flushing before checkpoint in order to | |
175 | persist data of regular and symlink. | |
176 | reserve_root=%d Support configuring reserved space which is used for | |
177 | allocation from a privileged user with specified uid or | |
178 | gid, unit: 4KB, the default limit is 0.2% of user blocks. | |
179 | resuid=%d The user ID which may use the reserved blocks. | |
180 | resgid=%d The group ID which may use the reserved blocks. | |
181 | fault_injection=%d Enable fault injection in all supported types with | |
182 | specified injection rate. | |
183 | fault_type=%d Support configuring fault injection type, should be | |
184 | enabled with fault_injection option, fault type value | |
185 | is shown below, it supports single or combined type. | |
89272ca1 | 186 | |
9aa1ccb4 JC |
187 | =================== =========== |
188 | Type_Name Type_Value | |
189 | =================== =========== | |
190 | FAULT_KMALLOC 0x000000001 | |
191 | FAULT_KVMALLOC 0x000000002 | |
192 | FAULT_PAGE_ALLOC 0x000000004 | |
193 | FAULT_PAGE_GET 0x000000008 | |
b96d9b3b | 194 | FAULT_ALLOC_BIO 0x000000010 (obsolete) |
9aa1ccb4 JC |
195 | FAULT_ALLOC_NID 0x000000020 |
196 | FAULT_ORPHAN 0x000000040 | |
197 | FAULT_BLOCK 0x000000080 | |
198 | FAULT_DIR_DEPTH 0x000000100 | |
199 | FAULT_EVICT_INODE 0x000000200 | |
200 | FAULT_TRUNCATE 0x000000400 | |
201 | FAULT_READ_IO 0x000000800 | |
202 | FAULT_CHECKPOINT 0x000001000 | |
203 | FAULT_DISCARD 0x000002000 | |
204 | FAULT_WRITE_IO 0x000004000 | |
32410577 | 205 | FAULT_SLAB_ALLOC 0x000008000 |
10a26878 | 206 | FAULT_DQUOT_INIT 0x000010000 |
3e020389 | 207 | FAULT_LOCK_OP 0x000020000 |
18792e64 | 208 | FAULT_BLKADDR 0x000040000 |
9aa1ccb4 JC |
209 | =================== =========== |
210 | mode=%s Control block allocation mode which supports "adaptive" | |
211 | and "lfs". In "lfs" mode, there should be no random | |
212 | writes towards main area. | |
6691d940 DJ |
213 | "fragment:segment" and "fragment:block" are newly added here. |
214 | These are developer options for experiments to simulate filesystem | |
215 | fragmentation/after-GC situation itself. The developers use these | |
216 | modes to understand filesystem fragmentation/after-GC condition well, | |
217 | and eventually get some insights to handle them better. | |
218 | In "fragment:segment", f2fs allocates a new segment in ramdom | |
219 | position. With this, we can simulate the after-GC condition. | |
220 | In "fragment:block", we can scatter block allocation with | |
221 | "max_fragment_chunk" and "max_fragment_hole" sysfs nodes. | |
222 | We added some randomness to both chunk and hole size to make | |
223 | it close to realistic IO pattern. So, in this mode, f2fs will allocate | |
224 | 1..<max_fragment_chunk> blocks in a chunk and make a hole in the | |
225 | length of 1..<max_fragment_hole> by turns. With this, the newly | |
226 | allocated blocks will be scattered throughout the whole partition. | |
227 | Note that "fragment:block" implicitly enables "fragment:segment" | |
228 | option for more randomness. | |
229 | Please, use these options for your experiments and we strongly | |
230 | recommend to re-format the filesystem after using these options. | |
9aa1ccb4 JC |
231 | io_bits=%u Set the bit size of write IO requests. It should be set |
232 | with "mode=lfs". | |
233 | usrquota Enable plain user disk quota accounting. | |
234 | grpquota Enable plain group disk quota accounting. | |
235 | prjquota Enable plain project quota accounting. | |
236 | usrjquota=<file> Appoint specified file and type during mount, so that quota | |
237 | grpjquota=<file> information can be properly updated during recovery flow, | |
238 | prjjquota=<file> <quota file>: must be in root directory; | |
239 | jqfmt=<quota type> <quota type>: [vfsold,vfsv0,vfsv1]. | |
ca313c82 RD |
240 | offusrjquota Turn off user journalled quota. |
241 | offgrpjquota Turn off group journalled quota. | |
242 | offprjjquota Turn off project journalled quota. | |
9aa1ccb4 JC |
243 | quota Enable plain user disk quota accounting. |
244 | noquota Disable all plain disk quota option. | |
9aa1ccb4 JC |
245 | alloc_mode=%s Adjust block allocation policy, which supports "reuse" |
246 | and "default". | |
247 | fsync_mode=%s Control the policy of fsync. Currently supports "posix", | |
248 | "strict", and "nobarrier". In "posix" mode, which is | |
249 | default, fsync will follow POSIX semantics and does a | |
250 | light operation to improve the filesystem performance. | |
251 | In "strict" mode, fsync will be heavy and behaves in line | |
252 | with xfs, ext4 and btrfs, where xfstest generic/342 will | |
253 | pass, but the performance will regress. "nobarrier" is | |
254 | based on "posix", but doesn't issue flush command for | |
255 | non-atomic files likewise "nobarrier" mount option. | |
ed318a6c EB |
256 | test_dummy_encryption |
257 | test_dummy_encryption=%s | |
9aa1ccb4 JC |
258 | Enable dummy encryption, which provides a fake fscrypt |
259 | context. The fake fscrypt context is used by xfstests. | |
260 | The argument may be either "v1" or "v2", in order to | |
261 | select the corresponding fscrypt policy version. | |
262 | checkpoint=%s[:%u[%]] Set to "disable" to turn off checkpointing. Set to "enable" | |
263 | to reenable checkpointing. Is enabled by default. While | |
264 | disabled, any unmounting or unexpected shutdowns will cause | |
265 | the filesystem contents to appear as they did when the | |
266 | filesystem was mounted with that option. | |
562abda4 | 267 | While mounting with checkpoint=disable, the filesystem must |
9aa1ccb4 JC |
268 | run garbage collection to ensure that all available space can |
269 | be used. If this takes too much time, the mount may return | |
270 | EAGAIN. You may optionally add a value to indicate how much | |
271 | of the disk you would be willing to temporarily give up to | |
272 | avoid additional garbage collection. This can be given as a | |
273 | number of blocks, or as a percent. For instance, mounting | |
274 | with checkpoint=disable:100% would always succeed, but it may | |
275 | hide up to all remaining free space. The actual space that | |
276 | would be unusable can be viewed at /sys/fs/f2fs/<disk>/unusable | |
277 | This space is reclaimed once checkpoint=enable. | |
261eeb9c DJ |
278 | checkpoint_merge When checkpoint is enabled, this can be used to create a kernel |
279 | daemon and make it to merge concurrent checkpoint requests as | |
280 | much as possible to eliminate redundant checkpoint issues. Plus, | |
281 | we can eliminate the sluggish issue caused by slow checkpoint | |
282 | operation when the checkpoint is done in a process context in | |
283 | a cgroup having low i/o budget and cpu shares. To make this | |
284 | do better, we set the default i/o priority of the kernel daemon | |
285 | to "3", to give one higher priority than other kernel threads. | |
286 | This is the same way to give a I/O priority to the jbd2 | |
287 | journaling thread of ext4 filesystem. | |
288 | nocheckpoint_merge Disable checkpoint merge feature. | |
9aa1ccb4 JC |
289 | compress_algorithm=%s Control compress algorithm, currently f2fs supports "lzo", |
290 | "lz4", "zstd" and "lzo-rle" algorithm. | |
3fde13f8 CY |
291 | compress_algorithm=%s:%d Control compress algorithm and its compress level, now, only |
292 | "lz4" and "zstd" support compress level config. | |
293 | algorithm level range | |
294 | lz4 3 - 16 | |
295 | zstd 1 - 22 | |
622d6f19 RD |
296 | compress_log_size=%u Support configuring compress cluster size. The size will |
297 | be 4KB * (1 << %u). The default and minimum sizes are 16KB. | |
9aa1ccb4 JC |
298 | compress_extension=%s Support adding specified extension, so that f2fs can enable |
299 | compression on those corresponding files, e.g. if all files | |
300 | with '.ext' has high compression rate, we can set the '.ext' | |
301 | on compression extension list and enable compression on | |
302 | these file by default rather than to enable it via ioctl. | |
303 | For other files, we can still enable compression via ioctl. | |
086ba2ec LT |
304 | Note that, there is one reserved special extension '*', it |
305 | can be set to enable compression for all files. | |
8c3b0188 | 306 | nocompress_extension=%s Support adding specified extension, so that f2fs can disable |
151b1982 FC |
307 | compression on those corresponding files, just contrary to compression extension. |
308 | If you know exactly which files cannot be compressed, you can use this. | |
309 | The same extension name can't appear in both compress and nocompress | |
310 | extension at the same time. | |
311 | If the compress extension specifies all files, the types specified by the | |
312 | nocompress extension will be treated as special cases and will not be compressed. | |
313 | Don't allow use '*' to specifie all file in nocompress extension. | |
314 | After add nocompress_extension, the priority should be: | |
315 | dir_flag < comp_extention,nocompress_extension < comp_file_flag,no_comp_file_flag. | |
316 | See more in compression sections. | |
317 | ||
b28f047b | 318 | compress_chksum Support verifying chksum of raw data in compressed cluster. |
602a16d5 DJ |
319 | compress_mode=%s Control file compression mode. This supports "fs" and "user" |
320 | modes. In "fs" mode (default), f2fs does automatic compression | |
321 | on the compression enabled files. In "user" mode, f2fs disables | |
322 | the automaic compression and gives the user discretion of | |
323 | choosing the target file and the timing. The user can do manual | |
324 | compression/decompression on the compression enabled files using | |
325 | ioctls. | |
6ce19aff CY |
326 | compress_cache Support to use address space of a filesystem managed inode to |
327 | cache compressed block, in order to improve cache hit ratio of | |
328 | random read. | |
2324d50d LT |
329 | inlinecrypt When possible, encrypt/decrypt the contents of encrypted |
330 | files using the blk-crypto framework rather than | |
331 | filesystem-layer encryption. This allows the use of | |
332 | inline encryption hardware. The on-disk format is | |
333 | unaffected. For more details, see | |
334 | Documentation/block/inline-encryption.rst. | |
093749e2 CY |
335 | atgc Enable age-threshold garbage collection, it provides high |
336 | effectiveness and efficiency on background GC. | |
4f993264 CY |
337 | discard_unit=%s Control discard unit, the argument can be "block", "segment" |
338 | and "section", issued discard command's offset/size will be | |
339 | aligned to the unit, by default, "discard_unit=block" is set, | |
340 | so that small discard functionality is enabled. | |
341 | For blkzoned device, "discard_unit=section" will be set by | |
342 | default, it is helpful for large sized SMR or ZNS devices to | |
343 | reduce memory cost by getting rid of fs metadata supports small | |
344 | discard. | |
7a8fc586 DJ |
345 | memory=%s Control memory mode. This supports "normal" and "low" modes. |
346 | "low" mode is introduced to support low memory devices. | |
347 | Because of the nature of low memory devices, in this mode, f2fs | |
348 | will try to save memory sometimes by sacrificing performance. | |
349 | "normal" mode is the default mode and same as before. | |
71644dff JK |
350 | age_extent_cache Enable an age extent cache based on rb-tree. It records |
351 | data block update frequency of the extent per inode, in | |
352 | order to provide better temperature hints for data block | |
353 | allocation. | |
b62e71be CY |
354 | errors=%s Specify f2fs behavior on critical errors. This supports modes: |
355 | "panic", "continue" and "remount-ro", respectively, trigger | |
356 | panic immediately, continue without doing anything, and remount | |
357 | the partition in read-only mode. By default it uses "continue" | |
358 | mode. | |
359 | ====================== =============== =============== ======== | |
360 | mode continue remount-ro panic | |
361 | ====================== =============== =============== ======== | |
d56b699d | 362 | access ops normal normal N/A |
b62e71be CY |
363 | syscall errors -EIO -EROFS N/A |
364 | mount option rw ro N/A | |
365 | pending dir write keep keep N/A | |
366 | pending non-dir write drop keep N/A | |
367 | pending node write drop keep N/A | |
368 | pending meta write keep keep N/A | |
369 | ====================== =============== =============== ======== | |
9aa1ccb4 | 370 | ======================== ============================================================ |
98e4da8c | 371 | |
89272ca1 MCC |
372 | Debugfs Entries |
373 | =============== | |
98e4da8c JK |
374 | |
375 | /sys/kernel/debug/f2fs/ contains information about all the partitions mounted as | |
376 | f2fs. Each file shows the whole f2fs information. | |
377 | ||
378 | /sys/kernel/debug/f2fs/status includes: | |
89272ca1 | 379 | |
98e4da8c JK |
380 | - major file system information managed by f2fs currently |
381 | - average SIT information about whole segments | |
382 | - current memory footprint consumed by f2fs. | |
383 | ||
89272ca1 MCC |
384 | Sysfs Entries |
385 | ============= | |
b59d0bae | 386 | |
6de3f12e | 387 | Information about mounted f2fs file systems can be found in |
b59d0bae NJ |
388 | /sys/fs/f2fs. Each mounted filesystem will have a directory in |
389 | /sys/fs/f2fs based on its device name (i.e., /sys/fs/f2fs/sda). | |
390 | The files in each per-device directory are shown in table below. | |
391 | ||
392 | Files in /sys/fs/f2fs/<devname> | |
393 | (see also Documentation/ABI/testing/sysfs-fs-f2fs) | |
5aba5430 | 394 | |
89272ca1 MCC |
395 | Usage |
396 | ===== | |
98e4da8c JK |
397 | |
398 | 1. Download userland tools and compile them. | |
399 | ||
400 | 2. Skip, if f2fs was compiled statically inside kernel. | |
89272ca1 MCC |
401 | Otherwise, insert the f2fs.ko module:: |
402 | ||
403 | # insmod f2fs.ko | |
98e4da8c | 404 | |
ca313c82 | 405 | 3. Create a directory to use when mounting:: |
98e4da8c | 406 | |
89272ca1 MCC |
407 | # mkdir /mnt/f2fs |
408 | ||
409 | 4. Format the block device, and then mount as f2fs:: | |
410 | ||
411 | # mkfs.f2fs -l label /dev/block_device | |
412 | # mount -t f2fs /dev/block_device /mnt/f2fs | |
98e4da8c | 413 | |
d51a7fba CL |
414 | mkfs.f2fs |
415 | --------- | |
416 | The mkfs.f2fs is for the use of formatting a partition as the f2fs filesystem, | |
417 | which builds a basic on-disk layout. | |
418 | ||
568d2a1e | 419 | The quick options consist of: |
89272ca1 MCC |
420 | |
421 | =============== =========================================================== | |
422 | ``-l [label]`` Give a volume label, up to 512 unicode name. | |
423 | ``-a [0 or 1]`` Split start location of each area for heap-based allocation. | |
424 | ||
425 | 1 is set by default, which performs this. | |
426 | ``-o [int]`` Set overprovision ratio in percent over volume size. | |
427 | ||
428 | 5 is set by default. | |
429 | ``-s [int]`` Set the number of segments per section. | |
430 | ||
431 | 1 is set by default. | |
432 | ``-z [int]`` Set the number of sections per zone. | |
433 | ||
434 | 1 is set by default. | |
435 | ``-e [str]`` Set basic extension list. e.g. "mp3,gif,mov" | |
436 | ``-t [0 or 1]`` Disable discard command or not. | |
437 | ||
438 | 1 is set by default, which conducts discard. | |
439 | =============== =========================================================== | |
98e4da8c | 440 | |
ca313c82 | 441 | Note: please refer to the manpage of mkfs.f2fs(8) to get full option list. |
568d2a1e | 442 | |
d51a7fba CL |
443 | fsck.f2fs |
444 | --------- | |
445 | The fsck.f2fs is a tool to check the consistency of an f2fs-formatted | |
446 | partition, which examines whether the filesystem metadata and user-made data | |
447 | are cross-referenced correctly or not. | |
448 | Note that, initial version of the tool does not fix any inconsistency. | |
449 | ||
568d2a1e | 450 | The quick options consist of:: |
89272ca1 | 451 | |
d51a7fba CL |
452 | -d debug level [default:0] |
453 | ||
ca313c82 | 454 | Note: please refer to the manpage of fsck.f2fs(8) to get full option list. |
568d2a1e | 455 | |
d51a7fba CL |
456 | dump.f2fs |
457 | --------- | |
458 | The dump.f2fs shows the information of specific inode and dumps SSA and SIT to | |
459 | file. Each file is dump_ssa and dump_sit. | |
460 | ||
461 | The dump.f2fs is used to debug on-disk data structures of the f2fs filesystem. | |
4bb9998d | 462 | It shows on-disk inode information recognized by a given inode number, and is |
d51a7fba CL |
463 | able to dump all the SSA and SIT entries into predefined files, ./dump_ssa and |
464 | ./dump_sit respectively. | |
465 | ||
89272ca1 MCC |
466 | The options consist of:: |
467 | ||
d51a7fba CL |
468 | -d debug level [default:0] |
469 | -i inode no (hex) | |
470 | -s [SIT dump segno from #1~#2 (decimal), for all 0~-1] | |
471 | -a [SSA dump segno from #1~#2 (decimal), for all 0~-1] | |
472 | ||
89272ca1 MCC |
473 | Examples:: |
474 | ||
475 | # dump.f2fs -i [ino] /dev/sdx | |
476 | # dump.f2fs -s 0~-1 /dev/sdx (SIT dump) | |
477 | # dump.f2fs -a 0~-1 /dev/sdx (SSA dump) | |
d51a7fba | 478 | |
ca313c82 | 479 | Note: please refer to the manpage of dump.f2fs(8) to get full option list. |
568d2a1e JK |
480 | |
481 | sload.f2fs | |
482 | ---------- | |
d56b699d | 483 | The sload.f2fs gives a way to insert files and directories in the existing disk |
568d2a1e JK |
484 | image. This tool is useful when building f2fs images given compiled files. |
485 | ||
ca313c82 | 486 | Note: please refer to the manpage of sload.f2fs(8) to get full option list. |
568d2a1e JK |
487 | |
488 | resize.f2fs | |
489 | ----------- | |
ca313c82 | 490 | The resize.f2fs lets a user resize the f2fs-formatted disk image, while preserving |
568d2a1e JK |
491 | all the files and directories stored in the image. |
492 | ||
ca313c82 | 493 | Note: please refer to the manpage of resize.f2fs(8) to get full option list. |
568d2a1e JK |
494 | |
495 | defrag.f2fs | |
496 | ----------- | |
ca313c82 | 497 | The defrag.f2fs can be used to defragment scattered written data as well as |
568d2a1e JK |
498 | filesystem metadata across the disk. This can improve the write speed by giving |
499 | more free consecutive space. | |
500 | ||
ca313c82 | 501 | Note: please refer to the manpage of defrag.f2fs(8) to get full option list. |
568d2a1e JK |
502 | |
503 | f2fs_io | |
504 | ------- | |
505 | The f2fs_io is a simple tool to issue various filesystem APIs as well as | |
506 | f2fs-specific ones, which is very useful for QA tests. | |
507 | ||
ca313c82 | 508 | Note: please refer to the manpage of f2fs_io(8) to get full option list. |
568d2a1e | 509 | |
89272ca1 MCC |
510 | Design |
511 | ====== | |
98e4da8c JK |
512 | |
513 | On-disk Layout | |
514 | -------------- | |
515 | ||
516 | F2FS divides the whole volume into a number of segments, each of which is fixed | |
517 | to 2MB in size. A section is composed of consecutive segments, and a zone | |
518 | consists of a set of sections. By default, section and zone sizes are set to one | |
519 | segment size identically, but users can easily modify the sizes by mkfs. | |
520 | ||
521 | F2FS splits the entire volume into six areas, and all the areas except superblock | |
ca313c82 | 522 | consist of multiple segments as described below:: |
98e4da8c JK |
523 | |
524 | align with the zone size <-| | |
525 | |-> align with the segment size | |
526 | _________________________________________________________________________ | |
9268cc35 HL |
527 | | | | Segment | Node | Segment | | |
528 | | Superblock | Checkpoint | Info. | Address | Summary | Main | | |
529 | | (SB) | (CP) | Table (SIT) | Table (NAT) | Area (SSA) | | | |
98e4da8c JK |
530 | |____________|_____2______|______N______|______N______|______N_____|__N___| |
531 | . . | |
532 | . . | |
533 | . . | |
534 | ._________________________________________. | |
535 | |_Segment_|_..._|_Segment_|_..._|_Segment_| | |
536 | . . | |
537 | ._________._________ | |
538 | |_section_|__...__|_ | |
539 | . . | |
540 | .________. | |
541 | |__zone__| | |
542 | ||
543 | - Superblock (SB) | |
89272ca1 | 544 | It is located at the beginning of the partition, and there exist two copies |
98e4da8c JK |
545 | to avoid file system crash. It contains basic partition information and some |
546 | default parameters of f2fs. | |
547 | ||
548 | - Checkpoint (CP) | |
89272ca1 | 549 | It contains file system information, bitmaps for valid NAT/SIT sets, orphan |
98e4da8c JK |
550 | inode lists, and summary entries of current active segments. |
551 | ||
98e4da8c | 552 | - Segment Information Table (SIT) |
89272ca1 | 553 | It contains segment information such as valid block count and bitmap for the |
98e4da8c JK |
554 | validity of all the blocks. |
555 | ||
9268cc35 | 556 | - Node Address Table (NAT) |
89272ca1 | 557 | It is composed of a block address table for all the node blocks stored in |
9268cc35 HL |
558 | Main area. |
559 | ||
98e4da8c | 560 | - Segment Summary Area (SSA) |
89272ca1 | 561 | It contains summary entries which contains the owner information of all the |
98e4da8c JK |
562 | data and node blocks stored in Main area. |
563 | ||
564 | - Main Area | |
89272ca1 | 565 | It contains file and directory data including their indices. |
98e4da8c JK |
566 | |
567 | In order to avoid misalignment between file system and flash-based storage, F2FS | |
568 | aligns the start block address of CP with the segment size. Also, it aligns the | |
569 | start block address of Main area with the zone size by reserving some segments | |
570 | in SSA area. | |
571 | ||
572 | Reference the following survey for additional technical details. | |
573 | https://wiki.linaro.org/WorkingGroups/Kernel/Projects/FlashCardSurvey | |
574 | ||
575 | File System Metadata Structure | |
576 | ------------------------------ | |
577 | ||
578 | F2FS adopts the checkpointing scheme to maintain file system consistency. At | |
579 | mount time, F2FS first tries to find the last valid checkpoint data by scanning | |
580 | CP area. In order to reduce the scanning time, F2FS uses only two copies of CP. | |
581 | One of them always indicates the last valid data, which is called as shadow copy | |
582 | mechanism. In addition to CP, NAT and SIT also adopt the shadow copy mechanism. | |
583 | ||
584 | For file system consistency, each CP points to which NAT and SIT copies are | |
89272ca1 | 585 | valid, as shown as below:: |
98e4da8c JK |
586 | |
587 | +--------+----------+---------+ | |
9268cc35 | 588 | | CP | SIT | NAT | |
98e4da8c JK |
589 | +--------+----------+---------+ |
590 | . . . . | |
591 | . . . . | |
592 | . . . . | |
593 | +-------+-------+--------+--------+--------+--------+ | |
9268cc35 | 594 | | CP #0 | CP #1 | SIT #0 | SIT #1 | NAT #0 | NAT #1 | |
98e4da8c JK |
595 | +-------+-------+--------+--------+--------+--------+ |
596 | | ^ ^ | |
597 | | | | | |
598 | `----------------------------------------' | |
599 | ||
600 | Index Structure | |
601 | --------------- | |
602 | ||
603 | The key data structure to manage the data locations is a "node". Similar to | |
604 | traditional file structures, F2FS has three types of node: inode, direct node, | |
d08ab08d | 605 | indirect node. F2FS assigns 4KB to an inode block which contains 923 data block |
98e4da8c JK |
606 | indices, two direct node pointers, two indirect node pointers, and one double |
607 | indirect node pointer as described below. One direct node block contains 1018 | |
608 | data blocks, and one indirect node block contains also 1018 node blocks. Thus, | |
89272ca1 | 609 | one inode block (i.e., a file) covers:: |
98e4da8c JK |
610 | |
611 | 4KB * (923 + 2 * 1018 + 2 * 1018 * 1018 + 1018 * 1018 * 1018) := 3.94TB. | |
612 | ||
613 | Inode block (4KB) | |
614 | |- data (923) | |
615 | |- direct node (2) | |
616 | | `- data (1018) | |
617 | |- indirect node (2) | |
618 | | `- direct node (1018) | |
619 | | `- data (1018) | |
620 | `- double indirect node (1) | |
621 | `- indirect node (1018) | |
622 | `- direct node (1018) | |
623 | `- data (1018) | |
624 | ||
ca313c82 | 625 | Note that all the node blocks are mapped by NAT which means the location of |
98e4da8c JK |
626 | each node is translated by the NAT table. In the consideration of the wandering |
627 | tree problem, F2FS is able to cut off the propagation of node updates caused by | |
628 | leaf data writes. | |
629 | ||
630 | Directory Structure | |
631 | ------------------- | |
632 | ||
633 | A directory entry occupies 11 bytes, which consists of the following attributes. | |
634 | ||
635 | - hash hash value of the file name | |
636 | - ino inode number | |
637 | - len the length of file name | |
638 | - type file type such as directory, symlink, etc | |
639 | ||
640 | A dentry block consists of 214 dentry slots and file names. Therein a bitmap is | |
641 | used to represent whether each dentry is valid or not. A dentry block occupies | |
642 | 4KB with the following composition. | |
643 | ||
89272ca1 MCC |
644 | :: |
645 | ||
98e4da8c JK |
646 | Dentry Block(4 K) = bitmap (27 bytes) + reserved (3 bytes) + |
647 | dentries(11 * 214 bytes) + file name (8 * 214 bytes) | |
648 | ||
649 | [Bucket] | |
650 | +--------------------------------+ | |
651 | |dentry block 1 | dentry block 2 | | |
652 | +--------------------------------+ | |
653 | . . | |
654 | . . | |
655 | . [Dentry Block Structure: 4KB] . | |
656 | +--------+----------+----------+------------+ | |
657 | | bitmap | reserved | dentries | file names | | |
658 | +--------+----------+----------+------------+ | |
659 | [Dentry Block: 4KB] . . | |
660 | . . | |
661 | . . | |
662 | +------+------+-----+------+ | |
663 | | hash | ino | len | type | | |
664 | +------+------+-----+------+ | |
665 | [Dentry Structure: 11 bytes] | |
666 | ||
667 | F2FS implements multi-level hash tables for directory structure. Each level has | |
668 | a hash table with dedicated number of hash buckets as shown below. Note that | |
669 | "A(2B)" means a bucket includes 2 data blocks. | |
670 | ||
89272ca1 MCC |
671 | :: |
672 | ||
673 | ---------------------- | |
674 | A : bucket | |
675 | B : block | |
676 | N : MAX_DIR_HASH_DEPTH | |
677 | ---------------------- | |
98e4da8c | 678 | |
89272ca1 MCC |
679 | level #0 | A(2B) |
680 | | | |
681 | level #1 | A(2B) - A(2B) | |
682 | | | |
683 | level #2 | A(2B) - A(2B) - A(2B) - A(2B) | |
684 | . | . . . . | |
685 | level #N/2 | A(2B) - A(2B) - A(2B) - A(2B) - A(2B) - ... - A(2B) | |
686 | . | . . . . | |
687 | level #N | A(4B) - A(4B) - A(4B) - A(4B) - A(4B) - ... - A(4B) | |
98e4da8c | 688 | |
89272ca1 | 689 | The number of blocks and buckets are determined by:: |
98e4da8c JK |
690 | |
691 | ,- 2, if n < MAX_DIR_HASH_DEPTH / 2, | |
692 | # of blocks in level #n = | | |
693 | `- 4, Otherwise | |
694 | ||
bfec07d0 CY |
695 | ,- 2^(n + dir_level), |
696 | | if n + dir_level < MAX_DIR_HASH_DEPTH / 2, | |
98e4da8c | 697 | # of buckets in level #n = | |
bfec07d0 CY |
698 | `- 2^((MAX_DIR_HASH_DEPTH / 2) - 1), |
699 | Otherwise | |
98e4da8c JK |
700 | |
701 | When F2FS finds a file name in a directory, at first a hash value of the file | |
702 | name is calculated. Then, F2FS scans the hash table in level #0 to find the | |
703 | dentry consisting of the file name and its inode number. If not found, F2FS | |
704 | scans the next hash table in level #1. In this way, F2FS scans hash tables in | |
ca313c82 | 705 | each levels incrementally from 1 to N. In each level F2FS needs to scan only |
98e4da8c | 706 | one bucket determined by the following equation, which shows O(log(# of files)) |
89272ca1 | 707 | complexity:: |
98e4da8c JK |
708 | |
709 | bucket number to scan in level #n = (hash value) % (# of buckets in level #n) | |
710 | ||
711 | In the case of file creation, F2FS finds empty consecutive slots that cover the | |
712 | file name. F2FS searches the empty slots in the hash tables of whole levels from | |
713 | 1 to N in the same way as the lookup operation. | |
714 | ||
89272ca1 MCC |
715 | The following figure shows an example of two cases holding children:: |
716 | ||
98e4da8c JK |
717 | --------------> Dir <-------------- |
718 | | | | |
719 | child child | |
720 | ||
721 | child - child [hole] - child | |
722 | ||
723 | child - child - child [hole] - [hole] - child | |
724 | ||
725 | Case 1: Case 2: | |
726 | Number of children = 6, Number of children = 3, | |
727 | File size = 7 File size = 7 | |
728 | ||
729 | Default Block Allocation | |
730 | ------------------------ | |
731 | ||
732 | At runtime, F2FS manages six active logs inside "Main" area: Hot/Warm/Cold node | |
733 | and Hot/Warm/Cold data. | |
734 | ||
735 | - Hot node contains direct node blocks of directories. | |
736 | - Warm node contains direct node blocks except hot node blocks. | |
737 | - Cold node contains indirect node blocks | |
738 | - Hot data contains dentry blocks | |
739 | - Warm data contains data blocks except hot and cold data blocks | |
740 | - Cold data contains multimedia data or migrated data blocks | |
741 | ||
742 | LFS has two schemes for free space management: threaded log and copy-and-compac- | |
743 | tion. The copy-and-compaction scheme which is known as cleaning, is well-suited | |
744 | for devices showing very good sequential write performance, since free segments | |
745 | are served all the time for writing new data. However, it suffers from cleaning | |
746 | overhead under high utilization. Contrarily, the threaded log scheme suffers | |
747 | from random writes, but no cleaning process is needed. F2FS adopts a hybrid | |
748 | scheme where the copy-and-compaction scheme is adopted by default, but the | |
749 | policy is dynamically changed to the threaded log scheme according to the file | |
750 | system status. | |
751 | ||
752 | In order to align F2FS with underlying flash-based storage, F2FS allocates a | |
753 | segment in a unit of section. F2FS expects that the section size would be the | |
754 | same as the unit size of garbage collection in FTL. Furthermore, with respect | |
755 | to the mapping granularity in FTL, F2FS allocates each section of the active | |
756 | logs from different zones as much as possible, since FTL can write the data in | |
757 | the active logs into one allocation unit according to its mapping granularity. | |
758 | ||
759 | Cleaning process | |
760 | ---------------- | |
761 | ||
762 | F2FS does cleaning both on demand and in the background. On-demand cleaning is | |
763 | triggered when there are not enough free segments to serve VFS calls. Background | |
764 | cleaner is operated by a kernel thread, and triggers the cleaning job when the | |
765 | system is idle. | |
766 | ||
767 | F2FS supports two victim selection policies: greedy and cost-benefit algorithms. | |
768 | In the greedy algorithm, F2FS selects a victim segment having the smallest number | |
769 | of valid blocks. In the cost-benefit algorithm, F2FS selects a victim segment | |
770 | according to the segment age and the number of valid blocks in order to address | |
771 | log block thrashing problem in the greedy algorithm. F2FS adopts the greedy | |
772 | algorithm for on-demand cleaner, while background cleaner adopts cost-benefit | |
773 | algorithm. | |
774 | ||
775 | In order to identify whether the data in the victim segment are valid or not, | |
776 | F2FS manages a bitmap. Each bit represents the validity of a block, and the | |
777 | bitmap is composed of a bit stream covering whole blocks in main area. | |
8b3a0ca0 | 778 | |
cad3836f JK |
779 | Fallocate(2) Policy |
780 | ------------------- | |
781 | ||
ca313c82 | 782 | The default policy follows the below POSIX rule. |
cad3836f JK |
783 | |
784 | Allocating disk space | |
785 | The default operation (i.e., mode is zero) of fallocate() allocates | |
786 | the disk space within the range specified by offset and len. The | |
787 | file size (as reported by stat(2)) will be changed if offset+len is | |
788 | greater than the file size. Any subregion within the range specified | |
789 | by offset and len that did not contain data before the call will be | |
790 | initialized to zero. This default behavior closely resembles the | |
791 | behavior of the posix_fallocate(3) library function, and is intended | |
792 | as a method of optimally implementing that function. | |
793 | ||
794 | However, once F2FS receives ioctl(fd, F2FS_IOC_SET_PIN_FILE) in prior to | |
d56b699d | 795 | fallocate(fd, DEFAULT_MODE), it allocates on-disk block addresses having |
cad3836f | 796 | zero or random data, which is useful to the below scenario where: |
89272ca1 | 797 | |
cad3836f JK |
798 | 1. create(fd) |
799 | 2. ioctl(fd, F2FS_IOC_SET_PIN_FILE) | |
800 | 3. fallocate(fd, 0, 0, size) | |
801 | 4. address = fibmap(fd, offset) | |
802 | 5. open(blkdev) | |
803 | 6. write(blkdev, address) | |
4c8ff709 CY |
804 | |
805 | Compression implementation | |
806 | -------------------------- | |
807 | ||
808 | - New term named cluster is defined as basic unit of compression, file can | |
89272ca1 MCC |
809 | be divided into multiple clusters logically. One cluster includes 4 << n |
810 | (n >= 0) logical pages, compression size is also cluster size, each of | |
811 | cluster can be compressed or not. | |
4c8ff709 CY |
812 | |
813 | - In cluster metadata layout, one special block address is used to indicate | |
ca313c82 | 814 | a cluster is a compressed one or normal one; for compressed cluster, following |
89272ca1 MCC |
815 | metadata maps cluster to [1, 4 << n - 1] physical blocks, in where f2fs |
816 | stores data including compress header and compressed data. | |
4c8ff709 CY |
817 | |
818 | - In order to eliminate write amplification during overwrite, F2FS only | |
89272ca1 | 819 | support compression on write-once file, data can be compressed only when |
4fc781a3 CY |
820 | all logical blocks in cluster contain valid data and compress ratio of |
821 | cluster data is lower than specified threshold. | |
4c8ff709 | 822 | |
151b1982 | 823 | - To enable compression on regular inode, there are four ways: |
89272ca1 MCC |
824 | |
825 | * chattr +c file | |
826 | * chattr +c dir; touch dir/file | |
827 | * mount w/ -o compress_extension=ext; touch file.ext | |
38740707 CY |
828 | * mount w/ -o compress_extension=*; touch any_file |
829 | ||
151b1982 FC |
830 | - To disable compression on regular inode, there are two ways: |
831 | ||
832 | * chattr -c file | |
833 | * mount w/ -o nocompress_extension=ext; touch file.ext | |
834 | ||
835 | - Priority in between FS_COMPR_FL, FS_NOCOMP_FS, extensions: | |
836 | ||
837 | * compress_extension=so; nocompress_extension=zip; chattr +c dir; touch | |
838 | dir/foo.so; touch dir/bar.zip; touch dir/baz.txt; then foo.so and baz.txt | |
839 | should be compresse, bar.zip should be non-compressed. chattr +c dir/bar.zip | |
840 | can enable compress on bar.zip. | |
841 | * compress_extension=so; nocompress_extension=zip; chattr -c dir; touch | |
842 | dir/foo.so; touch dir/bar.zip; touch dir/baz.txt; then foo.so should be | |
843 | compresse, bar.zip and baz.txt should be non-compressed. | |
844 | chattr+c dir/bar.zip; chattr+c dir/baz.txt; can enable compress on bar.zip | |
845 | and baz.txt. | |
846 | ||
38740707 CY |
847 | - At this point, compression feature doesn't expose compressed space to user |
848 | directly in order to guarantee potential data updates later to the space. | |
849 | Instead, the main goal is to reduce data writes to flash disk as much as | |
850 | possible, resulting in extending disk life time as well as relaxing IO | |
4a4fc043 | 851 | congestion. Alternatively, we've added ioctl(F2FS_IOC_RELEASE_COMPRESS_BLOCKS) |
d218bee8 CL |
852 | interface to reclaim compressed space and show it to user after setting a |
853 | special flag to the inode. Once the compressed space is released, the flag | |
854 | will block writing data to the file until either the compressed space is | |
855 | reserved via ioctl(F2FS_IOC_RESERVE_COMPRESS_BLOCKS) or the file size is | |
856 | truncated to zero. | |
89272ca1 MCC |
857 | |
858 | Compress metadata layout:: | |
859 | ||
860 | [Dnode Structure] | |
861 | +-----------------------------------------------+ | |
862 | | cluster 1 | cluster 2 | ......... | cluster N | | |
863 | +-----------------------------------------------+ | |
864 | . . . . | |
d218bee8 | 865 | . . . . |
89272ca1 MCC |
866 | . Compressed Cluster . . Normal Cluster . |
867 | +----------+---------+---------+---------+ +---------+---------+---------+---------+ | |
868 | |compr flag| block 1 | block 2 | block 3 | | block 1 | block 2 | block 3 | block 4 | | |
869 | +----------+---------+---------+---------+ +---------+---------+---------+---------+ | |
d218bee8 | 870 | . . |
89272ca1 MCC |
871 | . . |
872 | . . | |
873 | +-------------+-------------+----------+----------------------------+ | |
874 | | data length | data chksum | reserved | compressed data | | |
875 | +-------------+-------------+----------+----------------------------+ | |
de881df9 | 876 | |
602a16d5 DJ |
877 | Compression mode |
878 | -------------------------- | |
879 | ||
880 | f2fs supports "fs" and "user" compression modes with "compression_mode" mount option. | |
881 | With this option, f2fs provides a choice to select the way how to compress the | |
882 | compression enabled files (refer to "Compression implementation" section for how to | |
883 | enable compression on a regular inode). | |
884 | ||
885 | 1) compress_mode=fs | |
886 | This is the default option. f2fs does automatic compression in the writeback of the | |
887 | compression enabled files. | |
888 | ||
889 | 2) compress_mode=user | |
092af2eb | 890 | This disables the automatic compression and gives the user discretion of choosing the |
602a16d5 DJ |
891 | target file and the timing. The user can do manual compression/decompression on the |
892 | compression enabled files using F2FS_IOC_DECOMPRESS_FILE and F2FS_IOC_COMPRESS_FILE | |
893 | ioctls like the below. | |
894 | ||
895 | To decompress a file, | |
896 | ||
897 | fd = open(filename, O_WRONLY, 0); | |
898 | ret = ioctl(fd, F2FS_IOC_DECOMPRESS_FILE); | |
899 | ||
900 | To compress a file, | |
901 | ||
902 | fd = open(filename, O_WRONLY, 0); | |
903 | ret = ioctl(fd, F2FS_IOC_COMPRESS_FILE); | |
904 | ||
de881df9 AR |
905 | NVMe Zoned Namespace devices |
906 | ---------------------------- | |
907 | ||
908 | - ZNS defines a per-zone capacity which can be equal or less than the | |
909 | zone-size. Zone-capacity is the number of usable blocks in the zone. | |
ca313c82 | 910 | F2FS checks if zone-capacity is less than zone-size, if it is, then any |
de881df9 AR |
911 | segment which starts after the zone-capacity is marked as not-free in |
912 | the free segment bitmap at initial mount time. These segments are marked | |
913 | as permanently used so they are not allocated for writes and | |
914 | consequently are not needed to be garbage collected. In case the | |
915 | zone-capacity is not aligned to default segment size(2MB), then a segment | |
916 | can start before the zone-capacity and span across zone-capacity boundary. | |
917 | Such spanning segments are also considered as usable segments. All blocks | |
918 | past the zone-capacity are considered unusable in these segments. |