tests/unit/test_kernel_data.cpp

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