tests/unit/test_kernel_data.cpp

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