tests/unit/test_session.cpp

   1 /*
   2  * Copyright (C) 2011 EfficiOS Inc.
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #include <common/common.hpp>
   9 #include <common/compat/errno.hpp>
  10 #include <common/sessiond-comm/sessiond-comm.hpp>
  11
  12 #include <bin/lttng-sessiond/health-sessiond.hpp>
  13 #include <bin/lttng-sessiond/session.hpp>
  14 #include <bin/lttng-sessiond/thread.hpp>
  15 #include <bin/lttng-sessiond/ust-app.hpp>
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <sys/types.h>
  20 #include <tap/tap.h>
  21 #include <time.h>
  22 #include <unistd.h>
  23 #include <urcu.h>
  24
  25 #define SESSION1 "test1"
  26
  27 #define MAX_SESSIONS      10000
  28 #define RANDOM_STRING_LEN 11
  29
  30 /* Number of TAP tests in this file */
  31 #define NUM_TESTS 11
  32
  33 static struct ltt_session_list *session_list;
  34
  35 static const char alphanum[] = "0123456789"
  36                                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  37                                "abcdefghijklmnopqrstuvwxyz";
  38 static char random_string[RANDOM_STRING_LEN];
  39
  40 /*
  41  * Return random string of 10 characters.
  42  * Not thread-safe.
  43  */
  44 static char *get_random_string()
  45 {
  46         int i;
  47
  48         for (i = 0; i < RANDOM_STRING_LEN - 1; i++) {
  49                 random_string[i] = alphanum[rand() % (sizeof(alphanum) - 1)];
  50         }
  51
  52         random_string[RANDOM_STRING_LEN - 1] = '\0';
  53
  54         return random_string;
  55 }
  56
  57 /*
  58  * Return 0 if session name is found, else -1
  59  */
  60 static int find_session_name(const char *name)
  61 {
  62         struct ltt_session *iter;
  63
  64         cds_list_for_each_entry (iter, &session_list->head, list) {
  65                 if (strcmp(iter->name, name) == 0) {
  66                         return 0;
  67                 }
  68         }
  69
  70         return -1;
  71 }
  72
  73 static int session_list_count()
  74 {
  75         int count = 0;
  76         struct ltt_session *iter;
  77
  78         cds_list_for_each_entry (iter, &session_list->head, list) {
  79                 count++;
  80         }
  81         return count;
  82 }
  83
  84 /*
  85  * Empty session list manually.
  86  */
  87 static void empty_session_list()
  88 {
  89         struct ltt_session *iter, *tmp;
  90
  91         session_lock_list();
  92         cds_list_for_each_entry_safe (iter, tmp, &session_list->head, list) {
  93                 session_destroy(iter);
  94         }
  95         session_unlock_list();
  96
  97         /* Session list must be 0 */
  98         LTTNG_ASSERT(!session_list_count());
  99 }
 100
 101 /*
 102  * Test creation of 1 session
 103  */
 104 static int create_one_session(const char *name)
 105 {
 106         int ret;
 107         enum lttng_error_code ret_code;
 108         struct ltt_session *session = nullptr;
 109
 110         session_lock_list();
 111         ret_code = session_create(name, geteuid(), getegid(), &session);
 112         session_put(session);
 113         if (ret_code == LTTNG_OK) {
 114                 /* Validate */
 115                 ret = find_session_name(name);
 116                 if (ret < 0) {
 117                         /* Session not found by name */
 118                         printf("session not found after creation\n");
 119                         ret = -1;
 120                 } else {
 121                         /* Success */
 122                         ret = 0;
 123                 }
 124         } else {
 125                 if (ret_code == LTTNG_ERR_EXIST_SESS) {
 126                         printf("(session already exists) ");
 127                 }
 128                 ret = -1;
 129         }
 130
 131         session_unlock_list();
 132         return ret;
 133 }
 134
 135 /*
 136  * Test deletion of 1 session
 137  */
 138 static int destroy_one_session(struct ltt_session *session)
 139 {
 140         int ret;
 141         char session_name[NAME_MAX];
 142
 143         strncpy(session_name, session->name, sizeof(session_name));
 144         session_name[sizeof(session_name) - 1] = '\0';
 145
 146         session_destroy(session);
 147         session_put(session);
 148
 149         ret = find_session_name(session_name);
 150         if (ret < 0) {
 151                 /* Success, -1 means that the sesion is NOT found */
 152                 ret = 0;
 153         } else {
 154                 /* Fail */
 155                 ret = -1;
 156         }
 157         return ret;
 158 }
 159
 160 /*
 161  * This test is supposed to fail at the second create call. If so, return 0 for
 162  * test success, else -1.
 163  */
 164 static int two_session_same_name()
 165 {
 166         int ret;
 167         struct ltt_session *sess;
 168
 169         ret = create_one_session(SESSION1);
 170         if (ret < 0) {
 171                 /* Fail */
 172                 ret = -1;
 173                 goto end;
 174         }
 175
 176         session_lock_list();
 177         sess = session_find_by_name(SESSION1);
 178         if (sess) {
 179                 /* Success */
 180                 session_put(sess);
 181                 session_unlock_list();
 182                 ret = 0;
 183                 goto end_unlock;
 184         } else {
 185                 /* Fail */
 186                 ret = -1;
 187                 goto end_unlock;
 188         }
 189 end_unlock:
 190         session_unlock_list();
 191 end:
 192         return ret;
 193 }
 194
 195 static void test_session_list()
 196 {
 197         session_list = session_get_list();
 198         ok(session_list != nullptr, "Session list: not NULL");
 199 }
 200
 201 static void test_create_one_session()
 202 {
 203         ok(create_one_session(SESSION1) == 0, "Create session: %s", SESSION1);
 204 }
 205
 206 static void test_validate_session()
 207 {
 208         struct ltt_session *tmp;
 209
 210         session_lock_list();
 211         tmp = session_find_by_name(SESSION1);
 212
 213         ok(tmp != nullptr, "Validating session: session found");
 214
 215         if (tmp) {
 216                 ok(tmp->kernel_session == nullptr && strlen(tmp->name),
 217                    "Validating session: basic sanity check");
 218         } else {
 219                 skip(1, "Skipping session validation check as session was not found");
 220                 goto end;
 221         }
 222
 223         session_lock(tmp);
 224         session_unlock(tmp);
 225         session_put(tmp);
 226 end:
 227         session_unlock_list();
 228 }
 229
 230 static void test_destroy_session()
 231 {
 232         struct ltt_session *tmp;
 233
 234         session_lock_list();
 235         tmp = session_find_by_name(SESSION1);
 236
 237         ok(tmp != nullptr, "Destroying session: session found");
 238
 239         if (tmp) {
 240                 ok(destroy_one_session(tmp) == 0, "Destroying session: %s destroyed", SESSION1);
 241         } else {
 242                 skip(1, "Skipping session destruction as it was not found");
 243         }
 244         session_unlock_list();
 245 }
 246
 247 static void test_duplicate_session()
 248 {
 249         ok(two_session_same_name() == 0, "Duplicate session creation");
 250 }
 251
 252 static void test_session_name_generation()
 253 {
 254         struct ltt_session *session = nullptr;
 255         enum lttng_error_code ret_code;
 256         const char *expected_session_name_prefix = DEFAULT_SESSION_NAME;
 257
 258         session_lock_list();
 259         ret_code = session_create(nullptr, geteuid(), getegid(), &session);
 260         ok(ret_code == LTTNG_OK, "Create session with a NULL name (auto-generate a name)");
 261         if (!session) {
 262                 skip(1, "Skipping session name generation tests as session_create() failed.");
 263                 goto end;
 264         }
 265         diag("Automatically-generated session name: %s", *session->name ? session->name : "ERROR");
 266         ok(*session->name &&
 267                    !strncmp(expected_session_name_prefix,
 268                             session->name,
 269                             sizeof(DEFAULT_SESSION_NAME) - 1),
 270            "Auto-generated session name starts with %s",
 271            DEFAULT_SESSION_NAME);
 272 end:
 273         session_put(session);
 274         session_unlock_list();
 275 }
 276
 277 static void test_large_session_number()
 278 {
 279         int ret, i, failed = 0;
 280         struct ltt_session *iter, *tmp;
 281
 282         for (i = 0; i < MAX_SESSIONS; i++) {
 283                 char *tmp_name = get_random_string();
 284                 ret = create_one_session(tmp_name);
 285                 if (ret < 0) {
 286                         diag("session %d (name: %s) creation failed", i, tmp_name);
 287                         ++failed;
 288                 }
 289         }
 290
 291         ok(failed == 0, "Large sessions number: created %u sessions", MAX_SESSIONS);
 292
 293         failed = 0;
 294
 295         session_lock_list();
 296         for (i = 0; i < MAX_SESSIONS; i++) {
 297                 cds_list_for_each_entry_safe (iter, tmp, &session_list->head, list) {
 298                         LTTNG_ASSERT(session_get(iter));
 299                         ret = destroy_one_session(iter);
 300                         if (ret < 0) {
 301                                 diag("session %d destroy failed", i);
 302                                 ++failed;
 303                         }
 304                 }
 305         }
 306         session_unlock_list();
 307
 308         ok(failed == 0 && session_list_count() == 0,
 309            "Large sessions number: destroyed %u sessions",
 310            MAX_SESSIONS);
 311 }
 312
 313 int main()
 314 {
 315         plan_tests(NUM_TESTS);
 316
 317         the_health_sessiond = health_app_create(NR_HEALTH_SESSIOND_TYPES);
 318
 319         diag("Sessions unit tests");
 320
 321         rcu_register_thread();
 322
 323         test_session_list();
 324
 325         test_create_one_session();
 326
 327         test_validate_session();
 328
 329         test_destroy_session();
 330
 331         test_duplicate_session();
 332
 333         empty_session_list();
 334
 335         test_session_name_generation();
 336
 337         test_large_session_number();
 338
 339         rcu_unregister_thread();
 340         lttng_thread_list_shutdown_orphans();
 341
 342         return exit_status();
 343 }