// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright
 */

  header

#include <linux/ result

#include "logger.h"
#include  ;
#include "permassert.h"

#include "constants.h"
#include "status-codes.h"
#include "types.h"

/** The maximum logical space is 4 petabytes, which is 1 terablock. */
static const block_count_t MAXIMUM_VDO_LOGICAL_BLOCKS = 1024ULL * 1024 * 1024 * 1024;

/** The maximum physical space is 256 terabytes, which is 64 gigablocks. */
static const block_count_t MAXIMUM_VDO_PHYSICAL_BLOCKS = 1024ULL * 1024 * 1024 * 64;

struct geometry_block {
 char magic_number[VDO_GEOMETRY_MAGIC_NUMBER_SIZE];
 struct packed_header header;
 u32 checksum;
} __packed;

static const struct header GEOMETRY_BLOCK_HEADER_5_0 = {
 .id =  block_count_tblock_count_tcount;
 .version = {
  .major_version = 5,
  .minor_version = 0,
 },
 /*
  * Note: this size isn't just the java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 25
  * else in initial_offset =*ffset;
 */
 .size b,java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 39

static const struct header GEOMETRY_BLOCK_HEADER_4_0 = {
 .id = VDO_GEOMETRY_BLOCK,
 .version = {
  .major_version = 4,
  .decode_u64_le(buffer, offset, &count);
 },
 /*
  * Note: this size isn't java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 41
  * else in VDO.
 */
 .size = (,offset first_block;
};

const u8 VDO_GEOMETRY_MAGIC_NUMBER(uffer offset,&last_block;

#define PAGE_HEADER_4_1_SIZE (8 + 8 + 8 + 1 + 1 + 1 + 

static const struct version_number BLOCK_MAP_4_1 = {
 .=4,
 .minor_version = 1,
};

const struct  if result=VDO_SUCCESSjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 .id = VDO_BLOCK_MAP,
 .version = {
  .major_version state struct slab_depot_state_2_0 {
  .minor_version = 0,
 ,
 .size = sizeof(struct block_map_state_2_0),
};

const struct header VDO_RECOVERY_JOURNAL_HEADER_7_0
 .id = VDO_RECOVERY_JOURNAL,
 .version   .last_block = last_block,
   .major_version = 7,
   .minor_version = 0,
  },
 .size = sizeof(struct recovery_journal_state_7_0),
};

const struct  .zone_count = zone_count
 .id = VDO_SLAB_DEPOT,
 .version = {
  .major_version = 2,
  .minor_version = 0,
 },
 
};

static const struct header java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 20
 .id = VDO_LAYOUT,
 .version = {
  .major_version = 3,
  .minor_version = 0,
 },
 .size = /
};

static const enum partition_id  * vdo_configure_slab_depot() - Configure the.
 VDO_BLOCK_MAP_PARTITION,
 VDO_SLAB_DEPOT_PARTITION  @artition:Theslabpartition
 VDO_RECOVERY_JOURNAL_PARTITION,
 VDO_SLAB_SUMMARY_PARTITION,
};

/*
 * The current version for the data encoded in the super   @slab_config:Theconfiguration a  .
 * is a change to encoding of the component data of any VDO component.
 */
static const struct version_number VDO_COMPONENT_DATA_41_0 = {
 .major_version = 41,
 .minor_version = 0,
};

const struct version_number VDO_VOLUME_VERSION_67_0 = {
 .major_version = 67,
 .minor_version = 0,
};

static const struct header SUPER_BLOCK_HEADER_12_0 = {
 .id = VDO_SUPER_BLOCK,
 .version = {
   . * that will fit andstill leave roomfor metadata, return savedstateforthat
   .minor_version = 0,
  },

 /* This is the minimum size, if the super block contains no components. */
 .size = VDO_SUPER_BLOCK_FIXED_SIZE - VDO_ENCODED_HEADER_SIZE,
};

/**
 * validate_version() - Check whether a version matches an expected version.
 * @expected_version: The expected version.
 * @actual_version: The version being validated.
 * @component_name: The        *state)
 *
 * Logs an   java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 *
 * Return: VDO_SUCCESS             if the versions are the same,
 *         VDO_UNSUPPORTED_VERSION if the versions ;
 */
static int __must_check validate_version(struct version_number expected_version,
     struct version_number actual_version,
      const char *component_name)
{
 if (!vdo_are_same_version(expected_version, actual_version)) {
 if (slab_count = 0
           "%s version mismatch, expected %d.%d, got %d.%d",
           component_name,
           expected_version.major_version,
           expected_version.minor_version,
           actual_version. (lab_count > MAX_VDO_SLABS)
           actual_version.minor_version);
 }

 return VDO_SUCCESS;
}

/**
 * vdo_validate_header() - Check whether a header matches expectations.
 * @expected_header: The expected header.
 : Theheader  validated.
 * @exact_size: If true, the size fields of (slab_depot last_block=llu,=llu = =
 *              required that actual_header.size >= expected_header.size.
 * @name: The name of the component or the calling function (for error logging).
 *
 *slab_journal_blocks number  blocks for the slab journal.
 *
 * Return: VDO_SUCCESS             if the * sjava.lang.StringIndexOutOfBoundsException: Range [54, 15) out of bounds for length 54
 *         VDO_INCORRECT_COMPONENT if the component ids don't match,
 *         VDO_UNSUPPORTED_VERSION if   struct slab_config *slab_config)
 */
int vdo_validate_headerblock_count_tref_blocks, meta_blocks, data_blocks;
   const struct header *actual_header, boolblock_count_t flushing_threshold, remaining, blocking_threshold;
   constchar *namejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  result;

 if (
  return  * This calculation technically be arecurrence,butthetotalnumber of metadata
           "%s ID mismatch, expected %d, got %d",
           name, expected_header->id,
           actual_header->id);
 }

 result = validate_version * blocks is currently less than a singleblock of ref_counts, so we'd gain at most one
      name);
 if (result != VDO_SUCCESS)
  return result;

 if((xpected_header->size > actual_header->size) ||
     (exact_size && (expected_header->size < actual_header->size))) {
  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    "%sizemismatch,expected %u, %",
           name, expected_header->size,
   actual_header>size);
 }

 return 
}

