X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Frotation-thread.c;h=036296a3fe80bcc4a797311fcfa87d6e6f9078fc;hp=aaa2129419cf76d092c4e4b397669c44e7efc99b;hb=16100d7ad8517131cc3ef29743e325184802ad13;hpb=d295668767ac8234e83984e1812d342d03293d88 diff --git a/src/bin/lttng-sessiond/rotation-thread.c b/src/bin/lttng-sessiond/rotation-thread.c index aaa212941..036296a3f 100644 --- a/src/bin/lttng-sessiond/rotation-thread.c +++ b/src/bin/lttng-sessiond/rotation-thread.c @@ -1,19 +1,9 @@ /* - * Copyright (C) 2017 - Julien Desfossez - * Copyright (C) 2018 - Jérémie Galarneau + * Copyright (C) 2017 Julien Desfossez + * Copyright (C) 2018 Jérémie Galarneau * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License, version 2 only, as - * published by the Free Software Foundation. + * SPDX-License-Identifier: GPL-2.0-only * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - * more details. - * - * You should have received a copy of the GNU General Public License along with - * this program; if not, write to the Free Software Foundation, Inc., 51 - * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #define _LGPL_SOURCE @@ -111,33 +101,6 @@ end: return queue; } -void log_job_destruction(const struct rotation_thread_job *job) -{ - enum lttng_error_level log_level; - const char *job_type_str = get_job_type_str(job->type); - - switch (job->type) { - case ROTATION_THREAD_JOB_TYPE_SCHEDULED_ROTATION: - /* - * Not a problem, the scheduled rotation is racing with the teardown - * of the daemon. In this case, the rotation will not happen, which - * is not a problem (or at least, not important enough to delay - * the shutdown of the session daemon). - */ - log_level = PRINT_DBG; - break; - case ROTATION_THREAD_JOB_TYPE_CHECK_PENDING_ROTATION: - /* This is not expected to happen; warn the user. */ - log_level = PRINT_WARN; - break; - default: - abort(); - } - - LOG(log_level, "Rotation thread timer queue still contains job of type %s targeting session \"%s\" on destruction", - job_type_str, job->session->name); -} - void rotation_thread_timer_queue_destroy( struct rotation_thread_timer_queue *queue) { @@ -216,7 +179,7 @@ void rotation_thread_enqueue_job(struct rotation_thread_timer_queue *queue, struct ltt_session *session) { int ret; - const char * const dummy = "!"; + const char dummy = '!'; struct rotation_thread_job *job = NULL; const char *job_type_str = get_job_type_str(job_type); @@ -242,8 +205,8 @@ void rotation_thread_enqueue_job(struct rotation_thread_timer_queue *queue, job->type = job_type; cds_list_add_tail(&job->head, &queue->list); - ret = lttng_write(lttng_pipe_get_writefd(queue->event_pipe), dummy, - 1); + ret = lttng_write(lttng_pipe_get_writefd(queue->event_pipe), &dummy, + sizeof(dummy)); if (ret < 0) { /* * We do not want to block in the timer handler, the job has @@ -385,17 +348,17 @@ void check_session_rotation_pending_on_consumers(struct ltt_session *session, &exists_status); if (ret) { pthread_mutex_unlock(socket->lock); - ERR("Error occured while checking rotation status on consumer daemon"); + ERR("Error occurred while checking rotation status on consumer daemon"); goto end; } - if (exists_status != CONSUMER_TRACE_CHUNK_EXISTS_STATUS_UNKNOWN_CHUNK) { + if (exists_status != CONSUMER_TRACE_CHUNK_EXISTS_STATUS_UNKNOWN_CHUNK) { pthread_mutex_unlock(socket->lock); chunk_exists_on_peer = true; goto end; - } + } pthread_mutex_unlock(socket->lock); - } + } skip_ust: if (!session->kernel_session) { @@ -414,15 +377,15 @@ skip_ust: &exists_status); if (ret) { pthread_mutex_unlock(socket->lock); - ERR("Error occured while checking rotation status on consumer daemon"); + ERR("Error occurred while checking rotation status on consumer daemon"); goto end; } - if (exists_status != CONSUMER_TRACE_CHUNK_EXISTS_STATUS_UNKNOWN_CHUNK) { + if (exists_status != CONSUMER_TRACE_CHUNK_EXISTS_STATUS_UNKNOWN_CHUNK) { pthread_mutex_unlock(socket->lock); chunk_exists_on_peer = true; goto end; - } + } pthread_mutex_unlock(socket->lock); } skip_kernel: @@ -467,6 +430,11 @@ int check_session_rotation_pending(struct ltt_session *session, const char *archived_chunk_name; uint64_t chunk_being_archived_id; + if (!session->chunk_being_archived) { + ret = 0; + goto end; + } + chunk_status = lttng_trace_chunk_get_id(session->chunk_being_archived, &chunk_being_archived_id); assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK); @@ -474,11 +442,6 @@ int check_session_rotation_pending(struct ltt_session *session, DBG("[rotation-thread] Checking for pending rotation on session \"%s\", trace archive %" PRIu64, session->name, chunk_being_archived_id); - if (!session->chunk_being_archived) { - ret = 0; - goto end; - } - /* * The rotation-pending check timer of a session is launched in * one-shot mode. If the rotation is incomplete, the rotation @@ -489,15 +452,14 @@ int check_session_rotation_pending(struct ltt_session *session, */ ret = timer_session_rotation_pending_check_stop(session); if (ret) { - goto end; + goto check_ongoing_rotation; } check_session_rotation_pending_on_consumers(session, &rotation_completed); - if (!rotation_completed || session->rotation_state == LTTNG_ROTATION_STATE_ERROR) { - goto end; + goto check_ongoing_rotation; } /* @@ -514,45 +476,15 @@ int check_session_rotation_pending(struct ltt_session *session, } session_reset_rotation_state(session, LTTNG_ROTATION_STATE_COMPLETED); - location = session_get_trace_archive_location(session); - /* Ownership of location is transferred. */ - ret = notification_thread_command_session_rotation_completed( - notification_thread_handle, - session->name, - session->uid, - session->gid, - session->last_archived_chunk_id.value, - location); - if (ret != LTTNG_OK) { - ERR("[rotation-thread] Failed to notify notification thread of completed rotation for session %s", - session->name); - } - - if (!session->active) { - /* - * A stop command was issued during the rotation, it is - * up to the rotation completion check to perform the - * renaming of the last chunk that was produced. - */ - ret = notification_thread_command_session_rotation_ongoing( - notification_thread_handle, - session->name, - session->uid, - session->gid, - session->most_recent_chunk_id.value); - if (ret != LTTNG_OK) { - ERR("[rotation-thread] Failed to notify notification thread of completed rotation for session %s", - session->name); - } - - /* Ownership of location is transferred. */ + if (!session->quiet_rotation) { location = session_get_trace_archive_location(session); + /* Ownership of location is transferred. */ ret = notification_thread_command_session_rotation_completed( notification_thread_handle, session->name, session->uid, session->gid, - session->most_recent_chunk_id.value, + session->last_archived_chunk_id.value, location); if (ret != LTTNG_OK) { ERR("[rotation-thread] Failed to notify notification thread of completed rotation for session %s", @@ -561,7 +493,7 @@ int check_session_rotation_pending(struct ltt_session *session, } ret = 0; -end: +check_ongoing_rotation: if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING) { uint64_t chunk_being_archived_id; @@ -581,6 +513,7 @@ end: } } +end: return ret; } @@ -594,7 +527,8 @@ int launch_session_rotation(struct ltt_session *session) DBG("[rotation-thread] Launching scheduled time-based rotation on session \"%s\"", session->name); - ret = cmd_rotate_session(session, &rotation_return); + ret = cmd_rotate_session(session, &rotation_return, false, + LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED); if (ret == LTTNG_OK) { DBG("[rotation-thread] Scheduled time-based rotation successfully launched on session \"%s\"", session->name); @@ -614,7 +548,7 @@ int run_job(struct rotation_thread_job *job, struct ltt_session *session, switch (job->type) { case ROTATION_THREAD_JOB_TYPE_SCHEDULED_ROTATION: - ret = launch_session_rotation(session); + ret = launch_session_rotation(session); break; case ROTATION_THREAD_JOB_TYPE_CHECK_PENDING_ROTATION: ret = check_session_rotation_pending(session, @@ -670,7 +604,7 @@ int handle_job_queue(struct rotation_thread_handle *handle, } session_lock(session); - ret = run_job(job, session, handle->notification_thread_handle); + ret = run_job(job, session, handle->notification_thread_handle); session_unlock(session); /* Release reference held by the job. */ session_put(session); @@ -741,7 +675,8 @@ int handle_condition(const struct lttng_condition *condition, goto end_unlock; } - ret = cmd_rotate_session(session, NULL); + ret = cmd_rotate_session(session, NULL, false, + LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED); if (ret == -LTTNG_ERR_ROTATION_PENDING) { DBG("Rotate already pending, subscribe to the next threshold value"); } else if (ret != LTTNG_OK) { @@ -826,26 +761,28 @@ end: return ret; } +static void *thread_rotation(void *data) { int ret; struct rotation_thread_handle *handle = data; struct rotation_thread thread; - const int queue_pipe_fd = lttng_pipe_get_readfd( - handle->rotation_timer_queue->event_pipe); + int queue_pipe_fd; DBG("[rotation-thread] Started rotation thread"); + rcu_register_thread(); + rcu_thread_online(); + health_register(health_sessiond, HEALTH_SESSIOND_TYPE_ROTATION); + health_code_update(); if (!handle) { ERR("[rotation-thread] Invalid thread context provided"); goto end; } - rcu_register_thread(); - rcu_thread_online(); + queue_pipe_fd = lttng_pipe_get_readfd( + handle->rotation_timer_queue->event_pipe); - health_register(health_sessiond, HEALTH_SESSIOND_TYPE_ROTATION); - health_code_update(); ret = init_thread_state(handle, &thread); if (ret) { @@ -913,7 +850,6 @@ void *thread_rotation(void *data) ret = lttng_read(fd, &buf, 1); if (ret != 1) { ERR("[rotation-thread] Failed to read from wakeup pipe (fd = %i)", fd); - ret = -1; goto error; } } else { @@ -927,10 +863,10 @@ exit: error: DBG("[rotation-thread] Exit"); fini_thread_state(&thread); +end: health_unregister(health_sessiond); rcu_thread_offline(); rcu_unregister_thread(); -end: return NULL; }