#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <stddef.h>
#include <string.h>
#include <time.h>
#include <stdbool.h>
#include <limits.h>
#include <inttypes.h>
#include <sys/types.h>

Include dependency graph for f2fs_fs.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	compress_data

struct	compress_ctx

struct	device_info

struct	dev_cache_config_t

struct	compress_ops

struct	filter_ops

struct	compress_config_t

struct	f2fs_device

struct	f2fs_super_block

struct	f2fs_checkpoint

struct	f2fs_orphan_block

struct	orphan_block_footer

struct	f2fs_extent

struct	node_footer

struct	f2fs_compr_blk_cnt

struct	f2fs_inode

struct	f2fs_inode_nids

struct	direct_node

struct	indirect_node

struct	f2fs_node

struct	f2fs_nat_entry

struct	f2fs_nat_block

struct	f2fs_sit_entry

struct	f2fs_sit_block

struct	f2fs_summary

struct	summary_footer

struct	nat_journal_entry

struct	nat_journal

struct	sit_journal_entry

struct	sit_journal

struct	f2fs_extra_info

struct	f2fs_journal

struct	f2fs_summary_block

struct	f2fs_dir_entry

struct	f2fs_dentry_block

struct	f2fs_fault_info

struct	f2fs_configuration

struct	feature

struct	f2fs_nls_table

struct	f2fs_nls_ops

Macros
#define	__SANE_USERSPACE_TYPES__ /* For PPC64, to get LL64 types */

#define	WITH_DUMP

#define	WITH_DEFRAG

#define	WITH_RESIZE

#define	WITH_SLOAD

#define	WITH_LABEL

#define	WITH_INJECT

#define	UNUSED(x) x

#define	static_assert _Static_assert

#define	fallthrough __attribute__((__fallthrough__))

#define	MIN_COMPRESS_LOG_SIZE 2

#define	MAX_COMPRESS_LOG_SIZE 8

#define	COMPRESS_DATA_RESERVED_SIZE 4

#define	COMPRESS_HEADER_SIZE (sizeof(struct compress_data))

#define	le16_to_cpu(x) ((uint16_t)(x))

#define	le32_to_cpu(x) ((uint32_t)(x))

#define	le64_to_cpu(x) ((uint64_t)(x))

#define	cpu_to_le16(x) ((uint16_t)(x))

#define	cpu_to_le32(x) ((uint32_t)(x))

#define	cpu_to_le64(x) ((uint64_t)(x))

#define	be32_to_cpu(x) __builtin_bswap64(x)

#define	typecheck(type, x)

#define	NULL_SEGNO ((unsigned int)~0)

#define	INFO_MSG(fmt, ...)

#define	FIX_MSG(fmt, ...)

#define	ASSERT_MSG(fmt, ...)

#define	ASSERT(exp)

#define	ERR_MSG(fmt, ...)

#define	MSG(n, fmt, ...)

#define	DBG(n, fmt, ...)

#define	DISP(fmt, ptr, member)

#define	DISP_raw_str(fmt, member)

#define	DISP_str(fmt, ptr, member)

#define	DISP_u8(ptr, member)

#define	DISP_u16(ptr, member)

#define	DISP_u32(ptr, member)

#define	DISP_u64(ptr, member)

#define	DISP_utf(ptr, member)

#define	BUF_DISP_u32(buf, data, len, ptr, member)

#define	BUF_DISP_u64(buf, data, len, ptr, member)

#define	BUF_DISP_utf(buf, data, len, ptr, member) snprintf(buf, len, #member)

#define	BITS_PER_BYTE 8

#define	SECTOR_SHIFT 9

#define	F2FS_SUPER_MAGIC 0xF2F52010 /* F2FS Magic Number */

#define	CP_CHKSUM_OFFSET (F2FS_BLKSIZE - sizeof(__le32))

#define	SB_CHKSUM_OFFSET 3068

#define	MAX_PATH_LEN 64

#define	MAX_DEVICES 8

#define	F2FS_BYTES_TO_BLK(bytes) ((bytes) >> F2FS_BLKSIZE_BITS)

#define	F2FS_BLKSIZE_BITS c.blksize_bits

#define	F2FS_NUMBER_OF_CHECKPOINT_PACK 2

#define	DEFAULT_SECTOR_SIZE 512

#define	DEFAULT_SECTORS_PER_BLOCK (1 << (F2FS_BLKSIZE_BITS - SECTOR_SHIFT))

#define	DEFAULT_BLOCKS_PER_SEGMENT 512

#define	DEFAULT_SEGMENTS_PER_SECTION 1

#define	DEFAULT_BLKSIZE_BITS 12 /* 4096 */

#define	VERSION_LEN 256

#define	VERSION_TIMESTAMP_LEN 4

#define	VERSION_NAME_LEN (VERSION_LEN - VERSION_TIMESTAMP_LEN)

#define	LPF "lost+found"

#define	MIN_RSVD_SECS (NR_CURSEG_TYPE + 2U)

#define	CONFIG_RSVD_DEFAULT_OP_RATIO 3.0

#define	ALIGN_DOWN(addrs, size) (((addrs) / (size)) * (size))

#define	ALIGN_UP(addrs, size) ALIGN_DOWN(((addrs) + (size) - 1), (size))

#define	BITS_PER_LONG 32

#define	BIT_MASK(nr) (1 << (nr % BITS_PER_LONG))

#define	BIT_WORD(nr) (nr / BITS_PER_LONG)

#define	set_sb_le64(member, val) (sb->member = cpu_to_le64(val))

#define	set_sb_le32(member, val) (sb->member = cpu_to_le32(val))

#define	set_sb_le16(member, val) (sb->member = cpu_to_le16(val))

#define	get_sb_le64(member) le64_to_cpu(sb->member)

#define	get_sb_le32(member) le32_to_cpu(sb->member)

#define	get_sb_le16(member) le16_to_cpu(sb->member)

#define	get_newsb_le64(member) le64_to_cpu(new_sb->member)

#define	get_newsb_le32(member) le32_to_cpu(new_sb->member)

#define	get_newsb_le16(member) le16_to_cpu(new_sb->member)

#define	set_sb(member, val)

#define	get_sb(member)

#define	get_newsb(member)

#define	set_cp_le64(member, val) (cp->member = cpu_to_le64(val))

#define	set_cp_le32(member, val) (cp->member = cpu_to_le32(val))

#define	set_cp_le16(member, val) (cp->member = cpu_to_le16(val))

#define	get_cp_le64(member) le64_to_cpu(cp->member)

#define	get_cp_le32(member) le32_to_cpu(cp->member)

#define	get_cp_le16(member) le16_to_cpu(cp->member)

#define	set_cp(member, val)

#define	get_cp(member)

#define	__round_mask(x, y) ((__typeof__(x))((y)-1))

#define	round_down(x, y) ((x) & ~__round_mask(x, y))

#define	min(x, y)

#define	max(x, y)

#define	round_up(x, y) (((x) + (y) - 1) / (y))

#define	NR_CURSEG_DATA_TYPE (3)

#define	NR_CURSEG_NODE_TYPE (3)

#define	NR_CURSEG_TYPE (NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE)

#define	F2FS_MIN_SEGMENTS 9 /* SB + 2 (CP + SIT + NAT) + SSA + MAIN */

#define	GET_SUM_TYPE(sum) (F2FS_SUMMARY_BLOCK_FOOTER(sum)->entry_type)

#define	SET_SUM_TYPE(sum, type) (F2FS_SUMMARY_BLOCK_FOOTER(sum)->entry_type = type)

#define	F2FS_SUPER_OFFSET 1024 /* byte-size offset */

#define	F2FS_MIN_LOG_SECTOR_SIZE 9 /* 9 bits for 512 bytes */

#define	F2FS_MAX_LOG_SECTOR_SIZE F2FS_BLKSIZE_BITS /* max sector size is block size */

#define	F2FS_MIN_BLKSIZE 4096

#define	F2FS_MAX_BLKSIZE 16384

#define	F2FS_BLKSIZE c.blksize /* support configurable block size */

#define	F2FS_MAX_EXTENSION 64 /* # of extension entries */

#define	F2FS_EXTENSION_LEN 8 /* max size of extension */

#define	F2FS_BLK_ALIGN(x) (((x) + F2FS_BLKSIZE - 1) / F2FS_BLKSIZE)

#define	NULL_ADDR 0x0U

#define	NEW_ADDR -1U

#define	COMPRESS_ADDR -2U

#define	F2FS_ROOT_INO(sbi) (sbi->root_ino_num)

#define	F2FS_NODE_INO(sbi) (sbi->node_ino_num)

#define	F2FS_META_INO(sbi) (sbi->meta_ino_num)

#define	F2FS_MAX_QUOTAS 3

#define	QUOTA_DATA (((1024 * 6 - 1) / F2FS_BLKSIZE) + 1)

#define	QUOTA_INO(sb, t) (le32_to_cpu((sb)->qf_ino[t]))

#define	F2FS_COMPR_FL 0x00000004 /* Compress file */

#define	F2FS_NODUMP_FL 0x00000040 /* do not dump file */

#define	F2FS_IMMUTABLE_FL 0x00000010 /* Immutable file */

#define	F2FS_NOATIME_FL 0x00000080 /* do not update atime */

#define	F2FS_CASEFOLD_FL 0x40000000 /* Casefolded file */

#define	F2FS_DEVICE_ALIAS_FL 0x80000000 /* File for aliasing a device */

#define	IS_DEVICE_ALIASING(fi) ((fi)->i_flags & cpu_to_le32(F2FS_DEVICE_ALIAS_FL))

#define	F2FS_ENC_UTF8_12_1 1

#define	F2FS_ENC_STRICT_MODE_FL (1 << 0)

#define	F2FS_ENC_NO_COMPAT_FALLBACK_FL (1 << 1)

#define	GFP_F2FS_ZERO (GFP_NOFS \| __GFP_ZERO)

#define	MAX_ACTIVE_LOGS 16

#define	MAX_ACTIVE_NODE_LOGS 8

#define	MAX_ACTIVE_DATA_LOGS 8

#define	F2FS_FEATURE_ENCRYPT 0x0001

#define	F2FS_FEATURE_BLKZONED 0x0002

#define	F2FS_FEATURE_ATOMIC_WRITE 0x0004

#define	F2FS_FEATURE_EXTRA_ATTR 0x0008

#define	F2FS_FEATURE_PRJQUOTA 0x0010

#define	F2FS_FEATURE_INODE_CHKSUM 0x0020

#define	F2FS_FEATURE_FLEXIBLE_INLINE_XATTR 0x0040

#define	F2FS_FEATURE_QUOTA_INO 0x0080

#define	F2FS_FEATURE_INODE_CRTIME 0x0100

#define	F2FS_FEATURE_LOST_FOUND 0x0200

#define	F2FS_FEATURE_VERITY 0x0400 /* reserved */

#define	F2FS_FEATURE_SB_CHKSUM 0x0800

#define	F2FS_FEATURE_CASEFOLD 0x1000

#define	F2FS_FEATURE_COMPRESSION 0x2000

#define	F2FS_FEATURE_RO 0x4000

#define	F2FS_FEATURE_DEVICE_ALIAS 0x8000

#define	MAX_NR_FEATURE 32

#define	MAX_VOLUME_NAME 512

#define	MAX_STOP_REASON 32

#define	MAX_F2FS_ERRORS 16

#define	CP_RESIZEFS_FLAG 0x00004000

#define	CP_DISABLED_FLAG 0x00001000

#define	CP_QUOTA_NEED_FSCK_FLAG 0x00000800

#define	CP_LARGE_NAT_BITMAP_FLAG 0x00000400

#define	CP_NOCRC_RECOVERY_FLAG 0x00000200

#define	CP_TRIMMED_FLAG 0x00000100

#define	CP_NAT_BITS_FLAG 0x00000080

#define	CP_CRC_RECOVERY_FLAG 0x00000040

#define	CP_FASTBOOT_FLAG 0x00000020

#define	CP_FSCK_FLAG 0x00000010

#define	CP_ERROR_FLAG 0x00000008

#define	CP_COMPACT_SUM_FLAG 0x00000004

#define	CP_ORPHAN_PRESENT_FLAG 0x00000002

#define	CP_UMOUNT_FLAG 0x00000001

#define	F2FS_CP_PACKS 2 /* # of checkpoint packs */

#define	CP_BITMAP_OFFSET (offsetof(struct f2fs_checkpoint, sit_nat_version_bitmap))

#define	CP_MIN_CHKSUM_OFFSET CP_BITMAP_OFFSET

#define	MIN_NAT_BITMAP_SIZE 64

#define	MAX_SIT_BITMAP_SIZE_IN_CKPT (CP_CHKSUM_OFFSET - CP_BITMAP_OFFSET - MIN_NAT_BITMAP_SIZE)

#define	MAX_BITMAP_SIZE_IN_CKPT (CP_CHKSUM_OFFSET - CP_BITMAP_OFFSET)

#define	F2FS_ORPHANS_PER_BLOCK ((F2FS_BLKSIZE - 4 * sizeof(__le32)) / sizeof(__le32))

#define	F2FS_ORPHAN_BLOCK_FOOTER(blk) ((struct orphan_block_footer *)&(blk)->ino[F2FS_ORPHANS_PER_BLOCK])

#define	F2FS_NAME_LEN 255

