mirror of
https://github.com/morgan9e/systemd
synced 2026-04-14 16:37:19 +09:00
fa34123c35
To make sure everything still compiles, we add a preliminary include of forward.h to tests.h to make sure it is included in every test source file. We'll clean up the tests.h includes in a later commit. We also add a <errno.h> include to errno-list.h to keep test-errno-list.c compiling. It'll be removed again when we clean up includes in src/basic. Split out of #37344.
232 lines
8.0 KiB
C
232 lines
8.0 KiB
C
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
|
|
|
#include <malloc.h>
|
|
|
|
#include "alloc-util.h"
|
|
#include "memory-util.h"
|
|
#include "random-util.h"
|
|
#include "tests.h"
|
|
|
|
TEST(alloca) {
|
|
static const uint8_t zero[997] = { };
|
|
char *t;
|
|
|
|
t = alloca_align(17, 512);
|
|
assert_se(!((uintptr_t)t & 0xff));
|
|
memzero(t, 17);
|
|
|
|
t = alloca0_align(997, 1024);
|
|
assert_se(!((uintptr_t)t & 0x1ff));
|
|
assert_se(!memcmp(t, zero, 997));
|
|
}
|
|
|
|
TEST(GREEDY_REALLOC) {
|
|
_cleanup_free_ int *a = NULL, *b = NULL, *c = NULL;
|
|
size_t i, j, n_c = 0;
|
|
|
|
/* Give valgrind a chance to verify our realloc() operations */
|
|
|
|
for (i = 0; i < 20480; i++) {
|
|
assert_se(GREEDY_REALLOC(a, i + 1));
|
|
assert_se(MALLOC_ELEMENTSOF(a) >= i + 1);
|
|
assert_se(MALLOC_SIZEOF_SAFE(a) >= (i + 1) * sizeof(int));
|
|
a[i] = (int) i;
|
|
assert_se(GREEDY_REALLOC(a, i / 2));
|
|
assert_se(MALLOC_ELEMENTSOF(a) >= i / 2);
|
|
assert_se(MALLOC_SIZEOF_SAFE(a) >= (i / 2) * sizeof(int));
|
|
}
|
|
|
|
for (j = 0; j < i / 2; j++)
|
|
assert_se(a[j] == (int) j);
|
|
|
|
for (i = 30; i < 20480; i += 7) {
|
|
assert_se(GREEDY_REALLOC(b, i + 1));
|
|
assert_se(MALLOC_ELEMENTSOF(b) >= i + 1);
|
|
assert_se(MALLOC_SIZEOF_SAFE(b) >= (i + 1) * sizeof(int));
|
|
b[i] = (int) i;
|
|
assert_se(GREEDY_REALLOC(b, i / 2));
|
|
assert_se(MALLOC_ELEMENTSOF(b) >= i / 2);
|
|
assert_se(MALLOC_SIZEOF_SAFE(b) >= (i / 2) * sizeof(int));
|
|
}
|
|
|
|
for (j = 30; j < i / 2; j += 7)
|
|
assert_se(b[j] == (int) j);
|
|
|
|
size_t n_from = 10;
|
|
int from[n_from];
|
|
for (i = 0; i < 2048; i++) {
|
|
for (j = 0; j < n_from; j++)
|
|
from[j] = n_from * i + j;
|
|
|
|
_cleanup_free_ int *before = NULL;
|
|
size_t n_before = 0;
|
|
assert_se(GREEDY_REALLOC_APPEND(before, n_before, c, n_c));
|
|
assert_se(before);
|
|
assert_se(n_before == n_c);
|
|
assert_se(memcmp_safe(c, before, n_c) == 0);
|
|
|
|
assert_se(GREEDY_REALLOC_APPEND(c, n_c, from, n_from));
|
|
assert_se(n_c == n_before + n_from);
|
|
assert_se(MALLOC_ELEMENTSOF(c) >= n_c);
|
|
assert_se(MALLOC_SIZEOF_SAFE(c) >= n_c * sizeof(int));
|
|
assert_se(memcmp_safe(c, before, n_before) == 0);
|
|
assert_se(memcmp_safe(&c[n_before], from, n_from) == 0);
|
|
|
|
before = mfree(before);
|
|
assert_se(!before);
|
|
n_before = 0;
|
|
assert_se(GREEDY_REALLOC_APPEND(before, n_before, c, n_c));
|
|
assert_se(before);
|
|
assert_se(n_before == n_c);
|
|
assert_se(memcmp_safe(c, before, n_c) == 0);
|
|
|
|
assert_se(GREEDY_REALLOC_APPEND(c, n_c, NULL, 0));
|
|
assert_se(c);
|
|
assert_se(n_c == n_before);
|
|
assert_se(MALLOC_ELEMENTSOF(c) >= n_c);
|
|
assert_se(MALLOC_SIZEOF_SAFE(c) >= n_c * sizeof(int));
|
|
assert_se(memcmp_safe(c, before, n_c) == 0);
|
|
}
|
|
|
|
for (j = 0; j < i * n_from; j++)
|
|
assert_se(c[j] == (int) j);
|
|
}
|
|
|
|
TEST(memdup_multiply_and_greedy_realloc) {
|
|
static const int org[] = { 1, 2, 3 };
|
|
_cleanup_free_ int *dup;
|
|
size_t i;
|
|
int *p;
|
|
|
|
dup = memdup_suffix0_multiply(org, 3, sizeof(int));
|
|
assert_se(dup);
|
|
assert_se(dup[0] == 1);
|
|
assert_se(dup[1] == 2);
|
|
assert_se(dup[2] == 3);
|
|
assert_se(((uint8_t*) dup)[sizeof(int) * 3] == 0);
|
|
free(dup);
|
|
|
|
dup = memdup_multiply(org, 3, sizeof(int));
|
|
assert_se(dup);
|
|
assert_se(dup[0] == 1);
|
|
assert_se(dup[1] == 2);
|
|
assert_se(dup[2] == 3);
|
|
|
|
memzero(dup + 3, malloc_usable_size(dup) - sizeof(int) * 3);
|
|
|
|
p = dup;
|
|
assert_se(GREEDY_REALLOC0(dup, 2) == p);
|
|
|
|
p = GREEDY_REALLOC0(dup, 10);
|
|
assert_se(p == dup);
|
|
assert_se(MALLOC_ELEMENTSOF(p) >= 10);
|
|
assert_se(p[0] == 1);
|
|
assert_se(p[1] == 2);
|
|
assert_se(p[2] == 3);
|
|
for (i = 3; i < MALLOC_ELEMENTSOF(p); i++)
|
|
assert_se(p[i] == 0);
|
|
}
|
|
|
|
TEST(bool_assign) {
|
|
bool b, c, *cp = &c, d, e, f, g, h;
|
|
|
|
b = 123;
|
|
*cp = -11;
|
|
d = 0xF & 0xFF;
|
|
e = b & d;
|
|
f = 0x0;
|
|
g = cp; /* cast from pointer */
|
|
h = NULL; /* cast from pointer */
|
|
|
|
assert_se(b);
|
|
assert_se(c);
|
|
assert_se(d);
|
|
assert_se(e);
|
|
assert_se(!f);
|
|
assert_se(g);
|
|
assert_se(!h);
|
|
}
|
|
|
|
static int cleanup_counter = 0;
|
|
|
|
static void cleanup1(void *a) {
|
|
log_info("%s(%p)", __func__, a);
|
|
assert_se(++cleanup_counter == *(int*) a);
|
|
}
|
|
static void cleanup2(void *a) {
|
|
log_info("%s(%p)", __func__, a);
|
|
assert_se(++cleanup_counter == *(int*) a);
|
|
}
|
|
static void cleanup3(void *a) {
|
|
log_info("%s(%p)", __func__, a);
|
|
assert_se(++cleanup_counter == *(int*) a);
|
|
}
|
|
|
|
TEST(cleanup_order) {
|
|
_cleanup_(cleanup1) int x1 = 4, x2 = 3;
|
|
_cleanup_(cleanup3) int z = 2;
|
|
_cleanup_(cleanup2) int y = 1;
|
|
log_debug("x1: %p", &x1);
|
|
log_debug("x2: %p", &x2);
|
|
log_debug("y: %p", &y);
|
|
log_debug("z: %p", &z);
|
|
}
|
|
|
|
TEST(auto_erase_memory) {
|
|
_cleanup_(erase_and_freep) uint8_t *p1, *p2;
|
|
|
|
/* print address of p2, else e.g. clang-11 will optimize it out */
|
|
log_debug("p1: %p p2: %p", &p1, &p2);
|
|
|
|
assert_se(p1 = new(uint8_t, 4703)); /* use prime size, to ensure that there will be free space at the
|
|
* end of the allocation, since malloc() enforces alignment */
|
|
assert_se(p2 = new(uint8_t, 4703));
|
|
|
|
assert_se(crypto_random_bytes(p1, 4703) == 0);
|
|
|
|
/* before we exit the scope, do something with this data, so that the compiler won't optimize this away */
|
|
memcpy(p2, p1, 4703);
|
|
for (size_t i = 0; i < 4703; i++)
|
|
assert_se(p1[i] == p2[i]);
|
|
}
|
|
|
|
#define TEST_SIZES(f, n) \
|
|
do { \
|
|
log_debug("requested=%zu vs. malloc_size=%zu vs. gcc_size=%zu", \
|
|
n * sizeof(*f), \
|
|
malloc_usable_size(f), \
|
|
__builtin_object_size(f, 0)); \
|
|
assert_se(MALLOC_ELEMENTSOF(f) >= n); \
|
|
assert_se(MALLOC_SIZEOF_SAFE(f) >= sizeof(*f) * n); \
|
|
assert_se(malloc_usable_size(f) >= sizeof(*f) * n); \
|
|
assert_se(__builtin_object_size(f, 0) >= sizeof(*f) * n); \
|
|
} while (false)
|
|
|
|
TEST(malloc_size_safe) {
|
|
_cleanup_free_ uint32_t *f = NULL;
|
|
size_t n = 4711;
|
|
|
|
/* Let's check the macros and built-ins work on NULL and return the expected values */
|
|
assert_se(MALLOC_ELEMENTSOF((float*) NULL) == 0);
|
|
assert_se(MALLOC_SIZEOF_SAFE((float*) NULL) == 0);
|
|
assert_se(malloc_usable_size(NULL) == 0); /* as per man page, this is safe and defined */
|
|
assert_se(__builtin_object_size(NULL, 0) == SIZE_MAX); /* as per docs SIZE_MAX is returned for pointers where the size isn't known */
|
|
|
|
/* Then, let's try these macros once with constant size values, so that __builtin_object_size()
|
|
* definitely can work (as long as -O2 is used when compiling) */
|
|
assert_se(f = new(uint32_t, n));
|
|
TEST_SIZES(f, n);
|
|
|
|
/* Finally, let's use some dynamically sized allocations, to make sure this doesn't deteriorate */
|
|
for (unsigned i = 0; i < 50; i++) {
|
|
_cleanup_free_ uint64_t *g = NULL;
|
|
size_t m;
|
|
|
|
m = random_u64_range(16*1024);
|
|
assert_se(g = new(uint64_t, m));
|
|
TEST_SIZES(g, m);
|
|
}
|
|
}
|
|
|
|
DEFINE_TEST_MAIN(LOG_DEBUG);
|