dm vdo indexer: update ASSERT and ASSERT_LOG_ONLY usage

Update indexer uses of ASSERT and ASSERT_LOG_ONLY to
VDO_ASSERT and VDO_ASSERT_LOG_ONLY, respectively. Remove
ASSERT and ASSERT_LOG_ONLY. Also rename uds_assertion_failed
to vdo_assertion_failed.

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

diff --git a/drivers/md/dm-vdo/indexer/chapter-index.c b/drivers/md/dm-vdo/indexer/chapter-index.c
index 68d86028dbb7c41a5b2e326e0ddc394dbf8d6048..47e4ed234242621e8ee564650987c18601167fbb 100644 (file)
--- a/drivers/md/dm-vdo/indexer/chapter-index.c
+++ b/drivers/md/dm-vdo/indexer/chapter-index.c
@@ -83,10 +83,10 @@ int uds_put_open_chapter_index_record(struct open_chapter_index *chapter_index,
        u64 chapter_number = chapter_index->virtual_chapter_number;
        u32 record_pages = geometry->record_pages_per_chapter;
 
-       result = ASSERT(page_number < record_pages,
-                       "Page number within chapter (%u) exceeds the maximum value %u",
-                       page_number, record_pages);
-       if (result != UDS_SUCCESS)
+       result = VDO_ASSERT(page_number < record_pages,
+                           "Page number within chapter (%u) exceeds the maximum value %u",
+                           page_number, record_pages);
+       if (result != VDO_SUCCESS)
                return UDS_INVALID_ARGUMENT;
 
        address = uds_hash_to_chapter_delta_address(name, geometry);
@@ -97,10 +97,10 @@ int uds_put_open_chapter_index_record(struct open_chapter_index *chapter_index,
                return result;
 
        found = was_entry_found(&entry, address);
-       result = ASSERT(!(found && entry.is_collision),
-                       "Chunk appears more than once in chapter %llu",
-                       (unsigned long long) chapter_number);
-       if (result != UDS_SUCCESS)
+       result = VDO_ASSERT(!(found && entry.is_collision),
+                           "Chunk appears more than once in chapter %llu",
+                           (unsigned long long) chapter_number);
+       if (result != VDO_SUCCESS)
                return UDS_BAD_STATE;
 
        found_name = (found ? name->name : NULL);

diff --git a/drivers/md/dm-vdo/indexer/config.c b/drivers/md/dm-vdo/indexer/config.c
index 5da39043b9aeb7534e1d0a24013f65f012932e1e..69bf27a9d61bf48d5eb9ddb7547a0672124a2e35 100644 (file)
--- a/drivers/md/dm-vdo/indexer/config.c
+++ b/drivers/md/dm-vdo/indexer/config.c
@@ -134,10 +134,10 @@ int uds_validate_config_contents(struct buffered_reader *reader,
        decode_u32_le(buffer, &offset, &config.sparse_sample_rate);
        decode_u64_le(buffer, &offset, &config.nonce);
 
-       result = ASSERT(offset == sizeof(struct uds_configuration_6_02),
-                       "%zu bytes read but not decoded",
-                       sizeof(struct uds_configuration_6_02) - offset);
-       if (result != UDS_SUCCESS)
+       result = VDO_ASSERT(offset == sizeof(struct uds_configuration_6_02),
+                           "%zu bytes read but not decoded",
+                           sizeof(struct uds_configuration_6_02) - offset);
+       if (result != VDO_SUCCESS)
                return UDS_CORRUPT_DATA;
 
        if (is_version(INDEX_CONFIG_VERSION_6_02, version_buffer)) {
@@ -210,10 +210,10 @@ int uds_write_config_contents(struct buffered_writer *writer,
        encode_u32_le(buffer, &offset, config->sparse_sample_rate);
        encode_u64_le(buffer, &offset, config->nonce);
 
-       result = ASSERT(offset == sizeof(struct uds_configuration_6_02),
-                       "%zu bytes encoded, of %zu expected", offset,
-                       sizeof(struct uds_configuration_6_02));
-       if (result != UDS_SUCCESS)
+       result = VDO_ASSERT(offset == sizeof(struct uds_configuration_6_02),
+                           "%zu bytes encoded, of %zu expected", offset,
+                           sizeof(struct uds_configuration_6_02));
+       if (result != VDO_SUCCESS)
                return result;
 
        if (version >= 4) {

diff --git a/drivers/md/dm-vdo/indexer/delta-index.c b/drivers/md/dm-vdo/indexer/delta-index.c
index 5bba9a48c5a080b184a2c4b619cc537d84edf05a..b490665542488ab3e62eafd7c6935fe23ac56c79 100644 (file)
--- a/drivers/md/dm-vdo/indexer/delta-index.c
+++ b/drivers/md/dm-vdo/indexer/delta-index.c
@@ -856,10 +856,10 @@ int uds_start_restoring_delta_index(struct delta_index *delta_index,
                decode_u64_le(buffer, &offset, &header.record_count);
                decode_u64_le(buffer, &offset, &header.collision_count);
 
-               result = ASSERT(offset == sizeof(struct delta_index_header),
-                               "%zu bytes decoded of %zu expected", offset,
-                               sizeof(struct delta_index_header));
-               if (result != UDS_SUCCESS) {
+               result = VDO_ASSERT(offset == sizeof(struct delta_index_header),
+                                   "%zu bytes decoded of %zu expected", offset,
+                                   sizeof(struct delta_index_header));
+               if (result != VDO_SUCCESS) {
                        return uds_log_warning_strerror(result,
                                                        "failed to read delta index header");
                }
@@ -1136,10 +1136,10 @@ int uds_start_saving_delta_index(const struct delta_index *delta_index,
        encode_u64_le(buffer, &offset, delta_zone->record_count);
        encode_u64_le(buffer, &offset, delta_zone->collision_count);
 
-       result = ASSERT(offset == sizeof(struct delta_index_header),
-                       "%zu bytes encoded of %zu expected", offset,
-                       sizeof(struct delta_index_header));
-       if (result != UDS_SUCCESS)
+       result = VDO_ASSERT(offset == sizeof(struct delta_index_header),
+                           "%zu bytes encoded of %zu expected", offset,
+                           sizeof(struct delta_index_header));
+       if (result != VDO_SUCCESS)
                return result;
 
        result = uds_write_to_buffered_writer(buffered_writer, buffer, offset);
@@ -1212,9 +1212,9 @@ size_t uds_compute_delta_index_save_bytes(u32 list_count, size_t memory_size)
 
 static int assert_not_at_end(const struct delta_index_entry *delta_entry)
 {
-       int result = ASSERT(!delta_entry->at_end,
-                           "operation is invalid because the list entry is at the end of the delta list");
-       if (result != UDS_SUCCESS)
+       int result = VDO_ASSERT(!delta_entry->at_end,
+                               "operation is invalid because the list entry is at the end of the delta list");
+       if (result != VDO_SUCCESS)
                result = UDS_BAD_STATE;
 
        return result;
@@ -1236,19 +1236,19 @@ int uds_start_delta_index_search(const struct delta_index *delta_index, u32 list
        struct delta_zone *delta_zone;
        struct delta_list *delta_list;
 
-       result = ASSERT((list_number < delta_index->list_count),
-                       "Delta list number (%u) is out of range (%u)", list_number,
-                       delta_index->list_count);
-       if (result != UDS_SUCCESS)
+       result = VDO_ASSERT((list_number < delta_index->list_count),
+                           "Delta list number (%u) is out of range (%u)", list_number,
+                           delta_index->list_count);
+       if (result != VDO_SUCCESS)
                return UDS_CORRUPT_DATA;
 
        zone_number = list_number / delta_index->lists_per_zone;
        delta_zone = &delta_index->delta_zones[zone_number];
        list_number -= delta_zone->first_list;
-       result = ASSERT((list_number < delta_zone->list_count),
-                       "Delta list number (%u) is out of range (%u) for zone (%u)",
-                       list_number, delta_zone->list_count, zone_number);
-       if (result != UDS_SUCCESS)
+       result = VDO_ASSERT((list_number < delta_zone->list_count),
+                           "Delta list number (%u) is out of range (%u) for zone (%u)",
+                           list_number, delta_zone->list_count, zone_number);
+       if (result != VDO_SUCCESS)
                return UDS_CORRUPT_DATA;
 
        if (delta_index->mutable) {
@@ -1362,9 +1362,9 @@ noinline int uds_next_delta_index_entry(struct delta_index_entry *delta_entry)
                delta_entry->at_end = true;
                delta_entry->delta = 0;
                delta_entry->is_collision = false;
-               result = ASSERT((delta_entry->offset == size),
-                               "next offset past end of delta list");
-               if (result != UDS_SUCCESS)
+               result = VDO_ASSERT((delta_entry->offset == size),
+                                   "next offset past end of delta list");
+               if (result != VDO_SUCCESS)
                        result = UDS_CORRUPT_DATA;
 
                return result;
@@ -1390,8 +1390,8 @@ int uds_remember_delta_index_offset(const struct delta_index_entry *delta_entry)
        int result;
        struct delta_list *delta_list = delta_entry->delta_list;
 
-       result = ASSERT(!delta_entry->is_collision, "entry is not a collision");
-       if (result != UDS_SUCCESS)
+       result = VDO_ASSERT(!delta_entry->is_collision, "entry is not a collision");
+       if (result != VDO_SUCCESS)
                return result;
 
        delta_list->save_key = delta_entry->key - delta_entry->delta;
@@ -1489,9 +1489,9 @@ int uds_get_delta_entry_collision(const struct delta_index_entry *delta_entry, u
        if (result != UDS_SUCCESS)
                return result;
 
-       result = ASSERT(delta_entry->is_collision,
-                       "Cannot get full block name from a non-collision delta index entry");
-       if (result != UDS_SUCCESS)
+       result = VDO_ASSERT(delta_entry->is_collision,
+                           "Cannot get full block name from a non-collision delta index entry");
+       if (result != VDO_SUCCESS)
                return UDS_BAD_STATE;
 
        get_collision_name(delta_entry, name);
@@ -1506,9 +1506,9 @@ u32 uds_get_delta_entry_value(const struct delta_index_entry *delta_entry)
 
 static int assert_mutable_entry(const struct delta_index_entry *delta_entry)
 {
-       int result = ASSERT((delta_entry->delta_list != &delta_entry->temp_delta_list),
-                           "delta index is mutable");
-       if (result != UDS_SUCCESS)
+       int result = VDO_ASSERT((delta_entry->delta_list != &delta_entry->temp_delta_list),
+                               "delta index is mutable");
+       if (result != VDO_SUCCESS)
                result = UDS_BAD_STATE;
 
        return result;
@@ -1527,10 +1527,10 @@ int uds_set_delta_entry_value(const struct delta_index_entry *delta_entry, u32 v
        if (result != UDS_SUCCESS)
                return result;
 
-       result = ASSERT((value & value_mask) == value,
-                       "Value (%u) being set in a delta index is too large (must fit in %u bits)",
-                       value, delta_entry->value_bits);
-       if (result != UDS_SUCCESS)
+       result = VDO_ASSERT((value & value_mask) == value,
+                           "Value (%u) being set in a delta index is too large (must fit in %u bits)",
+                           value, delta_entry->value_bits);
+       if (result != VDO_SUCCESS)
                return UDS_INVALID_ARGUMENT;
 
        set_field(value, delta_entry->delta_zone->memory,
@@ -1730,9 +1730,9 @@ int uds_put_delta_index_entry(struct delta_index_entry *delta_entry, u32 key, u3
                if (result != UDS_SUCCESS)
                        return result;
 
-               result = ASSERT((key == delta_entry->key),
-                               "incorrect key for collision entry");
-               if (result != UDS_SUCCESS)
+               result = VDO_ASSERT((key == delta_entry->key),
+                                   "incorrect key for collision entry");
+               if (result != VDO_SUCCESS)
                        return result;
 
                delta_entry->offset += delta_entry->entry_bits;
@@ -1742,8 +1742,8 @@ int uds_put_delta_index_entry(struct delta_index_entry *delta_entry, u32 key, u3
                result = insert_bits(delta_entry, delta_entry->entry_bits);
        } else if (delta_entry->at_end) {
                /* Insert a new entry at the end of the delta list. */
-               result = ASSERT((key >= delta_entry->key), "key past end of list");
-               if (result != UDS_SUCCESS)
+               result = VDO_ASSERT((key >= delta_entry->key), "key past end of list");
+               if (result != VDO_SUCCESS)
                        return result;
 
                set_delta(delta_entry, key - delta_entry->key);
@@ -1760,14 +1760,14 @@ int uds_put_delta_index_entry(struct delta_index_entry *delta_entry, u32 key, u3
                 * Insert a new entry which requires the delta in the following entry to be
                 * updated.
                 */
-               result = ASSERT((key < delta_entry->key),
-                               "key precedes following entry");
-               if (result != UDS_SUCCESS)
+               result = VDO_ASSERT((key < delta_entry->key),
+                                   "key precedes following entry");
+               if (result != VDO_SUCCESS)
                        return result;
 
-               result = ASSERT((key >= delta_entry->key - delta_entry->delta),
-                               "key effects following entry's delta");
-               if (result != UDS_SUCCESS)
+               result = VDO_ASSERT((key >= delta_entry->key - delta_entry->delta),
+                                   "key effects following entry's delta");
+               if (result != VDO_SUCCESS)
                        return result;
 
                old_entry_size = delta_entry->entry_bits;

diff --git a/drivers/md/dm-vdo/indexer/index-layout.c b/drivers/md/dm-vdo/indexer/index-layout.c
index 01e0db4184aae0512ed5985eaf8556910d6fd325..349b3022f1e17955d4a2717555fb4fa7c4654010 100644 (file)
--- a/drivers/md/dm-vdo/indexer/index-layout.c
+++ b/drivers/md/dm-vdo/indexer/index-layout.c
@@ -837,8 +837,9 @@ static u64 generate_index_save_nonce(u64 volume_nonce, struct index_save_layout
        encode_u32_le(buffer, &offset, isl->save_data.version);
        encode_u32_le(buffer, &offset, 0U);
        encode_u64_le(buffer, &offset, isl->index_save.start_block);
-       ASSERT_LOG_ONLY(offset == sizeof(nonce_data),
-                       "%zu bytes encoded of %zu expected", offset, sizeof(nonce_data));
+       VDO_ASSERT_LOG_ONLY(offset == sizeof(nonce_data),
+                           "%zu bytes encoded of %zu expected",
+                           offset, sizeof(nonce_data));
        return generate_secondary_nonce(volume_nonce, buffer, sizeof(buffer));
 }
 

diff --git a/drivers/md/dm-vdo/indexer/index-session.c b/drivers/md/dm-vdo/indexer/index-session.c
index 22445dcb3fe018962fd434817b6d560af01132a7..9eae0054809547d981664842a8ca784968ccadf0 100644 (file)
--- a/drivers/md/dm-vdo/indexer/index-session.c
+++ b/drivers/md/dm-vdo/indexer/index-session.c
@@ -199,8 +199,8 @@ static void update_session_stats(struct uds_request *request)
                break;
 
        default:
-               request->status = ASSERT(false, "unknown request type: %d",
-                                        request->type);
+               request->status = VDO_ASSERT(false, "unknown request type: %d",
+                                            request->type);
        }
 }
 
@@ -402,8 +402,8 @@ static void suspend_rebuild(struct uds_index_session *session)
        case INDEX_FREEING:
        default:
                /* These cases should not happen. */
-               ASSERT_LOG_ONLY(false, "Bad load context state %u",
-                               session->load_context.status);
+               VDO_ASSERT_LOG_ONLY(false, "Bad load context state %u",
+                                   session->load_context.status);
                break;
        }
        mutex_unlock(&session->load_context.mutex);
@@ -531,8 +531,8 @@ int uds_resume_index_session(struct uds_index_session *session,
                case INDEX_FREEING:
                default:
                        /* These cases should not happen; do nothing. */
-                       ASSERT_LOG_ONLY(false, "Bad load context state %u",
-                                       session->load_context.status);
+                       VDO_ASSERT_LOG_ONLY(false, "Bad load context state %u",
+                                           session->load_context.status);
                        break;
                }
                mutex_unlock(&session->load_context.mutex);

diff --git a/drivers/md/dm-vdo/indexer/index.c b/drivers/md/dm-vdo/indexer/index.c
index 226713221105fa8d63eb32a78957738b29810362..221af95ca2a42420e013cae78591e65ff6fbff01 100644 (file)
--- a/drivers/md/dm-vdo/indexer/index.c
+++ b/drivers/md/dm-vdo/indexer/index.c
@@ -112,7 +112,7 @@ static void enqueue_barrier_messages(struct uds_index *index, u64 virtual_chapte
        for (zone = 0; zone < index->zone_count; zone++) {
                int result = launch_zone_message(message, zone, index);
 
-               ASSERT_LOG_ONLY((result == UDS_SUCCESS), "barrier message allocation");
+               VDO_ASSERT_LOG_ONLY((result == UDS_SUCCESS), "barrier message allocation");
        }
 }
 
@@ -1380,7 +1380,7 @@ void uds_enqueue_request(struct uds_request *request, enum request_stage stage)
                break;
 
        default:
-               ASSERT_LOG_ONLY(false, "invalid index stage: %d", stage);
+               VDO_ASSERT_LOG_ONLY(false, "invalid index stage: %d", stage);
                return;
        }
 

diff --git a/drivers/md/dm-vdo/indexer/volume-index.c b/drivers/md/dm-vdo/indexer/volume-index.c
index 1cc9ac4fe5108e91b29f6864a19353494fe77478..e2b0600d82b90979778f401ad7c46f06d0007470 100644 (file)
--- a/drivers/md/dm-vdo/indexer/volume-index.c
+++ b/drivers/md/dm-vdo/indexer/volume-index.c
@@ -832,10 +832,10 @@ static int start_restoring_volume_sub_index(struct volume_sub_index *sub_index,
                decode_u32_le(buffer, &offset, &header.first_list);
                decode_u32_le(buffer, &offset, &header.list_count);
 
-               result = ASSERT(offset == sizeof(buffer),
-                               "%zu bytes decoded of %zu expected", offset,
-                               sizeof(buffer));
-               if (result != UDS_SUCCESS)
+               result = VDO_ASSERT(offset == sizeof(buffer),
+                                   "%zu bytes decoded of %zu expected", offset,
+                                   sizeof(buffer));
+               if (result != VDO_SUCCESS)
                        result = UDS_CORRUPT_DATA;
 
                if (memcmp(header.magic, MAGIC_START_5, MAGIC_SIZE) != 0) {
@@ -924,10 +924,10 @@ static int start_restoring_volume_index(struct volume_index *volume_index,
                offset += MAGIC_SIZE;
                decode_u32_le(buffer, &offset, &header.sparse_sample_rate);
 
-               result = ASSERT(offset == sizeof(buffer),
-                               "%zu bytes decoded of %zu expected", offset,
-                               sizeof(buffer));
-               if (result != UDS_SUCCESS)
+               result = VDO_ASSERT(offset == sizeof(buffer),
+                                   "%zu bytes decoded of %zu expected", offset,
+                                   sizeof(buffer));
+               if (result != VDO_SUCCESS)
                        result = UDS_CORRUPT_DATA;
 
                if (memcmp(header.magic, MAGIC_START_6, MAGIC_SIZE) != 0)
@@ -1023,10 +1023,10 @@ static int start_saving_volume_sub_index(const struct volume_sub_index *sub_inde
        encode_u32_le(buffer, &offset, first_list);
        encode_u32_le(buffer, &offset, list_count);
 
-       result =  ASSERT(offset == sizeof(struct sub_index_data),
-                        "%zu bytes of config written, of %zu expected", offset,
-                        sizeof(struct sub_index_data));
-       if (result != UDS_SUCCESS)
+       result =  VDO_ASSERT(offset == sizeof(struct sub_index_data),
+                            "%zu bytes of config written, of %zu expected", offset,
+                            sizeof(struct sub_index_data));
+       if (result != VDO_SUCCESS)
                return result;
 
        result = uds_write_to_buffered_writer(buffered_writer, buffer, offset);
@@ -1066,10 +1066,10 @@ static int start_saving_volume_index(const struct volume_index *volume_index,
        memcpy(buffer, MAGIC_START_6, MAGIC_SIZE);
        offset += MAGIC_SIZE;
        encode_u32_le(buffer, &offset, volume_index->sparse_sample_rate);
-       result = ASSERT(offset == sizeof(struct volume_index_data),
-                       "%zu bytes of header written, of %zu expected", offset,
-                       sizeof(struct volume_index_data));
-       if (result != UDS_SUCCESS)
+       result = VDO_ASSERT(offset == sizeof(struct volume_index_data),
+                           "%zu bytes of header written, of %zu expected", offset,
+                           sizeof(struct volume_index_data));
+       if (result != VDO_SUCCESS)
                return result;
 
        result = uds_write_to_buffered_writer(writer, buffer, offset);

diff --git a/drivers/md/dm-vdo/indexer/volume.c b/drivers/md/dm-vdo/indexer/volume.c
index 0a4beef8ac8dd9025d2e5346219694d616b41472..701f2220d803d89009d9f860f98559f1393510fb 100644 (file)
--- a/drivers/md/dm-vdo/indexer/volume.c
+++ b/drivers/md/dm-vdo/indexer/volume.c
@@ -135,8 +135,8 @@ static void begin_pending_search(struct page_cache *cache, u32 physical_page,
        invalidate_counter.page = physical_page;
        invalidate_counter.counter++;
        set_invalidate_counter(cache, zone_number, invalidate_counter);
-       ASSERT_LOG_ONLY(search_pending(invalidate_counter),
-                       "Search is pending for zone %u", zone_number);
+       VDO_ASSERT_LOG_ONLY(search_pending(invalidate_counter),
+                           "Search is pending for zone %u", zone_number);
        /*
         * This memory barrier ensures that the write to the invalidate counter is seen by other
         * threads before this thread accesses the cached page. The corresponding read memory
@@ -158,8 +158,8 @@ static void end_pending_search(struct page_cache *cache, unsigned int zone_numbe
        smp_mb();
 
        invalidate_counter = get_invalidate_counter(cache, zone_number);
-       ASSERT_LOG_ONLY(search_pending(invalidate_counter),
-                       "Search is pending for zone %u", zone_number);
+       VDO_ASSERT_LOG_ONLY(search_pending(invalidate_counter),
+                           "Search is pending for zone %u", zone_number);
        invalidate_counter.counter++;
        set_invalidate_counter(cache, zone_number, invalidate_counter);
 }
@@ -259,8 +259,8 @@ static int put_page_in_cache(struct page_cache *cache, u32 physical_page,
        int result;
 
        /* We hold the read_threads_mutex. */
-       result = ASSERT((page->read_pending), "page to install has a pending read");
-       if (result != UDS_SUCCESS)
+       result = VDO_ASSERT((page->read_pending), "page to install has a pending read");
+       if (result != VDO_SUCCESS)
                return result;
 
        page->physical_page = physical_page;
@@ -285,8 +285,8 @@ static void cancel_page_in_cache(struct page_cache *cache, u32 physical_page,
        int result;
 
        /* We hold the read_threads_mutex. */
-       result = ASSERT((page->read_pending), "page to install has a pending read");
-       if (result != UDS_SUCCESS)
+       result = VDO_ASSERT((page->read_pending), "page to install has a pending read");
+       if (result != VDO_SUCCESS)
                return;
 
        clear_cache_page(cache, page);
@@ -889,10 +889,10 @@ int uds_search_cached_record_page(struct volume *volume, struct uds_request *req
        if (record_page_number == NO_CHAPTER_INDEX_ENTRY)
                return UDS_SUCCESS;
 
-       result = ASSERT(record_page_number < geometry->record_pages_per_chapter,
-                       "0 <= %d < %u", record_page_number,
-                       geometry->record_pages_per_chapter);
-       if (result != UDS_SUCCESS)
+       result = VDO_ASSERT(record_page_number < geometry->record_pages_per_chapter,
+                           "0 <= %d < %u", record_page_number,
+                           geometry->record_pages_per_chapter);
+       if (result != VDO_SUCCESS)
                return result;
 
        page_number = geometry->index_pages_per_chapter + record_page_number;
@@ -1501,10 +1501,10 @@ static int __must_check initialize_page_cache(struct page_cache *cache,
        cache->zone_count = zone_count;
        atomic64_set(&cache->clock, 1);
 
-       result = ASSERT((cache->cache_slots <= VOLUME_CACHE_MAX_ENTRIES),
-                       "requested cache size, %u, within limit %u",
-                       cache->cache_slots, VOLUME_CACHE_MAX_ENTRIES);
-       if (result != UDS_SUCCESS)
+       result = VDO_ASSERT((cache->cache_slots <= VOLUME_CACHE_MAX_ENTRIES),
+                           "requested cache size, %u, within limit %u",
+                           cache->cache_slots, VOLUME_CACHE_MAX_ENTRIES);
+       if (result != VDO_SUCCESS)
                return result;
 
        result = vdo_allocate(VOLUME_CACHE_MAX_QUEUED_READS, struct queued_read,

diff --git a/drivers/md/dm-vdo/permassert.c b/drivers/md/dm-vdo/permassert.c
index 3fa752ba00610931082245b397ea49381609da6e..6fe49c4b7e51763e9f9b90de235c50e53397386e 100644 (file)
--- a/drivers/md/dm-vdo/permassert.c
+++ b/drivers/md/dm-vdo/permassert.c
@@ -8,7 +8,7 @@
 #include "errors.h"
 #include "logger.h"
 
-int uds_assertion_failed(const char *expression_string, const char *file_name,
+int vdo_assertion_failed(const char *expression_string, const char *file_name,
                         int line_number, const char *format, ...)
 {
        va_list args;

diff --git a/drivers/md/dm-vdo/permassert.h b/drivers/md/dm-vdo/permassert.h
index 8774dde7927a37d3b06eeb40ed4f7dfd8adfaa87..c34f2ba650e1e67993b89644413c93932736a656 100644 (file)
--- a/drivers/md/dm-vdo/permassert.h
+++ b/drivers/md/dm-vdo/permassert.h
@@ -33,16 +33,12 @@ static inline int __must_check vdo_must_use(int value)
 /* Log a message if the expression is not true. */
 #define VDO_ASSERT_LOG_ONLY(expr, ...) __VDO_ASSERT(expr, __VA_ARGS__)
 
-/* For use by UDS */
-#define ASSERT(expr, ...) VDO_ASSERT(expr, __VA_ARGS__)
-#define ASSERT_LOG_ONLY(expr, ...) __VDO_ASSERT(expr, __VA_ARGS__)
-
 #define __VDO_ASSERT(expr, ...)                                      \
        (likely(expr) ? VDO_SUCCESS                           \
-                     : uds_assertion_failed(STRINGIFY(expr), __FILE__, __LINE__, __VA_ARGS__))
+                     : vdo_assertion_failed(STRINGIFY(expr), __FILE__, __LINE__, __VA_ARGS__))
 
 /* Log an assertion failure message. */
-int uds_assertion_failed(const char *expression_string, const char *file_name,
+int vdo_assertion_failed(const char *expression_string, const char *file_name,
                         int line_number, const char *format, ...)
        __printf(4, 5);