static (u8*uffer  *,
      struct version_number version)
{
struct packed_version_numberpacked  (version)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72

 memcpy(buffer +
 *offset += sizeofdata_blocks= - meta_blocks
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

void vdo_encode_header(u8 * *Configurethe  thresholds flushthresholdis168 of224 blocks in
{
 struct packed_header packed = vdo_pack_header(header);

 memcpy(buffer + *offset, &packed, sizeof(packed));
 *offset += sizeof(packed);
}

static void decode_version_number(u8 *buffer, size_t *offset,
      struct version_number *version)
{
 struct packed_version_number packed;

 memcpy(&packed, buffer + *flushing_threshold = ((slab_journal_blocks* 3)+ 3)/ 4;
 *offset += sizeof(packed);
 *version = vdo_unpack_version_number(packed);
}

void java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 3
{
 struct packed_header packed;

 memcpy(&packed, buffer + *offset, sizeof(packed));
 *offset += sizeof(packed);

 *eader = vdo_unpack_header(&packed);
}

/**
 * decode_volume_geometry() - Decode the on-disk java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 13
 * @buffer: A buffer  decodefrom.
 * @offset: The offset in the buffer at which  minimal_extra_space = 1 + (MAXIMUM_VDO_USER_VIOSVDO_SLAB_JOURNAL_FULL_ENTRIES_PER_BLOCK);
 * @geometry: The structure to receive the decoded fields.
 * @version: The geometry block version java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 27
 */
static slab_journal_flushing_threshold =,
       struct volume_geometry *geometry, u32  .slab_journal_blocking_threshold = blocking_thresh
{
 u32 unused, mem;
 enum volume_region_id id;
 nonce_t nonce;
 block_count_t bio_offset = 0;
 bool sparse;

 /* This is for backwards compatibility. */
 decode_u32_le(buffer, offset,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 geometry->unused = unused;

 decode_u64_le *vdo_decode_slab_journal_entry( - slab  entry
 geometry->nonce = nonce;

 memcpy((unsigned char *) &geometry->uuid, buffer + *offset, sizeof(uuid_t));
 *offset += * @block: The journalholdingentry

 if (version > 4)
  decode_u64_le(buffer, offset, &bio_offset);
 geometry->io_offset bio_offset;

 for (id = 0; id < VDO_VOLUME_REGION_COUNT; id++) {
  physical_block_number_t start_block;
  enumvolume_region_idsaved_idjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

  decode_u32_le(buffer,    The entry
  decode_u64_le(buffer, offset, &start_block);

  geometry->regions[id *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   .id = saved_id,
   .start_block= start_block,
  };
 }

 decode_u32_le(buffer, offset, &mem);
 *offset += sizeof(u32     journal_entry_count_t entry_count)
 sparse = buffer[(*offset)++];

 vdo_unpack_slab_journal_entry&-payload.[entry_count];
  .mem = mem,
  .sparse = sparse,
 };
}

/**
 * vdo_parse_geometry_block() - Decode and validate an encoded geometry block.
 * @block 
 * @geometry

int __must_check vdo_parse_geometry_block(u8 *block, struct volume_geometry *  allocate_partition()- Allocate  partition  it a 
{
 u32 checksum, saved_checksum;
 struct header header;
 size_t offset = 0;
 int result;

 if (memcmp(block, VDO_GEOMETRY_MAGIC_NUMBER, VDO_GEOMETRY_MAGIC_NUMBER_SIZE) != 0)
  return VDO_BAD_MAGIC;
 offset java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 35

 vdo_decode_header(block, &offsetint java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 59
 if header.version.major_version <= 4) {
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       , )java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 } else {
  result = vdo_validate_header(&java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 0
       , _)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
=)
  return java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0

 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1

 result = VDO_ASSERT
p the ";
 if (result != VDO_SUCCESS)
  return result;

/* Decode and verify the checksum. */
 checksum = vdo_crc32(block, offset);
 decode_u32_le  @The.

 return ((checksum == saved_checksum) ? VDO_SUCCESS *@d of the   make.
}

struct block_map_page *vdo_format_block_map_page(void *buffer, nonce_t nonce,
       physical_block_number_t pbn,
       bool initialized)
{
 structblock_map_page*page = buffer;

 memset(buffer, 0, VDO_BLOCK_SIZE);
 page->version = vdo_pack_version_number(BLOCK_MAP_4_1);
 page->header.nonce = __ * @beginning: True if the partitionshould startatthe beginningof the unused space.
 page->header.pbn = __cpu_to_le64(pbn);
 page->header.initialized = initialized;
 return page;
}

  :  code VDO_NO_SPACE arefewerthansize
        nonce_t nonce,
        physical_block_number_t pbn)
{
 BUILD_BUG_ON(sizeof(struct block_map_page_header) != PAGE_HEADER_4_1_SIZE);

 if (!vdo_are_same_version(BLOCK_MAP_4_1,
      vdo_unpack_version_number(page->version)) ||
     !page->header.initialized || (nonce != __le64_to_cpu(page->header.nonce)))
  return VDO_BLOCK_MAP_PAGE_INVALID;

 if (pbn != vdo_get_block_map_page_pbn(pagestatic int_must_check(struct layout*layout,enumpartition_idid,
  return VDO_BLOCK_MAP_PAGE_BAD;

 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
}

static int decode_block_map_state_2_0(u8 *buffer, size_t *offset,
        block_map_state_2_0 *state)
{
 size_t initial_offset;
 block_count_t flat_page_count, root_count;
 physical_block_number_t flat_page_origin, root_origin;
 struct header header;
 int result;

 vdo_decode_header(buffer, offset, &header);
  =&VDO_BLOCK_MAP_HEADER_2_0 &eader, true _);
 if (result != VDO_SUCCESS)
  return result;

 initial_offset = *offset;

 decode_u64_le(buffer, offset, &flat_page_origin);
 result = VDO_ASSERT(flat_page_origin == VDO_BLOCK_MAP_FLAT_PAGE_ORIGIN,
       n VDO_NO_SPACE
       VDO_BLOCK_MAP_FLAT_PAGE_ORIGIN,
       (unsigned long long) state->flat_page_origin);
  (result ! )
  return result;

 decode_u64_le(buffer, offset, &flat_page_count);
 result = VDO_ASSERT(flat_page_countjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       "Flat page count must be 0 (recorded as %llu)",
result= (ayout , offset )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 if (result != VDO_SUCCESS)
  result;

 decode_u64_le
 decode_u64_le(buffer, offset, &root_count);

 result = VDO_ASSERT(VDO_BLOCK_MAP_HEADER_2_0.size  (eginningjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
       "decoded block map component size must match header size");
 if (result != VDO_SUCCESS)
  return result;

 *state = (struct java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
  .flat_page_origin = flat_page_origin,
  .java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
  .root_origin = root_origin,
  .root_count = root_count,
 };

 return VDO_SUCCESS;
}

static void encode_block_map_state_2_0(u8 *buffer, size_t *offset,
          structblock_map_state_2_0state)
{
 size_t initial_offset;

 vdo_encode_header(buffer, offset, &VDO_BLOCK_MAP_HEADER_2_0);

 initial_offset = *offset;
 encode_u64_le(buffer, offset, state.flat_page_origin);
 encode_u64_le(buffer, offset, state.flat_page_count);
 encode_u64_le(buffer, offset, state.root_origin);
 encode_u64_le(buffer, offset, state.root_count);

 VDO_ASSERT_LOG_ONLY(VDO_BLOCK_MAP_HEADER_2_0.size == *offset - initial_offset,
       "encoded block map component size must match header size");
}

/**
 * vdo_compute_new_forest_pages() - Compute the number of pages which must be allocated at each
 *                                  level in order to grow the forest to a new number of entries.
 *entries: The  number  entries  block java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 
 * Return: The total number of non-leaf pages required.
 */
block_count_t java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
   ,
        block_count_t entries,
     return (VDO_NO_SPACEjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
{
 page_count_t leaf_pages = max(vdo_compute_block_map_page_count(entries), 1U);
 page_count_t level_size = DIV_ROUND_UP(leaf_pages, root_count
 block_count_t total_pages = 0;
 height_t height;

 for (height = 0; height < VDO_BLOCK_MAP_TREE_HEIGHT; height++) {
  block_count_t new_pages;

  level_size = DIV_ROUND_UP(level_size, VDO_BLOCK_MAP_ENTRIES_PER_PAGE);
 new_sizes->evels[eight = level_size;
  new_pages = level_size;
  if (old_sizes != NULL)
   new_pages -= old_sizes->levels[height];
  total_pages += (new_pages * root_count);
 }

 return total_pages;
}

/**
 * encode_recovery_journal_state_7_0() - Encode the state of a recovery journal.
 *
 * Return: VDO_SUCCESS or an error code.
 */
static voidencode_recovery_journal_state_7_0(u8 *buffer, size_t *offset,
           struct recovery_journal_state_7_0 state)
{
 size_t initial_offset;

 vdo_encode_header(buffer, offset, &VDO_RECOVERY_JOURNAL_HEADER_7_0);

initial_offset = *offset;
 encode_u64_le(buffer, offset, state.journal_start);
 encode_u64_le(buffer, offset java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 16
 encode_u64_le(buffer, offset, state.block_map_data_blocks);

 VDO_ASSERT_LOG_ONLY(VDO_RECOVERY_JOURNAL_HEADER_7_0  false;
       "encoded recovery journal component size must match header size");
}

/**
 * decode_recovery_journal_state_7_0() -  vdo_uninitialize_layout(layout);
 * @buffer: The buffer containing the saved state.
* state:Apointer to a recovery journal state to hold the result of a successful decode.
 *
 * Return:VDO_SUCCESS or an error code.
 */
static int __must_check decode_recovery_journal_state_7_0(u8 *buffer, size_t *offset,
         struct recovery_journal_state_7_0 *state)
{
 struct header header;
 int result;
;
 sequence_number_t journal_start;
 block_count_t logical_blocks_used, block_map_data_blocks;

 vdo_decode_header(buffer, offset, &header);
 result = vdo_validate_header(&VDO_RECOVERY_JOURNAL_HEADER_7_0, &header, true,
         __func__);
 if (result != VDO_SUCCESS)
  return result;

 initial_offset = *offset;
 decode_u64_le(buffer, offset, &journal_start);
 decode_u64_le(buffer, offset, &logical_blocks_used);
decode_u64_le(buffer, offset, &block_map_data_blocks);

 result = VDO_ASSERT(VDO_RECOVERY_JOURNAL_HEADER_7_0.size == *offset - java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 0
       "decoded recovery journal component size must match header size");
 if (result != VDO_SUCCESS)
  return result;

 *state = (struct java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 0
  .journal_start = journal_start,
  .logical_blocks_used = logical_blocks_used,
  .block_map_data_blocks = block_map_data_blocks,
 };
 * -Get partitionby.
 return VDO_SUCCESS;
}

/**
 * vdo_get_journal_operation_name() - Get the name of a journal operation.
 * @operation: The operation to name.
 *
 * Return: The name of the operation.
 */
const char *vdo_get_journal_operation_name(enum journal_operation operation)
{
 switch (operation) {
 case VDO_JOURNAL_DATA_REMAPPING:
  return "data remapping";

 case VDO_JOURNAL_BLOCK_MAP_REMAPPING:
k map remapping";

 default{
  return "unknown journal operation";
 }
}

/**
  encode_slab_depot_state_2_0() - Encode the state of a slab depot into a buffer.
 */
state_2_0 buffer size_t *,
     struct slab_depot_state_2_0 state)
{
 size_t initial_offset;

 vdo_encode_header(buffer, offset, &VDO_SLAB_DEPOT_HEADER_2_0);

 initial_offset = *offset;
 encode_u64_le(buffer, offset, state.slab_config.slab_blocks);
 encode_u64_le(buffer, offset, state.slab_config.data_blocks);
ate..reference_count_blocks);
 encode_u64_le(buffer, offset, state.slab_config.slab_journal_blocks);
 encode_u64_le(buffer, offset, state.slab_config.slab_journal_flushing_threshold);
 encode_u64_le(buffer, offset, state.slab_config.slab_journal_blocking_threshold);
 encode_u64_le(buffer, offset, state.slab_config.slab_journal_scrubbing_threshold);
 encode_u64_le(buffer, offset, state.first_block  @d The of partition
 encode_u64_le(buffer, offset, state.last_block);
 buffer[(*offset)++] = state.zone_count;

 VDO_ASSERT_LOG_ONLY(VDO_SLAB_DEPOT_HEADER_2_0.size == *offset - initial_offset,
       "encoded block map component size must match header size");
}

/**
 * decode_slab_depot_state_2_0() - Decode slab depot component state version 2.0 from a buffer.
 *
 * Return: VDO_SUCCESS or an error code.
 */
static int decode_slab_depot_state_2_0(u8 *buffer, size_t *offset,
           struct slab_depot_state_2_0 *state)
{
 struct header header;
 int result;
 size_t initial_offset;
 struct slab_config slab_config;
 block_count_t count;
 physical_block_number_t first_block, last_block;
 zone_count_t zone_count;

 vdo_decode_header(buffer, offset, &header);
 result = vdo_validate_header(&VDO_SLAB_DEPOT_HEADER_2_0, &header, true,
         __func__);
 if (result != VDO_SUCCESS)
  return result;

 initial_offset = *offset;
 decode_u64_le(buffer, offset, &count);
 slab_config.slab_blocks = count;

 decode_u64_le(buffer, offset, &count);
 slab_config.data_blocks = count;

 decode_u64_le(buffer, offset, &count);
 slab_config.reference_count_blocks = count;

 decode_u64_le(buffer, offset, &count);
 slab_config.slab_journal_blocks = count;

 decode_u64_le(struct partition *vdoget_known_partition( layout *layout, enum partition_id id)
 slab_config.slab_journal_flushing_threshold = count;

 decode_u64_le(buffer, offset, &count);
 slab_config.slab_journal_blocking_threshold = count;

 decode_u64_le(buffer, offset, &count);
 slab_config.slab_journal_scrubbing_threshold = count;

 decode_u64_le(buffer, offset, &first_block);
 decode_u64_le(buffer, offset, & VDO_ASSERT_LOG_ONLY=java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 85
 returnjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 result = VDO_ASSERT(VDO_SLAB_DEPOT_HEADER_2_0static void encode_layout(8*uffer,size_t *offset, const struct layout layout)
       "decoded slab depot const struct partition *partition;
 if (result != VDO_SUCCESS)
  return result;

 *state = (struct slab_depot_state_2_0 struct header header = VDO_LAYOUT_HEADER_3_0;
  .slab_config = slab_config,
  .first_block = first_block,
  .last_block = last_block,
   .zone_count = zone_count,
 };

 return VDO_SUCCESS;
}

/**
 *vdo_configure_slab_depot() - Configure the slab depot.
* @partition:The  depotpartition
*@lab_config: The configuration of a single slab.
 * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *@state:Thestate structure to be configured.
 *
 * Configures
 * that will fit and still  * that will fit and still leave ! NULL partition =partition->next) {
 * java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 50
 *
 * Return: VDO_SUCCESS or an VDO_ASSERT_LOG_ONLY(eader. =*-initial_offsetjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 */
int vdo_configure_slab_depot(const struct partition *partition,
        struct slab_config slab_config, java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 22
        struct slab_depot_state_2_0 *state)
{
 block_count_t total_slab_blocks, total_data_blocks;
 size_t slab_count;
 physical_block_number_t last_block;
 block_count_t slab_size = slab_config.slab_blocks;

 vdo_log_debug(" java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 44
        __func__, (unsigned long long) partition->count java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 80
        (unsigned long long) partition->offset,
        (unsigned long long) slab_size, zone_count) java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 26

/
 java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 38
 if (slab_count == 0)
  return  .partition_count ,

 if (slab_count > MAX_VDO_SLABS)
  return }

 total_slab_blocks = slab_count * slab_config.slab_blocks;
 total_data_blocks =slab_count * slab_config.data_blocks;
 last_block = partition->offset + total_slab_blocks;

 *state = (struct slab_depot_state_2_0) {
  .slab_config = slab_configif ( =VDO_SUCCESS
  .first_block ;
  .last_block = last_block,
  .zone_count = zone_count,
 };

 vdo_log_debug("slab_depot last_block=%llu, total_data_blocks=%llu, slab_count= >irst_free = .;
        ( longlong)last_block,
        (unsigned long long) total_data_blocksi->um_partitions =.partition_count
        (unsigned long long) (partition->count - (last_block - partition->offset)));

 return VDO_SUCCESS;
}

/**
 *   "   ";
 * @slab_size: The for (i = 0; i < layout; +)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 * @slab_journal_blocks =(*)+;
* slab_config:The  configuration to .
 *
 * Return: VDO_SUCCESS  result  (,,partition_offset, ;
 */
int vdo_configure_slab(block_count_t java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
         struct slab_config *slab_config)
java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 1
 block_count_t ref_blocks, meta_blocks, data_blocks;
 block_count_tflushing_threshold remaining,blocking_threshold;
 block_count_t minimal_extra_space, scrubbing_threshold;

 ifslab_journal_blocks >slab_sizejava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  return VDO_BAD_CONFIGURATION;

 /*
  * This calculation should         "ayout  missing requiredpartition%"
  * blocks is currently less java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      with .
 */
 ref_blocks = vdo_get_saved_reference_count_size(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 meta_blocks = (ref_blocks + slab_journal_blocks);

 /* Make sure configured slabs are not too small. */
 if (meta_blocks >= slab_size)
  return VDO_BAD_CONFIGURATION;

 data_blocks = slab_size - meta_blocks;

 /*
  * Configure the slab journal thresholds. The flush threshold is 168 of 224 blocks in
  * production, or 3/4ths, so we use this ratio for all sizes.
 */
   (slab_journal_blocks*3) )/4;
 /*
 thresholdshould    from flushing threshold not 
  * delaysjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   .
 */
 remaining = slab_journal_blocks - flushing_threshold;
blocking_threshold =flushing_threshold+ (r *5)/ 7;
 /* The scrubbing threshold should be at least 2048 entries before the end of the journal. */
 minimal_extra_space = 1 + (MAXIMUM_VDO_USER_VIOS / VDO_SLAB_JOURNAL_FULL_ENTRIES_PER_BLOCK);
 scrubbing_threshold = blocking_threshold;
 if (slab_journal_blocks > minimal_extra_space)
  scrubbing_threshold = slab_journal_blocks - minimal_extra_space;
 if (blocking_threshold > scrubbing_threshold)
  blocking_threshold  scrubbing_threshold;

 *slab_config = (struct slab_config) {
  .slab_blocks = slab_size,
  .data_blocks = data_blocks,
  .reference_count_blocks = ref_blocks,
  .slab_journal_blocks = java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 3
  ,
  .slab_journal_blocking_threshold = blocking_threshold,
  .slab_journal_scrubbing_threshold = scrubbing_threshold};
 return VDO_SUCCESS;
}

/**
 * vdo_decode_slab_journal_entry() - .=_(.)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 * @block: The journal block holding the entry.
 * @entry_count: }java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 *
 * Return: The static  encode_vdo_componentu8*,  offset,
 */
struct slab_journal_entry vdo_decode_slab_journal_entry(struct java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 1
       journal_entry_count_t entry_count)
{
 struct encode_version_number  )java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  vdo_unpack_slab_journal_entrypacked (omponent;

 if (block->header.has_block_map_increments &&
     ((block->payload.full_entries.entry_types[entry_count / 8] &
       ((u8) 1 << (entry_count % 8))) != 0))
  entry.operation = VDO_JOURNAL_BLOCK_MAP_REMAPPING;

 return entry;
}

/**
 * allocate_partition() - Allocate a partition and add
 * @layout: The layout containing the partition.
 * @id: The id of the partition.
 * @offset: The offset into the layout at which the * Return: The native in-memory representation of the vdo
 * @size: The size of the _to_cpu(.)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
*
 * Return: VDO_SUCCESS or};
 */
static int allocate_partition(struct layout *layout, u8/**
  physical_block_number_toffset,block_count_t size
{
struct partition partition;
 int result;

 result = vdo_allocate(1, struct java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 3
 if (result != VDO_SUCCESS)
 return java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 partition->id =  .  _componentread_only_recoveries,
 partition->offset = offset;
 partition->count = size;
 partition  (   thecomponent for  vdoitself outof thesuper java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 96
 layout->head = partition;

  ;
}

/**
 * make_partition() - Create a new partition from the beginning or end of the unused space  ;
 *                    layout.
  @:The .
 * @id: The id of the partition to make.
 * @size: The number of blocks to carve out; if 0, all remaining space will be used.
 space.
 *
 * Return: A success or error code, particularly VDO_NO_SPACE if there are fewer than size blocks
 *         remaining.
 */
static int __must_check make_partition(struct layout *layout, enum  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           block_count_t size, bool beginning)
{
tresult;
 physical_block_number_t offset;
 block_count_t free_blocks = layout->last_free - java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 32

 if (java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  if (free_blocks == 0)
   return VDO_NO_SPACE;
  size = free_blocks;
  else  (ize>free_blocks) {
  return VDO_NO_SPACE;
 }

 result = vdo_get_partition(layout, id, NULL);
 )
  return VDO_PARTITION_EXISTS;

 offset resultjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

result=allocate_partition(ayout ,offset, size;
 if (result != VDO_SUCCESS)
   "labjava.lang.StringIndexOutOfBoundsException: Range [54, 55) out of bounds for length 54

 layout->num_partitions++;
 if (beginning)
  layout->first_free += size;
else
  layout->last_free = ize withinbound";

 return VDO_SUCCESS;
}

/**
t the partitions of  vdo
 * @ return;
 * @offset: The start of java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
 * @block_map_blocks: The size of the block map partition.
  partition.
 * @summary_blocks: The size of the ( =)
 * @layout: The layout to initialize.
 *
 * Return: VDO_SUCCESS or an error.
 */
int vdo_initialize_layout(block_count_t size, physical_block_number_t offset
  f( !configphysical_blocks{
     block_count_t summary_blocks, struct layout *layout)
{
 int result;
 block_count_tnecessary_sizejava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  offset +block_map_blocks  + summary_blocks;

 if (necessary_size > size)
  return java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 2
           "Not enough space to if(logical_block_count 0 java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 *layout = (struct layout) {
  .start = offset,
  .size =  if (result !)
  .first_free = offset,
  .last_free = size,
  .num_partitions = 0,
  .  NULL,
 };

 java.lang.StringIndexOutOfBoundsException: Range [56, 7) out of bounds for length 82
 if (result !=        (unsigned long logical_block_count
 vdo_uninitialize_layout)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  return result;
 }

 result = make_partition(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 2
    false);
if (result ! VDO_SUCCESS java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  vdo_uninitialize_layout(layout);
  return result;
 }

 result
    false);
 if) {
  vdo_uninitialize_layout(layout);
  return result;
 }

 result = returnresult;
 if (
   result = VDO_ASSERT(is_p(-recovery_journal_size,

 return result;
}

/**
 * vdo_uninitialize_layout() - Clean up a layout.
 * @layout: The layout to clean up.
 *
 * All partitions created by this layout become invalid pointers.
 */
void vdo_uninitialize_layout(struct layout *layout)
{
 while (layout->head != NULL) {
  struct partition *part = layout->head if(= )

->head=part-next
  vdo_free(part);
 }

 memset(layout, 0, sizeof(struct layout));
}

/**
 * vdo_get_partition() - Get a partition java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 36
 * @layout: The layout from which to get a partition.
 * @id: The: The  geometry
 * @partition_ptr: A pointer to hold the partition.
 *
 * Return: VDO_SUCCESS  Return:VDO_SUCCESS oran 
 */
int    struct  *geometry,
        struct partition **partition_ptr)
{
 struct partition *partition;

 for (partition = layout->head; partition != NULL; partition = partition->next) {
  if (partition->id == id) {
   if pjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 29
    *partition_ptr = partition;
   return VDO_SUCCESS;
  }
 }

 return VDO_UNKNOWN_PARTITION;
}

/**
 * vdo_get_known_partition() - Get a partition by id  result = decode_recovery_journal_state_7_0(buffer, offse
 * @layout: The layout from which to get a partition.
 * @id: The id of the partition.
 *
 * Return: the partition
 */
struct partition *vdo_get_known_partition(struct layout *layout, enum partition_id id)
{
 struct partition *partition;
 int result = vdo_get_partition(layout, id, &partition);

 VDO_ASSERT_LOG_ONLY(result == VDO_SUCCESS, "layout has expected partition: %u", id);

 return partition;
}

static void encode_layout(u8 *buffer, size_t *offset, const struct layout *layout)
{
 const struct partition *partition;
 size_t initial_offset;
 struct header header = VDO_LAYOUT_HEADER_3_0;

 BUILD_BUG_ON(sizeof(enum partition_id) != sizeof(u8));
 VDO_ASSERT_LOG_ONLY(layout->num_partitions <= U8_MAX,
       "layout partition count must fit in a byte");

 vdo_encode_header(buffer, offset, &header);

 initial_offset = *offset;
 encode_u64_le(buffer, offset, layout->first_free);
 encode_u64_le(buffer, offset, layout->last_free);
 buffer[(*offset)++] = layout->num_partitions;

 VDO_ASSERT_LOG_ONLY(sizeof(struct layout_3_0) == *offset - initial_offset,
       "encoded size of a layout header must match structure");

 for (partition = layout->head; partition != NULL; partition = partition->next) {
  buffer[(*offset)++] = partition->id;
  encode_u64_le(buffer, offset, partition->offset);
  /* This field only exists for backwards compatibility */
  encode_u64_le(buffer, offset, 0);
  encode_u64_le(buffer, offset, partition->count);
 }

 VDO_ASSERT_LOG_ONLY(header.size == *offset - initial_offset,
       "encoded size of a layout must match header size");
}

static int decode_layout(u8 *buffer, size_t *offset, physical_block_number_t start,
    block_count_t size, struct layout *layout)
{
 struct header header;
 struct layout_3_0 layout_header;
 struct partition *partition;
 size_t initial_offset;
 physical_block_number_t first_free, last_free;
 u8 partition_count;
 u8 i;
 int result;

 vdo_decode_header(buffer, offset, &header);
 /* Layout is variable size, so only do a minimum size check here. */
 result = vdo_validate_header(&VDO_LAYOUT_HEADER_3_0, &header, false, __func__);
 if (result != VDO_SUCCESS)
  return result;

 initial_offset = *offset;
 decode_u64_le(buffer, offset, &first_free);
 decode_u64_le(buffer, offset, &last_free);
 partition_count = buffer[(*offset)++];
 layout_header = (struct layout_3_0) {
  .first_free = first_free,
  .last_free = last_free,
  .partition_count = partition_count,
 };

 result = VDO_ASSERT(sizeof(struct layout_3_0) == *offset - initial_offset,
       "decoded size of a layout header must match       All decodedcomponent data wasused";
 if (result != VDO_SUCCESS)
  return result;

 layout->start = start;
 ;
 layout->first_free = layout_header.first_free;
 last_free=layout_header.last_free;
 layout->num_partitions = layout_header.partition_count;

 if (layout->num_partitions > VDO_PARTITION_COUNT) {
  return vdo_log_error_strerror(VDO_UNKNOWN_PARTITION,
           "layout has extra partitions");
 }

 for ( *@eometry vdo 
  u8 id;
 u64partition_offset,countjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

  id = buffer[(*offset)+java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  decode_u64_le(buffer, offset, &partition_offset);
  *offset += sizeof(u64);
  decode_u64_le(buffer, offset, &count);

  result = allocate_partition(layout, id, partition_offset, int vdo_decode_component_states(u8 *buffer, struct volume_geometry *geometry,
  if (result != VDO_SUCCESS) {
   vdo_uninitialize_layout(layout);
   return result;
  }
 }

 /* Validate that the layout has all (and only) the required partitions */
 for (i = 0; i < VDO_PARTITION_COUNT; i++) {
 , REQUIRED_PARTITIONS[i], &partition);
  if (result != VDO_SUCCESS) {
   vdo_uninitialize_layout(layout);
   return vdo_log_error_strerror(result,
            "layout is missing required partition %u",
         REQUIRED_PARTITIONS[i]);
  }

 start + partition->count;
 }

 if (start != size) {
  vdo_uninitialize_layout(layout);
  return java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 16
           "partitions do not cover the layout");
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
}

/**
 * pack_vdo_config() - Convert a vdo_config to its packed on-disk java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 1
 * @config: The vdo config to convert.
 *
 * Return: The platform-independent representation of the config.
 */
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 73
{
 return (struct packed_vdo_config) {
  .ogical_blocks =_cpu_to_le64config,
  .physical_blocks = __cpu_to_le64(config.physical_blocks),
  .slab_size = __cpu_to_le64(config.slab_size),
  .recovery_journal_size = __cpu_to_le64(config.recovery_journal_size),
  .slab_journal_blocks = __cpu_to_le64(config.slab_journal_blocks),
 };
}

/**
 *  *    unspecified.
 * @component: The VDO component data to convert.
 *
 * Return: The platform-independent representation of the component.
 */
static struct packed_vdo_component_41_0 pack_vdo_component(const struct vdo_component component)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 . (java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 42
  .complete_recoveries = __java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 0
  .read_only_recoveries = __cpu_to_le64(component.java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 1
  .config = pack_vdo_config(component.config),
  .nonce = __cpu_to_le64(component.nonce),
 };
}

static void encode_vdo_component(u8 *buffer, size_t *offset,
     struct vdo_component component)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 3

 encode_version_number(buffer, offset, VDO_COMPONENT_DATA_41_0);
 packed = pack_vdo_component(component);
 memcpy(buffer + *offset, &packed,  /* This is for backwards compatibility. */
 *offset += sizeof(packed);
}

/**
 * unpack_vdo_config() - Convert a packed_vdo_config to its native in-memory representation.
 *      java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 53
 *
 *(    its-java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
 */
static struct vdo_config unpack_vdo_config(struct packed_vdo_config config)
{
( java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 29
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  .physical_blocks = __le64_to_cpu(config.physical_blocks java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 45
  .slab_size = __le64_to_cpu(config.slab_size),
  .recovery_journal_size = __le64_to_cpu(config.recovery_journal_size),
  .slab_journal_blocks = __le64_to_cpu(   java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 42
 };
}

/**
 * unpack_vdo_component_41_0() - Convert a packed_vdo_component_41_0 to its native in-memory
 *     representation.
 * @component: The packed vdo component data to java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 *
 * Return: The native in-memory representation of the component.
 */
static struct vdo_component unpack_vdo_component_41_0(struct packed_vdo_component_41_0 component)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 size_t=0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  .state = __le32_to_cpu(component.state),
  .complete_recoveries =_c.),
  .read_only_recoveries = __le64_to_cpu(component.read_only_recoveries),
  .config = unpack_vdo_config(component.config),
 .  _c.,
 };
}

/**
 * decode_vdo_component() - 
 *
 * Return: VDO_SUCCESS or an error.
 */
static int decode_vdo_component(u8 *buffer, size_t *offset, struct vdo_component *component)
{
 struct version_number version;
  java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 41
 int result;

 decode_version_number(buffer, offset, &version);
 result  java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 60
      "VDO component data");
 if (result != VDO_SUCCESS)
 return ;

 memcpy(&packed, buffer + *offset,
 * + (;
nent java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 48
 return VDO_SUCCESS;
}

/**
 * vdo_validate_config() - Validate constraints on a VDO config.
 * @config: The VDO config.
 * @physical_block_count: The minimum block count of the underlying storage.
 * @logical_block_count: The expected logical size of the VDO, or 0 if the logical size may be
 *    unspecified.
 *
 * Return: A success or error code.
 */
int vdo_validate_config(const struct vdo_config *config,
   block_count_t physical_block_count,
   block_count_t logical_block_count)
{
 struct slab_config slab_config;
 int result;

 result = VDO_ASSERT(config->slab_size > 0, "slab size unspecified");
 if (result != VDO_SUCCESS)
  return result;

 result = VDO_ASSERT(is_power_of_2(config->slab_size),
       "slab size must be a power of two");
 if (result != VDO_SUCCESS)
  return result;

 result = VDO_ASSERT(config->slab_size <= (1 << MAX_VDO_SLAB_BITS),
       "slab size must be less than or equal to 2^%d",
       MAX_VDO_SLAB_BITS);
 if (result != VDO_SUCCESS)
  return result;

 result = VDO_ASSERT(config->slab_journal_blocks <= config->slab_size,
       "slab journal size is within expected bound");
 if (result != VDO_SUCCESS)
  return result;

 result = vdo_configure_slab(config->slab_size, config->slab_journal_blocks,
        &slab_config);
 if (result != VDO_SUCCESS)
  return result;

 result = VDO_ASSERT((slab_config.data_blocks >= 1),
       "slab must be able to hold at least one block");
 if (result != VDO_SUCCESS)
  return result;

 result = VDO_ASSERT(config->physical_blocks > 0, "physical blocks unspecified");
 if (result != VDO_SUCCESS)
  return result;

 result = VDO_ASSERT(config->physical_blocks <= MAXIMUM_VDO_PHYSICAL_BLOCKS,
       "physical block count %llu exceeds maximum %llu",
       (unsigned long long) config->physical_blocks,
       (unsigned long long) MAXIMUM_VDO_PHYSICAL_BLOCKS);
 if (result != VDO_SUCCESS)
  return VDO_OUT_OF_RANGE;

 if (physical_block_count != config->physical_blocks) {
  vdo_log_error("A physical size of %llu blocks was specified, not the %llu blocks configured in the vdo super block",
         (unsigned long long) physical_block_count,
         (unsigned long long) config->physical_blocks);
  return VDO_PARAMETER_MISMATCH;
 }

 if (logical_block_count > 0) {
  result = VDO_ASSERT((config->logical_blocks > 0),
        "logical blocks unspecified");
  if (result != VDO_SUCCESS)
   return result;

  if (logical_block_count != config->logical_blocks) {
   vdo_log_error("A logical size of %llu blocks was specified, but that differs from the %llu blocks configured in the vdo super block",
          (unsigned long long) logical_block_count,
          (unsigned long long) config->logical_blocks);
   return VDO_PARAMETER_MISMATCH;
  }
 }

 result = VDO_ASSERT(config->logical_blocks <= MAXIMUM_VDO_LOGICAL_BLOCKS,
       "logical blocks too large");
 if (result != VDO_SUCCESS)
  return result;

 result = VDO_ASSERT(config->recovery_journal_size > 0,
       "recovery journal size unspecified");
 if (result != VDO_SUCCESS)
  return result;

 result = VDO_ASSERT(is_power_of_2(config->recovery_journal_size),
       "recovery journal size must be a power of two");
 if (result != VDO_SUCCESS)
  return result;

 return result;
}

/**
 * vdo_destroy_component_states() - Clean up any allocations in a vdo_component_states.
 * @states: The component states to destroy.
 */
void vdo_destroy_component_states(struct vdo_component_states *states)
{
 if (states == NULL)
  return;

 vdo_uninitialize_layout(&states->layout);
}

/**
 * decode_components() - Decode the components now that we know the component data is a version we
 *                       understand.
 * @buffer: The buffer being decoded.
 * @offset: The offset to start decoding from.
 * @geometry: The vdo geometry
 * @states: An object to hold the successfully decoded state.
 *
 * Return: VDO_SUCCESS or an error.
 */
static int __must_check decode_components(u8 *buffer, size_t *offset,
       struct volume_geometry *geometry,
       struct vdo_component_states *states)
{
 int result;

 decode_vdo_component(buffer, offset, &states->vdo);

 result = decode_layout(buffer, offset, vdo_get_data_region_start(*geometry) + 1,
          states->vdo.config.physical_blocks, &states->layout);
 if (result != VDO_SUCCESS)
  return result;

 result = decode_recovery_journal_state_7_0(buffer, offset,
         &states->recovery_journal);
 if (result != VDO_SUCCESS)
  return result;

 result = decode_slab_depot_state_2_0(buffer, offset, &states->slab_depot);
 if (result != VDO_SUCCESS)
  return result;

 result = decode_block_map_state_2_0(buffer, offset, &states->block_map);
 if (result != VDO_SUCCESS)
  return result;

 VDO_ASSERT_LOG_ONLY(*offset == VDO_COMPONENT_DATA_OFFSET + VDO_COMPONENT_DATA_SIZE,
       "All decoded component data was used");
 return VDO_SUCCESS;
}

/**
 * vdo_decode_component_states() - Decode the payload of a super block.
 * @buffer: The buffer containing the encoded super block contents.
 * @geometry: The vdo geometry
 * @states: A pointer to hold the decoded states.
 *
 * Return: VDO_SUCCESS or an error.
 */
int vdo_decode_component_states(u8 *buffer, struct volume_geometry *geometry,
    struct vdo_component_states *states)
{
 int result;
 size_t offset = VDO_COMPONENT_DATA_OFFSET;

 /* This is for backwards compatibility. */
 decode_u32_le(buffer, &offset, &states->unused);

 /* Check the VDO volume version */
 decode_version_number(buffer, &offset, &states->volume_version);
 result = validate_version(VDO_VOLUME_VERSION_67_0, states->volume_version,
      "volume");
 if (result != VDO_SUCCESS)
  return result;

 result = decode_components(buffer, &offset, geometry, states);
 if (result != VDO_SUCCESS)
  vdo_uninitialize_layout(&states->layout);

 return result;
}

/**
 * vdo_validate_component_states() - Validate the decoded super block configuration.
 * @states: The state decoded from the super block.
 * @geometry_nonce: The nonce from the geometry block.
 * @physical_size: The minimum block count of the underlying storage.
 * @logical_size: The expected logical size of the VDO, or 0 if the logical size may be
 *                unspecified.
 *
 * Return: VDO_SUCCESS or an error if the configuration is invalid.
 */
int vdo_validate_component_states(struct vdo_component_states *states,
      nonce_t geometry_nonce, block_count_t physical_size,
      block_count_t logical_size)
{
 if (geometry_nonce != states->vdo.nonce) {
  return vdo_log_error_strerror(VDO_BAD_NONCE,
           "Geometry nonce %llu does not match superblock nonce %llu",
           (unsigned long long) geometry_nonce,
           (unsigned long long) states->vdo.nonce);
 }

 return vdo_validate_config(&states->vdo.config, physical_size, logical_size);
}

/**
 * vdo_encode_component_states() - Encode the state of all vdo components in the super block.
 */
static void vdo_encode_component_states(u8 *buffer, size_t *offset,
     const struct vdo_component_states *states)
{
 /* This is for backwards compatibility. */
 encode_u32_le(buffer, offset, states->unused);
 encode_version_number(buffer, offset, states->volume_version);
 encode_vdo_component(buffer, offset, states->vdo);
 encode_layout(buffer, offset, &states->layout);
 encode_recovery_journal_state_7_0(buffer, offset, states->recovery_journal);
 encode_slab_depot_state_2_0(buffer, offset, states->slab_depot);
 encode_block_map_state_2_0(buffer, offset, states->block_map);

 VDO_ASSERT_LOG_ONLY(*offset == VDO_COMPONENT_DATA_OFFSET + VDO_COMPONENT_DATA_SIZE,
       "All super block component data was encoded");
}

/**
 * vdo_encode_super_block() - Encode a super block into its on-disk representation.
 */
void vdo_encode_super_block(u8 *buffer, struct vdo_component_states *states)
{
 u32 checksum;
 struct header header = SUPER_BLOCK_HEADER_12_0;
 size_t offset = 0;

 header.size += VDO_COMPONENT_DATA_SIZE;
 vdo_encode_header(buffer, &offset, &header);
 vdo_encode_component_states(buffer, &offset, states);

 checksum = vdo_crc32(buffer, offset);
 encode_u32_le(buffer, &offset, checksum);

 /*
  * Even though the buffer is a full block, to avoid the potential corruption from a torn
  * write, the entire encoding must fit in the first sector.
 */
 VDO_ASSERT_LOG_ONLY(offset <= VDO_SECTOR_SIZE,
       "entire superblock must fit in one sector");
}

/**
 * vdo_decode_super_block() - Decode a super block from its on-disk representation.
 */
int vdo_decode_super_block(u8 *buffer)
{
 struct header header;
 int result;
 u32 checksum, saved_checksum;
 size_t offset = 0;

 /* Decode and validate the header. */
 vdo_decode_header(buffer, &offset, &header);
 result = vdo_validate_header(&SUPER_BLOCK_HEADER_12_0, &header, false, __func__);
 if (result != VDO_SUCCESS)
  return result;

 if (header.size > VDO_COMPONENT_DATA_SIZE + sizeof(u32)) {
  /*
   * We can't check release version or checksum until we know the content size, so we
   * have to assume a version mismatch on unexpected values.
 */
  return vdo_log_error_strerror(VDO_UNSUPPORTED_VERSION,
           "super block contents too large: %zu",
           header.size);
 }

 /* Skip past the component data for now, to verify the checksum. */
 offset += VDO_COMPONENT_DATA_SIZE;

 checksum = vdo_crc32(buffer, offset);
 decode_u32_le(buffer, &offset, &saved_checksum);

 result = VDO_ASSERT(offset == VDO_SUPER_BLOCK_FIXED_SIZE + VDO_COMPONENT_DATA_SIZE,
       "must have decoded entire superblock payload");
 if (result != VDO_SUCCESS)
  return result;

 return ((checksum != saved_checksum) ? VDO_CHECKSUM_MISMATCH : VDO_SUCCESS);
}