summaryrefslogtreecommitdiff
path: root/drivers/md/dm-vdo/indexer
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/md/dm-vdo/indexer')
-rw-r--r--drivers/md/dm-vdo/indexer/chapter-index.c4
-rw-r--r--drivers/md/dm-vdo/indexer/config.c48
-rw-r--r--drivers/md/dm-vdo/indexer/delta-index.c50
-rw-r--r--drivers/md/dm-vdo/indexer/index-layout.c82
-rw-r--r--drivers/md/dm-vdo/indexer/index-page-map.c2
-rw-r--r--drivers/md/dm-vdo/indexer/index-session.c44
-rw-r--r--drivers/md/dm-vdo/indexer/index.c52
-rw-r--r--drivers/md/dm-vdo/indexer/io-factory.c2
-rw-r--r--drivers/md/dm-vdo/indexer/open-chapter.c6
-rw-r--r--drivers/md/dm-vdo/indexer/volume-index.c46
-rw-r--r--drivers/md/dm-vdo/indexer/volume.c64
11 files changed, 200 insertions, 200 deletions
diff --git a/drivers/md/dm-vdo/indexer/chapter-index.c b/drivers/md/dm-vdo/indexer/chapter-index.c
index 47e4ed234242..7e32a25d3f2f 100644
--- a/drivers/md/dm-vdo/indexer/chapter-index.c
+++ b/drivers/md/dm-vdo/indexer/chapter-index.c
@@ -166,7 +166,7 @@ int uds_pack_open_chapter_index_page(struct open_chapter_index *chapter_index,
if (removals == 0) {
uds_get_delta_index_stats(delta_index, &stats);
- uds_log_warning("The chapter index for chapter %llu contains %llu entries with %llu collisions",
+ vdo_log_warning("The chapter index for chapter %llu contains %llu entries with %llu collisions",
(unsigned long long) chapter_number,
(unsigned long long) stats.record_count,
(unsigned long long) stats.collision_count);
@@ -198,7 +198,7 @@ int uds_pack_open_chapter_index_page(struct open_chapter_index *chapter_index,
}
if (removals > 0) {
- uds_log_warning("To avoid chapter index page overflow in chapter %llu, %u entries were removed from the chapter index",
+ vdo_log_warning("To avoid chapter index page overflow in chapter %llu, %u entries were removed from the chapter index",
(unsigned long long) chapter_number, removals);
}
diff --git a/drivers/md/dm-vdo/indexer/config.c b/drivers/md/dm-vdo/indexer/config.c
index 69bf27a9d61b..5532371b952f 100644
--- a/drivers/md/dm-vdo/indexer/config.c
+++ b/drivers/md/dm-vdo/indexer/config.c
@@ -33,54 +33,54 @@ static bool are_matching_configurations(struct uds_configuration *saved_config,
bool result = true;
if (saved_geometry->record_pages_per_chapter != geometry->record_pages_per_chapter) {
- uds_log_error("Record pages per chapter (%u) does not match (%u)",
+ vdo_log_error("Record pages per chapter (%u) does not match (%u)",
saved_geometry->record_pages_per_chapter,
geometry->record_pages_per_chapter);
result = false;
}
if (saved_geometry->chapters_per_volume != geometry->chapters_per_volume) {
- uds_log_error("Chapter count (%u) does not match (%u)",
+ vdo_log_error("Chapter count (%u) does not match (%u)",
saved_geometry->chapters_per_volume,
geometry->chapters_per_volume);
result = false;
}
if (saved_geometry->sparse_chapters_per_volume != geometry->sparse_chapters_per_volume) {
- uds_log_error("Sparse chapter count (%u) does not match (%u)",
+ vdo_log_error("Sparse chapter count (%u) does not match (%u)",
saved_geometry->sparse_chapters_per_volume,
geometry->sparse_chapters_per_volume);
result = false;
}
if (saved_config->cache_chapters != user->cache_chapters) {
- uds_log_error("Cache size (%u) does not match (%u)",
+ vdo_log_error("Cache size (%u) does not match (%u)",
saved_config->cache_chapters, user->cache_chapters);
result = false;
}
if (saved_config->volume_index_mean_delta != user->volume_index_mean_delta) {
- uds_log_error("Volume index mean delta (%u) does not match (%u)",
+ vdo_log_error("Volume index mean delta (%u) does not match (%u)",
saved_config->volume_index_mean_delta,
user->volume_index_mean_delta);
result = false;
}
if (saved_geometry->bytes_per_page != geometry->bytes_per_page) {
- uds_log_error("Bytes per page value (%zu) does not match (%zu)",
+ vdo_log_error("Bytes per page value (%zu) does not match (%zu)",
saved_geometry->bytes_per_page, geometry->bytes_per_page);
result = false;
}
if (saved_config->sparse_sample_rate != user->sparse_sample_rate) {
- uds_log_error("Sparse sample rate (%u) does not match (%u)",
+ vdo_log_error("Sparse sample rate (%u) does not match (%u)",
saved_config->sparse_sample_rate,
user->sparse_sample_rate);
result = false;
}
if (saved_config->nonce != user->nonce) {
- uds_log_error("Nonce (%llu) does not match (%llu)",
+ vdo_log_error("Nonce (%llu) does not match (%llu)",
(unsigned long long) saved_config->nonce,
(unsigned long long) user->nonce);
result = false;
@@ -109,11 +109,11 @@ int uds_validate_config_contents(struct buffered_reader *reader,
result = uds_read_from_buffered_reader(reader, version_buffer,
INDEX_CONFIG_VERSION_LENGTH);
if (result != UDS_SUCCESS)
- return uds_log_error_strerror(result, "cannot read index config version");
+ return vdo_log_error_strerror(result, "cannot read index config version");
if (!is_version(INDEX_CONFIG_VERSION_6_02, version_buffer) &&
!is_version(INDEX_CONFIG_VERSION_8_02, version_buffer)) {
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"unsupported configuration version: '%.*s'",
INDEX_CONFIG_VERSION_LENGTH,
version_buffer);
@@ -121,7 +121,7 @@ int uds_validate_config_contents(struct buffered_reader *reader,
result = uds_read_from_buffered_reader(reader, buffer, sizeof(buffer));
if (result != UDS_SUCCESS)
- return uds_log_error_strerror(result, "cannot read config data");
+ return vdo_log_error_strerror(result, "cannot read config data");
decode_u32_le(buffer, &offset, &geometry.record_pages_per_chapter);
decode_u32_le(buffer, &offset, &geometry.chapters_per_volume);
@@ -149,7 +149,7 @@ int uds_validate_config_contents(struct buffered_reader *reader,
result = uds_read_from_buffered_reader(reader, remapping,
sizeof(remapping));
if (result != UDS_SUCCESS)
- return uds_log_error_strerror(result, "cannot read converted config");
+ return vdo_log_error_strerror(result, "cannot read converted config");
offset = 0;
decode_u64_le(remapping, &offset,
@@ -159,7 +159,7 @@ int uds_validate_config_contents(struct buffered_reader *reader,
}
if (!are_matching_configurations(&config, &geometry, user_config)) {
- uds_log_warning("Supplied configuration does not match save");
+ vdo_log_warning("Supplied configuration does not match save");
return UDS_NO_INDEX;
}
@@ -263,7 +263,7 @@ static int compute_memory_sizes(uds_memory_config_size_t mem_gb, bool sparse,
DEFAULT_CHAPTERS_PER_VOLUME);
*record_pages_per_chapter = DEFAULT_RECORD_PAGES_PER_CHAPTER;
} else {
- uds_log_error("received invalid memory size");
+ vdo_log_error("received invalid memory size");
return -EINVAL;
}
@@ -292,7 +292,7 @@ static unsigned int __must_check normalize_zone_count(unsigned int requested)
if (zone_count > MAX_ZONES)
zone_count = MAX_ZONES;
- uds_log_info("Using %u indexing zone%s for concurrency.",
+ vdo_log_info("Using %u indexing zone%s for concurrency.",
zone_count, zone_count == 1 ? "" : "s");
return zone_count;
}
@@ -364,13 +364,13 @@ void uds_log_configuration(struct uds_configuration *config)
{
struct index_geometry *geometry = config->geometry;
- uds_log_debug("Configuration:");
- uds_log_debug(" Record pages per chapter: %10u", geometry->record_pages_per_chapter);
- uds_log_debug(" Chapters per volume: %10u", geometry->chapters_per_volume);
- uds_log_debug(" Sparse chapters per volume: %10u", geometry->sparse_chapters_per_volume);
- uds_log_debug(" Cache size (chapters): %10u", config->cache_chapters);
- uds_log_debug(" Volume index mean delta: %10u", config->volume_index_mean_delta);
- uds_log_debug(" Bytes per page: %10zu", geometry->bytes_per_page);
- uds_log_debug(" Sparse sample rate: %10u", config->sparse_sample_rate);
- uds_log_debug(" Nonce: %llu", (unsigned long long) config->nonce);
+ vdo_log_debug("Configuration:");
+ vdo_log_debug(" Record pages per chapter: %10u", geometry->record_pages_per_chapter);
+ vdo_log_debug(" Chapters per volume: %10u", geometry->chapters_per_volume);
+ vdo_log_debug(" Sparse chapters per volume: %10u", geometry->sparse_chapters_per_volume);
+ vdo_log_debug(" Cache size (chapters): %10u", config->cache_chapters);
+ vdo_log_debug(" Volume index mean delta: %10u", config->volume_index_mean_delta);
+ vdo_log_debug(" Bytes per page: %10zu", geometry->bytes_per_page);
+ vdo_log_debug(" Sparse sample rate: %10u", config->sparse_sample_rate);
+ vdo_log_debug(" Nonce: %llu", (unsigned long long) config->nonce);
}
diff --git a/drivers/md/dm-vdo/indexer/delta-index.c b/drivers/md/dm-vdo/indexer/delta-index.c
index b49066554248..0ac2443f0df3 100644
--- a/drivers/md/dm-vdo/indexer/delta-index.c
+++ b/drivers/md/dm-vdo/indexer/delta-index.c
@@ -375,7 +375,7 @@ int uds_initialize_delta_index(struct delta_index *delta_index, unsigned int zon
*/
if (delta_index->list_count <= first_list_in_zone) {
uds_uninitialize_delta_index(delta_index);
- return uds_log_error_strerror(UDS_INVALID_ARGUMENT,
+ return vdo_log_error_strerror(UDS_INVALID_ARGUMENT,
"%u delta lists not enough for %u zones",
list_count, zone_count);
}
@@ -732,7 +732,7 @@ int uds_pack_delta_index_page(const struct delta_index *delta_index, u64 header_
free_bits -= GUARD_BITS;
if (free_bits < IMMUTABLE_HEADER_SIZE) {
/* This page is too small to store any delta lists. */
- return uds_log_error_strerror(UDS_OVERFLOW,
+ return vdo_log_error_strerror(UDS_OVERFLOW,
"Chapter Index Page of %zu bytes is too small",
memory_size);
}
@@ -843,7 +843,7 @@ int uds_start_restoring_delta_index(struct delta_index *delta_index,
result = uds_read_from_buffered_reader(buffered_readers[z], buffer,
sizeof(buffer));
if (result != UDS_SUCCESS) {
- return uds_log_warning_strerror(result,
+ return vdo_log_warning_strerror(result,
"failed to read delta index header");
}
@@ -860,23 +860,23 @@ int uds_start_restoring_delta_index(struct delta_index *delta_index,
"%zu bytes decoded of %zu expected", offset,
sizeof(struct delta_index_header));
if (result != VDO_SUCCESS) {
- return uds_log_warning_strerror(result,
+ return vdo_log_warning_strerror(result,
"failed to read delta index header");
}
if (memcmp(header.magic, DELTA_INDEX_MAGIC, MAGIC_SIZE) != 0) {
- return uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"delta index file has bad magic number");
}
if (zone_count != header.zone_count) {
- return uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"delta index files contain mismatched zone counts (%u,%u)",
zone_count, header.zone_count);
}
if (header.zone_number != z) {
- return uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"delta index zone %u found in slot %u",
header.zone_number, z);
}
@@ -887,7 +887,7 @@ int uds_start_restoring_delta_index(struct delta_index *delta_index,
collision_count += header.collision_count;
if (first_list[z] != list_next) {
- return uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"delta index file for zone %u starts with list %u instead of list %u",
z, first_list[z], list_next);
}
@@ -896,13 +896,13 @@ int uds_start_restoring_delta_index(struct delta_index *delta_index,
}
if (list_next != delta_index->list_count) {
- return uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"delta index files contain %u delta lists instead of %u delta lists",
list_next, delta_index->list_count);
}
if (collision_count > record_count) {
- return uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"delta index files contain %llu collisions and %llu records",
(unsigned long long) collision_count,
(unsigned long long) record_count);
@@ -927,7 +927,7 @@ int uds_start_restoring_delta_index(struct delta_index *delta_index,
size_data,
sizeof(size_data));
if (result != UDS_SUCCESS) {
- return uds_log_warning_strerror(result,
+ return vdo_log_warning_strerror(result,
"failed to read delta index size");
}
@@ -960,7 +960,7 @@ static int restore_delta_list_to_zone(struct delta_zone *delta_zone,
u32 list_number = save_info->index - delta_zone->first_list;
if (list_number >= delta_zone->list_count) {
- return uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"invalid delta list number %u not in range [%u,%u)",
save_info->index, delta_zone->first_list,
delta_zone->first_list + delta_zone->list_count);
@@ -968,7 +968,7 @@ static int restore_delta_list_to_zone(struct delta_zone *delta_zone,
delta_list = &delta_zone->delta_lists[list_number + 1];
if (delta_list->size == 0) {
- return uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"unexpected delta list number %u",
save_info->index);
}
@@ -976,7 +976,7 @@ static int restore_delta_list_to_zone(struct delta_zone *delta_zone,
bit_count = delta_list->size + save_info->bit_offset;
byte_count = BITS_TO_BYTES(bit_count);
if (save_info->byte_count != byte_count) {
- return uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"unexpected delta list size %u != %u",
save_info->byte_count, byte_count);
}
@@ -996,7 +996,7 @@ static int restore_delta_list_data(struct delta_index *delta_index, unsigned int
result = uds_read_from_buffered_reader(buffered_reader, buffer, sizeof(buffer));
if (result != UDS_SUCCESS) {
- return uds_log_warning_strerror(result,
+ return vdo_log_warning_strerror(result,
"failed to read delta list data");
}
@@ -1009,7 +1009,7 @@ static int restore_delta_list_data(struct delta_index *delta_index, unsigned int
if ((save_info.bit_offset >= BITS_PER_BYTE) ||
(save_info.byte_count > DELTA_LIST_MAX_BYTE_COUNT)) {
- return uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"corrupt delta list data");
}
@@ -1018,7 +1018,7 @@ static int restore_delta_list_data(struct delta_index *delta_index, unsigned int
return UDS_CORRUPT_DATA;
if (save_info.index >= delta_index->list_count) {
- return uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"invalid delta list number %u of %u",
save_info.index,
delta_index->list_count);
@@ -1027,7 +1027,7 @@ static int restore_delta_list_data(struct delta_index *delta_index, unsigned int
result = uds_read_from_buffered_reader(buffered_reader, data,
save_info.byte_count);
if (result != UDS_SUCCESS) {
- return uds_log_warning_strerror(result,
+ return vdo_log_warning_strerror(result,
"failed to read delta list data");
}
@@ -1102,7 +1102,7 @@ static int flush_delta_list(struct delta_zone *zone, u32 flush_index)
result = uds_write_to_buffered_writer(zone->buffered_writer, buffer,
sizeof(buffer));
if (result != UDS_SUCCESS) {
- uds_log_warning_strerror(result, "failed to write delta list memory");
+ vdo_log_warning_strerror(result, "failed to write delta list memory");
return result;
}
@@ -1110,7 +1110,7 @@ static int flush_delta_list(struct delta_zone *zone, u32 flush_index)
zone->memory + get_delta_list_byte_start(delta_list),
get_delta_list_byte_size(delta_list));
if (result != UDS_SUCCESS)
- uds_log_warning_strerror(result, "failed to write delta list memory");
+ vdo_log_warning_strerror(result, "failed to write delta list memory");
return result;
}
@@ -1144,7 +1144,7 @@ int uds_start_saving_delta_index(const struct delta_index *delta_index,
result = uds_write_to_buffered_writer(buffered_writer, buffer, offset);
if (result != UDS_SUCCESS)
- return uds_log_warning_strerror(result,
+ return vdo_log_warning_strerror(result,
"failed to write delta index header");
for (i = 0; i < delta_zone->list_count; i++) {
@@ -1156,7 +1156,7 @@ int uds_start_saving_delta_index(const struct delta_index *delta_index,
result = uds_write_to_buffered_writer(buffered_writer, data,
sizeof(data));
if (result != UDS_SUCCESS)
- return uds_log_warning_strerror(result,
+ return vdo_log_warning_strerror(result,
"failed to write delta list size");
}
@@ -1197,7 +1197,7 @@ int uds_write_guard_delta_list(struct buffered_writer *buffered_writer)
result = uds_write_to_buffered_writer(buffered_writer, buffer, sizeof(buffer));
if (result != UDS_SUCCESS)
- uds_log_warning_strerror(result, "failed to write guard delta list");
+ vdo_log_warning_strerror(result, "failed to write guard delta list");
return UDS_SUCCESS;
}
@@ -1378,7 +1378,7 @@ noinline int uds_next_delta_index_entry(struct delta_index_entry *delta_entry)
* This is not an assertion because uds_validate_chapter_index_page() wants to
* handle this error.
*/
- uds_log_warning("Decoded past the end of the delta list");
+ vdo_log_warning("Decoded past the end of the delta list");
return UDS_CORRUPT_DATA;
}
@@ -1959,7 +1959,7 @@ u32 uds_get_delta_index_page_count(u32 entry_count, u32 list_count, u32 mean_del
void uds_log_delta_index_entry(struct delta_index_entry *delta_entry)
{
- uds_log_ratelimit(uds_log_info,
+ vdo_log_ratelimit(vdo_log_info,
"List 0x%X Key 0x%X Offset 0x%X%s%s List_size 0x%X%s",
delta_entry->list_number, delta_entry->key,
delta_entry->offset, delta_entry->at_end ? " end" : "",
diff --git a/drivers/md/dm-vdo/indexer/index-layout.c b/drivers/md/dm-vdo/indexer/index-layout.c
index 74fd44c20e5c..627adc24af3b 100644
--- a/drivers/md/dm-vdo/indexer/index-layout.c
+++ b/drivers/md/dm-vdo/indexer/index-layout.c
@@ -231,7 +231,7 @@ static int __must_check compute_sizes(const struct uds_configuration *config,
result = uds_compute_volume_index_save_blocks(config, sls->block_size,
&sls->volume_index_blocks);
if (result != UDS_SUCCESS)
- return uds_log_error_strerror(result, "cannot compute index save size");
+ return vdo_log_error_strerror(result, "cannot compute index save size");
sls->page_map_blocks =
DIV_ROUND_UP(uds_compute_index_page_map_save_size(geometry),
@@ -255,13 +255,13 @@ int uds_compute_index_size(const struct uds_parameters *parameters, u64 *index_s
struct save_layout_sizes sizes;
if (index_size == NULL) {
- uds_log_error("Missing output size pointer");
+ vdo_log_error("Missing output size pointer");
return -EINVAL;
}
result = uds_make_configuration(parameters, &index_config);
if (result != UDS_SUCCESS) {
- uds_log_error_strerror(result, "cannot compute index size");
+ vdo_log_error_strerror(result, "cannot compute index size");
return uds_status_to_errno(result);
}
@@ -648,7 +648,7 @@ static int discard_index_state_data(struct index_layout *layout)
}
if (saved_result != UDS_SUCCESS) {
- return uds_log_error_strerror(result,
+ return vdo_log_error_strerror(result,
"%s: cannot destroy all index saves",
__func__);
}
@@ -755,18 +755,18 @@ static int __must_check write_uds_index_config(struct index_layout *layout,
result = open_layout_writer(layout, &layout->config, offset, &writer);
if (result != UDS_SUCCESS)
- return uds_log_error_strerror(result, "failed to open config region");
+ return vdo_log_error_strerror(result, "failed to open config region");
result = uds_write_config_contents(writer, config, layout->super.version);
if (result != UDS_SUCCESS) {
uds_free_buffered_writer(writer);
- return uds_log_error_strerror(result, "failed to write config region");
+ return vdo_log_error_strerror(result, "failed to write config region");
}
result = uds_flush_buffered_writer(writer);
if (result != UDS_SUCCESS) {
uds_free_buffered_writer(writer);
- return uds_log_error_strerror(result, "cannot flush config writer");
+ return vdo_log_error_strerror(result, "cannot flush config writer");
}
uds_free_buffered_writer(writer);
@@ -873,7 +873,7 @@ static int find_latest_uds_index_save_slot(struct index_layout *layout,
}
if (latest == NULL) {
- uds_log_error("No valid index save found");
+ vdo_log_error("No valid index save found");
return UDS_INDEX_NOT_SAVED_CLEANLY;
}
@@ -1145,7 +1145,7 @@ static int __must_check load_region_table(struct buffered_reader *reader,
result = uds_read_from_buffered_reader(reader, buffer, sizeof(buffer));
if (result != UDS_SUCCESS)
- return uds_log_error_strerror(result, "cannot read region table header");
+ return vdo_log_error_strerror(result, "cannot read region table header");
decode_u64_le(buffer, &offset, &header.magic);
decode_u64_le(buffer, &offset, &header.region_blocks);
@@ -1158,7 +1158,7 @@ static int __must_check load_region_table(struct buffered_reader *reader,
return UDS_NO_INDEX;
if (header.version != 1) {
- return uds_log_error_strerror(UDS_UNSUPPORTED_VERSION,
+ return vdo_log_error_strerror(UDS_UNSUPPORTED_VERSION,
"unknown region table version %hu",
header.version);
}
@@ -1178,7 +1178,7 @@ static int __must_check load_region_table(struct buffered_reader *reader,
sizeof(region_buffer));
if (result != UDS_SUCCESS) {
vdo_free(table);
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"cannot read region table layouts");
}
@@ -1209,7 +1209,7 @@ static int __must_check read_super_block_data(struct buffered_reader *reader,
result = uds_read_from_buffered_reader(reader, buffer, saved_size);
if (result != UDS_SUCCESS) {
vdo_free(buffer);
- return uds_log_error_strerror(result, "cannot read region table header");
+ return vdo_log_error_strerror(result, "cannot read region table header");
}
memcpy(&super->magic_label, buffer, MAGIC_SIZE);
@@ -1236,19 +1236,19 @@ static int __must_check read_super_block_data(struct buffered_reader *reader,
vdo_free(buffer);
if (memcmp(super->magic_label, LAYOUT_MAGIC, MAGIC_SIZE) != 0)
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"unknown superblock magic label");
if ((super->version < SUPER_VERSION_MINIMUM) ||
(super->version == 4) || (super->version == 5) || (super->version == 6) ||
(super->version > SUPER_VERSION_MAXIMUM)) {
- return uds_log_error_strerror(UDS_UNSUPPORTED_VERSION,
+ return vdo_log_error_strerror(UDS_UNSUPPORTED_VERSION,
"unknown superblock version number %u",
super->version);
}
if (super->volume_offset < super->start_offset) {
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"inconsistent offsets (start %llu, volume %llu)",
(unsigned long long) super->start_offset,
(unsigned long long) super->volume_offset);
@@ -1256,13 +1256,13 @@ static int __must_check read_super_block_data(struct buffered_reader *reader,
/* Sub-indexes are no longer used but the layout retains this field. */
if (super->index_count != 1) {
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"invalid subindex count %u",
super->index_count);
}
if (generate_primary_nonce(super->nonce_info, sizeof(super->nonce_info)) != super->nonce) {
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"inconsistent superblock nonce");
}
@@ -1273,15 +1273,15 @@ static int __must_check verify_region(struct layout_region *lr, u64 start_block,
enum region_kind kind, unsigned int instance)
{
if (lr->start_block != start_block)
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"incorrect layout region offset");
if (lr->kind != kind)
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"incorrect layout region kind");
if (lr->instance != instance) {
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"incorrect layout region instance");
}
@@ -1323,7 +1323,7 @@ static int __must_check verify_sub_index(struct index_layout *layout, u64 start_
next_block -= layout->super.volume_offset;
if (next_block != start_block + sil->sub_index.block_count) {
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"sub index region does not span all saves");
}
@@ -1368,7 +1368,7 @@ static int __must_check reconstitute_layout(struct index_layout *layout,
return result;
if (++next_block != (first_block + layout->total_blocks)) {
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"layout table does not span total blocks");
}
@@ -1388,19 +1388,19 @@ static int __must_check load_super_block(struct index_layout *layout, size_t blo
if (table->header.type != RH_TYPE_SUPER) {
vdo_free(table);
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"not a superblock region table");
}
result = read_super_block_data(reader, layout, table->header.payload);
if (result != UDS_SUCCESS) {
vdo_free(table);
- return uds_log_error_strerror(result, "unknown superblock format");
+ return vdo_log_error_strerror(result, "unknown superblock format");
}
if (super->block_size != block_size) {
vdo_free(table);
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"superblock saved block_size %u differs from supplied block_size %zu",
super->block_size, block_size);
}
@@ -1421,14 +1421,14 @@ static int __must_check read_index_save_data(struct buffered_reader *reader,
size_t offset = 0;
if (saved_size != sizeof(buffer)) {
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"unexpected index save data size %zu",
saved_size);
}
result = uds_read_from_buffered_reader(reader, buffer, sizeof(buffer));
if (result != UDS_SUCCESS)
- return uds_log_error_strerror(result, "cannot read index save data");
+ return vdo_log_error_strerror(result, "cannot read index save data");
decode_u64_le(buffer, &offset, &isl->save_data.timestamp);
decode_u64_le(buffer, &offset, &isl->save_data.nonce);
@@ -1436,7 +1436,7 @@ static int __must_check read_index_save_data(struct buffered_reader *reader,
offset += sizeof(u32);
if (isl->save_data.version > 1) {
- return uds_log_error_strerror(UDS_UNSUPPORTED_VERSION,
+ return vdo_log_error_strerror(UDS_UNSUPPORTED_VERSION,
"unknown index save version number %u",
isl->save_data.version);
}
@@ -1446,7 +1446,7 @@ static int __must_check read_index_save_data(struct buffered_reader *reader,
if ((file_version.signature != INDEX_STATE_VERSION_301.signature) ||
(file_version.version_id != INDEX_STATE_VERSION_301.version_id)) {
- return uds_log_error_strerror(UDS_UNSUPPORTED_VERSION,
+ return vdo_log_error_strerror(UDS_UNSUPPORTED_VERSION,
"index state version %d,%d is unsupported",
file_version.signature,
file_version.version_id);
@@ -1523,7 +1523,7 @@ static int __must_check reconstruct_index_save(struct index_save_layout *isl,
next_block += isl->free_space.block_count;
if (next_block != last_block) {
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"index save layout table incomplete");
}
@@ -1539,7 +1539,7 @@ static int __must_check load_index_save(struct index_save_layout *isl,
result = load_region_table(reader, &table);
if (result != UDS_SUCCESS) {
- return uds_log_error_strerror(result, "cannot read index save %u header",
+ return vdo_log_error_strerror(result, "cannot read index save %u header",
instance);
}
@@ -1547,7 +1547,7 @@ static int __must_check load_index_save(struct index_save_layout *isl,
u64 region_blocks = table->header.region_blocks;
vdo_free(table);
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"unexpected index save %u region block count %llu",
instance,
(unsigned long long) region_blocks);
@@ -1561,7 +1561,7 @@ static int __must_check load_index_save(struct index_save_layout *isl,
if (table->header.type != RH_TYPE_SAVE) {
- uds_log_error_strerror(UDS_CORRUPT_DATA,
+ vdo_log_error_strerror(UDS_CORRUPT_DATA,
"unexpected index save %u header type %u",
instance, table->header.type);
vdo_free(table);
@@ -1571,7 +1571,7 @@ static int __must_check load_index_save(struct index_save_layout *isl,
result = read_index_save_data(reader, isl, table->header.payload);
if (result != UDS_SUCCESS) {
vdo_free(table);
- return uds_log_error_strerror(result,
+ return vdo_log_error_strerror(result,
"unknown index save %u data format",
instance);
}
@@ -1579,7 +1579,7 @@ static int __must_check load_index_save(struct index_save_layout *isl,
result = reconstruct_index_save(isl, table);
vdo_free(table);
if (result != UDS_SUCCESS) {
- return uds_log_error_strerror(result, "cannot reconstruct index save %u",
+ return vdo_log_error_strerror(result, "cannot reconstruct index save %u",
instance);
}
@@ -1598,7 +1598,7 @@ static int __must_check load_sub_index_regions(struct index_layout *layout)
result = open_region_reader(layout, &isl->index_save, &reader);
if (result != UDS_SUCCESS) {
- uds_log_error_strerror(result,
+ vdo_log_error_strerror(result,
"cannot get reader for index 0 save %u",
j);
return result;
@@ -1626,12 +1626,12 @@ static int __must_check verify_uds_index_config(struct index_layout *layout,
offset = layout->super.volume_offset - layout->super.start_offset;
result = open_layout_reader(layout, &layout->config, offset, &reader);
if (result != UDS_SUCCESS)
- return uds_log_error_strerror(result, "failed to open config reader");
+ return vdo_log_error_strerror(result, "failed to open config reader");
result = uds_validate_config_contents(reader, config);
if (result != UDS_SUCCESS) {
uds_free_buffered_reader(reader);
- return uds_log_error_strerror(result, "failed to read config region");
+ return vdo_log_error_strerror(result, "failed to read config region");
}
uds_free_buffered_reader(reader);
@@ -1646,7 +1646,7 @@ static int load_index_layout(struct index_layout *layout, struct uds_configurati
result = uds_make_buffered_reader(layout->factory,
layout->offset / UDS_BLOCK_SIZE, 1, &reader);
if (result != UDS_SUCCESS)
- return uds_log_error_strerror(result, "unable to read superblock");
+ return vdo_log_error_strerror(result, "unable to read superblock");
result = load_super_block(layout, UDS_BLOCK_SIZE,
layout->offset / UDS_BLOCK_SIZE, reader);
@@ -1675,7 +1675,7 @@ static int create_layout_factory(struct index_layout *layout,
writable_size = uds_get_writable_size(factory) & -UDS_BLOCK_SIZE;
if (writable_size < config->size + config->offset) {
uds_put_io_factory(factory);
- uds_log_error("index storage (%zu) is smaller than the requested size %zu",
+ vdo_log_error("index storage (%zu) is smaller than the requested size %zu",
writable_size, config->size + config->offset);
return -ENOSPC;
}
@@ -1708,7 +1708,7 @@ int uds_make_index_layout(struct uds_configuration *config, bool new_layout,
}
if (layout->factory_size < sizes.total_size) {
- uds_log_error("index storage (%zu) is smaller than the required size %llu",
+ vdo_log_error("index storage (%zu) is smaller than the required size %llu",
layout->factory_size,
(unsigned long long) sizes.total_size);
uds_free_index_layout(layout);
diff --git a/drivers/md/dm-vdo/indexer/index-page-map.c b/drivers/md/dm-vdo/indexer/index-page-map.c
index c5d1b9995846..00b44e07d0c1 100644
--- a/drivers/md/dm-vdo/indexer/index-page-map.c
+++ b/drivers/md/dm-vdo/indexer/index-page-map.c
@@ -167,7 +167,7 @@ int uds_read_index_page_map(struct index_page_map *map, struct buffered_reader *
decode_u16_le(buffer, &offset, &map->entries[i]);
vdo_free(buffer);
- uds_log_debug("read index page map, last update %llu",
+ vdo_log_debug("read index page map, last update %llu",
(unsigned long long) map->last_update);
return UDS_SUCCESS;
}
diff --git a/drivers/md/dm-vdo/indexer/index-session.c b/drivers/md/dm-vdo/indexer/index-session.c
index 9eae00548095..aee0914d604a 100644
--- a/drivers/md/dm-vdo/indexer/index-session.c
+++ b/drivers/md/dm-vdo/indexer/index-session.c
@@ -104,7 +104,7 @@ int uds_launch_request(struct uds_request *request)
int result;
if (request->callback == NULL) {
- uds_log_error("missing required callback");
+ vdo_log_error("missing required callback");
return -EINVAL;
}
@@ -116,7 +116,7 @@ int uds_launch_request(struct uds_request *request)
case UDS_UPDATE:
break;
default:
- uds_log_error("received invalid callback type");
+ vdo_log_error("received invalid callback type");
return -EINVAL;
}
@@ -244,7 +244,7 @@ static int __must_check make_empty_index_session(struct uds_index_session **inde
int uds_create_index_session(struct uds_index_session **session)
{
if (session == NULL) {
- uds_log_error("missing session pointer");
+ vdo_log_error("missing session pointer");
return -EINVAL;
}
@@ -257,10 +257,10 @@ static int __must_check start_loading_index_session(struct uds_index_session *in
mutex_lock(&index_session->request_mutex);
if (index_session->state & IS_FLAG_SUSPENDED) {
- uds_log_info("Index session is suspended");
+ vdo_log_info("Index session is suspended");
result = -EBUSY;
} else if (index_session->state != 0) {
- uds_log_info("Index is already loaded");
+ vdo_log_info("Index is already loaded");
result = -EBUSY;
} else {
index_session->state |= IS_FLAG_LOADING;
@@ -290,7 +290,7 @@ static int initialize_index_session(struct uds_index_session *index_session,
result = uds_make_configuration(&index_session->parameters, &config);
if (result != UDS_SUCCESS) {
- uds_log_error_strerror(result, "Failed to allocate config");
+ vdo_log_error_strerror(result, "Failed to allocate config");
return result;
}
@@ -298,7 +298,7 @@ static int initialize_index_session(struct uds_index_session *index_session,
result = uds_make_index(config, open_type, &index_session->load_context,
enter_callback_stage, &index_session->index);
if (result != UDS_SUCCESS)
- uds_log_error_strerror(result, "Failed to make index");
+ vdo_log_error_strerror(result, "Failed to make index");
else
uds_log_configuration(config);
@@ -332,15 +332,15 @@ int uds_open_index(enum uds_open_index_type open_type,
char name[BDEVNAME_SIZE];
if (parameters == NULL) {
- uds_log_error("missing required parameters");
+ vdo_log_error("missing required parameters");
return -EINVAL;
}
if (parameters->bdev == NULL) {
- uds_log_error("missing required block device");
+ vdo_log_error("missing required block device");
return -EINVAL;
}
if (session == NULL) {
- uds_log_error("missing required session pointer");
+ vdo_log_error("missing required session pointer");
return -EINVAL;
}
@@ -350,11 +350,11 @@ int uds_open_index(enum uds_open_index_type open_type,
session->parameters = *parameters;
format_dev_t(name, parameters->bdev->bd_dev);
- uds_log_info("%s: %s", get_open_type_string(open_type), name);
+ vdo_log_info("%s: %s", get_open_type_string(open_type), name);
result = initialize_index_session(session, open_type);
if (result != UDS_SUCCESS)
- uds_log_error_strerror(result, "Failed %s",
+ vdo_log_error_strerror(result, "Failed %s",
get_open_type_string(open_type));
finish_loading_index_session(session, result);
@@ -426,7 +426,7 @@ int uds_suspend_index_session(struct uds_index_session *session, bool save)
if ((session->state & IS_FLAG_WAITING) || (session->state & IS_FLAG_DESTROYING)) {
no_work = true;
- uds_log_info("Index session is already changing state");
+ vdo_log_info("Index session is already changing state");
result = -EBUSY;
} else if (session->state & IS_FLAG_SUSPENDED) {
no_work = true;
@@ -485,7 +485,7 @@ int uds_resume_index_session(struct uds_index_session *session,
mutex_lock(&session->request_mutex);
if (session->state & IS_FLAG_WAITING) {
- uds_log_info("Index session is already changing state");
+ vdo_log_info("Index session is already changing state");
no_work = true;
result = -EBUSY;
} else if (!(session->state & IS_FLAG_SUSPENDED)) {
@@ -562,7 +562,7 @@ static int save_and_free_index(struct uds_index_session *index_session)
if (!suspended) {
result = uds_save_index(index);
if (result != UDS_SUCCESS)
- uds_log_warning_strerror(result,
+ vdo_log_warning_strerror(result,
"ignoring error from save_index");
}
uds_free_index(index);
@@ -598,7 +598,7 @@ int uds_close_index(struct uds_index_session *index_session)
}
if (index_session->state & IS_FLAG_SUSPENDED) {
- uds_log_info("Index session is suspended");
+ vdo_log_info("Index session is suspended");
result = -EBUSY;
} else if ((index_session->state & IS_FLAG_DESTROYING) ||
!(index_session->state & IS_FLAG_LOADED)) {
@@ -611,10 +611,10 @@ int uds_close_index(struct uds_index_session *index_session)
if (result != UDS_SUCCESS)
return uds_status_to_errno(result);
- uds_log_debug("Closing index");
+ vdo_log_debug("Closing index");
wait_for_no_requests_in_progress(index_session);
result = save_and_free_index(index_session);
- uds_log_debug("Closed index");
+ vdo_log_debug("Closed index");
mutex_lock(&index_session->request_mutex);
index_session->state &= ~IS_FLAG_CLOSING;
@@ -629,7 +629,7 @@ int uds_destroy_index_session(struct uds_index_session *index_session)
int result;
bool load_pending = false;
- uds_log_debug("Destroying index session");
+ vdo_log_debug("Destroying index session");
/* Wait for any current index state change to complete. */
mutex_lock(&index_session->request_mutex);
@@ -641,7 +641,7 @@ int uds_destroy_index_session(struct uds_index_session *index_session)
if (index_session->state & IS_FLAG_DESTROYING) {
mutex_unlock(&index_session->request_mutex);
- uds_log_info("Index session is already closing");
+ vdo_log_info("Index session is already closing");
return -EBUSY;
}
@@ -672,7 +672,7 @@ int uds_destroy_index_session(struct uds_index_session *index_session)
result = save_and_free_index(index_session);
uds_request_queue_finish(index_session->callback_queue);
index_session->callback_queue = NULL;
- uds_log_debug("Destroyed index session");
+ vdo_log_debug("Destroyed index session");
vdo_free(index_session);
return uds_status_to_errno(result);
}
@@ -710,7 +710,7 @@ int uds_get_index_session_stats(struct uds_index_session *index_session,
struct uds_index_stats *stats)
{
if (stats == NULL) {
- uds_log_error("received a NULL index stats pointer");
+ vdo_log_error("received a NULL index stats pointer");
return -EINVAL;
}
diff --git a/drivers/md/dm-vdo/indexer/index.c b/drivers/md/dm-vdo/indexer/index.c
index 221af95ca2a4..1ba767144426 100644
--- a/drivers/md/dm-vdo/indexer/index.c
+++ b/drivers/md/dm-vdo/indexer/index.c
@@ -188,7 +188,7 @@ static int finish_previous_chapter(struct uds_index *index, u64 current_chapter_
mutex_unlock(&writer->mutex);
if (result != UDS_SUCCESS)
- return uds_log_error_strerror(result,
+ return vdo_log_error_strerror(result,
"Writing of previous open chapter failed");
return UDS_SUCCESS;
@@ -258,7 +258,7 @@ static int open_next_chapter(struct index_zone *zone)
unsigned int finished_zones;
u32 expire_chapters;
- uds_log_debug("closing chapter %llu of zone %u after %u entries (%u short)",
+ vdo_log_debug("closing chapter %llu of zone %u after %u entries (%u short)",
(unsigned long long) zone->newest_virtual_chapter, zone->id,
zone->open_chapter->size,
zone->open_chapter->capacity - zone->open_chapter->size);
@@ -315,7 +315,7 @@ static int dispatch_index_zone_control_request(struct uds_request *request)
return handle_chapter_closed(zone, message->virtual_chapter);
default:
- uds_log_error("invalid message type: %d", message->type);
+ vdo_log_error("invalid message type: %d", message->type);
return UDS_INVALID_ARGUMENT;
}
}
@@ -600,7 +600,7 @@ static int dispatch_index_request(struct uds_index *index, struct uds_request *r
break;
default:
- result = uds_log_warning_strerror(UDS_INVALID_ARGUMENT,
+ result = vdo_log_warning_strerror(UDS_INVALID_ARGUMENT,
"invalid request type: %d",
request->type);
break;
@@ -618,7 +618,7 @@ static void execute_zone_request(struct uds_request *request)
if (request->zone_message.type != UDS_MESSAGE_NONE) {
result = dispatch_index_zone_control_request(request);
if (result != UDS_SUCCESS) {
- uds_log_error_strerror(result, "error executing message: %d",
+ vdo_log_error_strerror(result, "error executing message: %d",
request->zone_message.type);
}
@@ -678,7 +678,7 @@ static void close_chapters(void *arg)
struct chapter_writer *writer = arg;
struct uds_index *index = writer->index;
- uds_log_debug("chapter writer starting");
+ vdo_log_debug("chapter writer starting");
mutex_lock(&writer->mutex);
for (;;) {
while (writer->zones_to_write < index->zone_count) {
@@ -688,7 +688,7 @@ static void close_chapters(void *arg)
* open chapter, so we can exit now.
*/
mutex_unlock(&writer->mutex);
- uds_log_debug("chapter writer stopping");
+ vdo_log_debug("chapter writer stopping");
return;
}
uds_wait_cond(&writer->cond, &writer->mutex);
@@ -711,7 +711,7 @@ static void close_chapters(void *arg)
index->has_saved_open_chapter = false;
result = uds_discard_open_chapter(index->layout);
if (result == UDS_SUCCESS)
- uds_log_debug("Discarding saved open chapter");
+ vdo_log_debug("Discarding saved open chapter");
}
result = uds_close_open_chapter(writer->chapters, index->zone_count,
@@ -818,7 +818,7 @@ static int load_index(struct uds_index *index)
last_save_chapter = ((index->last_save != NO_LAST_SAVE) ? index->last_save : 0);
- uds_log_info("loaded index from chapter %llu through chapter %llu",
+ vdo_log_info("loaded index from chapter %llu through chapter %llu",
(unsigned long long) index->oldest_virtual_chapter,
(unsigned long long) last_save_chapter);
@@ -843,7 +843,7 @@ static int rebuild_index_page_map(struct uds_index *index, u64 vcn)
index_page_number,
&chapter_index_page);
if (result != UDS_SUCCESS) {
- return uds_log_error_strerror(result,
+ return vdo_log_error_strerror(result,
"failed to read index page %u in chapter %u",
index_page_number, chapter);
}
@@ -851,7 +851,7 @@ static int rebuild_index_page_map(struct uds_index *index, u64 vcn)
lowest_delta_list = chapter_index_page->lowest_list_number;
highest_delta_list = chapter_index_page->highest_list_number;
if (lowest_delta_list != expected_list_number) {
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"chapter %u index page %u is corrupt",
chapter, index_page_number);
}
@@ -980,7 +980,7 @@ static int replay_chapter(struct uds_index *index, u64 virtual, bool sparse)
u32 physical_chapter;
if (check_for_suspend(index)) {
- uds_log_info("Replay interrupted by index shutdown at chapter %llu",
+ vdo_log_info("Replay interrupted by index shutdown at chapter %llu",
(unsigned long long) virtual);
return -EBUSY;
}
@@ -992,7 +992,7 @@ static int replay_chapter(struct uds_index *index, u64 virtual, bool sparse)
result = rebuild_index_page_map(index, virtual);
if (result != UDS_SUCCESS) {
- return uds_log_error_strerror(result,
+ return vdo_log_error_strerror(result,
"could not rebuild index page map for chapter %u",
physical_chapter);
}
@@ -1005,7 +1005,7 @@ static int replay_chapter(struct uds_index *index, u64 virtual, bool sparse)
result = uds_get_volume_record_page(index->volume, physical_chapter,
record_page_number, &record_page);
if (result != UDS_SUCCESS) {
- return uds_log_error_strerror(result, "could not get page %d",
+ return vdo_log_error_strerror(result, "could not get page %d",
record_page_number);
}
@@ -1034,7 +1034,7 @@ static int replay_volume(struct uds_index *index)
u64 upto_virtual = index->newest_virtual_chapter;
bool will_be_sparse;
- uds_log_info("Replaying volume from chapter %llu through chapter %llu",
+ vdo_log_info("Replaying volume from chapter %llu through chapter %llu",
(unsigned long long) from_virtual,
(unsigned long long) upto_virtual);
@@ -1064,7 +1064,7 @@ static int replay_volume(struct uds_index *index)
new_map_update = index->volume->index_page_map->last_update;
if (new_map_update != old_map_update) {
- uds_log_info("replay changed index page map update from %llu to %llu",
+ vdo_log_info("replay changed index page map update from %llu to %llu",
(unsigned long long) old_map_update,
(unsigned long long) new_map_update);
}
@@ -1084,7 +1084,7 @@ static int rebuild_index(struct uds_index *index)
result = uds_find_volume_chapter_boundaries(index->volume, &lowest, &highest,
&is_empty);
if (result != UDS_SUCCESS) {
- return uds_log_fatal_strerror(result,
+ return vdo_log_fatal_strerror(result,
"cannot rebuild index: unknown volume chapter boundaries");
}
@@ -1194,7 +1194,7 @@ int uds_make_index(struct uds_configuration *config, enum uds_open_index_type op
result = make_index_zone(index, z);
if (result != UDS_SUCCESS) {
uds_free_index(index);
- return uds_log_error_strerror(result,
+ return vdo_log_error_strerror(result,
"Could not create index zone");
}
}
@@ -1203,7 +1203,7 @@ int uds_make_index(struct uds_configuration *config, enum uds_open_index_type op
result = uds_make_volume_index(config, nonce, &index->volume_index);
if (result != UDS_SUCCESS) {
uds_free_index(index);
- return uds_log_error_strerror(result, "could not make volume index");
+ return vdo_log_error_strerror(result, "could not make volume index");
}
index->load_context = load_context;
@@ -1229,14 +1229,14 @@ int uds_make_index(struct uds_configuration *config, enum uds_open_index_type op
break;
case -ENOMEM:
/* We should not try a rebuild for this error. */
- uds_log_error_strerror(result, "index could not be loaded");
+ vdo_log_error_strerror(result, "index could not be loaded");
break;
default:
- uds_log_error_strerror(result, "index could not be loaded");
+ vdo_log_error_strerror(result, "index could not be loaded");
if (open_type == UDS_LOAD) {
result = rebuild_index(index);
if (result != UDS_SUCCESS) {
- uds_log_error_strerror(result,
+ vdo_log_error_strerror(result,
"index could not be rebuilt");
}
}
@@ -1246,7 +1246,7 @@ int uds_make_index(struct uds_configuration *config, enum uds_open_index_type op
if (result != UDS_SUCCESS) {
uds_free_index(index);
- return uds_log_error_strerror(result, "fatal error in %s()", __func__);
+ return vdo_log_error_strerror(result, "fatal error in %s()", __func__);
}
for (z = 0; z < index->zone_count; z++) {
@@ -1320,16 +1320,16 @@ int uds_save_index(struct uds_index *index)
index->prev_save = index->last_save;
index->last_save = ((index->newest_virtual_chapter == 0) ?
NO_LAST_SAVE : index->newest_virtual_chapter - 1);
- uds_log_info("beginning save (vcn %llu)", (unsigned long long) index->last_save);
+ vdo_log_info("beginning save (vcn %llu)", (unsigned long long) index->last_save);
result = uds_save_index_state(index->layout, index);
if (result != UDS_SUCCESS) {
- uds_log_info("save index failed");
+ vdo_log_info("save index failed");
index->last_save = index->prev_save;
} else {
index->has_saved_open_chapter = true;
index->need_to_save = false;
- uds_log_info("finished save (vcn %llu)",
+ vdo_log_info("finished save (vcn %llu)",
(unsigned long long) index->last_save);
}
diff --git a/drivers/md/dm-vdo/indexer/io-factory.c b/drivers/md/dm-vdo/indexer/io-factory.c
index 0dcf6d596653..515765d35794 100644
--- a/drivers/md/dm-vdo/indexer/io-factory.c
+++ b/drivers/md/dm-vdo/indexer/io-factory.c
@@ -365,7 +365,7 @@ void uds_free_buffered_writer(struct buffered_writer *writer)
flush_previous_buffer(writer);
result = -dm_bufio_write_dirty_buffers(writer->client);
if (result != UDS_SUCCESS)
- uds_log_warning_strerror(result, "%s: failed to sync storage", __func__);
+ vdo_log_warning_strerror(result, "%s: failed to sync storage", __func__);
dm_bufio_client_destroy(writer->client);
uds_put_io_factory(writer->factory);
diff --git a/drivers/md/dm-vdo/indexer/open-chapter.c b/drivers/md/dm-vdo/indexer/open-chapter.c
index 46b7bc1ac324..4a67bcadaae0 100644
--- a/drivers/md/dm-vdo/indexer/open-chapter.c
+++ b/drivers/md/dm-vdo/indexer/open-chapter.c
@@ -259,14 +259,14 @@ static int fill_delta_chapter_index(struct open_chapter_zone **chapter_zones,
overflow_count++;
break;
default:
- uds_log_error_strerror(result,
+ vdo_log_error_strerror(result,
"failed to build open chapter index");
return result;
}
}
if (overflow_count > 0)
- uds_log_warning("Failed to add %d entries to chapter index",
+ vdo_log_warning("Failed to add %d entries to chapter index",
overflow_count);
return UDS_SUCCESS;
@@ -417,7 +417,7 @@ int uds_load_open_chapter(struct uds_index *index, struct buffered_reader *reade
return result;
if (memcmp(OPEN_CHAPTER_VERSION, version, sizeof(version)) != 0) {
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"Invalid open chapter version: %.*s",
(int) sizeof(version), version);
}
diff --git a/drivers/md/dm-vdo/indexer/volume-index.c b/drivers/md/dm-vdo/indexer/volume-index.c
index e2b0600d82b9..12f954a0c532 100644
--- a/drivers/md/dm-vdo/indexer/volume-index.c
+++ b/drivers/md/dm-vdo/indexer/volume-index.c
@@ -225,13 +225,13 @@ static int compute_volume_sub_index_parameters(const struct uds_configuration *c
params->address_bits = bits_per(address_count - 1);
params->chapter_bits = bits_per(rounded_chapters - 1);
if ((u32) params->list_count != params->list_count) {
- return uds_log_warning_strerror(UDS_INVALID_ARGUMENT,
+ return vdo_log_warning_strerror(UDS_INVALID_ARGUMENT,
"cannot initialize volume index with %llu delta lists",
(unsigned long long) params->list_count);
}
if (params->address_bits > 31) {
- return uds_log_warning_strerror(UDS_INVALID_ARGUMENT,
+ return vdo_log_warning_strerror(UDS_INVALID_ARGUMENT,
"cannot initialize volume index with %u address bits",
params->address_bits);
}
@@ -568,7 +568,7 @@ int uds_put_volume_index_record(struct volume_index_record *record, u64 virtual_
u64 low = get_zone_for_record(record)->virtual_chapter_low;
u64 high = get_zone_for_record(record)->virtual_chapter_high;
- return uds_log_warning_strerror(UDS_INVALID_ARGUMENT,
+ return vdo_log_warning_strerror(UDS_INVALID_ARGUMENT,
"cannot put record into chapter number %llu that is out of the valid range %llu to %llu",
(unsigned long long) virtual_chapter,
(unsigned long long) low,
@@ -590,7 +590,7 @@ int uds_put_volume_index_record(struct volume_index_record *record, u64 virtual_
record->is_found = true;
break;
case UDS_OVERFLOW:
- uds_log_ratelimit(uds_log_warning_strerror, UDS_OVERFLOW,
+ vdo_log_ratelimit(vdo_log_warning_strerror, UDS_OVERFLOW,
"Volume index entry dropped due to overflow condition");
uds_log_delta_index_entry(&record->delta_entry);
break;
@@ -606,7 +606,7 @@ int uds_remove_volume_index_record(struct volume_index_record *record)
int result;
if (!record->is_found)
- return uds_log_warning_strerror(UDS_BAD_STATE,
+ return vdo_log_warning_strerror(UDS_BAD_STATE,
"illegal operation on new record");
/* Mark the record so that it cannot be used again */
@@ -644,7 +644,7 @@ static void set_volume_sub_index_zone_open_chapter(struct volume_sub_index *sub_
1 + (used_bits - sub_index->max_zone_bits) / sub_index->chapter_zone_bits;
if (expire_count == 1) {
- uds_log_ratelimit(uds_log_info,
+ vdo_log_ratelimit(vdo_log_info,
"zone %u: At chapter %llu, expiring chapter %llu early",
zone_number,
(unsigned long long) virtual_chapter,
@@ -662,7 +662,7 @@ static void set_volume_sub_index_zone_open_chapter(struct volume_sub_index *sub_
zone->virtual_chapter_high - zone->virtual_chapter_low;
zone->virtual_chapter_low = zone->virtual_chapter_high;
}
- uds_log_ratelimit(uds_log_info,
+ vdo_log_ratelimit(vdo_log_info,
"zone %u: At chapter %llu, expiring chapters %llu to %llu early",
zone_number,
(unsigned long long) virtual_chapter,
@@ -713,14 +713,14 @@ int uds_set_volume_index_record_chapter(struct volume_index_record *record,
int result;
if (!record->is_found)
- return uds_log_warning_strerror(UDS_BAD_STATE,
+ return vdo_log_warning_strerror(UDS_BAD_STATE,
"illegal operation on new record");
if (!is_virtual_chapter_indexed(record, virtual_chapter)) {
u64 low = get_zone_for_record(record)->virtual_chapter_low;
u64 high = get_zone_for_record(record)->virtual_chapter_high;
- return uds_log_warning_strerror(UDS_INVALID_ARGUMENT,
+ return vdo_log_warning_strerror(UDS_INVALID_ARGUMENT,
"cannot set chapter number %llu that is out of the valid range %llu to %llu",
(unsigned long long) virtual_chapter,
(unsigned long long) low,
@@ -820,7 +820,7 @@ static int start_restoring_volume_sub_index(struct volume_sub_index *sub_index,
result = uds_read_from_buffered_reader(readers[i], buffer,
sizeof(buffer));
if (result != UDS_SUCCESS) {
- return uds_log_warning_strerror(result,
+ return vdo_log_warning_strerror(result,
"failed to read volume index header");
}
@@ -839,14 +839,14 @@ static int start_restoring_volume_sub_index(struct volume_sub_index *sub_index,
result = UDS_CORRUPT_DATA;
if (memcmp(header.magic, MAGIC_START_5, MAGIC_SIZE) != 0) {
- return uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"volume index file had bad magic number");
}
if (sub_index->volume_nonce == 0) {
sub_index->volume_nonce = header.volume_nonce;
} else if (header.volume_nonce != sub_index->volume_nonce) {
- return uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"volume index volume nonce incorrect");
}
@@ -857,7 +857,7 @@ static int start_restoring_volume_sub_index(struct volume_sub_index *sub_index,
u64 low = header.virtual_chapter_low;
u64 high = header.virtual_chapter_high;
- return uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"Inconsistent volume index zone files: Chapter range is [%llu,%llu], chapter range %d is [%llu,%llu]",
(unsigned long long) virtual_chapter_low,
(unsigned long long) virtual_chapter_high,
@@ -873,7 +873,7 @@ static int start_restoring_volume_sub_index(struct volume_sub_index *sub_index,
result = uds_read_from_buffered_reader(readers[i], decoded,
sizeof(u64));
if (result != UDS_SUCCESS) {
- return uds_log_warning_strerror(result,
+ return vdo_log_warning_strerror(result,
"failed to read volume index flush ranges");
}
@@ -891,7 +891,7 @@ static int start_restoring_volume_sub_index(struct volume_sub_index *sub_index,
result = uds_start_restoring_delta_index(&sub_index->delta_index, readers,
reader_count);
if (result != UDS_SUCCESS)
- return uds_log_warning_strerror(result, "restoring delta index failed");
+ return vdo_log_warning_strerror(result, "restoring delta index failed");
return UDS_SUCCESS;
}
@@ -916,7 +916,7 @@ static int start_restoring_volume_index(struct volume_index *volume_index,
result = uds_read_from_buffered_reader(buffered_readers[i], buffer,
sizeof(buffer));
if (result != UDS_SUCCESS) {
- return uds_log_warning_strerror(result,
+ return vdo_log_warning_strerror(result,
"failed to read volume index header");
}
@@ -931,13 +931,13 @@ static int start_restoring_volume_index(struct volume_index *volume_index,
result = UDS_CORRUPT_DATA;
if (memcmp(header.magic, MAGIC_START_6, MAGIC_SIZE) != 0)
- return uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"volume index file had bad magic number");
if (i == 0) {
volume_index->sparse_sample_rate = header.sparse_sample_rate;
} else if (volume_index->sparse_sample_rate != header.sparse_sample_rate) {
- uds_log_warning_strerror(UDS_CORRUPT_DATA,
+ vdo_log_warning_strerror(UDS_CORRUPT_DATA,
"Inconsistent sparse sample rate in delta index zone files: %u vs. %u",
volume_index->sparse_sample_rate,
header.sparse_sample_rate);
@@ -1031,7 +1031,7 @@ static int start_saving_volume_sub_index(const struct volume_sub_index *sub_inde
result = uds_write_to_buffered_writer(buffered_writer, buffer, offset);
if (result != UDS_SUCCESS)
- return uds_log_warning_strerror(result,
+ return vdo_log_warning_strerror(result,
"failed to write volume index header");
for (i = 0; i < list_count; i++) {
@@ -1041,7 +1041,7 @@ static int start_saving_volume_sub_index(const struct volume_sub_index *sub_inde
result = uds_write_to_buffered_writer(buffered_writer, encoded,
sizeof(u64));
if (result != UDS_SUCCESS) {
- return uds_log_warning_strerror(result,
+ return vdo_log_warning_strerror(result,
"failed to write volume index flush ranges");
}
}
@@ -1074,7 +1074,7 @@ static int start_saving_volume_index(const struct volume_index *volume_index,
result = uds_write_to_buffered_writer(writer, buffer, offset);
if (result != UDS_SUCCESS) {
- uds_log_warning_strerror(result, "failed to write volume index header");
+ vdo_log_warning_strerror(result, "failed to write volume index header");
return result;
}
@@ -1264,7 +1264,7 @@ int uds_make_volume_index(const struct uds_configuration *config, u64 volume_non
&volume_index->vi_non_hook);
if (result != UDS_SUCCESS) {
uds_free_volume_index(volume_index);
- return uds_log_error_strerror(result,
+ return vdo_log_error_strerror(result,
"Error creating non hook volume index");
}
@@ -1272,7 +1272,7 @@ int uds_make_volume_index(const struct uds_configuration *config, u64 volume_non
&volume_index->vi_hook);
if (result != UDS_SUCCESS) {
uds_free_volume_index(volume_index);
- return uds_log_error_strerror(result,
+ return vdo_log_error_strerror(result,
"Error creating hook volume index");
}
diff --git a/drivers/md/dm-vdo/indexer/volume.c b/drivers/md/dm-vdo/indexer/volume.c
index 701f2220d803..655453bb276b 100644
--- a/drivers/md/dm-vdo/indexer/volume.c
+++ b/drivers/md/dm-vdo/indexer/volume.c
@@ -357,7 +357,7 @@ static void enqueue_page_read(struct volume *volume, struct uds_request *request
{
/* Mark the page as queued, so that chapter invalidation knows to cancel a read. */
while (!enqueue_read(&volume->page_cache, request, physical_page)) {
- uds_log_debug("Read queue full, waiting for reads to finish");
+ vdo_log_debug("Read queue full, waiting for reads to finish");
uds_wait_cond(&volume->read_threads_read_done_cond,
&volume->read_threads_mutex);
}
@@ -431,7 +431,7 @@ static int init_chapter_index_page(const struct volume *volume, u8 *index_page,
return result;
if (result != UDS_SUCCESS) {
- return uds_log_error_strerror(result,
+ return vdo_log_error_strerror(result,
"Reading chapter index page for chapter %u page %u",
chapter, index_page_number);
}
@@ -445,14 +445,14 @@ static int init_chapter_index_page(const struct volume *volume, u8 *index_page,
(highest_list == chapter_index_page->highest_list_number))
return UDS_SUCCESS;
- uds_log_warning("Index page map updated to %llu",
+ vdo_log_warning("Index page map updated to %llu",
(unsigned long long) volume->index_page_map->last_update);
- uds_log_warning("Page map expects that chapter %u page %u has range %u to %u, but chapter index page has chapter %llu with range %u to %u",
+ vdo_log_warning("Page map expects that chapter %u page %u has range %u to %u, but chapter index page has chapter %llu with range %u to %u",
chapter, index_page_number, lowest_list, highest_list,
(unsigned long long) ci_virtual,
chapter_index_page->lowest_list_number,
chapter_index_page->highest_list_number);
- return uds_log_error_strerror(UDS_CORRUPT_DATA,
+ return vdo_log_error_strerror(UDS_CORRUPT_DATA,
"index page map mismatch with chapter index");
}
@@ -547,7 +547,7 @@ static int process_entry(struct volume *volume, struct queued_read *entry)
int result;
if (entry->invalid) {
- uds_log_debug("Requeuing requests for invalid page");
+ vdo_log_debug("Requeuing requests for invalid page");
return UDS_SUCCESS;
}
@@ -558,7 +558,7 @@ static int process_entry(struct volume *volume, struct queued_read *entry)
mutex_lock(&volume->read_threads_mutex);
if (IS_ERR(page_data)) {
result = -PTR_ERR(page_data);
- uds_log_warning_strerror(result,
+ vdo_log_warning_strerror(result,
"error reading physical page %u from volume",
page_number);
cancel_page_in_cache(&volume->page_cache, page_number, page);
@@ -566,7 +566,7 @@ static int process_entry(struct volume *volume, struct queued_read *entry)
}
if (entry->invalid) {
- uds_log_warning("Page %u invalidated after read", page_number);
+ vdo_log_warning("Page %u invalidated after read", page_number);
cancel_page_in_cache(&volume->page_cache, page_number, page);
return UDS_SUCCESS;
}
@@ -574,7 +574,7 @@ static int process_entry(struct volume *volume, struct queued_read *entry)
if (!is_record_page(volume->geometry, page_number)) {
result = initialize_index_page(volume, page_number, page);
if (result != UDS_SUCCESS) {
- uds_log_warning("Error initializing chapter index page");
+ vdo_log_warning("Error initializing chapter index page");
cancel_page_in_cache(&volume->page_cache, page_number, page);
return result;
}
@@ -582,7 +582,7 @@ static int process_entry(struct volume *volume, struct queued_read *entry)
result = put_page_in_cache(&volume->page_cache, page_number, page);
if (result != UDS_SUCCESS) {
- uds_log_warning("Error putting page %u in cache", page_number);
+ vdo_log_warning("Error putting page %u in cache", page_number);
cancel_page_in_cache(&volume->page_cache, page_number, page);
return result;
}
@@ -624,7 +624,7 @@ static void read_thread_function(void *arg)
{
struct volume *volume = arg;
- uds_log_debug("reader starting");
+ vdo_log_debug("reader starting");
mutex_lock(&volume->read_threads_mutex);
while (true) {
struct queued_read *queue_entry;
@@ -638,7 +638,7 @@ static void read_thread_function(void *arg)
release_queued_requests(volume, queue_entry, result);
}
mutex_unlock(&volume->read_threads_mutex);
- uds_log_debug("reader done");
+ vdo_log_debug("reader done");
}
static void get_page_and_index(struct page_cache *cache, u32 physical_page,
@@ -701,7 +701,7 @@ static int read_page_locked(struct volume *volume, u32 physical_page,
page_data = dm_bufio_read(volume->client, physical_page, &page->buffer);
if (IS_ERR(page_data)) {
result = -PTR_ERR(page_data);
- uds_log_warning_strerror(result,
+ vdo_log_warning_strerror(result,
"error reading physical page %u from volume",
physical_page);
cancel_page_in_cache(&volume->page_cache, physical_page, page);
@@ -712,7 +712,7 @@ static int read_page_locked(struct volume *volume, u32 physical_page,
result = initialize_index_page(volume, physical_page, page);
if (result != UDS_SUCCESS) {
if (volume->lookup_mode != LOOKUP_FOR_REBUILD)
- uds_log_warning("Corrupt index page %u", physical_page);
+ vdo_log_warning("Corrupt index page %u", physical_page);
cancel_page_in_cache(&volume->page_cache, physical_page, page);
return result;
}
@@ -720,7 +720,7 @@ static int read_page_locked(struct volume *volume, u32 physical_page,
result = put_page_in_cache(&volume->page_cache, physical_page, page);
if (result != UDS_SUCCESS) {
- uds_log_warning("Error putting page %u in cache", physical_page);
+ vdo_log_warning("Error putting page %u in cache", physical_page);
cancel_page_in_cache(&volume->page_cache, physical_page, page);
return result;
}
@@ -947,7 +947,7 @@ int uds_read_chapter_index_from_volume(const struct volume *volume, u64 virtual_
&volume_buffers[i]);
if (IS_ERR(index_page)) {
result = -PTR_ERR(index_page);
- uds_log_warning_strerror(result,
+ vdo_log_warning_strerror(result,
"error reading physical page %u",
physical_page);
return result;
@@ -1039,7 +1039,7 @@ static void invalidate_page(struct page_cache *cache, u32 physical_page)
wait_for_pending_searches(cache, page->physical_page);
clear_cache_page(cache, page);
} else if (queue_index > -1) {
- uds_log_debug("setting pending read to invalid");
+ vdo_log_debug("setting pending read to invalid");
cache->read_queue[queue_index].invalid = true;
}
}
@@ -1051,7 +1051,7 @@ void uds_forget_chapter(struct volume *volume, u64 virtual_chapter)
u32 first_page = map_to_physical_page(volume->geometry, physical_chapter, 0);
u32 i;
- uds_log_debug("forgetting chapter %llu", (unsigned long long) virtual_chapter);
+ vdo_log_debug("forgetting chapter %llu", (unsigned long long) virtual_chapter);
mutex_lock(&volume->read_threads_mutex);
for (i = 0; i < volume->geometry->pages_per_chapter; i++)
invalidate_page(&volume->page_cache, first_page + i);
@@ -1077,14 +1077,14 @@ static int donate_index_page_locked(struct volume *volume, u32 physical_chapter,
physical_chapter, index_page_number,
&page->index_page);
if (result != UDS_SUCCESS) {
- uds_log_warning("Error initialize chapter index page");
+ vdo_log_warning("Error initialize chapter index page");
cancel_page_in_cache(&volume->page_cache, physical_page, page);
return result;
}
result = put_page_in_cache(&volume->page_cache, physical_page, page);
if (result != UDS_SUCCESS) {
- uds_log_warning("Error putting page %u in cache", physical_page);
+ vdo_log_warning("Error putting page %u in cache", physical_page);
cancel_page_in_cache(&volume->page_cache, physical_page, page);
return result;
}
@@ -1112,7 +1112,7 @@ static int write_index_pages(struct volume *volume, u32 physical_chapter_number,
page_data = dm_bufio_new(volume->client, physical_page, &page_buffer);
if (IS_ERR(page_data)) {
- return uds_log_warning_strerror(-PTR_ERR(page_data),
+ return vdo_log_warning_strerror(-PTR_ERR(page_data),
"failed to prepare index page");
}
@@ -1122,14 +1122,14 @@ static int write_index_pages(struct volume *volume, u32 physical_chapter_number,
&lists_packed);
if (result != UDS_SUCCESS) {
dm_bufio_release(page_buffer);
- return uds_log_warning_strerror(result,
+ return vdo_log_warning_strerror(result,
"failed to pack index page");
}
dm_bufio_mark_buffer_dirty(page_buffer);
if (lists_packed == 0) {
- uds_log_debug("no delta lists packed on chapter %u page %u",
+ vdo_log_debug("no delta lists packed on chapter %u page %u",
physical_chapter_number, index_page_number);
} else {
delta_list_number += lists_packed;
@@ -1221,14 +1221,14 @@ static int write_record_pages(struct volume *volume, u32 physical_chapter_number
page_data = dm_bufio_new(volume->client, physical_page, &page_buffer);
if (IS_ERR(page_data)) {
- return uds_log_warning_strerror(-PTR_ERR(page_data),
+ return vdo_log_warning_strerror(-PTR_ERR(page_data),
"failed to prepare record page");
}
result = encode_record_page(volume, next_record, page_data);
if (result != UDS_SUCCESS) {
dm_bufio_release(page_buffer);
- return uds_log_warning_strerror(result,
+ return vdo_log_warning_strerror(result,
"failed to encode record page %u",
record_page_number);
}
@@ -1259,7 +1259,7 @@ int uds_write_chapter(struct volume *volume, struct open_chapter_index *chapter_
result = -dm_bufio_write_dirty_buffers(volume->client);
if (result != UDS_SUCCESS)
- uds_log_error_strerror(result, "cannot sync chapter to volume");
+ vdo_log_error_strerror(result, "cannot sync chapter to volume");
return result;
}
@@ -1286,7 +1286,7 @@ static void probe_chapter(struct volume *volume, u32 chapter_number,
return;
if (page->virtual_chapter_number == BAD_CHAPTER) {
- uds_log_error("corrupt index page in chapter %u",
+ vdo_log_error("corrupt index page in chapter %u",
chapter_number);
return;
}
@@ -1294,14 +1294,14 @@ static void probe_chapter(struct volume *volume, u32 chapter_number,
if (vcn == BAD_CHAPTER) {
vcn = page->virtual_chapter_number;
} else if (page->virtual_chapter_number != vcn) {
- uds_log_error("inconsistent chapter %u index page %u: expected vcn %llu, got vcn %llu",
+ vdo_log_error("inconsistent chapter %u index page %u: expected vcn %llu, got vcn %llu",
chapter_number, i, (unsigned long long) vcn,
(unsigned long long) page->virtual_chapter_number);
return;
}
if (expected_list_number != page->lowest_list_number) {
- uds_log_error("inconsistent chapter %u index page %u: expected list number %u, got list number %u",
+ vdo_log_error("inconsistent chapter %u index page %u: expected list number %u, got list number %u",
chapter_number, i, expected_list_number,
page->lowest_list_number);
return;
@@ -1314,7 +1314,7 @@ static void probe_chapter(struct volume *volume, u32 chapter_number,
}
if (chapter_number != uds_map_to_physical_chapter(geometry, vcn)) {
- uds_log_error("chapter %u vcn %llu is out of phase (%u)", chapter_number,
+ vdo_log_error("chapter %u vcn %llu is out of phase (%u)", chapter_number,
(unsigned long long) vcn, geometry->chapters_per_volume);
return;
}
@@ -1431,7 +1431,7 @@ static int find_chapter_limits(struct volume *volume, u32 chapter_limit, u64 *lo
probe_chapter(volume, right_chapter, &highest);
if (bad_chapters++ >= MAX_BAD_CHAPTERS) {
- uds_log_error("too many bad chapters in volume: %u",
+ vdo_log_error("too many bad chapters in volume: %u",
bad_chapters);
return UDS_CORRUPT_DATA;
}
@@ -1555,7 +1555,7 @@ int uds_make_volume(const struct uds_configuration *config, struct index_layout
result = uds_copy_index_geometry(config->geometry, &volume->geometry);
if (result != UDS_SUCCESS) {
uds_free_volume(volume);
- return uds_log_warning_strerror(result,
+ return vdo_log_warning_strerror(result,
"failed to allocate geometry: error");
}
geometry = volume->geometry;
generated by cgit v1.2.3 (git 2.39.0) at 2024-10-14 11:27:23 +0300