X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=lttng-sessiond%2Fmain.c;h=9464c2c1b8e0f4f3d17ef300cf15975d2174c6ec;hp=cc7885399c288a24cabf2c10dd9e431b6b0778de;hb=8be98f9a4419d360bce0678981ba3f4b891b0a19;hpb=421cb6011479aad4a37260e2e496c353a89318c0 diff --git a/lttng-sessiond/main.c b/lttng-sessiond/main.c index cc7885399..9464c2c1b 100644 --- a/lttng-sessiond/main.c +++ b/lttng-sessiond/main.c @@ -157,6 +157,8 @@ static struct ust_cmd_queue ust_cmd_queue; */ static struct ltt_session_list *session_list_ptr; +int ust_consumer_fd; + /* * Create a poll set with O_CLOEXEC and add the thread quit pipe to the set. */ @@ -588,9 +590,9 @@ static int setup_lttng_msg(struct command_ctx *cmd_ctx, size_t size) buf_size = size; - cmd_ctx->llm = malloc(sizeof(struct lttcomm_lttng_msg) + buf_size); + cmd_ctx->llm = zmalloc(sizeof(struct lttcomm_lttng_msg) + buf_size); if (cmd_ctx->llm == NULL) { - perror("malloc"); + perror("zmalloc"); ret = -ENOMEM; goto error; } @@ -1057,6 +1059,12 @@ static void *thread_manage_apps(void *data) goto error; } + /* + * Add channel(s) and event(s) to newly registered apps + * from lttng global UST domain. + */ + update_ust_app(ust_cmd.sock); + ret = ustctl_register_done(ust_cmd.sock); if (ret < 0) { /* @@ -1078,11 +1086,6 @@ static void *thread_manage_apps(void *data) ust_cmd.sock); } - /* - * Add channel(s) and event(s) to newly registered apps - * from lttng global UST domain. - */ - update_ust_app(ust_cmd.sock); break; } } else { @@ -1097,7 +1100,7 @@ static void *thread_manage_apps(void *data) goto error; } - /* Socket closed */ + /* Socket closed on remote end. */ ust_app_unregister(pollfd); break; } @@ -1259,9 +1262,9 @@ static void *thread_registration_apps(void *data) } /* Create UST registration command for enqueuing */ - ust_cmd = malloc(sizeof(struct ust_command)); + ust_cmd = zmalloc(sizeof(struct ust_command)); if (ust_cmd == NULL) { - perror("ust command malloc"); + perror("ust command zmalloc"); goto error; } @@ -1787,6 +1790,7 @@ static void list_lttng_sessions(struct lttng_session *sessions) sessions[i].path[PATH_MAX - 1] = '\0'; strncpy(sessions[i].name, session->name, NAME_MAX); sessions[i].name[NAME_MAX - 1] = '\0'; + sessions[i].enabled = session->enabled; i++; } } @@ -1794,7 +1798,7 @@ static void list_lttng_sessions(struct lttng_session *sessions) /* * Fill lttng_channel array of all channels. */ -static void list_lttng_channels(struct ltt_session *session, +static void list_lttng_channels(int domain, struct ltt_session *session, struct lttng_channel *channels) { int i = 0; @@ -1802,59 +1806,163 @@ static void list_lttng_channels(struct ltt_session *session, DBG("Listing channels for session %s", session->name); - /* Kernel channels */ - if (session->kernel_session != NULL) { - cds_list_for_each_entry(kchan, - &session->kernel_session->channel_list.head, list) { - /* Copy lttng_channel struct to array */ - memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel)); - channels[i].enabled = kchan->enabled; + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + /* Kernel channels */ + if (session->kernel_session != NULL) { + cds_list_for_each_entry(kchan, + &session->kernel_session->channel_list.head, list) { + /* Copy lttng_channel struct to array */ + memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel)); + channels[i].enabled = kchan->enabled; + i++; + } + } + break; + case LTTNG_DOMAIN_UST: + { + struct cds_lfht_iter iter; + struct ltt_ust_channel *uchan; + + cds_lfht_for_each_entry(session->ust_session->domain_global.channels, + &iter, uchan, node) { + strncpy(channels[i].name, uchan->name, LTTNG_SYMBOL_NAME_LEN); + channels[i].attr.overwrite = uchan->attr.overwrite; + channels[i].attr.subbuf_size = uchan->attr.subbuf_size; + channels[i].attr.num_subbuf = uchan->attr.num_subbuf; + channels[i].attr.switch_timer_interval = + uchan->attr.switch_timer_interval; + channels[i].attr.read_timer_interval = + uchan->attr.read_timer_interval; + channels[i].attr.output = uchan->attr.output; + } + break; + } + default: + break; + } +} + +/* + * Create a list of ust global domain events. + */ +static int list_lttng_ust_global_events(char *channel_name, + struct ltt_ust_domain_global *ust_global, struct lttng_event **events) +{ + int i = 0, ret = 0; + unsigned int nb_event = 0; + struct cds_lfht_iter iter; + struct ltt_ust_channel *uchan; + struct ltt_ust_event *uevent; + struct lttng_event *tmp; + + DBG("Listing UST global events for channel %s", channel_name); + + rcu_read_lock(); + + /* Count events in all channels */ + cds_lfht_for_each_entry(ust_global->channels, &iter, uchan, node) { + nb_event += hashtable_get_count(uchan->events); + } + + if (nb_event == 0) { + ret = nb_event; + goto error; + } + + DBG3("Listing UST global %d events", nb_event); + + tmp = zmalloc(nb_event * sizeof(struct lttng_event)); + if (tmp == NULL) { + ret = -LTTCOMM_FATAL; + goto error; + } + + cds_lfht_for_each_entry(ust_global->channels, &iter, uchan, node) { + cds_lfht_for_each_entry(uchan->events, &iter, uevent, node) { + strncpy(tmp[i].name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN); + tmp[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; + tmp[i].enabled = uevent->enabled; + switch (uevent->attr.instrumentation) { + case LTTNG_UST_TRACEPOINT: + tmp[i].type = LTTNG_EVENT_TRACEPOINT; + break; + case LTTNG_UST_PROBE: + tmp[i].type = LTTNG_EVENT_PROBE; + break; + case LTTNG_UST_FUNCTION: + tmp[i].type = LTTNG_EVENT_FUNCTION; + break; + } i++; } } - /* TODO: Missing UST listing */ + ret = nb_event; + *events = tmp; + +error: + rcu_read_unlock(); + return ret; } /* - * Fill lttng_event array of all events in the channel. + * Fill lttng_event array of all kernel events in the channel. */ -static void list_lttng_events(struct ltt_kernel_channel *kchan, - struct lttng_event *events) +static int list_lttng_kernel_events(char *channel_name, + struct ltt_kernel_session *kernel_session, struct lttng_event **events) { - /* - * TODO: This is ONLY kernel. Need UST support. - */ - int i = 0; + int i = 0, ret; + unsigned int nb_event; struct ltt_kernel_event *event; + struct ltt_kernel_channel *kchan; + + kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session); + if (kchan == NULL) { + ret = LTTCOMM_KERN_CHAN_NOT_FOUND; + goto error; + } + + nb_event = kchan->event_count; DBG("Listing events for channel %s", kchan->channel->name); + if (nb_event == 0) { + ret = nb_event; + goto error; + } + + *events = zmalloc(nb_event * sizeof(struct lttng_event)); + if (*events == NULL) { + ret = LTTCOMM_FATAL; + goto error; + } + /* Kernel channels */ cds_list_for_each_entry(event, &kchan->events_list.head , list) { - strncpy(events[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN); - events[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; - events[i].enabled = event->enabled; + strncpy((*events)[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN); + (*events)[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; + (*events)[i].enabled = event->enabled; switch (event->event->instrumentation) { case LTTNG_KERNEL_TRACEPOINT: - events[i].type = LTTNG_EVENT_TRACEPOINT; + (*events)[i].type = LTTNG_EVENT_TRACEPOINT; break; case LTTNG_KERNEL_KPROBE: case LTTNG_KERNEL_KRETPROBE: - events[i].type = LTTNG_EVENT_PROBE; - memcpy(&events[i].attr.probe, &event->event->u.kprobe, + (*events)[i].type = LTTNG_EVENT_PROBE; + memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe, sizeof(struct lttng_kernel_kprobe)); break; case LTTNG_KERNEL_FUNCTION: - events[i].type = LTTNG_EVENT_FUNCTION; - memcpy(&events[i].attr.ftrace, &event->event->u.ftrace, + (*events)[i].type = LTTNG_EVENT_FUNCTION; + memcpy(&((*events)[i].attr.ftrace), &event->event->u.ftrace, sizeof(struct lttng_kernel_function)); break; case LTTNG_KERNEL_NOOP: - events[i].type = LTTNG_EVENT_NOOP; + (*events)[i].type = LTTNG_EVENT_NOOP; break; case LTTNG_KERNEL_SYSCALL: - events[i].type = LTTNG_EVENT_SYSCALL; + (*events)[i].type = LTTNG_EVENT_SYSCALL; break; case LTTNG_KERNEL_ALL: assert(0); @@ -1862,6 +1970,11 @@ static void list_lttng_events(struct ltt_kernel_channel *kchan, } i++; } + + return nb_event; + +error: + return ret; } /* @@ -1938,7 +2051,7 @@ static int cmd_enable_channel(struct ltt_session *session, int ret; struct ltt_ust_session *usess = session->ust_session; - DBG("Enabling channel %s for session %s", session->name, attr->name); + DBG("Enabling channel %s for session %s", attr->name, session->name); switch (domain->type) { case LTTNG_DOMAIN_KERNEL: @@ -1976,6 +2089,7 @@ static int cmd_enable_channel(struct ltt_session *session, ret = LTTCOMM_UST_CHAN_FAIL; goto error; } + rcu_read_lock(); hashtable_add_unique(usess->domain_global.channels, &uchan->node); rcu_read_unlock(); @@ -1986,11 +2100,13 @@ static int cmd_enable_channel(struct ltt_session *session, } /* Add channel to all registered applications */ - ret = ust_app_add_channel_all(usess, uchan); - if (ret != LTTCOMM_OK) { + ret = ust_app_create_channel_all(usess, uchan); + if (ret != 0) { goto error; } + uchan->enabled = 1; + break; } case LTTNG_DOMAIN_UST_PID: @@ -2244,17 +2360,24 @@ static int cmd_enable_event(struct ltt_session *session, int domain, ret = LTTCOMM_FATAL; goto error; } + } - ret = ust_app_add_event_all(usess, uchan, uevent); + ret = ust_app_create_event_all(usess, uchan, uevent); if (ret < 0) { ret = LTTCOMM_UST_ENABLE_FAIL; goto error; } + /* Add ltt ust event to channel */ rcu_read_lock(); hashtable_add_unique(uchan->events, &uevent->node); rcu_read_unlock(); + + uevent->enabled = 1; + + DBG3("UST ltt event %s added to channel %s", uevent->attr.name, + uchan->name); break; } case LTTNG_DOMAIN_UST_EXEC_NAME: @@ -2358,8 +2481,14 @@ static ssize_t cmd_list_tracepoints(int domain, struct lttng_event **events) goto error; } break; + case LTTNG_DOMAIN_UST: + nb_events = ust_app_list_events(events); + if (nb_events < 0) { + ret = LTTCOMM_UST_LIST_FAIL; + goto error; + } + break; default: - /* TODO: Userspace listing */ ret = LTTCOMM_NOT_IMPLEMENTED; goto error; } @@ -2378,10 +2507,15 @@ static int cmd_start_trace(struct ltt_session *session) { int ret; struct ltt_kernel_session *ksession; - struct ltt_ust_session *usess = session->ust_session; + struct ltt_ust_session *usess; /* Short cut */ ksession = session->kernel_session; + usess = session->ust_session; + + if (session->enabled) + return LTTCOMM_UST_START_FAIL; + session->enabled = 1; /* Kernel tracing */ if (ksession != NULL) { @@ -2438,12 +2572,14 @@ static int cmd_start_trace(struct ltt_session *session) } /* Flag session that trace should start automatically */ - usess->start_trace = 1; + if (usess) { + usess->start_trace = 1; - ret = ust_app_start_trace_all(usess); - if (ret < 0) { - ret = LTTCOMM_UST_START_FAIL; - goto error; + ret = ust_app_start_trace_all(usess); + if (ret < 0) { + ret = LTTCOMM_UST_START_FAIL; + goto error; + } } ret = LTTCOMM_OK; @@ -2460,11 +2596,15 @@ static int cmd_stop_trace(struct ltt_session *session) int ret; struct ltt_kernel_channel *kchan; struct ltt_kernel_session *ksession; - //struct ltt_ust_session *usess; - //struct ltt_ust_channel *ustchan; + struct ltt_ust_session *usess; /* Short cut */ ksession = session->kernel_session; + usess = session->ust_session; + + if (!session->enabled) + return LTTCOMM_UST_START_FAIL; + session->enabled = 0; /* Kernel tracer */ if (ksession != NULL) { @@ -2492,32 +2632,16 @@ static int cmd_stop_trace(struct ltt_session *session) kernel_wait_quiescent(kernel_tracer_fd); } -#ifdef DISABLE - /* Stop each UST session */ - DBG("Stop UST tracing"); - cds_list_for_each_entry(usess, &session->ust_session_list.head, list) { - /* Flush all buffers before stopping */ - ret = ustctl_flush_buffer(usess->sock, usess->metadata->obj); - if (ret < 0) { - ERR("UST metadata flush failed"); - } - - cds_list_for_each_entry(ustchan, &usess->channels.head, list) { - ret = ustctl_flush_buffer(usess->sock, ustchan->obj); - if (ret < 0) { - ERR("UST flush buffer error"); - } - } + /* Flag session that trace should start automatically */ + if (usess) { + usess->start_trace = 0; - ret = ustctl_stop_session(usess->sock, usess->handle); + ret = ust_app_stop_trace_all(usess); if (ret < 0) { - ret = LTTCOMM_KERN_STOP_FAIL; + ret = LTTCOMM_UST_START_FAIL; goto error; } - - ustctl_wait_quiescent(usess->sock); } -#endif ret = LTTCOMM_OK; @@ -2641,22 +2765,34 @@ error: static ssize_t cmd_list_domains(struct ltt_session *session, struct lttng_domain **domains) { - int ret; + int ret, index = 0; ssize_t nb_dom = 0; if (session->kernel_session != NULL) { + DBG3("Listing domains found kernel domain"); nb_dom++; } - /* TODO: User-space tracer domain support */ + if (session->ust_session != NULL) { + DBG3("Listing domains found UST global domain"); + nb_dom++; + } - *domains = malloc(nb_dom * sizeof(struct lttng_domain)); + *domains = zmalloc(nb_dom * sizeof(struct lttng_domain)); if (*domains == NULL) { ret = -LTTCOMM_FATAL; goto error; } - (*domains)[0].type = LTTNG_DOMAIN_KERNEL; + if (session->kernel_session != NULL) { + (*domains)[index].type = LTTNG_DOMAIN_KERNEL; + index++; + } + + if (session->ust_session != NULL) { + (*domains)[index].type = LTTNG_DOMAIN_UST; + index++; + } return nb_dom; @@ -2667,25 +2803,43 @@ error: /* * Command LTTNG_LIST_CHANNELS processed by the client thread. */ -static ssize_t cmd_list_channels(struct ltt_session *session, +static ssize_t cmd_list_channels(int domain, struct ltt_session *session, struct lttng_channel **channels) { int ret; ssize_t nb_chan = 0; - if (session->kernel_session != NULL) { - nb_chan += session->kernel_session->channel_count; - } - - *channels = malloc(nb_chan * sizeof(struct lttng_channel)); - if (*channels == NULL) { - ret = -LTTCOMM_FATAL; + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + if (session->kernel_session != NULL) { + nb_chan = session->kernel_session->channel_count; + } + DBG3("Number of kernel channels %ld", nb_chan); + break; + case LTTNG_DOMAIN_UST: + if (session->ust_session != NULL) { + nb_chan = hashtable_get_count( + session->ust_session->domain_global.channels); + } + DBG3("Number of UST global channels %ld", nb_chan); + break; + default: + *channels = NULL; + ret = -LTTCOMM_NOT_IMPLEMENTED; goto error; } - list_lttng_channels(session, *channels); + if (nb_chan > 0) { + *channels = zmalloc(nb_chan * sizeof(struct lttng_channel)); + if (*channels == NULL) { + ret = -LTTCOMM_FATAL; + goto error; + } - /* TODO UST support */ + list_lttng_channels(domain, session, *channels); + } else { + *channels = NULL; + } return nb_chan; @@ -2696,34 +2850,33 @@ error: /* * Command LTTNG_LIST_EVENTS processed by the client thread. */ -static ssize_t cmd_list_events(struct ltt_session *session, +static ssize_t cmd_list_events(int domain, struct ltt_session *session, char *channel_name, struct lttng_event **events) { - int ret; + int ret = 0; ssize_t nb_event = 0; - struct ltt_kernel_channel *kchan = NULL; - if (session->kernel_session != NULL) { - kchan = trace_kernel_get_channel_by_name(channel_name, - session->kernel_session); - if (kchan == NULL) { - ret = -LTTCOMM_KERN_CHAN_NOT_FOUND; - goto error; + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + if (session->kernel_session != NULL) { + nb_event = list_lttng_kernel_events(channel_name, + session->kernel_session, events); + } + break; + case LTTNG_DOMAIN_UST: + { + if (session->ust_session != NULL) { + nb_event = list_lttng_ust_global_events(channel_name, + &session->ust_session->domain_global, events); } - nb_event += kchan->event_count; + break; } - - *events = malloc(nb_event * sizeof(struct lttng_event)); - if (*events == NULL) { - ret = -LTTCOMM_FATAL; + default: + ret = -LTTCOMM_NOT_IMPLEMENTED; goto error; } - list_lttng_events(kchan, *events); - - /* TODO: User-space tracer support */ - - return nb_event; + ret = nb_event; error: return ret; @@ -2852,8 +3005,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx) goto error; } - cmd_ctx->session->ust_session->consumer_fd = - ustconsumer_data.cmd_sock; + ust_consumer_fd = ustconsumer_data.cmd_sock; } pthread_mutex_unlock(&ustconsumer_data.pid_mutex); } @@ -2999,7 +3151,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx) size_t nb_chan; struct lttng_channel *channels; - nb_chan = cmd_list_channels(cmd_ctx->session, &channels); + nb_chan = cmd_list_channels(cmd_ctx->lsm->domain.type, + cmd_ctx->session, &channels); if (nb_chan < 0) { ret = -nb_chan; goto error; @@ -3021,10 +3174,10 @@ static int process_client_msg(struct command_ctx *cmd_ctx) } case LTTNG_LIST_EVENTS: { - size_t nb_event; + ssize_t nb_event; struct lttng_event *events = NULL; - nb_event = cmd_list_events(cmd_ctx->session, + nb_event = cmd_list_events(cmd_ctx->lsm->domain.type, cmd_ctx->session, cmd_ctx->lsm->u.list.channel_name, &events); if (nb_event < 0) { ret = -nb_event; @@ -3185,16 +3338,16 @@ static void *thread_manage_clients(void *data) } /* Allocate context command to process the client request */ - cmd_ctx = malloc(sizeof(struct command_ctx)); + cmd_ctx = zmalloc(sizeof(struct command_ctx)); if (cmd_ctx == NULL) { - perror("malloc cmd_ctx"); + perror("zmalloc cmd_ctx"); goto error; } /* Allocate data buffer for reception */ - cmd_ctx->lsm = malloc(sizeof(struct lttcomm_session_msg)); + cmd_ctx->lsm = zmalloc(sizeof(struct lttcomm_session_msg)); if (cmd_ctx->lsm == NULL) { - perror("malloc cmd_ctx->lsm"); + perror("zmalloc cmd_ctx->lsm"); goto error; } @@ -3231,7 +3384,7 @@ static void *thread_manage_clients(void *data) if (ret < 0) { /* * TODO: Inform client somehow of the fatal error. At - * this point, ret < 0 means that a malloc failed + * this point, ret < 0 means that a zmalloc failed * (ENOMEM). Error detected but still accept command. */ clean_command_ctx(&cmd_ctx);