Major changes of command processing for sessiond
authorDavid Goulet <david.goulet@polymtl.ca>
Mon, 16 May 2011 21:34:23 +0000 (17:34 -0400)
committerDavid Goulet <david.goulet@polymtl.ca>
Mon, 16 May 2011 21:45:35 +0000 (17:45 -0400)
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 <david.goulet@polymtl.ca>
liblttngctl/liblttngctl.c
liblttsessiondcomm/liblttsessiondcomm.h
ltt-sessiond/ltt-sessiond.h
ltt-sessiond/main.c
ltt-sessiond/session.c
ltt-sessiond/session.h
ltt-sessiond/trace.c
ltt-sessiond/trace.h
lttng/options.c

index 3ff1529a1857434202ac7acbd7f1d71fe1a3607b..38be54774049532c8d9cef30a67c244454109b96 100644 (file)
@@ -35,7 +35,7 @@ static char sessiond_sock_path[PATH_MAX];
 
 /* Communication structure to ltt-sessiond */
 static struct lttcomm_session_msg lsm;
 
 /* 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);
 
 /* 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 */
        }
 
        /* 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 (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;
        }
 
                goto end;
        }
 
-       size = llh.payload_size;
+       size = llm.trace_name_offset + llm.data_size;
        if (size == 0) {
                goto end;
        }
        if (size == 0) {
                goto end;
        }
@@ -250,7 +250,7 @@ int lttng_list_traces(uuid_t *uuid, struct lttng_trace **traces)
 {
        int ret;
 
 {
        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) {
 
        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;
        }
 
                goto end;
        }
 
-       uuid_copy(*session_id, llh.session_id);
+       uuid_copy(*session_id, llm.session_uuid);
 
 end:
        return ret;
 
 end:
        return ret;
@@ -293,7 +293,7 @@ int lttng_destroy_session(uuid_t *uuid)
 {
        int ret;
 
 {
        int ret;
 
-       uuid_copy(lsm.session_id, *uuid);
+       uuid_copy(lsm.session_uuid, *uuid);
 
        ret = ask_sessiond(LTTNG_DESTROY_SESSION, NULL);
        if (ret < 0) {
 
        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)
 {
  */
 void lttng_set_current_session_uuid(uuid_t *uuid)
 {
-       uuid_copy(lsm.session_id, *uuid);
+       uuid_copy(lsm.session_uuid, *uuid);
 }
 
 /*
 }
 
 /*
index a1960a94018f95178765ed922118a46c0431756c..4a7fdfcc48155e44c9937dd471649e38bbec5e3e 100644 (file)
@@ -115,7 +115,7 @@ enum lttcomm_kconsumerd_fd_state {
  */
 struct lttcomm_session_msg {
        u32 cmd_type;    /* enum lttcomm_sessiond_command */
  */
 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 */
        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.
  */
 /*
  * 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 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[];
 };
 
 /*
 };
 
 /*
index ab82bf8c579ed4a3621d4686975a353e9b4d87ed..7133d061fee9d03d064dd206e7017969141284d1 100644 (file)
@@ -27,4 +27,16 @@ extern const char default_home_dir[],
        default_ust_sock_dir[],
        default_global_apps_pipe[];
 
        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 */
 #endif /* _LTT_SESSIOND_H */
index 21b05fc8621847523169bae1d59d77e3bdf21391..c50bfd88c5d7538638081c3d7f44511848724d8a 100644 (file)
@@ -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 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 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 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 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);
 
 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;
 
 static int apps_sock;
 static int kconsumerd_err_sock;
 
-/* Extern in session.h */
-struct ltt_session *current_session;
-
 /*
  *  thread_manage_kconsumerd
  *
 /*
  *  thread_manage_kconsumerd
  *
@@ -208,7 +205,7 @@ error:
 static void *thread_manage_clients(void *data)
 {
        int sock, ret;
 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");
 
 
        DBG("[thread] Manage client started");
 
@@ -226,31 +223,53 @@ static void *thread_manage_clients(void *data)
 
        while (1) {
                /* Blocking call, waiting for transmission */
 
        while (1) {
                /* Blocking call, waiting for transmission */
+               DBG("Accepting client command ...");
                sock = lttcomm_accept_unix_sock(client_sock);
                if (sock < 0) {
                        goto error;
                }
 
                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
                /*
                 * 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;
                }
 
                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) {
                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 */
                        /* Error detected but still accept command */
+                       clean_command_ctx(cmd_ctx);
                        continue;
                }
                        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:
        }
 
 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);
 }
 
        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
  *
 /*
  *     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.
  */
  *
  *  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");
                perror("malloc");
-               ret = -1;
+               ret = -ENOMEM;
                goto error;
        }
 
                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;
 
 
        return buf_size;
 
@@ -392,202 +426,217 @@ error:
 /*
  *     process_client_msg
  *
 /*
  *     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.
  */
  *
  *     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 */
 
        /* 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:
        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;
                        ret = LTTCOMM_SELECT_SESS;
-                       goto end;
+                       goto error;
                }
                break;
        }
 
                }
                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 */
        /* Connect to ust apps if available pid */
