md/dm-vdo/encodings.c

204 static void encode_version_number(u8 *buffer, size_t *offset,
209 	memcpy(buffer + *offset, &packed, sizeof(packed));
210 	*offset += sizeof(packed);
213 void vdo_encode_header(u8 *buffer, size_t *offset, const struct header *header)
217 	memcpy(buffer + *offset, &packed, sizeof(packed));
218 	*offset += sizeof(packed);
221 static void decode_version_number(u8 *buffer, size_t *offset,
226 	memcpy(&packed, buffer + *offset, sizeof(packed));
227 	*offset += sizeof(packed);
231 void vdo_decode_header(u8 *buffer, size_t *offset, struct header *header)
235 	memcpy(&packed, buffer + *offset, sizeof(packed));
236 	*offset += sizeof(packed);
244  * @offset: The offset in the buffer at which to decode.
248 static void decode_volume_geometry(u8 *buffer, size_t *offset,
258 	decode_u32_le(buffer, offset, &unused);
261 	decode_u64_le(buffer, offset, &nonce);
264 	memcpy((unsigned char *) &geometry->uuid, buffer + *offset, sizeof(uuid_t));
265 	*offset += sizeof(uuid_t);
268 		decode_u64_le(buffer, offset, &bio_offset);
275 		decode_u32_le(buffer, offset, &saved_id);
276 		decode_u64_le(buffer, offset, &start_block);
284 	decode_u32_le(buffer, offset, &mem);
285 	*offset += sizeof(u32);
286 	sparse = buffer[(*offset)++];
303 	size_t offset = 0;
308 	offset += VDO_GEOMETRY_MAGIC_NUMBER_SIZE;
310 	vdo_decode_header(block, &offset, &header);
321 	decode_volume_geometry(block, &offset, geometry, header.version.major_version);
323 	result = VDO_ASSERT(header.size == offset + sizeof(u32),
329 	checksum = vdo_crc32(block, offset);
330 	decode_u32_le(block, &offset, &saved_checksum);
366 static int decode_block_map_state_2_0(u8 *buffer, size_t *offset,
375 	vdo_decode_header(buffer, offset, &header);
380 	initial_offset = *offset;
382 	decode_u64_le(buffer, offset, &flat_page_origin);
390 	decode_u64_le(buffer, offset, &flat_page_count);
397 	decode_u64_le(buffer, offset, &root_origin);
398 	decode_u64_le(buffer, offset, &root_count);
400 	result = VDO_ASSERT(VDO_BLOCK_MAP_HEADER_2_0.size == *offset - initial_offset,
415 static void encode_block_map_state_2_0(u8 *buffer, size_t *offset,
420 	vdo_encode_header(buffer, offset, &VDO_BLOCK_MAP_HEADER_2_0);
422 	initial_offset = *offset;
423 	encode_u64_le(buffer, offset, state.flat_page_origin);
424 	encode_u64_le(buffer, offset, state.flat_page_count);
425 	encode_u64_le(buffer, offset, state.root_origin);
426 	encode_u64_le(buffer, offset, state.root_count);
428 	VDO_ASSERT_LOG_ONLY(VDO_BLOCK_MAP_HEADER_2_0.size == *offset - initial_offset,
468 static void encode_recovery_journal_state_7_0(u8 *buffer, size_t *offset,
473 	vdo_encode_header(buffer, offset, &VDO_RECOVERY_JOURNAL_HEADER_7_0);
475 	initial_offset = *offset;
476 	encode_u64_le(buffer, offset, state.journal_start);
477 	encode_u64_le(buffer, offset, state.logical_blocks_used);
478 	encode_u64_le(buffer, offset, state.block_map_data_blocks);
480 	VDO_ASSERT_LOG_ONLY(VDO_RECOVERY_JOURNAL_HEADER_7_0.size == *offset - initial_offset,
491 static int __must_check decode_recovery_journal_state_7_0(u8 *buffer, size_t *offset,
500 	vdo_decode_header(buffer, offset, &header);
506 	initial_offset = *offset;
507 	decode_u64_le(buffer, offset, &journal_start);
508 	decode_u64_le(buffer, offset, &logical_blocks_used);
509 	decode_u64_le(buffer, offset, &block_map_data_blocks);
511 	result = VDO_ASSERT(VDO_RECOVERY_JOURNAL_HEADER_7_0.size == *offset - initial_offset,
548 static void encode_slab_depot_state_2_0(u8 *buffer, size_t *offset,
553 	vdo_encode_header(buffer, offset, &VDO_SLAB_DEPOT_HEADER_2_0);
555 	initial_offset = *offset;
556 	encode_u64_le(buffer, offset, state.slab_config.slab_blocks);
557 	encode_u64_le(buffer, offset, state.slab_config.data_blocks);
558 	encode_u64_le(buffer, offset, state.slab_config.reference_count_blocks);
559 	encode_u64_le(buffer, offset, state.slab_config.slab_journal_blocks);
560 	encode_u64_le(buffer, offset, state.slab_config.slab_journal_flushing_threshold);
561 	encode_u64_le(buffer, offset, state.slab_config.slab_journal_blocking_threshold);
562 	encode_u64_le(buffer, offset, state.slab_config.slab_journal_scrubbing_threshold);
563 	encode_u64_le(buffer, offset, state.first_block);
564 	encode_u64_le(buffer, offset, state.last_block);
565 	buffer[(*offset)++] = state.zone_count;
567 	VDO_ASSERT_LOG_ONLY(VDO_SLAB_DEPOT_HEADER_2_0.size == *offset - initial_offset,
576 static int decode_slab_depot_state_2_0(u8 *buffer, size_t *offset,
587 	vdo_decode_header(buffer, offset, &header);
593 	initial_offset = *offset;
594 	decode_u64_le(buffer, offset, &count);
597 	decode_u64_le(buffer, offset, &count);
600 	decode_u64_le(buffer, offset, &count);
603 	decode_u64_le(buffer, offset, &count);
606 	decode_u64_le(buffer, offset, &count);
609 	decode_u64_le(buffer, offset, &count);
612 	decode_u64_le(buffer, offset, &count);
615 	decode_u64_le(buffer, offset, &first_block);
616 	decode_u64_le(buffer, offset, &last_block);
617 	zone_count = buffer[(*offset)++];
619 	result = VDO_ASSERT(VDO_SLAB_DEPOT_HEADER_2_0.size == *offset - initial_offset,
658 		      (unsigned long long) partition->offset,
671 	last_block = partition->offset + total_slab_blocks;
675 		.first_block = partition->offset,
683 		      (unsigned long long) (partition->count - (last_block - partition->offset)));
776  * @offset: The offset into the layout at which the partition begins.
782 			      physical_block_number_t offset, block_count_t size)
792 	partition->offset = offset;
815 	physical_block_number_t offset;
830 	offset = beginning ? layout->first_free : (layout->last_free - size);
832 	result = allocate_partition(layout, id, offset, size);
848  * @offset: The start of the layout on the underlying storage in blocks.
856 int vdo_initialize_layout(block_count_t size, physical_block_number_t offset,
862 		(offset + block_map_blocks + journal_blocks + summary_blocks);
869 		.start = offset,
871 		.first_free = offset,
963 static void encode_layout(u8 *buffer, size_t *offset, const struct layout *layout)
973 	vdo_encode_header(buffer, offset, &header);
975 	initial_offset = *offset;
976 	encode_u64_le(buffer, offset, layout->first_free);
977 	encode_u64_le(buffer, offset, layout->last_free);
978 	buffer[(*offset)++] = layout->num_partitions;
980 	VDO_ASSERT_LOG_ONLY(sizeof(struct layout_3_0) == *offset - initial_offset,
984 		buffer[(*offset)++] = partition->id;
985 		encode_u64_le(buffer, offset, partition->offset);
987 		encode_u64_le(buffer, offset, 0);
988 		encode_u64_le(buffer, offset, partition->count);
991 	VDO_ASSERT_LOG_ONLY(header.size == *offset - initial_offset,
995 static int decode_layout(u8 *buffer, size_t *offset, physical_block_number_t start,
1007 	vdo_decode_header(buffer, offset, &header);
1013 	initial_offset = *offset;
1014 	decode_u64_le(buffer, offset, &first_free);
1015 	decode_u64_le(buffer, offset, &last_free);
1016 	partition_count = buffer[(*offset)++];
1023 	result = VDO_ASSERT(sizeof(struct layout_3_0) == *offset - initial_offset,
1043 		id = buffer[(*offset)++];
1044 		decode_u64_le(buffer, offset, &partition_offset);
1045 		*offset += sizeof(u64);
1046 		decode_u64_le(buffer, offset, &count);
1111 static void encode_vdo_component(u8 *buffer, size_t *offset,
1116 	encode_version_number(buffer, offset, VDO_COMPONENT_DATA_41_0);
1118 	memcpy(buffer + *offset, &packed, sizeof(packed));
1119 	*offset += sizeof(packed);
1162 static int decode_vdo_component(u8 *buffer, size_t *offset, struct vdo_component *component)
1168 	decode_version_number(buffer, offset, &version);
1174 	memcpy(&packed, buffer + *offset, sizeof(packed));
1175 	*offset += sizeof(packed);
1292  * @offset: The offset to start decoding from.
1298 static int __must_check decode_components(u8 *buffer, size_t *offset,
1304 	decode_vdo_component(buffer, offset, &states->vdo);
1306 	result = decode_layout(buffer, offset, vdo_get_data_region_start(*geometry) + 1,
1311 	result = decode_recovery_journal_state_7_0(buffer, offset,
1316 	result = decode_slab_depot_state_2_0(buffer, offset, &states->slab_depot);
1320 	result = decode_block_map_state_2_0(buffer, offset, &states->block_map);
1324 	VDO_ASSERT_LOG_ONLY(*offset == VDO_COMPONENT_DATA_OFFSET + VDO_COMPONENT_DATA_SIZE,
1341 	size_t offset = VDO_COMPONENT_DATA_OFFSET;
1344 	decode_u32_le(buffer, &offset, &states->unused);
1347 	decode_version_number(buffer, &offset, &states->volume_version);
1353 	result = decode_components(buffer, &offset, geometry, states);
1387 static void vdo_encode_component_states(u8 *buffer, size_t *offset,
1391 	encode_u32_le(buffer, offset, states->unused);
1392 	encode_version_number(buffer, offset, states->volume_version);
1393 	encode_vdo_component(buffer, offset, states->vdo);
1394 	encode_layout(buffer, offset, &states->layout);
1395 	encode_recovery_journal_state_7_0(buffer, offset, states->recovery_journal);
1396 	encode_slab_depot_state_2_0(buffer, offset, states->slab_depot);
1397 	encode_block_map_state_2_0(buffer, offset, states->block_map);
1399 	VDO_ASSERT_LOG_ONLY(*offset == VDO_COMPONENT_DATA_OFFSET + VDO_COMPONENT_DATA_SIZE,
1410 	size_t offset = 0;
1413 	vdo_encode_header(buffer, &offset, &header);
1414 	vdo_encode_component_states(buffer, &offset, states);
1416 	checksum = vdo_crc32(buffer, offset);
1417 	encode_u32_le(buffer, &offset, checksum);
1423 	VDO_ASSERT_LOG_ONLY(offset <= VDO_SECTOR_SIZE,
1435 	size_t offset = 0;
1438 	vdo_decode_header(buffer, &offset, &header);
1454 	offset += VDO_COMPONENT_DATA_SIZE;
1456 	checksum = vdo_crc32(buffer, offset);
1457 	decode_u32_le(buffer, &offset, &saved_checksum);
1459 	result = VDO_ASSERT(offset == VDO_SUPER_BLOCK_FIXED_SIZE + VDO_COMPONENT_DATA_SIZE,