include/f2fs_fs.h

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