#define	F2FS_PRINT_NAMELEN (4 * ((F2FS_NAME_LEN + 2) / 3) + 1)

#define	DEFAULT_INLINE_XATTR_ADDRS 50

#define	OFFSET_OF_END_OF_I_EXT 360

#define	SIZE_OF_I_NID 20

#define	DEF_ADDRS_PER_INODE

#define	CUR_ADDRS_PER_INODE(inode)

#define	ADDRS_PER_INODE(i) addrs_per_page(i, true)

#define	DEF_ADDRS_PER_BLOCK ((F2FS_BLKSIZE - sizeof(struct node_footer)) / sizeof(__le32))

#define	ADDRS_PER_BLOCK(i) addrs_per_page(i, false)

#define	NIDS_PER_BLOCK ((F2FS_BLKSIZE - sizeof(struct node_footer)) / sizeof(__le32))

#define	NODE_DIR1_BLOCK (DEF_ADDRS_PER_INODE + 1)

#define	NODE_DIR2_BLOCK (DEF_ADDRS_PER_INODE + 2)

#define	NODE_IND1_BLOCK (DEF_ADDRS_PER_INODE + 3)

#define	NODE_IND2_BLOCK (DEF_ADDRS_PER_INODE + 4)

#define	NODE_DIND_BLOCK (DEF_ADDRS_PER_INODE + 5)

#define	F2FS_INLINE_XATTR 0x01 /* file inline xattr flag */

#define	F2FS_INLINE_DATA 0x02 /* file inline data flag */

#define	F2FS_INLINE_DENTRY 0x04 /* file inline dentry flag */

#define	F2FS_DATA_EXIST 0x08 /* file inline data exist flag */

#define	F2FS_INLINE_DOTS 0x10 /* file having implicit dot dentries */

#define	F2FS_EXTRA_ATTR 0x20 /* file having extra attribute */

#define	F2FS_PIN_FILE 0x40 /* file should not be gced */

#define	F2FS_COMPRESS_RELEASED 0x80 /* file released compressed blocks */

#define	F2FS_EXTRA_ISIZE_OFFSET offsetof(struct f2fs_inode, i_extra_isize)

#define	F2FS_TOTAL_EXTRA_ATTR_SIZE (offsetof(struct f2fs_inode, i_extra_end) - F2FS_EXTRA_ISIZE_OFFSET)

#define	F2FS_DEF_PROJID 0 /* default project ID */

#define	MAX_INLINE_DATA(node)

#define	DEF_MAX_INLINE_DATA

#define	INLINE_DATA_OFFSET

#define	DEF_DIR_LEVEL 0

#define	FADVISE_COLD_BIT 0x01

#define	FADVISE_LOST_PINO_BIT 0x02

#define	FADVISE_ENCRYPT_BIT 0x04

#define	FADVISE_ENC_NAME_BIT 0x08

#define	FADVISE_KEEP_SIZE_BIT 0x10

#define	FADVISE_HOT_BIT 0x20

#define	FADVISE_VERITY_BIT 0x40 /* reserved */

#define	file_is_encrypt(fi) ((fi)->i_advise & FADVISE_ENCRYPT_BIT)

#define	file_enc_name(fi) ((fi)->i_advise & FADVISE_ENC_NAME_BIT)

#define	IS_CASEFOLDED(dir) ((dir)->i_flags & cpu_to_le32(F2FS_CASEFOLD_FL))

#define	CHEADER_PGOFS_NONE ((u32)-(1 << MAX_COMPRESS_LOG_SIZE))

#define	F2FS_INODE_NIDS(inode) ((struct f2fs_inode_nids *)(&(inode)->i_addr[DEF_ADDRS_PER_INODE]))

#define	F2FS_INODE_I_NID(inode, i) (F2FS_INODE_NIDS((inode))->i_nid[(i)])

#define	XATTR_NODE_OFFSET

#define	F2FS_NODE_FOOTER(blk)

#define	NAT_ENTRY_PER_BLOCK (F2FS_BLKSIZE / sizeof(struct f2fs_nat_entry))

#define	NAT_BLOCK_OFFSET(start_nid) (start_nid / NAT_ENTRY_PER_BLOCK)

#define	DEFAULT_NAT_ENTRY_RATIO 20

#define	SIT_VBLOCK_MAP_SIZE 64

#define	SIT_ENTRY_PER_BLOCK (F2FS_BLKSIZE / sizeof(struct f2fs_sit_entry))

#define	F2FS_MIN_SEGMENT 9 /* SB + 2 (CP + SIT + NAT) + SSA + MAIN */

#define	F2FS_MAX_SEGMENT ((16 * 1024 * 1024) / 2)

#define	MAX_SIT_BITMAP_SIZE

#define	MAX_CP_PAYLOAD

#define	SIT_VBLOCKS_SHIFT 10

#define	SIT_VBLOCKS_MASK ((1 << SIT_VBLOCKS_SHIFT) - 1)

#define	GET_SIT_VBLOCKS(raw_sit) (le16_to_cpu((raw_sit)->vblocks) & SIT_VBLOCKS_MASK)

#define	GET_SIT_TYPE(raw_sit)

#define	ENTRIES_IN_SUM (F2FS_BLKSIZE / 8)

#define	SUMMARY_SIZE (7) /* sizeof(struct summary) */

#define	SUM_FOOTER_SIZE (5) /* sizeof(struct summary_footer) */

#define	SUM_ENTRIES_SIZE (SUMMARY_SIZE * ENTRIES_IN_SUM)

#define	SUM_TYPE_NODE (1)

#define	SUM_TYPE_DATA (0)

#define	SUM_JOURNAL_SIZE

#define	NAT_JOURNAL_ENTRIES

#define	NAT_JOURNAL_RESERVED

#define	SIT_JOURNAL_ENTRIES

#define	SIT_JOURNAL_RESERVED

#define	EXTRA_INFO_RESERVED (SUM_JOURNAL_SIZE - 2 - 8)

#define	F2FS_SUMMARY_BLOCK_JOURNAL(blk) ((struct f2fs_journal *)(&(blk)->entries[ENTRIES_IN_SUM]))

#define	F2FS_SUMMARY_BLOCK_FOOTER(blk)

#define	F2FS_DOT_HASH 0

#define	F2FS_DDOT_HASH F2FS_DOT_HASH

#define	F2FS_MAX_HASH (~((0x3ULL) << 62))

#define	F2FS_HASH_COL_BIT ((0x1ULL) << 63)

#define	F2FS_SLOT_LEN 8

#define	F2FS_SLOT_LEN_BITS 3

#define	GET_DENTRY_SLOTS(x) ((x + F2FS_SLOT_LEN - 1) >> F2FS_SLOT_LEN_BITS)

#define	NR_DENTRY_IN_BLOCK

#define	MAX_DIR_HASH_DEPTH 63

#define	MAX_DIR_BUCKETS (1 << ((MAX_DIR_HASH_DEPTH / 2) - 1))

#define	SIZE_OF_DIR_ENTRY 11 /* by byte */

#define	SIZE_OF_DENTRY_BITMAP

#define	SIZE_OF_RESERVED

#define	MIN_INLINE_DENTRY_SIZE 40 /* just include '.' and '..' entries */

#define	F2FS_DENTRY_BLOCK_DENTRIES(blk)

#define	F2FS_DENTRY_BLOCK_DENTRY(blk, i) (F2FS_DENTRY_BLOCK_DENTRIES((blk))[(i)])

#define	F2FS_DENTRY_BLOCK_FILENAMES(blk)

#define	F2FS_DENTRY_BLOCK_FILENAME(blk, i)

#define	DEF_INLINE_RESERVED_SIZE 1

#define	NR_INLINE_DENTRY(node)

#define	INLINE_DENTRY_BITMAP_SIZE(node)

#define	INLINE_RESERVED_SIZE(node)

#define	LINUX_S_IFMT 00170000

#define	LINUX_S_IFREG 0100000

#define	LINUX_S_IFDIR 0040000

#define	LINUX_S_ISREG(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFREG)

#define	LINUX_S_ISDIR(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFDIR)

#define	SB_FORCE_STOP 0x1 /* s_stop_reason is set */

#define	SB_ABNORMAL_STOP 0x2 /* s_stop_reason is set except shutdown */

#define	SB_FS_ERRORS 0x4 /* s_erros is set */

#define	SB_INVALID 0x8 /* sb is invalid */

#define	SB_ENCODE_FLAG 0x16 /* encode_flag */

#define	SB_NEED_FIX

#define	MAX_CACHE_SUMS 8

#define	F2FS_ALL_FAULT_TYPE ((1UL << (FAULT_MAX)) - 1)

#define	IS_FAULT_SET(fi, type) ((fi)->inject_type & (1UL << (type)))

#define	get_extra_isize(node) __get_extra_isize(&node->i)

#define	F2FS_ZONED_NONE 0

#define	F2FS_ZONED_HA 1

#define	F2FS_ZONED_HM 2

#define	SIZE_ALIGN(val, size) (((val) + (size) - 1) / (size))

#define	SEG_ALIGN(blks) SIZE_ALIGN(blks, c.blks_per_seg)

#define	ZONE_ALIGN(blks)

#define	INIT_FEATURE_TABLE

#define	F2FS_ENC_UTF8_12_0 1

#define	time_to_inject(type)

Typedefs
typedef uint64_t	u64

typedef uint32_t	u32

typedef uint16_t	u16

typedef uint8_t	u8

typedef u32	block_t

typedef u32	nid_t

typedef unsigned long	pgoff_t

typedef unsigned short	umode_t

typedef u8	__u8

typedef u16	__u16

typedef u32	__u32

typedef u64	__u64

typedef u16	__le16

typedef u32	__le32

typedef u64	__le64

typedef u16	__be16

typedef u32	__be32

typedef u64	__be64

typedef __le32	f2fs_hash_t

typedef int()	report_zones_cb_t(int i, void , void )

Enumerations
enum	rw_hint { WRITE_LIFE_NOT_SET = 0 , WRITE_LIFE_NONE , WRITE_LIFE_SHORT , WRITE_LIFE_MEDIUM , WRITE_LIFE_LONG , WRITE_LIFE_EXTREME }

enum	f2fs_config_func { MKFS , FSCK , DUMP , DEFRAG , RESIZE , SLOAD , LABEL , INJECT }

enum	default_set { CONF_NONE = 0 , CONF_ANDROID }

enum	compress_algorithms { COMPR_LZO , COMPR_LZ4 , MAX_COMPRESS_ALGS }

enum	filter_policy { COMPR_FILTER_UNASSIGNED = 0 , COMPR_FILTER_ALLOW , COMPR_FILTER_DENY }

enum	{ CURSEG_HOT_DATA = 0 , CURSEG_WARM_DATA , CURSEG_COLD_DATA , CURSEG_HOT_NODE , CURSEG_WARM_NODE , CURSEG_COLD_NODE , NO_CHECK_TYPE }

enum	{ CURSEG_RO_HOT_DATA , CURSEG_RO_HOT_NODE , NR_RO_CURSEG_TYPE }

enum	stop_cp_reason { STOP_CP_REASON_SHUTDOWN , STOP_CP_REASON_FAULT_INJECT , STOP_CP_REASON_META_PAGE , STOP_CP_REASON_WRITE_FAIL , STOP_CP_REASON_CORRUPTED_SUMMARY , STOP_CP_REASON_UPDATE_INODE , STOP_CP_REASON_FLUSH_FAIL , STOP_CP_REASON_NO_SEGMENT , STOP_CP_REASON_CORRUPTED_FREE_BITMAP , STOP_CP_REASON_MAX }

enum	f2fs_error { ERROR_CORRUPTED_CLUSTER , ERROR_FAIL_DECOMPRESSION , ERROR_INVALID_BLKADDR , ERROR_CORRUPTED_DIRENT , ERROR_CORRUPTED_INODE , ERROR_INCONSISTENT_SUMMARY , ERROR_INCONSISTENT_FOOTER , ERROR_INCONSISTENT_SUM_TYPE , ERROR_CORRUPTED_JOURNAL , ERROR_INCONSISTENT_NODE_COUNT , ERROR_INCONSISTENT_BLOCK_COUNT , ERROR_INVALID_CURSEG , ERROR_INCONSISTENT_SIT , ERROR_CORRUPTED_VERITY_XATTR , ERROR_CORRUPTED_XATTR , ERROR_INVALID_NODE_REFERENCE , ERROR_INCONSISTENT_NAT , ERROR_MAX }

enum	{ COLD_BIT_SHIFT = 0 , FSYNC_BIT_SHIFT , DENT_BIT_SHIFT , OFFSET_BIT_SHIFT }

enum	{ NAT_JOURNAL = 0 , SIT_JOURNAL }

enum	FILE_TYPE { F2FS_FT_UNKNOWN , F2FS_FT_REG_FILE , F2FS_FT_DIR , F2FS_FT_CHRDEV , F2FS_FT_BLKDEV , F2FS_FT_FIFO , F2FS_FT_SOCK , F2FS_FT_SYMLINK , F2FS_FT_MAX , F2FS_FT_ORPHAN , F2FS_FT_XATTR , F2FS_FT_LAST_FILE_TYPE = F2FS_FT_XATTR }

enum	dot_type { NON_DOT , TYPE_DOT , TYPE_DOTDOT }

enum	{ LFS = 0 , SSR }

enum	{ F2FS_FEATURE_NAT_BITS = 0x0001 }

