/*
* Ask session daemon for all user space tracepoints available.
*/
static int list_ust_events(void)
{
int i, size;
struct lttng_domain domain;
struct lttng_handle *handle;
struct lttng_event *event_list;
pid_t cur_pid = 0;
char *cmdline = NULL;
memset(&domain, 0, sizeof(domain));
DBG("Getting UST tracing events");
domain.type = LTTNG_DOMAIN_UST;
handle = lttng_create_handle(NULL, &domain);
if (handle == NULL) {
goto error;
}
size = lttng_list_tracepoints(handle, &event_list);
if (size < 0) {
ERR("Unable to list UST events: %s", lttng_strerror(size));
lttng_destroy_handle(handle);
return size;
}
MSG("UST events:\n-------------");
if (size == 0) {
MSG("None");
}
for (i = 0; i < size; i++) {
if (cur_pid != event_list[i].pid) {
cur_pid = event_list[i].pid;
cmdline = get_cmdline_by_pid(cur_pid);
MSG("\nPID: %d - Name: %s", cur_pid, cmdline);
free(cmdline);
}
print_events(&event_list[i]);
}
MSG("");
free(event_list);
lttng_destroy_handle(handle);
return CMD_SUCCESS;
error:
lttng_destroy_handle(handle);
return -1;
}
int main(int argc, char **argv)
{
struct bt_opts opts;
struct btproc *bt_proc;
bt_proc = parse_args(argc, argv, &opts);
bt_proc->pi->pi_debug = opts.debug_opt;
if (opts.target_opt && opts.pid_opt) {
bt_proc_destroy(bt_proc);
printfd(2,
FATAL " You can't choose target and pid together !\n");
btrace_banner(*argv, 1);
} else if (!opts.target_opt && !opts.pid_opt) {
printfd(2, FATAL "No such target or porcess\n");
btrace_banner(*argv, 1);
} else {
/* using target executable */
if (opts.target_opt) {
bt_proc->exec =
check_target_path(bt_proc->pi->pi_target,
bt_proc->pi->pi_perm);
if (!bt_proc->exec) {
bt_proc_destroy(bt_proc);
btrace_banner(*argv, 1);
}
if (opts.target_has_args)
bt_proc->args_parser((char *)bt_proc->pi->
pi_args, bt_proc);
else
bt_proc->proc_arguments[0] =
strdup((const char *)bt_proc->exec);
if ((!opts.force_addr_opt && opts.off_opt) ||
(opts.force_addr_opt && !opts.off_opt)) {
printfd(STDERR_FILENO,
WARN
"You may choose both of address and offset !\n");
bt_proc_destroy(bt_proc);
btrace_banner(*argv, 1);
}
/* if address & offset are set */
else {
bt_proc->pi->pi_stack->ma_map[0] =
bt_proc->pi->pi_address;
bt_proc->pi->pi_stack->ma_map[1] =
bt_proc->pi->pi_address +
bt_proc->pi->pi_offset;
bt_proc->pi->pi_addr->ma_map[0] =
bt_proc->pi->pi_address;
bt_proc->pi->pi_addr->ma_map[1] =
bt_proc->pi->pi_address +
bt_proc->pi->pi_offset;
}
exec_target(bt_proc);
/* If force address and offset are not set we read
* from profs and fetch memory base address
* and write new elf binary
*/
if (!opts.force_addr_opt && !opts.off_opt) {
printfd(2,
DO "Target :" GREEN " %s " NORM
" PID : " GREEN "%d" NORM "\n",
bt_proc->exec, bt_proc->pi->pi_pid);
if (read_procfs_maps(bt_proc->pi) == -1)
die("no such process");
}
fetch_data(bt_proc->pi);
}
/* pid attach */
if (opts.pid_opt) {
if (attach_process(bt_proc->pi) == -1)
die(FATAL "Can't attach process");
get_cmdline_by_pid(bt_proc->pi);
printfd(2,
DO "Attach PID:" GREEN " %d" NORM " Target :"
GREEN " %s" NORM "\n", bt_proc->pi->pi_pid,
bt_proc->pi->pi_perm->p_full_path);
if ((!opts.force_addr_opt && opts.off_opt) ||
(opts.force_addr_opt && !opts.off_opt)) {
printfd(STDERR_FILENO,
WARN
"You may choose both of address and offset !\n");
bt_proc_destroy(bt_proc);
btrace_banner(*argv, 1);
}
/* if address & offset are set */
else {
bt_proc->pi->pi_stack->ma_map[0] =
bt_proc->pi->pi_address;
bt_proc->pi->pi_stack->ma_map[1] =
bt_proc->pi->pi_address +
bt_proc->pi->pi_offset;
bt_proc->pi->pi_addr->ma_map[0] =
bt_proc->pi->pi_address;
bt_proc->pi->pi_addr->ma_map[1] =
bt_proc->pi->pi_address +
bt_proc->pi->pi_offset;
}
if (!opts.force_addr_opt && !opts.off_opt)
if (read_procfs_maps(bt_proc->pi) == -1)
die(FATAL "No such process");
/* it shouldn't return anything
* BACK TO ME
*/
fetch_data(bt_proc->pi);
}
if (opts.raw_opt)
raw_dump(bt_proc->pi);
else
dump_using_memory(bt_proc->pi);
if(opts.elf_dump_opts) {
}
pinfo_destroy(bt_proc->pi);
bt_proc_destroy(bt_proc);
}
return 0;
}
/*
* Ask session daemon for all user space tracepoint fields available.
*/
static int list_ust_event_fields(void)
{
int i, size, ret = CMD_SUCCESS;
struct lttng_domain domain;
struct lttng_handle *handle;
struct lttng_event_field *event_field_list;
pid_t cur_pid = 0;
char *cmdline = NULL;
struct lttng_event cur_event;
memset(&domain, 0, sizeof(domain));
memset(&cur_event, 0, sizeof(cur_event));
DBG("Getting UST tracing event fields");
domain.type = LTTNG_DOMAIN_UST;
handle = lttng_create_handle(NULL, &domain);
if (handle == NULL) {
ret = CMD_ERROR;
goto end;
}
size = lttng_list_tracepoint_fields(handle, &event_field_list);
if (size < 0) {
ERR("Unable to list UST event fields: %s", lttng_strerror(size));
ret = CMD_ERROR;
goto end;
}
if (lttng_opt_mi) {
/* Mi print */
ret = mi_list_ust_event_fields(event_field_list, size, &domain);
if (ret) {
ret = CMD_ERROR;
goto error;
}
} else {
/* Pretty print */
MSG("UST events:\n-------------");
if (size == 0) {
MSG("None");
}
for (i = 0; i < size; i++) {
if (cur_pid != event_field_list[i].event.pid) {
cur_pid = event_field_list[i].event.pid;
cmdline = get_cmdline_by_pid(cur_pid);
if (cmdline == NULL) {
ret = CMD_ERROR;
goto error;
}
MSG("\nPID: %d - Name: %s", cur_pid, cmdline);
free(cmdline);
/* Wipe current event since we are about to print a new PID. */
memset(&cur_event, 0, sizeof(cur_event));
}
if (strcmp(cur_event.name, event_field_list[i].event.name) != 0) {
print_events(&event_field_list[i].event);
memcpy(&cur_event, &event_field_list[i].event,
sizeof(cur_event));
}
print_event_field(&event_field_list[i]);
}
MSG("");
}
error:
free(event_field_list);
end:
lttng_destroy_handle(handle);
return ret;
}
/*
* Machine interface
* List all ust event with their fields
*/
static int mi_list_ust_event_fields(struct lttng_event_field *fields, int count,
struct lttng_domain *domain)
{
int ret, i;
pid_t cur_pid = 0;
char *cmdline = NULL;
int pid_element_open = 0;
int event_element_open = 0;
struct lttng_event cur_event;
/* Open domains element */
ret = mi_lttng_domains_open(writer);
if (ret) {
goto end;
}
/* Write domain */
ret = mi_lttng_domain(writer, domain, 1);
if (ret) {
goto end;
}
/* Open pids element */
ret = mi_lttng_pids_open(writer);
if (ret) {
goto end;
}
for (i = 0; i < count; i++) {
if (cur_pid != fields[i].event.pid) {
if (pid_element_open) {
if (event_element_open) {
/* Close the previous field element and event. */
ret = mi_lttng_close_multi_element(writer, 2);
if (ret) {
goto end;
}
event_element_open = 0;
}
/* Close the previous events, pid element */
ret = mi_lttng_close_multi_element(writer, 2);
if (ret) {
goto end;
}
pid_element_open = 0;
}
cur_pid = fields[i].event.pid;
cmdline = get_cmdline_by_pid(cur_pid);
if (!pid_element_open) {
/* Open and write a pid element */
ret = mi_lttng_pid(writer, cur_pid, cmdline, 1);
if (ret) {
goto error;
}
/* Open events element */
ret = mi_lttng_events_open(writer);
if (ret) {
goto error;
}
pid_element_open = 1;
}
free(cmdline);
/* Wipe current event since we are about to print a new PID. */
memset(&cur_event, 0, sizeof(cur_event));
}
if (strcmp(cur_event.name, fields[i].event.name) != 0) {
if (event_element_open) {
/* Close the previous fields element and the previous event */
ret = mi_lttng_close_multi_element(writer, 2);
if (ret) {
goto end;
}
event_element_open = 0;
}
memcpy(&cur_event, &fields[i].event,
sizeof(cur_event));
if (!event_element_open) {
/* Open and write the event */
ret = mi_lttng_event(writer, &cur_event, 1,
handle->domain.type);
if (ret) {
goto end;
}
/* Open a fields element */
ret = mi_lttng_event_fields_open(writer);
if (ret) {
goto end;
}
event_element_open = 1;
}
}
/* Print the event_field */
ret = mi_lttng_event_field(writer, &fields[i]);
if (ret) {
goto end;
}
}
/* Close pids, domain, domains */
ret = mi_lttng_close_multi_element(writer, 3);
end:
return ret;
error:
free(cmdline);
return ret;
}
static int list_agent_events(void)
{
int i, size, ret = CMD_SUCCESS;
struct lttng_domain domain;
struct lttng_handle *handle = NULL;
struct lttng_event *event_list = NULL;
pid_t cur_pid = 0;
char *cmdline = NULL;
const char *agent_domain_str;
memset(&domain, 0, sizeof(domain));
if (opt_jul) {
domain.type = LTTNG_DOMAIN_JUL;
} else if (opt_log4j) {
domain.type = LTTNG_DOMAIN_LOG4J;
} else if (opt_python) {
domain.type = LTTNG_DOMAIN_PYTHON;
} else {
ERR("Invalid agent domain selected.");
ret = CMD_ERROR;
goto error;
}
agent_domain_str = get_domain_str(domain.type);
DBG("Getting %s tracing events", agent_domain_str);
handle = lttng_create_handle(NULL, &domain);
if (handle == NULL) {
ret = CMD_ERROR;
goto end;
}
size = lttng_list_tracepoints(handle, &event_list);
if (size < 0) {
ERR("Unable to list %s events: %s", agent_domain_str,
lttng_strerror(size));
ret = CMD_ERROR;
goto end;
}
if (lttng_opt_mi) {
/* Mi print */
ret = mi_list_agent_ust_events(event_list, size, &domain);
if (ret) {
ret = CMD_ERROR;
goto error;
}
} else {
/* Pretty print */
MSG("%s events (Logger name):\n-------------------------",
agent_domain_str);
if (size == 0) {
MSG("None");
}
for (i = 0; i < size; i++) {
if (cur_pid != event_list[i].pid) {
cur_pid = event_list[i].pid;
cmdline = get_cmdline_by_pid(cur_pid);
if (cmdline == NULL) {
ret = CMD_ERROR;
goto error;
}
MSG("\nPID: %d - Name: %s", cur_pid, cmdline);
free(cmdline);
}
MSG("%s- %s", indent6, event_list[i].name);
}
MSG("");
}
error:
free(event_list);
end:
lttng_destroy_handle(handle);
return ret;
}
/*
* Machine interface
* Jul and ust event listing
*/
static int mi_list_agent_ust_events(struct lttng_event *events, int count,
struct lttng_domain *domain)
{
int ret, i;
pid_t cur_pid = 0;
char *cmdline = NULL;
int pid_element_open = 0;
/* Open domains element */
ret = mi_lttng_domains_open(writer);
if (ret) {
goto end;
}
/* Write domain */
ret = mi_lttng_domain(writer, domain, 1);
if (ret) {
goto end;
}
/* Open pids element */
ret = mi_lttng_pids_open(writer);
if (ret) {
goto end;
}
for (i = 0; i < count; i++) {
if (cur_pid != events[i].pid) {
if (pid_element_open) {
/* Close the previous events and pid element */
ret = mi_lttng_close_multi_element(writer, 2);
if (ret) {
goto end;
}
pid_element_open = 0;
}
cur_pid = events[i].pid;
cmdline = get_cmdline_by_pid(cur_pid);
if (!cmdline) {
ret = CMD_ERROR;
goto end;
}
if (!pid_element_open) {
/* Open and write a pid element */
ret = mi_lttng_pid(writer, cur_pid, cmdline, 1);
if (ret) {
goto error;
}
/* Open events element */
ret = mi_lttng_events_open(writer);
if (ret) {
goto error;
}
pid_element_open = 1;
}
free(cmdline);
}
/* Write an event */
ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type);
if (ret) {
goto end;
}
}
/* Close pids */
ret = mi_lttng_writer_close_element(writer);
if (ret) {
goto end;
}
/* Close domain, domains */
ret = mi_lttng_close_multi_element(writer, 2);
end:
return ret;
error:
free(cmdline);
return ret;
}
