X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;ds=sidebyside;f=src%2Fbin%2Flttng-sessiond%2Fsession.c;h=491de61759825f0485326cae5b2d7e72db72c6ad;hb=b178f53e90c376dd44b020535c32649edef8f80e;hp=173afa8784f47b22e7e24fbc237dbbaae70809d2;hpb=e32d7f274604b77bcd83c24994e88df3761ed658;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/session.c b/src/bin/lttng-sessiond/session.c index 173afa878..491de6175 100644 --- a/src/bin/lttng-sessiond/session.c +++ b/src/bin/lttng-sessiond/session.c @@ -25,6 +25,7 @@ #include #include #include +#include #include #include @@ -54,6 +55,7 @@ static struct ltt_session_list ltt_session_list = { .head = CDS_LIST_HEAD_INIT(ltt_session_list.head), .lock = PTHREAD_MUTEX_INITIALIZER, + .removal_cond = PTHREAD_COND_INITIALIZER, .next_uuid = 0, }; @@ -130,6 +132,19 @@ struct ltt_session_list *session_get_list(void) return <t_session_list; } +/* + * Returns once the session list is empty. + */ +void session_list_wait_empty(void) +{ + pthread_mutex_lock(<t_session_list.lock); + while (!cds_list_empty(<t_session_list.head)) { + pthread_cond_wait(<t_session_list.removal_cond, + <t_session_list.lock); + } + pthread_mutex_unlock(<t_session_list.lock); +} + /* * Acquire session list lock */ @@ -428,8 +443,13 @@ void session_release(struct urcu_ref *ref) consumer_output_put(session->consumer); snapshot_destroy(&session->snapshot); - del_session_list(session); - del_session_ht(session); + + if (session->published) { + ASSERT_LOCKED(ltt_session_list.lock); + del_session_list(session); + del_session_ht(session); + pthread_cond_broadcast(<t_session_list.removal_cond); + } free(session); } @@ -447,6 +467,9 @@ bool session_get(struct ltt_session *session) */ void session_put(struct ltt_session *session) { + if (!session) { + return; + } /* * The session list lock must be held as any session_put() * may cause the removal of the session from the session_list. @@ -534,77 +557,144 @@ end: } /* - * Create a brand new session and add it to the session list. + * Create a new session and add it to the session list. + * Session list lock must be held by the caller. */ -int session_create(char *name, uid_t uid, gid_t gid) +enum lttng_error_code session_create(const char *name, uid_t uid, gid_t gid, + struct ltt_session **out_session) { int ret; - struct ltt_session *new_session; + enum lttng_error_code ret_code; + struct ltt_session *new_session = NULL; - /* Allocate session data structure */ + ASSERT_LOCKED(ltt_session_list.lock); + if (name) { + struct ltt_session *clashing_session; + + clashing_session = session_find_by_name(name); + if (clashing_session) { + session_put(clashing_session); + ret_code = LTTNG_ERR_EXIST_SESS; + goto error; + } + } new_session = zmalloc(sizeof(struct ltt_session)); - if (new_session == NULL) { - PERROR("zmalloc"); - ret = LTTNG_ERR_FATAL; - goto error_malloc; + if (!new_session) { + PERROR("Failed to allocate an ltt_session structure"); + ret_code = LTTNG_ERR_NOMEM; + goto error; } urcu_ref_init(&new_session->ref); + pthread_mutex_init(&new_session->lock, NULL); - /* Define session name */ - if (name != NULL) { - if (snprintf(new_session->name, NAME_MAX, "%s", name) < 0) { - ret = LTTNG_ERR_FATAL; - goto error_asprintf; - } - } else { - ERR("No session name given"); - ret = LTTNG_ERR_FATAL; + new_session->creation_time = time(NULL); + if (new_session->creation_time == (time_t) -1) { + PERROR("Failed to sample session creation time"); + ret_code = LTTNG_ERR_SESSION_FAIL; goto error; } - ret = validate_name(name); - if (ret < 0) { - ret = LTTNG_ERR_SESSION_INVALID_CHAR; + /* Create default consumer output. */ + new_session->consumer = consumer_create_output(CONSUMER_DST_LOCAL); + if (new_session->consumer == NULL) { + ret_code = LTTNG_ERR_NOMEM; goto error; } + if (name) { + ret = lttng_strncpy(new_session->name, name, sizeof(new_session->name)); + if (ret) { + ret_code = LTTNG_ERR_SESSION_INVALID_CHAR; + goto error; + } + ret = validate_name(name); + if (ret < 0) { + ret_code = LTTNG_ERR_SESSION_INVALID_CHAR; + goto error; + } + } else { + int i = 0; + bool found_name = false; + char datetime[16]; + struct tm *timeinfo; + + timeinfo = localtime(&new_session->creation_time); + if (!timeinfo) { + ret_code = LTTNG_ERR_SESSION_FAIL; + goto error; + } + strftime(datetime, sizeof(datetime), "%Y%m%d-%H%M%S", timeinfo); + for (i = 0; i < INT_MAX; i++) { + struct ltt_session *clashing_session; + + if (i == 0) { + ret = snprintf(new_session->name, + sizeof(new_session->name), + "%s-%s", + DEFAULT_SESSION_NAME, + datetime); + } else { + ret = snprintf(new_session->name, + sizeof(new_session->name), + "%s%d-%s", + DEFAULT_SESSION_NAME, i, + datetime); + } + if (ret == -1 || ret >= sizeof(new_session->name)) { + /* + * Null-terminate in case the name is used + * in logging statements. + */ + new_session->name[sizeof(new_session->name) - 1] = '\0'; + ret_code = LTTNG_ERR_SESSION_FAIL; + goto error; + } + + clashing_session = + session_find_by_name(new_session->name); + session_put(clashing_session); + if (!clashing_session) { + found_name = true; + break; + } + } + if (found_name) { + DBG("Generated session name \"%s\"", new_session->name); + new_session->has_auto_generated_name = true; + } else { + ERR("Failed to auto-generate a session name"); + ret_code = LTTNG_ERR_SESSION_FAIL; + goto error; + } + } + ret = gethostname(new_session->hostname, sizeof(new_session->hostname)); if (ret < 0) { if (errno == ENAMETOOLONG) { new_session->hostname[sizeof(new_session->hostname) - 1] = '\0'; + ERR("Hostname exceeds the maximal permitted length and has been truncated to %s", + new_session->hostname); } else { - ret = LTTNG_ERR_FATAL; + ret_code = LTTNG_ERR_SESSION_FAIL; goto error; } } - /* Init kernel session */ - new_session->kernel_session = NULL; - new_session->ust_session = NULL; - - /* Init lock */ - pthread_mutex_init(&new_session->lock, NULL); - new_session->uid = uid; new_session->gid = gid; ret = snapshot_init(&new_session->snapshot); if (ret < 0) { - ret = LTTNG_ERR_NOMEM; + ret_code = LTTNG_ERR_NOMEM; goto error; } - new_session->rotation_pending_local = false; - new_session->rotation_pending_relay = false; new_session->rotation_state = LTTNG_ROTATION_STATE_NO_ROTATION; - new_session->rotation_pending_check_timer_enabled = false; - new_session->rotation_schedule_timer_enabled = false; - - /* Add new session to the session list */ - session_lock_list(); + /* Add new session to the session list. */ new_session->id = add_session_list(new_session); + /* * Add the new session to the ltt_sessions_ht_by_id. * No ownership is taken by the hash table; it is merely @@ -612,23 +702,26 @@ int session_create(char *name, uid_t uid, gid_t gid) * by session id. */ add_session_ht(new_session); - session_unlock_list(); + new_session->published = true; /* - * Consumer is let to NULL since the create_session_uri command will set it - * up and, if valid, assign it to the session. + * Consumer is left to NULL since the create_session_uri command will + * set it up and, if valid, assign it to the session. */ - DBG("Tracing session %s created with ID %" PRIu64 " by UID %d GID %d", - name, new_session->id, new_session->uid, new_session->gid); - - return LTTNG_OK; - + DBG("Tracing session %s created with ID %" PRIu64 " by uid = %d, gid = %d", + new_session->name, new_session->id, new_session->uid, + new_session->gid); + ret_code = LTTNG_OK; +end: + if (new_session) { + (void) session_get(new_session); + *out_session = new_session; + } + return ret_code; error: -error_asprintf: - free(new_session); - -error_malloc: - return ret; + session_put(new_session); + new_session = NULL; + goto end; } /*