enum	{ LINEAR_LOOKUP_DEFAULT = 0 , LINEAR_LOOKUP_ENABLE , LINEAR_LOOKUP_DISABLE }

enum	{ FAULT_SEG_TYPE , FAULT_SUM_TYPE , FAULT_SUM_ENT , FAULT_NAT , FAULT_NODE , FAULT_XATTR_ENT , FAULT_COMPR , FAULT_INODE , FAULT_DENTRY , FAULT_DATA , FAULT_QUOTA , FAULT_MAX }

Functions
static uint16_t	bswap_16 (uint16_t val)

static uint32_t	bswap_32 (uint32_t val)

struct f2fs_super_block	__attribute__ ((packed))

int	utf8_to_utf16 (char , const char , size_t, size_t)

int	utf16_to_utf8 (char , const char , size_t, size_t)

int	log_base_2 (uint32_t)

unsigned int	addrs_per_page (struct f2fs_inode *, bool)

u64	f2fs_max_file_offset (struct f2fs_inode *)

__u32	f2fs_inode_chksum (struct f2fs_node *)

__u32	f2fs_checkpoint_chksum (struct f2fs_checkpoint *)

int	write_inode (struct f2fs_node *, u64, enum rw_hint)

int	get_bits_in_byte (unsigned char n)

int	test_and_set_bit_le (u32, u8 *)

int	test_and_clear_bit_le (u32, u8 *)

int	test_bit_le (u32, const u8 *)

int	f2fs_test_bit (unsigned int, const char *)

int	f2fs_set_bit (unsigned int, char *)

int	f2fs_clear_bit (unsigned int, char *)

u64	find_next_bit_le (const u8 *, u64, u64)

u64	find_next_zero_bit_le (const u8 *, u64, u64)

uint32_t	f2fs_cal_crc32 (uint32_t, void *, int)

int	f2fs_crc_valid (uint32_t blk_crc, void *buf, int len)

void	f2fs_init_configuration (void)

int	f2fs_devs_are_umounted (void)

int	f2fs_dev_is_writable (void)

int	f2fs_dev_is_umounted (char *)

int	f2fs_get_device_info (void)

int	f2fs_get_f2fs_info (void)

unsigned int	calc_extra_isize (void)

int	get_device_info (int)

int	f2fs_init_sparse_file (void)

void	f2fs_release_sparse_resource (void)

int	f2fs_finalize_device (void)

int	f2fs_fsync_device (void)

void	dcache_init (void)

void	dcache_release (void)

int	dev_read (void *, __u64, size_t)

int	dev_readahead (__u64, size_t UNUSED(len))

enum rw_hint	f2fs_io_type_to_rw_hint (int)

int	dev_write (void *, __u64, size_t, enum rw_hint)

int	dev_write_block (void *, __u64, enum rw_hint)

int	dev_write_dump (void *, __u64, size_t)

int	dev_write_symlink (char *, size_t)

int	dev_fill (void *, __u64, size_t, enum rw_hint)

int	dev_fill_block (void *, __u64, enum rw_hint)

int	dev_read_block (void *, __u64)

int	dev_reada_block (__u64)

int	dev_read_version (void *, __u64, size_t)

void	get_kernel_version (__u8 *)

void	get_kernel_uname_version (__u8 *)

f2fs_hash_t	f2fs_dentry_hash (int, int, const unsigned char *, int)

static bool	f2fs_has_extra_isize (struct f2fs_inode *inode)

static int	__get_extra_isize (struct f2fs_inode *inode)

static int	get_inline_xattr_addrs (struct f2fs_inode *inode)

int	f2fs_get_zoned_model (int)

int	f2fs_get_zone_blocks (int)

int	f2fs_report_zone (int, uint64_t, struct blk_zone *)

int	f2fs_report_zones (int, report_zones_cb_t , void )

int	f2fs_check_zones (int)

int	f2fs_reset_zone (int, void *)

int	f2fs_reset_zones (int)

int	f2fs_finish_zone (int i, void *blkzone)

uint32_t	f2fs_get_usable_segments (struct f2fs_super_block *sb)

static uint32_t	get_reserved (struct f2fs_super_block *sb, double ovp)

static uint32_t	overprovision_segment_buffer (struct f2fs_super_block *sb)

static double	get_best_overprovision (struct f2fs_super_block *sb)

static __le64	get_cp_crc (struct f2fs_checkpoint *cp)

static int	exist_qf_ino (struct f2fs_super_block *sb)

static int	is_qf_ino (struct f2fs_super_block *sb, nid_t ino)

static void	show_version (const char *prog)

static void	f2fs_init_inode (struct f2fs_super_block sb, struct f2fs_node raw_node, nid_t ino, time_t mtime, mode_t mode)

static u32	feature_map (struct feature table, char feature)

static char *	feature_name (struct feature *table, u32 mask)

static int	set_feature_bits (struct feature table, char features)

static int	parse_feature (struct feature table, const char features)

static int	parse_root_owner (char ids, uint32_t root_uid, uint32_t *root_gid)

const struct f2fs_nls_table *	f2fs_load_nls_table (int encoding)

int	f2fs_str2encoding (const char *string)

char *	f2fs_encoding2str (const int encoding)

int	f2fs_get_encoding_flags (int encoding)

int	f2fs_str2encoding_flags (char *param, __u16 flags)

static void	check_block_struct_sizes (void)

static bool	__time_to_inject (int type, const char func, const char parent_func)

Variables
__le32	magic

__le16	major_ver

__le16	minor_ver

__le32	log_sectorsize

__le32	log_sectors_per_block

__le32	log_blocksize

__le32	log_blocks_per_seg

__le32	segs_per_sec

__le32	secs_per_zone

__le32	checksum_offset

__le32	section_count

__le32	segment_count

__le32	segment_count_ckpt

__le32	segment_count_sit

__le32	segment_count_nat

__le32	segment_count_ssa

__le32	segment_count_main

__le32	segment0_blkaddr

__le32	cp_blkaddr

__le32	sit_blkaddr

__le32	nat_blkaddr

__le32	ssa_blkaddr

__le32	main_blkaddr

__le32	root_ino

__le32	node_ino

__le32	meta_ino

__u8	uuid [16]

__le16	volume_name [MAX_VOLUME_NAME]

__le32	extension_count

__u8	extension_list [F2FS_MAX_EXTENSION][8]

__le32	cp_payload

__u8	version [VERSION_LEN]

__u8	init_version [VERSION_LEN]

__le32	feature

__u8	encryption_level

__u8	encrypt_pw_salt [16]

__u8	hot_ext_count

__le16	s_encoding

__le16	s_encoding_flags

__u8	s_stop_reason [MAX_STOP_REASON]

__u8	s_errors [MAX_F2FS_ERRORS]

__u8	reserved [258]

__le32	crc

struct f2fs_checkpoint	__attribute__

__le16	i_extra_isize

__le16	i_inline_xattr_size

__le32	i_projid

__le32	i_inode_checksum

__le64	i_crtime

__le32	i_crtime_nsec

__le64	i_compr_blocks

__u8	i_compress_algorithm

__u8	i_log_cluster_size

__le16	i_compress_flag

__le32	i_extra_end [0]

__le32	ino

__le32	block_addr

__le16	vblocks

__u8	valid_map [SIT_VBLOCK_MAP_SIZE]

__le64	mtime

__le16	ofs_in_node

__le32	nid

struct f2fs_nat_entry	ne

__le32	segno

struct f2fs_sit_entry	se

__le64	kbytes_written

union {
__le16 n_nats

__le16 n_sits

};

union {
struct nat_journal nat_j

struct sit_journal sit_j

struct f2fs_extra_info info

};

__le32	hash_code

__le16	name_len

__u8	file_type

const char *	f2fs_fault_name [FAULT_MAX]

struct f2fs_configuration	c

Macro Definition Documentation

◆ __round_mask

#define __round_mask	(	x,
		y
	)	((__typeof__(x))((y)-1))

◆ __SANE_USERSPACE_TYPES__

#define __SANE_USERSPACE_TYPES__ /* For PPC64, to get LL64 types */

f2fs_fs.h

Copyright (c) 2012 Samsung Electronics Co., Ltd. http://www.samsung.com/ Copyright (c) 2019 Google Inc. http://www.google.com/ Copyright (c) 2020 Google Inc. Robin Hsu robin.nosp@m.hsu@.nosp@m.googl.nosp@m.e.co.nosp@m.m : add sload compression support

Dual licensed under the GPL or LGPL version 2 licenses.

The byteswap codes are copied from: samba_3_master/lib/ccan/endian/endian.h under LGPL 2.1

◆ ADDRS_PER_BLOCK

#define ADDRS_PER_BLOCK ( i ) addrs_per_page(i, false)

◆ ADDRS_PER_INODE

#define ADDRS_PER_INODE ( i ) addrs_per_page(i, true)

◆ ALIGN_DOWN

#define ALIGN_DOWN	(	addrs,
		size
	)	(((addrs) / (size)) * (size))

◆ ALIGN_UP

#define ALIGN_UP	(	addrs,
		size
	)	ALIGN_DOWN(((addrs) + (size) - 1), (size))

◆ ASSERT

#define ASSERT ( exp )

Value:

    do {                                \
        if (!(exp)) {                       \
            printf("[ASSERT] (%s:%4d) %s\n",        \
                    __func__, __LINE__, #exp);  \
            exit(-1);                   \
        }                           \
    } while (0)

◆ ASSERT_MSG

#define ASSERT_MSG	(	fmt,
		...
	)

Value:

    do {                                \
        printf("[ASSERT] (%s:%4d) ", __func__, __LINE__);   \
        printf(" --> "fmt"\n", ##__VA_ARGS__);          \
        c.bug_on = 1;                       \
    } while (0)

◆ be32_to_cpu

#define be32_to_cpu ( x ) __builtin_bswap64(x)

◆ BIT_MASK

#define BIT_MASK ( nr ) (1 << (nr % BITS_PER_LONG))

◆ BIT_WORD

#define BIT_WORD ( nr ) (nr / BITS_PER_LONG)

◆ BITS_PER_BYTE

#define BITS_PER_BYTE 8

◆ BITS_PER_LONG

#define BITS_PER_LONG 32

◆ BUF_DISP_u32

#define BUF_DISP_u32	(	buf,
		data,
		len,
		ptr,
		member
	)

Value:

    do {                                \
        assert(sizeof((ptr)->member) <= 4);         \
        snprintf(buf, len, #member);                \
        snprintf(data, len, "0x%x : %u", ((ptr)->member),   \
                        ((ptr)->member));   \
    } while (0)

◆ BUF_DISP_u64

#define BUF_DISP_u64	(	buf,
		data,
		len,
		ptr,
		member
	)

Value:

    do {                                \
        assert(sizeof((ptr)->member) == 8);         \
        snprintf(buf, len, #member);                \
        snprintf(data, len, "0x%llx : %llu", ((ptr)->member),   \
                        ((ptr)->member));   \
    } while (0)

◆ BUF_DISP_utf

#define BUF_DISP_utf	(	buf,
		data,
		len,
		ptr,
		member
	)	snprintf(buf, len, #member)

◆ CHEADER_PGOFS_NONE

#define CHEADER_PGOFS_NONE ((u32)-(1 << MAX_COMPRESS_LOG_SIZE))

◆ COMPRESS_ADDR

#define COMPRESS_ADDR -2U

◆ COMPRESS_DATA_RESERVED_SIZE

#define COMPRESS_DATA_RESERVED_SIZE 4

◆ COMPRESS_HEADER_SIZE

#define COMPRESS_HEADER_SIZE (sizeof(struct compress_data))

◆ CONFIG_RSVD_DEFAULT_OP_RATIO

#define CONFIG_RSVD_DEFAULT_OP_RATIO 3.0

◆ CP_BITMAP_OFFSET

#define CP_BITMAP_OFFSET (offsetof(struct f2fs_checkpoint, sit_nat_version_bitmap))

◆ CP_CHKSUM_OFFSET

#define CP_CHKSUM_OFFSET (F2FS_BLKSIZE - sizeof(__le32))

◆ CP_COMPACT_SUM_FLAG

#define CP_COMPACT_SUM_FLAG 0x00000004

◆ CP_CRC_RECOVERY_FLAG

#define CP_CRC_RECOVERY_FLAG 0x00000040

◆ CP_DISABLED_FLAG

#define CP_DISABLED_FLAG 0x00001000

◆ CP_ERROR_FLAG

#define CP_ERROR_FLAG 0x00000008

◆ CP_FASTBOOT_FLAG

#define CP_FASTBOOT_FLAG 0x00000020

◆ CP_FSCK_FLAG

#define CP_FSCK_FLAG 0x00000010

◆ CP_LARGE_NAT_BITMAP_FLAG

#define CP_LARGE_NAT_BITMAP_FLAG 0x00000400

◆ CP_MIN_CHKSUM_OFFSET

#define CP_MIN_CHKSUM_OFFSET CP_BITMAP_OFFSET

◆ CP_NAT_BITS_FLAG

#define CP_NAT_BITS_FLAG 0x00000080

◆ CP_NOCRC_RECOVERY_FLAG

#define CP_NOCRC_RECOVERY_FLAG 0x00000200

◆ CP_ORPHAN_PRESENT_FLAG

#define CP_ORPHAN_PRESENT_FLAG 0x00000002

◆ CP_QUOTA_NEED_FSCK_FLAG

#define CP_QUOTA_NEED_FSCK_FLAG 0x00000800

◆ CP_RESIZEFS_FLAG

#define CP_RESIZEFS_FLAG 0x00004000

◆ CP_TRIMMED_FLAG

#define CP_TRIMMED_FLAG 0x00000100

◆ CP_UMOUNT_FLAG

#define CP_UMOUNT_FLAG 0x00000001

◆ cpu_to_le16

#define cpu_to_le16 ( x ) ((uint16_t)(x))

◆ cpu_to_le32

#define cpu_to_le32 ( x ) ((uint32_t)(x))

◆ cpu_to_le64

#define cpu_to_le64 ( x ) ((uint64_t)(x))

◆ CUR_ADDRS_PER_INODE

#define CUR_ADDRS_PER_INODE ( inode )

Value:

(DEF_ADDRS_PER_INODE - \

__get_extra_isize(inode))

DEF_ADDRS_PER_INODE

#define DEF_ADDRS_PER_INODE

Definition: f2fs_fs.h:945

◆ DBG

#define DBG	(	n,
		fmt,
		...
	)

