SymbX/systemd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test: convert sd-journal tests to the new test macros

Browse Source 
So we can, hopefully, debug issues like #40551 more easily.
This commit is contained in:
Frantisek Sumsal
2026-04-20 19:43:26 +01:00
committed by Luca Boccassi
parent 8ad4adcb6f
commit 1b787f20cf
12 changed files with 297 additions and 332 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libsystemd/sd-journal/test-catalog.c
+34 -43
View File
@@ -27,11 +27,10 @@ static OrderedHashmap* test_import(const char* contents, ssize_t size, int code)
if (size < 0)
size = strlen(contents);
fd = mkostemp_safe(name);
assert_se(fd >= 0);
assert_se(write(fd, contents, size) == size);
ASSERT_OK(fd = mkostemp_safe(name));
ASSERT_EQ(write(fd, contents, size), size);
assert_se(catalog_import_file(&h, fd, name) == code);
ASSERT_EQ(catalog_import_file(&h, fd, name), code);
return h;
}
@@ -40,7 +39,7 @@ static void test_catalog_import_invalid(void) {
_cleanup_ordered_hashmap_free_ OrderedHashmap *h = NULL;
h = test_import("xxx", -1, -EINVAL);
assert_se(ordered_hashmap_isempty(h));
ASSERT_TRUE(ordered_hashmap_isempty(h));
}
static void test_catalog_import_badid(void) {
@@ -68,12 +67,12 @@ static void test_catalog_import_one(void) {
"payload\n";
h = test_import(input, -1, 0);
assert_se(ordered_hashmap_size(h) == 1);
ASSERT_EQ(ordered_hashmap_size(h), 1u);
ORDERED_HASHMAP_FOREACH(payload, h) {
printf("expect: %s\n", expect);
printf("actual: %s\n", payload);
assert_se(streq(expect, payload));
ASSERT_STREQ(expect, payload);
}
}
@@ -103,10 +102,10 @@ static void test_catalog_import_merge(void) {
"override payload\n";
h = test_import(input, -1, 0);
assert_se(ordered_hashmap_size(h) == 1);
ASSERT_EQ(ordered_hashmap_size(h), 1u);
ORDERED_HASHMAP_FOREACH(payload, h)
assert_se(streq(combined, payload));
ASSERT_STREQ(combined, payload);
}
static void test_catalog_import_merge_no_body(void) {
@@ -134,62 +133,56 @@ static void test_catalog_import_merge_no_body(void) {
"payload\n";
h = test_import(input, -1, 0);
assert_se(ordered_hashmap_size(h) == 1);
ASSERT_EQ(ordered_hashmap_size(h), 1u);
ORDERED_HASHMAP_FOREACH(payload, h)
assert_se(streq(combined, payload));
ASSERT_STREQ(combined, payload);
}
static void test_catalog_update(const char *database) {
int r;
/* Test what happens if there are no files. */
r = catalog_update(database, NULL, NULL);
assert_se(r == 0);
ASSERT_OK_ZERO(catalog_update(database, NULL, NULL));
/* Test what happens if there are no files in the directory. */
r = catalog_update(database, NULL, no_catalog_dirs);
assert_se(r == 0);
ASSERT_OK_ZERO(catalog_update(database, NULL, no_catalog_dirs));
/* Make sure that we at least have some files loaded or the
* catalog_list below will fail. */
r = catalog_update(database, NULL, (const char * const *) catalog_dirs);
assert_se(r == 0);
ASSERT_OK_ZERO(catalog_update(database, NULL, (const char * const *) catalog_dirs));
}
static void test_catalog_file_lang(void) {
_cleanup_free_ char *lang = NULL, *lang2 = NULL, *lang3 = NULL, *lang4 = NULL;
assert_se(catalog_file_lang("systemd.de_DE.catalog", &lang) == 1);
assert_se(streq(lang, "de_DE"));
ASSERT_EQ(catalog_file_lang("systemd.de_DE.catalog", &lang), 1);
ASSERT_STREQ(lang, "de_DE");
assert_se(catalog_file_lang("systemd..catalog", &lang2) == 0);
assert_se(lang2 == NULL);
ASSERT_OK_ZERO(catalog_file_lang("systemd..catalog", &lang2));
ASSERT_NULL(lang2);
assert_se(catalog_file_lang("systemd.fr.catalog", &lang2) == 1);
assert_se(streq(lang2, "fr"));
ASSERT_EQ(catalog_file_lang("systemd.fr.catalog", &lang2), 1);
ASSERT_STREQ(lang2, "fr");
assert_se(catalog_file_lang("systemd.fr.catalog.gz", &lang3) == 0);
assert_se(lang3 == NULL);
ASSERT_OK_ZERO(catalog_file_lang("systemd.fr.catalog.gz", &lang3));
ASSERT_NULL(lang3);
assert_se(catalog_file_lang("systemd.01234567890123456789012345678901.catalog", &lang3) == 0);
assert_se(lang3 == NULL);
ASSERT_OK_ZERO(catalog_file_lang("systemd.01234567890123456789012345678901.catalog", &lang3));
ASSERT_NULL(lang3);
assert_se(catalog_file_lang("systemd.0123456789012345678901234567890.catalog", &lang3) == 1);
assert_se(streq(lang3, "0123456789012345678901234567890"));
ASSERT_EQ(catalog_file_lang("systemd.0123456789012345678901234567890.catalog", &lang3), 1);
ASSERT_STREQ(lang3, "0123456789012345678901234567890");
assert_se(catalog_file_lang("/x/y/systemd.catalog", &lang4) == 0);
assert_se(lang4 == NULL);
ASSERT_OK_ZERO(catalog_file_lang("/x/y/systemd.catalog", &lang4));
ASSERT_NULL(lang4);
assert_se(catalog_file_lang("/x/y/systemd.ru_RU.catalog", &lang4) == 1);
assert_se(streq(lang4, "ru_RU"));
ASSERT_EQ(catalog_file_lang("/x/y/systemd.ru_RU.catalog", &lang4), 1);
ASSERT_STREQ(lang4, "ru_RU");
}
int main(int argc, char *argv[]) {
_cleanup_(unlink_tempfilep) char database[] = "/tmp/test-catalog.XXXXXX";
_cleanup_close_ int fd = -EBADF;
_cleanup_free_ char *text = NULL;
int r;
setlocale(LC_ALL, "de_DE.UTF-8");
@@ -199,7 +192,7 @@ int main(int argc, char *argv[]) {
* If it is not, e.g. installed by systemd-tests package, then use installed catalogs. */
catalog_dirs = STRV_MAKE(get_catalog_dir());
assert_se(access(catalog_dirs[0], F_OK) >= 0);
ASSERT_OK_ERRNO(access(catalog_dirs[0], F_OK));
log_notice("Using catalog directory '%s'", catalog_dirs[0]);
test_catalog_file_lang();
@@ -210,17 +203,15 @@ int main(int argc, char *argv[]) {
test_catalog_import_merge();
test_catalog_import_merge_no_body();
assert_se((fd = mkostemp_safe(database)) >= 0);
ASSERT_OK(fd = mkostemp_safe(database));
test_catalog_update(database);
r = catalog_list(NULL, database, true);
assert_se(r >= 0);
ASSERT_OK(catalog_list(NULL, database, true));
r = catalog_list(NULL, database, false);
assert_se(r >= 0);
ASSERT_OK(catalog_list(NULL, database, false));
assert_se(catalog_get(database, SD_MESSAGE_COREDUMP, &text) >= 0);
ASSERT_OK(catalog_get(database, SD_MESSAGE_COREDUMP, &text));
printf(">>>%s<<<\n", text);
return 0;
src/libsystemd/sd-journal/test-journal-append.c
+10 -13
View File
@@ -45,15 +45,14 @@ static int journal_corrupt_and_append(uint64_t start_offset, uint64_t step) {
uint64_t start, end;
int r;
mmap_cache = mmap_cache_new();
assert_se(mmap_cache);
ASSERT_NOT_NULL(mmap_cache = mmap_cache_new());
/* journal_file_open() requires a valid machine id */
if (sd_id128_get_machine(NULL) < 0)
return log_tests_skipped("No valid machine ID found");
assert_se(mkdtemp_malloc("/tmp/journal-append-XXXXXX", &tempdir) >= 0);
assert_se(chdir(tempdir) >= 0);
ASSERT_OK(mkdtemp_malloc("/tmp/journal-append-XXXXXX", &tempdir));
ASSERT_OK_ERRNO(chdir(tempdir));
(void) chattr_path(tempdir, FS_NOCOW_FL, FS_NOCOW_FL);
log_debug("Opening journal %s/system.journal", tempdir);
@@ -72,13 +71,13 @@ static int journal_corrupt_and_append(uint64_t start_offset, uint64_t step) {
if (r < 0)
return log_error_errno(r, "Failed to open the journal: %m");
assert_se(mj);
ASSERT_NOT_NULL(mj);
/* Add a couple of initial messages */
for (int i = 0; i < 10; i++) {
_cleanup_free_ char *message = NULL;
assert_se(asprintf(&message, "MESSAGE=Initial message %d", i) >= 0);
ASSERT_OK_ERRNO(asprintf(&message, "MESSAGE=Initial message %d", i));
r = journal_append_message(mj, message);
if (r < 0)
return log_error_errno(r, "Failed to write to the journal: %m");
@@ -101,11 +100,9 @@ static int journal_corrupt_and_append(uint64_t start_offset, uint64_t step) {
uint8_t b;
/* Flip a bit in the journal file */
r = pread(mj->fd, &b, 1, offset);
assert_se(r == 1);
ASSERT_EQ(pread(mj->fd, &b, 1, offset), 1);
b |= 0x1;
r = pwrite(mj->fd, &b, 1, offset);
assert_se(r == 1);
ASSERT_EQ(pwrite(mj->fd, &b, 1, offset), 1);
/* Close and reopen the journal to flush all caches and remap
* the corrupted journal */
@@ -130,7 +127,7 @@ static int journal_corrupt_and_append(uint64_t start_offset, uint64_t step) {
}
/* Try to write something to the (possibly corrupted) journal */
assert_se(asprintf(&message, "MESSAGE=Hello world %" PRIu64, offset) >= 0);
ASSERT_OK_ERRNO(asprintf(&message, "MESSAGE=Hello world %" PRIu64, offset));
r = journal_append_message(mj, message);
if (r < 0) {
/* We care only about crashes or sanitizer errors,
@@ -173,8 +170,8 @@ int main(int argc, char *argv[]) {
{}
};
assert_se(argc >= 0);
assert_se(argv);
ASSERT_GE(argc, 0);
ASSERT_NOT_NULL(argv);
while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
switch (c) {
src/libsystemd/sd-journal/test-journal-enum.c
+4 -4
View File
@@ -12,16 +12,16 @@ int main(int argc, char *argv[]) {
test_setup_logging(LOG_DEBUG);
assert_se(sd_journal_open(&j, SD_JOURNAL_LOCAL_ONLY | SD_JOURNAL_ASSUME_IMMUTABLE) >= 0);
ASSERT_OK(sd_journal_open(&j, SD_JOURNAL_LOCAL_ONLY | SD_JOURNAL_ASSUME_IMMUTABLE));
assert_se(sd_journal_add_match(j, "_TRANSPORT=syslog", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "_UID=0", SIZE_MAX) >= 0);
ASSERT_OK(sd_journal_add_match(j, "_TRANSPORT=syslog", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "_UID=0", SIZE_MAX));
SD_JOURNAL_FOREACH_BACKWARDS(j) {
const void *d;
size_t l;
assert_se(sd_journal_get_data(j, "MESSAGE", &d, &l) >= 0);
ASSERT_OK(sd_journal_get_data(j, "MESSAGE", &d, &l));
printf("%.*s\n", (int) l, (char*) d);
src/libsystemd/sd-journal/test-journal-file.c
+3 -3
View File
@@ -16,11 +16,11 @@ static void test_journal_file_parse_uid_from_filename_simple(
log_info("testing %s", path);
r = journal_file_parse_uid_from_filename(path, &uid);
assert_se(r == expected_error);
ASSERT_EQ(r, expected_error);
if (r < 0)
assert_se(uid == UID_INVALID);
ASSERT_EQ(uid, UID_INVALID);
else
assert_se(uid == expected_uid);
ASSERT_EQ(uid, expected_uid);
}
TEST(journal_file_parse_uid_from_filename) {
src/libsystemd/sd-journal/test-journal-flush.c
+23 -24
View File
@@ -108,14 +108,13 @@ static void test_journal_flush_one(int argc, char *argv[]) {
unsigned n, limit;
int r;
assert_se(m = mmap_cache_new());
assert_se(mkdtemp_malloc("/var/tmp/test-journal-flush.XXXXXX", &dn) >= 0);
ASSERT_NOT_NULL(m = mmap_cache_new());
ASSERT_OK(mkdtemp_malloc("/var/tmp/test-journal-flush.XXXXXX", &dn));
(void) chattr_path(dn, FS_NOCOW_FL, FS_NOCOW_FL);
assert_se(fn = path_join(dn, "test.journal"));
ASSERT_NOT_NULL(fn = path_join(dn, "test.journal"));
r = journal_file_open(-EBADF, fn, O_CREAT|O_RDWR, 0, 0644, 0, NULL, m, NULL, &new_journal);
assert_se(r >= 0);
ASSERT_OK(journal_file_open(-EBADF, fn, O_CREAT|O_RDWR, 0, 0644, 0, NULL, m, NULL, &new_journal));
if (argc > 1)
r = sd_journal_open_files(&j, (const char **) strv_skip(argv, 1), SD_JOURNAL_ASSUME_IMMUTABLE);
@@ -124,7 +123,7 @@ static void test_journal_flush_one(int argc, char *argv[]) {
if (r < 0)
r = sd_journal_open(&j, SD_JOURNAL_ASSUME_IMMUTABLE);
}
assert_se(r == 0);
ASSERT_OK_ZERO(r);
sd_journal_set_data_threshold(j, 0);
@@ -135,21 +134,21 @@ static void test_journal_flush_one(int argc, char *argv[]) {
JournalFile *f;
f = j->current_file;
assert_se(f && f->current_offset > 0);
ASSERT_TRUE(f && f->current_offset > 0);
r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
if (r < 0)
log_error_errno(r, "journal_file_move_to_object failed: %m");
assert_se(r >= 0);
ASSERT_OK(r);
r = journal_file_copy_entry(f, new_journal, o, f->current_offset, NULL, NULL);
if (r < 0)
log_warning_errno(r, "journal_file_copy_entry failed: %m");
assert_se(r >= 0 ||
IN_SET(r, -EBADMSG, /* corrupted file */
-EPROTONOSUPPORT, /* unsupported compression */
-EIO, /* file rotated */
-EREMCHG)); /* clock rollback */
ASSERT_TRUE(r >= 0 ||
IN_SET(r, -EBADMSG, /* corrupted file */
-EPROTONOSUPPORT, /* unsupported compression */
-EIO, /* file rotated */
-EREMCHG)); /* clock rollback */
if (++n >= limit)
break;
@@ -160,43 +159,43 @@ static void test_journal_flush_one(int argc, char *argv[]) {
/* Open the new journal before archiving and offlining the file. */
sd_journal_close(j);
assert_se(sd_journal_open_directory(&j, dn, SD_JOURNAL_ASSUME_IMMUTABLE) >= 0);
ASSERT_OK(sd_journal_open_directory(&j, dn, SD_JOURNAL_ASSUME_IMMUTABLE));
/* Read the online journal. */
assert_se(sd_journal_seek_tail(j) >= 0);
assert_se(sd_journal_step_one(j, 0) > 0);
ASSERT_OK(sd_journal_seek_tail(j));
ASSERT_OK_POSITIVE(sd_journal_step_one(j, 0));
printf("current_journal: %s (%i)\n", j->current_file->path, j->current_file->fd);
assert_se(show_journal_entry(stdout, j, OUTPUT_EXPORT, 0, 0, NULL, NULL, NULL, &(dual_timestamp) {}, &(sd_id128_t) {}) >= 0);
ASSERT_OK(show_journal_entry(stdout, j, OUTPUT_EXPORT, 0, 0, NULL, NULL, NULL, &(dual_timestamp) {}, &(sd_id128_t) {}));
uint64_t p;
assert_se(journal_file_tail_end_by_mmap(j->current_file, &p) >= 0);
ASSERT_OK(journal_file_tail_end_by_mmap(j->current_file, &p));
for (uint64_t q = ALIGN64(p + 1); q < (uint64_t) j->current_file->last_stat.st_size; q = ALIGN64(q + 1)) {
Object *o;
r = journal_file_move_to_object(j->current_file, OBJECT_UNUSED, q, &o);
assert_se(IN_SET(r, -EBADMSG, -EADDRNOTAVAIL));
ASSERT_TRUE(IN_SET(r, -EBADMSG, -EADDRNOTAVAIL));
}
/* Archive and offline file. */
assert_se(journal_file_archive(new_journal, NULL) >= 0);
assert_se(journal_file_set_offline(new_journal, /* wait= */ true) >= 0);
ASSERT_OK(journal_file_archive(new_journal, NULL));
ASSERT_OK(journal_file_set_offline(new_journal, /* wait= */ true));
/* Read the archived and offline journal. */
for (uint64_t q = ALIGN64(p + 1); q < (uint64_t) j->current_file->last_stat.st_size; q = ALIGN64(q + 1)) {
Object *o;
r = journal_file_move_to_object(j->current_file, OBJECT_UNUSED, q, &o);
assert_se(IN_SET(r, -EBADMSG, -EADDRNOTAVAIL, -EIDRM));
ASSERT_TRUE(IN_SET(r, -EBADMSG, -EADDRNOTAVAIL, -EIDRM));
}
}
TEST(journal_flush) {
assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1));
test_journal_flush_one(saved_argc, saved_argv);
}
TEST(journal_flush_compact) {
assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1));
test_journal_flush_one(saved_argc, saved_argv);
}
src/libsystemd/sd-journal/test-journal-init.c
+11 -13
View File
@@ -28,41 +28,39 @@ int main(int argc, char *argv[]) {
log_info("Running %d loops", I);
assert_se(mkdtemp(t));
ASSERT_NOT_NULL(mkdtemp(t));
(void) chattr_path(t, FS_NOCOW_FL, FS_NOCOW_FL);
for (i = 0; i < I; i++) {
r = sd_journal_open(&j, SD_JOURNAL_LOCAL_ONLY | SD_JOURNAL_ASSUME_IMMUTABLE);
assert_se(r == 0);
ASSERT_OK_ZERO(sd_journal_open(&j, SD_JOURNAL_LOCAL_ONLY | SD_JOURNAL_ASSUME_IMMUTABLE));
sd_journal_close(j);
r = sd_journal_open_directory(&j, t, SD_JOURNAL_ASSUME_IMMUTABLE);
assert_se(r == 0);
ASSERT_OK_ZERO(sd_journal_open_directory(&j, t, SD_JOURNAL_ASSUME_IMMUTABLE));
assert_se(sd_journal_seek_head(j) == 0);
assert_se(j->current_location.type == LOCATION_HEAD);
ASSERT_OK_ZERO(sd_journal_seek_head(j));
ASSERT_EQ(j->current_location.type, (LocationType) LOCATION_HEAD);
r = pidref_safe_fork("(journal-fork-test)", FORK_WAIT|FORK_LOG, NULL);
if (r == 0) {
assert_se(j);
ASSERT_NOT_NULL(j);
ASSERT_RETURN_EXPECTED_SE(sd_journal_get_realtime_usec(j, NULL) == -ECHILD);
ASSERT_RETURN_EXPECTED_SE(sd_journal_seek_tail(j) == -ECHILD);
assert_se(j->current_location.type == LOCATION_HEAD);
ASSERT_EQ(j->current_location.type, (LocationType) LOCATION_HEAD);
sd_journal_close(j);
_exit(EXIT_SUCCESS);
}
assert_se(r >= 0);
ASSERT_OK(r);
sd_journal_close(j);
j = NULL;
ASSERT_RETURN_EXPECTED(assert_se(sd_journal_open_directory(&j, t, SD_JOURNAL_LOCAL_ONLY) == -EINVAL));
assert_se(j == NULL);
ASSERT_RETURN_EXPECTED(ASSERT_ERROR(sd_journal_open_directory(&j, t, SD_JOURNAL_LOCAL_ONLY), EINVAL));
ASSERT_NULL(j);
}
assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
ASSERT_OK(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL));
return 0;
}
src/libsystemd/sd-journal/test-journal-match.c
+29 -29
View File
@@ -14,46 +14,46 @@ int main(int argc, char *argv[]) {
test_setup_logging(LOG_DEBUG);
assert_se(sd_journal_open(&j, SD_JOURNAL_ASSUME_IMMUTABLE) >= 0);
ASSERT_OK(sd_journal_open(&j, SD_JOURNAL_ASSUME_IMMUTABLE));
assert_se(sd_journal_add_match(j, "foobar", SIZE_MAX) < 0);
assert_se(sd_journal_add_match(j, "foobar=waldo", SIZE_MAX) < 0);
assert_se(sd_journal_add_match(j, "", SIZE_MAX) < 0);
assert_se(sd_journal_add_match(j, "=", SIZE_MAX) < 0);
assert_se(sd_journal_add_match(j, "=xxxxx", SIZE_MAX) < 0);
assert_se(sd_journal_add_match(j, (uint8_t[4]){'A', '=', '\1', '\2'}, 4) >= 0);
assert_se(sd_journal_add_match(j, (uint8_t[5]){'B', '=', 'C', '\0', 'D'}, 5) >= 0);
assert_se(sd_journal_add_match(j, "HALLO=WALDO", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "QUUX=mmmm", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "QUUX=xxxxx", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "HALLO=", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "QUUX=xxxxx", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "QUUX=yyyyy", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "PIFF=paff", SIZE_MAX) >= 0);
ASSERT_FAIL(sd_journal_add_match(j, "foobar", SIZE_MAX));
ASSERT_FAIL(sd_journal_add_match(j, "foobar=waldo", SIZE_MAX));
ASSERT_FAIL(sd_journal_add_match(j, "", SIZE_MAX));
ASSERT_FAIL(sd_journal_add_match(j, "=", SIZE_MAX));
ASSERT_FAIL(sd_journal_add_match(j, "=xxxxx", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, (uint8_t[4]){'A', '=', '\1', '\2'}, 4));
ASSERT_OK(sd_journal_add_match(j, (uint8_t[5]){'B', '=', 'C', '\0', 'D'}, 5));
ASSERT_OK(sd_journal_add_match(j, "HALLO=WALDO", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "QUUX=mmmm", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "QUUX=xxxxx", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "HALLO=", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "QUUX=xxxxx", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "QUUX=yyyyy", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "PIFF=paff", SIZE_MAX));
assert_se(sd_journal_add_disjunction(j) >= 0);
ASSERT_OK(sd_journal_add_disjunction(j));
assert_se(sd_journal_add_match(j, "ONE=one", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "ONE=two", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "TWO=two", SIZE_MAX) >= 0);
ASSERT_OK(sd_journal_add_match(j, "ONE=one", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "ONE=two", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "TWO=two", SIZE_MAX));
assert_se(sd_journal_add_conjunction(j) >= 0);
ASSERT_OK(sd_journal_add_conjunction(j));
assert_se(sd_journal_add_match(j, "L4_1=yes", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "L4_1=ok", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "L4_2=yes", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "L4_2=ok", SIZE_MAX) >= 0);
ASSERT_OK(sd_journal_add_match(j, "L4_1=yes", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "L4_1=ok", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "L4_2=yes", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "L4_2=ok", SIZE_MAX));
assert_se(sd_journal_add_disjunction(j) >= 0);
ASSERT_OK(sd_journal_add_disjunction(j));
assert_se(sd_journal_add_match(j, "L3=yes", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "L3=ok", SIZE_MAX) >= 0);
ASSERT_OK(sd_journal_add_match(j, "L3=yes", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "L3=ok", SIZE_MAX));
assert_se(t = journal_make_match_string(j));
ASSERT_NOT_NULL(t = journal_make_match_string(j));
printf("resulting match expression is: %s\n", t);
assert_se(streq(t, "(((L3=ok OR L3=yes) OR ((L4_2=ok OR L4_2=yes) AND (L4_1=ok OR L4_1=yes))) AND ((TWO=two AND (ONE=two OR ONE=one)) OR (PIFF=paff AND (QUUX=yyyyy OR QUUX=xxxxx OR QUUX=mmmm) AND (HALLO= OR HALLO=WALDO) AND B=C\\000D AND A=\\001\\002)))"));
ASSERT_STREQ(t, "(((L3=ok OR L3=yes) OR ((L4_2=ok OR L4_2=yes) AND (L4_1=ok OR L4_1=yes))) AND ((TWO=two AND (ONE=two OR ONE=one)) OR (PIFF=paff AND (QUUX=yyyyy OR QUUX=xxxxx OR QUUX=mmmm) AND (HALLO= OR HALLO=WALDO) AND B=C\\000D AND A=\\001\\002)))");
return 0;
}
src/libsystemd/sd-journal/test-journal-send.c
+41 -41
View File
@@ -10,18 +10,18 @@
#include "tests.h"
TEST(journal_print) {
assert_se(sd_journal_print(LOG_INFO, "XXX") == 0);
assert_se(sd_journal_print(LOG_INFO, "%s", "YYY") == 0);
assert_se(sd_journal_print(LOG_INFO, "X%4094sY", "ZZZ") == 0);
assert_se(sd_journal_print(LOG_INFO, "X%*sY", (int) LONG_LINE_MAX - 8 - 3, "ZZZ") == 0);
assert_se(sd_journal_print(LOG_INFO, "X%*sY", (int) LONG_LINE_MAX - 8 - 2, "ZZZ") == -ENOBUFS);
ASSERT_OK_ZERO(sd_journal_print(LOG_INFO, "XXX"));
ASSERT_OK_ZERO(sd_journal_print(LOG_INFO, "%s", "YYY"));
ASSERT_OK_ZERO(sd_journal_print(LOG_INFO, "X%4094sY", "ZZZ"));
ASSERT_OK_ZERO(sd_journal_print(LOG_INFO, "X%*sY", (int) LONG_LINE_MAX - 8 - 3, "ZZZ"));
ASSERT_ERROR(sd_journal_print(LOG_INFO, "X%*sY", (int) LONG_LINE_MAX - 8 - 2, "ZZZ"), ENOBUFS);
}
TEST(journal_send) {
_cleanup_free_ char *huge = NULL;
#define HUGE_SIZE (4096*1024)
assert_se(huge = malloc(HUGE_SIZE));
ASSERT_NOT_NULL(huge = malloc(HUGE_SIZE));
/* utf-8 and non-utf-8, message-less and message-ful iovecs */
struct iovec graph1[] = {
@@ -37,59 +37,59 @@ TEST(journal_send) {
{(char*) "MESSAGE=graph\n", STRLEN("MESSAGE=graph\n")}
};
assert_se(sd_journal_print(LOG_INFO, "piepapo") == 0);
ASSERT_OK_ZERO(sd_journal_print(LOG_INFO, "piepapo"));
assert_se(sd_journal_send("MESSAGE=foobar",
"VALUE=%i", 7,
NULL) == 0);
ASSERT_OK_ZERO(sd_journal_send("MESSAGE=foobar",
"VALUE=%i", 7,
NULL));
errno = ENOENT;
assert_se(sd_journal_perror("Foobar") == 0);
ASSERT_OK_ZERO(sd_journal_perror("Foobar"));
assert_se(sd_journal_perror("") == 0);
ASSERT_OK_ZERO(sd_journal_perror(""));
memcpy(huge, "HUGE=", STRLEN("HUGE="));
memset(&huge[STRLEN("HUGE=")], 'x', HUGE_SIZE - STRLEN("HUGE=") - 1);
huge[HUGE_SIZE - 1] = '\0';
assert_se(sd_journal_send("MESSAGE=Huge field attached",
huge,
NULL) == 0);
ASSERT_OK_ZERO(sd_journal_send("MESSAGE=Huge field attached",
huge,
NULL));
assert_se(sd_journal_send("MESSAGE=uiui",
"VALUE=A",
"VALUE=B",
"VALUE=C",
"SINGLETON=1",
"OTHERVALUE=X",
"OTHERVALUE=Y",
"WITH_BINARY=this is a binary value \a",
NULL) == 0);
ASSERT_OK_ZERO(sd_journal_send("MESSAGE=uiui",
"VALUE=A",
"VALUE=B",
"VALUE=C",
"SINGLETON=1",
"OTHERVALUE=X",
"OTHERVALUE=Y",
"WITH_BINARY=this is a binary value \a",
NULL));
syslog(LOG_NOTICE, "Hello World!");
assert_se(sd_journal_print(LOG_NOTICE, "Hello World") == 0);
ASSERT_OK_ZERO(sd_journal_print(LOG_NOTICE, "Hello World"));
assert_se(sd_journal_send("MESSAGE=Hello World!",
"MESSAGE_ID=52fb62f99e2c49d89cfbf9d6de5e3555",
"PRIORITY=5",
"HOME=%s", getenv("HOME"),
"TERM=%s", getenv("TERM"),
"PAGE_SIZE=%li", sysconf(_SC_PAGESIZE),
"N_CPUS=%li", sysconf(_SC_NPROCESSORS_ONLN),
NULL) == 0);
ASSERT_OK_ZERO(sd_journal_send("MESSAGE=Hello World!",
"MESSAGE_ID=52fb62f99e2c49d89cfbf9d6de5e3555",
"PRIORITY=5",
"HOME=%s", getenv("HOME"),
"TERM=%s", getenv("TERM"),
"PAGE_SIZE=%li", sysconf(_SC_PAGESIZE),
"N_CPUS=%li", sysconf(_SC_NPROCESSORS_ONLN),
NULL));
assert_se(sd_journal_sendv(graph1, 1) == 0);
assert_se(sd_journal_sendv(graph2, 1) == 0);
assert_se(sd_journal_sendv(message1, 1) == 0);
assert_se(sd_journal_sendv(message2, 1) == 0);
ASSERT_OK_ZERO(sd_journal_sendv(graph1, 1));
ASSERT_OK_ZERO(sd_journal_sendv(graph2, 1));
ASSERT_OK_ZERO(sd_journal_sendv(message1, 1));
ASSERT_OK_ZERO(sd_journal_sendv(message2, 1));
/* test without location fields */
#undef sd_journal_sendv
assert_se(sd_journal_sendv(graph1, 1) == 0);
assert_se(sd_journal_sendv(graph2, 1) == 0);
assert_se(sd_journal_sendv(message1, 1) == 0);
assert_se(sd_journal_sendv(message2, 1) == 0);
ASSERT_OK_ZERO(sd_journal_sendv(graph1, 1));
ASSERT_OK_ZERO(sd_journal_sendv(graph2, 1));
ASSERT_OK_ZERO(sd_journal_sendv(message1, 1));
ASSERT_OK_ZERO(sd_journal_sendv(message2, 1));
/* The above syslog() opens a fd which is stored in libc, and the valgrind reports the fd is
* leaked when we do not call closelog(). */
src/libsystemd/sd-journal/test-journal-stream.c
+43 -44
View File
@@ -15,12 +15,12 @@
#include "tests.h"
#include "time-util.h"
#define N_ENTRIES 200
#define N_ENTRIES 200u
static void verify_contents(sd_journal *j, unsigned skip) {
unsigned i;
assert_se(j);
ASSERT_NOT_NULL(j);
i = 0;
SD_JOURNAL_FOREACH(j) {
@@ -29,32 +29,32 @@ static void verify_contents(sd_journal *j, unsigned skip) {
size_t l;
unsigned u = 0;
assert_se(sd_journal_get_cursor(j, &k) >= 0);
ASSERT_OK(sd_journal_get_cursor(j, &k));
printf("cursor: %s\n", k);
free(k);
assert_se(sd_journal_get_data(j, "MAGIC", &d, &l) >= 0);
ASSERT_OK(sd_journal_get_data(j, "MAGIC", &d, &l));
printf("\t%.*s\n", (int) l, (const char*) d);
assert_se(sd_journal_get_data(j, "NUMBER", &d, &l) >= 0);
assert_se(k = strndup(d, l));
ASSERT_OK(sd_journal_get_data(j, "NUMBER", &d, &l));
ASSERT_NOT_NULL(k = strndup(d, l));
printf("\t%s\n", k);
if (skip > 0) {
assert_se(safe_atou(k + 7, &u) >= 0);
assert_se(i == u);
ASSERT_OK(safe_atou(k + 7, &u));
ASSERT_EQ(i, u);
i += skip;
}
free(k);
assert_se(sd_journal_get_cursor(j, &c) >= 0);
assert_se(sd_journal_test_cursor(j, c) > 0);
ASSERT_OK(sd_journal_get_cursor(j, &c));
ASSERT_OK_POSITIVE(sd_journal_test_cursor(j, c));
free(c);
}
if (skip > 0)
assert_se(i == N_ENTRIES);
ASSERT_EQ(i, N_ENTRIES);
}
static void run_test(void) {
@@ -68,16 +68,15 @@ static void run_test(void) {
size_t l;
dual_timestamp previous_ts = DUAL_TIMESTAMP_NULL;
m = mmap_cache_new();
assert_se(m != NULL);
ASSERT_NOT_NULL(m = mmap_cache_new());
assert_se(mkdtemp(t));
assert_se(chdir(t) >= 0);
ASSERT_NOT_NULL(mkdtemp(t));
ASSERT_OK_ERRNO(chdir(t));
(void) chattr_path(t, FS_NOCOW_FL, FS_NOCOW_FL);
assert_se(journal_file_open(-EBADF, "one.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &one) == 0);
assert_se(journal_file_open(-EBADF, "two.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &two) == 0);
assert_se(journal_file_open(-EBADF, "three.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &three) == 0);
ASSERT_OK_ZERO(journal_file_open(-EBADF, "one.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &one));
ASSERT_OK_ZERO(journal_file_open(-EBADF, "two.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &two));
ASSERT_OK_ZERO(journal_file_open(-EBADF, "three.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &three));
for (i = 0; i < N_ENTRIES; i++) {
char *p, *q;
@@ -94,20 +93,20 @@ static void run_test(void) {
previous_ts = ts;
assert_se(asprintf(&p, "NUMBER=%u", i) >= 0);
ASSERT_OK_ERRNO(asprintf(&p, "NUMBER=%u", i));
iovec[0] = IOVEC_MAKE(p, strlen(p));
assert_se(asprintf(&q, "MAGIC=%s", i % 5 == 0 ? "quux" : "waldo") >= 0);
ASSERT_OK_ERRNO(asprintf(&q, "MAGIC=%s", i % 5 == 0 ? "quux" : "waldo"));
iovec[1] = IOVEC_MAKE(q, strlen(q));
if (i % 10 == 0)
assert_se(journal_file_append_entry(three, &ts, NULL, iovec, 2, NULL, NULL, NULL, NULL) == 0);
ASSERT_OK_ZERO(journal_file_append_entry(three, &ts, NULL, iovec, 2, NULL, NULL, NULL, NULL));
else {
if (i % 3 == 0)
assert_se(journal_file_append_entry(two, &ts, NULL, iovec, 2, NULL, NULL, NULL, NULL) == 0);
ASSERT_OK_ZERO(journal_file_append_entry(two, &ts, NULL, iovec, 2, NULL, NULL, NULL, NULL));
assert_se(journal_file_append_entry(one, &ts, NULL, iovec, 2, NULL, NULL, NULL, NULL) == 0);
ASSERT_OK_ZERO(journal_file_append_entry(one, &ts, NULL, iovec, 2, NULL, NULL, NULL, NULL));
}
free(p);
@@ -118,27 +117,27 @@ static void run_test(void) {
(void) journal_file_offline_close(two);
(void) journal_file_offline_close(three);
assert_se(sd_journal_open_directory(&j, t, SD_JOURNAL_ASSUME_IMMUTABLE) >= 0);
ASSERT_OK(sd_journal_open_directory(&j, t, SD_JOURNAL_ASSUME_IMMUTABLE));
assert_se(sd_journal_add_match(j, "MAGIC=quux", SIZE_MAX) >= 0);
ASSERT_OK(sd_journal_add_match(j, "MAGIC=quux", SIZE_MAX));
SD_JOURNAL_FOREACH_BACKWARDS(j) {
_cleanup_free_ char *c;
assert_se(sd_journal_get_data(j, "NUMBER", &data, &l) >= 0);
ASSERT_OK(sd_journal_get_data(j, "NUMBER", &data, &l));
printf("\t%.*s\n", (int) l, (const char*) data);
assert_se(sd_journal_get_cursor(j, &c) >= 0);
assert_se(sd_journal_test_cursor(j, c) > 0);
ASSERT_OK(sd_journal_get_cursor(j, &c));
ASSERT_OK_POSITIVE(sd_journal_test_cursor(j, c));
}
SD_JOURNAL_FOREACH(j) {
_cleanup_free_ char *c;
assert_se(sd_journal_get_data(j, "NUMBER", &data, &l) >= 0);
ASSERT_OK(sd_journal_get_data(j, "NUMBER", &data, &l));
printf("\t%.*s\n", (int) l, (const char*) data);
assert_se(sd_journal_get_cursor(j, &c) >= 0);
assert_se(sd_journal_test_cursor(j, c) > 0);
ASSERT_OK(sd_journal_get_cursor(j, &c));
ASSERT_OK_POSITIVE(sd_journal_test_cursor(j, c));
}
sd_journal_flush_matches(j);
@@ -146,9 +145,9 @@ static void run_test(void) {
verify_contents(j, 1);
printf("NEXT TEST\n");
assert_se(sd_journal_add_match(j, "MAGIC=quux", SIZE_MAX) >= 0);
ASSERT_OK(sd_journal_add_match(j, "MAGIC=quux", SIZE_MAX));
assert_se(z = journal_make_match_string(j));
ASSERT_NOT_NULL(z = journal_make_match_string(j));
printf("resulting match expression is: %s\n", z);
free(z);
@@ -156,22 +155,22 @@ static void run_test(void) {
printf("NEXT TEST\n");
sd_journal_flush_matches(j);
assert_se(sd_journal_add_match(j, "MAGIC=waldo", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "NUMBER=10", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "NUMBER=11", SIZE_MAX) >= 0);
assert_se(sd_journal_add_match(j, "NUMBER=12", SIZE_MAX) >= 0);
ASSERT_OK(sd_journal_add_match(j, "MAGIC=waldo", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "NUMBER=10", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "NUMBER=11", SIZE_MAX));
ASSERT_OK(sd_journal_add_match(j, "NUMBER=12", SIZE_MAX));
assert_se(z = journal_make_match_string(j));
ASSERT_NOT_NULL(z = journal_make_match_string(j));
printf("resulting match expression is: %s\n", z);
free(z);
verify_contents(j, 0);
assert_se(sd_journal_query_unique(j, "NUMBER") >= 0);
ASSERT_OK(sd_journal_query_unique(j, "NUMBER"));
SD_JOURNAL_FOREACH_UNIQUE(j, data, l)
printf("%.*s\n", (int) l, (const char*) data);
assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
ASSERT_OK(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL));
}
int main(int argc, char *argv[]) {
@@ -184,16 +183,16 @@ int main(int argc, char *argv[]) {
/* Run this test multiple times with different configurations of features. */
assert_se(setenv("SYSTEMD_JOURNAL_KEYED_HASH", "0", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_KEYED_HASH", "0", 1));
run_test();
assert_se(setenv("SYSTEMD_JOURNAL_KEYED_HASH", "1", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_KEYED_HASH", "1", 1));
run_test();
assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1));
run_test();
assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1));
run_test();
return 0;
src/libsystemd/sd-journal/test-journal-verify.c
+21 -27
View File
@@ -22,19 +22,15 @@
static void bit_toggle(const char *fn, uint64_t p) {
uint8_t b;
ssize_t r;
int fd;
fd = open(fn, O_RDWR|O_CLOEXEC);
assert_se(fd >= 0);
ASSERT_OK_ERRNO(fd = open(fn, O_RDWR|O_CLOEXEC));
r = pread(fd, &b, 1, p/8);
assert_se(r == 1);
ASSERT_EQ(pread(fd, &b, 1, p/8), 1);
b ^= 1 << (p % 8);
r = pwrite(fd, &b, 1, p/8);
assert_se(r == 1);
ASSERT_EQ(pwrite(fd, &b, 1, p/8), 1);
safe_close(fd);
}
@@ -44,8 +40,7 @@ static int raw_verify(const char *fn, const char *verification_key) {
JournalFile *f;
int r;
m = mmap_cache_new();
assert_se(m != NULL);
ASSERT_NOT_NULL(m = mmap_cache_new());
r = journal_file_open(
/* fd= */ -EBADF,
@@ -77,8 +72,7 @@ static int run_test(const char *verification_key, ssize_t max_iterations) {
uint64_t start, end;
int r;
m = mmap_cache_new();
assert_se(m != NULL);
ASSERT_NOT_NULL(m = mmap_cache_new());
/* journal_file_open() requires a valid machine id */
if (sd_id128_get_machine(NULL) < 0)
@@ -86,13 +80,13 @@ static int run_test(const char *verification_key, ssize_t max_iterations) {
test_setup_logging(LOG_DEBUG);
assert_se(mkdtemp(t));
assert_se(chdir(t) >= 0);
ASSERT_NOT_NULL(mkdtemp(t));
ASSERT_OK_ERRNO(chdir(t));
(void) chattr_path(t, FS_NOCOW_FL, FS_NOCOW_FL);
log_info("Generating a test journal");
assert_se(journal_file_open(
ASSERT_OK_ZERO(journal_file_open(
/* fd= */ -EBADF,
"test.journal",
O_RDWR|O_CREAT,
@@ -102,7 +96,7 @@ static int run_test(const char *verification_key, ssize_t max_iterations) {
/* metrics= */ NULL,
m,
/* template= */ NULL,
&df) == 0);
&df));
for (size_t n = 0; n < N_ENTRIES; n++) {
_cleanup_free_ char *test = NULL;
@@ -110,9 +104,9 @@ static int run_test(const char *verification_key, ssize_t max_iterations) {
struct dual_timestamp ts;
dual_timestamp_now(&ts);
assert_se(asprintf(&test, "RANDOM=%li", random() % RANDOM_RANGE));
ASSERT_OK_ERRNO(asprintf(&test, "RANDOM=%li", random() % RANDOM_RANGE));
iovec = IOVEC_MAKE_STRING(test);
assert_se(journal_file_append_entry(
ASSERT_OK_ZERO(journal_file_append_entry(
df,
&ts,
/* boot_id= */ NULL,
@@ -121,14 +115,14 @@ static int run_test(const char *verification_key, ssize_t max_iterations) {
/* seqnum= */ NULL,
/* seqnum_id= */ NULL,
/* ret_object= */ NULL,
/* ret_offset= */ NULL) == 0);
/* ret_offset= */ NULL));
}
(void) journal_file_offline_close(df);
log_info("Verifying with key: %s", strna(verification_key));
assert_se(journal_file_open(
ASSERT_OK_ZERO(journal_file_open(
/* fd= */ -EBADF,
"test.journal",
O_RDONLY,
@@ -138,11 +132,11 @@ static int run_test(const char *verification_key, ssize_t max_iterations) {
/* metrics= */ NULL,
m,
/* template= */ NULL,
&f) == 0);
&f));
journal_file_print_header(f);
journal_file_dump(f);
assert_se(journal_file_verify(f, verification_key, &from, &to, &total, true) >= 0);
ASSERT_OK(journal_file_verify(f, verification_key, &from, &to, &total, true));
if (verification_key && JOURNAL_HEADER_SEALED(f->header))
log_info("=> Validated from %s to %s, %s missing",
@@ -151,7 +145,7 @@ static int run_test(const char *verification_key, ssize_t max_iterations) {
FORMAT_TIMESPAN(total > to ? total - to : 0, 0));
(void) journal_file_close(f);
assert_se(stat("test.journal", &st) >= 0);
ASSERT_OK_ERRNO(stat("test.journal", &st));
start = 38448 * 8 + 0;
end = max_iterations < 0 ? (uint64_t)st.st_size * 8 : start + max_iterations;
@@ -171,7 +165,7 @@ static int run_test(const char *verification_key, ssize_t max_iterations) {
bit_toggle("test.journal", p);
}
assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
ASSERT_OK(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL));
return 0;
}
@@ -187,10 +181,10 @@ int main(int argc, char *argv[]) {
max_iterations = -1;
}
assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1));
run_test(verification_key, max_iterations);
assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1));
run_test(verification_key, max_iterations);
#if HAVE_GCRYPT
@@ -199,10 +193,10 @@ int main(int argc, char *argv[]) {
if (argc <= 1) {
verification_key = "c262bd-85187f-0b1b04-877cc5/1c7af8-35a4e900";
assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1));
run_test(verification_key, max_iterations);
assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1));
run_test(verification_key, max_iterations);
}
#endif
src/libsystemd/sd-journal/test-journal.c
+64 -69
View File
@@ -17,8 +17,8 @@
static bool arg_keep = false;
static void mkdtemp_chdir_chattr(char *path) {
assert_se(mkdtemp(path));
assert_se(chdir(path) >= 0);
ASSERT_NOT_NULL(mkdtemp(path));
ASSERT_OK_ERRNO(chdir(path));
/* Speed up things a bit on btrfs, ensuring that CoW is turned off for all files created in our
* directory during the test run */
@@ -36,71 +36,70 @@ static void test_non_empty_one(void) {
sd_id128_t fake_boot_id;
char t[] = "/var/tmp/journal-XXXXXX";
m = mmap_cache_new();
assert_se(m != NULL);
ASSERT_NOT_NULL(m = mmap_cache_new());
mkdtemp_chdir_chattr(t);
assert_se(journal_file_open(-EBADF, "test.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS|JOURNAL_SEAL, 0666, UINT64_MAX, NULL, m, NULL, &f) == 0);
ASSERT_OK_ZERO(journal_file_open(-EBADF, "test.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS|JOURNAL_SEAL, 0666, UINT64_MAX, NULL, m, NULL, &f));
assert_se(dual_timestamp_now(&ts));
assert_se(sd_id128_randomize(&fake_boot_id) == 0);
ASSERT_NOT_NULL(dual_timestamp_now(&ts));
ASSERT_OK_ZERO(sd_id128_randomize(&fake_boot_id));
iovec = IOVEC_MAKE_STRING(test);
assert_se(journal_file_append_entry(f, &ts, NULL, &iovec, 1, NULL, NULL, NULL, NULL) == 0);
ASSERT_OK_ZERO(journal_file_append_entry(f, &ts, NULL, &iovec, 1, NULL, NULL, NULL, NULL));
iovec = IOVEC_MAKE_STRING(test2);
assert_se(journal_file_append_entry(f, &ts, NULL, &iovec, 1, NULL, NULL, NULL, NULL) == 0);
ASSERT_OK_ZERO(journal_file_append_entry(f, &ts, NULL, &iovec, 1, NULL, NULL, NULL, NULL));
iovec = IOVEC_MAKE_STRING(test);
assert_se(journal_file_append_entry(f, &ts, &fake_boot_id, &iovec, 1, NULL, NULL, NULL, NULL) == 0);
ASSERT_OK_ZERO(journal_file_append_entry(f, &ts, &fake_boot_id, &iovec, 1, NULL, NULL, NULL, NULL));
#if HAVE_GCRYPT
journal_file_append_tag(f);
#endif
journal_file_dump(f);
assert_se(journal_file_next_entry(f, 0, DIRECTION_DOWN, &o, &p) == 1);
assert_se(le64toh(o->entry.seqnum) == 1);
ASSERT_EQ(journal_file_next_entry(f, 0, DIRECTION_DOWN, &o, &p), 1);
ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(1));
assert_se(journal_file_next_entry(f, p, DIRECTION_DOWN, &o, &p) == 1);
assert_se(le64toh(o->entry.seqnum) == 2);
ASSERT_EQ(journal_file_next_entry(f, p, DIRECTION_DOWN, &o, &p), 1);
ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(2));
assert_se(journal_file_next_entry(f, p, DIRECTION_DOWN, &o, &p) == 1);
assert_se(le64toh(o->entry.seqnum) == 3);
assert_se(sd_id128_equal(o->entry.boot_id, fake_boot_id));
ASSERT_EQ(journal_file_next_entry(f, p, DIRECTION_DOWN, &o, &p), 1);
ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(3));
ASSERT_EQ_ID128(o->entry.boot_id, fake_boot_id);
assert_se(journal_file_next_entry(f, p, DIRECTION_DOWN, &o, &p) == 0);
ASSERT_OK_ZERO(journal_file_next_entry(f, p, DIRECTION_DOWN, &o, &p));
assert_se(journal_file_next_entry(f, 0, DIRECTION_DOWN, &o, &p) == 1);
assert_se(le64toh(o->entry.seqnum) == 1);
ASSERT_EQ(journal_file_next_entry(f, 0, DIRECTION_DOWN, &o, &p), 1);
ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(1));
assert_se(journal_file_find_data_object(f, test, strlen(test), &d, NULL) == 1);
assert_se(journal_file_move_to_entry_for_data(f, d, DIRECTION_DOWN, &o, NULL) == 1);
assert_se(le64toh(o->entry.seqnum) == 1);
ASSERT_EQ(journal_file_find_data_object(f, test, strlen(test), &d, NULL), 1);
ASSERT_EQ(journal_file_move_to_entry_for_data(f, d, DIRECTION_DOWN, &o, NULL), 1);
ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(1));
assert_se(journal_file_move_to_entry_for_data(f, d, DIRECTION_UP, &o, NULL) == 1);
assert_se(le64toh(o->entry.seqnum) == 3);
ASSERT_EQ(journal_file_move_to_entry_for_data(f, d, DIRECTION_UP, &o, NULL), 1);
ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(3));
assert_se(journal_file_find_data_object(f, test2, strlen(test2), &d, NULL) == 1);
assert_se(journal_file_move_to_entry_for_data(f, d, DIRECTION_UP, &o, NULL) == 1);
assert_se(le64toh(o->entry.seqnum) == 2);
ASSERT_EQ(journal_file_find_data_object(f, test2, strlen(test2), &d, NULL), 1);
ASSERT_EQ(journal_file_move_to_entry_for_data(f, d, DIRECTION_UP, &o, NULL), 1);
ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(2));
assert_se(journal_file_move_to_entry_for_data(f, d, DIRECTION_DOWN, &o, NULL) == 1);
assert_se(le64toh(o->entry.seqnum) == 2);
ASSERT_EQ(journal_file_move_to_entry_for_data(f, d, DIRECTION_DOWN, &o, NULL), 1);
ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(2));
assert_se(journal_file_find_data_object(f, "quux", 4, &d, NULL) == 0);
ASSERT_OK_ZERO(journal_file_find_data_object(f, "quux", 4, &d, NULL));
assert_se(journal_file_move_to_entry_by_seqnum(f, 1, DIRECTION_DOWN, &o, NULL) == 1);
assert_se(le64toh(o->entry.seqnum) == 1);
ASSERT_EQ(journal_file_move_to_entry_by_seqnum(f, 1, DIRECTION_DOWN, &o, NULL), 1);
ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(1));
assert_se(journal_file_move_to_entry_by_seqnum(f, 3, DIRECTION_DOWN, &o, NULL) == 1);
assert_se(le64toh(o->entry.seqnum) == 3);
ASSERT_EQ(journal_file_move_to_entry_by_seqnum(f, 3, DIRECTION_DOWN, &o, NULL), 1);
ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(3));
assert_se(journal_file_move_to_entry_by_seqnum(f, 2, DIRECTION_DOWN, &o, NULL) == 1);
assert_se(le64toh(o->entry.seqnum) == 2);
ASSERT_EQ(journal_file_move_to_entry_by_seqnum(f, 2, DIRECTION_DOWN, &o, NULL), 1);
ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(2));
assert_se(journal_file_move_to_entry_by_seqnum(f, 10, DIRECTION_DOWN, &o, NULL) == 0);
ASSERT_OK_ZERO(journal_file_move_to_entry_by_seqnum(f, 10, DIRECTION_DOWN, &o, NULL));
journal_file_rotate(&f, m, JOURNAL_SEAL|JOURNAL_COMPRESS, UINT64_MAX, NULL);
journal_file_rotate(&f, m, JOURNAL_SEAL|JOURNAL_COMPRESS, UINT64_MAX, NULL);
@@ -114,17 +113,17 @@ static void test_non_empty_one(void) {
else {
journal_directory_vacuum(".", 3000000, 0, 0, NULL, true);
assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
ASSERT_OK(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL));
}
puts("------------------------------------------------------------");
}
TEST(non_empty) {
assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1));
test_non_empty_one();
assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1));
test_non_empty_one();
}
@@ -133,15 +132,14 @@ static void test_empty_one(void) {
JournalFile *f1, *f2, *f3, *f4;
char t[] = "/var/tmp/journal-XXXXXX";
m = mmap_cache_new();
assert_se(m != NULL);
ASSERT_NOT_NULL(m = mmap_cache_new());
mkdtemp_chdir_chattr(t);
assert_se(journal_file_open(-EBADF, "test.journal", O_RDWR|O_CREAT, 0, 0666, UINT64_MAX, NULL, m, NULL, &f1) == 0);
assert_se(journal_file_open(-EBADF, "test-compress.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &f2) == 0);
assert_se(journal_file_open(-EBADF, "test-seal.journal", O_RDWR|O_CREAT, JOURNAL_SEAL, 0666, UINT64_MAX, NULL, m, NULL, &f3) == 0);
assert_se(journal_file_open(-EBADF, "test-seal-compress.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS|JOURNAL_SEAL, 0666, UINT64_MAX, NULL, m, NULL, &f4) == 0);
ASSERT_OK_ZERO(journal_file_open(-EBADF, "test.journal", O_RDWR|O_CREAT, 0, 0666, UINT64_MAX, NULL, m, NULL, &f1));
ASSERT_OK_ZERO(journal_file_open(-EBADF, "test-compress.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &f2));
ASSERT_OK_ZERO(journal_file_open(-EBADF, "test-seal.journal", O_RDWR|O_CREAT, JOURNAL_SEAL, 0666, UINT64_MAX, NULL, m, NULL, &f3));
ASSERT_OK_ZERO(journal_file_open(-EBADF, "test-seal-compress.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS|JOURNAL_SEAL, 0666, UINT64_MAX, NULL, m, NULL, &f4));
journal_file_print_header(f1);
puts("");
@@ -159,7 +157,7 @@ static void test_empty_one(void) {
else {
journal_directory_vacuum(".", 3000000, 0, 0, NULL, true);
assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
ASSERT_OK(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL));
}
(void) journal_file_offline_close(f1);
@@ -169,10 +167,10 @@ static void test_empty_one(void) {
}
TEST(empty) {
assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1));
test_empty_one();
assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1));
test_empty_one();
}
@@ -187,21 +185,19 @@ static bool check_compressed(uint64_t compress_threshold, uint64_t data_size) {
char t[] = "/var/tmp/journal-XXXXXX";
char data[2048] = "FIELD=";
bool is_compressed;
int r;
assert_se(data_size <= sizeof(data));
ASSERT_LE(data_size, sizeof(data));
m = mmap_cache_new();
assert_se(m != NULL);
ASSERT_NOT_NULL(m = mmap_cache_new());
mkdtemp_chdir_chattr(t);
assert_se(journal_file_open(-EBADF, "test.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS|JOURNAL_SEAL, 0666, compress_threshold, NULL, m, NULL, &f) == 0);
ASSERT_OK_ZERO(journal_file_open(-EBADF, "test.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS|JOURNAL_SEAL, 0666, compress_threshold, NULL, m, NULL, &f));
dual_timestamp_now(&ts);
iovec = IOVEC_MAKE(data, data_size);
assert_se(journal_file_append_entry(f, &ts, NULL, &iovec, 1, NULL, NULL, NULL, NULL) == 0);
ASSERT_OK_ZERO(journal_file_append_entry(f, &ts, NULL, &iovec, 1, NULL, NULL, NULL, NULL));
#if HAVE_GCRYPT
journal_file_append_tag(f);
@@ -212,12 +208,11 @@ static bool check_compressed(uint64_t compress_threshold, uint64_t data_size) {
* decompression for us. */
p = le64toh(f->header->header_size);
for (;;) {
r = journal_file_move_to_object(f, OBJECT_UNUSED, p, &o);
assert_se(r == 0);
ASSERT_OK_ZERO(journal_file_move_to_object(f, OBJECT_UNUSED, p, &o));
if (o->object.type == OBJECT_DATA)
break;
assert_se(p < le64toh(f->header->tail_object_offset));
ASSERT_LT(p, le64toh(f->header->tail_object_offset));
p = p + ALIGN64(le64toh(o->object.size));
}
@@ -232,7 +227,7 @@ static bool check_compressed(uint64_t compress_threshold, uint64_t data_size) {
else {
journal_directory_vacuum(".", 3000000, 0, 0, NULL, true);
assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
ASSERT_OK(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL));
}
puts("------------------------------------------------------------");
@@ -245,26 +240,26 @@ static void test_min_compress_size_one(void) {
* carefully */
/* DEFAULT_MIN_COMPRESS_SIZE is 512 */
assert_se(!check_compressed(UINT64_MAX, 255));
assert_se(check_compressed(UINT64_MAX, 513));
ASSERT_FALSE(check_compressed(UINT64_MAX, 255));
ASSERT_TRUE(check_compressed(UINT64_MAX, 513));
/* compress everything */
assert_se(check_compressed(0, 96));
assert_se(check_compressed(8, 96));
ASSERT_TRUE(check_compressed(0, 96));
ASSERT_TRUE(check_compressed(8, 96));
/* Ensure we don't try to compress less than 8 bytes */
assert_se(!check_compressed(0, 7));
ASSERT_FALSE(check_compressed(0, 7));
/* check boundary conditions */
assert_se(check_compressed(256, 256));
assert_se(!check_compressed(256, 255));
ASSERT_TRUE(check_compressed(256, 256));
ASSERT_FALSE(check_compressed(256, 255));
}
TEST(min_compress_size) {
assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1));
test_min_compress_size_one();
assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1) >= 0);
ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1));
test_min_compress_size_one();
}
#endif
src/libsystemd/sd-journal/test-mmap-cache.c
+14 -22
View File
@@ -10,49 +10,41 @@
int main(int argc, char *argv[]) {
MMapFileDescriptor *fx;
int x, y, z, r;
int x, y, z;
char px[] = "/tmp/testmmapXXXXXXX", py[] = "/tmp/testmmapYXXXXXX", pz[] = "/tmp/testmmapZXXXXXX";
MMapCache *m;
void *p, *q;
test_setup_logging(LOG_DEBUG);
assert_se(m = mmap_cache_new());
ASSERT_NOT_NULL(m = mmap_cache_new());
x = mkostemp_safe(px);
assert_se(x >= 0);
ASSERT_OK(x = mkostemp_safe(px));
(void) unlink(px);
assert_se(mmap_cache_add_fd(m, x, PROT_READ, &fx) > 0);
ASSERT_OK_POSITIVE(mmap_cache_add_fd(m, x, PROT_READ, &fx));
y = mkostemp_safe(py);
assert_se(y >= 0);
ASSERT_OK(y = mkostemp_safe(py));
(void) unlink(py);
z = mkostemp_safe(pz);
assert_se(z >= 0);
ASSERT_OK(z = mkostemp_safe(pz));
(void) unlink(pz);
r = mmap_cache_fd_get(fx, 0, false, 1, 2, NULL, &p);
assert_se(r >= 0);
ASSERT_OK(mmap_cache_fd_get(fx, 0, false, 1, 2, NULL, &p));
r = mmap_cache_fd_get(fx, 0, false, 2, 2, NULL, &q);
assert_se(r >= 0);
ASSERT_OK(mmap_cache_fd_get(fx, 0, false, 2, 2, NULL, &q));
assert_se((uint8_t*) p + 1 == (uint8_t*) q);
ASSERT_PTR_EQ((uint8_t*) p + 1, (uint8_t*) q);
r = mmap_cache_fd_get(fx, 1, false, 3, 2, NULL, &q);
assert_se(r >= 0);
ASSERT_OK(mmap_cache_fd_get(fx, 1, false, 3, 2, NULL, &q));
assert_se((uint8_t*) p + 2 == (uint8_t*) q);
ASSERT_PTR_EQ((uint8_t*) p + 2, (uint8_t*) q);
r = mmap_cache_fd_get(fx, 0, false, 16ULL*1024ULL*1024ULL, 2, NULL, &p);
assert_se(r >= 0);
ASSERT_OK(mmap_cache_fd_get(fx, 0, false, 16ULL*1024ULL*1024ULL, 2, NULL, &p));
r = mmap_cache_fd_get(fx, 1, false, 16ULL*1024ULL*1024ULL+1, 2, NULL, &q);
assert_se(r >= 0);
ASSERT_OK(mmap_cache_fd_get(fx, 1, false, 16ULL*1024ULL*1024ULL+1, 2, NULL, &q));
assert_se((uint8_t*) p + 1 == (uint8_t*) q);
ASSERT_PTR_EQ((uint8_t*) p + 1, (uint8_t*) q);
mmap_cache_fd_free(fx);
mmap_cache_unref(m);