Skip to content

Commit e601673

Browse files
lorelei-sakaiMike Snitzer
lorelei-sakai
authored and
Mike Snitzer
committed
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>
1 parent fc03f73 commit e601673

10 files changed

Lines changed: 107 additions & 110 deletions

File tree

‎drivers/md/dm-vdo/indexer/chapter-index.c‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -83,10 +83,10 @@ int uds_put_open_chapter_index_record(struct open_chapter_index *chapter_index,
8383
u64 chapter_number = chapter_index->virtual_chapter_number;
8484
u32 record_pages = geometry->record_pages_per_chapter;
8585

86-
result = ASSERT(page_number < record_pages,
87-
"Page number within chapter (%u) exceeds the maximum value %u",
88-
page_number, record_pages);
89-
if (result != UDS_SUCCESS)
86+
result = VDO_ASSERT(page_number < record_pages,
87+
"Page number within chapter (%u) exceeds the maximum value %u",
88+
page_number, record_pages);
89+
if (result != VDO_SUCCESS)
9090
return UDS_INVALID_ARGUMENT;
9191

9292
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,
9797
return result;
9898

9999
found = was_entry_found(&entry, address);
100-
result = ASSERT(!(found && entry.is_collision),
101-
"Chunk appears more than once in chapter %llu",
102-
(unsigned long long) chapter_number);
103-
if (result != UDS_SUCCESS)
100+
result = VDO_ASSERT(!(found && entry.is_collision),
101+
"Chunk appears more than once in chapter %llu",
102+
(unsigned long long) chapter_number);
103+
if (result != VDO_SUCCESS)
104104
return UDS_BAD_STATE;
105105

106106
found_name = (found ? name->name : NULL);

‎drivers/md/dm-vdo/indexer/config.c‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -134,10 +134,10 @@ int uds_validate_config_contents(struct buffered_reader *reader,
134134
decode_u32_le(buffer, &offset, &config.sparse_sample_rate);
135135
decode_u64_le(buffer, &offset, &config.nonce);
136136

137-
result = ASSERT(offset == sizeof(struct uds_configuration_6_02),
138-
"%zu bytes read but not decoded",
139-
sizeof(struct uds_configuration_6_02) - offset);
140-
if (result != UDS_SUCCESS)
137+
result = VDO_ASSERT(offset == sizeof(struct uds_configuration_6_02),
138+
"%zu bytes read but not decoded",
139+
sizeof(struct uds_configuration_6_02) - offset);
140+
if (result != VDO_SUCCESS)
141141
return UDS_CORRUPT_DATA;
142142

143143
if (is_version(INDEX_CONFIG_VERSION_6_02, version_buffer)) {
@@ -210,10 +210,10 @@ int uds_write_config_contents(struct buffered_writer *writer,
210210
encode_u32_le(buffer, &offset, config->sparse_sample_rate);
211211
encode_u64_le(buffer, &offset, config->nonce);
212212

213-
result = ASSERT(offset == sizeof(struct uds_configuration_6_02),
214-
"%zu bytes encoded, of %zu expected", offset,
215-
sizeof(struct uds_configuration_6_02));
216-
if (result != UDS_SUCCESS)
213+
result = VDO_ASSERT(offset == sizeof(struct uds_configuration_6_02),
214+
"%zu bytes encoded, of %zu expected", offset,
215+
sizeof(struct uds_configuration_6_02));
216+
if (result != VDO_SUCCESS)
217217
return result;
218218

219219
if (version >= 4) {

‎drivers/md/dm-vdo/indexer/delta-index.c‎

Lines changed: 45 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -856,10 +856,10 @@ int uds_start_restoring_delta_index(struct delta_index *delta_index,
856856
decode_u64_le(buffer, &offset, &header.record_count);
857857
decode_u64_le(buffer, &offset, &header.collision_count);
858858

859-
result = ASSERT(offset == sizeof(struct delta_index_header),
860-
"%zu bytes decoded of %zu expected", offset,
861-
sizeof(struct delta_index_header));
862-
if (result != UDS_SUCCESS) {
859+
result = VDO_ASSERT(offset == sizeof(struct delta_index_header),
860+
"%zu bytes decoded of %zu expected", offset,
861+
sizeof(struct delta_index_header));
862+
if (result != VDO_SUCCESS) {
863863
return uds_log_warning_strerror(result,
864864
"failed to read delta index header");
865865
}
@@ -1136,10 +1136,10 @@ int uds_start_saving_delta_index(const struct delta_index *delta_index,
11361136
encode_u64_le(buffer, &offset, delta_zone->record_count);
11371137
encode_u64_le(buffer, &offset, delta_zone->collision_count);
11381138

1139-
result = ASSERT(offset == sizeof(struct delta_index_header),
1140-
"%zu bytes encoded of %zu expected", offset,
1141-
sizeof(struct delta_index_header));
1142-
if (result != UDS_SUCCESS)
1139+
result = VDO_ASSERT(offset == sizeof(struct delta_index_header),
1140+
"%zu bytes encoded of %zu expected", offset,
1141+
sizeof(struct delta_index_header));
1142+
if (result != VDO_SUCCESS)
11431143
return result;
11441144

11451145
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)
12121212

12131213
static int assert_not_at_end(const struct delta_index_entry *delta_entry)
12141214
{
1215-
int result = ASSERT(!delta_entry->at_end,
1216-
"operation is invalid because the list entry is at the end of the delta list");
1217-
if (result != UDS_SUCCESS)
1215+
int result = VDO_ASSERT(!delta_entry->at_end,
1216+
"operation is invalid because the list entry is at the end of the delta list");
1217+
if (result != VDO_SUCCESS)
12181218
result = UDS_BAD_STATE;
12191219

12201220
return result;
@@ -1236,19 +1236,19 @@ int uds_start_delta_index_search(const struct delta_index *delta_index, u32 list
12361236
struct delta_zone *delta_zone;
12371237
struct delta_list *delta_list;
12381238

1239-
result = ASSERT((list_number < delta_index->list_count),
1240-
"Delta list number (%u) is out of range (%u)", list_number,
1241-
delta_index->list_count);
1242-
if (result != UDS_SUCCESS)
1239+
result = VDO_ASSERT((list_number < delta_index->list_count),
1240+
"Delta list number (%u) is out of range (%u)", list_number,
1241+
delta_index->list_count);
1242+
if (result != VDO_SUCCESS)
12431243
return UDS_CORRUPT_DATA;
12441244

12451245
zone_number = list_number / delta_index->lists_per_zone;
12461246
delta_zone = &delta_index->delta_zones[zone_number];
12471247
list_number -= delta_zone->first_list;
1248-
result = ASSERT((list_number < delta_zone->list_count),
1249-
"Delta list number (%u) is out of range (%u) for zone (%u)",
1250-
list_number, delta_zone->list_count, zone_number);
1251-
if (result != UDS_SUCCESS)
1248+
result = VDO_ASSERT((list_number < delta_zone->list_count),
1249+
"Delta list number (%u) is out of range (%u) for zone (%u)",
1250+
list_number, delta_zone->list_count, zone_number);
1251+
if (result != VDO_SUCCESS)
12521252
return UDS_CORRUPT_DATA;
12531253

12541254
if (delta_index->mutable) {
@@ -1362,9 +1362,9 @@ noinline int uds_next_delta_index_entry(struct delta_index_entry *delta_entry)
13621362
delta_entry->at_end = true;
13631363
delta_entry->delta = 0;
13641364
delta_entry->is_collision = false;
1365-
result = ASSERT((delta_entry->offset == size),
1366-
"next offset past end of delta list");
1367-
if (result != UDS_SUCCESS)
1365+
result = VDO_ASSERT((delta_entry->offset == size),
1366+
"next offset past end of delta list");
1367+
if (result != VDO_SUCCESS)
13681368
result = UDS_CORRUPT_DATA;
13691369

13701370
return result;
@@ -1390,8 +1390,8 @@ int uds_remember_delta_index_offset(const struct delta_index_entry *delta_entry)
13901390
int result;
13911391
struct delta_list *delta_list = delta_entry->delta_list;
13921392

1393-
result = ASSERT(!delta_entry->is_collision, "entry is not a collision");
1394-
if (result != UDS_SUCCESS)
1393+
result = VDO_ASSERT(!delta_entry->is_collision, "entry is not a collision");
1394+
if (result != VDO_SUCCESS)
13951395
return result;
13961396

13971397
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
14891489
if (result != UDS_SUCCESS)
14901490
return result;
14911491

1492-
result = ASSERT(delta_entry->is_collision,
1493-
"Cannot get full block name from a non-collision delta index entry");
1494-
if (result != UDS_SUCCESS)
1492+
result = VDO_ASSERT(delta_entry->is_collision,
1493+
"Cannot get full block name from a non-collision delta index entry");
1494+
if (result != VDO_SUCCESS)
14951495
return UDS_BAD_STATE;
14961496

14971497
get_collision_name(delta_entry, name);
@@ -1506,9 +1506,9 @@ u32 uds_get_delta_entry_value(const struct delta_index_entry *delta_entry)
15061506

15071507
static int assert_mutable_entry(const struct delta_index_entry *delta_entry)
15081508
{
1509-
int result = ASSERT((delta_entry->delta_list != &delta_entry->temp_delta_list),
1510-
"delta index is mutable");
1511-
if (result != UDS_SUCCESS)
1509+
int result = VDO_ASSERT((delta_entry->delta_list != &delta_entry->temp_delta_list),
1510+
"delta index is mutable");
1511+
if (result != VDO_SUCCESS)
15121512
result = UDS_BAD_STATE;
15131513

15141514
return result;
@@ -1527,10 +1527,10 @@ int uds_set_delta_entry_value(const struct delta_index_entry *delta_entry, u32 v
15271527
if (result != UDS_SUCCESS)
15281528
return result;
15291529

1530-
result = ASSERT((value & value_mask) == value,
1531-
"Value (%u) being set in a delta index is too large (must fit in %u bits)",
1532-
value, delta_entry->value_bits);
1533-
if (result != UDS_SUCCESS)
1530+
result = VDO_ASSERT((value & value_mask) == value,
1531+
"Value (%u) being set in a delta index is too large (must fit in %u bits)",
1532+
value, delta_entry->value_bits);
1533+
if (result != VDO_SUCCESS)
15341534
return UDS_INVALID_ARGUMENT;
15351535

15361536
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
17301730
if (result != UDS_SUCCESS)
17311731
return result;
17321732

1733-
result = ASSERT((key == delta_entry->key),
1734-
"incorrect key for collision entry");
1735-
if (result != UDS_SUCCESS)
1733+
result = VDO_ASSERT((key == delta_entry->key),
1734+
"incorrect key for collision entry");
1735+
if (result != VDO_SUCCESS)
17361736
return result;
17371737

17381738
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
17421742
result = insert_bits(delta_entry, delta_entry->entry_bits);
17431743
} else if (delta_entry->at_end) {
17441744
/* Insert a new entry at the end of the delta list. */
1745-
result = ASSERT((key >= delta_entry->key), "key past end of list");
1746-
if (result != UDS_SUCCESS)
1745+
result = VDO_ASSERT((key >= delta_entry->key), "key past end of list");
1746+
if (result != VDO_SUCCESS)
17471747
return result;
17481748

17491749
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
17601760
* Insert a new entry which requires the delta in the following entry to be
17611761
* updated.
17621762
*/
1763-
result = ASSERT((key < delta_entry->key),
1764-
"key precedes following entry");
1765-
if (result != UDS_SUCCESS)
1763+
result = VDO_ASSERT((key < delta_entry->key),
1764+
"key precedes following entry");
1765+
if (result != VDO_SUCCESS)
17661766
return result;
17671767

1768-
result = ASSERT((key >= delta_entry->key - delta_entry->delta),
1769-
"key effects following entry's delta");
1770-
if (result != UDS_SUCCESS)
1768+
result = VDO_ASSERT((key >= delta_entry->key - delta_entry->delta),
1769+
"key effects following entry's delta");
1770+
if (result != VDO_SUCCESS)
17711771
return result;
17721772

17731773
old_entry_size = delta_entry->entry_bits;

‎drivers/md/dm-vdo/indexer/index-layout.c‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -837,8 +837,9 @@ static u64 generate_index_save_nonce(u64 volume_nonce, struct index_save_layout
837837
encode_u32_le(buffer, &offset, isl->save_data.version);
838838
encode_u32_le(buffer, &offset, 0U);
839839
encode_u64_le(buffer, &offset, isl->index_save.start_block);
840-
ASSERT_LOG_ONLY(offset == sizeof(nonce_data),
841-
"%zu bytes encoded of %zu expected", offset, sizeof(nonce_data));
840+
VDO_ASSERT_LOG_ONLY(offset == sizeof(nonce_data),
841+
"%zu bytes encoded of %zu expected",
842+
offset, sizeof(nonce_data));
842843
return generate_secondary_nonce(volume_nonce, buffer, sizeof(buffer));
843844
}
844845

‎drivers/md/dm-vdo/indexer/index-session.c‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -199,8 +199,8 @@ static void update_session_stats(struct uds_request *request)
199199
break;
200200

201201
default:
202-
request->status = ASSERT(false, "unknown request type: %d",
203-
request->type);
202+
request->status = VDO_ASSERT(false, "unknown request type: %d",
203+
request->type);
204204
}
205205
}
206206

@@ -402,8 +402,8 @@ static void suspend_rebuild(struct uds_index_session *session)
402402
case INDEX_FREEING:
403403
default:
404404
/* These cases should not happen. */
405-
ASSERT_LOG_ONLY(false, "Bad load context state %u",
406-
session->load_context.status);
405+
VDO_ASSERT_LOG_ONLY(false, "Bad load context state %u",
406+
session->load_context.status);
407407
break;
408408
}
409409
mutex_unlock(&session->load_context.mutex);
@@ -531,8 +531,8 @@ int uds_resume_index_session(struct uds_index_session *session,
531531
case INDEX_FREEING:
532532
default:
533533
/* These cases should not happen; do nothing. */
534-
ASSERT_LOG_ONLY(false, "Bad load context state %u",
535-
session->load_context.status);
534+
VDO_ASSERT_LOG_ONLY(false, "Bad load context state %u",
535+
session->load_context.status);
536536
break;
537537
}
538538
mutex_unlock(&session->load_context.mutex);

‎drivers/md/dm-vdo/indexer/index.c‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -112,7 +112,7 @@ static void enqueue_barrier_messages(struct uds_index *index, u64 virtual_chapte
112112
for (zone = 0; zone < index->zone_count; zone++) {
113113
int result = launch_zone_message(message, zone, index);
114114

115-
ASSERT_LOG_ONLY((result == UDS_SUCCESS), "barrier message allocation");
115+
VDO_ASSERT_LOG_ONLY((result == UDS_SUCCESS), "barrier message allocation");
116116
}
117117
}
118118

@@ -1380,7 +1380,7 @@ void uds_enqueue_request(struct uds_request *request, enum request_stage stage)
13801380
break;
13811381

13821382
default:
1383-
ASSERT_LOG_ONLY(false, "invalid index stage: %d", stage);
1383+
VDO_ASSERT_LOG_ONLY(false, "invalid index stage: %d", stage);
13841384
return;
13851385
}
13861386

‎drivers/md/dm-vdo/indexer/volume-index.c‎

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -832,10 +832,10 @@ static int start_restoring_volume_sub_index(struct volume_sub_index *sub_index,
832832
decode_u32_le(buffer, &offset, &header.first_list);
833833
decode_u32_le(buffer, &offset, &header.list_count);
834834

835-
result = ASSERT(offset == sizeof(buffer),
836-
"%zu bytes decoded of %zu expected", offset,
837-
sizeof(buffer));
838-
if (result != UDS_SUCCESS)
835+
result = VDO_ASSERT(offset == sizeof(buffer),
836+
"%zu bytes decoded of %zu expected", offset,
837+
sizeof(buffer));
838+
if (result != VDO_SUCCESS)
839839
result = UDS_CORRUPT_DATA;
840840

841841
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,
924924
offset += MAGIC_SIZE;
925925
decode_u32_le(buffer, &offset, &header.sparse_sample_rate);
926926

927-
result = ASSERT(offset == sizeof(buffer),
928-
"%zu bytes decoded of %zu expected", offset,
929-
sizeof(buffer));
930-
if (result != UDS_SUCCESS)
927+
result = VDO_ASSERT(offset == sizeof(buffer),
928+
"%zu bytes decoded of %zu expected", offset,
929+
sizeof(buffer));
930+
if (result != VDO_SUCCESS)
931931
result = UDS_CORRUPT_DATA;
932932

933933
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
10231023
encode_u32_le(buffer, &offset, first_list);
10241024
encode_u32_le(buffer, &offset, list_count);
10251025

1026-
result = ASSERT(offset == sizeof(struct sub_index_data),
1027-
"%zu bytes of config written, of %zu expected", offset,
1028-
sizeof(struct sub_index_data));
1029-
if (result != UDS_SUCCESS)
1026+
result = VDO_ASSERT(offset == sizeof(struct sub_index_data),
1027+
"%zu bytes of config written, of %zu expected", offset,
1028+
sizeof(struct sub_index_data));
1029+
if (result != VDO_SUCCESS)
10301030
return result;
10311031

10321032
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,
10661066
memcpy(buffer, MAGIC_START_6, MAGIC_SIZE);
10671067
offset += MAGIC_SIZE;
10681068
encode_u32_le(buffer, &offset, volume_index->sparse_sample_rate);
1069-
result = ASSERT(offset == sizeof(struct volume_index_data),
1070-
"%zu bytes of header written, of %zu expected", offset,
1071-
sizeof(struct volume_index_data));
1072-
if (result != UDS_SUCCESS)
1069+
result = VDO_ASSERT(offset == sizeof(struct volume_index_data),
1070+
"%zu bytes of header written, of %zu expected", offset,
1071+
sizeof(struct volume_index_data));
1072+
if (result != VDO_SUCCESS)
10731073
return result;
10741074

10751075
result = uds_write_to_buffered_writer(writer, buffer, offset);

0 commit comments

Comments
 (0)