Value:

    do {                                \
        if (c.dbg_lv >= n && !c.layout && !c.show_file_map) {   \
            printf("[%s:%4d] " fmt,             \
                __func__, __LINE__, ##__VA_ARGS__); \
        }                           \
    } while (0)

◆ DEF_ADDRS_PER_BLOCK

#define DEF_ADDRS_PER_BLOCK ((F2FS_BLKSIZE - sizeof(struct node_footer)) / sizeof(__le32))

◆ DEF_ADDRS_PER_INODE

#define DEF_ADDRS_PER_INODE

Value:

                ((F2FS_BLKSIZE - OFFSET_OF_END_OF_I_EXT \
                - SIZE_OF_I_NID \
                - sizeof(struct node_footer)) / sizeof(__le32))

◆ DEF_DIR_LEVEL

#define DEF_DIR_LEVEL 0

◆ DEF_INLINE_RESERVED_SIZE

#define DEF_INLINE_RESERVED_SIZE 1

◆ DEF_MAX_INLINE_DATA

#define DEF_MAX_INLINE_DATA

Value:

                (sizeof(__le32) *           \
                (DEF_ADDRS_PER_INODE -          \
                DEFAULT_INLINE_XATTR_ADDRS -        \
                F2FS_TOTAL_EXTRA_ATTR_SIZE -        \
                DEF_INLINE_RESERVED_SIZE))

◆ DEFAULT_BLKSIZE_BITS

#define DEFAULT_BLKSIZE_BITS 12 /* 4096 */

◆ DEFAULT_BLOCKS_PER_SEGMENT

#define DEFAULT_BLOCKS_PER_SEGMENT 512

◆ DEFAULT_INLINE_XATTR_ADDRS

#define DEFAULT_INLINE_XATTR_ADDRS 50

◆ DEFAULT_NAT_ENTRY_RATIO

#define DEFAULT_NAT_ENTRY_RATIO 20

◆ DEFAULT_SECTOR_SIZE

#define DEFAULT_SECTOR_SIZE 512

◆ DEFAULT_SECTORS_PER_BLOCK

#define DEFAULT_SECTORS_PER_BLOCK (1 << (F2FS_BLKSIZE_BITS - SECTOR_SHIFT))

◆ DEFAULT_SEGMENTS_PER_SECTION

#define DEFAULT_SEGMENTS_PER_SECTION 1

◆ DISP

#define DISP	(	fmt,
		ptr,
		member
	)

Value:

    do {                        \
        printf("%-30s" fmt, #member, ((ptr)->member));  \
    } while (0)

◆ DISP_raw_str

#define DISP_raw_str	(	fmt,
		member
	)

Value:

    do {                                \
        if (c.layout)                       \
            printf("%-30s " fmt "\n", #member":", member);  \
        else                            \
            printf("%-30s" "\t\t[" fmt "]\n",       \
            #member, member);               \
    } while (0)

◆ DISP_str

#define DISP_str	(	fmt,
		ptr,
		member
	)

Value:

    do {                                \
        if (c.layout)                       \
            printf("%-30s " fmt "\n",           \
            #member":", ((ptr)->member));           \
        else                            \
            printf("%-30s" "\t\t[" fmt "]\n",       \
            #member, ((ptr)->member));          \
    } while (0)

◆ DISP_u16

#define DISP_u16	(	ptr,
		member
	)

Value:

    do {                                \
        assert(sizeof((ptr)->member) == 2);         \
        if (c.layout)                       \
            printf("%-30s %u\n",                \
            #member":", le16_to_cpu(((ptr)->member)));  \
        else                            \
            printf("%-30s" "\t\t[0x%8x : %u]\n",        \
            #member, le16_to_cpu(((ptr)->member)),      \
            le16_to_cpu(((ptr)->member)));          \
    } while (0)

◆ DISP_u32

#define DISP_u32	(	ptr,
		member
	)

Value:

    do {                                \
        assert(sizeof((ptr)->member) <= 4);         \
        if (c.layout)                       \
            printf("%-30s %u\n",                \
            #member":", le32_to_cpu(((ptr)->member)));  \
        else                            \
            printf("%-30s" "\t\t[0x%8x : %u]\n",        \
            #member, le32_to_cpu(((ptr)->member)),      \
            le32_to_cpu(((ptr)->member)));          \
    } while (0)

◆ DISP_u64

#define DISP_u64	(	ptr,
		member
	)

Value:

    do {                                \
        assert(sizeof((ptr)->member) == 8);         \
        if (c.layout)                       \
            printf("%-30s %" PRIu64 "\n",           \
            #member":", le64_to_cpu(((ptr)->member)));  \
        else                            \
            printf("%-30s" "\t\t[0x%8" PRIx64 " : %" PRIu64 "]\n",  \
            #member, le64_to_cpu(((ptr)->member)),      \
            le64_to_cpu(((ptr)->member)));          \
    } while (0)

◆ DISP_u8

#define DISP_u8	(	ptr,
		member
	)

Value:

    do {                                \
        assert(sizeof((ptr)->member) == 1);         \
        if (c.layout)                       \
            printf("%-30s %u\n",                \
            #member":", ((ptr)->member));           \
        else                            \
            printf("%-30s" "\t\t[0x%8x : %u]\n",        \
            #member, ((ptr)->member), ((ptr)->member)); \
    } while (0)

◆ DISP_utf

#define DISP_utf	(	ptr,
		member
	)

Value:

    do {                                \
        if (c.layout)                       \
            printf("%-30s %s\n", #member":",        \
                    ((ptr)->member));       \
        else                            \
            printf("%-30s" "\t\t[%s]\n", #member,       \
                    ((ptr)->member));       \
    } while (0)

◆ ENTRIES_IN_SUM

#define ENTRIES_IN_SUM (F2FS_BLKSIZE / 8)

◆ ERR_MSG

#define ERR_MSG	(	fmt,
		...
	)

Value:

    do {                                \
        printf("[%s:%d] " fmt, __func__, __LINE__, ##__VA_ARGS__); \
    } while (0)

◆ EXTRA_INFO_RESERVED

#define EXTRA_INFO_RESERVED (SUM_JOURNAL_SIZE - 2 - 8)

◆ F2FS_ALL_FAULT_TYPE

#define F2FS_ALL_FAULT_TYPE ((1UL << (FAULT_MAX)) - 1)

◆ F2FS_BLK_ALIGN

#define F2FS_BLK_ALIGN ( x ) (((x) + F2FS_BLKSIZE - 1) / F2FS_BLKSIZE)

◆ F2FS_BLKSIZE

#define F2FS_BLKSIZE c.blksize /* support configurable block size */

◆ F2FS_BLKSIZE_BITS

#define F2FS_BLKSIZE_BITS c.blksize_bits

◆ F2FS_BYTES_TO_BLK

#define F2FS_BYTES_TO_BLK ( bytes ) ((bytes) >> F2FS_BLKSIZE_BITS)

◆ F2FS_CASEFOLD_FL

#define F2FS_CASEFOLD_FL 0x40000000 /* Casefolded file */

◆ F2FS_COMPR_FL

#define F2FS_COMPR_FL 0x00000004 /* Compress file */

◆ F2FS_COMPRESS_RELEASED

#define F2FS_COMPRESS_RELEASED 0x80 /* file released compressed blocks */

◆ F2FS_CP_PACKS

#define F2FS_CP_PACKS 2 /* # of checkpoint packs */

◆ F2FS_DATA_EXIST

#define F2FS_DATA_EXIST 0x08 /* file inline data exist flag */

◆ F2FS_DDOT_HASH

#define F2FS_DDOT_HASH F2FS_DOT_HASH

◆ F2FS_DEF_PROJID

#define F2FS_DEF_PROJID 0 /* default project ID */

◆ F2FS_DENTRY_BLOCK_DENTRIES

#define F2FS_DENTRY_BLOCK_DENTRIES ( blk )

Value:

((struct f2fs_dir_entry *)\

&((blk)->dentry_bitmap[SIZE_OF_DENTRY_BITMAP + SIZE_OF_RESERVED]))

SIZE_OF_RESERVED

#define SIZE_OF_RESERVED

Definition: f2fs_fs.h:1380

SIZE_OF_DENTRY_BITMAP

#define SIZE_OF_DENTRY_BITMAP

Definition: f2fs_fs.h:1378

f2fs_dir_entry

Definition: f2fs_fs.h:1386

◆ F2FS_DENTRY_BLOCK_DENTRY

#define F2FS_DENTRY_BLOCK_DENTRY	(	blk,
		i
	)	(F2FS_DENTRY_BLOCK_DENTRIES((blk))[(i)])

◆ F2FS_DENTRY_BLOCK_FILENAME

#define F2FS_DENTRY_BLOCK_FILENAME	(	blk,
		i
	)

Value:

(&((__u8 *)&F2FS_DENTRY_BLOCK_DENTRY(blk,\

NR_DENTRY_IN_BLOCK))[(i) * F2FS_SLOT_LEN])

__u8

unsigned char __u8

Definition: blkid_types.h:10

NR_DENTRY_IN_BLOCK

#define NR_DENTRY_IN_BLOCK

Definition: f2fs_fs.h:1369

F2FS_SLOT_LEN

#define F2FS_SLOT_LEN

Definition: f2fs_fs.h:1363

F2FS_DENTRY_BLOCK_DENTRY

#define F2FS_DENTRY_BLOCK_DENTRY(blk, i)

Definition: f2fs_fs.h:1412

◆ F2FS_DENTRY_BLOCK_FILENAMES

#define F2FS_DENTRY_BLOCK_FILENAMES ( blk )

Value:

((__u8(*)[F2FS_SLOT_LEN])&F2FS_DENTRY_BLOCK_DENTRY(blk,\

NR_DENTRY_IN_BLOCK))

__u8

u8 __u8

Definition: f2fs_fs.h:128

◆ F2FS_DEVICE_ALIAS_FL

#define F2FS_DEVICE_ALIAS_FL 0x80000000 /* File for aliasing a device */

◆ F2FS_DOT_HASH

#define F2FS_DOT_HASH 0

◆ F2FS_ENC_NO_COMPAT_FALLBACK_FL

#define F2FS_ENC_NO_COMPAT_FALLBACK_FL (1 << 1)

◆ F2FS_ENC_STRICT_MODE_FL

#define F2FS_ENC_STRICT_MODE_FL (1 << 0)

◆ F2FS_ENC_UTF8_12_0

#define F2FS_ENC_UTF8_12_0 1

◆ F2FS_ENC_UTF8_12_1

#define F2FS_ENC_UTF8_12_1 1

◆ F2FS_EXTENSION_LEN

#define F2FS_EXTENSION_LEN 8 /* max size of extension */

◆ F2FS_EXTRA_ATTR

#define F2FS_EXTRA_ATTR 0x20 /* file having extra attribute */

◆ F2FS_EXTRA_ISIZE_OFFSET

#define F2FS_EXTRA_ISIZE_OFFSET offsetof(struct f2fs_inode, i_extra_isize)

◆ F2FS_FEATURE_ATOMIC_WRITE

#define F2FS_FEATURE_ATOMIC_WRITE 0x0004

◆ F2FS_FEATURE_BLKZONED

#define F2FS_FEATURE_BLKZONED 0x0002

◆ F2FS_FEATURE_CASEFOLD

#define F2FS_FEATURE_CASEFOLD 0x1000

◆ F2FS_FEATURE_COMPRESSION

#define F2FS_FEATURE_COMPRESSION 0x2000

◆ F2FS_FEATURE_DEVICE_ALIAS

#define F2FS_FEATURE_DEVICE_ALIAS 0x8000

◆ F2FS_FEATURE_ENCRYPT

#define F2FS_FEATURE_ENCRYPT 0x0001

◆ F2FS_FEATURE_EXTRA_ATTR

#define F2FS_FEATURE_EXTRA_ATTR 0x0008

◆ F2FS_FEATURE_FLEXIBLE_INLINE_XATTR

#define F2FS_FEATURE_FLEXIBLE_INLINE_XATTR 0x0040

◆ F2FS_FEATURE_INODE_CHKSUM

#define F2FS_FEATURE_INODE_CHKSUM 0x0020

◆ F2FS_FEATURE_INODE_CRTIME

#define F2FS_FEATURE_INODE_CRTIME 0x0100

◆ F2FS_FEATURE_LOST_FOUND

#define F2FS_FEATURE_LOST_FOUND 0x0200

◆ F2FS_FEATURE_PRJQUOTA

#define F2FS_FEATURE_PRJQUOTA 0x0010

◆ F2FS_FEATURE_QUOTA_INO

#define F2FS_FEATURE_QUOTA_INO 0x0080

◆ F2FS_FEATURE_RO

#define F2FS_FEATURE_RO 0x4000

◆ F2FS_FEATURE_SB_CHKSUM

#define F2FS_FEATURE_SB_CHKSUM 0x0800

◆ F2FS_FEATURE_VERITY

#define F2FS_FEATURE_VERITY 0x0400 /* reserved */

◆ F2FS_HASH_COL_BIT

#define F2FS_HASH_COL_BIT ((0x1ULL) << 63)

◆ F2FS_IMMUTABLE_FL

#define F2FS_IMMUTABLE_FL 0x00000010 /* Immutable file */

◆ F2FS_INLINE_DATA

#define F2FS_INLINE_DATA 0x02 /* file inline data flag */

◆ F2FS_INLINE_DENTRY

#define F2FS_INLINE_DENTRY 0x04 /* file inline dentry flag */

◆ F2FS_INLINE_DOTS

#define F2FS_INLINE_DOTS 0x10 /* file having implicit dot dentries */

◆ F2FS_INLINE_XATTR

#define F2FS_INLINE_XATTR 0x01 /* file inline xattr flag */

◆ F2FS_INODE_I_NID

#define F2FS_INODE_I_NID	(	inode,
		i
	)	(F2FS_INODE_NIDS((inode))->i_nid[(i)])

