xref: /linux/drivers/md/dm-vdo/types.h (revision 79790b6818e96c58fe2bffee1b418c16e64e7b80)
1 /* SPDX-License-Identifier: GPL-2.0-only */
2 /*
3  * Copyright 2023 Red Hat
4  */
5 
6 #ifndef VDO_TYPES_H
7 #define VDO_TYPES_H
8 
9 #include <linux/bio.h>
10 #include <linux/blkdev.h>
11 #include <linux/device-mapper.h>
12 #include <linux/list.h>
13 #include <linux/compiler_attributes.h>
14 #include <linux/types.h>
15 
16 #include "funnel-queue.h"
17 
18 /* A size type in blocks. */
19 typedef u64 block_count_t;
20 
21 /* The size of a block. */
22 typedef u16 block_size_t;
23 
24 /* A counter for data_vios */
25 typedef u16 data_vio_count_t;
26 
27 /* A height within a tree. */
28 typedef u8 height_t;
29 
30 /* The logical block number as used by the consumer. */
31 typedef u64 logical_block_number_t;
32 
33 /* The type of the nonce used to identify instances of VDO. */
34 typedef u64 nonce_t;
35 
36 /* A size in pages. */
37 typedef u32 page_count_t;
38 
39 /* A page number. */
40 typedef u32 page_number_t;
41 
42 /*
43  * The physical (well, less logical) block number at which the block is found on the underlying
44  * device.
45  */
46 typedef u64 physical_block_number_t;
47 
48 /* A count of tree roots. */
49 typedef u8 root_count_t;
50 
51 /* A number of sectors. */
52 typedef u8 sector_count_t;
53 
54 /* A sequence number. */
55 typedef u64 sequence_number_t;
56 
57 /* The offset of a block within a slab. */
58 typedef u32 slab_block_number;
59 
60 /* A size type in slabs. */
61 typedef u16 slab_count_t;
62 
63 /* A slot in a bin or block map page. */
64 typedef u16 slot_number_t;
65 
66 /* typedef thread_count_t - A thread counter. */
67 typedef u8 thread_count_t;
68 
69 /* typedef thread_id_t - A thread ID, vdo threads are numbered sequentially from 0. */
70 typedef u8 thread_id_t;
71 
72 /* A zone counter */
73 typedef u8 zone_count_t;
74 
75 /* The following enums are persisted on storage, so the values must be preserved. */
76 
77 /* The current operating mode of the VDO. */
78 enum vdo_state {
79 	VDO_DIRTY = 0,
80 	VDO_NEW = 1,
81 	VDO_CLEAN = 2,
82 	VDO_READ_ONLY_MODE = 3,
83 	VDO_FORCE_REBUILD = 4,
84 	VDO_RECOVERING = 5,
85 	VDO_REPLAYING = 6, /* VDO_REPLAYING is never set anymore, but retained for upgrade */
86 	VDO_REBUILD_FOR_UPGRADE = 7,
87 
88 	/* Keep VDO_STATE_COUNT at the bottom. */
89 	VDO_STATE_COUNT
90 };
91 
92 /**
93  * vdo_state_requires_read_only_rebuild() - Check whether a vdo_state indicates
94  * that a read-only rebuild is required.
95  * @state: The vdo_state to check.
96  *
97  * Return: true if the state indicates a rebuild is required
98  */
vdo_state_requires_read_only_rebuild(enum vdo_state state)99 static inline bool __must_check vdo_state_requires_read_only_rebuild(enum vdo_state state)
100 {
101 	return ((state == VDO_FORCE_REBUILD) || (state == VDO_REBUILD_FOR_UPGRADE));
102 }
103 
104 /**
105  * vdo_state_requires_recovery() - Check whether a vdo state indicates that recovery is needed.
106  * @state: The state to check.
107  *
108  * Return: true if the state indicates a recovery is required
109  */
vdo_state_requires_recovery(enum vdo_state state)110 static inline bool __must_check vdo_state_requires_recovery(enum vdo_state state)
111 {
112 	return ((state == VDO_DIRTY) || (state == VDO_REPLAYING) || (state == VDO_RECOVERING));
113 }
114 
115 /*
116  * The current operation on a physical block (from the point of view of the recovery journal, slab
117  * journals, and reference counts.
118  */
119 enum journal_operation {
120 	VDO_JOURNAL_DATA_REMAPPING = 0,
121 	VDO_JOURNAL_BLOCK_MAP_REMAPPING = 1,
122 } __packed;
123 
124 /* Partition IDs encoded in the volume layout in the super block. */
125 enum partition_id {
126 	VDO_BLOCK_MAP_PARTITION = 0,
127 	VDO_SLAB_DEPOT_PARTITION = 1,
128 	VDO_RECOVERY_JOURNAL_PARTITION = 2,
129 	VDO_SLAB_SUMMARY_PARTITION = 3,
130 } __packed;
131 
132 /* Metadata types for the vdo. */
133 enum vdo_metadata_type {
134 	VDO_METADATA_RECOVERY_JOURNAL = 1,
135 	VDO_METADATA_SLAB_JOURNAL = 2,
136 	VDO_METADATA_RECOVERY_JOURNAL_2 = 3,
137 } __packed;
138 
139 /* A position in the block map where a block map entry is stored. */
140 struct block_map_slot {
141 	physical_block_number_t pbn;
142 	slot_number_t slot;
143 };
144 
145 /*
146  * Four bits of each five-byte block map entry contain a mapping state value used to distinguish
147  * unmapped or discarded logical blocks (which are treated as mapped to the zero block) from entries
148  * that have been mapped to a physical block, including the zero block.
149  *
150  * FIXME: these should maybe be defines.
151  */
152 enum block_mapping_state {
153 	VDO_MAPPING_STATE_UNMAPPED = 0, /* Must be zero to be the default value */
154 	VDO_MAPPING_STATE_UNCOMPRESSED = 1, /* A normal (uncompressed) block */
155 	VDO_MAPPING_STATE_COMPRESSED_BASE = 2, /* Compressed in slot 0 */
156 	VDO_MAPPING_STATE_COMPRESSED_MAX = 15, /* Compressed in slot 13 */
157 };
158 
159 enum {
160 	VDO_MAX_COMPRESSION_SLOTS =
161 		(VDO_MAPPING_STATE_COMPRESSED_MAX - VDO_MAPPING_STATE_COMPRESSED_BASE + 1),
162 };
163 
164 
165 struct data_location {
166 	physical_block_number_t pbn;
167 	enum block_mapping_state state;
168 };
169 
170 /* The configuration of a single slab derived from the configured block size and slab size. */
171 struct slab_config {
172 	/* total number of blocks in the slab */
173 	block_count_t slab_blocks;
174 	/* number of blocks available for data */
175 	block_count_t data_blocks;
176 	/* number of blocks for reference counts */
177 	block_count_t reference_count_blocks;
178 	/* number of blocks for the slab journal */
179 	block_count_t slab_journal_blocks;
180 	/*
181 	 * Number of blocks after which the slab journal starts pushing out a reference_block for
182 	 * each new entry it receives.
183 	 */
184 	block_count_t slab_journal_flushing_threshold;
185 	/*
186 	 * Number of blocks after which the slab journal pushes out all reference_blocks and makes
187 	 * all vios wait.
188 	 */
189 	block_count_t slab_journal_blocking_threshold;
190 	/* Number of blocks after which the slab must be scrubbed before coming online. */
191 	block_count_t slab_journal_scrubbing_threshold;
192 } __packed;
193 
194 /*
195  * This structure is memcmp'd for equality. Keep it packed and don't add any fields that are not
196  * properly set in both extant and parsed configs.
197  */
198 struct thread_count_config {
199 	unsigned int bio_ack_threads;
200 	unsigned int bio_threads;
201 	unsigned int bio_rotation_interval;
202 	unsigned int cpu_threads;
203 	unsigned int logical_zones;
204 	unsigned int physical_zones;
205 	unsigned int hash_zones;
206 } __packed;
207 
208 struct device_config {
209 	struct dm_target *owning_target;
210 	struct dm_dev *owned_device;
211 	struct vdo *vdo;
212 	/* All configs referencing a layer are kept on a list in the layer */
213 	struct list_head config_list;
214 	char *original_string;
215 	unsigned int version;
216 	char *parent_device_name;
217 	block_count_t physical_blocks;
218 	/*
219 	 * This is the number of logical blocks from VDO's internal point of view. It is the number
220 	 * of 4K blocks regardless of the value of the logical_block_size parameter below.
221 	 */
222 	block_count_t logical_blocks;
223 	unsigned int logical_block_size;
224 	unsigned int cache_size;
225 	unsigned int block_map_maximum_age;
226 	bool deduplication;
227 	bool compression;
228 	struct thread_count_config thread_counts;
229 	block_count_t max_discard_blocks;
230 };
231 
232 enum vdo_completion_type {
233 	/* Keep VDO_UNSET_COMPLETION_TYPE at the top. */
234 	VDO_UNSET_COMPLETION_TYPE,
235 	VDO_ACTION_COMPLETION,
236 	VDO_ADMIN_COMPLETION,
237 	VDO_BLOCK_ALLOCATOR_COMPLETION,
238 	VDO_DATA_VIO_POOL_COMPLETION,
239 	VDO_DECREMENT_COMPLETION,
240 	VDO_FLUSH_COMPLETION,
241 	VDO_FLUSH_NOTIFICATION_COMPLETION,
242 	VDO_GENERATION_FLUSHED_COMPLETION,
243 	VDO_HASH_ZONE_COMPLETION,
244 	VDO_HASH_ZONES_COMPLETION,
245 	VDO_LOCK_COUNTER_COMPLETION,
246 	VDO_PAGE_COMPLETION,
247 	VDO_READ_ONLY_MODE_COMPLETION,
248 	VDO_REPAIR_COMPLETION,
249 	VDO_SYNC_COMPLETION,
250 	VIO_COMPLETION,
251 } __packed;
252 
253 struct vdo_completion;
254 
255 /**
256  * typedef vdo_action_fn - An asynchronous VDO operation.
257  * @completion: The completion of the operation.
258  */
259 typedef void (*vdo_action_fn)(struct vdo_completion *completion);
260 
261 enum vdo_completion_priority {
262 	BIO_ACK_Q_ACK_PRIORITY = 0,
263 	BIO_ACK_Q_MAX_PRIORITY = 0,
264 	BIO_Q_COMPRESSED_DATA_PRIORITY = 0,
265 	BIO_Q_DATA_PRIORITY = 0,
266 	BIO_Q_FLUSH_PRIORITY = 2,
267 	BIO_Q_HIGH_PRIORITY = 2,
268 	BIO_Q_METADATA_PRIORITY = 1,
269 	BIO_Q_VERIFY_PRIORITY = 1,
270 	BIO_Q_MAX_PRIORITY = 2,
271 	CPU_Q_COMPLETE_VIO_PRIORITY = 0,
272 	CPU_Q_COMPLETE_READ_PRIORITY = 0,
273 	CPU_Q_COMPRESS_BLOCK_PRIORITY = 0,
274 	CPU_Q_EVENT_REPORTER_PRIORITY = 0,
275 	CPU_Q_HASH_BLOCK_PRIORITY = 0,
276 	CPU_Q_MAX_PRIORITY = 0,
277 	UDS_Q_PRIORITY = 0,
278 	UDS_Q_MAX_PRIORITY = 0,
279 	VDO_DEFAULT_Q_COMPLETION_PRIORITY = 1,
280 	VDO_DEFAULT_Q_FLUSH_PRIORITY = 2,
281 	VDO_DEFAULT_Q_MAP_BIO_PRIORITY = 0,
282 	VDO_DEFAULT_Q_SYNC_PRIORITY = 2,
283 	VDO_DEFAULT_Q_VIO_CALLBACK_PRIORITY = 1,
284 	VDO_DEFAULT_Q_MAX_PRIORITY = 2,
285 	/* The maximum allowable priority */
286 	VDO_WORK_Q_MAX_PRIORITY = 2,
287 	/* A value which must be out of range for a valid priority */
288 	VDO_WORK_Q_DEFAULT_PRIORITY = VDO_WORK_Q_MAX_PRIORITY + 1,
289 };
290 
291 struct vdo_completion {
292 	/* The type of completion this is */
293 	enum vdo_completion_type type;
294 
295 	/*
296 	 * <code>true</code> once the processing of the operation is complete. This flag should not
297 	 * be used by waiters external to the VDO base as it is used to gate calling the callback.
298 	 */
299 	bool complete;
300 
301 	/*
302 	 * If true, queue this completion on the next callback invocation, even if it is already
303 	 * running on the correct thread.
304 	 */
305 	bool requeue;
306 
307 	/* The ID of the thread which should run the next callback */
308 	thread_id_t callback_thread_id;
309 
310 	/* The result of the operation */
311 	int result;
312 
313 	/* The VDO on which this completion operates */
314 	struct vdo *vdo;
315 
316 	/* The callback which will be called once the operation is complete */
317 	vdo_action_fn callback;
318 
319 	/* Callback which, if set, will be called if an error result is set */
320 	vdo_action_fn error_handler;
321 
322 	/* The parent object, if any, that spawned this completion */
323 	void *parent;
324 
325 	/* Entry link for lock-free work queue */
326 	struct funnel_queue_entry work_queue_entry_link;
327 	enum vdo_completion_priority priority;
328 	struct vdo_work_queue *my_queue;
329 };
330 
331 struct block_allocator;
332 struct data_vio;
333 struct vdo;
334 struct vdo_config;
335 
336 /* vio types for statistics and instrumentation. */
337 enum vio_type {
338 	VIO_TYPE_UNINITIALIZED = 0,
339 	VIO_TYPE_DATA,
340 	VIO_TYPE_BLOCK_ALLOCATOR,
341 	VIO_TYPE_BLOCK_MAP,
342 	VIO_TYPE_BLOCK_MAP_INTERIOR,
343 	VIO_TYPE_GEOMETRY,
344 	VIO_TYPE_PARTITION_COPY,
345 	VIO_TYPE_RECOVERY_JOURNAL,
346 	VIO_TYPE_SLAB_JOURNAL,
347 	VIO_TYPE_SLAB_SUMMARY,
348 	VIO_TYPE_SUPER_BLOCK,
349 } __packed;
350 
351 /* Priority levels for asynchronous I/O operations performed on a vio. */
352 enum vio_priority {
353 	VIO_PRIORITY_LOW = 0,
354 	VIO_PRIORITY_DATA = VIO_PRIORITY_LOW,
355 	VIO_PRIORITY_COMPRESSED_DATA = VIO_PRIORITY_DATA,
356 	VIO_PRIORITY_METADATA,
357 	VIO_PRIORITY_HIGH,
358 } __packed;
359 
360 /*
361  * A wrapper for a bio. All I/O to the storage below a vdo is conducted via vios.
362  */
363 struct vio {
364 	/* The completion for this vio */
365 	struct vdo_completion completion;
366 
367 	/* The bio zone in which I/O should be processed */
368 	zone_count_t bio_zone;
369 
370 	/* The queueing priority of the vio operation */
371 	enum vio_priority priority;
372 
373 	/* The vio type is used for statistics and instrumentation. */
374 	enum vio_type type;
375 
376 	/* The size of this vio in blocks */
377 	unsigned int block_count;
378 
379 	/* The data being read or written. */
380 	char *data;
381 
382 	/* The VDO-owned bio to use for all IO for this vio */
383 	struct bio *bio;
384 
385 	/*
386 	 * A list of enqueued bios with consecutive block numbers, stored by vdo_submit_bio() under
387 	 * the first-enqueued vio. The other vios are found via their bio entries in this list, and
388 	 * are not added to the work queue as separate completions.
389 	 */
390 	struct bio_list bios_merged;
391 };
392 
393 #endif /* VDO_TYPES_H */
394