/*
* Stop tracing for all traces of the session.
*/
static int _lttng_stop_tracing(const char *session_name, int wait)
{
int ret, data_ret;
struct lttcomm_session_msg lsm;
if (session_name == NULL) {
return -LTTNG_ERR_INVALID;
}
lsm.cmd_type = LTTNG_STOP_TRACE;
copy_string(lsm.session.name, session_name, sizeof(lsm.session.name));
ret = ask_sessiond(&lsm, NULL);
if (ret < 0 && ret != -LTTNG_ERR_TRACE_ALREADY_STOPPED) {
goto error;
}
if (!wait) {
goto end;
}
_MSG("Waiting for data availability");
/* Check for data availability */
do {
data_ret = lttng_data_pending(session_name);
if (data_ret < 0) {
/* Return the data available call error. */
ret = data_ret;
goto error;
}
/*
* Data sleep time before retrying (in usec). Don't sleep if the call
* returned value indicates availability.
*/
if (data_ret) {
usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME);
_MSG(".");
}
} while (data_ret != 0);
MSG("");
end:
error:
return ret;
}
static
int cleanup_session(const char *session_name)
{
int ret;
printf("Stopping session %s", session_name);
ret = lttng_stop_tracing_no_wait(session_name);
if (ret) {
fprintf(stderr, "Failed to stop tracing\n");
goto end;
}
fflush(stdout);
do {
ret = lttng_data_pending(session_name);
if (ret < 0) {
/* Return the data available call error. */
goto end;
}
/*
* Data sleep time before retrying (in usec). Don't sleep if the call
* returned value indicates availability.
*/
if (ret) {
usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME);
printf(".");
fflush(stdout);
}
} while (ret != 0);
printf("\n");
printf("Destroying session %s\n", session_name);
ret = lttng_destroy_session(session_name);
if (ret) {
fprintf(stderr, "Failed to destroy the session\n");
goto end;
}
ret = 0;
end:
return ret;
}
/*
* destroy_session
*
* Unregister the provided session to the session daemon. On success, removes
* the default configuration.
*/
static int destroy_session(struct lttng_session *session)
{
int ret;
char *session_name = NULL;
bool session_was_stopped;
ret = lttng_stop_tracing_no_wait(session->name);
if (ret < 0 && ret != -LTTNG_ERR_TRACE_ALREADY_STOPPED) {
ERR("%s", lttng_strerror(ret));
}
session_was_stopped = ret == -LTTNG_ERR_TRACE_ALREADY_STOPPED;
if (!opt_no_wait) {
bool printed_wait_msg = false;
do {
ret = lttng_data_pending(session->name);
if (ret < 0) {
/* Return the data available call error. */
goto error;
}
/*
* Data sleep time before retrying (in usec). Don't sleep if the call
* returned value indicates availability.
*/
if (ret) {
if (!printed_wait_msg) {
_MSG("Waiting for data availability");
fflush(stdout);
}
printed_wait_msg = true;
usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME);
_MSG(".");
fflush(stdout);
}
} while (ret != 0);
if (printed_wait_msg) {
MSG("");
}
}
if (!session_was_stopped) {
/*
* Don't print the event and packet loss warnings since the user
* already saw them when stopping the trace.
*/
print_session_stats(session->name);
}
ret = lttng_destroy_session_no_wait(session->name);
if (ret < 0) {
goto error;
}
MSG("Session %s destroyed", session->name);
session_name = get_session_name_quiet();
if (session_name && !strncmp(session->name, session_name, NAME_MAX)) {
config_destroy_default();
}
if (lttng_opt_mi) {
ret = mi_lttng_session(writer, session, 0);
if (ret) {
ret = CMD_ERROR;
goto error;
}
}
ret = CMD_SUCCESS;
error:
free(session_name);
return ret;
}
/*
* Start tracing for all trace of the session.
*/
static int stop_tracing(void)
{
int ret;
char *session_name;
if (opt_session_name == NULL) {
session_name = get_session_name();
if (session_name == NULL) {
ret = CMD_ERROR;
goto error;
}
} else {
session_name = opt_session_name;
}
ret = lttng_stop_tracing_no_wait(session_name);
if (ret < 0) {
switch (-ret) {
case LTTNG_ERR_TRACE_ALREADY_STOPPED:
WARN("Tracing already stopped for session %s", session_name);
break;
default:
ERR("%s", lttng_strerror(ret));
break;
}
goto free_name;
}
if (!opt_no_wait) {
_MSG("Waiting for data availability");
fflush(stdout);
do {
ret = lttng_data_pending(session_name);
if (ret < 0) {
/* Return the data available call error. */
goto free_name;
}
/*
* Data sleep time before retrying (in usec). Don't sleep if the call
* returned value indicates availability.
*/
if (ret) {
usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME);
_MSG(".");
fflush(stdout);
}
} while (ret != 0);
MSG("");
}
ret = CMD_SUCCESS;
print_session_stats(session_name);
MSG("Tracing stopped for session %s", session_name);
if (lttng_opt_mi) {
ret = mi_print_session(session_name, 0);
if (ret) {
goto free_name;
}
}
free_name:
if (opt_session_name == NULL) {
free(session_name);
}
error:
return ret;
}
