| /* |
| * Copyright (C) 2010 by Jiro SEKIBA <jir@unicus.jp> |
| * |
| * This file may be redistributed under the terms of the |
| * GNU Lesser General Public License |
| */ |
| #include <stddef.h> |
| #include <string.h> |
| |
| #include "superblocks.h" |
| #include "crc32.h" |
| |
| struct nilfs_super_block { |
| uint32_t s_rev_level; |
| uint16_t s_minor_rev_level; |
| uint16_t s_magic; |
| |
| uint16_t s_bytes; |
| |
| uint16_t s_flags; |
| uint32_t s_crc_seed; |
| uint32_t s_sum; |
| |
| uint32_t s_log_block_size; |
| |
| uint64_t s_nsegments; |
| uint64_t s_dev_size; |
| uint64_t s_first_data_block; |
| uint32_t s_blocks_per_segment; |
| uint32_t s_r_segments_percentage; |
| |
| uint64_t s_last_cno; |
| uint64_t s_last_pseg; |
| uint64_t s_last_seq; |
| uint64_t s_free_blocks_count; |
| |
| uint64_t s_ctime; |
| |
| uint64_t s_mtime; |
| uint64_t s_wtime; |
| uint16_t s_mnt_count; |
| uint16_t s_max_mnt_count; |
| uint16_t s_state; |
| uint16_t s_errors; |
| uint64_t s_lastcheck; |
| |
| uint32_t s_checkinterval; |
| uint32_t s_creator_os; |
| uint16_t s_def_resuid; |
| uint16_t s_def_resgid; |
| uint32_t s_first_ino; |
| |
| uint16_t s_inode_size; |
| uint16_t s_dat_entry_size; |
| uint16_t s_checkpoint_size; |
| uint16_t s_segment_usage_size; |
| |
| uint8_t s_uuid[16]; |
| char s_volume_name[80]; |
| |
| uint32_t s_c_interval; |
| uint32_t s_c_block_max; |
| uint32_t s_reserved[192]; |
| }; |
| |
| #define NILFS_SB_MAGIC 0x3434 |
| #define NILFS_SB_OFFSET 0x400 |
| #define NILFS_SBB_OFFSET(_sz) ((((_sz) / 0x200) - 8) * 0x200) |
| |
| static int nilfs_valid_sb(blkid_probe pr, struct nilfs_super_block *sb, int is_bak) |
| { |
| static unsigned char sum[4]; |
| const int sumoff = offsetof(struct nilfs_super_block, s_sum); |
| size_t bytes; |
| const size_t crc_start = sumoff + 4; |
| uint32_t crc; |
| |
| if (!sb || le16_to_cpu(sb->s_magic) != NILFS_SB_MAGIC) |
| return 0; |
| |
| if (is_bak && blkid_probe_is_wholedisk(pr) && |
| sb->s_dev_size != pr->size) |
| return 0; |
| |
| bytes = le16_to_cpu(sb->s_bytes); |
| /* ensure that no underrun can happen in the length parameter |
| * of the crc32 call or more data are processed than read into |
| * sb */ |
| if (bytes < crc_start || bytes > sizeof(struct nilfs_super_block)) |
| return 0; |
| |
| crc = ul_crc32(le32_to_cpu(sb->s_crc_seed), (unsigned char *)sb, sumoff); |
| crc = ul_crc32(crc, sum, 4); |
| crc = ul_crc32(crc, (unsigned char *)sb + crc_start, bytes - crc_start); |
| |
| return blkid_probe_verify_csum(pr, crc, le32_to_cpu(sb->s_sum)); |
| } |
| |
| static int probe_nilfs2(blkid_probe pr, |
| const struct blkid_idmag *mag __attribute__((__unused__))) |
| { |
| struct nilfs_super_block *sb, *sbp, *sbb; |
| int valid[2], swp = 0; |
| uint64_t magoff; |
| |
| /* primary */ |
| sbp = (struct nilfs_super_block *) blkid_probe_get_buffer( |
| pr, NILFS_SB_OFFSET, sizeof(struct nilfs_super_block)); |
| if (!sbp) |
| return errno ? -errno : 1; |
| |
| valid[0] = nilfs_valid_sb(pr, sbp, 0); |
| |
| |
| /* backup */ |
| sbb = (struct nilfs_super_block *) blkid_probe_get_buffer( |
| pr, NILFS_SBB_OFFSET(pr->size), sizeof(struct nilfs_super_block)); |
| if (!sbb) { |
| valid[1] = 0; |
| |
| /* If the primary block is valid then continue and ignore also |
| * I/O errors for backup block. Note the this is probably CD |
| * where I/O errors and the end of the disk/session are "normal". |
| */ |
| if (!valid[0]) |
| return errno ? -errno : 1; |
| } else |
| valid[1] = nilfs_valid_sb(pr, sbb, 1); |
| |
| |
| /* |
| * Compare two super blocks and set 1 in swp if the secondary |
| * super block is valid and newer. Otherwise, set 0 in swp. |
| */ |
| if (!valid[0] && !valid[1]) |
| return 1; |
| |
| swp = valid[1] && (!valid[0] || |
| le64_to_cpu(sbp->s_last_cno) > |
| le64_to_cpu(sbb->s_last_cno)); |
| sb = swp ? sbb : sbp; |
| |
| DBG(LOWPROBE, ul_debug("nilfs2: primary=%d, backup=%d, swap=%d", |
| valid[0], valid[1], swp)); |
| |
| if (*(sb->s_volume_name) != '\0') |
| blkid_probe_set_label(pr, (unsigned char *) sb->s_volume_name, |
| sizeof(sb->s_volume_name)); |
| |
| blkid_probe_set_uuid(pr, sb->s_uuid); |
| blkid_probe_sprintf_version(pr, "%u", le32_to_cpu(sb->s_rev_level)); |
| |
| magoff = swp ? NILFS_SBB_OFFSET(pr->size) : NILFS_SB_OFFSET; |
| magoff += offsetof(struct nilfs_super_block, s_magic); |
| |
| if (blkid_probe_set_magic(pr, magoff, sizeof(sb->s_magic), |
| (unsigned char *) &sb->s_magic)) |
| return 1; |
| |
| return 0; |
| } |
| |
| const struct blkid_idinfo nilfs2_idinfo = |
| { |
| .name = "nilfs2", |
| .usage = BLKID_USAGE_FILESYSTEM, |
| .probefunc = probe_nilfs2, |
| /* default min.size is 128MiB, but 1MiB for "mkfs.nilfs2 -b 1024 -B 16" */ |
| .minsz = (1024 * 1024), |
| .magics = BLKID_NONE_MAGIC |
| }; |