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