-       if (lsm->pid != 0) {
+       if (cmd_ctx->lsm->pid > 0) {
                /* Connect to app using ustctl API */
                /* 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;
                        ret = LTTCOMM_NO_TRACEABLE;
-                       goto end;
+                       goto error;
                }
        }
 
        /* Process by command type */
                }
        }
 
        /* Process by command type */
-       switch (lsm->cmd_type) {
+       switch (cmd_ctx->lsm->cmd_type) {
        case LTTNG_CREATE_SESSION:
        {
        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;
                        }
                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:
        {
                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;
                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:
        {
        }
        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;
                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:
        {
                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 (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:
        {
        }
        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;
                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:
        {
                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:
        {
        }
        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:
        {
        }
        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;
                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 */
                break;
        }
        default:
                /* Undefined command */
+               ret = setup_lttng_msg(cmd_ctx, 0);
+               if (ret < 0) {
+                       goto setup_error;
+               }
+
                ret = LTTCOMM_UND;
                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;
 
 
        return ret;
 
-end:
+error:
        DBG("Return code to client %d", ret);
        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 */
        /* 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;
 }
 
        return ret;
 }
 
index 93f03e4c5ef11386d7fc5fdf36288993d246b078..069213655323a978eb0c355f482782be2e0f2fe6 100644 (file)
@@ -224,7 +224,7 @@ error_mem:
  *  Iterate over the global session list and
  *  fill the lttng_session array.
  */
  *  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;
 {
        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';
                uuid_copy(lsess.uuid, iter->uuid);
                strncpy(lsess.name, iter->name, sizeof(lsess.name));
                lsess.name[sizeof(lsess.name) - 1] = '\0';
-               memcpy(&lt[i], &lsess, sizeof(lsess));
+               memcpy(&sessions[i], &lsess, sizeof(lsess));
                i++;
                /* Reset struct for next pass */
                memset(&lsess, 0, sizeof(lsess));
                i++;
                /* Reset struct for next pass */
                memset(&lsess, 0, sizeof(lsess));
index 11f9b9ace8986b0366e046d5787a7803fa38180c..586c55a246ddc70908fe76e0265239c8ae481c4c 100644 (file)
 #include <lttng/lttng.h>
 #include <uuid/uuid.h>
 
 #include <lttng/lttng.h>
 #include <uuid/uuid.h>
 
-/*
- * 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;
 /* 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);
 /* 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);
 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);
index a821327e253242ef780b4d8c06614687169cfdbf..9a3c95956439e08a462b8e1e21f25ed050359a08 100644 (file)
@@ -29,6 +29,7 @@
 #include "lttngerr.h"
 #include "trace.h"
 #include "session.h"
 #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);
 
 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.
  */
  *  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;
 
 {
        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) {
 
        trace = malloc(sizeof(struct ltt_ust_trace));
        if (trace == NULL) {
@@ -126,7 +127,7 @@ int ust_create_trace(int sock, pid_t pid)
        }
 
        /* Init */
        }
 
        /* 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
        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");
 
         */
        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 (ret < 0) {
                ret = LTTCOMM_CREATE_FAIL;
                goto error_create;
        }
 
        /* Check if current session is valid */
-       if (current_session) {
-               cds_list_add(&trace->list, &current_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);
 
 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.
  */
  *  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;
 
 {
        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;
        }
 
        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;
        }
 
        if (ret < 0) {
                ret = LTTCOMM_START_FAIL;
                goto error;
        }
 
+       ret = LTTCOMM_OK;
+
 error:
        return ret;
 }
 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.
  */
  *  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;
 
 {
        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;
        }
 
        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;
        }
 
        if (ret < 0) {
                ret = LTTCOMM_STOP_FAIL;
                goto error;
        }
 
+       ret = LTTCOMM_OK;
+
 error:
        return ret;
 }
 error:
        return ret;
 }
index a7eadcbc8d3081e6bdb9ddd82a9feed84346f22e..5114272d879d3e354e081dd1c786a35b526f4454 100644 (file)
@@ -19,6 +19,7 @@
 #ifndef _LTT_TRACE_H
 #define _LTT_TRACE_H
 
 #ifndef _LTT_TRACE_H
 #define _LTT_TRACE_H
 
+#include "ltt-sessiond.h"
 #include "session.h"
 
 /* LTTng trace representation */
 #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 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 */
 
 #endif /* _LTT_TRACE_H */
index 279bc2ffd6dd28d4593049be62c9d7db8ecb581d..de2681054c93d2dbbfd95088a860fd3909e7dda7 100644 (file)
@@ -41,7 +41,7 @@ int opt_stop_trace = 0;
 pid_t opt_trace_pid = 0;
 
 enum {
 pid_t opt_trace_pid = 0;
 
 enum {
-       OPT_HELP,
+       OPT_HELP = 1,
        OPT_CREATE_SESSION,
        OPT_DESTROY_SESSION,
 };
        OPT_CREATE_SESSION,
        OPT_DESTROY_SESSION,
 };
This page took 0.055976 seconds and 4 git commands to generate.