/* erofs on-disk super block (currently 144 bytes at maximum) */
struct erofs_super_block {
	__le32 magic;           /* file system magic number */
	__le32 checksum;        /* crc32c to avoid unexpected on-disk overlap */
	__le32 feature_compat;
	__u8 blkszbits;         /* filesystem block size in bit shift */
	__u8 sb_extslots;	/* superblock size = 128 + sb_extslots * 16 */
	union {
		__le16 rootnid_2b;	/* nid of root directory */
		__le16 blocks_hi;	/* (48BIT on) blocks count MSB */
	} __packed rb;
	__le64 inos;            /* total valid ino # (== f_files - f_favail) */
	__le64 epoch;		/* base seconds used for compact inodes */
	__le32 fixed_nsec;	/* fixed nanoseconds for compact inodes */
	__le32 blocks_lo;	/* blocks count LSB */
	__le32 meta_blkaddr;	/* start block address of metadata area */
	__le32 xattr_blkaddr;	/* start block address of shared xattr area */
	__u8 uuid[16];          /* 128-bit uuid for volume */
	__u8 volume_name[16];   /* volume name */
	__le32 feature_incompat;
	union {
		/* bitmap for available compression algorithms */
		__le16 available_compr_algs;
		/* customized sliding window size instead of 64k by default */
		__le16 lz4_max_distance;
	} __packed u1;
	__le16 extra_devices;	/* # of devices besides the primary device */
	__le16 devt_slotoff;	/* startoff = devt_slotoff * devt_slotsize */
	__u8 dirblkbits;	/* directory block size in bit shift */
	__u8 xattr_prefix_count;	/* # of long xattr name prefixes */
	__le32 xattr_prefix_start;	/* start of long xattr prefixes */
	__le64 packed_nid;	/* nid of the special packed inode */
	__u8 xattr_filter_reserved; /* reserved for xattr name filter */
	__u8 ishare_xattr_prefix_id;
	__u8 reserved[2];
	__le32 build_time;	/* seconds added to epoch for mkfs time */
	__le64 rootnid_8b;	/* (48BIT on) nid of root directory */
	__le64 reserved2;
	__le64 metabox_nid;     /* (METABOX on) nid of the metabox inode */
	__le64 reserved3;	/* [align to extslot 1] */
};

__u8 sb_extslots;	/* superblock size = 128 + sb_extslots * 16 */

unsigned int sb_size = 128;
if (erofs_sb_has_metabox(sbi) &&
    sb_size <= offsetof(struct erofs_super_block, metabox_nid))
        sb_size = offsetof(struct erofs_super_block, metabox_nid) + 8;
sbi->sb_size = round_up(sb_size, 16);

sb.sb_extslots = (sbi->sb_size - 128) >> 4;    /* (144 - 128) / 16 = 1 */

data = erofs_read_metabuf(&buf, sb, 0, false);          /* 读块 0 */
...
dsb = (struct erofs_super_block *)(data + EROFS_SUPER_OFFSET);   /* +1024 */

/* erofs_read_superblock() —— fs/erofs/super.c */
if (le32_to_cpu(dsb->magic) != EROFS_SUPER_MAGIC_V1) {
        erofs_err(sb, "cannot find valid erofs superblock");
        goto out;
}

sbi->blkszbits = dsb->blkszbits;
if (sbi->blkszbits < 9 || sbi->blkszbits > PAGE_SHIFT) { ... }

sbi->feature_incompat = le32_to_cpu(dsb->feature_incompat);
if (sbi->feature_incompat & ~EROFS_ALL_FEATURE_INCOMPAT) {
        erofs_err(sb, "unidentified incompatible feature %x, please upgrade kernel",
                  sbi->feature_incompat & ~EROFS_ALL_FEATURE_INCOMPAT);
        goto out;
}

sbi->sb_size = 128 + dsb->sb_extslots * EROFS_SB_EXTSLOT_SIZE;

u32 len = 1 << EROFS_SB(sb)->blkszbits, crc;
if (len > EROFS_SUPER_OFFSET)
        len -= EROFS_SUPER_OFFSET;
len -= offsetof(struct erofs_super_block, checksum) + sizeof(dsb->checksum);

/* skip .magic(pre-verified) and .checksum(0) fields */
crc = crc32c(0x5045B54A, (&dsb->checksum) + 1, len);
if (crc == le32_to_cpu(dsb->checksum))
        return 0;

/* turn on checksum feature */
sb->feature_compat = cpu_to_le32(le32_to_cpu(sb->feature_compat) |
                                 EROFS_FEATURE_COMPAT_SB_CHKSUM);
*crc = erofs_crc32c(~0, (u8 *)sb, len);      /* len = blksiz - 1024，从偏移 0 起 */
sb->checksum = cpu_to_le32(*crc);

struct erofs_super_block sb = {
        .magic     = cpu_to_le32(EROFS_SUPER_MAGIC_V1),
        .blkszbits = sbi->blkszbits,
        .rb.rootnid_2b  = cpu_to_le16(sbi->root_nid),
        .inos      = cpu_to_le64(sbi->inos),
        .epoch     = cpu_to_le64(sbi->epoch),
        .build_time = cpu_to_le64(sbi->build_time),
        .fixed_nsec = cpu_to_le32(sbi->fixed_nsec),
        .meta_blkaddr  = cpu_to_le32(sbi->meta_blkaddr),
        .xattr_blkaddr = cpu_to_le32(sbi->xattr_blkaddr),
        ...
        .feature_incompat = cpu_to_le32(sbi->feature_incompat),
        .feature_compat = cpu_to_le32(sbi->feature_compat &
                                      ~EROFS_FEATURE_COMPAT_SB_CHKSUM),
        .extra_devices = cpu_to_le16(sbi->extra_devices),
        .devt_slotoff = cpu_to_le16(sbi->devt_slotoff),
        .packed_nid = cpu_to_le64(sbi->packed_nid),
};

sb.blocks_lo = cpu_to_le32(sbi->primarydevice_blocks);
if (sbi->primarydevice_blocks > UINT32_MAX || sbi->root_nid > UINT16_MAX) {
        sb.rb.blocks_hi = cpu_to_le16(sbi->primarydevice_blocks >> 32);
        sb.rootnid_8b = cpu_to_le64(sbi->root_nid);        /* 切换为 48 位布局 */
}
...
if (erofs_sb_has_compr_cfgs(sbi))
        sb.u1.available_compr_algs = cpu_to_le16(sbi->available_compr_algs);
else
        sb.u1.lz4_max_distance = cpu_to_le16(sbi->lz4.max_distance);

if (erofs_sb_has_metabox(sbi))
        sb.metabox_nid = cpu_to_le64(sbi->metabox_nid);
sb.sb_extslots = (sbi->sb_size - 128) >> 4;

buf = calloc(round_up(EROFS_SUPER_OFFSET + sbi->sb_size, erofs_blksiz(sbi)), 1);
memcpy(buf + EROFS_SUPER_OFFSET, &sb, sbi->sb_size);
ret = erofs_dev_write(sbi, buf, sb_bh ? erofs_btell(sb_bh, false) : 0,
                      EROFS_SUPER_OFFSET + sbi->sb_size);