[lttng-tools.git] / tests / unit / test_kernel_data.c

/*
 * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 */

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>

#include <common/compat/errno.h>
#include <bin/lttng-sessiond/trace-kernel.h>
#include <common/defaults.h>

#include <tap/tap.h>

#define RANDOM_STRING_LEN	11

/* Number of TAP tests in this file */
#define NUM_TESTS 11

static const char alphanum[] =
	"0123456789"
	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	"abcdefghijklmnopqrstuvwxyz";

static struct ltt_kernel_session *kern;
static char random_string[RANDOM_STRING_LEN];

/*
 * Return random string of 10 characters.
 * Not thread-safe.
 */
static char *get_random_string(void)
{
	int i;

	for (i = 0; i < RANDOM_STRING_LEN - 1; i++) {
		random_string[i] = alphanum[rand() % (sizeof(alphanum) - 1)];
	}

	random_string[RANDOM_STRING_LEN - 1] = '\0';

	return random_string;
}

static void test_create_one_kernel_session(void)
{
	kern = trace_kernel_create_session();
	ok(kern != NULL, "Create kernel session");

	if (!kern) {
		skip(1, "Kernel session is null");
		return;
	}
	ok(kern->fd == -1 &&
	   kern->metadata_stream_fd == -1 &&
	   kern->consumer_fds_sent == 0 &&
	   kern->channel_count == 0 &&
	   kern->stream_count_global == 0 &&
	   kern->metadata == NULL,
	   "Validate kernel session");
}

static void test_create_kernel_metadata(void)
{
	assert(kern != NULL);

	kern->metadata = trace_kernel_create_metadata();
	ok(kern->metadata != NULL, "Create kernel metadata");

	ok(kern->metadata->fd == -1 &&
	   kern->metadata->conf != NULL &&
	   kern->metadata->conf->attr.overwrite
			== DEFAULT_METADATA_OVERWRITE &&
	   kern->metadata->conf->attr.subbuf_size
			== default_get_metadata_subbuf_size() &&
	   kern->metadata->conf->attr.num_subbuf
			== DEFAULT_METADATA_SUBBUF_NUM &&
	   kern->metadata->conf->attr.switch_timer_interval
			== DEFAULT_METADATA_SWITCH_TIMER &&
	   kern->metadata->conf->attr.read_timer_interval
			== DEFAULT_METADATA_READ_TIMER &&
	   kern->metadata->conf->attr.output
			== LTTNG_EVENT_MMAP,
	   "Validate kernel session metadata");

	trace_kernel_destroy_metadata(kern->metadata);
}

static void test_create_kernel_channel(void)
{
	struct ltt_kernel_channel *chan;
	struct lttng_channel attr;
	struct lttng_channel_extended extended;

	memset(&attr, 0, sizeof(attr));
	memset(&extended, 0, sizeof(extended));
	attr.attr.extended.ptr = &extended;

	chan = trace_kernel_create_channel(&attr);
	ok(chan != NULL, "Create kernel channel");

	if (!chan) {
		skip(1, "Channel is null");
		return;
	}

	ok(chan->fd == -1 &&
	   chan->enabled == 1 &&
	   chan->stream_count == 0 &&
	   chan->channel->attr.overwrite  == attr.attr.overwrite,
	   "Validate kernel channel");

	/* Init list in order to avoid sefaults from cds_list_del */
	CDS_INIT_LIST_HEAD(&chan->list);
	trace_kernel_destroy_channel(chan);
}

