Skip to content

Commit b8eb2a4

Browse files
ashleypittmanashleypittman
authored
DAOS-623 gurt: Make daos error numbers a named enum and remove dead code. (#12312)
Newer versions of compilers can perform type checking of enums so put daos error numbers in a named enum. Remove some dead code for adding error numbers dynamically. Signed-off-by: Ashley Pittman <[email protected]>
1 parent 1b54d9e commit b8eb2a4

File tree

3 files changed

+66
-314
lines changed

3 files changed

+66
-314
lines changed

‎src/gurt/errno.c

+30-90
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* (C) Copyright 2016-2021 Intel Corporation.
2+
* (C) Copyright 2016-2023 Intel Corporation.
33
*
44
* SPDX-License-Identifier: BSD-2-Clause-Patent
55
*/
@@ -16,127 +16,67 @@
1616
static D_LIST_HEAD(g_error_reg_list);
1717

1818
struct d_error_reg {
19-
d_list_t er_link;
20-
int er_base;
21-
int er_limit;
22-
const char * const *er_strings;
23-
const char * const *er_strerror;
24-
bool er_alloc;
19+
d_list_t er_link;
20+
int er_base;
21+
int er_limit;
22+
const char *const *er_strings;
23+
const char *const *er_strerror;
2524
};
2625

27-
#define D_DEFINE_COMP_ERRSTR(name, base) \
28-
static const char * const g_##name##_errstr[] = { \
29-
D_FOREACH_##name##_ERR(D_DEFINE_ERRSTR) \
30-
}; \
31-
static const char * const g_##name##_errstr_desc[] = { \
32-
D_FOREACH_##name##_ERR(D_DEFINE_ERRDESC) \
33-
}; \
34-
D_CASSERT((sizeof(g_##name##_errstr) / \
35-
sizeof(g_##name##_errstr[0])) == \
36-
((DER_ERR_##name##_LIMIT - DER_ERR_##name##_BASE - 1)), \
37-
#name "is not contiguous"); \
38-
static struct d_error_reg g_##name##_errreg = { \
39-
.er_base = DER_ERR_##name##_BASE, \
40-
.er_limit = DER_ERR_##name##_LIMIT, \
41-
.er_strings = g_##name##_errstr, \
42-
.er_strerror = g_##name##_errstr_desc, \
43-
.er_alloc = false, \
26+
#define D_DEFINE_COMP_ERRSTR(name, base) \
27+
static const char *const g_##name##_errstr[] = {D_FOREACH_##name##_ERR(D_DEFINE_ERRSTR)}; \
28+
static const char *const g_##name##_errstr_desc[] = { \
29+
D_FOREACH_##name##_ERR(D_DEFINE_ERRDESC)}; \
30+
D_CASSERT((sizeof(g_##name##_errstr) / sizeof(g_##name##_errstr[0])) == \
31+
((DER_ERR_##name##_LIMIT - DER_ERR_##name##_BASE - 1)), \
32+
#name "is not contiguous"); \
33+
static struct d_error_reg g_##name##_errreg = { \
34+
.er_base = DER_ERR_##name##_BASE, \
35+
.er_limit = DER_ERR_##name##_LIMIT, \
36+
.er_strings = g_##name##_errstr, \
37+
.er_strerror = g_##name##_errstr_desc, \
4438
};
4539

46-
4740
D_FOREACH_ERR_RANGE(D_DEFINE_COMP_ERRSTR)
4841

49-
#define D_CHECK_RANGE(name, base) \
50-
do { \
51-
int first = DER_ERR_##name##_BASE + 1; \
52-
if (rc <= DER_ERR_##name##_BASE || \
53-
rc >= DER_ERR_##name##_LIMIT) \
54-
break; \
55-
return g_##name##_errstr[rc - first]; \
56-
} while (0);
57-
58-
#define D_ADD_LIST(name, base) \
59-
d_list_add_tail(&g_##name##_errreg.er_link, &g_error_reg_list);
60-
61-
#define D_ABS(value) ((value) > 0 ? (value) : (-value))
42+
#define D_ADD_LIST(name, base) d_list_add_tail(&g_##name##_errreg.er_link, &g_error_reg_list);
6243

63-
#define D_ERR_BUF_SIZE 32
44+
#define D_ERR_BUF_SIZE 32
6445

6546
static __attribute__((constructor)) void
6647
d_err_init(void)
6748
{
6849
D_FOREACH_ERR_RANGE(D_ADD_LIST)
6950
}
7051

71-
const char *d_errstr(int rc)
52+
const char *
53+
d_errstr(int errnum)
7254
{
73-
struct d_error_reg *entry;
55+
struct d_error_reg *entry;
7456

75-
if (rc == 0)
57+
if (errnum == 0)
7658
return "DER_SUCCESS";
7759

78-
if (rc > 0)
60+
if (errnum > 0)
7961
goto out;
8062

81-
rc = D_ABS(rc);
63+
errnum = -errnum;
8264

8365
d_list_for_each_entry(entry, &g_error_reg_list, er_link) {
84-
if (rc <= entry->er_base || rc >= entry->er_limit)
66+
if (errnum <= entry->er_base || errnum >= entry->er_limit)
8567
continue;
86-
return entry->er_strings[rc - entry->er_base - 1];
68+
return entry->er_strings[errnum - entry->er_base - 1];
8769
}
8870

8971
out:
9072
return "DER_UNKNOWN";
9173
}
9274

93-
int
94-
d_errno_register_range(int start, int end, const char * const *error_strings,
95-
const char * const *strerror)
96-
{
97-
struct d_error_reg *entry;
98-
99-
D_ALLOC_PTR(entry);
100-
if (entry == NULL) {
101-
D_ERROR("No memory to register error code range %d - %d\n",
102-
start, end);
103-
/* Not fatal. It just means we get DER_UNKNOWN from d_errstr */
104-
return -DER_NOMEM;
105-
}
106-
107-
entry->er_base = start;
108-
entry->er_limit = end;
109-
entry->er_strings = error_strings;
110-
entry->er_strerror = strerror;
111-
entry->er_alloc = true;
112-
d_list_add(&entry->er_link, &g_error_reg_list);
113-
114-
return 0;
115-
}
116-
117-
void
118-
d_errno_deregister_range(int start)
119-
{
120-
struct d_error_reg *entry;
121-
122-
d_list_for_each_entry(entry, &g_error_reg_list, er_link) {
123-
if (!entry->er_alloc)
124-
break;
125-
if (entry->er_base == start) {
126-
d_list_del(&entry->er_link);
127-
D_FREE(entry);
128-
return;
129-
}
130-
}
131-
D_ERROR("Attempted to deregister non-existent error range from %d\n",
132-
start);
133-
}
134-
13575
const char *
13676
d_errdesc(int errnum)
13777
{
13878
struct d_error_reg *entry;
139-
static char buf[D_ERR_BUF_SIZE];
79+
static char buf[D_ERR_BUF_SIZE];
14080

14181
if (errnum == DER_SUCCESS)
14282
return "Success";
@@ -149,7 +89,7 @@ d_errdesc(int errnum)
14989
if (errnum > 0)
15090
goto out;
15191

152-
errnum = D_ABS(errnum);
92+
errnum = -errnum;
15393

15494
d_list_for_each_entry(entry, &g_error_reg_list, er_link) {
15595
if (errnum <= entry->er_base || errnum >= entry->er_limit)

‎src/gurt/tests/test_gurt.c

+17-163
Original file line numberDiff line numberDiff line change
@@ -95,150 +95,6 @@ test_time(void **state)
9595
assert_int_equal(timeleft, 0);
9696
}
9797

98-
#define D_CHECK_STRLIMITS(name, base) \
99-
do { \
100-
value = d_errstr(-DER_ERR_##name##_BASE); \
101-
assert_string_equal(value, "DER_UNKNOWN"); \
102-
value = d_errstr(-DER_ERR_##name##_LIMIT); \
103-
assert_string_equal(value, "DER_UNKNOWN"); \
104-
value = d_errstr(DER_ERR_##name##_BASE); \
105-
assert_string_equal(value, "DER_UNKNOWN"); \
106-
value = d_errstr(DER_ERR_##name##_LIMIT); \
107-
assert_string_equal(value, "DER_UNKNOWN"); \
108-
} while (0);
109-
110-
#define D_CHECK_ERR_IN_RANGE(name, value, errstr) \
111-
do { \
112-
const char *str = d_errstr(-name); \
113-
assert_string_not_equal(str, "DER_UNKNOWN"); \
114-
} while (0);
115-
116-
#define D_CHECK_IN_RANGE(name, base) \
117-
D_FOREACH_##name##_ERR(D_CHECK_ERR_IN_RANGE)
118-
119-
#define D_FOREACH_CUSTOM1_ERR(ACTION) \
120-
ACTION(DER_CUSTOM1, (DER_ERR_CUSTOM1_BASE + 1), \
121-
"Custom error description 1") \
122-
ACTION(DER_CUSTOM2, (DER_ERR_CUSTOM1_BASE + 2), \
123-
"Custom error description 2")
124-
125-
#define D_FOREACH_CUSTOM2_ERR(ACTION) \
126-
ACTION(DER_CUSTOM3, (DER_ERR_CUSTOM2_BASE + 1), \
127-
"Custom error description 3") \
128-
ACTION(DER_CUSTOM4, (DER_ERR_CUSTOM2_BASE + 2), \
129-
"Custom error description 4")
130-
131-
D_DEFINE_RANGE_ERRNO(CUSTOM1, 2000)
132-
D_DEFINE_RANGE_ERRNO(CUSTOM2, 3000)
133-
134-
D_DEFINE_RANGE_ERRSTR(CUSTOM1)
135-
D_DEFINE_RANGE_ERRSTR(CUSTOM2)
136-
137-
void test_d_errstr_v2(void **state)
138-
{
139-
const char *value;
140-
int rc;
141-
142-
rc = D_REGISTER_RANGE(CUSTOM1);
143-
assert_int_equal(rc, 0);
144-
145-
rc = D_REGISTER_RANGE(CUSTOM2);
146-
assert_int_equal(rc, 0);
147-
148-
value = d_errstr(-DER_CUSTOM1);
149-
assert_string_equal(value, "DER_CUSTOM1");
150-
151-
value = d_errstr(-DER_CUSTOM2);
152-
assert_string_equal(value, "DER_CUSTOM2");
153-
154-
value = d_errstr(-DER_CUSTOM3);
155-
assert_string_equal(value, "DER_CUSTOM3");
156-
157-
value = d_errstr(-DER_CUSTOM4);
158-
assert_string_equal(value, "DER_CUSTOM4");
159-
160-
D_DEREGISTER_RANGE(CUSTOM1);
161-
D_DEREGISTER_RANGE(CUSTOM2);
162-
163-
/* CUSTOM1 and CUSTOM2 overlap with DAOS codes */
164-
value = d_errstr(-DER_CUSTOM1);
165-
assert_string_not_equal(value, "DER_CUSTOM1");
166-
assert_string_not_equal(value, "DER_UNKNOWN");
167-
168-
value = d_errstr(-DER_CUSTOM2);
169-
assert_string_not_equal(value, "DER_CUSTOM2");
170-
assert_string_not_equal(value, "DER_UNKNOWN");
171-
172-
value = d_errstr(-DER_CUSTOM3);
173-
assert_string_equal(value, "DER_UNKNOWN");
174-
175-
value = d_errstr(-DER_CUSTOM4);
176-
assert_string_equal(value, "DER_UNKNOWN");
177-
}
178-
179-
void test_d_errstr(void **state)
180-
{
181-
const char *value;
182-
183-
D_FOREACH_ERR_RANGE(D_CHECK_STRLIMITS)
184-
D_FOREACH_ERR_RANGE(D_CHECK_IN_RANGE)
185-
value = d_errstr(-DER_INVAL);
186-
assert_string_equal(value, "DER_INVAL");
187-
value = d_errstr(DER_INVAL);
188-
assert_string_equal(value, "DER_UNKNOWN");
189-
value = d_errstr(5000000);
190-
assert_string_equal(value, "DER_UNKNOWN");
191-
value = d_errstr(3);
192-
assert_string_equal(value, "DER_UNKNOWN");
193-
value = d_errstr(-3);
194-
assert_string_equal(value, "DER_UNKNOWN");
195-
value = d_errstr(0);
196-
assert_string_equal(value, "DER_SUCCESS");
197-
value = d_errstr(DER_SUCCESS);
198-
assert_string_equal(value, "DER_SUCCESS");
199-
value = d_errstr(-DER_IVCB_FORWARD);
200-
assert_string_equal(value, "DER_IVCB_FORWARD");
201-
#ifdef TEST_OLD_ERROR
202-
value = d_errstr(-DER_FREE_MEM);
203-
assert_string_equal(value, "DER_FREE_MEM");
204-
value = d_errstr(-DER_STALE);
205-
assert_string_equal(value, "DER_STALE");
206-
(void)test_d_errstr_v2;
207-
#else
208-
test_d_errstr_v2(state);
209-
#endif
210-
}
211-
212-
void test_d_errdesc(void **state)
213-
{
214-
const char *value;
215-
216-
value = d_errdesc(-DER_INVAL);
217-
assert_string_equal(value, "Invalid parameters");
218-
value = d_errdesc(DER_INVAL);
219-
assert_string_equal(value, "Unknown error code 1003");
220-
value = d_errdesc(5000000);
221-
assert_string_equal(value, "Unknown error code 5000000");
222-
value = d_errdesc(3);
223-
assert_string_equal(value, "Unknown error code 3");
224-
value = d_errdesc(-3);
225-
assert_string_equal(value, "Unknown error code -3");
226-
value = d_errdesc(0);
227-
assert_string_equal(value, "Success");
228-
value = d_errdesc(DER_SUCCESS);
229-
assert_string_equal(value, "Success");
230-
value = d_errdesc(-DER_NOTDIR);
231-
assert_string_equal(value, "Not a directory");
232-
value = d_errdesc(-2028);
233-
assert_string_equal(value, "TX is not committed");
234-
value = d_errdesc(-2100);
235-
assert_string_equal(value, "Unknown error code -2100");
236-
value = d_errdesc(-DER_UNKNOWN);
237-
assert_string_equal(value, "Unknown error");
238-
value = d_errdesc(-501001);
239-
assert_string_equal(value, "Unknown error code -501001");
240-
}
241-
24298
static int
24399
init_tests(void **state)
244100
{
@@ -2149,25 +2005,23 @@ test_d_rank_list_dup_sort_uniq(void **state)
21492005
int
21502006
main(int argc, char **argv)
21512007
{
2152-
const struct CMUnitTest tests[] = {
2153-
cmocka_unit_test(test_time),
2154-
cmocka_unit_test(test_d_errstr),
2155-
cmocka_unit_test(test_d_errdesc),
2156-
cmocka_unit_test(test_gurt_list),
2157-
cmocka_unit_test(test_gurt_hlist),
2158-
cmocka_unit_test(test_binheap),
2159-
cmocka_unit_test(test_log),
2160-
cmocka_unit_test(test_gurt_hash_empty),
2161-
cmocka_unit_test(test_gurt_hash_insert_lookup_delete),
2162-
cmocka_unit_test(test_gurt_hash_decref),
2163-
cmocka_unit_test(test_gurt_alloc),
2164-
cmocka_unit_test(test_gurt_hash_parallel_same_operations),
2165-
cmocka_unit_test(test_gurt_hash_parallel_different_operations),
2166-
cmocka_unit_test(test_gurt_hash_parallel_refcounting),
2167-
cmocka_unit_test(test_gurt_atomic),
2168-
cmocka_unit_test(test_gurt_string_buffer),
2169-
cmocka_unit_test(test_d_rank_list_dup_sort_uniq),
2170-
cmocka_unit_test(test_hash_perf),
2008+
const struct CMUnitTest tests[] = {
2009+
cmocka_unit_test(test_time),
2010+
cmocka_unit_test(test_gurt_list),
2011+
cmocka_unit_test(test_gurt_hlist),
2012+
cmocka_unit_test(test_binheap),
2013+
cmocka_unit_test(test_log),
2014+
cmocka_unit_test(test_gurt_hash_empty),
2015+
cmocka_unit_test(test_gurt_hash_insert_lookup_delete),
2016+
cmocka_unit_test(test_gurt_hash_decref),
2017+
cmocka_unit_test(test_gurt_alloc),
2018+
cmocka_unit_test(test_gurt_hash_parallel_same_operations),
2019+
cmocka_unit_test(test_gurt_hash_parallel_different_operations),
2020+
cmocka_unit_test(test_gurt_hash_parallel_refcounting),
2021+
cmocka_unit_test(test_gurt_atomic),
2022+
cmocka_unit_test(test_gurt_string_buffer),
2023+
cmocka_unit_test(test_d_rank_list_dup_sort_uniq),
2024+
cmocka_unit_test(test_hash_perf),
21712025
};
21722026

21732027
d_register_alt_assert(mock_assert);

0 commit comments

Comments
 (0)