◆ F2FS_INODE_NIDS

#define F2FS_INODE_NIDS ( inode ) ((struct f2fs_inode_nids *)(&(inode)->i_addr[DEF_ADDRS_PER_INODE]))

◆ F2FS_MAX_BLKSIZE

#define F2FS_MAX_BLKSIZE 16384

◆ F2FS_MAX_EXTENSION

#define F2FS_MAX_EXTENSION 64 /* # of extension entries */

◆ F2FS_MAX_HASH

#define F2FS_MAX_HASH (~((0x3ULL) << 62))

◆ F2FS_MAX_LOG_SECTOR_SIZE

#define F2FS_MAX_LOG_SECTOR_SIZE F2FS_BLKSIZE_BITS /* max sector size is block size */

◆ F2FS_MAX_QUOTAS

#define F2FS_MAX_QUOTAS 3

◆ F2FS_MAX_SEGMENT

#define F2FS_MAX_SEGMENT ((16 * 1024 * 1024) / 2)

◆ F2FS_META_INO

#define F2FS_META_INO ( sbi ) (sbi->meta_ino_num)

◆ F2FS_MIN_BLKSIZE

#define F2FS_MIN_BLKSIZE 4096

◆ F2FS_MIN_LOG_SECTOR_SIZE

#define F2FS_MIN_LOG_SECTOR_SIZE 9 /* 9 bits for 512 bytes */

◆ F2FS_MIN_SEGMENT

#define F2FS_MIN_SEGMENT 9 /* SB + 2 (CP + SIT + NAT) + SSA + MAIN */

◆ F2FS_MIN_SEGMENTS

#define F2FS_MIN_SEGMENTS 9 /* SB + 2 (CP + SIT + NAT) + SSA + MAIN */

◆ F2FS_NAME_LEN

#define F2FS_NAME_LEN 255

◆ F2FS_NOATIME_FL

#define F2FS_NOATIME_FL 0x00000080 /* do not update atime */

◆ F2FS_NODE_FOOTER

#define F2FS_NODE_FOOTER ( blk )

Value:

((struct node_footer *)\

&(((char *)(&(blk)->i))[F2FS_BLKSIZE - sizeof(struct node_footer)]))

◆ F2FS_NODE_INO

#define F2FS_NODE_INO ( sbi ) (sbi->node_ino_num)

◆ F2FS_NODUMP_FL

#define F2FS_NODUMP_FL 0x00000040 /* do not dump file */

◆ F2FS_NUMBER_OF_CHECKPOINT_PACK

#define F2FS_NUMBER_OF_CHECKPOINT_PACK 2

◆ F2FS_ORPHAN_BLOCK_FOOTER

#define F2FS_ORPHAN_BLOCK_FOOTER ( blk ) ((struct orphan_block_footer *)&(blk)->ino[F2FS_ORPHANS_PER_BLOCK])

◆ F2FS_ORPHANS_PER_BLOCK

#define F2FS_ORPHANS_PER_BLOCK ((F2FS_BLKSIZE - 4 * sizeof(__le32)) / sizeof(__le32))

◆ F2FS_PIN_FILE

#define F2FS_PIN_FILE 0x40 /* file should not be gced */

◆ F2FS_PRINT_NAMELEN

#define F2FS_PRINT_NAMELEN (4 * ((F2FS_NAME_LEN + 2) / 3) + 1)

◆ F2FS_ROOT_INO

#define F2FS_ROOT_INO ( sbi ) (sbi->root_ino_num)

◆ F2FS_SLOT_LEN

#define F2FS_SLOT_LEN 8

◆ F2FS_SLOT_LEN_BITS

#define F2FS_SLOT_LEN_BITS 3

◆ F2FS_SUMMARY_BLOCK_FOOTER

#define F2FS_SUMMARY_BLOCK_FOOTER ( blk )

Value:

((struct summary_footer *)&((char *)\

(&(blk)->entries[0]))[F2FS_BLKSIZE - SUM_FOOTER_SIZE])

SUM_FOOTER_SIZE

#define SUM_FOOTER_SIZE

Definition: f2fs_fs.h:1223

summary_footer

Definition: f2fs_fs.h:1244

◆ F2FS_SUMMARY_BLOCK_JOURNAL

#define F2FS_SUMMARY_BLOCK_JOURNAL ( blk ) ((struct f2fs_journal *)(&(blk)->entries[ENTRIES_IN_SUM]))

◆ F2FS_SUPER_MAGIC

#define F2FS_SUPER_MAGIC 0xF2F52010 /* F2FS Magic Number */

◆ F2FS_SUPER_OFFSET

#define F2FS_SUPER_OFFSET 1024 /* byte-size offset */

◆ F2FS_TOTAL_EXTRA_ATTR_SIZE

#define F2FS_TOTAL_EXTRA_ATTR_SIZE (offsetof(struct f2fs_inode, i_extra_end) - F2FS_EXTRA_ISIZE_OFFSET)

◆ F2FS_ZONED_HA

#define F2FS_ZONED_HA 1

◆ F2FS_ZONED_HM

#define F2FS_ZONED_HM 2

◆ F2FS_ZONED_NONE

#define F2FS_ZONED_NONE 0

◆ FADVISE_COLD_BIT

#define FADVISE_COLD_BIT 0x01

◆ FADVISE_ENC_NAME_BIT

#define FADVISE_ENC_NAME_BIT 0x08

◆ FADVISE_ENCRYPT_BIT

#define FADVISE_ENCRYPT_BIT 0x04

◆ FADVISE_HOT_BIT

#define FADVISE_HOT_BIT 0x20

◆ FADVISE_KEEP_SIZE_BIT

#define FADVISE_KEEP_SIZE_BIT 0x10

◆ FADVISE_LOST_PINO_BIT

#define FADVISE_LOST_PINO_BIT 0x02

◆ FADVISE_VERITY_BIT

#define FADVISE_VERITY_BIT 0x40 /* reserved */

◆ fallthrough

#define fallthrough __attribute__((__fallthrough__))

◆ file_enc_name

#define file_enc_name ( fi ) ((fi)->i_advise & FADVISE_ENC_NAME_BIT)

◆ file_is_encrypt

#define file_is_encrypt ( fi ) ((fi)->i_advise & FADVISE_ENCRYPT_BIT)

◆ FIX_MSG

#define FIX_MSG	(	fmt,
		...
	)

Value:

    do {                                \
        printf("[FIX] (%s:%4d) ", __func__, __LINE__);      \
        printf(" --> "fmt"\n", ##__VA_ARGS__);          \
    } while (0)

◆ get_cp

#define get_cp ( member )

Value:

            ({                      \
                typeof(cp->member) t;           \
                switch (sizeof(t)) {            \
                case 8: t = get_cp_le64(member); break; \
                case 4: t = get_cp_le32(member); break; \
                case 2: t = get_cp_le16(member); break; \
                }                   \
                t; \
            })

◆ get_cp_le16

#define get_cp_le16 ( member ) le16_to_cpu(cp->member)

◆ get_cp_le32

#define get_cp_le32 ( member ) le32_to_cpu(cp->member)

◆ get_cp_le64

#define get_cp_le64 ( member ) le64_to_cpu(cp->member)

◆ GET_DENTRY_SLOTS

#define GET_DENTRY_SLOTS ( x ) ((x + F2FS_SLOT_LEN - 1) >> F2FS_SLOT_LEN_BITS)

◆ get_extra_isize

#define get_extra_isize ( node ) __get_extra_isize(&node->i)

◆ get_newsb

#define get_newsb ( member )

Value:

            ({                      \
                typeof(new_sb->member) t;       \
                switch (sizeof(t)) {            \
                case 8: t = get_newsb_le64(member); break; \
                case 4: t = get_newsb_le32(member); break; \
                case 2: t = get_newsb_le16(member); break; \
                }                   \
                t; \
            })

◆ get_newsb_le16

#define get_newsb_le16 ( member ) le16_to_cpu(new_sb->member)

◆ get_newsb_le32

#define get_newsb_le32 ( member ) le32_to_cpu(new_sb->member)

◆ get_newsb_le64

#define get_newsb_le64 ( member ) le64_to_cpu(new_sb->member)

◆ get_sb

#define get_sb ( member )

Value:

            ({                      \
                typeof(sb->member) t;           \
                switch (sizeof(t)) {            \
                case 8: t = get_sb_le64(member); break; \
                case 4: t = get_sb_le32(member); break; \
                case 2: t = get_sb_le16(member); break; \
                }                   \
                t; \
            })

◆ get_sb_le16

#define get_sb_le16 ( member ) le16_to_cpu(sb->member)

◆ get_sb_le32

#define get_sb_le32 ( member ) le32_to_cpu(sb->member)

◆ get_sb_le64

#define get_sb_le64 ( member ) le64_to_cpu(sb->member)

◆ GET_SIT_TYPE

#define GET_SIT_TYPE ( raw_sit )

Value:

((le16_to_cpu((raw_sit)->vblocks) & ~SIT_VBLOCKS_MASK) \

>> SIT_VBLOCKS_SHIFT)

vblocks

__le16 vblocks

Definition: f2fs_fs.h:0

SIT_VBLOCKS_SHIFT

#define SIT_VBLOCKS_SHIFT

Definition: f2fs_fs.h:1182

◆ GET_SIT_VBLOCKS

#define GET_SIT_VBLOCKS ( raw_sit ) (le16_to_cpu((raw_sit)->vblocks) & SIT_VBLOCKS_MASK)

◆ GET_SUM_TYPE

#define GET_SUM_TYPE ( sum ) (F2FS_SUMMARY_BLOCK_FOOTER(sum)->entry_type)

◆ GFP_F2FS_ZERO

#define GFP_F2FS_ZERO (GFP_NOFS | __GFP_ZERO)

◆ INFO_MSG

#define INFO_MSG	(	fmt,
		...
	)

Value:

    do {                                \
        printf("[INFO] (%s:%4d) ", __func__, __LINE__);     \
        printf(" --> "fmt"\n", ##__VA_ARGS__);          \
    } while (0)

◆ INIT_FEATURE_TABLE

#define INIT_FEATURE_TABLE

Value:

struct feature feature_table[] = {                  \
    { "encrypt",            F2FS_FEATURE_ENCRYPT,       1}, \
    { "blkzoned",           F2FS_FEATURE_BLKZONED,      0}, \
    { "extra_attr",         F2FS_FEATURE_EXTRA_ATTR,    1}, \
    { "project_quota",      F2FS_FEATURE_PRJQUOTA,      1}, \
    { "inode_checksum",     F2FS_FEATURE_INODE_CHKSUM,  1}, \
    { "flexible_inline_xattr",  F2FS_FEATURE_FLEXIBLE_INLINE_XATTR,1}, \
    { "quota",          F2FS_FEATURE_QUOTA_INO,     1}, \
    { "inode_crtime",       F2FS_FEATURE_INODE_CRTIME,  1}, \
    { "lost_found",         F2FS_FEATURE_LOST_FOUND,    1}, \
    { "verity",         F2FS_FEATURE_VERITY,        1}, \
    { "sb_checksum",        F2FS_FEATURE_SB_CHKSUM,     1}, \
    { "casefold",           F2FS_FEATURE_CASEFOLD,      1}, \
    { "compression",        F2FS_FEATURE_COMPRESSION,   1}, \
    { "ro",             F2FS_FEATURE_RO,        1}, \
    { NULL,             0x0,                0}, \
};

◆ INLINE_DATA_OFFSET

#define INLINE_DATA_OFFSET

Value:

                (F2FS_BLKSIZE -             \
                sizeof(struct node_footer) -        \
                sizeof(__le32) * (DEF_ADDRS_PER_INODE + \
                5 - DEF_INLINE_RESERVED_SIZE))

◆ INLINE_DENTRY_BITMAP_SIZE

#define INLINE_DENTRY_BITMAP_SIZE ( node )

Value:

((NR_INLINE_DENTRY(node) + \

BITS_PER_BYTE - 1) / BITS_PER_BYTE)

BITS_PER_BYTE

#define BITS_PER_BYTE

Definition: f2fs_fs.h:404

NR_INLINE_DENTRY

#define NR_INLINE_DENTRY(node)

Definition: f2fs_fs.h:1423

◆ INLINE_RESERVED_SIZE

#define INLINE_RESERVED_SIZE ( node )

Value:

                (MAX_INLINE_DATA(node) - \
                ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
                NR_INLINE_DENTRY(node) + \
                INLINE_DENTRY_BITMAP_SIZE(node)))

