1 /**
2 * f2fs_fs.h
3 *
4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
6 * Copyright (c) 2019 Google Inc.
7 * http://www.google.com/
8 * Copyright (c) 2020 Google Inc.
9 * Robin Hsu <robinhsu@google.com>
10 * : add sload compression support
11 *
12 * Dual licensed under the GPL or LGPL version 2 licenses.
13 *
14 * The byteswap codes are copied from:
15 * samba_3_master/lib/ccan/endian/endian.h under LGPL 2.1
16 */
17 #ifndef __F2FS_FS_H__
18 #define __F2FS_FS_H__
19
20 #ifndef __SANE_USERSPACE_TYPES__
21 #define __SANE_USERSPACE_TYPES__ /* For PPC64, to get LL64 types */
22 #endif
23
24 #include <assert.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <sys/stat.h>
28 #include <stddef.h>
29 #include <string.h>
30 #include <time.h>
31
32 #ifdef HAVE_CONFIG_H
33 #include <config.h>
34 #else
35 #ifdef __ANDROID__
36 #define WITH_ANDROID
37 #endif
38 #endif /* HAVE_CONFIG_H */
39
40 #ifdef WITH_ANDROID
41 #include <android_config.h>
42 #else
43 #define WITH_DUMP
44 #define WITH_DEFRAG
45 #define WITH_RESIZE
46 #define WITH_SLOAD
47 #define WITH_LABEL
48 #endif
49
50 #include <inttypes.h>
51 #ifdef HAVE_LINUX_TYPES_H
52 #include <linux/types.h>
53 #endif
54 #include <sys/types.h>
55
56 #ifdef HAVE_KERNEL_UAPI_LINUX_BLKZONED_H
57 #include <kernel/uapi/linux/blkzoned.h>
58 #elif defined(HAVE_LINUX_BLKZONED_H)
59 #include <linux/blkzoned.h>
60 #endif
61
62 #ifdef HAVE_LIBSELINUX
63 #include <selinux/selinux.h>
64 #include <selinux/label.h>
65 #endif
66
67 #ifdef UNUSED
68 #elif defined(__GNUC__)
69 # define UNUSED(x) UNUSED_ ## x __attribute__((unused))
70 #elif defined(__LCLINT__)
71 # define UNUSED(x) x
72 #elif defined(__cplusplus)
73 # define UNUSED(x)
74 #else
75 # define UNUSED(x) x
76 #endif
77
78 #ifndef static_assert
79 #define static_assert _Static_assert
80 #endif
81
82 #ifdef HAVE_SYS_MOUNT_H
83 #include <sys/mount.h>
84 #endif
85
86 #ifndef fallthrough
87 #ifdef __clang__
88 #define fallthrough do {} while (0) /* fall through */
89 #else
90 #define fallthrough __attribute__((__fallthrough__))
91 #endif
92 #endif
93
94 #ifdef _WIN32
95 #undef HAVE_LINUX_TYPES_H
96 #endif
97
98 /* codes from kernel's f2fs.h, GPL-v2.0 */
99 #define MIN_COMPRESS_LOG_SIZE 2
100 #define MAX_COMPRESS_LOG_SIZE 8
101
102 typedef uint64_t u64;
103 typedef uint32_t u32;
104 typedef uint16_t u16;
105 typedef uint8_t u8;
106 typedef u32 block_t;
107 typedef u32 nid_t;
108 #ifndef bool
109 typedef u8 bool;
110 #endif
111 typedef unsigned long pgoff_t;
112 typedef unsigned short umode_t;
113
114 #ifndef HAVE_LINUX_TYPES_H
115 typedef u8 __u8;
116 typedef u16 __u16;
117 typedef u32 __u32;
118 typedef u64 __u64;
119 typedef u16 __le16;
120 typedef u32 __le32;
121 typedef u64 __le64;
122 typedef u16 __be16;
123 typedef u32 __be32;
124 typedef u64 __be64;
125 #endif
126
127 /*
128 * code borrowed from kernel f2fs dirver: f2fs.h, GPL-2.0
129 * : definitions of COMPRESS_DATA_RESERVED_SIZE,
130 * struct compress_data, COMPRESS_HEADER_SIZE,
131 * and struct compress_ctx
132 */
133 #define COMPRESS_DATA_RESERVED_SIZE 4
134 struct compress_data {
135 __le32 clen; /* compressed data size */
136 __le32 chksum; /* checksum of compressed data */
137 __le32 reserved[COMPRESS_DATA_RESERVED_SIZE]; /* reserved */
138 u8 cdata[]; /* compressed data */
139 };
140 #define COMPRESS_HEADER_SIZE (sizeof(struct compress_data))
141 /* compress context */
142 struct compress_ctx {
143 unsigned int cluster_size; /* page count in cluster */
144 unsigned int log_cluster_size; /* log of cluster size */
145 void *rbuf; /* compression input buffer */
146 struct compress_data *cbuf; /* comprsssion output header + data */
147 size_t rlen; /* valid data length in rbuf */
148 size_t clen; /* valid data length in cbuf */
149 void *private; /* work buf for compress algorithm */
150 };
151
152 #if HAVE_BYTESWAP_H
153 #include <byteswap.h>
154 #else
155 /**
156 * bswap_16 - reverse bytes in a uint16_t value.
157 * @val: value whose bytes to swap.
158 *
159 * Example:
160 * // Output contains "1024 is 4 as two bytes reversed"
161 * printf("1024 is %u as two bytes reversed\n", bswap_16(1024));
162 */
bswap_16(uint16_t val)163 static inline uint16_t bswap_16(uint16_t val)
164 {
165 return ((val & (uint16_t)0x00ffU) << 8)
166 | ((val & (uint16_t)0xff00U) >> 8);
167 }
168
169 /**
170 * bswap_32 - reverse bytes in a uint32_t value.
171 * @val: value whose bytes to swap.
172 *
173 * Example:
174 * // Output contains "1024 is 262144 as four bytes reversed"
175 * printf("1024 is %u as four bytes reversed\n", bswap_32(1024));
176 */
bswap_32(uint32_t val)177 static inline uint32_t bswap_32(uint32_t val)
178 {
179 return ((val & (uint32_t)0x000000ffUL) << 24)
180 | ((val & (uint32_t)0x0000ff00UL) << 8)
181 | ((val & (uint32_t)0x00ff0000UL) >> 8)
182 | ((val & (uint32_t)0xff000000UL) >> 24);
183 }
184 #endif /* !HAVE_BYTESWAP_H */
185
186 #if defined HAVE_DECL_BSWAP_64 && !HAVE_DECL_BSWAP_64
187 /**
188 * bswap_64 - reverse bytes in a uint64_t value.
189 * @val: value whose bytes to swap.
190 *
191 * Example:
192 * // Output contains "1024 is 1125899906842624 as eight bytes reversed"
193 * printf("1024 is %llu as eight bytes reversed\n",
194 * (unsigned long long)bswap_64(1024));
195 */
bswap_64(uint64_t val)196 static inline uint64_t bswap_64(uint64_t val)
197 {
198 return ((val & (uint64_t)0x00000000000000ffULL) << 56)
199 | ((val & (uint64_t)0x000000000000ff00ULL) << 40)
200 | ((val & (uint64_t)0x0000000000ff0000ULL) << 24)
201 | ((val & (uint64_t)0x00000000ff000000ULL) << 8)
202 | ((val & (uint64_t)0x000000ff00000000ULL) >> 8)
203 | ((val & (uint64_t)0x0000ff0000000000ULL) >> 24)
204 | ((val & (uint64_t)0x00ff000000000000ULL) >> 40)
205 | ((val & (uint64_t)0xff00000000000000ULL) >> 56);
206 }
207 #endif
208
209 #if __BYTE_ORDER == __LITTLE_ENDIAN
210 #define le16_to_cpu(x) ((uint16_t)(x))
211 #define le32_to_cpu(x) ((uint32_t)(x))
212 #define le64_to_cpu(x) ((uint64_t)(x))
213 #define cpu_to_le16(x) ((uint16_t)(x))
214 #define cpu_to_le32(x) ((uint32_t)(x))
215 #define cpu_to_le64(x) ((uint64_t)(x))
216 #define be32_to_cpu(x) __builtin_bswap64(x)
217 #elif __BYTE_ORDER == __BIG_ENDIAN
218 #define le16_to_cpu(x) bswap_16(x)
219 #define le32_to_cpu(x) bswap_32(x)
220 #define le64_to_cpu(x) bswap_64(x)
221 #define cpu_to_le16(x) bswap_16(x)
222 #define cpu_to_le32(x) bswap_32(x)
223 #define cpu_to_le64(x) bswap_64(x)
224 #define be32_to_cpu(x) ((uint64_t)(x))
225 #endif
226
227 #define typecheck(type,x) \
228 ({ type __dummy; \
229 typeof(x) __dummy2; \
230 (void)(&__dummy == &__dummy2); \
231 1; \
232 })
233
234 #define NULL_SEGNO ((unsigned int)~0)
235
236 /*
237 * Debugging interfaces
238 */
239
240 #define INFO_MSG(fmt, ...) \
241 do { \
242 printf("[INFO] (%s:%4d) ", __func__, __LINE__); \
243 printf(" --> "fmt"\n", ##__VA_ARGS__); \
244 } while (0)
245
246 #define FIX_MSG(fmt, ...) \
247 do { \
248 printf("[FIX] (%s:%4d) ", __func__, __LINE__); \
249 printf(" --> "fmt"\n", ##__VA_ARGS__); \
250 } while (0)
251
252 #define ASSERT_MSG(fmt, ...) \
253 do { \
254 printf("[ASSERT] (%s:%4d) ", __func__, __LINE__); \
255 printf(" --> "fmt"\n", ##__VA_ARGS__); \
256 c.bug_on = 1; \
257 } while (0)
258
259 #define ASSERT(exp) \
260 do { \
261 if (!(exp)) { \
262 printf("[ASSERT] (%s:%4d) %s\n", \
263 __func__, __LINE__, #exp); \
264 exit(-1); \
265 } \
266 } while (0)
267
268 #define ERR_MSG(fmt, ...) \
269 do { \
270 printf("[%s:%d] " fmt, __func__, __LINE__, ##__VA_ARGS__); \
271 } while (0)
272
273 #define MSG(n, fmt, ...) \
274 do { \
275 if (c.dbg_lv >= n && !c.layout && !c.show_file_map) { \
276 printf(fmt, ##__VA_ARGS__); \
277 } \
278 } while (0)
279
280 #define DBG(n, fmt, ...) \
281 do { \
282 if (c.dbg_lv >= n && !c.layout && !c.show_file_map) { \
283 printf("[%s:%4d] " fmt, \
284 __func__, __LINE__, ##__VA_ARGS__); \
285 } \
286 } while (0)
287
288 /* Display on console */
289 #define DISP(fmt, ptr, member) \
290 do { \
291 printf("%-30s" fmt, #member, ((ptr)->member)); \
292 } while (0)
293
294 #define DISP_raw_str(fmt, member) \
295 do { \
296 if (c.layout) \
297 printf("%-30s " fmt "\n", #member":", member); \
298 else \
299 printf("%-30s" "\t\t[" fmt "]\n", \
300 #member, member); \
301 } while (0)
302
303 #define DISP_str(fmt, ptr, member) \
304 do { \
305 if (c.layout) \
306 printf("%-30s " fmt "\n", \
307 #member":", ((ptr)->member)); \
308 else \
309 printf("%-30s" "\t\t[" fmt "]\n", \
310 #member, ((ptr)->member)); \
311 } while (0)
312
313 #define DISP_u8(ptr, member) \
314 do { \
315 assert(sizeof((ptr)->member) == 1); \
316 if (c.layout) \
317 printf("%-30s %u\n", \
318 #member":", ((ptr)->member)); \
319 else \
320 printf("%-30s" "\t\t[0x%8x : %u]\n", \
321 #member, ((ptr)->member), ((ptr)->member)); \
322 } while (0)
323
324 #define DISP_u16(ptr, member) \
325 do { \
326 assert(sizeof((ptr)->member) == 2); \
327 if (c.layout) \
328 printf("%-30s %u\n", \
329 #member":", le16_to_cpu(((ptr)->member))); \
330 else \
331 printf("%-30s" "\t\t[0x%8x : %u]\n", \
332 #member, le16_to_cpu(((ptr)->member)), \
333 le16_to_cpu(((ptr)->member))); \
334 } while (0)
335
336 #define DISP_u32(ptr, member) \
337 do { \
338 assert(sizeof((ptr)->member) <= 4); \
339 if (c.layout) \
340 printf("%-30s %u\n", \
341 #member":", le32_to_cpu(((ptr)->member))); \
342 else \
343 printf("%-30s" "\t\t[0x%8x : %u]\n", \
344 #member, le32_to_cpu(((ptr)->member)), \
345 le32_to_cpu(((ptr)->member))); \
346 } while (0)
347
348 #define DISP_u64(ptr, member) \
349 do { \
350 assert(sizeof((ptr)->member) == 8); \
351 if (c.layout) \
352 printf("%-30s %" PRIu64 "\n", \
353 #member":", le64_to_cpu(((ptr)->member))); \
354 else \
355 printf("%-30s" "\t\t[0x%8" PRIx64 " : %" PRIu64 "]\n", \
356 #member, le64_to_cpu(((ptr)->member)), \
357 le64_to_cpu(((ptr)->member))); \
358 } while (0)
359
360 #define DISP_utf(ptr, member) \
361 do { \
362 if (c.layout) \
363 printf("%-30s %s\n", #member":", \
364 ((ptr)->member)); \
365 else \
366 printf("%-30s" "\t\t[%s]\n", #member, \
367 ((ptr)->member)); \
368 } while (0)
369
370 /* Display to buffer */
371 #define BUF_DISP_u32(buf, data, len, ptr, member) \
372 do { \
373 assert(sizeof((ptr)->member) <= 4); \
374 snprintf(buf, len, #member); \
375 snprintf(data, len, "0x%x : %u", ((ptr)->member), \
376 ((ptr)->member)); \
377 } while (0)
378
379 #define BUF_DISP_u64(buf, data, len, ptr, member) \
380 do { \
381 assert(sizeof((ptr)->member) == 8); \
382 snprintf(buf, len, #member); \
383 snprintf(data, len, "0x%llx : %llu", ((ptr)->member), \
384 ((ptr)->member)); \
385 } while (0)
386
387 #define BUF_DISP_utf(buf, data, len, ptr, member) \
388 snprintf(buf, len, #member)
389
390 /* these are defined in kernel */
391 #define BITS_PER_BYTE 8
392 #ifndef SECTOR_SHIFT
393 #define SECTOR_SHIFT 9
394 #endif
395 #define F2FS_SUPER_MAGIC 0xF2F52010 /* F2FS Magic Number */
396 #define CP_CHKSUM_OFFSET (F2FS_BLKSIZE - sizeof(__le32))
397 #define SB_CHKSUM_OFFSET 3068
398 #define MAX_PATH_LEN 64
399 #define MAX_DEVICES 8
400
401 #define F2FS_BYTES_TO_BLK(bytes) ((bytes) >> F2FS_BLKSIZE_BITS)
402 #define F2FS_BLKSIZE_BITS c.blksize_bits
403
404 /* for mkfs */
405 #define F2FS_NUMBER_OF_CHECKPOINT_PACK 2
406 #define DEFAULT_SECTOR_SIZE 512
407 #define DEFAULT_SECTORS_PER_BLOCK (1 << (F2FS_BLKSIZE_BITS - SECTOR_SHIFT))
408 #define DEFAULT_BLOCKS_PER_SEGMENT 512
409 #define DEFAULT_SEGMENTS_PER_SECTION 1
410 #define DEFAULT_BLKSIZE_BITS 12 /* 4096 */
411
412 #define VERSION_LEN 256
413 #define VERSION_TIMESTAMP_LEN 4
414 #define VERSION_NAME_LEN (VERSION_LEN - VERSION_TIMESTAMP_LEN)
415
416 #define LPF "lost+found"
417
418 /* one for gc buffer, the other for node */
419 #define MIN_RSVD_SECS (NR_CURSEG_TYPE + 2U)
420 #define CONFIG_RSVD_DEFAULT_OP_RATIO 3.0
421
422 enum f2fs_config_func {
423 MKFS,
424 FSCK,
425 DUMP,
426 DEFRAG,
427 RESIZE,
428 SLOAD,
429 LABEL,
430 };
431
432 enum default_set {
433 CONF_NONE = 0,
434 CONF_ANDROID,
435 };
436
437 struct device_info {
438 char *path;
439 int32_t fd;
440 uint32_t sector_size;
441 uint64_t total_sectors; /* got by get_device_info */
442 uint64_t start_blkaddr;
443 uint64_t end_blkaddr;
444 uint32_t total_segments;
445
446 /* to handle zone block devices */
447 int zoned_model;
448 uint32_t nr_zones;
449 uint32_t nr_rnd_zones;
450 size_t zone_blocks;
451 uint64_t zone_size;
452 size_t *zone_cap_blocks;
453 };
454
455 typedef struct {
456 /* Value 0 means no cache, minimum 1024 */
457 long num_cache_entry;
458
459 /* Value 0 means always overwrite (no collision allowed). maximum 16 */
460 unsigned max_hash_collision;
461
462 bool dbg_en;
463 } dev_cache_config_t;
464
465 /* f2fs_configration for compression used for sload.f2fs */
466 typedef struct {
467 void (*init)(struct compress_ctx *cc);
468 int (*compress)(struct compress_ctx *cc);
469 void (*reset)(struct compress_ctx *cc);
470 } compress_ops;
471
472 /* Should be aligned to supported_comp_names and support_comp_ops */
473 enum compress_algorithms {
474 COMPR_LZO,
475 COMPR_LZ4,
476 MAX_COMPRESS_ALGS,
477 };
478
479 enum filter_policy {
480 COMPR_FILTER_UNASSIGNED = 0,
481 COMPR_FILTER_ALLOW,
482 COMPR_FILTER_DENY,
483 };
484
485 typedef struct {
486 void (*add)(const char *);
487 void (*destroy)(void);
488 bool (*filter)(const char *);
489 } filter_ops;
490
491 typedef struct {
492 bool enabled; /* disabled by default */
493 bool required; /* require to enable */
494 bool readonly; /* readonly to release blocks */
495 struct compress_ctx cc; /* work context */
496 enum compress_algorithms alg; /* algorithm to compress */
497 compress_ops *ops; /* ops per algorithm */
498 unsigned int min_blocks; /* save more blocks than this */
499 enum filter_policy filter; /* filter to try compression */
500 filter_ops *filter_ops; /* filter ops */
501 } compress_config_t;
502
503 #define ALIGN_DOWN(addrs, size) (((addrs) / (size)) * (size))
504 #define ALIGN_UP(addrs, size) ALIGN_DOWN(((addrs) + (size) - 1), (size))
505
506 #ifdef CONFIG_64BIT
507 #define BITS_PER_LONG 64
508 #else
509 #define BITS_PER_LONG 32
510 #endif
511
512 #define BIT_MASK(nr) (1 << (nr % BITS_PER_LONG))
513 #define BIT_WORD(nr) (nr / BITS_PER_LONG)
514
515 #define set_sb_le64(member, val) (sb->member = cpu_to_le64(val))
516 #define set_sb_le32(member, val) (sb->member = cpu_to_le32(val))
517 #define set_sb_le16(member, val) (sb->member = cpu_to_le16(val))
518 #define get_sb_le64(member) le64_to_cpu(sb->member)
519 #define get_sb_le32(member) le32_to_cpu(sb->member)
520 #define get_sb_le16(member) le16_to_cpu(sb->member)
521 #define get_newsb_le64(member) le64_to_cpu(new_sb->member)
522 #define get_newsb_le32(member) le32_to_cpu(new_sb->member)
523 #define get_newsb_le16(member) le16_to_cpu(new_sb->member)
524
525 #define set_sb(member, val) \
526 do { \
527 typeof(sb->member) t = (val); \
528 switch (sizeof(t)) { \
529 case 8: set_sb_le64(member, t); break; \
530 case 4: set_sb_le32(member, t); break; \
531 case 2: set_sb_le16(member, t); break; \
532 } \
533 } while(0)
534
535 #define get_sb(member) \
536 ({ \
537 typeof(sb->member) t; \
538 switch (sizeof(t)) { \
539 case 8: t = get_sb_le64(member); break; \
540 case 4: t = get_sb_le32(member); break; \
541 case 2: t = get_sb_le16(member); break; \
542 } \
543 t; \
544 })
545 #define get_newsb(member) \
546 ({ \
547 typeof(new_sb->member) t; \
548 switch (sizeof(t)) { \
549 case 8: t = get_newsb_le64(member); break; \
550 case 4: t = get_newsb_le32(member); break; \
551 case 2: t = get_newsb_le16(member); break; \
552 } \
553 t; \
554 })
555
556 #define set_cp_le64(member, val) (cp->member = cpu_to_le64(val))
557 #define set_cp_le32(member, val) (cp->member = cpu_to_le32(val))
558 #define set_cp_le16(member, val) (cp->member = cpu_to_le16(val))
559 #define get_cp_le64(member) le64_to_cpu(cp->member)
560 #define get_cp_le32(member) le32_to_cpu(cp->member)
561 #define get_cp_le16(member) le16_to_cpu(cp->member)
562
563 #define set_cp(member, val) \
564 do { \
565 typeof(cp->member) t = (val); \
566 switch (sizeof(t)) { \
567 case 8: set_cp_le64(member, t); break; \
568 case 4: set_cp_le32(member, t); break; \
569 case 2: set_cp_le16(member, t); break; \
570 } \
571 } while(0)
572
573 #define get_cp(member) \
574 ({ \
575 typeof(cp->member) t; \
576 switch (sizeof(t)) { \
577 case 8: t = get_cp_le64(member); break; \
578 case 4: t = get_cp_le32(member); break; \
579 case 2: t = get_cp_le16(member); break; \
580 } \
581 t; \
582 })
583
584 /*
585 * Copied from include/linux/kernel.h
586 */
587 #define __round_mask(x, y) ((__typeof__(x))((y)-1))
588 #define round_down(x, y) ((x) & ~__round_mask(x, y))
589
590 #define min(x, y) ({ \
591 typeof(x) _min1 = (x); \
592 typeof(y) _min2 = (y); \
593 (void) (&_min1 == &_min2); \
594 _min1 < _min2 ? _min1 : _min2; })
595
596 #define max(x, y) ({ \
597 typeof(x) _max1 = (x); \
598 typeof(y) _max2 = (y); \
599 (void) (&_max1 == &_max2); \
600 _max1 > _max2 ? _max1 : _max2; })
601
602 #define round_up(x, y) (((x) + (y) - 1) / (y))
603 /*
604 * Copied from fs/f2fs/f2fs.h
605 */
606 #define NR_CURSEG_DATA_TYPE (3)
607 #define NR_CURSEG_NODE_TYPE (3)
608 #define NR_CURSEG_TYPE (NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE)
609
610 enum {
611 CURSEG_HOT_DATA = 0, /* directory entry blocks */
612 CURSEG_WARM_DATA, /* data blocks */
613 CURSEG_COLD_DATA, /* multimedia or GCed data blocks */
614 CURSEG_HOT_NODE, /* direct node blocks of directory files */
615 CURSEG_WARM_NODE, /* direct node blocks of normal files */
616 CURSEG_COLD_NODE, /* indirect node blocks */
617 NO_CHECK_TYPE
618 };
619
620 enum {
621 CURSEG_RO_HOT_DATA,
622 CURSEG_RO_HOT_NODE,
623 NR_RO_CURSEG_TYPE,
624 };
625
626 #define F2FS_MIN_SEGMENTS 9 /* SB + 2 (CP + SIT + NAT) + SSA + MAIN */
627
628 /*
629 * Copied from fs/f2fs/segment.h
630 */
631 #define GET_SUM_TYPE(sum) (F2FS_SUMMARY_BLOCK_FOOTER(sum)->entry_type)
632 #define SET_SUM_TYPE(sum, type) (F2FS_SUMMARY_BLOCK_FOOTER(sum)->entry_type = type)
633
634 /*
635 * Copied from include/linux/f2fs_sb.h
636 */
637 #define F2FS_SUPER_OFFSET 1024 /* byte-size offset */
638 #define F2FS_MIN_LOG_SECTOR_SIZE 9 /* 9 bits for 512 bytes */
639 #define F2FS_MAX_LOG_SECTOR_SIZE F2FS_BLKSIZE_BITS /* max sector size is block size */
640 #define F2FS_MIN_BLKSIZE 4096
641 #define F2FS_MAX_BLKSIZE 16384
642 #define F2FS_BLKSIZE c.blksize /* support configurable block size */
643 #define F2FS_MAX_EXTENSION 64 /* # of extension entries */
644 #define F2FS_EXTENSION_LEN 8 /* max size of extension */
645 #define F2FS_BLK_ALIGN(x) (((x) + F2FS_BLKSIZE - 1) / F2FS_BLKSIZE)
646
647 #define NULL_ADDR 0x0U
648 #define NEW_ADDR -1U
649 #define COMPRESS_ADDR -2U
650
651 #define F2FS_ROOT_INO(sbi) (sbi->root_ino_num)
652 #define F2FS_NODE_INO(sbi) (sbi->node_ino_num)
653 #define F2FS_META_INO(sbi) (sbi->meta_ino_num)
654
655 #define F2FS_MAX_QUOTAS 3
656 #define QUOTA_DATA (((1024 * 6 - 1) / F2FS_BLKSIZE) + 1)
657 #define QUOTA_INO(sb,t) (le32_to_cpu((sb)->qf_ino[t]))
658
659 /*
660 * On-disk inode flags (f2fs_inode::i_flags)
661 */
662 #define F2FS_IMMUTABLE_FL 0x00000010 /* Immutable file */
663 #define F2FS_NOATIME_FL 0x00000080 /* do not update atime */
664
665
666 #define F2FS_ENC_UTF8_12_1 1
667 #define F2FS_ENC_STRICT_MODE_FL (1 << 0)
668
669 /* This flag is used by node and meta inodes, and by recovery */
670 #define GFP_F2FS_ZERO (GFP_NOFS | __GFP_ZERO)
671
672 /*
673 * For further optimization on multi-head logs, on-disk layout supports maximum
674 * 16 logs by default. The number, 16, is expected to cover all the cases
675 * enoughly. The implementaion currently uses no more than 6 logs.
676 * Half the logs are used for nodes, and the other half are used for data.
677 */
678 #define MAX_ACTIVE_LOGS 16
679 #define MAX_ACTIVE_NODE_LOGS 8
680 #define MAX_ACTIVE_DATA_LOGS 8
681
682 #define F2FS_FEATURE_ENCRYPT 0x0001
683 #define F2FS_FEATURE_BLKZONED 0x0002
684 #define F2FS_FEATURE_ATOMIC_WRITE 0x0004
685 #define F2FS_FEATURE_EXTRA_ATTR 0x0008
686 #define F2FS_FEATURE_PRJQUOTA 0x0010
687 #define F2FS_FEATURE_INODE_CHKSUM 0x0020
688 #define F2FS_FEATURE_FLEXIBLE_INLINE_XATTR 0x0040
689 #define F2FS_FEATURE_QUOTA_INO 0x0080
690 #define F2FS_FEATURE_INODE_CRTIME 0x0100
691 #define F2FS_FEATURE_LOST_FOUND 0x0200
692 #define F2FS_FEATURE_VERITY 0x0400 /* reserved */
693 #define F2FS_FEATURE_SB_CHKSUM 0x0800
694 #define F2FS_FEATURE_CASEFOLD 0x1000
695 #define F2FS_FEATURE_COMPRESSION 0x2000
696 #define F2FS_FEATURE_RO 0x4000
697
698 #define MAX_NR_FEATURE 32
699
700 #define MAX_VOLUME_NAME 512
701
702 /*
703 * For superblock
704 */
705 struct f2fs_device {
706 __u8 path[MAX_PATH_LEN];
707 __le32 total_segments;
708 };
709
710 static_assert(sizeof(struct f2fs_device) == 68, "");
711
712 /* reason of stop_checkpoint */
713 enum stop_cp_reason {
714 STOP_CP_REASON_SHUTDOWN,
715 STOP_CP_REASON_FAULT_INJECT,
716 STOP_CP_REASON_META_PAGE,
717 STOP_CP_REASON_WRITE_FAIL,
718 STOP_CP_REASON_CORRUPTED_SUMMARY,
719 STOP_CP_REASON_UPDATE_INODE,
720 STOP_CP_REASON_FLUSH_FAIL,
721 STOP_CP_REASON_NO_SEGMENT,
722 STOP_CP_REASON_MAX,
723 };
724
725 #define MAX_STOP_REASON 32
726
727 /* detail reason for EFSCORRUPTED */
728 enum f2fs_error {
729 ERROR_CORRUPTED_CLUSTER,
730 ERROR_FAIL_DECOMPRESSION,
731 ERROR_INVALID_BLKADDR,
732 ERROR_CORRUPTED_DIRENT,
733 ERROR_CORRUPTED_INODE,
734 ERROR_INCONSISTENT_SUMMARY,
735 ERROR_INCONSISTENT_FOOTER,
736 ERROR_INCONSISTENT_SUM_TYPE,
737 ERROR_CORRUPTED_JOURNAL,
738 ERROR_INCONSISTENT_NODE_COUNT,
739 ERROR_INCONSISTENT_BLOCK_COUNT,
740 ERROR_INVALID_CURSEG,
741 ERROR_INCONSISTENT_SIT,
742 ERROR_CORRUPTED_VERITY_XATTR,
743 ERROR_CORRUPTED_XATTR,
744 ERROR_INVALID_NODE_REFERENCE,
745 ERROR_INCONSISTENT_NAT,
746 ERROR_MAX,
747 };
748
749 #define MAX_F2FS_ERRORS 16
750
751 struct f2fs_super_block {
752 __le32 magic; /* Magic Number */
753 __le16 major_ver; /* Major Version */
754 __le16 minor_ver; /* Minor Version */
755 __le32 log_sectorsize; /* log2 sector size in bytes */
756 __le32 log_sectors_per_block; /* log2 # of sectors per block */
757 __le32 log_blocksize; /* log2 block size in bytes */
758 __le32 log_blocks_per_seg; /* log2 # of blocks per segment */
759 __le32 segs_per_sec; /* # of segments per section */
760 __le32 secs_per_zone; /* # of sections per zone */
761 __le32 checksum_offset; /* checksum offset inside super block */
762 __le64 block_count __attribute__((packed));
763 /* total # of user blocks */
764 __le32 section_count; /* total # of sections */
765 __le32 segment_count; /* total # of segments */
766 __le32 segment_count_ckpt; /* # of segments for checkpoint */
767 __le32 segment_count_sit; /* # of segments for SIT */
768 __le32 segment_count_nat; /* # of segments for NAT */
769 __le32 segment_count_ssa; /* # of segments for SSA */
770 __le32 segment_count_main; /* # of segments for main area */
771 __le32 segment0_blkaddr; /* start block address of segment 0 */
772 __le32 cp_blkaddr; /* start block address of checkpoint */
773 __le32 sit_blkaddr; /* start block address of SIT */
774 __le32 nat_blkaddr; /* start block address of NAT */
775 __le32 ssa_blkaddr; /* start block address of SSA */
776 __le32 main_blkaddr; /* start block address of main area */
777 __le32 root_ino; /* root inode number */
778 __le32 node_ino; /* node inode number */
779 __le32 meta_ino; /* meta inode number */
780 __u8 uuid[16]; /* 128-bit uuid for volume */
781 __le16 volume_name[MAX_VOLUME_NAME]; /* volume name */
782 __le32 extension_count; /* # of extensions below */
783 __u8 extension_list[F2FS_MAX_EXTENSION][8]; /* extension array */
784 __le32 cp_payload;
785 __u8 version[VERSION_LEN]; /* the kernel version */
786 __u8 init_version[VERSION_LEN]; /* the initial kernel version */
787 __le32 feature; /* defined features */
788 __u8 encryption_level; /* versioning level for encryption */
789 __u8 encrypt_pw_salt[16]; /* Salt used for string2key algorithm */
790 struct f2fs_device devs[MAX_DEVICES] __attribute__((packed)); /* device list */
791 __le32 qf_ino[F2FS_MAX_QUOTAS] __attribute__((packed)); /* quota inode numbers */
792 __u8 hot_ext_count; /* # of hot file extension */
793 __le16 s_encoding; /* Filename charset encoding */
794 __le16 s_encoding_flags; /* Filename charset encoding flags */
795 __u8 s_stop_reason[MAX_STOP_REASON]; /* stop checkpoint reason */
796 __u8 s_errors[MAX_F2FS_ERRORS]; /* reason of image corrupts */
797 __u8 reserved[258]; /* valid reserved region */
798 __le32 crc; /* checksum of superblock */
799 } __attribute__((packed));
800
801 static_assert(sizeof(struct f2fs_super_block) == 3072, "");
802
803 /*
804 * For checkpoint
805 */
806 #define CP_RESIZEFS_FLAG 0x00004000
807 #define CP_DISABLED_FLAG 0x00001000
808 #define CP_QUOTA_NEED_FSCK_FLAG 0x00000800
809 #define CP_LARGE_NAT_BITMAP_FLAG 0x00000400
810 #define CP_NOCRC_RECOVERY_FLAG 0x00000200
811 #define CP_TRIMMED_FLAG 0x00000100
812 #define CP_NAT_BITS_FLAG 0x00000080
813 #define CP_CRC_RECOVERY_FLAG 0x00000040
814 #define CP_FASTBOOT_FLAG 0x00000020
815 #define CP_FSCK_FLAG 0x00000010
816 #define CP_ERROR_FLAG 0x00000008
817 #define CP_COMPACT_SUM_FLAG 0x00000004
818 #define CP_ORPHAN_PRESENT_FLAG 0x00000002
819 #define CP_UMOUNT_FLAG 0x00000001
820
821 #define F2FS_CP_PACKS 2 /* # of checkpoint packs */
822
823 struct f2fs_checkpoint {
824 __le64 checkpoint_ver; /* checkpoint block version number */
825 __le64 user_block_count; /* # of user blocks */
826 __le64 valid_block_count; /* # of valid blocks in main area */
827 __le32 rsvd_segment_count; /* # of reserved segments for gc */
828 __le32 overprov_segment_count; /* # of overprovision segments */
829 __le32 free_segment_count; /* # of free segments in main area */
830
831 /* information of current node segments */
832 __le32 cur_node_segno[MAX_ACTIVE_NODE_LOGS];
833 __le16 cur_node_blkoff[MAX_ACTIVE_NODE_LOGS];
834 /* information of current data segments */
835 __le32 cur_data_segno[MAX_ACTIVE_DATA_LOGS];
836 __le16 cur_data_blkoff[MAX_ACTIVE_DATA_LOGS];
837 __le32 ckpt_flags; /* Flags : umount and journal_present */
838 __le32 cp_pack_total_block_count; /* total # of one cp pack */
839 __le32 cp_pack_start_sum; /* start block number of data summary */
840 __le32 valid_node_count; /* Total number of valid nodes */
841 __le32 valid_inode_count; /* Total number of valid inodes */
842 __le32 next_free_nid; /* Next free node number */
843 __le32 sit_ver_bitmap_bytesize; /* Default value 64 */
844 __le32 nat_ver_bitmap_bytesize; /* Default value 256 */
845 __le32 checksum_offset; /* checksum offset inside cp block */
846 __le64 elapsed_time; /* mounted time */
847 /* allocation type of current segment */
848 unsigned char alloc_type[MAX_ACTIVE_LOGS];
849
850 /* SIT and NAT version bitmap */
851 unsigned char sit_nat_version_bitmap[];
852 };
853
854 static_assert(sizeof(struct f2fs_checkpoint) == 192, "");
855
856 #define CP_BITMAP_OFFSET \
857 (offsetof(struct f2fs_checkpoint, sit_nat_version_bitmap))
858 #define CP_MIN_CHKSUM_OFFSET CP_BITMAP_OFFSET
859
860 #define MIN_NAT_BITMAP_SIZE 64
861 #define MAX_SIT_BITMAP_SIZE_IN_CKPT \
862 (CP_CHKSUM_OFFSET - CP_BITMAP_OFFSET - MIN_NAT_BITMAP_SIZE)
863 #define MAX_BITMAP_SIZE_IN_CKPT \
864 (CP_CHKSUM_OFFSET - CP_BITMAP_OFFSET)
865
866 /*
867 * For orphan inode management
868 */
869 #define F2FS_ORPHANS_PER_BLOCK ((F2FS_BLKSIZE - 4 * sizeof(__le32)) / sizeof(__le32))
870
871 /*
872 * On disk layout is:
873 * __le32 ino[F2FS_ORPHANS_PER_BLOCK];
874 * struct f2fs_ophan_block_footer
875 *
876 * Do NOT use sizeof, use F2FS_BLKSIZE instead
877 */
878 struct f2fs_orphan_block {
879 __le32 ino[0]; /* F2FS_ORPHANS_PER_BLOCK inode numbers */
880 };
881 #define F2FS_ORPHAN_BLOCK_FOOTER(blk) ((struct orphan_block_footer *)&(blk)->ino[F2FS_ORPHANS_PER_BLOCK])
882
883 struct orphan_block_footer {
884 __le32 reserved; /* reserved */
885 __le16 blk_addr; /* block index in current CP */
886 __le16 blk_count; /* Number of orphan inode blocks in CP */
887 __le32 entry_count; /* Total number of orphan nodes in current CP */
888 __le32 check_sum; /* CRC32 for orphan inode block */
889 };
890
891 /*
892 * For NODE structure
893 */
894 struct f2fs_extent {
895 __le32 fofs; /* start file offset of the extent */
896 __le32 blk_addr; /* start block address of the extent */
897 __le32 len; /* lengh of the extent */
898 };
899
900 static_assert(sizeof(struct f2fs_extent) == 12, "");
901
902 #define F2FS_NAME_LEN 255
903
904 /* max output length of pretty_print_filename() including null terminator */
905 #define F2FS_PRINT_NAMELEN (4 * ((F2FS_NAME_LEN + 2) / 3) + 1)
906
907 /* 200 bytes for inline xattrs by default */
908 #define DEFAULT_INLINE_XATTR_ADDRS 50
909
910 struct node_footer {
911 __le32 nid; /* node id */
912 __le32 ino; /* inode number */
913 __le32 flag; /* include cold/fsync/dentry marks and offset */
914 __le64 cp_ver __attribute__((packed)); /* checkpoint version */
915 __le32 next_blkaddr; /* next node page block address */
916 };
917
918 static_assert(sizeof(struct node_footer) == 24, "");
919
920 #define OFFSET_OF_END_OF_I_EXT 360
921 #define SIZE_OF_I_NID 20
922 /* Address Pointers in an Inode */
923 #define DEF_ADDRS_PER_INODE ((F2FS_BLKSIZE - OFFSET_OF_END_OF_I_EXT \
924 - SIZE_OF_I_NID \
925 - sizeof(struct node_footer)) / sizeof(__le32))
926 #define CUR_ADDRS_PER_INODE(inode) (DEF_ADDRS_PER_INODE - \
927 __get_extra_isize(inode))
928 #define ADDRS_PER_INODE(i) addrs_per_inode(i)
929 /* Address Pointers in a Direct Block */
930 #define DEF_ADDRS_PER_BLOCK ((F2FS_BLKSIZE - sizeof(struct node_footer)) / sizeof(__le32))
931 #define ADDRS_PER_BLOCK(i) addrs_per_block(i)
932 /* Node IDs in an Indirect Block */
933 #define NIDS_PER_BLOCK ((F2FS_BLKSIZE - sizeof(struct node_footer)) / sizeof(__le32))
934
935 #define NODE_DIR1_BLOCK (DEF_ADDRS_PER_INODE + 1)
936 #define NODE_DIR2_BLOCK (DEF_ADDRS_PER_INODE + 2)
937 #define NODE_IND1_BLOCK (DEF_ADDRS_PER_INODE + 3)
938 #define NODE_IND2_BLOCK (DEF_ADDRS_PER_INODE + 4)
939 #define NODE_DIND_BLOCK (DEF_ADDRS_PER_INODE + 5)
940
941 #define F2FS_INLINE_XATTR 0x01 /* file inline xattr flag */
942 #define F2FS_INLINE_DATA 0x02 /* file inline data flag */
943 #define F2FS_INLINE_DENTRY 0x04 /* file inline dentry flag */
944 #define F2FS_DATA_EXIST 0x08 /* file inline data exist flag */
945 #define F2FS_INLINE_DOTS 0x10 /* file having implicit dot dentries */
946 #define F2FS_EXTRA_ATTR 0x20 /* file having extra attribute */
947 #define F2FS_PIN_FILE 0x40 /* file should not be gced */
948 #define F2FS_COMPRESS_RELEASED 0x80 /* file released compressed blocks */
949
950 #define F2FS_EXTRA_ISIZE_OFFSET \
951 offsetof(struct f2fs_inode, i_extra_isize)
952 #define F2FS_TOTAL_EXTRA_ATTR_SIZE \
953 (offsetof(struct f2fs_inode, i_extra_end) - F2FS_EXTRA_ISIZE_OFFSET)
954
955 #define F2FS_DEF_PROJID 0 /* default project ID */
956
957 #define MAX_INLINE_DATA(node) (sizeof(__le32) * \
958 (DEF_ADDRS_PER_INODE - \
959 get_inline_xattr_addrs(&node->i) - \
960 get_extra_isize(node) - \
961 DEF_INLINE_RESERVED_SIZE))
962 #define DEF_MAX_INLINE_DATA (sizeof(__le32) * \
963 (DEF_ADDRS_PER_INODE - \
964 DEFAULT_INLINE_XATTR_ADDRS - \
965 F2FS_TOTAL_EXTRA_ATTR_SIZE - \
966 DEF_INLINE_RESERVED_SIZE))
967 #define INLINE_DATA_OFFSET (F2FS_BLKSIZE - \
968 sizeof(struct node_footer) - \
969 sizeof(__le32) * (DEF_ADDRS_PER_INODE + \
970 5 - DEF_INLINE_RESERVED_SIZE))
971
972 #define DEF_DIR_LEVEL 0
973
974 /*
975 * i_advise uses FADVISE_XXX_BIT. We can add additional hints later.
976 */
977 #define FADVISE_COLD_BIT 0x01
978 #define FADVISE_LOST_PINO_BIT 0x02
979 #define FADVISE_ENCRYPT_BIT 0x04
980 #define FADVISE_ENC_NAME_BIT 0x08
981 #define FADVISE_KEEP_SIZE_BIT 0x10
982 #define FADVISE_HOT_BIT 0x20
983 #define FADVISE_VERITY_BIT 0x40 /* reserved */
984
985 #define file_is_encrypt(fi) ((fi)->i_advise & FADVISE_ENCRYPT_BIT)
986 #define file_enc_name(fi) ((fi)->i_advise & FADVISE_ENC_NAME_BIT)
987
988 #define F2FS_CASEFOLD_FL 0x40000000 /* Casefolded file */
989 #define IS_CASEFOLDED(dir) ((dir)->i_flags & F2FS_CASEFOLD_FL)
990
991 /*
992 * fsck i_compr_blocks counting helper
993 */
994 struct f2fs_compr_blk_cnt {
995 /* counting i_compr_blocks, init 0 */
996 u32 cnt;
997
998 /*
999 * previous seen compression header (COMPR_ADDR) page offsets,
1000 * use CHEADER_PGOFS_NONE for none
1001 */
1002 u32 cheader_pgofs;
1003 };
1004 #define CHEADER_PGOFS_NONE ((u32)-(1 << MAX_COMPRESS_LOG_SIZE))
1005
1006 /*
1007 * inode flags
1008 */
1009 #define F2FS_COMPR_FL 0x00000004 /* Compress file */
1010 /*
1011 * On disk layout is
1012 * struct f2fs_inode
1013 * struct f2fs_inode_nids
1014 *
1015 * where the size of f2fs_inode depends on block size.
1016 * Do NOT use sizeof
1017 */
1018 struct f2fs_inode {
1019 __le16 i_mode; /* file mode */
1020 __u8 i_advise; /* file hints */
1021 __u8 i_inline; /* file inline flags */
1022 __le32 i_uid; /* user ID */
1023 __le32 i_gid; /* group ID */
1024 __le32 i_links; /* links count */
1025 __le64 i_size; /* file size in bytes */
1026 __le64 i_blocks; /* file size in blocks */
1027 __le64 i_atime; /* access time */
1028 __le64 i_ctime; /* change time */
1029 __le64 i_mtime; /* modification time */
1030 __le32 i_atime_nsec; /* access time in nano scale */
1031 __le32 i_ctime_nsec; /* change time in nano scale */
1032 __le32 i_mtime_nsec; /* modification time in nano scale */
1033 __le32 i_generation; /* file version (for NFS) */
1034 union {
1035 __le32 i_current_depth; /* only for directory depth */
1036 __le16 i_gc_failures; /*
1037 * # of gc failures on pinned file.
1038 * only for regular files.
1039 */
1040 };
1041 __le32 i_xattr_nid; /* nid to save xattr */
1042 __le32 i_flags; /* file attributes */
1043 __le32 i_pino; /* parent inode number */
1044 __le32 i_namelen; /* file name length */
1045 __u8 i_name[F2FS_NAME_LEN]; /* file name for SPOR */
1046 __u8 i_dir_level; /* dentry_level for large dir */
1047
1048 struct f2fs_extent i_ext __attribute__((packed)); /* caching a largest extent */
1049
1050 union {
1051 struct {
1052 __le16 i_extra_isize; /* extra inode attribute size */
1053 __le16 i_inline_xattr_size; /* inline xattr size, unit: 4 bytes */
1054 __le32 i_projid; /* project id */
1055 __le32 i_inode_checksum;/* inode meta checksum */
1056 __le64 i_crtime; /* creation time */
1057 __le32 i_crtime_nsec; /* creation time in nano scale */
1058 __le64 i_compr_blocks; /* # of compressed blocks */
1059 __u8 i_compress_algorithm; /* compress algorithm */
1060 __u8 i_log_cluster_size; /* log of cluster size */
1061 __le16 i_compress_flag; /* compress flag */
1062 /* 0 bit: chksum flag
1063 * [8,15] bits: compress level
1064 */
1065 __le32 i_extra_end[0]; /* for attribute size calculation */
1066 } __attribute__((packed));
1067 __le32 i_addr[0]; /* Pointers to DEF_ADDRS_PER_INODE data blocks */
1068 };
1069 };
1070 struct f2fs_inode_nids {
1071 __le32 i_nid[5]; /* direct(2), indirect(2),
1072 double_indirect(1) node id */
1073 };
1074
1075 #define F2FS_INODE_NIDS(inode) ((struct f2fs_inode_nids *)(&(inode)->i_addr[DEF_ADDRS_PER_INODE]))
1076 #define F2FS_INODE_I_NID(inode, i) (F2FS_INODE_NIDS((inode))->i_nid[(i)])
1077
1078 static_assert(offsetof(struct f2fs_inode, i_extra_end) -
1079 offsetof(struct f2fs_inode, i_extra_isize) == 36, "");
1080
1081 struct direct_node {
1082 __le32 addr[0]; /* array of DEF_ADDRS_PER_BLOCK data block address */
1083 };
1084
1085 struct indirect_node {
1086 __le32 nid[0]; /* array of NIDS_PER_BLOCK data block address */
1087 };
1088
1089 enum {
1090 COLD_BIT_SHIFT = 0,
1091 FSYNC_BIT_SHIFT,
1092 DENT_BIT_SHIFT,
1093 OFFSET_BIT_SHIFT
1094 };
1095
1096 #define XATTR_NODE_OFFSET ((((unsigned int)-1) << OFFSET_BIT_SHIFT) \
1097 >> OFFSET_BIT_SHIFT)
1098 /*
1099 * On disk format is:
1100 * struct f2fs_node
1101 * struct node_footer
1102 *
1103 * where the size of f2fs_node depends on Block Size.
1104 * Do NOT use sizeof. Use F2FS_BLKSIZE instead.
1105 */
1106 struct f2fs_node {
1107 /* can be one of three types: inode, direct, and indirect types */
1108 union {
1109 struct f2fs_inode i;
1110 struct direct_node dn;
1111 struct indirect_node in;
1112 };
1113 };
1114 #define F2FS_NODE_FOOTER(blk) ((struct node_footer *)\
1115 &(((char *)(&(blk)->i))[F2FS_BLKSIZE - sizeof(struct node_footer)]))
1116
1117 /*
1118 * For NAT entries
1119 */
1120 #define NAT_ENTRY_PER_BLOCK (F2FS_BLKSIZE / sizeof(struct f2fs_nat_entry))
1121 #define NAT_BLOCK_OFFSET(start_nid) (start_nid / NAT_ENTRY_PER_BLOCK)
1122
1123 #define DEFAULT_NAT_ENTRY_RATIO 20
1124
1125 struct f2fs_nat_entry {
1126 __u8 version; /* latest version of cached nat entry */
1127 __le32 ino; /* inode number */
1128 __le32 block_addr; /* block address */
1129 } __attribute__((packed));
1130
1131 static_assert(sizeof(struct f2fs_nat_entry) == 9, "");
1132
1133 struct f2fs_nat_block {
1134 struct f2fs_nat_entry entries[0]; /* NAT_ENTRY_PER_BLOCK */
1135 };
1136
1137 /*
1138 * For SIT entries
1139 *
1140 * Each segment is 2MB in size by default so that a bitmap for validity of
1141 * there-in blocks should occupy 64 bytes, 512 bits.
1142 * Not allow to change this.
1143 */
1144 #define SIT_VBLOCK_MAP_SIZE 64
1145 #define SIT_ENTRY_PER_BLOCK (F2FS_BLKSIZE / sizeof(struct f2fs_sit_entry))
1146
1147 /*
1148 * F2FS uses 4 bytes to represent block address. As a result, supported size of
1149 * disk is 16 TB and it equals to 16 * 1024 * 1024 / 2 segments.
1150 */
1151 #define F2FS_MIN_SEGMENT 9 /* SB + 2 (CP + SIT + NAT) + SSA + MAIN */
1152 #define F2FS_MAX_SEGMENT ((16 * 1024 * 1024) / 2)
1153 #define MAX_SIT_BITMAP_SIZE (SEG_ALIGN(SIZE_ALIGN(F2FS_MAX_SEGMENT, \
1154 SIT_ENTRY_PER_BLOCK)) * \
1155 c.blks_per_seg / 8)
1156 #define MAX_CP_PAYLOAD (SEG_ALIGN(SIZE_ALIGN(UINT32_MAX, NAT_ENTRY_PER_BLOCK)) * \
1157 DEFAULT_NAT_ENTRY_RATIO / 100 * \
1158 c.blks_per_seg / 8 + \
1159 MAX_SIT_BITMAP_SIZE - MAX_BITMAP_SIZE_IN_CKPT)
1160
1161 /*
1162 * Note that f2fs_sit_entry->vblocks has the following bit-field information.
1163 * [15:10] : allocation type such as CURSEG_XXXX_TYPE
1164 * [9:0] : valid block count
1165 */
1166 #define SIT_VBLOCKS_SHIFT 10
1167 #define SIT_VBLOCKS_MASK ((1 << SIT_VBLOCKS_SHIFT) - 1)
1168 #define GET_SIT_VBLOCKS(raw_sit) \
1169 (le16_to_cpu((raw_sit)->vblocks) & SIT_VBLOCKS_MASK)
1170 #define GET_SIT_TYPE(raw_sit) \
1171 ((le16_to_cpu((raw_sit)->vblocks) & ~SIT_VBLOCKS_MASK) \
1172 >> SIT_VBLOCKS_SHIFT)
1173
1174 struct f2fs_sit_entry {
1175 __le16 vblocks; /* reference above */
1176 __u8 valid_map[SIT_VBLOCK_MAP_SIZE]; /* bitmap for valid blocks */
1177 __le64 mtime; /* segment age for cleaning */
1178 } __attribute__((packed));
1179
1180 static_assert(sizeof(struct f2fs_sit_entry) == 74, "");
1181
1182 /*
1183 * On disk layout is:
1184 * struct f2fs_sit_entry entries[SIT_ENTRY_PER_BLOCK];
1185 */
1186 struct f2fs_sit_block {
1187 struct f2fs_sit_entry entries[0];
1188 };
1189
1190 /*
1191 * For segment summary
1192 *
1193 * One summary block contains exactly 2048 summary entries, which represents
1194 * exactly 32MB segment by default. Not allow to change the basic units.
1195 *
1196 * NOTE: For initializing fields, you must use set_summary
1197 *
1198 * - If data page, nid represents dnode's nid
1199 * - If node page, nid represents the node page's nid.
1200 *
1201 * The ofs_in_node is used by only data page. It represents offset
1202 * from node's page's beginning to get a data block address.
1203 * ex) data_blkaddr = (block_t)(nodepage_start_address + ofs_in_node)
1204 */
1205 #define ENTRIES_IN_SUM (F2FS_BLKSIZE / 8)
1206 #define SUMMARY_SIZE (7) /* sizeof(struct summary) */
1207 #define SUM_FOOTER_SIZE (5) /* sizeof(struct summary_footer) */
1208 #define SUM_ENTRIES_SIZE (SUMMARY_SIZE * ENTRIES_IN_SUM)
1209
1210 /* a summary entry for a 4KB-sized block in a segment */
1211 struct f2fs_summary {
1212 __le32 nid; /* parent node id */
1213 union {
1214 __u8 reserved[3];
1215 struct {
1216 __u8 version; /* node version number */
1217 __le16 ofs_in_node; /* block index in parent node */
1218 } __attribute__((packed));
1219 };
1220 } __attribute__((packed));
1221
1222 static_assert(sizeof(struct f2fs_summary) == 7, "");
1223
1224 /* summary block type, node or data, is stored to the summary_footer */
1225 #define SUM_TYPE_NODE (1)
1226 #define SUM_TYPE_DATA (0)
1227
1228 struct summary_footer {
1229 unsigned char entry_type; /* SUM_TYPE_XXX */
1230 __le32 check_sum __attribute__((packed)); /* summary checksum */
1231 };
1232
1233 static_assert(sizeof(struct summary_footer) == 5, "");
1234
1235 #define SUM_JOURNAL_SIZE (F2FS_BLKSIZE - SUM_FOOTER_SIZE -\
1236 SUM_ENTRIES_SIZE)
1237 #define NAT_JOURNAL_ENTRIES ((SUM_JOURNAL_SIZE - 2) /\
1238 sizeof(struct nat_journal_entry))
1239 #define NAT_JOURNAL_RESERVED ((SUM_JOURNAL_SIZE - 2) %\
1240 sizeof(struct nat_journal_entry))
1241 #define SIT_JOURNAL_ENTRIES ((SUM_JOURNAL_SIZE - 2) /\
1242 sizeof(struct sit_journal_entry))
1243 #define SIT_JOURNAL_RESERVED ((SUM_JOURNAL_SIZE - 2) %\
1244 sizeof(struct sit_journal_entry))
1245
1246 /*
1247 * Reserved area should make size of f2fs_extra_info equals to
1248 * that of nat_journal and sit_journal.
1249 */
1250 #define EXTRA_INFO_RESERVED (SUM_JOURNAL_SIZE - 2 - 8)
1251
1252 /*
1253 * frequently updated NAT/SIT entries can be stored in the spare area in
1254 * summary blocks
1255 */
1256 enum {
1257 NAT_JOURNAL = 0,
1258 SIT_JOURNAL
1259 };
1260
1261 struct nat_journal_entry {
1262 __le32 nid;
1263 struct f2fs_nat_entry ne;
1264 } __attribute__((packed));
1265
1266 static_assert(sizeof(struct nat_journal_entry) == 13, "");
1267
1268 /*
1269 * Layout is as follows:
1270 * struct nat_journal_entry entries[NAT_JOURNAL_ENTRIES];
1271 * __u8 reserved[NAT_JOURNAL_RESERVED];
1272 */
1273 struct nat_journal {
1274 struct nat_journal_entry entries[0];
1275 };
1276
1277 struct sit_journal_entry {
1278 __le32 segno;
1279 struct f2fs_sit_entry se;
1280 } __attribute__((packed));
1281
1282 static_assert(sizeof(struct sit_journal_entry) == 78, "");
1283
1284 /*
1285 * Layout is as follows:
1286 * struct sit_journal_entry entries[SIT_JOURNAL_ENTRIES];
1287 * __u8 reserved[SIT_JOURNAL_RESERVED];
1288 */
1289 struct sit_journal {
1290 struct sit_journal_entry entries[0];
1291 };
1292
1293 /*
1294 * Layout is as follows:
1295 * __le64 kbytes_written;
1296 * __u8 reserved[EXTRA_INFO_RESERVED];
1297 */
1298 struct f2fs_extra_info {
1299 __le64 kbytes_written;
1300 __u8 reserved[0];
1301 } __attribute__((packed));
1302
1303 /*
1304 * This struct's used size depends on F2FS_BLKSIZE. DO NOT use sizeof
1305 */
1306 struct f2fs_journal {
1307 union {
1308 __le16 n_nats;
1309 __le16 n_sits;
1310 };
1311 /* spare area is used by NAT or SIT journals or extra info */
1312 union {
1313 struct nat_journal nat_j;
1314 struct sit_journal sit_j;
1315 struct f2fs_extra_info info;
1316 };
1317 } __attribute__((packed));
1318
1319 /*
1320 * Block-sized summary block structure
1321 * Layout of f2fs_summary block is
1322 * struct f2fs_summary entries[ENTRIES_IN_SUM];
1323 * struct f2fs_journal journal;
1324 * struct summary_footer footer;
1325 *
1326 * Do NOT use sizeof, use F2FS_BLKSIZE
1327 *
1328 */
1329 struct f2fs_summary_block {
1330 struct f2fs_summary entries[0];
1331 };
1332 #define F2FS_SUMMARY_BLOCK_JOURNAL(blk) ((struct f2fs_journal *)(&(blk)->entries[ENTRIES_IN_SUM]))
1333 #define F2FS_SUMMARY_BLOCK_FOOTER(blk) ((struct summary_footer *)&((char *)\
1334 (&(blk)->entries[0]))[F2FS_BLKSIZE - SUM_FOOTER_SIZE])
1335
1336 /*
1337 * For directory operations
1338 */
1339 #define F2FS_DOT_HASH 0
1340 #define F2FS_DDOT_HASH F2FS_DOT_HASH
1341 #define F2FS_MAX_HASH (~((0x3ULL) << 62))
1342 #define F2FS_HASH_COL_BIT ((0x1ULL) << 63)
1343
1344 typedef __le32 f2fs_hash_t;
1345
1346 /* One directory entry slot covers 8bytes-long file name */
1347 #define F2FS_SLOT_LEN 8
1348 #define F2FS_SLOT_LEN_BITS 3
1349
1350 #define GET_DENTRY_SLOTS(x) ((x + F2FS_SLOT_LEN - 1) >> F2FS_SLOT_LEN_BITS)
1351
1352 /* the number of dentry in a block */
1353 #define NR_DENTRY_IN_BLOCK ((BITS_PER_BYTE * F2FS_BLKSIZE) / \
1354 ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * BITS_PER_BYTE + 1))
1355 /* MAX level for dir lookup */
1356 #define MAX_DIR_HASH_DEPTH 63
1357
1358 /* MAX buckets in one level of dir */
1359 #define MAX_DIR_BUCKETS (1 << ((MAX_DIR_HASH_DEPTH / 2) - 1))
1360
1361 #define SIZE_OF_DIR_ENTRY 11 /* by byte */
1362 #define SIZE_OF_DENTRY_BITMAP ((NR_DENTRY_IN_BLOCK + BITS_PER_BYTE - 1) / \
1363 BITS_PER_BYTE)
1364 #define SIZE_OF_RESERVED (F2FS_BLKSIZE - ((SIZE_OF_DIR_ENTRY + \
1365 F2FS_SLOT_LEN) * \
1366 NR_DENTRY_IN_BLOCK + SIZE_OF_DENTRY_BITMAP))
1367 #define MIN_INLINE_DENTRY_SIZE 40 /* just include '.' and '..' entries */
1368
1369 /* One directory entry slot representing F2FS_SLOT_LEN-sized file name */
1370 struct f2fs_dir_entry {
1371 __le32 hash_code; /* hash code of file name */
1372 __le32 ino; /* inode number */
1373 __le16 name_len; /* lengh of file name */
1374 __u8 file_type; /* file type */
1375 } __attribute__((packed));
1376
1377 static_assert(sizeof(struct f2fs_dir_entry) == 11, "");
1378
1379 /*
1380 * Block-sized directory entry block
1381 * On disk structure:
1382 * struct f2fs_dentry_block;
1383 * __u8 reserved[SIZE_OF_RESERVED];
1384 * struct f2fs_dir_entry dentry[NR_DENTRY_IN_BLOCK];
1385 * __u8 filename[NR_DENTRY_IN_BLOCK][F2FS_SLOT_LEN];
1386 *
1387 * Do NOT use sizeof. Use F2FS_BLKSIZE instead
1388 */
1389 struct f2fs_dentry_block {
1390 /* validity bitmap for directory entries in each block */
1391 __u8 dentry_bitmap[0]; /* size is SIZE_OF_DENTRY_BITMAP, based on block size */
1392 };
1393
1394 #define F2FS_DENTRY_BLOCK_DENTRIES(blk) ((struct f2fs_dir_entry *)\
1395 &((blk)->dentry_bitmap[SIZE_OF_DENTRY_BITMAP + SIZE_OF_RESERVED]))
1396 #define F2FS_DENTRY_BLOCK_DENTRY(blk, i) (F2FS_DENTRY_BLOCK_DENTRIES((blk))[(i)])
1397
1398 #define F2FS_DENTRY_BLOCK_FILENAMES(blk) ((__u8(*)[F2FS_SLOT_LEN])&F2FS_DENTRY_BLOCK_DENTRY(blk,\
1399 NR_DENTRY_IN_BLOCK))
1400 #define F2FS_DENTRY_BLOCK_FILENAME(blk, i) (&((__u8 *)&F2FS_DENTRY_BLOCK_DENTRY(blk,\
1401 NR_DENTRY_IN_BLOCK))[(i) * F2FS_SLOT_LEN])
1402
1403 /* for inline stuff */
1404 #define DEF_INLINE_RESERVED_SIZE 1
1405
1406 /* for inline dir */
1407 #define NR_INLINE_DENTRY(node) (MAX_INLINE_DATA(node) * BITS_PER_BYTE / \
1408 ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
1409 BITS_PER_BYTE + 1))
1410 #define INLINE_DENTRY_BITMAP_SIZE(node) ((NR_INLINE_DENTRY(node) + \
1411 BITS_PER_BYTE - 1) / BITS_PER_BYTE)
1412 #define INLINE_RESERVED_SIZE(node) (MAX_INLINE_DATA(node) - \
1413 ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
1414 NR_INLINE_DENTRY(node) + \
1415 INLINE_DENTRY_BITMAP_SIZE(node)))
1416
1417 /* file types used in inode_info->flags */
1418 enum FILE_TYPE {
1419 F2FS_FT_UNKNOWN,
1420 F2FS_FT_REG_FILE,
1421 F2FS_FT_DIR,
1422 F2FS_FT_CHRDEV,
1423 F2FS_FT_BLKDEV,
1424 F2FS_FT_FIFO,
1425 F2FS_FT_SOCK,
1426 F2FS_FT_SYMLINK,
1427 F2FS_FT_MAX,
1428 /* added for fsck */
1429 F2FS_FT_ORPHAN,
1430 F2FS_FT_XATTR,
1431 F2FS_FT_LAST_FILE_TYPE = F2FS_FT_XATTR,
1432 };
1433
1434 #define LINUX_S_IFMT 00170000
1435 #define LINUX_S_IFREG 0100000
1436 #define LINUX_S_IFDIR 0040000
1437 #define LINUX_S_ISREG(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFREG)
1438 #define LINUX_S_ISDIR(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFDIR)
1439
1440 /* from f2fs/segment.h */
1441 enum {
1442 LFS = 0,
1443 SSR
1444 };
1445
1446 #define MAX_CACHE_SUMS 8
1447
1448 struct f2fs_configuration {
1449 uint32_t conf_reserved_sections;
1450 uint32_t reserved_segments;
1451 uint32_t new_reserved_segments;
1452 int sparse_mode;
1453 int zoned_mode;
1454 int zoned_model;
1455 size_t zone_blocks;
1456 double overprovision;
1457 double new_overprovision;
1458 uint32_t cur_seg[NR_CURSEG_TYPE];
1459 uint32_t segs_per_sec;
1460 uint32_t secs_per_zone;
1461 uint32_t segs_per_zone;
1462 uint32_t start_sector;
1463 uint32_t total_segments;
1464 uint32_t sector_size;
1465 uint64_t device_size;
1466 uint64_t total_sectors;
1467 uint64_t wanted_total_sectors;
1468 uint64_t wanted_sector_size;
1469 uint64_t target_sectors;
1470 uint32_t sectors_per_blk;
1471 uint32_t blks_per_seg;
1472 __u8 init_version[VERSION_LEN + 1];
1473 __u8 sb_version[VERSION_LEN + 1];
1474 __u8 version[VERSION_LEN + 1];
1475 char *vol_label;
1476 char *vol_uuid;
1477 uint16_t s_encoding;
1478 uint16_t s_encoding_flags;
1479 int32_t kd;
1480 int32_t dump_fd;
1481 struct device_info devices[MAX_DEVICES];
1482 int ndevs;
1483 char *extension_list[2];
1484 const char *rootdev_name;
1485 int dbg_lv;
1486 int show_dentry;
1487 int trim;
1488 int trimmed;
1489 int func;
1490 void *private;
1491 int dry_run;
1492 int no_kernel_check;
1493 int fix_on;
1494 int force;
1495 int defset;
1496 int bug_on;
1497 int force_stop;
1498 int abnormal_stop;
1499 int fs_errors;
1500 int bug_nat_bits;
1501 bool quota_fixed;
1502 int alloc_failed;
1503 int auto_fix;
1504 int layout;
1505 int show_file_map;
1506 u64 show_file_map_max_offset;
1507 int quota_fix;
1508 int preen_mode;
1509 int ro;
1510 int preserve_limits; /* preserve quota limits */
1511 int large_nat_bitmap;
1512 int fix_chksum; /* fix old cp.chksum position */
1513 unsigned int feature; /* defined features */
1514 unsigned int quota_bits; /* quota bits */
1515 time_t fixed_time;
1516 int roll_forward;
1517 bool need_fsync;
1518
1519 /* mkfs parameters */
1520 int fake_seed;
1521 uint32_t next_free_nid;
1522 uint32_t lpf_ino;
1523 uint32_t root_uid;
1524 uint32_t root_gid;
1525 uint32_t blksize;
1526 uint32_t blksize_bits;
1527
1528 /* defragmentation parameters */
1529 int defrag_shrink;
1530 uint64_t defrag_start;
1531 uint64_t defrag_len;
1532 uint64_t defrag_target;
1533
1534 /* sload parameters */
1535 char *from_dir;
1536 char *mount_point;
1537 char *target_out_dir;
1538 char *fs_config_file;
1539 #ifdef HAVE_LIBSELINUX
1540 struct selinux_opt seopt_file[8];
1541 int nr_opt;
1542 #endif
1543 int preserve_perms;
1544
1545 /* resize parameters */
1546 int safe_resize;
1547
1548 /* precomputed fs UUID checksum for seeding other checksums */
1549 uint32_t chksum_seed;
1550
1551 /* cache parameters */
1552 dev_cache_config_t cache_config;
1553
1554 /* compression support for sload.f2fs */
1555 compress_config_t compress;
1556
1557 block_t curseg_offset[NR_CURSEG_TYPE];
1558 struct f2fs_summary sum[NR_CURSEG_TYPE][MAX_CACHE_SUMS];
1559 union {
1560 struct f2fs_journal sit_jnl;
1561 char sit_bytes[F2FS_MAX_BLKSIZE];
1562 };
1563 union {
1564 struct f2fs_journal nat_jnl;
1565 char nat_bytes[F2FS_MAX_BLKSIZE];
1566 };
1567 };
1568
1569 extern int utf8_to_utf16(char *, const char *, size_t, size_t);
1570 extern int utf16_to_utf8(char *, const char *, size_t, size_t);
1571 extern int log_base_2(uint32_t);
1572 extern unsigned int addrs_per_inode(struct f2fs_inode *);
1573 extern unsigned int addrs_per_block(struct f2fs_inode *);
1574 extern unsigned int f2fs_max_file_offset(struct f2fs_inode *);
1575 extern __u32 f2fs_inode_chksum(struct f2fs_node *);
1576 extern __u32 f2fs_checkpoint_chksum(struct f2fs_checkpoint *);
1577 extern int write_inode(struct f2fs_node *, u64);
1578
1579 extern int get_bits_in_byte(unsigned char n);
1580 extern int test_and_set_bit_le(u32, u8 *);
1581 extern int test_and_clear_bit_le(u32, u8 *);
1582 extern int test_bit_le(u32, const u8 *);
1583 extern int f2fs_test_bit(unsigned int, const char *);
1584 extern int f2fs_set_bit(unsigned int, char *);
1585 extern int f2fs_clear_bit(unsigned int, char *);
1586 extern u64 find_next_bit_le(const u8 *, u64, u64);
1587 extern u64 find_next_zero_bit_le(const u8 *, u64, u64);
1588
1589 extern uint32_t f2fs_cal_crc32(uint32_t, void *, int);
1590 extern int f2fs_crc_valid(uint32_t blk_crc, void *buf, int len);
1591
1592 extern void f2fs_init_configuration(void);
1593 extern int f2fs_devs_are_umounted(void);
1594 extern int f2fs_dev_is_writable(void);
1595 extern int f2fs_dev_is_umounted(char *);
1596 extern int f2fs_get_device_info(void);
1597 extern int f2fs_get_f2fs_info(void);
1598 extern unsigned int calc_extra_isize(void);
1599 extern int get_device_info(int);
1600 extern int f2fs_init_sparse_file(void);
1601 extern void f2fs_release_sparse_resource(void);
1602 extern int f2fs_finalize_device(void);
1603 extern int f2fs_fsync_device(void);
1604
1605 extern void dcache_init(void);
1606 extern void dcache_release(void);
1607
1608 extern int dev_read(void *, __u64, size_t);
1609 #ifdef POSIX_FADV_WILLNEED
1610 extern int dev_readahead(__u64, size_t);
1611 #else
1612 extern int dev_readahead(__u64, size_t UNUSED(len));
1613 #endif
1614 extern int dev_write(void *, __u64, size_t);
1615 extern int dev_write_block(void *, __u64);
1616 extern int dev_write_dump(void *, __u64, size_t);
1617 /* All bytes in the buffer must be 0 use dev_fill(). */
1618 extern int dev_fill(void *, __u64, size_t);
1619 extern int dev_fill_block(void *, __u64);
1620
1621 extern int dev_read_block(void *, __u64);
1622 extern int dev_reada_block(__u64);
1623
1624 extern int dev_read_version(void *, __u64, size_t);
1625 extern void get_kernel_version(__u8 *);
1626 extern void get_kernel_uname_version(__u8 *);
1627 f2fs_hash_t f2fs_dentry_hash(int, int, const unsigned char *, int);
1628
f2fs_has_extra_isize(struct f2fs_inode * inode)1629 static inline bool f2fs_has_extra_isize(struct f2fs_inode *inode)
1630 {
1631 return (inode->i_inline & F2FS_EXTRA_ATTR);
1632 }
1633
__get_extra_isize(struct f2fs_inode * inode)1634 static inline int __get_extra_isize(struct f2fs_inode *inode)
1635 {
1636 if (f2fs_has_extra_isize(inode))
1637 return le16_to_cpu(inode->i_extra_isize) / sizeof(__le32);
1638 return 0;
1639 }
1640
1641 extern struct f2fs_configuration c;
get_inline_xattr_addrs(struct f2fs_inode * inode)1642 static inline int get_inline_xattr_addrs(struct f2fs_inode *inode)
1643 {
1644 if (c.feature & F2FS_FEATURE_FLEXIBLE_INLINE_XATTR)
1645 return le16_to_cpu(inode->i_inline_xattr_size);
1646 else if (inode->i_inline & F2FS_INLINE_XATTR ||
1647 inode->i_inline & F2FS_INLINE_DENTRY)
1648 return DEFAULT_INLINE_XATTR_ADDRS;
1649 else
1650 return 0;
1651 }
1652
1653 #define get_extra_isize(node) __get_extra_isize(&node->i)
1654
1655 #define F2FS_ZONED_NONE 0
1656 #define F2FS_ZONED_HA 1
1657 #define F2FS_ZONED_HM 2
1658
1659 #ifdef HAVE_LINUX_BLKZONED_H
1660
1661 /* Let's just use v2, since v1 should be compatible with v2 */
1662 #define BLK_ZONE_REP_CAPACITY (1 << 0)
1663 struct blk_zone_v2 {
1664 __u64 start; /* Zone start sector */
1665 __u64 len; /* Zone length in number of sectors */
1666 __u64 wp; /* Zone write pointer position */
1667 __u8 type; /* Zone type */
1668 __u8 cond; /* Zone condition */
1669 __u8 non_seq; /* Non-sequential write resources active */
1670 __u8 reset; /* Reset write pointer recommended */
1671 __u8 resv[4];
1672 __u64 capacity; /* Zone capacity in number of sectors */
1673 __u8 reserved[24];
1674 };
1675 #define blk_zone blk_zone_v2
1676
1677 struct blk_zone_report_v2 {
1678 __u64 sector;
1679 __u32 nr_zones;
1680 __u32 flags;
1681 struct blk_zone zones[0];
1682 };
1683 #define blk_zone_report blk_zone_report_v2
1684
1685 #define blk_zone_type(z) (z)->type
1686 #define blk_zone_conv(z) ((z)->type == BLK_ZONE_TYPE_CONVENTIONAL)
1687 #define blk_zone_seq_req(z) ((z)->type == BLK_ZONE_TYPE_SEQWRITE_REQ)
1688 #define blk_zone_seq_pref(z) ((z)->type == BLK_ZONE_TYPE_SEQWRITE_PREF)
1689 #define blk_zone_seq(z) (blk_zone_seq_req(z) || blk_zone_seq_pref(z))
1690
1691 static inline const char *
blk_zone_type_str(struct blk_zone * blkz)1692 blk_zone_type_str(struct blk_zone *blkz)
1693 {
1694 switch (blk_zone_type(blkz)) {
1695 case BLK_ZONE_TYPE_CONVENTIONAL:
1696 return( "Conventional" );
1697 case BLK_ZONE_TYPE_SEQWRITE_REQ:
1698 return( "Sequential-write-required" );
1699 case BLK_ZONE_TYPE_SEQWRITE_PREF:
1700 return( "Sequential-write-preferred" );
1701 }
1702 return( "Unknown-type" );
1703 }
1704
1705 #define blk_zone_cond(z) (z)->cond
1706
1707 static inline const char *
blk_zone_cond_str(struct blk_zone * blkz)1708 blk_zone_cond_str(struct blk_zone *blkz)
1709 {
1710 switch (blk_zone_cond(blkz)) {
1711 case BLK_ZONE_COND_NOT_WP:
1712 return "Not-write-pointer";
1713 case BLK_ZONE_COND_EMPTY:
1714 return "Empty";
1715 case BLK_ZONE_COND_IMP_OPEN:
1716 return "Implicit-open";
1717 case BLK_ZONE_COND_EXP_OPEN:
1718 return "Explicit-open";
1719 case BLK_ZONE_COND_CLOSED:
1720 return "Closed";
1721 case BLK_ZONE_COND_READONLY:
1722 return "Read-only";
1723 case BLK_ZONE_COND_FULL:
1724 return "Full";
1725 case BLK_ZONE_COND_OFFLINE:
1726 return "Offline";
1727 }
1728 return "Unknown-cond";
1729 }
1730
1731 /*
1732 * Handle kernel zone capacity support
1733 */
1734 #define blk_zone_empty(z) (blk_zone_cond(z) == BLK_ZONE_COND_EMPTY)
1735 #define blk_zone_sector(z) (z)->start
1736 #define blk_zone_length(z) (z)->len
1737 #define blk_zone_wp_sector(z) (z)->wp
1738 #define blk_zone_need_reset(z) (int)(z)->reset
1739 #define blk_zone_non_seq(z) (int)(z)->non_seq
1740 #define blk_zone_capacity(z, f) ((f & BLK_ZONE_REP_CAPACITY) ? \
1741 (z)->capacity : (z)->len)
1742
1743 #endif
1744
1745 struct blk_zone;
1746
1747 extern int f2fs_get_zoned_model(int);
1748 extern int f2fs_get_zone_blocks(int);
1749 extern int f2fs_report_zone(int, uint64_t, struct blk_zone *);
1750 typedef int (report_zones_cb_t)(int i, void *, void *);
1751 extern int f2fs_report_zones(int, report_zones_cb_t *, void *);
1752 extern int f2fs_check_zones(int);
1753 int f2fs_reset_zone(int, void *);
1754 extern int f2fs_reset_zones(int);
1755 int f2fs_finish_zone(int i, void *blkzone);
1756 extern uint32_t f2fs_get_usable_segments(struct f2fs_super_block *sb);
1757
1758 #define SIZE_ALIGN(val, size) (((val) + (size) - 1) / (size))
1759 #define SEG_ALIGN(blks) SIZE_ALIGN(blks, c.blks_per_seg)
1760 #define ZONE_ALIGN(blks) SIZE_ALIGN(blks, c.blks_per_seg * \
1761 c.segs_per_zone)
1762
get_reserved(struct f2fs_super_block * sb,double ovp)1763 static inline uint32_t get_reserved(struct f2fs_super_block *sb, double ovp)
1764 {
1765 uint32_t usable_main_segs = f2fs_get_usable_segments(sb);
1766 uint32_t segs_per_sec = round_up(usable_main_segs, get_sb(section_count));
1767 uint32_t reserved;
1768
1769 if (c.conf_reserved_sections)
1770 reserved = c.conf_reserved_sections * segs_per_sec;
1771 else
1772 reserved = (100 / ovp + 1 + NR_CURSEG_TYPE) * segs_per_sec;
1773
1774 /* Let's keep the section alignment */
1775 return round_up(reserved, segs_per_sec) * segs_per_sec;
1776 }
1777
overprovision_segment_buffer(struct f2fs_super_block * sb)1778 static inline uint32_t overprovision_segment_buffer(struct f2fs_super_block *sb)
1779 {
1780 /* Give 6 current sections to avoid huge GC overheads. */
1781 return 6 * get_sb(segs_per_sec);
1782 }
1783
get_best_overprovision(struct f2fs_super_block * sb)1784 static inline double get_best_overprovision(struct f2fs_super_block *sb)
1785 {
1786 double ovp, candidate, end, diff, space;
1787 double max_ovp = 0, max_space = 0;
1788 uint32_t usable_main_segs = f2fs_get_usable_segments(sb);
1789 uint32_t reserved;
1790
1791 if (get_sb(segment_count_main) < 256) {
1792 candidate = 10;
1793 end = 95;
1794 diff = 5;
1795 } else {
1796 candidate = 0.01;
1797 end = 10;
1798 diff = 0.01;
1799 }
1800
1801 for (; candidate <= end; candidate += diff) {
1802 reserved = get_reserved(sb, candidate);
1803 ovp = (usable_main_segs - reserved) * candidate / 100;
1804 if (ovp < 0)
1805 continue;
1806 space = usable_main_segs - max((double)reserved, ovp) -
1807 overprovision_segment_buffer(sb);
1808 if (max_space < space) {
1809 max_space = space;
1810 max_ovp = candidate;
1811 }
1812 }
1813 return max_ovp;
1814 }
1815
get_cp_crc(struct f2fs_checkpoint * cp)1816 static inline __le64 get_cp_crc(struct f2fs_checkpoint *cp)
1817 {
1818 uint64_t cp_ver = get_cp(checkpoint_ver);
1819 size_t crc_offset = get_cp(checksum_offset);
1820 uint32_t crc = le32_to_cpu(*(__le32 *)((unsigned char *)cp +
1821 crc_offset));
1822
1823 cp_ver |= ((uint64_t)crc << 32);
1824 return cpu_to_le64(cp_ver);
1825 }
1826
exist_qf_ino(struct f2fs_super_block * sb)1827 static inline int exist_qf_ino(struct f2fs_super_block *sb)
1828 {
1829 int i;
1830
1831 for (i = 0; i < F2FS_MAX_QUOTAS; i++)
1832 if (sb->qf_ino[i])
1833 return 1;
1834 return 0;
1835 }
1836
is_qf_ino(struct f2fs_super_block * sb,nid_t ino)1837 static inline int is_qf_ino(struct f2fs_super_block *sb, nid_t ino)
1838 {
1839 int i;
1840
1841 for (i = 0; i < F2FS_MAX_QUOTAS; i++)
1842 if (sb->qf_ino[i] == ino)
1843 return 1;
1844 return 0;
1845 }
1846
show_version(const char * prog)1847 static inline void show_version(const char *prog)
1848 {
1849 #if defined(F2FS_TOOLS_VERSION) && defined(F2FS_TOOLS_DATE)
1850 MSG(0, "%s %s (%s)\n", prog, F2FS_TOOLS_VERSION, F2FS_TOOLS_DATE);
1851 #else
1852 MSG(0, "%s -- version not supported\n", prog);
1853 #endif
1854 }
1855
f2fs_init_inode(struct f2fs_super_block * sb,struct f2fs_node * raw_node,nid_t ino,time_t mtime,mode_t mode)1856 static inline void f2fs_init_inode(struct f2fs_super_block *sb,
1857 struct f2fs_node *raw_node, nid_t ino, time_t mtime, mode_t mode)
1858 {
1859 F2FS_NODE_FOOTER(raw_node)->nid = cpu_to_le32(ino);
1860 F2FS_NODE_FOOTER(raw_node)->ino = cpu_to_le32(ino);
1861 F2FS_NODE_FOOTER(raw_node)->cp_ver = cpu_to_le64(1);
1862
1863 raw_node->i.i_uid = cpu_to_le32(c.root_uid);
1864 raw_node->i.i_gid = cpu_to_le32(c.root_gid);
1865
1866 raw_node->i.i_atime = cpu_to_le32(mtime);
1867 raw_node->i.i_atime_nsec = 0;
1868 raw_node->i.i_ctime = cpu_to_le32(mtime);
1869 raw_node->i.i_ctime_nsec = 0;
1870 raw_node->i.i_mtime = cpu_to_le32(mtime);
1871 raw_node->i.i_mtime_nsec = 0;
1872 raw_node->i.i_generation = 0;
1873 raw_node->i.i_xattr_nid = 0;
1874 raw_node->i.i_flags = 0;
1875 raw_node->i.i_current_depth = cpu_to_le32(LINUX_S_ISDIR(mode) ? 1 : 0);
1876 raw_node->i.i_dir_level = DEF_DIR_LEVEL;
1877 raw_node->i.i_mode = cpu_to_le16(mode);
1878 raw_node->i.i_links = cpu_to_le32(LINUX_S_ISDIR(mode) ? 2 : 1);
1879
1880 /* for dentry block in directory */
1881 raw_node->i.i_size = cpu_to_le64(1 << get_sb(log_blocksize));
1882 raw_node->i.i_blocks = cpu_to_le64(2);
1883
1884 if (c.feature & F2FS_FEATURE_EXTRA_ATTR) {
1885 raw_node->i.i_inline = F2FS_EXTRA_ATTR;
1886 raw_node->i.i_extra_isize = cpu_to_le16(calc_extra_isize());
1887 }
1888
1889 if (c.feature & F2FS_FEATURE_PRJQUOTA)
1890 raw_node->i.i_projid = cpu_to_le32(F2FS_DEF_PROJID);
1891
1892 if (c.feature & F2FS_FEATURE_INODE_CRTIME) {
1893 raw_node->i.i_crtime = cpu_to_le32(mtime);
1894 raw_node->i.i_crtime_nsec = 0;
1895 }
1896
1897 if (c.feature & F2FS_FEATURE_COMPRESSION) {
1898 raw_node->i.i_compr_blocks = 0;
1899 raw_node->i.i_compress_algorithm = 0;
1900 raw_node->i.i_log_cluster_size = 0;
1901 raw_node->i.i_compress_flag = 0;
1902 }
1903
1904 raw_node->i.i_ext.fofs = 0;
1905 raw_node->i.i_ext.blk_addr = 0;
1906 raw_node->i.i_ext.len = 0;
1907 }
1908
1909 struct feature {
1910 char *name;
1911 u32 mask;
1912 u32 settable;
1913 };
1914
1915 #define INIT_FEATURE_TABLE \
1916 struct feature feature_table[] = { \
1917 { "encrypt", F2FS_FEATURE_ENCRYPT, 1}, \
1918 { "blkzoned", F2FS_FEATURE_BLKZONED, 0}, \
1919 { "extra_attr", F2FS_FEATURE_EXTRA_ATTR, 1}, \
1920 { "project_quota", F2FS_FEATURE_PRJQUOTA, 1}, \
1921 { "inode_checksum", F2FS_FEATURE_INODE_CHKSUM, 1}, \
1922 { "flexible_inline_xattr", F2FS_FEATURE_FLEXIBLE_INLINE_XATTR,1}, \
1923 { "quota", F2FS_FEATURE_QUOTA_INO, 1}, \
1924 { "inode_crtime", F2FS_FEATURE_INODE_CRTIME, 1}, \
1925 { "lost_found", F2FS_FEATURE_LOST_FOUND, 1}, \
1926 { "verity", F2FS_FEATURE_VERITY, 1}, \
1927 { "sb_checksum", F2FS_FEATURE_SB_CHKSUM, 1}, \
1928 { "casefold", F2FS_FEATURE_CASEFOLD, 1}, \
1929 { "compression", F2FS_FEATURE_COMPRESSION, 1}, \
1930 { "ro", F2FS_FEATURE_RO, 1}, \
1931 { NULL, 0x0, 0}, \
1932 };
1933
feature_map(struct feature * table,char * feature)1934 static inline u32 feature_map(struct feature *table, char *feature)
1935 {
1936 struct feature *p;
1937 for (p = table; p->name; p++) {
1938 if (!p->settable)
1939 continue;
1940 if (strcmp(p->name, feature))
1941 continue;
1942 break;
1943 }
1944 return p->mask;
1945 }
1946
feature_name(struct feature * table,u32 mask)1947 static inline char *feature_name(struct feature *table, u32 mask)
1948 {
1949 struct feature *p;
1950 for (p = table; p->name; p++) {
1951 if (p->mask != mask)
1952 continue;
1953 break;
1954 }
1955 return p->name;
1956 }
1957
set_feature_bits(struct feature * table,char * features)1958 static inline int set_feature_bits(struct feature *table, char *features)
1959 {
1960 u32 mask = feature_map(table, features);
1961 if (mask) {
1962 c.feature |= mask;
1963 } else {
1964 MSG(0, "Error: Wrong features %s\n", features);
1965 return -1;
1966 }
1967 return 0;
1968 }
1969
parse_feature(struct feature * table,const char * features)1970 static inline int parse_feature(struct feature *table, const char *features)
1971 {
1972 char *buf, *sub, *next;
1973
1974 buf = strdup(features);
1975 if (!buf)
1976 return -1;
1977
1978 for (sub = buf; sub && *sub; sub = next ? next + 1 : NULL) {
1979 /* Skip the beginning blanks */
1980 while (*sub && *sub == ' ')
1981 sub++;
1982 next = sub;
1983 /* Skip a feature word */
1984 while (*next && *next != ' ' && *next != ',')
1985 next++;
1986
1987 if (*next == 0)
1988 next = NULL;
1989 else
1990 *next = 0;
1991
1992 if (set_feature_bits(table, sub)) {
1993 free(buf);
1994 return -1;
1995 }
1996 }
1997 free(buf);
1998 return 0;
1999 }
2000
parse_root_owner(char * ids,uint32_t * root_uid,uint32_t * root_gid)2001 static inline int parse_root_owner(char *ids,
2002 uint32_t *root_uid, uint32_t *root_gid)
2003 {
2004 char *uid = ids;
2005 char *gid = NULL;
2006 int i;
2007
2008 /* uid:gid */
2009 for (i = 0; i < strlen(ids) - 1; i++)
2010 if (*(ids + i) == ':')
2011 gid = ids + i + 1;
2012 if (!gid)
2013 return -1;
2014
2015 *root_uid = atoi(uid);
2016 *root_gid = atoi(gid);
2017 return 0;
2018 }
2019
2020 /*
2021 * NLS definitions
2022 */
2023 struct f2fs_nls_table {
2024 int version;
2025 const struct f2fs_nls_ops *ops;
2026 };
2027
2028 struct f2fs_nls_ops {
2029 int (*casefold)(const struct f2fs_nls_table *charset,
2030 const unsigned char *str, size_t len,
2031 unsigned char *dest, size_t dlen);
2032 };
2033
2034 extern const struct f2fs_nls_table *f2fs_load_nls_table(int encoding);
2035 #define F2FS_ENC_UTF8_12_0 1
2036
2037 extern int f2fs_str2encoding(const char *string);
2038 extern char *f2fs_encoding2str(const int encoding);
2039 extern int f2fs_get_encoding_flags(int encoding);
2040 extern int f2fs_str2encoding_flags(char **param, __u16 *flags);
2041
check_block_struct_sizes(void)2042 static inline void check_block_struct_sizes(void)
2043 {
2044 /* Check Orphan Block Size */
2045 assert(F2FS_ORPHANS_PER_BLOCK * sizeof(__le32)
2046 + sizeof(struct orphan_block_footer) == F2FS_BLKSIZE);
2047
2048 /* Check Inode Block Size */
2049 assert(offsetof(struct f2fs_inode, i_extra_isize) + DEF_ADDRS_PER_INODE * sizeof(__le32)
2050 + sizeof(struct f2fs_inode_nids) + sizeof(struct node_footer) == F2FS_BLKSIZE);
2051
2052 /* Check Direct Block Size */
2053 assert(DEF_ADDRS_PER_BLOCK * sizeof(__le32) + sizeof(struct node_footer) == F2FS_BLKSIZE);
2054
2055 /* Check Indirect Block Size */
2056 assert(NIDS_PER_BLOCK * sizeof(__le32) + sizeof(struct node_footer) == F2FS_BLKSIZE);
2057
2058 /* Check NAT Block Size */
2059 assert((NAT_ENTRY_PER_BLOCK + 1) * sizeof(struct f2fs_nat_entry) > F2FS_BLKSIZE);
2060 assert(NAT_ENTRY_PER_BLOCK * sizeof(struct f2fs_nat_entry) <= F2FS_BLKSIZE);
2061
2062 /* Check SIT Block Size */
2063 assert((SIT_ENTRY_PER_BLOCK + 1) * sizeof(struct f2fs_sit_entry) > F2FS_BLKSIZE);
2064 assert(SIT_ENTRY_PER_BLOCK * sizeof(struct f2fs_sit_entry) <= F2FS_BLKSIZE);
2065
2066 /* Check NAT Journal Block Size */
2067 assert(sizeof(struct f2fs_summary) * ENTRIES_IN_SUM
2068 + offsetof(struct f2fs_journal, nat_j)
2069 + NAT_JOURNAL_ENTRIES * sizeof(struct nat_journal_entry)
2070 + NAT_JOURNAL_RESERVED + sizeof(struct summary_footer) == F2FS_BLKSIZE);
2071
2072 /* Check SIT Journal Block Size */
2073 assert(sizeof(struct f2fs_summary) * ENTRIES_IN_SUM
2074 + offsetof(struct f2fs_journal, sit_j)
2075 + SIT_JOURNAL_ENTRIES * sizeof(struct sit_journal_entry)
2076 + SIT_JOURNAL_RESERVED + sizeof(struct summary_footer) == F2FS_BLKSIZE);
2077
2078 /* Check Info Journal Block Size */
2079 assert(sizeof(struct f2fs_summary) * ENTRIES_IN_SUM + sizeof(__le64)
2080 + offsetof(struct f2fs_journal, info)
2081 + EXTRA_INFO_RESERVED + sizeof(struct summary_footer) == F2FS_BLKSIZE);
2082
2083 /* Check Dentry Block Size */
2084 assert(sizeof(__u8) * (SIZE_OF_DENTRY_BITMAP + SIZE_OF_RESERVED)
2085 + NR_DENTRY_IN_BLOCK * sizeof(struct f2fs_dir_entry)
2086 + NR_DENTRY_IN_BLOCK * F2FS_SLOT_LEN * sizeof(u8) == F2FS_BLKSIZE);
2087 }
2088
2089 #endif /*__F2FS_FS_H */
2090