static void test_create_kernel_event(void)
{
	enum lttng_error_code ret;
	struct ltt_kernel_event *event;
	struct lttng_event ev;

	memset(&ev, 0, sizeof(ev));
	ok(!lttng_strncpy(ev.name, get_random_string(),
			RANDOM_STRING_LEN),
		"Validate string length");
	ev.type = LTTNG_EVENT_TRACEPOINT;
	ev.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;

	ret = trace_kernel_create_event(&ev, NULL, NULL, &event);
	ok(ret == LTTNG_OK, "Create kernel event");

	if (!event) {
		skip(1, "Event is null");
		return;
	}

	ok(event->fd == -1 &&
	   event->enabled == 1 &&
	   event->event->instrumentation == LTTNG_KERNEL_ABI_TRACEPOINT &&
	   strlen(event->event->name),
	   "Validate kernel event");

	/* Init list in order to avoid sefaults from cds_list_del */
	CDS_INIT_LIST_HEAD(&event->list);
	trace_kernel_destroy_event(event);
}

static void test_create_kernel_stream(void)
{
	struct ltt_kernel_stream *stream;

	stream = trace_kernel_create_stream("stream1", 0);
	ok(stream != NULL, "Create kernel stream");

	if (!stream) {
		skip(1, "Stream is null");
		return;
	}

	ok(stream->fd == -1 &&
	   stream->state == 0,
	   "Validate kernel stream");

	/* Init list in order to avoid sefaults from cds_list_del */
	CDS_INIT_LIST_HEAD(&stream->list);
	trace_kernel_destroy_stream(stream);
}