◆ IS_CASEFOLDED

#define IS_CASEFOLDED ( dir ) ((dir)->i_flags & cpu_to_le32(F2FS_CASEFOLD_FL))

◆ IS_DEVICE_ALIASING

#define IS_DEVICE_ALIASING ( fi ) ((fi)->i_flags & cpu_to_le32(F2FS_DEVICE_ALIAS_FL))

◆ IS_FAULT_SET

#define IS_FAULT_SET	(	fi,
		type
	)	((fi)->inject_type & (1UL << (type)))

◆ le16_to_cpu

#define le16_to_cpu ( x ) ((uint16_t)(x))

◆ le32_to_cpu

#define le32_to_cpu ( x ) ((uint32_t)(x))

◆ le64_to_cpu

#define le64_to_cpu ( x ) ((uint64_t)(x))

◆ LINUX_S_IFDIR

#define LINUX_S_IFDIR 0040000

◆ LINUX_S_IFMT

#define LINUX_S_IFMT 00170000

◆ LINUX_S_IFREG

#define LINUX_S_IFREG 0100000

◆ LINUX_S_ISDIR

#define LINUX_S_ISDIR ( m ) (((m) & LINUX_S_IFMT) == LINUX_S_IFDIR)

◆ LINUX_S_ISREG

#define LINUX_S_ISREG ( m ) (((m) & LINUX_S_IFMT) == LINUX_S_IFREG)

◆ LPF

#define LPF "lost+found"

◆ max

#define max	(	x,
		y
	)

Value:

    ({              \
    typeof(x) _max1 = (x);          \
    typeof(y) _max2 = (y);          \
    (void) (&_max1 == &_max2);      \
    _max1 > _max2 ? _max1 : _max2; })

◆ MAX_ACTIVE_DATA_LOGS

#define MAX_ACTIVE_DATA_LOGS 8

◆ MAX_ACTIVE_LOGS

#define MAX_ACTIVE_LOGS 16

◆ MAX_ACTIVE_NODE_LOGS

#define MAX_ACTIVE_NODE_LOGS 8

◆ MAX_BITMAP_SIZE_IN_CKPT

#define MAX_BITMAP_SIZE_IN_CKPT (CP_CHKSUM_OFFSET - CP_BITMAP_OFFSET)

◆ MAX_CACHE_SUMS

#define MAX_CACHE_SUMS 8

◆ MAX_COMPRESS_LOG_SIZE

#define MAX_COMPRESS_LOG_SIZE 8

◆ MAX_CP_PAYLOAD

#define MAX_CP_PAYLOAD

Value:

                        (SEG_ALIGN(SIZE_ALIGN(UINT32_MAX, NAT_ENTRY_PER_BLOCK)) * \
                        DEFAULT_NAT_ENTRY_RATIO / 100 * \
                        c.blks_per_seg / 8 + \
                        MAX_SIT_BITMAP_SIZE - MAX_BITMAP_SIZE_IN_CKPT)

◆ MAX_DEVICES

#define MAX_DEVICES 8

◆ MAX_DIR_BUCKETS

#define MAX_DIR_BUCKETS (1 << ((MAX_DIR_HASH_DEPTH / 2) - 1))

◆ MAX_DIR_HASH_DEPTH

#define MAX_DIR_HASH_DEPTH 63

◆ MAX_F2FS_ERRORS

#define MAX_F2FS_ERRORS 16

◆ MAX_INLINE_DATA

#define MAX_INLINE_DATA ( node )

Value:

                (sizeof(__le32) *               \
                (DEF_ADDRS_PER_INODE -          \
                get_inline_xattr_addrs(&node->i) -  \
                get_extra_isize(node) -         \
                DEF_INLINE_RESERVED_SIZE))

◆ MAX_NR_FEATURE

#define MAX_NR_FEATURE 32

◆ MAX_PATH_LEN

#define MAX_PATH_LEN 64

◆ MAX_SIT_BITMAP_SIZE

#define MAX_SIT_BITMAP_SIZE

Value:

                        (SEG_ALIGN(SIZE_ALIGN(F2FS_MAX_SEGMENT, \
                        SIT_ENTRY_PER_BLOCK)) * \
                        c.blks_per_seg / 8)

◆ MAX_SIT_BITMAP_SIZE_IN_CKPT

#define MAX_SIT_BITMAP_SIZE_IN_CKPT (CP_CHKSUM_OFFSET - CP_BITMAP_OFFSET - MIN_NAT_BITMAP_SIZE)

◆ MAX_STOP_REASON

#define MAX_STOP_REASON 32

◆ MAX_VOLUME_NAME

#define MAX_VOLUME_NAME 512

◆ min

#define min	(	x,
		y
	)

Value:

    ({              \
    typeof(x) _min1 = (x);          \
    typeof(y) _min2 = (y);          \
    (void) (&_min1 == &_min2);      \
    _min1 < _min2 ? _min1 : _min2; })

◆ MIN_COMPRESS_LOG_SIZE

#define MIN_COMPRESS_LOG_SIZE 2

◆ MIN_INLINE_DENTRY_SIZE

#define MIN_INLINE_DENTRY_SIZE 40 /* just include '.' and '..' entries */

◆ MIN_NAT_BITMAP_SIZE

#define MIN_NAT_BITMAP_SIZE 64

◆ MIN_RSVD_SECS

#define MIN_RSVD_SECS (NR_CURSEG_TYPE + 2U)

◆ MSG

#define MSG	(	n,
		fmt,
		...
	)

Value:

    do {                                \
        if (c.dbg_lv >= n && !c.layout && !c.show_file_map) {   \
            printf(fmt, ##__VA_ARGS__);         \
        }                           \
    } while (0)

◆ NAT_BLOCK_OFFSET

#define NAT_BLOCK_OFFSET ( start_nid ) (start_nid / NAT_ENTRY_PER_BLOCK)

◆ NAT_ENTRY_PER_BLOCK

#define NAT_ENTRY_PER_BLOCK (F2FS_BLKSIZE / sizeof(struct f2fs_nat_entry))

◆ NAT_JOURNAL_ENTRIES

#define NAT_JOURNAL_ENTRIES

Value:

((SUM_JOURNAL_SIZE - 2) /\

sizeof(struct nat_journal_entry))

SUM_JOURNAL_SIZE

#define SUM_JOURNAL_SIZE

Definition: f2fs_fs.h:1251

nat_journal_entry

Definition: f2fs_fs.h:1277

◆ NAT_JOURNAL_RESERVED

#define NAT_JOURNAL_RESERVED

Value:

((SUM_JOURNAL_SIZE - 2) %\

sizeof(struct nat_journal_entry))

◆ NEW_ADDR

#define NEW_ADDR -1U

◆ NIDS_PER_BLOCK

#define NIDS_PER_BLOCK ((F2FS_BLKSIZE - sizeof(struct node_footer)) / sizeof(__le32))

◆ NODE_DIND_BLOCK

#define NODE_DIND_BLOCK (DEF_ADDRS_PER_INODE + 5)

◆ NODE_DIR1_BLOCK

#define NODE_DIR1_BLOCK (DEF_ADDRS_PER_INODE + 1)

◆ NODE_DIR2_BLOCK

#define NODE_DIR2_BLOCK (DEF_ADDRS_PER_INODE + 2)

◆ NODE_IND1_BLOCK

#define NODE_IND1_BLOCK (DEF_ADDRS_PER_INODE + 3)

◆ NODE_IND2_BLOCK

#define NODE_IND2_BLOCK (DEF_ADDRS_PER_INODE + 4)

◆ NR_CURSEG_DATA_TYPE

#define NR_CURSEG_DATA_TYPE (3)

◆ NR_CURSEG_NODE_TYPE

#define NR_CURSEG_NODE_TYPE (3)

◆ NR_CURSEG_TYPE

#define NR_CURSEG_TYPE (NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE)

◆ NR_DENTRY_IN_BLOCK

#define NR_DENTRY_IN_BLOCK

Value:

((BITS_PER_BYTE * F2FS_BLKSIZE) / \

((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * BITS_PER_BYTE + 1))

◆ NR_INLINE_DENTRY

#define NR_INLINE_DENTRY ( node )

Value:

                (MAX_INLINE_DATA(node) * BITS_PER_BYTE / \
                ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
                BITS_PER_BYTE + 1))

◆ NULL_ADDR

#define NULL_ADDR 0x0U

◆ NULL_SEGNO

#define NULL_SEGNO ((unsigned int)~0)

◆ OFFSET_OF_END_OF_I_EXT

#define OFFSET_OF_END_OF_I_EXT 360

◆ QUOTA_DATA

#define QUOTA_DATA (((1024 * 6 - 1) / F2FS_BLKSIZE) + 1)

◆ QUOTA_INO

#define QUOTA_INO	(	sb,
		t
	)	(le32_to_cpu((sb)->qf_ino[t]))

◆ round_down

#define round_down	(	x,
		y
	)	((x) & ~__round_mask(x, y))

◆ round_up

#define round_up	(	x,
		y
	)	(((x) + (y) - 1) / (y))

◆ SB_ABNORMAL_STOP

#define SB_ABNORMAL_STOP 0x2 /* s_stop_reason is set except shutdown */

◆ SB_CHKSUM_OFFSET

#define SB_CHKSUM_OFFSET 3068

◆ SB_ENCODE_FLAG

#define SB_ENCODE_FLAG 0x16 /* encode_flag */

◆ SB_FORCE_STOP

#define SB_FORCE_STOP 0x1 /* s_stop_reason is set */

◆ SB_FS_ERRORS

#define SB_FS_ERRORS 0x4 /* s_erros is set */

◆ SB_INVALID

#define SB_INVALID 0x8 /* sb is invalid */

◆ SB_NEED_FIX

#define SB_NEED_FIX

Value:

(SB_ABNORMAL_STOP | SB_FS_ERRORS | \

SB_INVALID | SB_ENCODE_FLAG)

SB_FS_ERRORS

#define SB_FS_ERRORS

Definition: f2fs_fs.h:1471

SB_ABNORMAL_STOP

#define SB_ABNORMAL_STOP

Definition: f2fs_fs.h:1470

SB_ENCODE_FLAG

#define SB_ENCODE_FLAG

Definition: f2fs_fs.h:1473

◆ SECTOR_SHIFT

#define SECTOR_SHIFT 9

◆ SEG_ALIGN

#define SEG_ALIGN ( blks ) SIZE_ALIGN(blks, c.blks_per_seg)

◆ set_cp

#define set_cp	(	member,
		val
	)

Value:

            do {                        \
                typeof(cp->member) t = (val);       \
                switch (sizeof(t)) {            \
                case 8: set_cp_le64(member, t); break;  \
                case 4: set_cp_le32(member, t); break;  \
                case 2: set_cp_le16(member, t); break;  \
                }                   \
            } while(0)

◆ set_cp_le16

#define set_cp_le16	(	member,
		val
	)	(cp->member = cpu_to_le16(val))

◆ set_cp_le32

#define set_cp_le32	(	member,
		val
	)	(cp->member = cpu_to_le32(val))

◆ set_cp_le64

#define set_cp_le64	(	member,
		val
	)	(cp->member = cpu_to_le64(val))

◆ set_sb

#define set_sb	(	member,
		val
	)

Value:

            do {                        \
                typeof(sb->member) t = (val);       \
                switch (sizeof(t)) {            \
                case 8: set_sb_le64(member, t); break;  \
                case 4: set_sb_le32(member, t); break;  \
                case 2: set_sb_le16(member, t); break;  \
                }                   \
            } while(0)

◆ set_sb_le16

#define set_sb_le16	(	member,
		val
	)	(sb->member = cpu_to_le16(val))

◆ set_sb_le32

#define set_sb_le32	(	member,
		val
	)	(sb->member = cpu_to_le32(val))

◆ set_sb_le64

#define set_sb_le64	(	member,
		val
	)	(sb->member = cpu_to_le64(val))

◆ SET_SUM_TYPE

#define SET_SUM_TYPE	(	sum,
		type
	)	(F2FS_SUMMARY_BLOCK_FOOTER(sum)->entry_type = type)

◆ SIT_ENTRY_PER_BLOCK

#define SIT_ENTRY_PER_BLOCK (F2FS_BLKSIZE / sizeof(struct f2fs_sit_entry))

◆ SIT_JOURNAL_ENTRIES

#define SIT_JOURNAL_ENTRIES

Value:

((SUM_JOURNAL_SIZE - 2) /\

sizeof(struct sit_journal_entry))

sit_journal_entry

Definition: f2fs_fs.h:1293

◆ SIT_JOURNAL_RESERVED

