#include "ltt-kconsumerd.h"
#include "utils.h"
+#include "benchmark.h"
+
/* Const values */
const char default_home_dir[] = DEFAULT_HOME_DIR;
const char default_tracing_group[] = LTTNG_DEFAULT_TRACING_GROUP;
DBG("Unloading kernel modules");
modprobe_remove_kernel_modules();
+
+ /* OUTPUT BENCHMARK RESULTS */
+ bench_init();
+
+ bench_print_boot_process();
+
+ bench_close();
+ /* END BENCHMARK */
}
/*
char tmp;
int update_poll_flag = 1;
+ tracepoint(sessiond_th_kern_start);
+
DBG("Thread manage kernel started");
while (1) {
DBG("Polling on %d fds", nb_fd);
+ tracepoint(sessiond_th_kern_poll);
+
/* Poll infinite value of time */
ret = poll(kernel_pollfd, nb_fd, -1);
if (ret < 0) {
enum lttcomm_return_code code;
struct pollfd pollfd[2];
+ tracepoint(sessiond_th_kcon_start);
+
DBG("[thread] Manage kconsumerd started");
ret = lttcomm_listen_unix_sock(kconsumerd_err_sock);
pollfd[1].fd = kconsumerd_err_sock;
pollfd[1].events = POLLIN;
+ tracepoint(sessiond_th_kcon_poll);
+
/* Inifinite blocking call, waiting for transmission */
ret = poll(pollfd, 2, -1);
if (ret < 0) {
int sock = 0, ret;
struct pollfd pollfd[2];
+ tracepoint(sessiond_th_apps_start);
+
/* TODO: Something more elegant is needed but fine for now */
/* FIXME: change all types to either uint8_t, uint32_t, uint64_t
* for 32-bit vs 64-bit compat processes. */
while (1) {
DBG("Accepting application registration");
+ tracepoint(sessiond_th_apps_poll);
+
/* Inifinite blocking call, waiting for transmission */
ret = poll(pollfd, 2, -1);
if (ret < 0) {
}
/*
- * Basic recv here to handle the very simple data
- * that the libust send to register (reg_msg).
+ * Using message-based transmissions to ensure we don't
+ * have to deal with partially received messages.
*/
- ret = recv(sock, ®_msg, sizeof(reg_msg), 0);
+ ret = lttcomm_recv_unix_sock(sock, ®_msg, sizeof(reg_msg));
if (ret < 0) {
perror("recv");
continue;
/* Add application to the global traceable list */
if (reg_msg.reg == 1) {
/* Registering */
+ /*
+ * TODO: socket should be either passed to a
+ * listener thread (for more messages) or
+ * closed. It currently leaks.
+ */
ret = register_traceable_app(reg_msg.pid, reg_msg.uid);
if (ret < 0) {
/* register_traceable_app only return an error with
goto setup_error;
}
+ tracepoint(create_session_start);
ret = create_session(cmd_ctx->lsm->session.name, cmd_ctx->lsm->session.path);
+ tracepoint(create_session_end);
if (ret < 0) {
if (ret == -EEXIST) {
ret = LTTCOMM_EXIST_SESS;
/* Clean kernel session teardown */
teardown_kernel_session(cmd_ctx->session);
+ tracepoint(destroy_session_start);
ret = destroy_session(cmd_ctx->lsm->session.name);
+ tracepoint(destroy_session_end);
if (ret < 0) {
ret = LTTCOMM_FATAL;
goto error;
struct command_ctx *cmd_ctx = NULL;
struct pollfd pollfd[2];
+ tracepoint(sessiond_th_cli_start);
+
DBG("[thread] Manage client started");
ret = lttcomm_listen_unix_sock(client_sock);
while (1) {
DBG("Accepting client command ...");
+ tracepoint(sessiond_th_cli_poll);
+
/* Inifinite blocking call, waiting for transmission */
ret = poll(pollfd, 2, -1);
if (ret < 0) {
void *status;
const char *home_path;
+ tracepoint(sessiond_boot_start);
+
/* Create thread quit pipe */
if ((ret = init_thread_quit_pipe()) < 0) {
goto error;
goto exit_kernel;
}
+ tracepoint(sessiond_boot_end);
+
ret = pthread_join(kernel_thread, &status);
if (ret != 0) {
perror("pthread_join");