From 5461b305aef403f7f2e48c977c188b5526746c6e Mon Sep 17 00:00:00 2001 From: David Goulet Date: Mon, 16 May 2011 17:34:23 -0400 Subject: [PATCH] Major changes of command processing for sessiond This follows up a TODO added at commit 5e16da05 by me and Mathieu Desnoyers about the command processing using a command context. This patch introduce a command context data structure which contains all the necessary information to process a command received by the session daemon from the lttng client. The entire session daemon is refactored with this addition. All userspace trace action also. The global current_session pointer is removed and is now in the command context struct. Some of the functions for the buffer allocation are removed/changed. This is the first step of getting the session daemon multi-threaded. This patch also fix the -h bug of the lttng client introduce in the commit 5e16da05. Minor variable renaming also occured. Signed-off-by: David Goulet --- liblttngctl/liblttngctl.c | 18 +- liblttsessiondcomm/liblttsessiondcomm.h | 12 +- ltt-sessiond/ltt-sessiond.h | 12 + ltt-sessiond/main.c | 337 ++++++++++++++---------- ltt-sessiond/session.c | 4 +- ltt-sessiond/session.h | 9 +- ltt-sessiond/trace.c | 37 +-- ltt-sessiond/trace.h | 7 +- lttng/options.c | 2 +- 9 files changed, 250 insertions(+), 188 deletions(-) diff --git a/liblttngctl/liblttngctl.c b/liblttngctl/liblttngctl.c index 3ff1529a1..38be54774 100644 --- a/liblttngctl/liblttngctl.c +++ b/liblttngctl/liblttngctl.c @@ -35,7 +35,7 @@ static char sessiond_sock_path[PATH_MAX]; /* Communication structure to ltt-sessiond */ static struct lttcomm_session_msg lsm; -static struct lttcomm_lttng_header llh; +static struct lttcomm_lttng_msg llm; /* Prototypes */ static int check_tracing_group(const char *grp_name); @@ -125,18 +125,18 @@ static int ask_sessiond(enum lttcomm_sessiond_command lct, void **buf) } /* Get header from data transmission */ - ret = recv_data_sessiond(&llh, sizeof(llh)); + ret = recv_data_sessiond(&llm, sizeof(llm)); if (ret < 0) { goto end; } /* Check error code if OK */ - if (llh.ret_code != LTTCOMM_OK) { - ret = -llh.ret_code; + if (llm.ret_code != LTTCOMM_OK) { + ret = -llm.ret_code; goto end; } - size = llh.payload_size; + size = llm.trace_name_offset + llm.data_size; if (size == 0) { goto end; } @@ -250,7 +250,7 @@ int lttng_list_traces(uuid_t *uuid, struct lttng_trace **traces) { int ret; - uuid_copy(lsm.session_id, *uuid); + uuid_copy(lsm.session_uuid, *uuid); ret = ask_sessiond(LTTNG_LIST_TRACES, (void **) traces); if (ret < 0) { @@ -278,7 +278,7 @@ int lttng_create_session(char *name, uuid_t *session_id) goto end; } - uuid_copy(*session_id, llh.session_id); + uuid_copy(*session_id, llm.session_uuid); end: return ret; @@ -293,7 +293,7 @@ int lttng_destroy_session(uuid_t *uuid) { int ret; - uuid_copy(lsm.session_id, *uuid); + uuid_copy(lsm.session_uuid, *uuid); ret = ask_sessiond(LTTNG_DESTROY_SESSION, NULL); if (ret < 0) { @@ -377,7 +377,7 @@ int lttng_disconnect_sessiond(void) */ void lttng_set_current_session_uuid(uuid_t *uuid) { - uuid_copy(lsm.session_id, *uuid); + uuid_copy(lsm.session_uuid, *uuid); } /* diff --git a/liblttsessiondcomm/liblttsessiondcomm.h b/liblttsessiondcomm/liblttsessiondcomm.h index a1960a940..4a7fdfcc4 100644 --- a/liblttsessiondcomm/liblttsessiondcomm.h +++ b/liblttsessiondcomm/liblttsessiondcomm.h @@ -115,7 +115,7 @@ enum lttcomm_kconsumerd_fd_state { */ struct lttcomm_session_msg { u32 cmd_type; /* enum lttcomm_sessiond_command */ - uuid_t session_id; + uuid_t session_uuid; char trace_name[NAME_MAX]; char session_name[NAME_MAX]; u32 pid; /* pid_t */ @@ -148,13 +148,15 @@ struct lttcomm_session_msg { /* * Data structure for the response from sessiond to the lttng client. */ -struct lttcomm_lttng_header { +struct lttcomm_lttng_msg { u32 cmd_type; /* enum lttcomm_sessiond_command */ u32 ret_code; /* enum lttcomm_return_code */ u32 pid; /* pid_t */ - u32 payload_size; - uuid_t session_id; - char trace_name[NAME_MAX]; + u32 trace_name_offset; + u32 data_size; + uuid_t session_uuid; + /* Contains: trace_name + data */ + char payload[]; }; /* diff --git a/ltt-sessiond/ltt-sessiond.h b/ltt-sessiond/ltt-sessiond.h index ab82bf8c5..7133d061f 100644 --- a/ltt-sessiond/ltt-sessiond.h +++ b/ltt-sessiond/ltt-sessiond.h @@ -27,4 +27,16 @@ extern const char default_home_dir[], default_ust_sock_dir[], default_global_apps_pipe[]; +/* + * This contains extra data needed for processing a command received by the + * session daemon from the lttng client. + */ +struct command_ctx { + int ust_sock; + unsigned int lttng_msg_size; + struct ltt_session *session; + struct lttcomm_lttng_msg *llm; + struct lttcomm_session_msg *lsm; +}; + #endif /* _LTT_SESSIOND_H */ diff --git a/ltt-sessiond/main.c b/ltt-sessiond/main.c index 21b05fc86..c50bfd88c 100644 --- a/ltt-sessiond/main.c +++ b/ltt-sessiond/main.c @@ -62,16 +62,16 @@ static int check_existing_daemon(void); static int ust_connect_app(pid_t pid); static int init_daemon_socket(void); static int notify_apps(const char* name); -static int process_client_msg(int sock, struct lttcomm_session_msg*); +static int process_client_msg(struct command_ctx *cmd_ctx); static int send_unix_sock(int sock, void *buf, size_t len); static int set_signal_handler(void); static int set_permissions(void); -static int setup_data_buffer(char **buf, size_t size, struct lttcomm_lttng_header *llh); +static int setup_lttng_msg(struct command_ctx *cmd_ctx, size_t size); static int create_lttng_rundir(void); static int set_kconsumerd_sockets(void); static void cleanup(void); -static void copy_common_data(struct lttcomm_lttng_header *llh, struct lttcomm_session_msg *lsm); static void sighandler(int sig); +static void clean_command_ctx(struct command_ctx *cmd_ctx); static void *thread_manage_clients(void *data); static void *thread_manage_apps(void *data); @@ -96,9 +96,6 @@ static int client_sock; static int apps_sock; static int kconsumerd_err_sock; -/* Extern in session.h */ -struct ltt_session *current_session; - /* * thread_manage_kconsumerd * @@ -208,7 +205,7 @@ error: static void *thread_manage_clients(void *data) { int sock, ret; - struct lttcomm_session_msg lsm; + struct command_ctx *cmd_ctx; DBG("[thread] Manage client started"); @@ -226,31 +223,53 @@ static void *thread_manage_clients(void *data) while (1) { /* Blocking call, waiting for transmission */ + DBG("Accepting client command ..."); sock = lttcomm_accept_unix_sock(client_sock); if (sock < 0) { goto error; } + /* Allocate context command to process the client request */ + cmd_ctx = malloc(sizeof(struct command_ctx)); + + /* Allocate data buffer for reception */ + cmd_ctx->lsm = malloc(sizeof(struct lttcomm_session_msg)); + cmd_ctx->llm = NULL; + cmd_ctx->session = NULL; + /* * Data is received from the lttng client. The struct - * lttcomm_session_msg (lsm) contains the command and data - * request of the client. + * lttcomm_session_msg (lsm) contains the command and data request of + * the client. */ - ret = lttcomm_recv_unix_sock(sock, &lsm, sizeof(lsm)); + DBG("Receiving data from client ..."); + ret = lttcomm_recv_unix_sock(sock, cmd_ctx->lsm, sizeof(struct lttcomm_session_msg)); if (ret <= 0) { continue; } - /* This function dispatch the work to the LTTng or UST libs - * and then sends back the response to the client. This is needed - * because there might be more then one lttcomm_lttng_header to - * send out so process_client_msg do both jobs. + /* + * This function dispatch the work to the kernel or userspace tracer + * libs and fill the lttcomm_lttng_msg data structure of all the needed + * informations for the client. The command context struct contains + * everything this function may needs. */ - ret = process_client_msg(sock, &lsm); + ret = process_client_msg(cmd_ctx); if (ret < 0) { + /* TODO: Inform client somehow of the fatal error. At this point, + * ret < 0 means that a malloc failed (ENOMEM). */ /* Error detected but still accept command */ + clean_command_ctx(cmd_ctx); continue; } + + DBG("Sending response to client (size: %d)", cmd_ctx->lttng_msg_size); + ret = send_unix_sock(sock, cmd_ctx->llm, cmd_ctx->lttng_msg_size); + if (ret < 0) { + ERR("Failed to send data back to client"); + } + + clean_command_ctx(cmd_ctx); } error: @@ -274,6 +293,26 @@ static int send_unix_sock(int sock, void *buf, size_t len) return lttcomm_send_unix_sock(sock, buf, len); } +/* + * clean_command_ctx + * + * Free memory of a command context structure. + */ +static void clean_command_ctx(struct command_ctx *cmd_ctx) +{ + DBG("Clean command context structure %p", cmd_ctx); + if (cmd_ctx) { + if (cmd_ctx->llm) { + free(cmd_ctx->llm); + } + if (cmd_ctx->lsm) { + free(cmd_ctx->lsm); + } + free(cmd_ctx); + cmd_ctx = NULL; + } +} + /* * ust_connect_app * @@ -338,50 +377,45 @@ error: } /* - * copy_common_data + * setup_lttng_msg * - * Copy common data between lttcomm_lttng_header and lttcomm_session_msg - */ -static void copy_common_data(struct lttcomm_lttng_header *llh, struct lttcomm_session_msg *lsm) -{ - llh->cmd_type = lsm->cmd_type; - llh->pid = lsm->pid; - - /* Manage uuid */ - if (!uuid_is_null(lsm->session_id)) { - uuid_copy(llh->session_id, lsm->session_id); - } - - strncpy(llh->trace_name, lsm->trace_name, strlen(llh->trace_name)); - llh->trace_name[strlen(llh->trace_name) - 1] = '\0'; -} - -/* - * setup_data_buffer - * - * Setup the outgoing data buffer for the response - * data allocating the right amount of memory. + * Setup the outgoing data buffer for the response (llm) by allocating the + * right amount of memory and copying the original information from the lsm + * structure. * * Return total size of the buffer pointed by buf. */ -static int setup_data_buffer(char **buf, size_t s_data, struct lttcomm_lttng_header *llh) +static int setup_lttng_msg(struct command_ctx *cmd_ctx, size_t size) { - int ret = 0; - size_t buf_size; + int ret, buf_size, trace_name_size; - buf_size = sizeof(struct lttcomm_lttng_header) + s_data; - *buf = malloc(buf_size); - if (*buf == NULL) { + /* + * Check for the trace_name. If defined, it's part of the payload data of + * the llm structure. + */ + trace_name_size = strlen(cmd_ctx->lsm->trace_name); + buf_size = trace_name_size + size; + + cmd_ctx->llm = malloc(sizeof(struct lttcomm_lttng_msg) + buf_size); + if (cmd_ctx->llm == NULL) { perror("malloc"); - ret = -1; + ret = -ENOMEM; goto error; } - /* Setup lttcomm_lttng_header data and copy - * it to the newly allocated buffer. - */ - llh->payload_size = s_data; - memcpy(*buf, llh, sizeof(struct lttcomm_lttng_header)); + /* Copy common data */ + cmd_ctx->llm->cmd_type = cmd_ctx->lsm->cmd_type; + cmd_ctx->llm->pid = cmd_ctx->lsm->pid; + if (!uuid_is_null(cmd_ctx->lsm->session_uuid)) { + uuid_copy(cmd_ctx->llm->session_uuid, cmd_ctx->lsm->session_uuid); + } + + cmd_ctx->llm->trace_name_offset = trace_name_size; + cmd_ctx->llm->data_size = size; + cmd_ctx->lttng_msg_size = sizeof(struct lttcomm_lttng_msg) + buf_size; + + /* Copy trace name to the llm structure. Begining of the payload. */ + memcpy(cmd_ctx->llm->payload, cmd_ctx->lsm->trace_name, trace_name_size); return buf_size; @@ -392,202 +426,217 @@ error: /* * process_client_msg * - * This takes the lttcomm_session_msg struct and process the command requested - * by the client. It then creates response(s) and send it back to the - * given socket (sock). + * Process the command requested by the lttng client within the command + * context structure. This function make sure that the return structure (llm) + * is set and ready for transmission before returning. * * Return any error encountered or 0 for success. */ -static int process_client_msg(int sock, struct lttcomm_session_msg *lsm) +static int process_client_msg(struct command_ctx *cmd_ctx) { - int ust_sock, ret, buf_size; - size_t header_size; - char *send_buf = NULL; - struct lttcomm_lttng_header llh; + int ret; - DBG("Processing client message"); - - /* Copy common data to identify the response - * on the lttng client side. - */ - copy_common_data(&llh, lsm); + DBG("Processing client command %d", cmd_ctx->lsm->cmd_type); /* Check command that needs a session */ - switch (lsm->cmd_type) { + switch (cmd_ctx->lsm->cmd_type) { case LTTNG_CREATE_SESSION: case LTTNG_LIST_SESSIONS: case UST_LIST_APPS: break; default: - current_session = find_session_by_uuid(lsm->session_id); - if (current_session == NULL) { + cmd_ctx->session = find_session_by_uuid(cmd_ctx->lsm->session_uuid); + if (cmd_ctx->session == NULL) { ret = LTTCOMM_SELECT_SESS; - goto end; + goto error; } break; } - /* Default return code. - * In our world, everything is OK... right? ;) - */ - llh.ret_code = LTTCOMM_OK; - - header_size = sizeof(struct lttcomm_lttng_header); - /* Connect to ust apps if available pid */ - if (lsm->pid != 0) { + if (cmd_ctx->lsm->pid > 0) { /* Connect to app using ustctl API */ - ust_sock = ust_connect_app(lsm->pid); - if (ust_sock < 0) { + cmd_ctx->ust_sock = ust_connect_app(cmd_ctx->lsm->pid); + if (cmd_ctx->ust_sock < 0) { ret = LTTCOMM_NO_TRACEABLE; - goto end; + goto error; } } /* Process by command type */ - switch (lsm->cmd_type) { + switch (cmd_ctx->lsm->cmd_type) { case LTTNG_CREATE_SESSION: { - ret = create_session(lsm->session_name, &llh.session_id); + /* Setup lttng message with no payload */ + ret = setup_lttng_msg(cmd_ctx, 0); + if (ret < 0) { + goto setup_error; + } + + ret = create_session(cmd_ctx->lsm->session_name, &cmd_ctx->llm->session_uuid); if (ret < 0) { if (ret == -1) { ret = LTTCOMM_EXIST_SESS; } else { ret = LTTCOMM_FATAL; } - goto end; - } - - buf_size = setup_data_buffer(&send_buf, 0, &llh); - if (buf_size < 0) { - ret = LTTCOMM_FATAL; - goto end; + goto error; } + ret = LTTCOMM_OK; break; } case LTTNG_DESTROY_SESSION: { - ret = destroy_session(&lsm->session_id); + /* Setup lttng message with no payload */ + ret = setup_lttng_msg(cmd_ctx, 0); + if (ret < 0) { + goto setup_error; + } + + ret = destroy_session(&cmd_ctx->lsm->session_uuid); if (ret < 0) { ret = LTTCOMM_NO_SESS; - } else { - ret = LTTCOMM_OK; + goto error; } - /* No auxiliary data so only send the llh struct. */ - goto end; + ret = LTTCOMM_OK; + break; } case LTTNG_LIST_TRACES: { - unsigned int trace_count = get_trace_count_per_session(current_session); + unsigned int trace_count; + trace_count = get_trace_count_per_session(cmd_ctx->session); if (trace_count == 0) { ret = LTTCOMM_NO_TRACE; - goto end; + goto error; } - buf_size = setup_data_buffer(&send_buf, - sizeof(struct lttng_trace) * trace_count, &llh); - if (buf_size < 0) { - ret = LTTCOMM_FATAL; - goto end; + ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_trace) * trace_count); + if (ret < 0) { + goto setup_error; } - get_traces_per_session(current_session, (struct lttng_trace *)(send_buf + header_size)); + get_traces_per_session(cmd_ctx->session, + (struct lttng_trace *)(cmd_ctx->llm->payload)); + + ret = LTTCOMM_OK; break; } case UST_CREATE_TRACE: { - ret = ust_create_trace(ust_sock, lsm->pid); + /* Setup lttng message with no payload */ + ret = setup_lttng_msg(cmd_ctx, 0); if (ret < 0) { - /* If -1 is returned from ust_create_trace, malloc - * failed so it's pretty much a fatal error. - */ - ret = LTTCOMM_FATAL; - goto end; + goto setup_error; } - /* No auxiliary data so only send the llh struct. */ - goto end; + ret = ust_create_trace(cmd_ctx); + if (ret < 0) { + goto setup_error; + } + break; } case UST_LIST_APPS: { - unsigned int app_count = get_app_count(); - /* Stop right now if no apps */ + unsigned int app_count; + + app_count = get_app_count(); + DBG("Traceable application count : %d", app_count); if (app_count == 0) { ret = LTTCOMM_NO_APPS; - goto end; + goto error; } - /* Setup data buffer and details for transmission */ - buf_size = setup_data_buffer(&send_buf, - sizeof(pid_t) * app_count, &llh); - if (buf_size < 0) { - ret = LTTCOMM_FATAL; - goto end; + ret = setup_lttng_msg(cmd_ctx, sizeof(pid_t) * app_count); + if (ret < 0) { + goto setup_error; } - get_app_list_pids((pid_t *)(send_buf + header_size)); + get_app_list_pids((pid_t *)(cmd_ctx->llm->payload)); + ret = LTTCOMM_OK; break; } case UST_START_TRACE: { - ret = ust_start_trace(ust_sock, lsm->pid); + /* Setup lttng message with no payload */ + ret = setup_lttng_msg(cmd_ctx, 0); + if (ret < 0) { + goto setup_error; + } - /* No auxiliary data so only send the llh struct. */ - goto end; + ret = ust_start_trace(cmd_ctx); + if (ret < 0) { + goto setup_error; + } + break; } case UST_STOP_TRACE: { - ret = ust_stop_trace(ust_sock, lsm->pid); + /* Setup lttng message with no payload */ + ret = setup_lttng_msg(cmd_ctx, 0); + if (ret < 0) { + goto setup_error; + } - /* No auxiliary data so only send the llh struct. */ - goto end; + ret = ust_stop_trace(cmd_ctx); + if (ret < 0) { + goto setup_error; + } + break; } case LTTNG_LIST_SESSIONS: { - unsigned int session_count = get_session_count(); - /* Stop right now if no session */ + unsigned int session_count; + + session_count = get_session_count(); if (session_count == 0) { ret = LTTCOMM_NO_SESS; - goto end; + goto error; } - /* Setup data buffer and details for transmission */ - buf_size = setup_data_buffer(&send_buf, - (sizeof(struct lttng_session) * session_count), &llh); - if (buf_size < 0) { - ret = LTTCOMM_FATAL; - goto end; + ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_session) * session_count); + if (ret < 0) { + goto setup_error; } - get_lttng_session((struct lttng_session *)(send_buf + header_size)); + get_lttng_session((struct lttng_session *)(cmd_ctx->llm->payload)); + ret = LTTCOMM_OK; break; } default: /* Undefined command */ + ret = setup_lttng_msg(cmd_ctx, 0); + if (ret < 0) { + goto setup_error; + } + ret = LTTCOMM_UND; - goto end; + break; } - ret = send_unix_sock(sock, send_buf, buf_size); - - if (send_buf != NULL) { - free(send_buf); - } + /* Set return code */ + cmd_ctx->llm->ret_code = ret; return ret; -end: +error: DBG("Return code to client %d", ret); + + if (cmd_ctx->llm == NULL) { + DBG("Missing llm structure. Allocating one."); + ret = setup_lttng_msg(cmd_ctx, 0); + if (ret < 0) { + goto setup_error; + } + } /* Notify client of error */ - llh.ret_code = ret; - llh.payload_size = 0; - send_unix_sock(sock, (void*) &llh, sizeof(llh)); + cmd_ctx->llm->ret_code = ret; +setup_error: return ret; } diff --git a/ltt-sessiond/session.c b/ltt-sessiond/session.c index 93f03e4c5..069213655 100644 --- a/ltt-sessiond/session.c +++ b/ltt-sessiond/session.c @@ -224,7 +224,7 @@ error_mem: * Iterate over the global session list and * fill the lttng_session array. */ -void get_lttng_session(struct lttng_session *lt) +void get_lttng_session(struct lttng_session *sessions) { int i = 0; struct ltt_session *iter; @@ -240,7 +240,7 @@ void get_lttng_session(struct lttng_session *lt) uuid_copy(lsess.uuid, iter->uuid); strncpy(lsess.name, iter->name, sizeof(lsess.name)); lsess.name[sizeof(lsess.name) - 1] = '\0'; - memcpy(<[i], &lsess, sizeof(lsess)); + memcpy(&sessions[i], &lsess, sizeof(lsess)); i++; /* Reset struct for next pass */ memset(&lsess, 0, sizeof(lsess)); diff --git a/ltt-sessiond/session.h b/ltt-sessiond/session.h index 11f9b9ace..586c55a24 100644 --- a/ltt-sessiond/session.h +++ b/ltt-sessiond/session.h @@ -22,13 +22,6 @@ #include #include -/* - * FIXME: create a cmd_context structure to pass this kind of - * information around as parameter. Will facilitate multithreaded design - * later. - */ -extern struct ltt_session *current_session; - /* Global session list */ struct ltt_session_list { struct cds_list_head head; @@ -52,7 +45,7 @@ struct ltt_session { /* Prototypes */ int create_session(char *name, uuid_t *session_id); int destroy_session(uuid_t *uuid); -void get_lttng_session(struct lttng_session *lt); +void get_lttng_session(struct lttng_session *sessions); struct ltt_session *find_session_by_uuid(uuid_t session_id); struct ltt_session *find_session_by_name(char *name); unsigned int get_session_count(void); diff --git a/ltt-sessiond/trace.c b/ltt-sessiond/trace.c index a821327e2..9a3c95956 100644 --- a/ltt-sessiond/trace.c +++ b/ltt-sessiond/trace.c @@ -29,6 +29,7 @@ #include "lttngerr.h" #include "trace.h" #include "session.h" +#include "ltt-sessiond.h" static struct ltt_ust_trace *find_session_ust_trace_by_pid( struct ltt_session *session, pid_t pid); @@ -111,12 +112,12 @@ void get_traces_per_session(struct ltt_session *session, struct lttng_trace *tra * This trace is then appended to the current session * ust trace list. */ -int ust_create_trace(int sock, pid_t pid) +int ust_create_trace(struct command_ctx *cmd_ctx) { int ret; struct ltt_ust_trace *trace; - DBG("Creating trace for pid %d", pid); + DBG("Creating trace for pid %d", cmd_ctx->lsm->pid); trace = malloc(sizeof(struct ltt_ust_trace)); if (trace == NULL) { @@ -126,7 +127,7 @@ int ust_create_trace(int sock, pid_t pid) } /* Init */ - trace->pid = pid; + trace->pid = cmd_ctx->lsm->pid; trace->shmid = 0; /* NOTE: to be removed. Trace name will no longer be * required for LTTng userspace tracer. For now, we set it @@ -134,19 +135,19 @@ int ust_create_trace(int sock, pid_t pid) */ snprintf(trace->name, 5, "auto"); - ret = ustctl_create_trace(sock, trace->name); + ret = ustctl_create_trace(cmd_ctx->ust_sock, trace->name); if (ret < 0) { ret = LTTCOMM_CREATE_FAIL; goto error_create; } /* Check if current session is valid */ - if (current_session) { - cds_list_add(&trace->list, ¤t_session->ust_traces); - current_session->ust_trace_count++; + if (cmd_ctx->session) { + cds_list_add(&trace->list, &cmd_ctx->session->ust_traces); + cmd_ctx->session->ust_trace_count++; } - return 0; + return LTTCOMM_OK; error_create: free(trace); @@ -160,25 +161,27 @@ error: * Start a trace. This trace, identified by the pid, must be * in the current session ust_traces list. */ -int ust_start_trace(int sock, pid_t pid) +int ust_start_trace(struct command_ctx *cmd_ctx) { int ret; struct ltt_ust_trace *trace; - DBG("Starting trace for pid %d", pid); + DBG("Starting trace for pid %d", cmd_ctx->lsm->pid); - trace = find_session_ust_trace_by_pid(current_session, pid); + trace = find_session_ust_trace_by_pid(cmd_ctx->session, cmd_ctx->lsm->pid); if (trace == NULL) { ret = LTTCOMM_NO_TRACE; goto error; } - ret = ustctl_start_trace(sock, "auto"); + ret = ustctl_start_trace(cmd_ctx->ust_sock, "auto"); if (ret < 0) { ret = LTTCOMM_START_FAIL; goto error; } + ret = LTTCOMM_OK; + error: return ret; } @@ -189,25 +192,27 @@ error: * Stop a trace. This trace, identified by the pid, must be * in the current session ust_traces list. */ -int ust_stop_trace(int sock, pid_t pid) +int ust_stop_trace(struct command_ctx *cmd_ctx) { int ret; struct ltt_ust_trace *trace; - DBG("Stopping trace for pid %d", pid); + DBG("Stopping trace for pid %d", cmd_ctx->lsm->pid); - trace = find_session_ust_trace_by_pid(current_session, pid); + trace = find_session_ust_trace_by_pid(cmd_ctx->session, cmd_ctx->lsm->pid); if (trace == NULL) { ret = LTTCOMM_NO_TRACE; goto error; } - ret = ustctl_stop_trace(sock, trace->name); + ret = ustctl_stop_trace(cmd_ctx->ust_sock, trace->name); if (ret < 0) { ret = LTTCOMM_STOP_FAIL; goto error; } + ret = LTTCOMM_OK; + error: return ret; } diff --git a/ltt-sessiond/trace.h b/ltt-sessiond/trace.h index a7eadcbc8..5114272d8 100644 --- a/ltt-sessiond/trace.h +++ b/ltt-sessiond/trace.h @@ -19,6 +19,7 @@ #ifndef _LTT_TRACE_H #define _LTT_TRACE_H +#include "ltt-sessiond.h" #include "session.h" /* LTTng trace representation */ @@ -45,8 +46,8 @@ struct ltt_ust_marker { int get_trace_count_per_session(struct ltt_session *session); void get_traces_per_session(struct ltt_session *session, struct lttng_trace *traces); -int ust_create_trace(int sock, pid_t pid); -int ust_start_trace(int sock, pid_t pid); -int ust_stop_trace(int sock, pid_t pid); +int ust_create_trace(struct command_ctx *cmd_ctx); +int ust_start_trace(struct command_ctx *cmd_ctx); +int ust_stop_trace(struct command_ctx *cmd_ctx); #endif /* _LTT_TRACE_H */ diff --git a/lttng/options.c b/lttng/options.c index 279bc2ffd..de2681054 100644 --- a/lttng/options.c +++ b/lttng/options.c @@ -41,7 +41,7 @@ int opt_stop_trace = 0; pid_t opt_trace_pid = 0; enum { - OPT_HELP, + OPT_HELP = 1, OPT_CREATE_SESSION, OPT_DESTROY_SESSION, }; -- 2.34.1