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