tests/unit/test_kernel_data.c

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