#define SIT_JOURNAL_RESERVED

Value:

((SUM_JOURNAL_SIZE - 2) %\

sizeof(struct sit_journal_entry))

◆ SIT_VBLOCK_MAP_SIZE

#define SIT_VBLOCK_MAP_SIZE 64

◆ SIT_VBLOCKS_MASK

#define SIT_VBLOCKS_MASK ((1 << SIT_VBLOCKS_SHIFT) - 1)

◆ SIT_VBLOCKS_SHIFT

#define SIT_VBLOCKS_SHIFT 10

◆ SIZE_ALIGN

#define SIZE_ALIGN	(	val,
		size
	)	(((val) + (size) - 1) / (size))

◆ SIZE_OF_DENTRY_BITMAP

#define SIZE_OF_DENTRY_BITMAP

Value:

((NR_DENTRY_IN_BLOCK + BITS_PER_BYTE - 1) / \

BITS_PER_BYTE)

◆ SIZE_OF_DIR_ENTRY

#define SIZE_OF_DIR_ENTRY 11 /* by byte */

◆ SIZE_OF_I_NID

#define SIZE_OF_I_NID 20

◆ SIZE_OF_RESERVED

#define SIZE_OF_RESERVED

Value:

                (F2FS_BLKSIZE - ((SIZE_OF_DIR_ENTRY + \
                F2FS_SLOT_LEN) * \
                NR_DENTRY_IN_BLOCK + SIZE_OF_DENTRY_BITMAP))

◆ static_assert

#define static_assert _Static_assert

◆ SUM_ENTRIES_SIZE

#define SUM_ENTRIES_SIZE (SUMMARY_SIZE * ENTRIES_IN_SUM)

◆ SUM_FOOTER_SIZE

#define SUM_FOOTER_SIZE (5) /* sizeof(struct summary_footer) */

◆ SUM_JOURNAL_SIZE

#define SUM_JOURNAL_SIZE

Value:

(F2FS_BLKSIZE - SUM_FOOTER_SIZE -\

SUM_ENTRIES_SIZE)

◆ SUM_TYPE_DATA

#define SUM_TYPE_DATA (0)

◆ SUM_TYPE_NODE

#define SUM_TYPE_NODE (1)

◆ SUMMARY_SIZE

#define SUMMARY_SIZE (7) /* sizeof(struct summary) */

◆ time_to_inject

#define time_to_inject ( type )

Value:

__time_to_inject(type, __func__, \

__builtin_return_address(0))

__time_to_inject

static bool __time_to_inject(int type, const char *func, const char *parent_func)

Definition: f2fs_fs.h:2182

type

uint8_t type

Definition: pairing_connection.h:0

◆ typecheck

#define typecheck	(	type,
		x
	)

Value:

    ({  type __dummy; \
        typeof(x) __dummy2; \
        (void)(&__dummy == &__dummy2); \
        1; \
     })

◆ UNUSED

#define UNUSED ( x ) x

◆ VERSION_LEN

#define VERSION_LEN 256

◆ VERSION_NAME_LEN

#define VERSION_NAME_LEN (VERSION_LEN - VERSION_TIMESTAMP_LEN)

◆ VERSION_TIMESTAMP_LEN

#define VERSION_TIMESTAMP_LEN 4

◆ WITH_DEFRAG

#define WITH_DEFRAG

◆ WITH_DUMP

#define WITH_DUMP

◆ WITH_INJECT

#define WITH_INJECT

◆ WITH_LABEL

#define WITH_LABEL

◆ WITH_RESIZE

#define WITH_RESIZE

◆ WITH_SLOAD

#define WITH_SLOAD

◆ XATTR_NODE_OFFSET

#define XATTR_NODE_OFFSET

Value:

((((unsigned int)-1) << OFFSET_BIT_SHIFT) \

>> OFFSET_BIT_SHIFT)

OFFSET_BIT_SHIFT

@ OFFSET_BIT_SHIFT

Definition: f2fs_fs.h:1109

◆ ZONE_ALIGN

#define ZONE_ALIGN ( blks )

Value:

SIZE_ALIGN(blks, c.blks_per_seg * \

c.segs_per_zone)

f2fs_configuration::segs_per_zone

uint32_t segs_per_zone

Definition: f2fs_fs.h:1532

f2fs_configuration::blks_per_seg

uint32_t blks_per_seg

Definition: f2fs_fs.h:1542

Typedef Documentation

◆ __be16

typedef u16 __be16

◆ __be32

typedef u32 __be32

◆ __be64

typedef u64 __be64

◆ __le16

typedef u16 __le16

◆ __le32

typedef u32 __le32

◆ __le64

typedef u64 __le64

◆ __u16

typedef u16 __u16

◆ __u32

typedef u32 __u32

◆ __u64

typedef u64 __u64

◆ __u8

typedef u8 __u8

◆ block_t

typedef u32 block_t

◆ f2fs_hash_t

typedef __le32 f2fs_hash_t

◆ nid_t

typedef u32 nid_t

◆ pgoff_t

typedef unsigned long pgoff_t

◆ report_zones_cb_t

typedef int() report_zones_cb_t(int i, void *, void *)

◆ u16

typedef uint16_t u16

◆ u32

typedef uint32_t u32

◆ u64

typedef uint64_t u64

◆ u8

typedef uint8_t u8

◆ umode_t

typedef unsigned short umode_t

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
COLD_BIT_SHIFT
FSYNC_BIT_SHIFT
DENT_BIT_SHIFT
OFFSET_BIT_SHIFT

◆ anonymous enum

anonymous enum

Enumerator
NAT_JOURNAL
SIT_JOURNAL

◆ anonymous enum

anonymous enum

Enumerator
LFS
SSR

◆ anonymous enum

anonymous enum

Enumerator
F2FS_FEATURE_NAT_BITS

◆ anonymous enum

anonymous enum

Enumerator
LINEAR_LOOKUP_DEFAULT
LINEAR_LOOKUP_ENABLE
LINEAR_LOOKUP_DISABLE

◆ anonymous enum

anonymous enum

Enumerator
FAULT_SEG_TYPE
FAULT_SUM_TYPE
FAULT_SUM_ENT
FAULT_NAT
FAULT_NODE
FAULT_XATTR_ENT
FAULT_COMPR
FAULT_INODE
FAULT_DENTRY
FAULT_DATA
FAULT_QUOTA
FAULT_MAX

◆ anonymous enum

anonymous enum

Enumerator
CURSEG_HOT_DATA
CURSEG_WARM_DATA
CURSEG_COLD_DATA
CURSEG_HOT_NODE
CURSEG_WARM_NODE
CURSEG_COLD_NODE
NO_CHECK_TYPE

◆ anonymous enum

anonymous enum

Enumerator
CURSEG_RO_HOT_DATA
CURSEG_RO_HOT_NODE
NR_RO_CURSEG_TYPE

◆ compress_algorithms

enum compress_algorithms

Enumerator
COMPR_LZO
COMPR_LZ4
MAX_COMPRESS_ALGS

◆ default_set

enum default_set

Enumerator
CONF_NONE
CONF_ANDROID

◆ dot_type

enum dot_type

Enumerator
NON_DOT
TYPE_DOT
TYPE_DOTDOT

◆ f2fs_config_func

enum f2fs_config_func

Enumerator
MKFS
FSCK
DUMP
DEFRAG
RESIZE
SLOAD
LABEL
INJECT

◆ f2fs_error

enum f2fs_error

Enumerator
ERROR_CORRUPTED_CLUSTER
ERROR_FAIL_DECOMPRESSION
ERROR_INVALID_BLKADDR
ERROR_CORRUPTED_DIRENT
ERROR_CORRUPTED_INODE
ERROR_INCONSISTENT_SUMMARY
ERROR_INCONSISTENT_FOOTER
ERROR_INCONSISTENT_SUM_TYPE
ERROR_CORRUPTED_JOURNAL
ERROR_INCONSISTENT_NODE_COUNT
ERROR_INCONSISTENT_BLOCK_COUNT
ERROR_INVALID_CURSEG
ERROR_INCONSISTENT_SIT
ERROR_CORRUPTED_VERITY_XATTR
ERROR_CORRUPTED_XATTR
ERROR_INVALID_NODE_REFERENCE
ERROR_INCONSISTENT_NAT
ERROR_MAX

◆ FILE_TYPE

enum FILE_TYPE

Enumerator
F2FS_FT_UNKNOWN
F2FS_FT_REG_FILE
F2FS_FT_DIR
F2FS_FT_CHRDEV
F2FS_FT_BLKDEV
F2FS_FT_FIFO
F2FS_FT_SOCK
F2FS_FT_SYMLINK
F2FS_FT_MAX
F2FS_FT_ORPHAN
F2FS_FT_XATTR
F2FS_FT_LAST_FILE_TYPE

◆ filter_policy

enum filter_policy

Enumerator
COMPR_FILTER_UNASSIGNED
COMPR_FILTER_ALLOW
COMPR_FILTER_DENY

◆ rw_hint

enum rw_hint

Enumerator
WRITE_LIFE_NOT_SET
WRITE_LIFE_NONE
WRITE_LIFE_SHORT
WRITE_LIFE_MEDIUM
WRITE_LIFE_LONG
WRITE_LIFE_EXTREME

◆ stop_cp_reason

enum stop_cp_reason

Enumerator
STOP_CP_REASON_SHUTDOWN
STOP_CP_REASON_FAULT_INJECT
STOP_CP_REASON_META_PAGE
STOP_CP_REASON_WRITE_FAIL
STOP_CP_REASON_CORRUPTED_SUMMARY
STOP_CP_REASON_UPDATE_INODE
STOP_CP_REASON_FLUSH_FAIL
STOP_CP_REASON_NO_SEGMENT
STOP_CP_REASON_CORRUPTED_FREE_BITMAP
STOP_CP_REASON_MAX

Function Documentation

◆ attribute()

struct f2fs_super_block __attribute__ ( (packed) )

◆ __get_extra_isize()

static int __get_extra_isize ( struct f2fs_inode * inode )

inlinestatic

◆ __time_to_inject()

static bool __time_to_inject	(	int	type,
		const char *	func,
		const char *	parent_func
	)

inlinestatic

◆ addrs_per_page()

unsigned int addrs_per_page	(	struct f2fs_inode *	i,
		bool	is_inode
	)

◆ bswap_16()

static uint16_t bswap_16 ( uint16_t val )

inlinestatic

bswap_16 - reverse bytes in a uint16_t value. @val: value whose bytes to swap.

Example: // Output contains "1024 is 4 as two bytes reversed" printf("1024 is %u as two bytes reversed\n", bswap_16(1024));

◆ bswap_32()

static uint32_t bswap_32 ( uint32_t val )

inlinestatic

bswap_32 - reverse bytes in a uint32_t value. @val: value whose bytes to swap.

Example: // Output contains "1024 is 262144 as four bytes reversed" printf("1024 is %u as four bytes reversed\n", bswap_32(1024));

◆ calc_extra_isize()

unsigned int calc_extra_isize ( void )

◆ check_block_struct_sizes()

static void check_block_struct_sizes ( void )

inlinestatic

◆ dcache_init()

void dcache_init ( void )

◆ dcache_release()

void dcache_release ( void )

◆ dev_fill()

int dev_fill	(	void *	buf,
		__u64	offset,
		size_t	len,
		enum	rw_hint
	)

◆ dev_fill_block()

int dev_fill_block	(	void *	buf,
		__u64	blk_addr,
		enum	rw_hint
	)

◆ dev_read()

int dev_read	(	void *	buf,
		__u64	offset,
		size_t	len
	)

◆ dev_read_block()

int dev_read_block	(	void *	buf,
		__u64	blk_addr
	)

◆ dev_read_version()

int dev_read_version	(	void *	buf,
		__u64	offset,
		size_t	len
	)

◆ dev_reada_block()

int dev_reada_block ( __u64 blk_addr )

◆ dev_readahead()

int dev_readahead	(	__u64	offset,
		size_t	UNUSEDlen
	)

◆ dev_write()

int dev_write	(	void *	buf,
		__u64	offset,
		size_t	len,
		enum	rw_hint
	)

◆ dev_write_block()

int dev_write_block	(	void *	buf,
		__u64	blk_addr,
		enum	rw_hint
	)

◆ dev_write_dump()

int dev_write_dump	(	void *	buf,
		__u64	offset,
		size_t	len
	)

◆ dev_write_symlink()

int dev_write_symlink	(	char *	buf,
		size_t	len
	)

◆ exist_qf_ino()

static int exist_qf_ino ( struct f2fs_super_block * sb )

inlinestatic

◆ f2fs_cal_crc32()

uint32_t f2fs_cal_crc32	(	uint32_t	crc,
		void *	buf,
		int	len
	)

◆ f2fs_check_zones()

int f2fs_check_zones ( int i )

◆ f2fs_checkpoint_chksum()

__u32 f2fs_checkpoint_chksum ( struct f2fs_checkpoint * cp )

◆ f2fs_clear_bit()

int f2fs_clear_bit	(	unsigned int	nr,
		char *	addr
	)

◆ f2fs_crc_valid()

int f2fs_crc_valid	(	uint32_t	blk_crc,
		void *	buf,
		int	len
	)

◆ f2fs_dentry_hash()

f2fs_hash_t f2fs_dentry_hash	(	int	encoding,
		int	casefolded,
		const unsigned char *	name,
		int	len
	)

