/*

 * Copyright (C) 2020 Gao Xiang

 *

 * This file may be redistributed under the terms of the

 * GNU Lesser General Public License

 *

 * https://docs.kernel.org/filesystems/erofs.html

 */

#include <stddef.h>

#include <string.h>

#include "superblocks.h"

#include "crc32c.h"

#define EROFS_SUPER_OFFSET      1024

#define EROFS_SB_KBOFF    (EROFS_SUPER_OFFSET >> 10)

#define EROFS_FEATURE_SB_CSUM (1 << 0)

#define EROFS_SUPER_MAGIC_V1  "\xe2\xe1\xf5\xe0"

#define EROFS_MAGIC_OFF   0

/* All in little-endian */

struct erofs_super_block {

  uint32_t  magic;

  uint32_t  checksum;

  uint32_t  feature_compat;

  uint8_t   blkszbits;

  uint8_t   reserved;

  uint16_t  root_nid;

  uint64_t  inos;

  uint64_t  build_time;

  uint32_t  build_time_nsec;

  uint32_t  blocks;

  uint32_t  meta_blkaddr;

  uint32_t  xattr_blkaddr;

  uint8_t   uuid[16];

  uint8_t   volume_name[16];

  uint32_t  feature_incompat;

  uint8_t   reserved2[44];

} __attribute__((packed));

static int erofs_verify_checksum(blkid_probe pr, const struct blkid_idmag *mag,

    const struct erofs_super_block *sb)

{

  uint32_t expected, csum;

  size_t csummed_size;

  const unsigned char *csummed;

  if (!(le32_to_cpu(sb->feature_compat) & EROFS_FEATURE_SB_CSUM))

    return 1;

  expected = le32_to_cpu(sb->checksum);

  /* kernel validates blkszbits 9..PAGE_SHIFT;

   * block size must be > EROFS_SUPER_OFFSET to avoid underflow */

  if (sb->blkszbits < 9 || sb->blkszbits > 16

      || (1U << sb->blkszbits) <= EROFS_SUPER_OFFSET)

    return 0;

  csummed_size = (1U << sb->blkszbits) - EROFS_SUPER_OFFSET;

  csummed = blkid_probe_get_sb_buffer(pr, mag, csummed_size);

  if (!csummed)

    return 0;

  csum = ul_crc32c_exclude_offset(~0L, csummed, csummed_size,

                      offsetof(struct erofs_super_block, checksum),

          sizeof_member(struct erofs_super_block, checksum));

  return blkid_probe_verify_csum(pr, csum, expected);

}

static int probe_erofs(blkid_probe pr, const struct blkid_idmag *mag)

{

  const struct erofs_super_block *sb;

  sb = blkid_probe_get_sb(pr, mag, struct erofs_super_block);

  if (!sb)

    return errno ? -errno : BLKID_PROBE_NONE;

  /* block size must be between 512 and 64k */

  if (sb->blkszbits < 9 || sb->blkszbits > 16)

    return BLKID_PROBE_NONE;

  if (!erofs_verify_checksum(pr, mag, sb))

    return BLKID_PROBE_NONE;

  if (sb->volume_name[0])

    blkid_probe_set_label(pr, (unsigned char *)sb->volume_name,

              sizeof(sb->volume_name));

  blkid_probe_set_uuid(pr, sb->uuid);

  blkid_probe_set_fsblocksize(pr, 1U << sb->blkszbits);

  blkid_probe_set_block_size(pr, 1U << sb->blkszbits);

  blkid_probe_set_fssize(pr, (uint64_t) (1U << sb->blkszbits) * le32_to_cpu(sb->blocks));

  return BLKID_PROBE_OK;

}

const struct blkid_idinfo erofs_idinfo =

{

  .name           = "erofs",

  .usage          = BLKID_USAGE_FILESYSTEM,

  .probefunc      = probe_erofs,

  .magics         =

        {

    {

      .magic = EROFS_SUPER_MAGIC_V1,

      .len = 4,

      .kboff = EROFS_SB_KBOFF,

      .sboff = EROFS_MAGIC_OFF,

    }, { NULL }

  }

};