[systemd.git] / src / journal / test-journal-interleaving.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2013 Marius Vollmer
  Copyright 2013 Zbigniew Jędrzejewski-Szmek

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <unistd.h>
#include <fcntl.h>

#include "sd-journal.h"
#include "journal-file.h"
#include "journal-vacuum.h"
#include "util.h"
#include "log.h"
#include "rm-rf.h"

/* This program tests skipping around in a multi-file journal.
 */

static bool arg_keep = false;

noreturn static void log_assert_errno(const char *text, int eno, const char *file, int line, const char *func) {
        log_internal(LOG_CRIT, 0, file, line, func,
                     "'%s' failed at %s:%u (%s): %s.",
                     text, file, line, func, strerror(eno));
        abort();
}

#define assert_ret(expr)                                                \
        do {                                                            \
                int _r_ = (expr);                                       \
                if (_unlikely_(_r_ < 0))                                \
                        log_assert_errno(#expr, -_r_, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
        } while (false)

static JournalFile *test_open(const char *name) {
        JournalFile *f;
        assert_ret(journal_file_open(name, O_RDWR|O_CREAT, 0644, true, false, NULL, NULL, NULL, &f));
        return f;
}

static void test_close(JournalFile *f) {
        journal_file_close (f);
}

static void append_number(JournalFile *f, int n, uint64_t *seqnum) {
        char *p;
        dual_timestamp ts;
        static dual_timestamp previous_ts = {};
        struct iovec iovec[1];

        dual_timestamp_get(&ts);

        if (ts.monotonic <= previous_ts.monotonic)
                ts.monotonic = previous_ts.monotonic + 1;

        if (ts.realtime <= previous_ts.realtime)
                ts.realtime = previous_ts.realtime + 1;

        previous_ts = ts;

        assert_se(asprintf(&p, "NUMBER=%d", n) >= 0);
        iovec[0].iov_base = p;
        iovec[0].iov_len = strlen(p);
        assert_ret(journal_file_append_entry(f, &ts, iovec, 1, seqnum, NULL, NULL));
        free(p);
}

static void test_check_number (sd_journal *j, int n) {
        const void *d;
        _cleanup_free_ char *k;
        size_t l;
        int x;

        assert_ret(sd_journal_get_data(j, "NUMBER", &d, &l));
        assert_se(k = strndup(d, l));
        printf("%s\n", k);

        assert_se(safe_atoi(k + 7, &x) >= 0);
        assert_se(n == x);
}

static void test_check_numbers_down (sd_journal *j, int count) {
        int i;

        for (i = 1; i <= count; i++) {
                int r;
                test_check_number(j, i);
                assert_ret(r = sd_journal_next(j));
                if (i == count)
                        assert_se(r == 0);
                else
                        assert_se(r == 1);
        }

}

static void test_check_numbers_up (sd_journal *j, int count) {
        for (int i = count; i >= 1; i--) {
                int r;
                test_check_number(j, i);
                assert_ret(r = sd_journal_previous(j));
                if (i == 1)
                        assert_se(r == 0);
                else
                        assert_se(r == 1);
        }

}

static void setup_sequential(void) {
        JournalFile *one, *two;
        one = test_open("one.journal");
        two = test_open("two.journal");
        append_number(one, 1, NULL);
        append_number(one, 2, NULL);
        append_number(two, 3, NULL);
        append_number(two, 4, NULL);
        test_close(one);
        test_close(two);
}

static void setup_interleaved(void) {
        JournalFile *one, *two;
        one = test_open("one.journal");
        two = test_open("two.journal");
        append_number(one, 1, NULL);
        append_number(two, 2, NULL);
        append_number(one, 3, NULL);
        append_number(two, 4, NULL);
        test_close(one);
        test_close(two);
}

static void test_skip(void (*setup)(void)) {
        char t[] = "/tmp/journal-skip-XXXXXX";
        sd_journal *j;
        int r;

        assert_se(mkdtemp(t));
        assert_se(chdir(t) >= 0);

        setup();

        /* Seek to head, iterate down.
         */
        assert_ret(sd_journal_open_directory(&j, t, 0));
        assert_ret(sd_journal_seek_head(j));
        assert_ret(sd_journal_next(j));
        test_check_numbers_down(j, 4);
        sd_journal_close(j);

        /* Seek to tail, iterate up.
         */
        assert_ret(sd_journal_open_directory(&j, t, 0));
        assert_ret(sd_journal_seek_tail(j));
        assert_ret(sd_journal_previous(j));
        test_check_numbers_up(j, 4);
        sd_journal_close(j);

        /* Seek to tail, skip to head, iterate down.
         */
        assert_ret(sd_journal_open_directory(&j, t, 0));
        assert_ret(sd_journal_seek_tail(j));
        assert_ret(r = sd_journal_previous_skip(j, 4));
        assert_se(r == 4);
        test_check_numbers_down(j, 4);
        sd_journal_close(j);

        /* Seek to head, skip to tail, iterate up.
         */
        assert_ret(sd_journal_open_directory(&j, t, 0));
        assert_ret(sd_journal_seek_head(j));
        assert_ret(r = sd_journal_next_skip(j, 4));
        assert_se(r == 4);
        test_check_numbers_up(j, 4);
        sd_journal_close(j);

        log_info("Done...");

        if (arg_keep)
                log_info("Not removing %s", t);
        else {
                journal_directory_vacuum(".", 3000000, 0, 0, NULL, true);

                assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
        }

        puts("------------------------------------------------------------");
}

static void test_sequence_numbers(void) {

        char t[] = "/tmp/journal-seq-XXXXXX";
        JournalFile *one, *two;
        uint64_t seqnum = 0;
        sd_id128_t seqnum_id;

        assert_se(mkdtemp(t));
        assert_se(chdir(t) >= 0);

        assert_se(journal_file_open("one.journal", O_RDWR|O_CREAT, 0644,
                                    true, false, NULL, NULL, NULL, &one) == 0);

        append_number(one, 1, &seqnum);
        printf("seqnum=%"PRIu64"\n", seqnum);
        assert_se(seqnum == 1);
        append_number(one, 2, &seqnum);
        printf("seqnum=%"PRIu64"\n", seqnum);
        assert_se(seqnum == 2);

        assert_se(one->header->state == STATE_ONLINE);
        assert_se(!sd_id128_equal(one->header->file_id, one->header->machine_id));
        assert_se(!sd_id128_equal(one->header->file_id, one->header->boot_id));
        assert_se(sd_id128_equal(one->header->file_id, one->header->seqnum_id));

        memcpy(&seqnum_id, &one->header->seqnum_id, sizeof(sd_id128_t));

        assert_se(journal_file_open("two.journal", O_RDWR|O_CREAT, 0644,
                                    true, false, NULL, NULL, one, &two) == 0);

        assert_se(two->header->state == STATE_ONLINE);
        assert_se(!sd_id128_equal(two->header->file_id, one->header->file_id));
        assert_se(sd_id128_equal(one->header->machine_id, one->header->machine_id));
        assert_se(sd_id128_equal(one->header->boot_id, one->header->boot_id));
        assert_se(sd_id128_equal(one->header->seqnum_id, one->header->seqnum_id));

        append_number(two, 3, &seqnum);
        printf("seqnum=%"PRIu64"\n", seqnum);
        assert_se(seqnum == 3);
        append_number(two, 4, &seqnum);
        printf("seqnum=%"PRIu64"\n", seqnum);
        assert_se(seqnum == 4);

        test_close(two);

        append_number(one, 5, &seqnum);
        printf("seqnum=%"PRIu64"\n", seqnum);
        assert_se(seqnum == 5);

        append_number(one, 6, &seqnum);
        printf("seqnum=%"PRIu64"\n", seqnum);
        assert_se(seqnum == 6);

        test_close(one);

        /* restart server */
        seqnum = 0;

        assert_se(journal_file_open("two.journal", O_RDWR, 0,
                                    true, false, NULL, NULL, NULL, &two) == 0);

        assert_se(sd_id128_equal(two->header->seqnum_id, seqnum_id));

        append_number(two, 7, &seqnum);
        printf("seqnum=%"PRIu64"\n", seqnum);
        assert_se(seqnum == 5);

        /* So..., here we have the same seqnum in two files with the
         * same seqnum_id. */

        test_close(two);

        log_info("Done...");

        if (arg_keep)
                log_info("Not removing %s", t);
        else {
                journal_directory_vacuum(".", 3000000, 0, 0, NULL, true);

                assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
        }
}

int main(int argc, char *argv[]) {
        log_set_max_level(LOG_DEBUG);

        /* journal_file_open requires a valid machine id */
        if (access("/etc/machine-id", F_OK) != 0)
                return EXIT_TEST_SKIP;

        arg_keep = argc > 1;

        test_skip(setup_sequential);
        test_skip(setup_interleaved);

        test_sequence_numbers();

        return 0;
}
Commit	Line	Data
14228c0d MB	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2013 Marius Vollmer
	7	Copyright 2013 Zbigniew Jędrzejewski-Szmek
	8
	9	systemd is free software; you can redistribute it and/or modify it
	10	under the terms of the GNU Lesser General Public License as published by
	11	the Free Software Foundation; either version 2.1 of the License, or
	12	(at your option) any later version.
	13
	14	systemd is distributed in the hope that it will be useful, but
	15	WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	Lesser General Public License for more details.
	18
	19	You should have received a copy of the GNU Lesser General Public License
	20	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	21	***/
	22
	23	#include <unistd.h>
	24	#include <fcntl.h>
	25
e3bff60a	26	#include "sd-journal.h"
14228c0d	27	#include "journal-file.h"
14228c0d MB	28	#include "journal-vacuum.h"
	29	#include "util.h"
	30	#include "log.h"
e3bff60a	31	#include "rm-rf.h"
14228c0d MB	32
	33	/* This program tests skipping around in a multi-file journal.
	34	*/
	35
	36	static bool arg_keep = false;
	37
60f067b4	38	noreturn static void log_assert_errno(const char text, int eno, const char file, int line, const char *func) {
f47781d8 MP	39	log_internal(LOG_CRIT, 0, file, line, func,
	40	"'%s' failed at %s:%u (%s): %s.",
	41	text, file, line, func, strerror(eno));
14228c0d MB	42	abort();
	43	}
	44
	45	#define assert_ret(expr) \
	46	do { \
	47	int _r_ = (expr); \
	48	if (_unlikely_(_r_ < 0)) \
	49	log_assert_errno(#expr, -_r_, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
	50	} while (false)
	51
60f067b4	52	static JournalFile test_open(const char name) {
14228c0d MB	53	JournalFile *f;
	54	assert_ret(journal_file_open(name, O_RDWR\|O_CREAT, 0644, true, false, NULL, NULL, NULL, &f));
	55	return f;
	56	}
	57
60f067b4	58	static void test_close(JournalFile *f) {
14228c0d MB	59	journal_file_close (f);
	60	}
	61
60f067b4	62	static void append_number(JournalFile f, int n, uint64_t seqnum) {
14228c0d MB	63	char *p;
14228c0d MB	64	dual_timestamp ts;
86f210e9	65	static dual_timestamp previous_ts = {};
14228c0d MB	66	struct iovec iovec[1];
	67
	68	dual_timestamp_get(&ts);
	69
86f210e9 MP	70	if (ts.monotonic <= previous_ts.monotonic)
	71	ts.monotonic = previous_ts.monotonic + 1;
	72
	73	if (ts.realtime <= previous_ts.realtime)
	74	ts.realtime = previous_ts.realtime + 1;
	75
	76	previous_ts = ts;
	77
14228c0d MB	78	assert_se(asprintf(&p, "NUMBER=%d", n) >= 0);
	79	iovec[0].iov_base = p;
	80	iovec[0].iov_len = strlen(p);
	81	assert_ret(journal_file_append_entry(f, &ts, iovec, 1, seqnum, NULL, NULL));
60f067b4	82	free(p);
14228c0d MB	83	}
14228c0d MB	84
60f067b4	85	static void test_check_number (sd_journal *j, int n) {
14228c0d	86	const void *d;
60f067b4	87	_cleanup_free_ char *k;
14228c0d MB	88	size_t l;
	89	int x;
	90
	91	assert_ret(sd_journal_get_data(j, "NUMBER", &d, &l));
	92	assert_se(k = strndup(d, l));
	93	printf("%s\n", k);
	94
	95	assert_se(safe_atoi(k + 7, &x) >= 0);
	96	assert_se(n == x);
	97	}
	98
60f067b4 JS	99	static void test_check_numbers_down (sd_journal *j, int count) {
	100	int i;
	101
	102	for (i = 1; i <= count; i++) {
14228c0d MB	103	int r;
	104	test_check_number(j, i);
	105	assert_ret(r = sd_journal_next(j));
	106	if (i == count)
	107	assert_se(r == 0);
	108	else
	109	assert_se(r == 1);
	110	}
	111
	112	}
	113
60f067b4	114	static void test_check_numbers_up (sd_journal *j, int count) {
14228c0d MB	115	for (int i = count; i >= 1; i--) {
	116	int r;
	117	test_check_number(j, i);
	118	assert_ret(r = sd_journal_previous(j));
	119	if (i == 1)
	120	assert_se(r == 0);
	121	else
	122	assert_se(r == 1);
	123	}
	124
	125	}
	126
	127	static void setup_sequential(void) {
	128	JournalFile one, two;
	129	one = test_open("one.journal");
	130	two = test_open("two.journal");
	131	append_number(one, 1, NULL);
	132	append_number(one, 2, NULL);
	133	append_number(two, 3, NULL);
	134	append_number(two, 4, NULL);
	135	test_close(one);
	136	test_close(two);
	137	}
	138
	139	static void setup_interleaved(void) {
	140	JournalFile one, two;
	141	one = test_open("one.journal");
	142	two = test_open("two.journal");
	143	append_number(one, 1, NULL);
	144	append_number(two, 2, NULL);
	145	append_number(one, 3, NULL);
	146	append_number(two, 4, NULL);
	147	test_close(one);
	148	test_close(two);
	149	}
	150
60f067b4	151	static void test_skip(void (*setup)(void)) {
14228c0d MB	152	char t[] = "/tmp/journal-skip-XXXXXX";
	153	sd_journal *j;
	154	int r;
	155
	156	assert_se(mkdtemp(t));
	157	assert_se(chdir(t) >= 0);
	158
	159	setup();
	160
	161	/* Seek to head, iterate down.
	162	*/
	163	assert_ret(sd_journal_open_directory(&j, t, 0));
	164	assert_ret(sd_journal_seek_head(j));
	165	assert_ret(sd_journal_next(j));
	166	test_check_numbers_down(j, 4);
	167	sd_journal_close(j);
	168
	169	/* Seek to tail, iterate up.
	170	*/
	171	assert_ret(sd_journal_open_directory(&j, t, 0));
	172	assert_ret(sd_journal_seek_tail(j));
	173	assert_ret(sd_journal_previous(j));
	174	test_check_numbers_up(j, 4);
	175	sd_journal_close(j);
	176
	177	/* Seek to tail, skip to head, iterate down.
	178	*/
	179	assert_ret(sd_journal_open_directory(&j, t, 0));
	180	assert_ret(sd_journal_seek_tail(j));
	181	assert_ret(r = sd_journal_previous_skip(j, 4));
	182	assert_se(r == 4);
	183	test_check_numbers_down(j, 4);
	184	sd_journal_close(j);
	185
	186	/* Seek to head, skip to tail, iterate up.
	187	*/
	188	assert_ret(sd_journal_open_directory(&j, t, 0));
	189	assert_ret(sd_journal_seek_head(j));
	190	assert_ret(r = sd_journal_next_skip(j, 4));
	191	assert_se(r == 4);
	192	test_check_numbers_up(j, 4);
	193	sd_journal_close(j);
	194
	195	log_info("Done...");
	196
	197	if (arg_keep)
	198	log_info("Not removing %s", t);
	199	else {
6300502b	200	journal_directory_vacuum(".", 3000000, 0, 0, NULL, true);
14228c0d	201
e3bff60a	202	assert_se(rm_rf(t, REMOVE_ROOT\|REMOVE_PHYSICAL) >= 0);
14228c0d MB	203	}
	204
	205	puts("------------------------------------------------------------");
	206	}
	207
	208	static void test_sequence_numbers(void) {
	209
	210	char t[] = "/tmp/journal-seq-XXXXXX";
	211	JournalFile one, two;
	212	uint64_t seqnum = 0;
	213	sd_id128_t seqnum_id;
	214
	215	assert_se(mkdtemp(t));
	216	assert_se(chdir(t) >= 0);
	217
	218	assert_se(journal_file_open("one.journal", O_RDWR\|O_CREAT, 0644,
	219	true, false, NULL, NULL, NULL, &one) == 0);
	220
	221	append_number(one, 1, &seqnum);
	222	printf("seqnum=%"PRIu64"\n", seqnum);
e735f4d4	223	assert_se(seqnum == 1);
14228c0d MB	224	append_number(one, 2, &seqnum);
14228c0d MB	225	printf("seqnum=%"PRIu64"\n", seqnum);
e735f4d4	226	assert_se(seqnum == 2);
14228c0d	227
e735f4d4 MP	228	assert_se(one->header->state == STATE_ONLINE);
	229	assert_se(!sd_id128_equal(one->header->file_id, one->header->machine_id));
	230	assert_se(!sd_id128_equal(one->header->file_id, one->header->boot_id));
	231	assert_se(sd_id128_equal(one->header->file_id, one->header->seqnum_id));
14228c0d MB	232
	233	memcpy(&seqnum_id, &one->header->seqnum_id, sizeof(sd_id128_t));
	234
	235	assert_se(journal_file_open("two.journal", O_RDWR\|O_CREAT, 0644,
	236	true, false, NULL, NULL, one, &two) == 0);
	237
e735f4d4 MP	238	assert_se(two->header->state == STATE_ONLINE);
	239	assert_se(!sd_id128_equal(two->header->file_id, one->header->file_id));
	240	assert_se(sd_id128_equal(one->header->machine_id, one->header->machine_id));
	241	assert_se(sd_id128_equal(one->header->boot_id, one->header->boot_id));
	242	assert_se(sd_id128_equal(one->header->seqnum_id, one->header->seqnum_id));
14228c0d MB	243
	244	append_number(two, 3, &seqnum);
	245	printf("seqnum=%"PRIu64"\n", seqnum);
e735f4d4	246	assert_se(seqnum == 3);
14228c0d MB	247	append_number(two, 4, &seqnum);
14228c0d MB	248	printf("seqnum=%"PRIu64"\n", seqnum);
e735f4d4	249	assert_se(seqnum == 4);
14228c0d MB	250
	251	test_close(two);
	252
	253	append_number(one, 5, &seqnum);
	254	printf("seqnum=%"PRIu64"\n", seqnum);
e735f4d4	255	assert_se(seqnum == 5);
14228c0d MB	256
	257	append_number(one, 6, &seqnum);
	258	printf("seqnum=%"PRIu64"\n", seqnum);
e735f4d4	259	assert_se(seqnum == 6);
14228c0d MB	260
	261	test_close(one);
	262
	263	/* restart server */
	264	seqnum = 0;
	265
	266	assert_se(journal_file_open("two.journal", O_RDWR, 0,
	267	true, false, NULL, NULL, NULL, &two) == 0);
	268
e735f4d4	269	assert_se(sd_id128_equal(two->header->seqnum_id, seqnum_id));
14228c0d MB	270
	271	append_number(two, 7, &seqnum);
	272	printf("seqnum=%"PRIu64"\n", seqnum);
e735f4d4	273	assert_se(seqnum == 5);
14228c0d MB	274
	275	/* So..., here we have the same seqnum in two files with the
	276	* same seqnum_id. */
	277
	278	test_close(two);
	279
	280	log_info("Done...");
	281
	282	if (arg_keep)
	283	log_info("Not removing %s", t);
	284	else {
6300502b	285	journal_directory_vacuum(".", 3000000, 0, 0, NULL, true);
14228c0d	286
e3bff60a	287	assert_se(rm_rf(t, REMOVE_ROOT\|REMOVE_PHYSICAL) >= 0);
14228c0d MB	288	}
	289	}
	290
	291	int main(int argc, char *argv[]) {
	292	log_set_max_level(LOG_DEBUG);
	293
	294	/* journal_file_open requires a valid machine id */
	295	if (access("/etc/machine-id", F_OK) != 0)
	296	return EXIT_TEST_SKIP;
	297
	298	arg_keep = argc > 1;
	299
	300	test_skip(setup_sequential);
	301	test_skip(setup_interleaved);
	302
	303	test_sequence_numbers();
	304
	305	return 0;
	306	}