md/dm-vdo/encodings.h

50 /* The header for versioned data stored on disk. */
51 struct header {
52 	u32 id; /* The component this is a header for */
54 	size_t size; /* The size of the data following this header */
57 /* A packed, machine-independent, on-disk representation of a component header. */
173 	struct block_map_page_header header;
195 extern const struct header VDO_BLOCK_MAP_HEADER_2_0;
207 extern const struct header VDO_RECOVERY_JOURNAL_HEADER_7_0;
322  * The packed, on-disk representation of a recovery journal block header. All fields are kept in
439 extern const struct header VDO_SLAB_DEPOT_HEADER_2_0;
469 /* The unpacked representation of the header of a slab journal block */
488  * The packed, on-disk representation of a slab journal block header. All fields are kept in
536 	struct packed_slab_journal_block_header header;
728 int __must_check vdo_validate_header(const struct header *expected_header,
729 				     const struct header *actual_header, bool exact_size,
732 void vdo_encode_header(u8 *buffer, size_t *offset, const struct header *header);
733 void vdo_decode_header(u8 *buffer, size_t *offset, struct header *header);
765  * vdo_pack_header() - Convert a component header to its packed on-disk representation.
766  * @header: The header to convert.
768  * Return: the platform-independent representation of the header
770 static inline struct packed_header vdo_pack_header(const struct header *header)
773 		.id = __cpu_to_le32(header->id),
774 		.version = vdo_pack_version_number(header->version),
775 		.size = __cpu_to_le64(header->size),
781  * @header: The header to convert.
785 static inline struct header vdo_unpack_header(const struct packed_header *header)
787 	return (struct header) {
788 		.id = __le32_to_cpu(header->id),
789 		.version = vdo_unpack_version_number(header->version),
790 		.size = __le64_to_cpu(header->size),
876 	return __le64_to_cpu(page->header.pbn);
947  * vdo_is_valid_recovery_journal_sector() - Determine whether the header of the given sector could
949  *                                          header.
950  * @header: The unpacked block header to compare against.
954  * Return: true if the sector matches the block header.
957 vdo_is_valid_recovery_journal_sector(const struct recovery_block_header *header,
961 	if ((header->check_byte != sector->check_byte) ||
962 	    (header->recovery_count != sector->recovery_count))
965 	if (header->metadata_type == VDO_METADATA_RECOVERY_JOURNAL_2)
995  * vdo_get_journal_block_sector() - Find the recovery journal sector from the block header and
997  * @header: The header of the recovery journal block.
1003 vdo_get_journal_block_sector(struct packed_journal_header *header, int sector_number)
1005 	char *sector_data = ((char *) header) + (VDO_SECTOR_SIZE * sector_number);
1012  *                                    header.
1013  * @header: The header containing the values to encode.
1014  * @packed: The header into which to pack the values.
1016 static inline void vdo_pack_recovery_block_header(const struct recovery_block_header *header,
1020 		.block_map_head = __cpu_to_le64(header->block_map_head),
1021 		.slab_journal_head = __cpu_to_le64(header->slab_journal_head),
1022 		.sequence_number = __cpu_to_le64(header->sequence_number),
1023 		.nonce = __cpu_to_le64(header->nonce),
1024 		.logical_blocks_used = __cpu_to_le64(header->logical_blocks_used),
1025 		.block_map_data_blocks = __cpu_to_le64(header->block_map_data_blocks),
1026 		.entry_count = __cpu_to_le16(header->entry_count),
1027 		.check_byte = header->check_byte,
1028 		.recovery_count = header->recovery_count,
1029 		.metadata_type = header->metadata_type,
1035  *                                      header.
1036  * @packed: The packed header to decode.
1038  * Return: The unpacked header.
1167  *                                        header.
1168  * @header: The header containing the values to encode.
1169  * @packed: The header into which to pack the values.
1172 vdo_pack_slab_journal_block_header(const struct slab_journal_block_header *header,
1175 	packed->head = __cpu_to_le64(header->head);
1176 	packed->sequence_number = __cpu_to_le64(header->sequence_number);
1177 	packed->nonce = __cpu_to_le64(header->nonce);
1178 	packed->entry_count = __cpu_to_le16(header->entry_count);
1179 	packed->metadata_type = header->metadata_type;
1180 	packed->has_block_map_increments = header->has_block_map_increments;
1182 	vdo_pack_journal_point(&header->recovery_point, &packed->recovery_point);
1187  *                                          header.
1188  * @packed: The packed header to decode.
1189  * @header: The header into which to unpack the values.
1193 				     struct slab_journal_block_header *header)
1195 	*header = (struct slab_journal_block_header) {
1203 	vdo_unpack_journal_point(&packed->recovery_point, &header->recovery_point);