dm vdo logger: change from uds_ to vdo_ namespace

Rename all uds_log_* to vdo_log_*.

Signed-off-by: Mike Snitzer <snitzer@kernel.org>
Signed-off-by: Chung Chung <cchung@redhat.com>
Signed-off-by: Matthew Sakai <msakai@redhat.com>

1 files changed, 41 insertions, 41 deletions

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);