X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fsession.c;h=0da2058fdf28dbbef05f0d2490cfbf49a089a294;hp=9072a2ecbead28a7b1c1e990d9d827f009e8af89;hb=ccbdaca404a66cf124ec7e4926b1507327f6d165;hpb=78fc586baa98ae77506c34eac8bb980a7d3cc901 diff --git a/src/bin/lttng-sessiond/session.c b/src/bin/lttng-sessiond/session.c index 9072a2ecb..0da2058fd 100644 --- a/src/bin/lttng-sessiond/session.c +++ b/src/bin/lttng-sessiond/session.c @@ -46,6 +46,11 @@ struct ltt_session_destroy_notifier_element { void *user_data; }; +struct ltt_session_clear_notifier_element { + ltt_session_clear_notifier notifier; + void *user_data; +}; + /* * NOTES: * @@ -302,7 +307,7 @@ end: * * The session list lock must be held. */ -int ltt_sessions_ht_alloc(void) +static int ltt_sessions_ht_alloc(void) { int ret = 0; @@ -491,7 +496,8 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session, pthread_mutex_lock(socket->lock); ret = consumer_create_trace_chunk(socket, relayd_id, - session->id, new_trace_chunk); + session->id, new_trace_chunk, + DEFAULT_UST_TRACE_DIR); pthread_mutex_unlock(socket->lock); if (ret) { goto error; @@ -521,7 +527,8 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session, pthread_mutex_lock(socket->lock); ret = consumer_create_trace_chunk(socket, relayd_id, - session->id, new_trace_chunk); + session->id, new_trace_chunk, + DEFAULT_KERNEL_TRACE_DIR); pthread_mutex_unlock(socket->lock); if (ret) { goto error; @@ -575,7 +582,7 @@ struct lttng_trace_chunk *session_create_new_trace_chunk( const time_t chunk_creation_ts = time(NULL); bool is_local_trace; const char *base_path; - struct lttng_directory_handle session_output_directory; + struct lttng_directory_handle *session_output_directory = NULL; const struct lttng_credentials session_credentials = { .uid = session->uid, .gid = session->gid, @@ -640,28 +647,29 @@ struct lttng_trace_chunk *session_create_new_trace_chunk( if (ret) { goto error; } - ret = lttng_directory_handle_init(&session_output_directory, - base_path); - if (ret) { + session_output_directory = lttng_directory_handle_create(base_path); + if (!session_output_directory) { goto error; } chunk_status = lttng_trace_chunk_set_as_owner(trace_chunk, - &session_output_directory); - lttng_directory_handle_fini(&session_output_directory); + session_output_directory); + lttng_directory_handle_put(session_output_directory); + session_output_directory = NULL; if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) { goto error; } end: return trace_chunk; error: + lttng_directory_handle_put(session_output_directory); lttng_trace_chunk_put(trace_chunk); trace_chunk = NULL; goto end; } -int session_close_trace_chunk(const struct ltt_session *session, +int session_close_trace_chunk(struct ltt_session *session, struct lttng_trace_chunk *trace_chunk, - const enum lttng_trace_chunk_command_type *close_command, + enum lttng_trace_chunk_command_type close_command, char *closed_trace_chunk_path) { int ret = 0; @@ -671,13 +679,11 @@ int session_close_trace_chunk(const struct ltt_session *session, enum lttng_trace_chunk_status chunk_status; const time_t chunk_close_timestamp = time(NULL); - if (close_command) { - chunk_status = lttng_trace_chunk_set_close_command( - trace_chunk, *close_command); - if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) { - ret = -1; - goto end; - } + chunk_status = lttng_trace_chunk_set_close_command( + trace_chunk, close_command); + if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) { + ret = -1; + goto end; } if (chunk_close_timestamp == (time_t) -1) { @@ -768,6 +774,25 @@ void session_notify_destruction(const struct ltt_session *session) } } +/* + * Fire each clear notifier once, and remove them from the array. + */ +void session_notify_clear(struct ltt_session *session) +{ + size_t i; + const size_t count = lttng_dynamic_array_get_count( + &session->clear_notifiers); + + for (i = 0; i < count; i++) { + const struct ltt_session_clear_notifier_element *element = + lttng_dynamic_array_get_element( + &session->clear_notifiers, i); + + element->notifier(session, element->user_data); + } + lttng_dynamic_array_clear(&session->clear_notifiers); +} + static void session_release(struct urcu_ref *ref) { @@ -811,7 +836,6 @@ void session_release(struct urcu_ref *ref) DBG("Destroying session %s (id %" PRIu64 ")", session->name, session->id); - consumer_output_put(session->consumer); snapshot_destroy(&session->snapshot); pthread_mutex_destroy(&session->lock); @@ -823,6 +847,7 @@ void session_release(struct urcu_ref *ref) } session_notify_destruction(session); + consumer_output_put(session->consumer); kernel_free_session(ksess); session->kernel_session = NULL; if (usess) { @@ -830,6 +855,7 @@ void session_release(struct urcu_ref *ref) session->ust_session = NULL; } lttng_dynamic_array_reset(&session->destroy_notifiers); + lttng_dynamic_array_reset(&session->clear_notifiers); free(session->last_archived_chunk_name); free(session->base_path); free(session); @@ -898,6 +924,18 @@ int session_add_destroy_notifier(struct ltt_session *session, &element); } +int session_add_clear_notifier(struct ltt_session *session, + ltt_session_clear_notifier notifier, void *user_data) +{ + const struct ltt_session_clear_notifier_element element = { + .notifier = notifier, + .user_data = user_data + }; + + return lttng_dynamic_array_add_element(&session->clear_notifiers, + &element); +} + /* * Return a ltt_session structure ptr that matches name. If no session found, * NULL is returned. This must be called with the session list lock held using @@ -962,7 +1000,7 @@ end: * Session list lock must be held by the caller. */ enum lttng_error_code session_create(const char *name, uid_t uid, gid_t gid, - const char *base_path, struct ltt_session **out_session) + struct ltt_session **out_session) { int ret; enum lttng_error_code ret_code; @@ -989,6 +1027,9 @@ enum lttng_error_code session_create(const char *name, uid_t uid, gid_t gid, lttng_dynamic_array_init(&new_session->destroy_notifiers, sizeof(struct ltt_session_destroy_notifier_element), NULL); + lttng_dynamic_array_init(&new_session->clear_notifiers, + sizeof(struct ltt_session_clear_notifier_element), + NULL); urcu_ref_init(&new_session->ref); pthread_mutex_init(&new_session->lock, NULL); @@ -1086,16 +1127,6 @@ enum lttng_error_code session_create(const char *name, uid_t uid, gid_t gid, } } - if (base_path) { - new_session->base_path = strdup(base_path); - if (!new_session->base_path) { - ERR("Failed to allocate base path of session \"%s\"", - name); - ret_code = LTTNG_ERR_SESSION_FAIL; - goto error; - } - } - new_session->uid = uid; new_session->gid = gid; @@ -1163,7 +1194,7 @@ int session_access_ok(struct ltt_session *session, uid_t uid, gid_t gid) * * Be careful of the result passed to this function. For instance, * on failure to launch a rotation, a client will expect the rotation - * state to be set to "NO_ROTATION". If an error occured while the + * state to be set to "NO_ROTATION". If an error occurred while the * rotation was "ONGOING", result should be set to "ERROR", which will * allow a client to report it. * @@ -1193,6 +1224,11 @@ int session_reset_rotation_state(struct ltt_session *session, chunk_id); lttng_trace_chunk_put(session->chunk_being_archived); session->chunk_being_archived = NULL; + /* + * Fire the clear reply notifiers if we are completing a clear + * rotation. + */ + session_notify_clear(session); } return ret; }