int main(int argc, char **argv)
{
	plan_tests(NUM_TESTS);

	diag("Kernel data structure unit test");

	test_create_one_kernel_session();
	test_create_kernel_metadata();
	test_create_kernel_channel();
	test_create_kernel_event();
	test_create_kernel_stream();

	return exit_status();
}
Commit	Line	Data
	1	/*
	2	* Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
	3	*
	4	* SPDX-License-Identifier: GPL-2.0-only
	5	*
	6	*/
	7
	8	#include <assert.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <string.h>
	12	#include <unistd.h>
	13	#include <time.h>
	14
	15	#include <common/compat/errno.h>
	16	#include <bin/lttng-sessiond/trace-kernel.h>
	17	#include <common/defaults.h>
	18
	19	#include <tap/tap.h>
	20
	21	#define RANDOM_STRING_LEN 11
	22
	23	/* Number of TAP tests in this file */
	24	#define NUM_TESTS 11
	25
	26	static const char alphanum[] =
	27	"0123456789"
	28	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	29	"abcdefghijklmnopqrstuvwxyz";
	30
	31	static struct ltt_kernel_session *kern;
	32	static char random_string[RANDOM_STRING_LEN];
	33
	34	/*
	35	* Return random string of 10 characters.
	36	* Not thread-safe.
	37	*/
	38	static char *get_random_string(void)
	39	{
	40	int i;
	41
	42	for (i = 0; i < RANDOM_STRING_LEN - 1; i++) {
	43	random_string[i] = alphanum[rand() % (sizeof(alphanum) - 1)];
	44	}
	45
	46	random_string[RANDOM_STRING_LEN - 1] = '\0';
	47
	48	return random_string;
	49	}
	50
	51	static void test_create_one_kernel_session(void)
	52	{
	53	kern = trace_kernel_create_session();
	54	ok(kern != NULL, "Create kernel session");
	55
	56	if (!kern) {
	57	skip(1, "Kernel session is null");
	58	return;
	59	}
	60	ok(kern->fd == -1 &&
	61	kern->metadata_stream_fd == -1 &&
	62	kern->consumer_fds_sent == 0 &&
	63	kern->channel_count == 0 &&
	64	kern->stream_count_global == 0 &&
	65	kern->metadata == NULL,
	66	"Validate kernel session");
	67	}
	68
	69	static void test_create_kernel_metadata(void)
	70	{
	71	assert(kern != NULL);
	72
	73	kern->metadata = trace_kernel_create_metadata();
	74	ok(kern->metadata != NULL, "Create kernel metadata");
	75
	76	ok(kern->metadata->fd == -1 &&
	77	kern->metadata->conf != NULL &&
	78	kern->metadata->conf->attr.overwrite
	79	== DEFAULT_METADATA_OVERWRITE &&
	80	kern->metadata->conf->attr.subbuf_size
	81	== default_get_metadata_subbuf_size() &&
	82	kern->metadata->conf->attr.num_subbuf
	83	== DEFAULT_METADATA_SUBBUF_NUM &&
	84	kern->metadata->conf->attr.switch_timer_interval
	85	== DEFAULT_METADATA_SWITCH_TIMER &&
	86	kern->metadata->conf->attr.read_timer_interval
	87	== DEFAULT_METADATA_READ_TIMER &&
	88	kern->metadata->conf->attr.output
	89	== LTTNG_EVENT_MMAP,
	90	"Validate kernel session metadata");
	91
	92	trace_kernel_destroy_metadata(kern->metadata);
	93	}
	94
	95	static void test_create_kernel_channel(void)
	96	{
	97	struct ltt_kernel_channel *chan;
	98	struct lttng_channel attr;
	99	struct lttng_channel_extended extended;
	100
	101	memset(&attr, 0, sizeof(attr));
	102	memset(&extended, 0, sizeof(extended));
	103	attr.attr.extended.ptr = &extended;
	104
	105	chan = trace_kernel_create_channel(&attr);
	106	ok(chan != NULL, "Create kernel channel");
	107
	108	if (!chan) {
	109	skip(1, "Channel is null");
	110	return;
	111	}
	112
	113	ok(chan->fd == -1 &&
	114	chan->enabled == 1 &&
	115	chan->stream_count == 0 &&
	116	chan->channel->attr.overwrite == attr.attr.overwrite,
	117	"Validate kernel channel");
	118
	119	/* Init list in order to avoid sefaults from cds_list_del */
	120	CDS_INIT_LIST_HEAD(&chan->list);
	121	trace_kernel_destroy_channel(chan);
	122	}
	123
	124	static void test_create_kernel_event(void)
	125	{
	126	enum lttng_error_code ret;
	127	struct ltt_kernel_event *event;
	128	struct lttng_event ev;
	129
	130	memset(&ev, 0, sizeof(ev));
	131	ok(!lttng_strncpy(ev.name, get_random_string(),
	132	RANDOM_STRING_LEN),
	133	"Validate string length");
	134	ev.type = LTTNG_EVENT_TRACEPOINT;
	135	ev.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
	136
	137	ret = trace_kernel_create_event(&ev, NULL, NULL, &event);
	138	ok(ret == LTTNG_OK, "Create kernel event");
	139
	140	if (!event) {
	141	skip(1, "Event is null");
	142	return;
	143	}
	144
	145	ok(event->fd == -1 &&
	146	event->enabled == 1 &&
	147	event->event->instrumentation == LTTNG_KERNEL_ABI_TRACEPOINT &&
	148	strlen(event->event->name),
	149	"Validate kernel event");
	150
	151	/* Init list in order to avoid sefaults from cds_list_del */
	152	CDS_INIT_LIST_HEAD(&event->list);
	153	trace_kernel_destroy_event(event);
	154	}
	155
	156	static void test_create_kernel_stream(void)
	157	{
	158	struct ltt_kernel_stream *stream;
	159
	160	stream = trace_kernel_create_stream("stream1", 0);
	161	ok(stream != NULL, "Create kernel stream");
	162
	163	if (!stream) {
	164	skip(1, "Stream is null");
	165	return;
	166	}
	167
	168	ok(stream->fd == -1 &&
	169	stream->state == 0,
	170	"Validate kernel stream");
	171
	172	/* Init list in order to avoid sefaults from cds_list_del */
	173	CDS_INIT_LIST_HEAD(&stream->list);
	174	trace_kernel_destroy_stream(stream);
	175	}
	176
	177	int main(int argc, char **argv)
	178	{
	179	plan_tests(NUM_TESTS);
	180
	181	diag("Kernel data structure unit test");
	182
	183	test_create_one_kernel_session();
	184	test_create_kernel_metadata();
	185	test_create_kernel_channel();
	186	test_create_kernel_event();
	187	test_create_kernel_stream();
	188
	189	return exit_status();
	190	}