145 lines
5.3 KiB
Diff
145 lines
5.3 KiB
Diff
From cce56ebaa6b67d53b0430d5b52b957e194c9527d Mon Sep 17 00:00:00 2001
|
|
From: Zdenek Kabelac <zkabelac@redhat.com>
|
|
Date: Sat, 9 Jul 2022 21:28:40 +0200
|
|
Subject: [PATCH 3/3] vdo: report supported range in error path
|
|
|
|
(cherry picked from commit 9f3eff002cc229d3c22dfd7db6da69dadc0bd460)
|
|
---
|
|
device_mapper/vdo/vdo_target.c | 63 ++++++++++++++++++++++++----------
|
|
1 file changed, 45 insertions(+), 18 deletions(-)
|
|
|
|
diff --git a/device_mapper/vdo/vdo_target.c b/device_mapper/vdo/vdo_target.c
|
|
index 3ebe0592e..ab3fff26a 100644
|
|
--- a/device_mapper/vdo/vdo_target.c
|
|
+++ b/device_mapper/vdo/vdo_target.c
|
|
@@ -27,81 +27,108 @@ bool dm_vdo_validate_target_params(const struct dm_vdo_target_params *vtp,
|
|
/* 512 or 4096 bytes only ATM */
|
|
if ((vtp->minimum_io_size != (512 >> SECTOR_SHIFT)) &&
|
|
(vtp->minimum_io_size != (4096 >> SECTOR_SHIFT))) {
|
|
- log_error("VDO minimum io size %u is unsupported.",
|
|
+ log_error("VDO minimum io size %u is unsupported [512, 4096].",
|
|
vtp->minimum_io_size);
|
|
valid = false;
|
|
}
|
|
|
|
if ((vtp->block_map_cache_size_mb < DM_VDO_BLOCK_MAP_CACHE_SIZE_MINIMUM_MB) ||
|
|
(vtp->block_map_cache_size_mb > DM_VDO_BLOCK_MAP_CACHE_SIZE_MAXIMUM_MB)) {
|
|
- log_error("VDO block map cache size %u out of range.",
|
|
- vtp->block_map_cache_size_mb);
|
|
+ log_error("VDO block map cache size %u MiB is out of range [%u..%u].",
|
|
+ vtp->block_map_cache_size_mb,
|
|
+ DM_VDO_BLOCK_MAP_CACHE_SIZE_MINIMUM_MB,
|
|
+ DM_VDO_BLOCK_MAP_CACHE_SIZE_MAXIMUM_MB);
|
|
valid = false;
|
|
}
|
|
|
|
if ((vtp->block_map_era_length < DM_VDO_BLOCK_MAP_ERA_LENGTH_MINIMUM) ||
|
|
(vtp->block_map_era_length > DM_VDO_BLOCK_MAP_ERA_LENGTH_MAXIMUM)) {
|
|
- log_error("VDO block map era length %u out of range.",
|
|
- vtp->block_map_era_length);
|
|
+ log_error("VDO block map era length %u is out of range [%u..%u].",
|
|
+ vtp->block_map_era_length,
|
|
+ DM_VDO_BLOCK_MAP_ERA_LENGTH_MINIMUM,
|
|
+ DM_VDO_BLOCK_MAP_ERA_LENGTH_MAXIMUM);
|
|
valid = false;
|
|
}
|
|
|
|
if ((vtp->index_memory_size_mb < DM_VDO_INDEX_MEMORY_SIZE_MINIMUM_MB) ||
|
|
(vtp->index_memory_size_mb > DM_VDO_INDEX_MEMORY_SIZE_MAXIMUM_MB)) {
|
|
- log_error("VDO index memory size %u out of range.",
|
|
- vtp->index_memory_size_mb);
|
|
+ log_error("VDO index memory size %u MiB is out of range [%u..%u].",
|
|
+ vtp->index_memory_size_mb,
|
|
+ DM_VDO_INDEX_MEMORY_SIZE_MINIMUM_MB,
|
|
+ DM_VDO_INDEX_MEMORY_SIZE_MAXIMUM_MB);
|
|
valid = false;
|
|
}
|
|
|
|
if ((vtp->slab_size_mb < DM_VDO_SLAB_SIZE_MINIMUM_MB) ||
|
|
(vtp->slab_size_mb > DM_VDO_SLAB_SIZE_MAXIMUM_MB)) {
|
|
- log_error("VDO slab size %u out of range.",
|
|
- vtp->slab_size_mb);
|
|
+ log_error("VDO slab size %u MiB is out of range [%u..%u].",
|
|
+ vtp->slab_size_mb,
|
|
+ DM_VDO_SLAB_SIZE_MINIMUM_MB,
|
|
+ DM_VDO_SLAB_SIZE_MAXIMUM_MB);
|
|
valid = false;
|
|
}
|
|
|
|
if ((vtp->max_discard < DM_VDO_MAX_DISCARD_MINIMUM) ||
|
|
(vtp->max_discard > DM_VDO_MAX_DISCARD_MAXIMUM)) {
|
|
- log_error("VDO max discard %u out of range.",
|
|
- vtp->max_discard);
|
|
+ log_error("VDO max discard %u is out of range [%u..%u].",
|
|
+ vtp->max_discard,
|
|
+ DM_VDO_MAX_DISCARD_MINIMUM,
|
|
+ DM_VDO_MAX_DISCARD_MAXIMUM);
|
|
valid = false;
|
|
}
|
|
|
|
if (vtp->ack_threads > DM_VDO_ACK_THREADS_MAXIMUM) {
|
|
- log_error("VDO ack threads %u out of range.", vtp->ack_threads);
|
|
+ log_error("VDO ack threads %u is out of range [0..%u].",
|
|
+ vtp->ack_threads,
|
|
+ DM_VDO_ACK_THREADS_MAXIMUM);
|
|
valid = false;
|
|
}
|
|
|
|
if ((vtp->bio_threads < DM_VDO_BIO_THREADS_MINIMUM) ||
|
|
(vtp->bio_threads > DM_VDO_BIO_THREADS_MAXIMUM)) {
|
|
- log_error("VDO bio threads %u out of range.", vtp->bio_threads);
|
|
+ log_error("VDO bio threads %u is out of range [%u..%u].",
|
|
+ vtp->bio_threads,
|
|
+ DM_VDO_BIO_THREADS_MINIMUM,
|
|
+ DM_VDO_BIO_THREADS_MAXIMUM);
|
|
valid = false;
|
|
}
|
|
|
|
if ((vtp->bio_rotation < DM_VDO_BIO_ROTATION_MINIMUM) ||
|
|
(vtp->bio_rotation > DM_VDO_BIO_ROTATION_MAXIMUM)) {
|
|
- log_error("VDO bio rotation %u out of range.", vtp->bio_rotation);
|
|
+ log_error("VDO bio rotation %u is out of range [%u..%u].",
|
|
+ vtp->bio_rotation,
|
|
+ DM_VDO_BIO_ROTATION_MINIMUM,
|
|
+ DM_VDO_BIO_ROTATION_MAXIMUM);
|
|
valid = false;
|
|
}
|
|
|
|
if ((vtp->cpu_threads < DM_VDO_CPU_THREADS_MINIMUM) ||
|
|
(vtp->cpu_threads > DM_VDO_CPU_THREADS_MAXIMUM)) {
|
|
- log_error("VDO cpu threads %u out of range.", vtp->cpu_threads);
|
|
+ log_error("VDO cpu threads %u is out of range [%u..%u].",
|
|
+ vtp->cpu_threads,
|
|
+ DM_VDO_CPU_THREADS_MINIMUM,
|
|
+ DM_VDO_CPU_THREADS_MAXIMUM);
|
|
valid = false;
|
|
}
|
|
|
|
if (vtp->hash_zone_threads > DM_VDO_HASH_ZONE_THREADS_MAXIMUM) {
|
|
- log_error("VDO hash zone threads %u out of range.", vtp->hash_zone_threads);
|
|
+ log_error("VDO hash zone threads %u is out of range [0..%u].",
|
|
+ vtp->hash_zone_threads,
|
|
+ DM_VDO_HASH_ZONE_THREADS_MAXIMUM);
|
|
valid = false;
|
|
}
|
|
|
|
if (vtp->logical_threads > DM_VDO_LOGICAL_THREADS_MAXIMUM) {
|
|
- log_error("VDO logical threads %u out of range.", vtp->logical_threads);
|
|
+ log_error("VDO logical threads %u is out of range [0..%u].",
|
|
+ vtp->logical_threads,
|
|
+ DM_VDO_LOGICAL_THREADS_MAXIMUM);
|
|
valid = false;
|
|
}
|
|
|
|
if (vtp->physical_threads > DM_VDO_PHYSICAL_THREADS_MAXIMUM) {
|
|
- log_error("VDO physical threads %u out of range.", vtp->physical_threads);
|
|
+ log_error("VDO physical threads %u is out of range [0..%u].",
|
|
+ vtp->physical_threads,
|
|
+ DM_VDO_PHYSICAL_THREADS_MAXIMUM);
|
|
valid = false;
|
|
}
|
|
|
|
--
|
|
2.38.1
|
|
|