◆ f2fs_dev_is_umounted()

int f2fs_dev_is_umounted ( char * path )

◆ f2fs_dev_is_writable()

int f2fs_dev_is_writable ( void )

◆ f2fs_devs_are_umounted()

int f2fs_devs_are_umounted ( void )

◆ f2fs_encoding2str()

char * f2fs_encoding2str ( const int encoding )

◆ f2fs_finalize_device()

int f2fs_finalize_device ( void )

◆ f2fs_finish_zone()

int f2fs_finish_zone	(	int	i,
		void *	blkzone
	)

◆ f2fs_fsync_device()

int f2fs_fsync_device ( void )

◆ f2fs_get_device_info()

int f2fs_get_device_info ( void )

◆ f2fs_get_encoding_flags()

int f2fs_get_encoding_flags ( int encoding )

◆ f2fs_get_f2fs_info()

int f2fs_get_f2fs_info ( void )

◆ f2fs_get_usable_segments()

uint32_t f2fs_get_usable_segments ( struct f2fs_super_block * sb )

◆ f2fs_get_zone_blocks()

int f2fs_get_zone_blocks ( int i )

◆ f2fs_get_zoned_model()

int f2fs_get_zoned_model ( int i )

◆ f2fs_has_extra_isize()

static bool f2fs_has_extra_isize ( struct f2fs_inode * inode )

inlinestatic

◆ f2fs_init_configuration()

void f2fs_init_configuration ( void )

◆ f2fs_init_inode()

static void f2fs_init_inode	(	struct f2fs_super_block *	sb,
		struct f2fs_node *	raw_node,
		nid_t	ino,
		time_t	mtime,
		mode_t	mode
	)

inlinestatic

◆ f2fs_init_sparse_file()

int f2fs_init_sparse_file ( void )

◆ f2fs_inode_chksum()

__u32 f2fs_inode_chksum ( struct f2fs_node * node )

◆ f2fs_io_type_to_rw_hint()

enum rw_hint f2fs_io_type_to_rw_hint ( int seg_type )

◆ f2fs_load_nls_table()

const struct f2fs_nls_table * f2fs_load_nls_table ( int encoding )

◆ f2fs_max_file_offset()

u64 f2fs_max_file_offset ( struct f2fs_inode * i )

◆ f2fs_release_sparse_resource()

void f2fs_release_sparse_resource ( void )

◆ f2fs_report_zone()

int f2fs_report_zone	(	int	,
		uint64_t	,
		struct blk_zone *
	)

◆ f2fs_report_zones()

int f2fs_report_zones	(	int	,
		report_zones_cb_t *	,
		void *
	)

◆ f2fs_reset_zone()

int f2fs_reset_zone	(	int	,
		void *
	)

◆ f2fs_reset_zones()

int f2fs_reset_zones ( int i )

◆ f2fs_set_bit()

int f2fs_set_bit	(	unsigned int	nr,
		char *	addr
	)

◆ f2fs_str2encoding()

int f2fs_str2encoding ( const char * string )

◆ f2fs_str2encoding_flags()

int f2fs_str2encoding_flags	(	char **	param,
		__u16 *	flags
	)

◆ f2fs_test_bit()

int f2fs_test_bit	(	unsigned int	nr,
		const char *	p
	)

◆ feature_map()

static u32 feature_map	(	struct feature *	table,
		char *	feature
	)

inlinestatic

◆ feature_name()

static char * feature_name	(	struct feature *	table,
		u32	mask
	)

inlinestatic

◆ find_next_bit_le()

u64 find_next_bit_le	(	const u8 *	addr,
		u64	size,
		u64	offset
	)

◆ find_next_zero_bit_le()

u64 find_next_zero_bit_le	(	const u8 *	addr,
		u64	size,
		u64	offset
	)

◆ get_best_overprovision()

static double get_best_overprovision ( struct f2fs_super_block * sb )

inlinestatic

◆ get_bits_in_byte()

int get_bits_in_byte ( unsigned char n )

◆ get_cp_crc()

static __le64 get_cp_crc ( struct f2fs_checkpoint * cp )

inlinestatic

◆ get_device_info()

int get_device_info ( int i )

◆ get_inline_xattr_addrs()

static int get_inline_xattr_addrs ( struct f2fs_inode * inode )

inlinestatic

◆ get_kernel_uname_version()

void get_kernel_uname_version ( __u8 * version )

◆ get_kernel_version()

void get_kernel_version ( __u8 * version )

◆ get_reserved()

static uint32_t get_reserved	(	struct f2fs_super_block *	sb,
		double	ovp
	)

inlinestatic

◆ is_qf_ino()

static int is_qf_ino	(	struct f2fs_super_block *	sb,
		nid_t	ino
	)

inlinestatic

◆ log_base_2()

int log_base_2 ( uint32_t num )

◆ overprovision_segment_buffer()

static uint32_t overprovision_segment_buffer ( struct f2fs_super_block * sb )

inlinestatic

◆ parse_feature()

static int parse_feature	(	struct feature *	table,
		const char *	features
	)

inlinestatic

◆ parse_root_owner()

static int parse_root_owner	(	char *	ids,
		uint32_t *	root_uid,
		uint32_t *	root_gid
	)

inlinestatic

◆ set_feature_bits()

static int set_feature_bits	(	struct feature *	table,
		char *	features
	)

inlinestatic

◆ show_version()

static void show_version ( const char * prog )

inlinestatic

◆ test_and_clear_bit_le()

int test_and_clear_bit_le	(	u32	nr,
		u8 *	addr
	)

◆ test_and_set_bit_le()

int test_and_set_bit_le	(	u32	nr,
		u8 *	addr
	)

◆ test_bit_le()

int test_bit_le	(	u32	nr,
		const u8 *	addr
	)

◆ utf16_to_utf8()

int utf16_to_utf8	(	char *	output,
		const char *	input,
		size_t	outsize,
		size_t	insize
	)

◆ utf8_to_utf16()

int utf8_to_utf16	(	char *	output,
		const char *	input,
		size_t	outsize,
		size_t	insize
	)

◆ write_inode()

int write_inode	(	struct f2fs_node *	inode,
		u64	blkaddr,
		enum	rw_hint
	)

Variable Documentation

◆

union { ... }

◆

union { ... }

◆ attribute

struct f2fs_dentry_block __attribute__

◆ block_addr

__le32 block_addr

◆ c

struct f2fs_configuration c

extern

◆ checksum_offset

__le32 checksum_offset

◆ cp_blkaddr

__le32 cp_blkaddr

◆ cp_payload

__le32 cp_payload

◆ crc

__le32 crc

◆ encrypt_pw_salt

__u8 encrypt_pw_salt[16]

◆ encryption_level

__u8 encryption_level

◆ extension_count

__le32 extension_count

◆ extension_list

__u8 extension_list[F2FS_MAX_EXTENSION][8]

◆ f2fs_fault_name

const char* f2fs_fault_name[FAULT_MAX]

extern

◆ feature

__le32 feature

◆ file_type

__u8 file_type

◆ hash_code

__le32 hash_code

◆ hot_ext_count

__u8 hot_ext_count

◆ i_compr_blocks

__le64 i_compr_blocks

◆ i_compress_algorithm

__u8 i_compress_algorithm

◆ i_compress_flag

__le16 i_compress_flag

◆ i_crtime

__le64 i_crtime

◆ i_crtime_nsec

__le32 i_crtime_nsec

◆ i_extra_end

__le32 i_extra_end[0]

◆ i_extra_isize

__le16 i_extra_isize

◆ i_inline_xattr_size

__le16 i_inline_xattr_size

◆ i_inode_checksum

__le32 i_inode_checksum

◆ i_log_cluster_size

__u8 i_log_cluster_size

◆ i_projid

__le32 i_projid

◆ info

struct f2fs_extra_info info

◆ init_version

__u8 init_version[VERSION_LEN]

◆ ino

__le32 ino

◆ kbytes_written

__le64 kbytes_written

◆ log_blocks_per_seg

__le32 log_blocks_per_seg

◆ log_blocksize

__le32 log_blocksize

◆ log_sectors_per_block

__le32 log_sectors_per_block

◆ log_sectorsize

__le32 log_sectorsize

◆ magic

__le32 magic

◆ main_blkaddr

__le32 main_blkaddr

◆ major_ver

__le16 major_ver

◆ meta_ino

__le32 meta_ino

◆ minor_ver

__le16 minor_ver

◆ mtime

__le64 mtime

◆ n_nats

__le16 n_nats

◆ n_sits

__le16 n_sits

◆ name_len

__le16 name_len

◆ nat_blkaddr

__le32 nat_blkaddr

◆ nat_j

struct nat_journal nat_j

◆ ne

struct f2fs_nat_entry ne

◆ nid

__le32 nid

◆ node_ino

__le32 node_ino

◆ ofs_in_node

__le16 ofs_in_node

◆ reserved

__u8 reserved

◆ root_ino

__le32 root_ino

◆ s_encoding

__le16 s_encoding

◆ s_encoding_flags

__le16 s_encoding_flags

◆ s_errors

__u8 s_errors[MAX_F2FS_ERRORS]

◆ s_stop_reason

__u8 s_stop_reason[MAX_STOP_REASON]

◆ se

struct f2fs_sit_entry se

◆ secs_per_zone

__le32 secs_per_zone

◆ section_count

__le32 section_count

◆ segment0_blkaddr

__le32 segment0_blkaddr

◆ segment_count

__le32 segment_count

◆ segment_count_ckpt

__le32 segment_count_ckpt

◆ segment_count_main

__le32 segment_count_main

◆ segment_count_nat

__le32 segment_count_nat

◆ segment_count_sit

__le32 segment_count_sit

◆ segment_count_ssa

__le32 segment_count_ssa

◆ segno

__le32 segno

◆ segs_per_sec

__le32 segs_per_sec

◆ sit_blkaddr

__le32 sit_blkaddr

◆ sit_j

struct sit_journal sit_j

◆ ssa_blkaddr

__le32 ssa_blkaddr

◆ uuid

__u8 uuid[16]

◆ valid_map

__u8 valid_map[SIT_VBLOCK_MAP_SIZE]

◆ vblocks

__le16 vblocks

◆ version

__u8 version

◆ volume_name

__le16 volume_name[MAX_VOLUME_NAME]

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ __round_mask

◆ __SANE_USERSPACE_TYPES__

◆ ADDRS_PER_BLOCK

◆ ADDRS_PER_INODE

◆ ALIGN_DOWN

◆ ALIGN_UP

◆ ASSERT

◆ ASSERT_MSG

◆ be32_to_cpu

◆ BIT_MASK

◆ BIT_WORD

◆ BITS_PER_BYTE

◆ BITS_PER_LONG

◆ BUF_DISP_u32

◆ BUF_DISP_u64

◆ BUF_DISP_utf

◆ CHEADER_PGOFS_NONE

◆ COMPRESS_ADDR

◆ COMPRESS_DATA_RESERVED_SIZE

◆ COMPRESS_HEADER_SIZE

◆ CONFIG_RSVD_DEFAULT_OP_RATIO

◆ CP_BITMAP_OFFSET

◆ CP_CHKSUM_OFFSET

◆ CP_COMPACT_SUM_FLAG

◆ CP_CRC_RECOVERY_FLAG

◆ CP_DISABLED_FLAG

◆ CP_ERROR_FLAG

◆ CP_FASTBOOT_FLAG

◆ CP_FSCK_FLAG

◆ CP_LARGE_NAT_BITMAP_FLAG

◆ CP_MIN_CHKSUM_OFFSET

◆ CP_NAT_BITS_FLAG

◆ CP_NOCRC_RECOVERY_FLAG

◆ CP_ORPHAN_PRESENT_FLAG

◆ CP_QUOTA_NEED_FSCK_FLAG

◆ CP_RESIZEFS_FLAG

◆ CP_TRIMMED_FLAG

◆ CP_UMOUNT_FLAG

◆ cpu_to_le16

◆ cpu_to_le32

◆ cpu_to_le64

◆ CUR_ADDRS_PER_INODE

◆ DBG

◆ DEF_ADDRS_PER_BLOCK

◆ DEF_ADDRS_PER_INODE

◆ DEF_DIR_LEVEL

◆ DEF_INLINE_RESERVED_SIZE

◆ DEF_MAX_INLINE_DATA

◆ DEFAULT_BLKSIZE_BITS

◆ DEFAULT_BLOCKS_PER_SEGMENT

◆ DEFAULT_INLINE_XATTR_ADDRS

◆ DEFAULT_NAT_ENTRY_RATIO

◆ DEFAULT_SECTOR_SIZE

◆ DEFAULT_SECTORS_PER_BLOCK

◆ DEFAULT_SEGMENTS_PER_SECTION

◆ DISP

◆ DISP_raw_str

◆ DISP_str

◆ DISP_u16

◆ DISP_u32

◆ DISP_u64

◆ DISP_u8

◆ DISP_utf

◆ ENTRIES_IN_SUM

◆ ERR_MSG

◆ EXTRA_INFO_RESERVED

◆ F2FS_ALL_FAULT_TYPE

◆ F2FS_BLK_ALIGN

◆ F2FS_BLKSIZE

◆ F2FS_BLKSIZE_BITS

◆ F2FS_BYTES_TO_BLK

◆ F2FS_CASEFOLD_FL

◆ F2FS_COMPR_FL