* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "ltt-sessiond.h"
#include "lttngerr.h"
#include "session.h"
+#include "trace.h"
+#include "traceable-app.h"
/* Const values */
const char default_home_dir[] = DEFAULT_HOME_DIR;
const char default_global_apps_pipe[] = DEFAULT_GLOBAL_APPS_PIPE;
/* Static functions */
-static int set_signal_handler(void);
-static int set_socket_perms(void);
-static void sighandler(int sig);
-static void cleanup(void);
-static void copy_common_data(struct lttcomm_lttng_msg *llm, struct lttcomm_session_msg *lsm);
static int check_existing_daemon(void);
-static int notify_apps(const char* name);
static int connect_app(pid_t pid);
-static int find_app_by_pid(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 send_unix_sock(int sock, void *buf, size_t len);
+static int set_signal_handler(void);
+static int set_socket_perms(void);
static int setup_data_buffer(char **buf, size_t size, struct lttcomm_lttng_msg *llm);
-static void add_traceable_app(struct ltt_traceable_app *lta);
-static void del_traceable_app(struct ltt_traceable_app *lta);
-
-/* Command function */
-static void get_list_apps(pid_t *pids);
+static void cleanup(void);
+static void copy_common_data(struct lttcomm_lttng_msg *llm, struct lttcomm_session_msg *lsm);
+static void sighandler(int sig);
static void *thread_manage_clients(void *data);
static void *thread_manage_apps(void *data);
/* Variables */
+int opt_verbose;
+int opt_quiet;
const char *progname;
const char *opt_tracing_group;
static int opt_sig_parent;
static int opt_daemon;
-int opt_verbose;
-int opt_quiet;
static int is_root; /* Set to 1 if the daemon is running as root */
static pid_t ppid;
static struct ltt_session *current_session;
-/* Number of element for the list below. */
-static unsigned int traceable_app_count;
-
-/* Init ust traceabl application's list */
-static struct ltt_traceable_app_list ltt_traceable_app_list = {
- .head = CDS_LIST_HEAD_INIT(ltt_traceable_app_list.head),
-};
-
-/* List mutex */
-pthread_mutex_t ltt_traceable_app_list_mutex;
-
/*
* thread_manage_apps
*
static void *thread_manage_apps(void *data)
{
int sock, ret;
- struct ltt_traceable_app *lta;
/* TODO: Something more elegant is needed but fine for now */
struct {
uid_t uid;
} reg_msg;
+ DBG("[thread] Manage apps started");
+
/* Notify all applications to register */
notify_apps(default_global_apps_pipe);
/* Add application to the global traceable list */
if (reg_msg.reg == 1) {
/* Registering */
- lta = malloc(sizeof(struct ltt_traceable_app));
- lta->pid = reg_msg.pid;
- lta->uid = reg_msg.uid;
- add_traceable_app(lta);
+ ret = register_traceable_app(reg_msg.pid, reg_msg.uid);
+ if (ret < 0) {
+ /* register_traceable_app only return an error with
+ * ENOMEM. At this point, we better stop everything.
+ */
+ goto error;
+ }
} else {
/* Unregistering */
- cds_list_for_each_entry(lta, <t_traceable_app_list.head, list) {
- if (lta->pid == reg_msg.pid && lta->uid == reg_msg.uid) {
- del_traceable_app(lta);
- free(lta);
- break;
- }
- }
+ unregister_traceable_app(reg_msg.pid);
}
}
int sock, ret;
struct lttcomm_session_msg lsm;
+ DBG("[thread] Manage client started");
+
ret = lttcomm_listen_unix_sock(client_socket);
if (ret < 0) {
goto error;
return NULL;
}
-/*
- * add_traceable_app
- *
- * Add a traceable application structure to the global
- * list protected by a mutex.
- */
-static void add_traceable_app(struct ltt_traceable_app *lta)
-{
- pthread_mutex_lock(<t_traceable_app_list_mutex);
- cds_list_add(<a->list, <t_traceable_app_list.head);
- traceable_app_count++;
- pthread_mutex_unlock(<t_traceable_app_list_mutex);
-}
-
-/*
- * del_traceable_app
- *
- * Delete a traceable application structure from the
- * global list protected by a mutex.
- */
-static void del_traceable_app(struct ltt_traceable_app *lta)
-{
- pthread_mutex_lock(<t_traceable_app_list_mutex);
- cds_list_del(<a->list);
- /* Sanity check */
- if (traceable_app_count != 0) {
- traceable_app_count--;
- }
- pthread_mutex_unlock(<t_traceable_app_list_mutex);
-}
-
/*
* send_unix_sock
*
*/
static int connect_app(pid_t pid)
{
- int sock, ret;
+ int sock;
+ struct ltt_traceable_app *lta;
- ret = find_app_by_pid(pid);
- if (ret == 0) {
+ DBG("Connect to application pid %d", pid);
+
+ lta = find_app_by_pid(pid);
+ if (lta == NULL) {
+ /* App not found */
return -1;
}
- sock = ustctl_connect_pid(pid);
+ sock = ustctl_connect_pid(lta->pid);
if (sock < 0) {
ERR("Fail connecting to the PID %d\n", pid);
}
int fd;
int ret = -1;
+ DBG("Notify the global application pipe");
+
/* Try opening the global pipe */
fd = open(name, O_WRONLY);
if (fd < 0) {
return ret;
}
-/*
- * find_app_by_pid
- *
- * Iterate over the traceable apps list.
- * On success, return 1, else return 0
- */
-static int find_app_by_pid(pid_t pid)
-{
- struct ltt_traceable_app *iter;
-
- pthread_mutex_lock(<t_traceable_app_list_mutex);
- cds_list_for_each_entry(iter, <t_traceable_app_list.head, list) {
- if (iter->pid == pid) {
- pthread_mutex_unlock(<t_traceable_app_list_mutex);
- /* Found */
- return 1;
- }
- }
- pthread_mutex_unlock(<t_traceable_app_list_mutex);
-
- return 0;
-}
-
/*
* ust_create_trace
*
int sock, ret;
struct ltt_ust_trace *trace;
+ DBG("Creating trace for pid %d", pid);
+
trace = malloc(sizeof(struct ltt_ust_trace));
if (trace == NULL) {
perror("malloc");
/* Init */
trace->pid = pid;
trace->shmid = 0;
+ /* NOTE: to be removed. Trace name will no longer be
+ * required for LTTng userspace tracer. For now, we set it
+ * to 'auto' for API compliance.
+ */
+ snprintf(trace->name, 5, "auto");
/* Connect to app using ustctl API */
sock = connect_app(pid);
goto error;
}
- ret = ustctl_create_trace(sock, "auto");
+ ret = ustctl_create_trace(sock, trace->name);
if (ret < 0) {
ret = LTTCOMM_CREATE_FAIL;
goto error;
/* Check if current session is valid */
if (current_session) {
cds_list_add(&trace->list, ¤t_session->ust_traces);
+ current_session->ust_trace_count++;
}
error:
}
/*
- * get_list_apps
+ * ust_start_trace
*
- * List traceable user-space application and fill an
- * array of pids.
+ * Start a trace. This trace, identified by the pid, must be
+ * in the current session ust_traces list.
*/
-static void get_list_apps(pid_t *pids)
+static int ust_start_trace(pid_t pid)
{
- int i = 0;
- struct ltt_traceable_app *iter;
+ int sock, ret;
+ struct ltt_ust_trace *trace;
- /* Protected by a mutex here because the threads manage_client
- * and manage_apps can access this list.
- */
- pthread_mutex_lock(<t_traceable_app_list_mutex);
- cds_list_for_each_entry(iter, <t_traceable_app_list.head, list) {
- pids[i] = iter->pid;
- i++;
+ DBG("Starting trace for pid %d", pid);
+
+ trace = find_session_ust_trace_by_pid(current_session, pid);
+ if (trace == NULL) {
+ ret = LTTCOMM_NO_TRACE;
+ goto error;
}
- pthread_mutex_unlock(<t_traceable_app_list_mutex);
+
+ /* Connect to app using ustctl API */
+ sock = connect_app(pid);
+ if (sock < 0) {
+ ret = LTTCOMM_NO_TRACEABLE;
+ goto error;
+ }
+
+ ret = ustctl_start_trace(sock, "auto");
+ if (ret < 0) {
+ ret = LTTCOMM_START_FAIL;
+ goto error;
+ }
+
+error:
+ return ret;
}
/*
char *send_buf = NULL;
struct lttcomm_lttng_msg llm;
+ DBG("Processing client message");
+
/* Copy common data to identify the response
* on the lttng client side.
*/
/* No auxiliary data so only send the llm struct. */
goto end;
}
+ case LTTNG_LIST_TRACES:
+ {
+ unsigned int trace_count = get_trace_count_per_session(current_session);
+
+ if (trace_count == 0) {
+ ret = LTTCOMM_NO_TRACE;
+ goto end;
+ }
+
+ buf_size = setup_data_buffer(&send_buf,
+ sizeof(struct lttng_trace) * trace_count, &llm);
+ if (buf_size < 0) {
+ ret = LTTCOMM_FATAL;
+ goto end;
+ }
+
+ get_traces_per_session(current_session, (struct lttng_trace *)(send_buf + header_size));
+ break;
+ }
case UST_CREATE_TRACE:
{
ret = ust_create_trace(lsm->pid);
if (ret < 0) {
- ret = LTTCOMM_CREATE_FAIL;
+ /* If -1 is returned from ust_create_trace, malloc
+ * failed so it's pretty much a fatal error.
+ */
+ ret = LTTCOMM_FATAL;
goto end;
}
}
case UST_LIST_APPS:
{
+ unsigned int app_count = get_app_count();
/* Stop right now if no apps */
- if (traceable_app_count == 0) {
+ if (app_count == 0) {
ret = LTTCOMM_NO_APPS;
goto end;
}
/* Setup data buffer and details for transmission */
buf_size = setup_data_buffer(&send_buf,
- sizeof(pid_t) * traceable_app_count, &llm);
+ sizeof(pid_t) * app_count, &llm);
if (buf_size < 0) {
ret = LTTCOMM_FATAL;
goto end;
}
- get_list_apps((pid_t *)(send_buf + header_size));
+ get_app_list_pids((pid_t *)(send_buf + header_size));
break;
}
+ case UST_START_TRACE:
+ {
+ ret = ust_start_trace(lsm->pid);
+
+ /* No auxiliary data so only send the llm struct. */
+ goto end;
+ }
case LTTNG_LIST_SESSIONS:
{
unsigned int session_count = get_session_count();
fprintf(stderr, " -V, --version Show version number.\n");
fprintf(stderr, " -S, --sig-parent Send SIGCHLD to parent pid to notify readiness.\n");
fprintf(stderr, " -q, --quiet No output at all.\n");
+ fprintf(stderr, " -v, --verbose Verbose mode. Activate DBG() macro.\n");
}
/*
{ "group", 1, 0, 'g' },
{ "version", 0, 0, 'V' },
{ "quiet", 0, 0, 'q' },
+ { "verbose", 0, 0, 'v' },
{ NULL, 0, 0, 0 }
};
while (1) {
int option_index = 0;
- c = getopt_long(argc, argv, "dhqVS" "a:c:g:s:", long_options, &option_index);
+ c = getopt_long(argc, argv, "dhqvVS" "a:c:g:s:", long_options, &option_index);
if (c == -1) {
break;
}
case 'q':
opt_quiet = 1;
break;
+ case 'v':
+ opt_verbose = 1;
+ break;
default:
/* Unknown option or other error.
* Error is printed by getopt, just return */
* init_daemon_socket
*
* Creates the two needed socket by the daemon.
- * apps_socket - The communication socket for all UST apps.
- * client_socket - The communication of the cli tool (lttng).
+ * apps_socket - The communication socket for all UST apps.
+ * client_socket - The communication of the cli tool (lttng).
*/
static int init_daemon_socket()
{
* check_existing_daemon
*
* Check if the global socket is available.
- * If yes, error is returned.
+ * If yes, error is returned.
*/
static int check_existing_daemon()
{
}
/*
- * get_home_dir
+ * get_home_dir
*
- * Return pointer to home directory path using
- * the env variable HOME.
+ * Return pointer to home directory path using
+ * the env variable HOME.
*
- * Default : /tmp
+ * Default : /tmp
*/
static const char *get_home_dir(void)
{
perror("chown");
}
+ DBG("Sockets permissions set");
+
end:
return ret;
}
/*
- * set_signal_handler
+ * set_signal_handler
*
- * Setup signal handler for :
+ * Setup signal handler for :
* SIGINT, SIGTERM, SIGPIPE
*/
static int set_signal_handler(void)
return ret;
}
+ DBG("Signal handler set for SIGTERM, SIGPIPE and SIGINT");
+
return ret;
}
/**
- * sighandler
+ * sighandler
*
- * Signal handler for the daemon
+ * Signal handler for the daemon
*/
static void sighandler(int sig)
{
switch (sig) {
case SIGPIPE:
+ DBG("SIGPIPE catched");
return;
case SIGINT:
+ DBG("SIGINT catched");
+ cleanup();
+ break;
case SIGTERM:
+ DBG("SIGTERM catched");
cleanup();
break;
default:
}
/*
- * cleanup
+ * cleanup
*
- * Cleanup the daemon on exit
+ * Cleanup the daemon on exit
*/
static void cleanup()
{
+ DBG("Cleaning up");
+
/* <fun> */
MSG("\n%c[%d;%dm*** assert failed *** ==> %c[%dm", 27,1,31,27,0);
MSG("%c[%d;%dmMatthew, BEET driven development works!%c[%dm",27,1,33,27,0);