#include "ust-consumer.h"
#include "utils.h"
#include "fd-limit.h"
-#include "filter.h"
#include "health.h"
#include "testpoint.h"
assert(socket->fd >= 0);
pthread_mutex_lock(socket->lock);
- ret = kernel_consumer_send_channel_stream(socket->fd,
+ ret = kernel_consumer_send_channel_stream(socket,
channel, ksess);
pthread_mutex_unlock(socket->lock);
if (ret < 0) {
char tmp;
struct lttng_poll_event events;
- DBG("Thread manage kernel started");
+ DBG("[thread] Thread manage kernel started");
- testpoint(thread_manage_kernel);
+ if (testpoint(thread_manage_kernel)) {
+ goto error_testpoint;
+ }
health_code_update(&health_thread_kernel);
- testpoint(thread_manage_kernel_before_loop);
-
ret = create_thread_poll_set(&events, 2);
if (ret < 0) {
goto error_poll_create;
goto error;
}
+ if (testpoint(thread_manage_kernel_before_loop)) {
+ goto error;
+ }
+
while (1) {
health_code_update(&health_thread_kernel);
update_poll_flag = 0;
}
- nb_fd = LTTNG_POLL_GETNB(&events);
-
- DBG("Thread kernel polling on %d fds", nb_fd);
-
- /* Zeroed the poll events */
- lttng_poll_reset(&events);
+ DBG("Thread kernel polling on %d fds", events.nb_fd);
/* Poll infinite value of time */
restart:
continue;
}
+ nb_fd = ret;
+
for (i = 0; i < nb_fd; i++) {
/* Fetch once the poll data */
revents = LTTNG_POLL_GETEV(&events, i);
error:
lttng_poll_clean(&events);
error_poll_create:
+error_testpoint:
utils_close_pipe(kernel_poll_pipe);
kernel_poll_pipe[0] = kernel_poll_pipe[1] = -1;
if (err) {
goto error;
}
- nb_fd = LTTNG_POLL_GETNB(&events);
-
health_code_update(&consumer_data->health);
/* Inifinite blocking call, waiting for transmission */
restart:
health_poll_update(&consumer_data->health);
- testpoint(thread_manage_consumer);
+ if (testpoint(thread_manage_consumer)) {
+ goto error;
+ }
ret = lttng_poll_wait(&events, -1);
health_poll_update(&consumer_data->health);
goto error;
}
+ nb_fd = ret;
+
for (i = 0; i < nb_fd; i++) {
/* Fetch once the poll data */
revents = LTTNG_POLL_GETEV(&events, i);
health_code_update(&consumer_data->health);
- /* Update number of fd */
- nb_fd = LTTNG_POLL_GETNB(&events);
-
/* Inifinite blocking call, waiting for transmission */
restart_poll:
health_poll_update(&consumer_data->health);
goto error;
}
+ nb_fd = ret;
+
for (i = 0; i < nb_fd; i++) {
/* Fetch once the poll data */
revents = LTTNG_POLL_GETEV(&events, i);
DBG("[thread] Manage application started");
- testpoint(thread_manage_apps);
-
rcu_register_thread();
rcu_thread_online();
+ if (testpoint(thread_manage_apps)) {
+ goto error_testpoint;
+ }
+
health_code_update(&health_thread_app_manage);
ret = create_thread_poll_set(&events, 2);
goto error;
}
- testpoint(thread_manage_apps_before_loop);
+ if (testpoint(thread_manage_apps_before_loop)) {
+ goto error;
+ }
health_code_update(&health_thread_app_manage);
while (1) {
- /* Zeroed the events structure */
- lttng_poll_reset(&events);
-
- nb_fd = LTTNG_POLL_GETNB(&events);
-
- DBG("Apps thread polling on %d fds", nb_fd);
+ DBG("Apps thread polling on %d fds", events.nb_fd);
/* Inifinite blocking call, waiting for transmission */
restart:
goto error;
}
+ nb_fd = ret;
+
for (i = 0; i < nb_fd; i++) {
/* Fetch once the poll data */
revents = LTTNG_POLL_GETEV(&events, i);
error:
lttng_poll_clean(&events);
error_poll_create:
+error_testpoint:
utils_close_pipe(apps_cmd_pipe);
apps_cmd_pipe[0] = apps_cmd_pipe[1] = -1;
DBG("[thread] Manage application registration started");
- testpoint(thread_registration_apps);
+ if (testpoint(thread_registration_apps)) {
+ goto error_testpoint;
+ }
ret = lttcomm_listen_unix_sock(apps_sock);
if (ret < 0) {
while (1) {
DBG("Accepting application registration");
- nb_fd = LTTNG_POLL_GETNB(&events);
-
/* Inifinite blocking call, waiting for transmission */
restart:
health_poll_update(&health_thread_app_reg);
goto error;
}
+ nb_fd = ret;
+
for (i = 0; i < nb_fd; i++) {
health_code_update(&health_thread_app_reg);
health_error(&health_thread_app_reg);
ERR("Health error occurred in %s", __func__);
}
- health_exit(&health_thread_app_reg);
/* Notify that the registration thread is gone */
notify_ust_apps(0);
lttng_poll_clean(&events);
error_listen:
error_create_poll:
+error_testpoint:
DBG("UST Registration thread cleanup complete");
+ health_exit(&health_thread_app_reg);
return NULL;
}
{
ret = cmd_add_context(cmd_ctx->session, cmd_ctx->lsm->domain.type,
cmd_ctx->lsm->u.context.channel_name,
- cmd_ctx->lsm->u.context.event_name,
&cmd_ctx->lsm->u.context.ctx, kernel_poll_pipe[1]);
break;
}
{
ret = cmd_enable_event(cmd_ctx->session, cmd_ctx->lsm->domain.type,
cmd_ctx->lsm->u.enable.channel_name,
- &cmd_ctx->lsm->u.enable.event, kernel_poll_pipe[1]);
+ &cmd_ctx->lsm->u.enable.event, NULL, kernel_poll_pipe[1]);
break;
}
case LTTNG_ENABLE_ALL_EVENT:
ret = cmd_enable_event_all(cmd_ctx->session, cmd_ctx->lsm->domain.type,
cmd_ctx->lsm->u.enable.channel_name,
- cmd_ctx->lsm->u.enable.event.type, kernel_poll_pipe[1]);
+ cmd_ctx->lsm->u.enable.event.type, NULL, kernel_poll_pipe[1]);
break;
}
case LTTNG_LIST_TRACEPOINTS:
cmd_ctx->lsm->u.reg.path, cdata);
break;
}
- case LTTNG_SET_FILTER:
+ case LTTNG_ENABLE_EVENT_WITH_FILTER:
{
struct lttng_filter_bytecode *bytecode;
- if (cmd_ctx->lsm->u.filter.bytecode_len > LTTNG_FILTER_MAX_LEN) {
+ if (cmd_ctx->lsm->u.enable.bytecode_len > LTTNG_FILTER_MAX_LEN) {
ret = LTTNG_ERR_FILTER_INVAL;
goto error;
}
- bytecode = zmalloc(cmd_ctx->lsm->u.filter.bytecode_len);
+ if (cmd_ctx->lsm->u.enable.bytecode_len == 0) {
+ ret = LTTNG_ERR_FILTER_INVAL;
+ goto error;
+ }
+ bytecode = zmalloc(cmd_ctx->lsm->u.enable.bytecode_len);
if (!bytecode) {
ret = LTTNG_ERR_FILTER_NOMEM;
goto error;
/* Receive var. len. data */
DBG("Receiving var len data from client ...");
ret = lttcomm_recv_unix_sock(sock, bytecode,
- cmd_ctx->lsm->u.filter.bytecode_len);
+ cmd_ctx->lsm->u.enable.bytecode_len);
if (ret <= 0) {
DBG("Nothing recv() from client var len data... continuing");
*sock_error = 1;
}
if (bytecode->len + sizeof(*bytecode)
- != cmd_ctx->lsm->u.filter.bytecode_len) {
+ != cmd_ctx->lsm->u.enable.bytecode_len) {
free(bytecode);
ret = LTTNG_ERR_FILTER_INVAL;
goto error;
}
- ret = cmd_set_filter(cmd_ctx->session, cmd_ctx->lsm->domain.type,
- cmd_ctx->lsm->u.filter.channel_name,
- cmd_ctx->lsm->u.filter.event_name,
- bytecode);
+ ret = cmd_enable_event(cmd_ctx->session, cmd_ctx->lsm->domain.type,
+ cmd_ctx->lsm->u.enable.channel_name,
+ &cmd_ctx->lsm->u.enable.event, bytecode, kernel_poll_pipe[1]);
break;
}
case LTTNG_DATA_PENDING:
while (1) {
DBG("Health check ready");
- nb_fd = LTTNG_POLL_GETNB(&events);
-
/* Inifinite blocking call, waiting for transmission */
restart:
ret = lttng_poll_wait(&events, -1);
goto error;
}
+ nb_fd = ret;
+
for (i = 0; i < nb_fd; i++) {
/* Fetch once the poll data */
revents = LTTNG_POLL_GETEV(&events, i);
DBG("[thread] Manage client started");
- testpoint(thread_manage_clients);
-
rcu_register_thread();
+ if (testpoint(thread_manage_clients)) {
+ goto error_testpoint;
+ }
+
health_code_update(&health_thread_cmd);
ret = lttcomm_listen_unix_sock(client_sock);
kill(ppid, SIGUSR1);
}
- testpoint(thread_manage_clients_before_loop);
+ if (testpoint(thread_manage_clients_before_loop)) {
+ goto error;
+ }
health_code_update(&health_thread_cmd);
while (1) {
DBG("Accepting client command ...");
- nb_fd = LTTNG_POLL_GETNB(&events);
-
/* Inifinite blocking call, waiting for transmission */
restart:
health_poll_update(&health_thread_cmd);
goto error;
}
+ nb_fd = ret;
+
for (i = 0; i < nb_fd; i++) {
/* Fetch once the poll data */
revents = LTTNG_POLL_GETEV(&events, i);
error_listen:
error_create_poll:
+error_testpoint:
unlink(client_unix_sock_path);
if (client_sock >= 0) {
ret = close(client_sock);