Lines Matching +full:block +full:- +full:offset
1 // SPDX-License-Identifier: GPL-2.0-only
11 #include "memory-alloc.h"
15 #include "status-codes.h"
109 * The current version for the data encoded in the super block. This must be changed any time there
129 /* This is the minimum size, if the super block contains no components. */
130 .size = VDO_SUPER_BLOCK_FIXED_SIZE - VDO_ENCODED_HEADER_SIZE,
134 * validate_version() - Check whether a version matches an expected version.
162 * vdo_validate_header() - Check whether a header matches expectations.
181 if (expected_header->id != actual_header->id) { in vdo_validate_header()
184 name, expected_header->id, in vdo_validate_header()
185 actual_header->id); in vdo_validate_header()
188 result = validate_version(expected_header->version, actual_header->version, in vdo_validate_header()
193 if ((expected_header->size > actual_header->size) || in vdo_validate_header()
194 (exact_size && (expected_header->size < actual_header->size))) { in vdo_validate_header()
197 name, expected_header->size, in vdo_validate_header()
198 actual_header->size); in vdo_validate_header()
204 static void encode_version_number(u8 *buffer, size_t *offset, in encode_version_number() argument
209 memcpy(buffer + *offset, &packed, sizeof(packed)); in encode_version_number()
210 *offset += sizeof(packed); in encode_version_number()
213 void vdo_encode_header(u8 *buffer, size_t *offset, const struct header *header) in vdo_encode_header() argument
217 memcpy(buffer + *offset, &packed, sizeof(packed)); in vdo_encode_header()
218 *offset += sizeof(packed); in vdo_encode_header()
221 static void decode_version_number(u8 *buffer, size_t *offset, in decode_version_number() argument
226 memcpy(&packed, buffer + *offset, sizeof(packed)); in decode_version_number()
227 *offset += sizeof(packed); in decode_version_number()
231 void vdo_decode_header(u8 *buffer, size_t *offset, struct header *header) in vdo_decode_header() argument
235 memcpy(&packed, buffer + *offset, sizeof(packed)); in vdo_decode_header()
236 *offset += sizeof(packed); in vdo_decode_header()
242 * decode_volume_geometry() - Decode the on-disk representation of a volume geometry from a buffer.
244 * @offset: The offset in the buffer at which to decode.
246 * @version: The geometry block version to decode.
248 static void decode_volume_geometry(u8 *buffer, size_t *offset, in decode_volume_geometry() argument
258 decode_u32_le(buffer, offset, &unused); in decode_volume_geometry()
259 geometry->unused = unused; in decode_volume_geometry()
261 decode_u64_le(buffer, offset, &nonce); in decode_volume_geometry()
262 geometry->nonce = nonce; in decode_volume_geometry()
264 memcpy((unsigned char *) &geometry->uuid, buffer + *offset, sizeof(uuid_t)); in decode_volume_geometry()
265 *offset += sizeof(uuid_t); in decode_volume_geometry()
268 decode_u64_le(buffer, offset, &bio_offset); in decode_volume_geometry()
269 geometry->bio_offset = bio_offset; in decode_volume_geometry()
275 decode_u32_le(buffer, offset, &saved_id); in decode_volume_geometry()
276 decode_u64_le(buffer, offset, &start_block); in decode_volume_geometry()
278 geometry->regions[id] = (struct volume_region) { in decode_volume_geometry()
284 decode_u32_le(buffer, offset, &mem); in decode_volume_geometry()
285 *offset += sizeof(u32); in decode_volume_geometry()
286 sparse = buffer[(*offset)++]; in decode_volume_geometry()
288 geometry->index_config = (struct index_config) { in decode_volume_geometry()
295 * vdo_parse_geometry_block() - Decode and validate an encoded geometry block.
296 * @block: The encoded geometry block.
299 int __must_check vdo_parse_geometry_block(u8 *block, struct volume_geometry *geometry) in vdo_parse_geometry_block() argument
303 size_t offset = 0; in vdo_parse_geometry_block() local
306 if (memcmp(block, VDO_GEOMETRY_MAGIC_NUMBER, VDO_GEOMETRY_MAGIC_NUMBER_SIZE) != 0) in vdo_parse_geometry_block()
308 offset += VDO_GEOMETRY_MAGIC_NUMBER_SIZE; in vdo_parse_geometry_block()
310 vdo_decode_header(block, &offset, &header); in vdo_parse_geometry_block()
321 decode_volume_geometry(block, &offset, geometry, header.version.major_version); in vdo_parse_geometry_block()
323 result = VDO_ASSERT(header.size == offset + sizeof(u32), in vdo_parse_geometry_block()
329 checksum = vdo_crc32(block, offset); in vdo_parse_geometry_block()
330 decode_u32_le(block, &offset, &saved_checksum); in vdo_parse_geometry_block()
342 page->version = vdo_pack_version_number(BLOCK_MAP_4_1); in vdo_format_block_map_page()
343 page->header.nonce = __cpu_to_le64(nonce); in vdo_format_block_map_page()
344 page->header.pbn = __cpu_to_le64(pbn); in vdo_format_block_map_page()
345 page->header.initialized = initialized; in vdo_format_block_map_page()
356 vdo_unpack_version_number(page->version)) || in vdo_validate_block_map_page()
357 !page->header.initialized || (nonce != __le64_to_cpu(page->header.nonce))) in vdo_validate_block_map_page()
366 static int decode_block_map_state_2_0(u8 *buffer, size_t *offset, in decode_block_map_state_2_0() argument
375 vdo_decode_header(buffer, offset, &header); in decode_block_map_state_2_0()
380 initial_offset = *offset; in decode_block_map_state_2_0()
382 decode_u64_le(buffer, offset, &flat_page_origin); in decode_block_map_state_2_0()
386 (unsigned long long) state->flat_page_origin); in decode_block_map_state_2_0()
390 decode_u64_le(buffer, offset, &flat_page_count); in decode_block_map_state_2_0()
393 (unsigned long long) state->flat_page_count); in decode_block_map_state_2_0()
397 decode_u64_le(buffer, offset, &root_origin); in decode_block_map_state_2_0()
398 decode_u64_le(buffer, offset, &root_count); in decode_block_map_state_2_0()
400 result = VDO_ASSERT(VDO_BLOCK_MAP_HEADER_2_0.size == *offset - initial_offset, in decode_block_map_state_2_0()
401 "decoded block map component size must match header size"); in decode_block_map_state_2_0()
415 static void encode_block_map_state_2_0(u8 *buffer, size_t *offset, in encode_block_map_state_2_0() argument
420 vdo_encode_header(buffer, offset, &VDO_BLOCK_MAP_HEADER_2_0); in encode_block_map_state_2_0()
422 initial_offset = *offset; in encode_block_map_state_2_0()
423 encode_u64_le(buffer, offset, state.flat_page_origin); in encode_block_map_state_2_0()
424 encode_u64_le(buffer, offset, state.flat_page_count); in encode_block_map_state_2_0()
425 encode_u64_le(buffer, offset, state.root_origin); in encode_block_map_state_2_0()
426 encode_u64_le(buffer, offset, state.root_count); in encode_block_map_state_2_0()
428 VDO_ASSERT_LOG_ONLY(VDO_BLOCK_MAP_HEADER_2_0.size == *offset - initial_offset, in encode_block_map_state_2_0()
429 "encoded block map component size must match header size"); in encode_block_map_state_2_0()
433 * vdo_compute_new_forest_pages() - Compute the number of pages which must be allocated at each
435 * @entries: The new number of entries the block map must address.
437 * Return: The total number of non-leaf pages required.
453 new_sizes->levels[height] = level_size; in vdo_compute_new_forest_pages()
456 new_pages -= old_sizes->levels[height]; in vdo_compute_new_forest_pages()
464 * encode_recovery_journal_state_7_0() - Encode the state of a recovery journal.
468 static void encode_recovery_journal_state_7_0(u8 *buffer, size_t *offset, in encode_recovery_journal_state_7_0() argument
473 vdo_encode_header(buffer, offset, &VDO_RECOVERY_JOURNAL_HEADER_7_0); in encode_recovery_journal_state_7_0()
475 initial_offset = *offset; in encode_recovery_journal_state_7_0()
476 encode_u64_le(buffer, offset, state.journal_start); in encode_recovery_journal_state_7_0()
477 encode_u64_le(buffer, offset, state.logical_blocks_used); in encode_recovery_journal_state_7_0()
478 encode_u64_le(buffer, offset, state.block_map_data_blocks); in encode_recovery_journal_state_7_0()
480 VDO_ASSERT_LOG_ONLY(VDO_RECOVERY_JOURNAL_HEADER_7_0.size == *offset - initial_offset, in encode_recovery_journal_state_7_0()
485 * decode_recovery_journal_state_7_0() - Decode the state of a recovery journal saved in a buffer.
491 static int __must_check decode_recovery_journal_state_7_0(u8 *buffer, size_t *offset, in decode_recovery_journal_state_7_0() argument
500 vdo_decode_header(buffer, offset, &header); in decode_recovery_journal_state_7_0()
506 initial_offset = *offset; in decode_recovery_journal_state_7_0()
507 decode_u64_le(buffer, offset, &journal_start); in decode_recovery_journal_state_7_0()
508 decode_u64_le(buffer, offset, &logical_blocks_used); in decode_recovery_journal_state_7_0()
509 decode_u64_le(buffer, offset, &block_map_data_blocks); in decode_recovery_journal_state_7_0()
511 result = VDO_ASSERT(VDO_RECOVERY_JOURNAL_HEADER_7_0.size == *offset - initial_offset, in decode_recovery_journal_state_7_0()
526 * vdo_get_journal_operation_name() - Get the name of a journal operation.
538 return "block map remapping"; in vdo_get_journal_operation_name()
546 * encode_slab_depot_state_2_0() - Encode the state of a slab depot into a buffer.
548 static void encode_slab_depot_state_2_0(u8 *buffer, size_t *offset, in encode_slab_depot_state_2_0() argument
553 vdo_encode_header(buffer, offset, &VDO_SLAB_DEPOT_HEADER_2_0); in encode_slab_depot_state_2_0()
555 initial_offset = *offset; in encode_slab_depot_state_2_0()
556 encode_u64_le(buffer, offset, state.slab_config.slab_blocks); in encode_slab_depot_state_2_0()
557 encode_u64_le(buffer, offset, state.slab_config.data_blocks); in encode_slab_depot_state_2_0()
558 encode_u64_le(buffer, offset, state.slab_config.reference_count_blocks); in encode_slab_depot_state_2_0()
559 encode_u64_le(buffer, offset, state.slab_config.slab_journal_blocks); in encode_slab_depot_state_2_0()
560 encode_u64_le(buffer, offset, state.slab_config.slab_journal_flushing_threshold); in encode_slab_depot_state_2_0()
561 encode_u64_le(buffer, offset, state.slab_config.slab_journal_blocking_threshold); in encode_slab_depot_state_2_0()
562 encode_u64_le(buffer, offset, state.slab_config.slab_journal_scrubbing_threshold); in encode_slab_depot_state_2_0()
563 encode_u64_le(buffer, offset, state.first_block); in encode_slab_depot_state_2_0()
564 encode_u64_le(buffer, offset, state.last_block); in encode_slab_depot_state_2_0()
565 buffer[(*offset)++] = state.zone_count; in encode_slab_depot_state_2_0()
567 VDO_ASSERT_LOG_ONLY(VDO_SLAB_DEPOT_HEADER_2_0.size == *offset - initial_offset, in encode_slab_depot_state_2_0()
568 "encoded block map component size must match header size"); in encode_slab_depot_state_2_0()
572 * decode_slab_depot_state_2_0() - Decode slab depot component state version 2.0 from a buffer.
576 static int decode_slab_depot_state_2_0(u8 *buffer, size_t *offset, in decode_slab_depot_state_2_0() argument
587 vdo_decode_header(buffer, offset, &header); in decode_slab_depot_state_2_0()
593 initial_offset = *offset; in decode_slab_depot_state_2_0()
594 decode_u64_le(buffer, offset, &count); in decode_slab_depot_state_2_0()
597 decode_u64_le(buffer, offset, &count); in decode_slab_depot_state_2_0()
600 decode_u64_le(buffer, offset, &count); in decode_slab_depot_state_2_0()
603 decode_u64_le(buffer, offset, &count); in decode_slab_depot_state_2_0()
606 decode_u64_le(buffer, offset, &count); in decode_slab_depot_state_2_0()
609 decode_u64_le(buffer, offset, &count); in decode_slab_depot_state_2_0()
612 decode_u64_le(buffer, offset, &count); in decode_slab_depot_state_2_0()
615 decode_u64_le(buffer, offset, &first_block); in decode_slab_depot_state_2_0()
616 decode_u64_le(buffer, offset, &last_block); in decode_slab_depot_state_2_0()
617 zone_count = buffer[(*offset)++]; in decode_slab_depot_state_2_0()
619 result = VDO_ASSERT(VDO_SLAB_DEPOT_HEADER_2_0.size == *offset - initial_offset, in decode_slab_depot_state_2_0()
635 * vdo_configure_slab_depot() - Configure the slab depot.
657 __func__, (unsigned long long) partition->count, in vdo_configure_slab_depot()
658 (unsigned long long) partition->offset, in vdo_configure_slab_depot()
662 slab_count = (partition->count / slab_size); in vdo_configure_slab_depot()
671 last_block = partition->offset + total_slab_blocks; in vdo_configure_slab_depot()
675 .first_block = partition->offset, in vdo_configure_slab_depot()
683 (unsigned long long) (partition->count - (last_block - partition->offset))); in vdo_configure_slab_depot()
689 * vdo_configure_slab() - Measure and initialize the configuration to use for each slab.
708 * blocks is currently less than a single block of ref_counts, so we'd gain at most one in vdo_configure_slab()
709 * data block in each slab with more iteration. in vdo_configure_slab()
711 ref_blocks = vdo_get_saved_reference_count_size(slab_size - slab_journal_blocks); in vdo_configure_slab()
718 data_blocks = slab_size - meta_blocks; in vdo_configure_slab()
730 remaining = slab_journal_blocks - flushing_threshold; in vdo_configure_slab()
736 scrubbing_threshold = slab_journal_blocks - minimal_extra_space; in vdo_configure_slab()
752 * vdo_decode_slab_journal_entry() - Decode a slab journal entry.
753 * @block: The journal block holding the entry.
758 struct slab_journal_entry vdo_decode_slab_journal_entry(struct packed_slab_journal_block *block, in vdo_decode_slab_journal_entry() argument
762 vdo_unpack_slab_journal_entry(&block->payload.entries[entry_count]); in vdo_decode_slab_journal_entry()
764 if (block->header.has_block_map_increments && in vdo_decode_slab_journal_entry()
765 ((block->payload.full_entries.entry_types[entry_count / 8] & in vdo_decode_slab_journal_entry()
773 * allocate_partition() - Allocate a partition and add it to a layout.
776 * @offset: The offset into the layout at which the partition begins.
782 physical_block_number_t offset, block_count_t size) in allocate_partition() argument
791 partition->id = id; in allocate_partition()
792 partition->offset = offset; in allocate_partition()
793 partition->count = size; in allocate_partition()
794 partition->next = layout->head; in allocate_partition()
795 layout->head = partition; in allocate_partition()
801 * make_partition() - Create a new partition from the beginning or end of the unused space in a
815 physical_block_number_t offset; in make_partition() local
816 block_count_t free_blocks = layout->last_free - layout->first_free; in make_partition()
830 offset = beginning ? layout->first_free : (layout->last_free - size); in make_partition()
832 result = allocate_partition(layout, id, offset, size); in make_partition()
836 layout->num_partitions++; in make_partition()
838 layout->first_free += size; in make_partition()
840 layout->last_free = layout->last_free - size; in make_partition()
846 * vdo_initialize_layout() - Lay out the partitions of a vdo.
848 * @offset: The start of the layout on the underlying storage in blocks.
849 * @block_map_blocks: The size of the block map partition.
856 int vdo_initialize_layout(block_count_t size, physical_block_number_t offset, in vdo_initialize_layout() argument
862 (offset + block_map_blocks + journal_blocks + summary_blocks); in vdo_initialize_layout()
869 .start = offset, in vdo_initialize_layout()
871 .first_free = offset, in vdo_initialize_layout()
905 * vdo_uninitialize_layout() - Clean up a layout.
912 while (layout->head != NULL) { in vdo_uninitialize_layout()
913 struct partition *part = layout->head; in vdo_uninitialize_layout()
915 layout->head = part->next; in vdo_uninitialize_layout()
923 * vdo_get_partition() - Get a partition by id.
935 for (partition = layout->head; partition != NULL; partition = partition->next) { in vdo_get_partition()
936 if (partition->id == id) { in vdo_get_partition()
947 * vdo_get_known_partition() - Get a partition by id from a validated layout.
963 static void encode_layout(u8 *buffer, size_t *offset, const struct layout *layout) in encode_layout() argument
970 VDO_ASSERT_LOG_ONLY(layout->num_partitions <= U8_MAX, in encode_layout()
973 vdo_encode_header(buffer, offset, &header); in encode_layout()
975 initial_offset = *offset; in encode_layout()
976 encode_u64_le(buffer, offset, layout->first_free); in encode_layout()
977 encode_u64_le(buffer, offset, layout->last_free); in encode_layout()
978 buffer[(*offset)++] = layout->num_partitions; in encode_layout()
980 VDO_ASSERT_LOG_ONLY(sizeof(struct layout_3_0) == *offset - initial_offset, in encode_layout()
983 for (partition = layout->head; partition != NULL; partition = partition->next) { in encode_layout()
984 buffer[(*offset)++] = partition->id; in encode_layout()
985 encode_u64_le(buffer, offset, partition->offset); in encode_layout()
987 encode_u64_le(buffer, offset, 0); in encode_layout()
988 encode_u64_le(buffer, offset, partition->count); in encode_layout()
991 VDO_ASSERT_LOG_ONLY(header.size == *offset - initial_offset, in encode_layout()
995 static int decode_layout(u8 *buffer, size_t *offset, physical_block_number_t start, in decode_layout() argument
1007 vdo_decode_header(buffer, offset, &header); in decode_layout()
1013 initial_offset = *offset; in decode_layout()
1014 decode_u64_le(buffer, offset, &first_free); in decode_layout()
1015 decode_u64_le(buffer, offset, &last_free); in decode_layout()
1016 partition_count = buffer[(*offset)++]; in decode_layout()
1023 result = VDO_ASSERT(sizeof(struct layout_3_0) == *offset - initial_offset, in decode_layout()
1028 layout->start = start; in decode_layout()
1029 layout->size = size; in decode_layout()
1030 layout->first_free = layout_header.first_free; in decode_layout()
1031 layout->last_free = layout_header.last_free; in decode_layout()
1032 layout->num_partitions = layout_header.partition_count; in decode_layout()
1034 if (layout->num_partitions > VDO_PARTITION_COUNT) { in decode_layout()
1039 for (i = 0; i < layout->num_partitions; i++) { in decode_layout()
1043 id = buffer[(*offset)++]; in decode_layout()
1044 decode_u64_le(buffer, offset, &partition_offset); in decode_layout()
1045 *offset += sizeof(u64); in decode_layout()
1046 decode_u64_le(buffer, offset, &count); in decode_layout()
1065 start += partition->count; in decode_layout()
1078 * pack_vdo_config() - Convert a vdo_config to its packed on-disk representation.
1081 * Return: The platform-independent representation of the config.
1095 * pack_vdo_component() - Convert a vdo_component to its packed on-disk representation.
1098 * Return: The platform-independent representation of the component.
1111 static void encode_vdo_component(u8 *buffer, size_t *offset, in encode_vdo_component() argument
1116 encode_version_number(buffer, offset, VDO_COMPONENT_DATA_41_0); in encode_vdo_component()
1118 memcpy(buffer + *offset, &packed, sizeof(packed)); in encode_vdo_component()
1119 *offset += sizeof(packed); in encode_vdo_component()
1123 * unpack_vdo_config() - Convert a packed_vdo_config to its native in-memory representation.
1126 * Return: The native in-memory representation of the vdo config.
1140 * unpack_vdo_component_41_0() - Convert a packed_vdo_component_41_0 to its native in-memory
1144 * Return: The native in-memory representation of the component.
1158 * decode_vdo_component() - Decode the component data for the vdo itself out of the super block.
1162 static int decode_vdo_component(u8 *buffer, size_t *offset, struct vdo_component *component) in decode_vdo_component() argument
1168 decode_version_number(buffer, offset, &version); in decode_vdo_component()
1174 memcpy(&packed, buffer + *offset, sizeof(packed)); in decode_vdo_component()
1175 *offset += sizeof(packed); in decode_vdo_component()
1181 * vdo_validate_config() - Validate constraints on a VDO config.
1183 * @physical_block_count: The minimum block count of the underlying storage.
1196 result = VDO_ASSERT(config->slab_size > 0, "slab size unspecified"); in vdo_validate_config()
1200 result = VDO_ASSERT(is_power_of_2(config->slab_size), in vdo_validate_config()
1205 result = VDO_ASSERT(config->slab_size <= (1 << MAX_VDO_SLAB_BITS), in vdo_validate_config()
1211 result = VDO_ASSERT(config->slab_journal_blocks <= config->slab_size, in vdo_validate_config()
1216 result = vdo_configure_slab(config->slab_size, config->slab_journal_blocks, in vdo_validate_config()
1222 "slab must be able to hold at least one block"); in vdo_validate_config()
1226 result = VDO_ASSERT(config->physical_blocks > 0, "physical blocks unspecified"); in vdo_validate_config()
1230 result = VDO_ASSERT(config->physical_blocks <= MAXIMUM_VDO_PHYSICAL_BLOCKS, in vdo_validate_config()
1231 "physical block count %llu exceeds maximum %llu", in vdo_validate_config()
1232 (unsigned long long) config->physical_blocks, in vdo_validate_config()
1237 if (physical_block_count != config->physical_blocks) { in vdo_validate_config()
1238 …physical size of %llu blocks was specified, not the %llu blocks configured in the vdo super block", in vdo_validate_config()
1240 (unsigned long long) config->physical_blocks); in vdo_validate_config()
1245 result = VDO_ASSERT((config->logical_blocks > 0), in vdo_validate_config()
1250 if (logical_block_count != config->logical_blocks) { in vdo_validate_config()
1251 …llu blocks was specified, but that differs from the %llu blocks configured in the vdo super block", in vdo_validate_config()
1253 (unsigned long long) config->logical_blocks); in vdo_validate_config()
1258 result = VDO_ASSERT(config->logical_blocks <= MAXIMUM_VDO_LOGICAL_BLOCKS, in vdo_validate_config()
1263 result = VDO_ASSERT(config->recovery_journal_size > 0, in vdo_validate_config()
1268 result = VDO_ASSERT(is_power_of_2(config->recovery_journal_size), in vdo_validate_config()
1277 * vdo_destroy_component_states() - Clean up any allocations in a vdo_component_states.
1285 vdo_uninitialize_layout(&states->layout); in vdo_destroy_component_states()
1289 * decode_components() - Decode the components now that we know the component data is a version we
1292 * @offset: The offset to start decoding from.
1298 static int __must_check decode_components(u8 *buffer, size_t *offset, in decode_components() argument
1304 decode_vdo_component(buffer, offset, &states->vdo); in decode_components()
1306 result = decode_layout(buffer, offset, vdo_get_data_region_start(*geometry) + 1, in decode_components()
1307 states->vdo.config.physical_blocks, &states->layout); in decode_components()
1311 result = decode_recovery_journal_state_7_0(buffer, offset, in decode_components()
1312 &states->recovery_journal); in decode_components()
1316 result = decode_slab_depot_state_2_0(buffer, offset, &states->slab_depot); in decode_components()
1320 result = decode_block_map_state_2_0(buffer, offset, &states->block_map); in decode_components()
1324 VDO_ASSERT_LOG_ONLY(*offset == VDO_COMPONENT_DATA_OFFSET + VDO_COMPONENT_DATA_SIZE, in decode_components()
1330 * vdo_decode_component_states() - Decode the payload of a super block.
1331 * @buffer: The buffer containing the encoded super block contents.
1341 size_t offset = VDO_COMPONENT_DATA_OFFSET; in vdo_decode_component_states() local
1344 decode_u32_le(buffer, &offset, &states->unused); in vdo_decode_component_states()
1347 decode_version_number(buffer, &offset, &states->volume_version); in vdo_decode_component_states()
1348 result = validate_version(VDO_VOLUME_VERSION_67_0, states->volume_version, in vdo_decode_component_states()
1353 result = decode_components(buffer, &offset, geometry, states); in vdo_decode_component_states()
1355 vdo_uninitialize_layout(&states->layout); in vdo_decode_component_states()
1361 * vdo_validate_component_states() - Validate the decoded super block configuration.
1362 * @states: The state decoded from the super block.
1363 * @geometry_nonce: The nonce from the geometry block.
1364 * @physical_size: The minimum block count of the underlying storage.
1374 if (geometry_nonce != states->vdo.nonce) { in vdo_validate_component_states()
1378 (unsigned long long) states->vdo.nonce); in vdo_validate_component_states()
1381 return vdo_validate_config(&states->vdo.config, physical_size, logical_size); in vdo_validate_component_states()
1385 * vdo_encode_component_states() - Encode the state of all vdo components in the super block.
1387 static void vdo_encode_component_states(u8 *buffer, size_t *offset, in vdo_encode_component_states() argument
1391 encode_u32_le(buffer, offset, states->unused); in vdo_encode_component_states()
1392 encode_version_number(buffer, offset, states->volume_version); in vdo_encode_component_states()
1393 encode_vdo_component(buffer, offset, states->vdo); in vdo_encode_component_states()
1394 encode_layout(buffer, offset, &states->layout); in vdo_encode_component_states()
1395 encode_recovery_journal_state_7_0(buffer, offset, states->recovery_journal); in vdo_encode_component_states()
1396 encode_slab_depot_state_2_0(buffer, offset, states->slab_depot); in vdo_encode_component_states()
1397 encode_block_map_state_2_0(buffer, offset, states->block_map); in vdo_encode_component_states()
1399 VDO_ASSERT_LOG_ONLY(*offset == VDO_COMPONENT_DATA_OFFSET + VDO_COMPONENT_DATA_SIZE, in vdo_encode_component_states()
1400 "All super block component data was encoded"); in vdo_encode_component_states()
1404 * vdo_encode_super_block() - Encode a super block into its on-disk representation.
1410 size_t offset = 0; in vdo_encode_super_block() local
1413 vdo_encode_header(buffer, &offset, &header); in vdo_encode_super_block()
1414 vdo_encode_component_states(buffer, &offset, states); in vdo_encode_super_block()
1416 checksum = vdo_crc32(buffer, offset); in vdo_encode_super_block()
1417 encode_u32_le(buffer, &offset, checksum); in vdo_encode_super_block()
1420 * Even though the buffer is a full block, to avoid the potential corruption from a torn in vdo_encode_super_block()
1423 VDO_ASSERT_LOG_ONLY(offset <= VDO_SECTOR_SIZE, in vdo_encode_super_block()
1428 * vdo_decode_super_block() - Decode a super block from its on-disk representation.
1435 size_t offset = 0; in vdo_decode_super_block() local
1438 vdo_decode_header(buffer, &offset, &header); in vdo_decode_super_block()
1449 "super block contents too large: %zu", in vdo_decode_super_block()
1454 offset += VDO_COMPONENT_DATA_SIZE; in vdo_decode_super_block()
1456 checksum = vdo_crc32(buffer, offset); in vdo_decode_super_block()
1457 decode_u32_le(buffer, &offset, &saved_checksum); in vdo_decode_super_block()
1459 result = VDO_ASSERT(offset == VDO_SUPER_BLOCK_FIXED_SIZE + VDO_COMPONENT_DATA_SIZE, in vdo_decode_super_block()