X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=tests%2Funit%2Ftest_session.c;h=4e659d5242b6af9f1fdf5ee91ac5e711159d33e7;hp=a6d76c73df49a96a8300f4ca3834811e9d87c441;hb=c109c263a5bf6c52d3a1cf27e26a784fb28fac07;hpb=81d029da32ba3c502bdce6ea56b3603eed77e951 diff --git a/tests/unit/test_session.c b/tests/unit/test_session.c index a6d76c73d..4e659d524 100644 --- a/tests/unit/test_session.c +++ b/tests/unit/test_session.c @@ -16,7 +16,6 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE #include #include #include @@ -25,39 +24,36 @@ #include #include #include +#include + +#include #include +#include +#include +#include +#include #include #include -#include "utils.h" - #define SESSION1 "test1" -/* This path will NEVER be created in this test */ -#define PATH1 "/tmp/.test-junk-lttng" - #define MAX_SESSIONS 10000 #define RANDOM_STRING_LEN 11 -/* - * String of 263 caracters. NAME_MAX + "OVERFLOW". If OVERFLOW appears in the - * session name, we have a problem. - * - * NAME_MAX = 255 - */ -#define OVERFLOW_SESSION_NAME \ - "abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd" \ - "abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd" \ - "abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd" \ - "abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabc" \ - "OVERFLOW" +/* Number of TAP tests in this file */ +#define NUM_TESTS 11 +struct health_app *health_sessiond; static struct ltt_session_list *session_list; -/* For lttngerr.h */ +/* For error.h */ int lttng_opt_quiet = 1; int lttng_opt_verbose = 0; +int lttng_opt_mi; + +int ust_consumerd32_fd; +int ust_consumerd64_fd; static const char alphanum[] = "0123456789" @@ -116,10 +112,11 @@ static void empty_session_list(void) { struct ltt_session *iter, *tmp; + session_lock_list(); cds_list_for_each_entry_safe(iter, tmp, &session_list->head, list) { - cds_list_del(&iter->list); - free(iter); + session_destroy(iter); } + session_unlock_list(); /* Session list must be 0 */ assert(!session_list_count()); @@ -128,30 +125,35 @@ static void empty_session_list(void) /* * Test creation of 1 session */ -static int create_one_session(char *name, char *path) +static int create_one_session(char *name) { int ret; + enum lttng_error_code ret_code; + struct ltt_session *session = NULL; - ret = session_create(name, path, geteuid(), getegid()); - if (ret == LTTNG_OK) { + session_lock_list(); + ret_code = session_create(name, geteuid(), getegid(), &session); + session_put(session); + if (ret_code == LTTNG_OK) { /* Validate */ ret = find_session_name(name); if (ret < 0) { /* Session not found by name */ printf("session not found after creation\n"); - return -1; + ret = -1; } else { /* Success */ - return 0; + ret = 0; } } else { - if (ret == LTTNG_ERR_EXIST_SESS) { + if (ret_code == LTTNG_ERR_EXIST_SESS) { printf("(session already exists) "); } - return -1; + ret = -1; } - return 0; + session_unlock_list(); + return ret; } /* @@ -160,47 +162,23 @@ static int create_one_session(char *name, char *path) static int destroy_one_session(struct ltt_session *session) { int ret; + char session_name[NAME_MAX]; - ret = session_destroy(session); + strncpy(session_name, session->name, sizeof(session_name)); + session_name[sizeof(session_name) - 1] = '\0'; - if (ret == LTTNG_OK) { - /* Validate */ - if (session == NULL) { - return 0; - } - ret = find_session_name(session->name); - if (ret < 0) { - /* Success, -1 means that the sesion is NOT found */ - return 0; - } else { - /* Fail */ - return -1; - } - } - - return 0; -} - -static int fuzzing_create_args(void) -{ - int ret; - - ret = create_one_session(NULL, NULL); - if (ret > 0) { - printf("Session created with (null),(null)\n"); - return -1; - } + session_destroy(session); + session_put(session); - ret = create_one_session(NULL, PATH1); - if (ret > 0) { - printf("Session created with (null), %s)\n", PATH1); - return -1; + ret = find_session_name(session_name); + if (ret < 0) { + /* Success, -1 means that the sesion is NOT found */ + ret = 0; + } else { + /* Fail */ + ret = -1; } - - /* Session list must be 0 */ - assert(!session_list_count()); - - return 0; + return ret; } /* @@ -212,119 +190,193 @@ static int two_session_same_name(void) int ret; struct ltt_session *sess; - ret = create_one_session(SESSION1, PATH1); + ret = create_one_session(SESSION1); if (ret < 0) { /* Fail */ - return -1; + ret = -1; + goto end; } + session_lock_list(); sess = session_find_by_name(SESSION1); if (sess) { /* Success */ - return 0; + session_put(sess); + session_unlock_list(); + ret = 0; + goto end_unlock; + } else { + /* Fail */ + ret = -1; + goto end_unlock; } +end_unlock: + session_unlock_list(); +end: + return ret; +} - /* Fail */ - return -1; +static void test_session_list(void) +{ + session_list = session_get_list(); + ok(session_list != NULL, "Session list: not NULL"); } -int main(int argc, char **argv) +static void test_create_one_session(void) { - int ret, i; - struct ltt_session *iter, *tmp; + ok(create_one_session(SESSION1) == 0, + "Create session: %s", + SESSION1); +} - srand(time(NULL)); +static void test_validate_session(void) +{ + struct ltt_session *tmp; - printf("\nTesting Sessions:\n-----------\n"); + session_lock_list(); + tmp = session_find_by_name(SESSION1); - session_list = session_get_list(); - if (session_list == NULL) { - return -1; - } + ok(tmp != NULL, + "Validating session: session found"); - printf("Create 1 session %s: ", SESSION1); - fflush(stdout); - ret = create_one_session(SESSION1, PATH1); - if (ret < 0) { - return -1; + if (tmp) { + ok(tmp->kernel_session == NULL && + strlen(tmp->name), + "Validating session: basic sanity check"); + } else { + skip(1, "Skipping session validation check as session was not found"); + goto end; } - PRINT_OK(); - printf("Validating created session %s: ", SESSION1); - fflush(stdout); - tmp = session_find_by_name(SESSION1); - if (tmp == NULL) { - return -1; - } - /* Basic init session values */ - assert(tmp->kernel_session == NULL); - assert(strlen(tmp->path)); - assert(strlen(tmp->name)); session_lock(tmp); session_unlock(tmp); + session_put(tmp); +end: + session_unlock_list(); +} - PRINT_OK(); +static void test_destroy_session(void) +{ + struct ltt_session *tmp; - printf("Destroy 1 session %s: ", SESSION1); - fflush(stdout); - ret = destroy_one_session(tmp); - if (ret < 0) { - return -1; - } - PRINT_OK(); + session_lock_list(); + tmp = session_find_by_name(SESSION1); - printf("Two session with same name: "); - fflush(stdout); - ret = two_session_same_name(); - if (ret < 0) { - return -1; + ok(tmp != NULL, + "Destroying session: session found"); + + if (tmp) { + ok(destroy_one_session(tmp) == 0, + "Destroying session: %s destroyed", + SESSION1); + } else { + skip(1, "Skipping session destruction as it was not found"); } - PRINT_OK(); + session_unlock_list(); +} - empty_session_list(); +static void test_duplicate_session(void) +{ + ok(two_session_same_name() == 0, + "Duplicate session creation"); +} - printf("Fuzzing create_session arguments: "); - fflush(stdout); - ret = fuzzing_create_args(); - if (ret < 0) { - return -1; +static void test_session_name_generation(void) +{ + struct ltt_session *session = NULL; + enum lttng_error_code ret_code; + const char *expected_session_name_prefix = DEFAULT_SESSION_NAME; + + session_lock_list(); + ret_code = session_create(NULL, geteuid(), getegid(), &session); + ok(ret_code == LTTNG_OK, + "Create session with a NULL name (auto-generate a name)"); + if (!session) { + skip(1, "Skipping session name generation tests as session_create() failed."); + goto end; } - PRINT_OK(); + diag("Automatically-generated session name: %s", *session->name ? + session->name : "ERROR"); + ok(*session->name && !strncmp(expected_session_name_prefix, session->name, + sizeof(DEFAULT_SESSION_NAME) - 1), + "Auto-generated session name starts with %s", + DEFAULT_SESSION_NAME); +end: + session_put(session); + session_unlock_list(); +} + +static void test_large_session_number(void) +{ + int ret, i, failed = 0; + struct ltt_session *iter, *tmp; - printf("Creating %d sessions: ", MAX_SESSIONS); - fflush(stdout); for (i = 0; i < MAX_SESSIONS; i++) { char *tmp_name = get_random_string(); - - ret = create_one_session(tmp_name, PATH1); + ret = create_one_session(tmp_name); if (ret < 0) { - printf("session %d (name: %s) creation failed\n", i, tmp_name); - return -1; - } - - if ((i % 1000) == 0) { - fprintf(stdout, "%d..", i); - fflush(stdout); + diag("session %d (name: %s) creation failed", i, tmp_name); + ++failed; } } - PRINT_OK(); - printf("Destroying %d sessions: ", MAX_SESSIONS); - fflush(stdout); + ok(failed == 0, + "Large sessions number: created %u sessions", + MAX_SESSIONS); + + failed = 0; + + session_lock_list(); for (i = 0; i < MAX_SESSIONS; i++) { cds_list_for_each_entry_safe(iter, tmp, &session_list->head, list) { + assert(session_get(iter)); ret = destroy_one_session(iter); if (ret < 0) { - printf("session %d (name: %s) creation failed\n", i, iter->name); - return -1; + diag("session %d destroy failed", i); + ++failed; } } } - PRINT_OK(); + session_unlock_list(); - /* Session list must be 0 */ - assert(!session_list_count()); + ok(failed == 0 && session_list_count() == 0, + "Large sessions number: destroyed %u sessions", + MAX_SESSIONS); +} + +int main(int argc, char **argv) +{ + struct lttng_thread *ht_cleanup_thread; + + plan_tests(NUM_TESTS); + + health_sessiond = health_app_create(NR_HEALTH_SESSIOND_TYPES); + ht_cleanup_thread = launch_ht_cleanup_thread(); + assert(ht_cleanup_thread); + lttng_thread_put(ht_cleanup_thread); + + diag("Sessions unit tests"); + + rcu_register_thread(); + + test_session_list(); + + test_create_one_session(); + + test_validate_session(); + + test_destroy_session(); + + test_duplicate_session(); + + empty_session_list(); + + test_session_name_generation(); + + test_large_session_number(); + + rcu_unregister_thread(); + lttng_thread_list_shutdown_orphans(); - /* Success */ - return 0; + return exit_status(); }