| /* SPDX-License-Identifier: GPL-2.0-only */ | |
| /* | |
| * Copyright 2023 Red Hat | |
| */ | |
| #ifndef VDO_TYPES_H | |
| #define VDO_TYPES_H | |
| #include <linux/bio.h> | |
| #include <linux/blkdev.h> | |
| #include <linux/device-mapper.h> | |
| #include <linux/list.h> | |
| #include <linux/compiler_attributes.h> | |
| #include <linux/types.h> | |
| #include "funnel-queue.h" | |
| /* A size type in blocks. */ | |
| typedef u64 block_count_t; | |
| /* The size of a block. */ | |
| typedef u16 block_size_t; | |
| /* A counter for data_vios */ | |
| typedef u16 data_vio_count_t; | |
| /* A height within a tree. */ | |
| typedef u8 height_t; | |
| /* The logical block number as used by the consumer. */ | |
| typedef u64 logical_block_number_t; | |
| /* The type of the nonce used to identify instances of VDO. */ | |
| typedef u64 nonce_t; | |
| /* A size in pages. */ | |
| typedef u32 page_count_t; | |
| /* A page number. */ | |
| typedef u32 page_number_t; | |
| /* | |
| * The physical (well, less logical) block number at which the block is found on the underlying | |
| * device. | |
| */ | |
| typedef u64 physical_block_number_t; | |
| /* A count of tree roots. */ | |
| typedef u8 root_count_t; | |
| /* A number of sectors. */ | |
| typedef u8 sector_count_t; | |
| /* A sequence number. */ | |
| typedef u64 sequence_number_t; | |
| /* The offset of a block within a slab. */ | |
| typedef u32 slab_block_number; | |
| /* A size type in slabs. */ | |
| typedef u16 slab_count_t; | |
| /* A slot in a bin or block map page. */ | |
| typedef u16 slot_number_t; | |
| /* typedef thread_count_t - A thread counter. */ | |
| typedef u8 thread_count_t; | |
| /* typedef thread_id_t - A thread ID, vdo threads are numbered sequentially from 0. */ | |
| typedef u8 thread_id_t; | |
| /* A zone counter */ | |
| typedef u8 zone_count_t; | |
| /* The following enums are persisted on storage, so the values must be preserved. */ | |
| /* The current operating mode of the VDO. */ | |
| enum vdo_state { | |
| VDO_DIRTY = 0, | |
| VDO_NEW = 1, | |
| VDO_CLEAN = 2, | |
| VDO_READ_ONLY_MODE = 3, | |
| VDO_FORCE_REBUILD = 4, | |
| VDO_RECOVERING = 5, | |
| VDO_REPLAYING = 6, /* VDO_REPLAYING is never set anymore, but retained for upgrade */ | |
| VDO_REBUILD_FOR_UPGRADE = 7, | |
| /* Keep VDO_STATE_COUNT at the bottom. */ | |
| VDO_STATE_COUNT | |
| }; | |
| /** | |
| * vdo_state_requires_read_only_rebuild() - Check whether a vdo_state indicates | |
| * that a read-only rebuild is required. | |
| * @state: The vdo_state to check. | |
| * | |
| * Return: true if the state indicates a rebuild is required | |
| */ | |
| static inline bool __must_check vdo_state_requires_read_only_rebuild(enum vdo_state state) | |
| { | |
| return ((state == VDO_FORCE_REBUILD) || (state == VDO_REBUILD_FOR_UPGRADE)); | |
| } | |
| /** | |
| * vdo_state_requires_recovery() - Check whether a vdo state indicates that recovery is needed. | |
| * @state: The state to check. | |
| * | |
| * Return: true if the state indicates a recovery is required | |
| */ | |
| static inline bool __must_check vdo_state_requires_recovery(enum vdo_state state) | |
| { | |
| return ((state == VDO_DIRTY) || (state == VDO_REPLAYING) || (state == VDO_RECOVERING)); | |
| } | |
| /* | |
| * The current operation on a physical block (from the point of view of the recovery journal, slab | |
| * journals, and reference counts. | |
| */ | |
| enum journal_operation { | |
| VDO_JOURNAL_DATA_REMAPPING = 0, | |
| VDO_JOURNAL_BLOCK_MAP_REMAPPING = 1, | |
| } __packed; | |
| /* Partition IDs encoded in the volume layout in the super block. */ | |
| enum partition_id { | |
| VDO_BLOCK_MAP_PARTITION = 0, | |
| VDO_SLAB_DEPOT_PARTITION = 1, | |
| VDO_RECOVERY_JOURNAL_PARTITION = 2, | |
| VDO_SLAB_SUMMARY_PARTITION = 3, | |
| } __packed; | |
| /* Metadata types for the vdo. */ | |
| enum vdo_metadata_type { | |
| VDO_METADATA_RECOVERY_JOURNAL = 1, | |
| VDO_METADATA_SLAB_JOURNAL = 2, | |
| VDO_METADATA_RECOVERY_JOURNAL_2 = 3, | |
| } __packed; | |
| /* A position in the block map where a block map entry is stored. */ | |
| struct block_map_slot { | |
| physical_block_number_t pbn; | |
| slot_number_t slot; | |
| }; | |
| /* | |
| * Four bits of each five-byte block map entry contain a mapping state value used to distinguish | |
| * unmapped or discarded logical blocks (which are treated as mapped to the zero block) from entries | |
| * that have been mapped to a physical block, including the zero block. | |
| * | |
| * FIXME: these should maybe be defines. | |
| */ | |
| enum block_mapping_state { | |
| VDO_MAPPING_STATE_UNMAPPED = 0, /* Must be zero to be the default value */ | |
| VDO_MAPPING_STATE_UNCOMPRESSED = 1, /* A normal (uncompressed) block */ | |
| VDO_MAPPING_STATE_COMPRESSED_BASE = 2, /* Compressed in slot 0 */ | |
| VDO_MAPPING_STATE_COMPRESSED_MAX = 15, /* Compressed in slot 13 */ | |
| }; | |
| enum { | |
| VDO_MAX_COMPRESSION_SLOTS = | |
| (VDO_MAPPING_STATE_COMPRESSED_MAX - VDO_MAPPING_STATE_COMPRESSED_BASE + 1), | |
| }; | |
| struct data_location { | |
| physical_block_number_t pbn; | |
| enum block_mapping_state state; | |
| }; | |
| /* The configuration of a single slab derived from the configured block size and slab size. */ | |
| struct slab_config { | |
| /* total number of blocks in the slab */ | |
| block_count_t slab_blocks; | |
| /* number of blocks available for data */ | |
| block_count_t data_blocks; | |
| /* number of blocks for reference counts */ | |
| block_count_t reference_count_blocks; | |
| /* number of blocks for the slab journal */ | |
| block_count_t slab_journal_blocks; | |
| /* | |
| * Number of blocks after which the slab journal starts pushing out a reference_block for | |
| * each new entry it receives. | |
| */ | |
| block_count_t slab_journal_flushing_threshold; | |
| /* | |
| * Number of blocks after which the slab journal pushes out all reference_blocks and makes | |
| * all vios wait. | |
| */ | |
| block_count_t slab_journal_blocking_threshold; | |
| /* Number of blocks after which the slab must be scrubbed before coming online. */ | |
| block_count_t slab_journal_scrubbing_threshold; | |
| } __packed; | |
| /* | |
| * This structure is memcmp'd for equality. Keep it packed and don't add any fields that are not | |
| * properly set in both extant and parsed configs. | |
| */ | |
| struct thread_count_config { | |
| unsigned int bio_ack_threads; | |
| unsigned int bio_threads; | |
| unsigned int bio_rotation_interval; | |
| unsigned int cpu_threads; | |
| unsigned int logical_zones; | |
| unsigned int physical_zones; | |
| unsigned int hash_zones; | |
| } __packed; | |
| struct device_config { | |
| struct dm_target *owning_target; | |
| struct dm_dev *owned_device; | |
| struct vdo *vdo; | |
| /* All configs referencing a layer are kept on a list in the layer */ | |
| struct list_head config_list; | |
| char *original_string; | |
| unsigned int version; | |
| char *parent_device_name; | |
| block_count_t physical_blocks; | |
| /* | |
| * This is the number of logical blocks from VDO's internal point of view. It is the number | |
| * of 4K blocks regardless of the value of the logical_block_size parameter below. | |
| */ | |
| block_count_t logical_blocks; | |
| unsigned int logical_block_size; | |
| unsigned int cache_size; | |
| unsigned int block_map_maximum_age; | |
| bool deduplication; | |
| bool compression; | |
| struct thread_count_config thread_counts; | |
| block_count_t max_discard_blocks; | |
| }; | |
| enum vdo_completion_type { | |
| /* Keep VDO_UNSET_COMPLETION_TYPE at the top. */ | |
| VDO_UNSET_COMPLETION_TYPE, | |
| VDO_ACTION_COMPLETION, | |
| VDO_ADMIN_COMPLETION, | |
| VDO_BLOCK_ALLOCATOR_COMPLETION, | |
| VDO_DATA_VIO_POOL_COMPLETION, | |
| VDO_DECREMENT_COMPLETION, | |
| VDO_FLUSH_COMPLETION, | |
| VDO_FLUSH_NOTIFICATION_COMPLETION, | |
| VDO_GENERATION_FLUSHED_COMPLETION, | |
| VDO_HASH_ZONE_COMPLETION, | |
| VDO_HASH_ZONES_COMPLETION, | |
| VDO_LOCK_COUNTER_COMPLETION, | |
| VDO_PAGE_COMPLETION, | |
| VDO_READ_ONLY_MODE_COMPLETION, | |
| VDO_REPAIR_COMPLETION, | |
| VDO_SYNC_COMPLETION, | |
| VIO_COMPLETION, | |
| } __packed; | |
| struct vdo_completion; | |
| /** | |
| * typedef vdo_action_fn - An asynchronous VDO operation. | |
| * @completion: The completion of the operation. | |
| */ | |
| typedef void (*vdo_action_fn)(struct vdo_completion *completion); | |
| enum vdo_completion_priority { | |
| BIO_ACK_Q_ACK_PRIORITY = 0, | |
| BIO_ACK_Q_MAX_PRIORITY = 0, | |
| BIO_Q_COMPRESSED_DATA_PRIORITY = 0, | |
| BIO_Q_DATA_PRIORITY = 0, | |
| BIO_Q_FLUSH_PRIORITY = 2, | |
| BIO_Q_HIGH_PRIORITY = 2, | |
| BIO_Q_METADATA_PRIORITY = 1, | |
| BIO_Q_VERIFY_PRIORITY = 1, | |
| BIO_Q_MAX_PRIORITY = 2, | |
| CPU_Q_COMPLETE_VIO_PRIORITY = 0, | |
| CPU_Q_COMPLETE_READ_PRIORITY = 0, | |
| CPU_Q_COMPRESS_BLOCK_PRIORITY = 0, | |
| CPU_Q_EVENT_REPORTER_PRIORITY = 0, | |
| CPU_Q_HASH_BLOCK_PRIORITY = 0, | |
| CPU_Q_MAX_PRIORITY = 0, | |
| UDS_Q_PRIORITY = 0, | |
| UDS_Q_MAX_PRIORITY = 0, | |
| VDO_DEFAULT_Q_COMPLETION_PRIORITY = 1, | |
| VDO_DEFAULT_Q_FLUSH_PRIORITY = 2, | |
| VDO_DEFAULT_Q_MAP_BIO_PRIORITY = 0, | |
| VDO_DEFAULT_Q_SYNC_PRIORITY = 2, | |
| VDO_DEFAULT_Q_VIO_CALLBACK_PRIORITY = 1, | |
| VDO_DEFAULT_Q_MAX_PRIORITY = 2, | |
| /* The maximum allowable priority */ | |
| VDO_WORK_Q_MAX_PRIORITY = 2, | |
| /* A value which must be out of range for a valid priority */ | |
| VDO_WORK_Q_DEFAULT_PRIORITY = VDO_WORK_Q_MAX_PRIORITY + 1, | |
| }; | |
| struct vdo_completion { | |
| /* The type of completion this is */ | |
| enum vdo_completion_type type; | |
| /* | |
| * <code>true</code> once the processing of the operation is complete. This flag should not | |
| * be used by waiters external to the VDO base as it is used to gate calling the callback. | |
| */ | |
| bool complete; | |
| /* | |
| * If true, queue this completion on the next callback invocation, even if it is already | |
| * running on the correct thread. | |
| */ | |
| bool requeue; | |
| /* The ID of the thread which should run the next callback */ | |
| thread_id_t callback_thread_id; | |
| /* The result of the operation */ | |
| int result; | |
| /* The VDO on which this completion operates */ | |
| struct vdo *vdo; | |
| /* The callback which will be called once the operation is complete */ | |
| vdo_action_fn callback; | |
| /* Callback which, if set, will be called if an error result is set */ | |
| vdo_action_fn error_handler; | |
| /* The parent object, if any, that spawned this completion */ | |
| void *parent; | |
| /* Entry link for lock-free work queue */ | |
| struct funnel_queue_entry work_queue_entry_link; | |
| enum vdo_completion_priority priority; | |
| struct vdo_work_queue *my_queue; | |
| }; | |
| struct block_allocator; | |
| struct data_vio; | |
| struct vdo; | |
| struct vdo_config; | |
| /* vio types for statistics and instrumentation. */ | |
| enum vio_type { | |
| VIO_TYPE_UNINITIALIZED = 0, | |
| VIO_TYPE_DATA, | |
| VIO_TYPE_BLOCK_ALLOCATOR, | |
| VIO_TYPE_BLOCK_MAP, | |
| VIO_TYPE_BLOCK_MAP_INTERIOR, | |
| VIO_TYPE_GEOMETRY, | |
| VIO_TYPE_PARTITION_COPY, | |
| VIO_TYPE_RECOVERY_JOURNAL, | |
| VIO_TYPE_SLAB_JOURNAL, | |
| VIO_TYPE_SLAB_SUMMARY, | |
| VIO_TYPE_SUPER_BLOCK, | |
| } __packed; | |
| /* Priority levels for asynchronous I/O operations performed on a vio. */ | |
| enum vio_priority { | |
| VIO_PRIORITY_LOW = 0, | |
| VIO_PRIORITY_DATA = VIO_PRIORITY_LOW, | |
| VIO_PRIORITY_COMPRESSED_DATA = VIO_PRIORITY_DATA, | |
| VIO_PRIORITY_METADATA, | |
| VIO_PRIORITY_HIGH, | |
| } __packed; | |
| /* | |
| * A wrapper for a bio. All I/O to the storage below a vdo is conducted via vios. | |
| */ | |
| struct vio { | |
| /* The completion for this vio */ | |
| struct vdo_completion completion; | |
| /* The bio zone in which I/O should be processed */ | |
| zone_count_t bio_zone; | |
| /* The queueing priority of the vio operation */ | |
| enum vio_priority priority; | |
| /* The vio type is used for statistics and instrumentation. */ | |
| enum vio_type type; | |
| /* The size of this vio in blocks */ | |
| unsigned int block_count; | |
| /* The data being read or written. */ | |
| char *data; | |
| /* The VDO-owned bio to use for all IO for this vio */ | |
| struct bio *bio; | |
| /* | |
| * A list of enqueued bios with consecutive block numbers, stored by vdo_submit_bio() under | |
| * the first-enqueued vio. The other vios are found via their bio entries in this list, and | |
| * are not added to the work queue as separate completions. | |
| */ | |
| struct bio_list bios_merged; | |
| }; | |
| #endif /* VDO_TYPES_H */ |