/*
* List JUL events for a specific session using the handle.
*
* Return CMD_SUCCESS on success else a negative value.
*/
static int list_session_jul_events(void)
{
int ret, count, i;
struct lttng_event *events = NULL;
count = lttng_list_events(handle, "", &events);
if (count < 0) {
ret = count;
ERR("%s", lttng_strerror(ret));
goto error;
}
MSG("Events (Logger name):\n---------------------");
if (count == 0) {
MSG("%sNone\n", indent6);
goto end;
}
for (i = 0; i < count; i++) {
MSG("%s- %s%s", indent4, events[i].name,
enabled_string(events[i].enabled));
}
MSG("");
end:
free(events);
ret = CMD_SUCCESS;
error:
return ret;
}
static void
track_conf_read(void) {
dict_t node;
char *str, *modes;
node = conf_get_data("modules/track", RECDB_OBJECT);
if (!node)
return;
str = database_get_data(node, "snomask", RECDB_QSTRING);
if (!str)
track_cfg.snomask = TRACK_NICK|TRACK_KICK|TRACK_JOIN|TRACK_PART|TRACK_CHANMODE|TRACK_NEW|TRACK_DEL|TRACK_AUTH;
else
parse_track_conf(str);
str = database_get_data(node, "channel", RECDB_QSTRING);
modes = database_get_data(node, "channel_modes", RECDB_QSTRING);
if (!str)
return;
// XXX - dont do addchannel if the channel is being shared with
// another module:
track_cfg.channel = AddChannel(str, now, (modes ? modes : "+sntOm"), NULL, NULL);
if (!track_cfg.channel)
return;
str = database_get_data(node, "show_bursts", RECDB_QSTRING);
track_cfg.show_bursts = str ? enabled_string(str) : 0;
track_cfg.enabled = 1;
if (finalized)
track_finalize();
}
/*
* Pretty print single event.
*/
static void print_events(struct lttng_event *event)
{
switch (event->type) {
case LTTNG_EVENT_TRACEPOINT:
{
if (event->loglevel != -1) {
MSG("%s%s (loglevel: %s (%d)) (type: tracepoint)%s%s",
indent6,
event->name,
loglevel_string(event->loglevel),
event->loglevel,
enabled_string(event->enabled),
filter_string(event->filter));
} else {
MSG("%s%s (type: tracepoint)%s%s",
indent6,
event->name,
enabled_string(event->enabled),
filter_string(event->filter));
}
break;
}
case LTTNG_EVENT_PROBE:
MSG("%s%s (type: probe)%s%s", indent6,
event->name, enabled_string(event->enabled),
filter_string(event->filter));
if (event->attr.probe.addr != 0) {
MSG("%saddr: 0x%" PRIx64, indent8, event->attr.probe.addr);
} else {
MSG("%soffset: 0x%" PRIx64, indent8, event->attr.probe.offset);
MSG("%ssymbol: %s", indent8, event->attr.probe.symbol_name);
}
break;
case LTTNG_EVENT_FUNCTION:
case LTTNG_EVENT_FUNCTION_ENTRY:
MSG("%s%s (type: function)%s%s", indent6,
event->name, enabled_string(event->enabled),
filter_string(event->filter));
MSG("%ssymbol: \"%s\"", indent8, event->attr.ftrace.symbol_name);
break;
case LTTNG_EVENT_SYSCALL:
MSG("%ssyscalls (type: syscall)%s%s", indent6,
enabled_string(event->enabled),
filter_string(event->filter));
break;
case LTTNG_EVENT_NOOP:
MSG("%s (type: noop)%s%s", indent6,
enabled_string(event->enabled),
filter_string(event->filter));
break;
case LTTNG_EVENT_ALL:
/* We should never have "all" events in list. */
assert(0);
break;
}
}
/*
* List agent events for a specific session using the handle.
*
* Return CMD_SUCCESS on success else a negative value.
*/
static int list_session_agent_events(void)
{
int ret = CMD_SUCCESS, count, i;
struct lttng_event *events = NULL;
count = lttng_list_events(handle, "", &events);
if (count < 0) {
ret = CMD_ERROR;
ERR("%s", lttng_strerror(count));
goto error;
}
if (lttng_opt_mi) {
/* Mi print */
ret = mi_list_session_agent_events(events, count);
if (ret) {
ret = CMD_ERROR;
goto end;
}
} else {
/* Pretty print */
MSG("Events (Logger name):\n---------------------");
if (count == 0) {
MSG("%sNone\n", indent6);
goto end;
}
for (i = 0; i < count; i++) {
MSG("%s- %s%s (loglevel%s %s)", indent4, events[i].name,
enabled_string(events[i].enabled),
logleveltype_string(events[i].loglevel_type),
mi_lttng_loglevel_string(events[i].loglevel,
handle->domain.type));
}
MSG("");
}
end:
free(events);
error:
return ret;
}
/*
* Pretty print channel
*/
static void print_channel(struct lttng_channel *channel)
{
MSG("- %s:%s\n", channel->name, enabled_string(channel->enabled));
MSG("%sAttributes:", indent4);
MSG("%soverwrite mode: %d", indent6, channel->attr.overwrite);
MSG("%ssubbufers size: %" PRIu64, indent6, channel->attr.subbuf_size);
MSG("%snumber of subbufers: %" PRIu64, indent6, channel->attr.num_subbuf);
MSG("%sswitch timer interval: %u", indent6, channel->attr.switch_timer_interval);
MSG("%sread timer interval: %u", indent6, channel->attr.read_timer_interval);
switch (channel->attr.output) {
case LTTNG_EVENT_SPLICE:
MSG("%soutput: splice()", indent6);
break;
case LTTNG_EVENT_MMAP:
MSG("%soutput: mmap()", indent6);
break;
}
}
static void
global_conf_read(void)
{
dict_t conf_node;
const char *str;
if (!(conf_node = conf_get_data(GLOBAL_CONF_NAME, RECDB_OBJECT))) {
log_module(G_LOG, LOG_ERROR, "config node `%s' is missing or has wrong type.", GLOBAL_CONF_NAME);
return;
}
str = database_get_data(conf_node, KEY_DB_BACKUP_FREQ, RECDB_QSTRING);
global_conf.db_backup_frequency = str ? ParseInterval(str) : 7200;
str = database_get_data(conf_node, KEY_ANNOUNCEMENTS_DEFAULT, RECDB_QSTRING);
global_conf.announcements_default = str ? enabled_string(str) : 1;
str = database_get_data(conf_node, KEY_NICK, RECDB_QSTRING);
if(global && str)
NickChange(global, str, 0);
}
static void
snoop_conf_read(void) {
dict_t node;
char *str, *modes;
node = conf_get_data("modules/snoop", RECDB_OBJECT);
if (!node)
return;
str = database_get_data(node, "channel", RECDB_QSTRING);
modes = database_get_data(node, "channel_modes", RECDB_QSTRING);
if (!str)
return;
snoop_cfg.channel = AddChannel(str, now, (modes ? modes : "+sntim"), NULL, NULL);
if (!snoop_cfg.channel)
return;
str = database_get_data(node, "show_bursts", RECDB_QSTRING);
snoop_cfg.show_bursts = str ? enabled_string(str) : 0;
snoop_cfg.enabled = 1;
if (finalized)
snoop_finalize();
}
/*
* Pretty print single event.
*/
static void print_events(struct lttng_event *event)
{
int ret;
const char *filter_str;
char *filter_msg = NULL;
char *exclusion_msg = NULL;
ret = lttng_event_get_filter_expression(event, &filter_str);
if (ret) {
filter_msg = strdup(" [failed to retrieve filter]");
} else if (filter_str) {
const char * const filter_fmt = " [filter: '%s']";
filter_msg = malloc(strlen(filter_str) +
strlen(filter_fmt) + 1);
if (filter_msg) {
sprintf(filter_msg, filter_fmt,
filter_str);
}
}
exclusion_msg = get_exclusion_names_msg(event);
if (!exclusion_msg) {
exclusion_msg = strdup(" [failed to retrieve exclusions]");
}
switch (event->type) {
case LTTNG_EVENT_TRACEPOINT:
{
if (event->loglevel != -1) {
MSG("%s%s (loglevel%s %s (%d)) (type: tracepoint)%s%s%s",
indent6,
event->name,
logleveltype_string(event->loglevel_type),
mi_lttng_loglevel_string(event->loglevel, handle->domain.type),
event->loglevel,
enabled_string(event->enabled),
safe_string(exclusion_msg),
safe_string(filter_msg));
} else {
MSG("%s%s (type: tracepoint)%s%s%s",
indent6,
event->name,
enabled_string(event->enabled),
safe_string(exclusion_msg),
safe_string(filter_msg));
}
break;
}
case LTTNG_EVENT_FUNCTION:
MSG("%s%s (type: function)%s%s", indent6,
event->name, enabled_string(event->enabled),
safe_string(filter_msg));
if (event->attr.probe.addr != 0) {
MSG("%saddr: 0x%" PRIx64, indent8, event->attr.probe.addr);
} else {
MSG("%soffset: 0x%" PRIx64, indent8, event->attr.probe.offset);
MSG("%ssymbol: %s", indent8, event->attr.probe.symbol_name);
}
break;
case LTTNG_EVENT_PROBE:
MSG("%s%s (type: probe)%s%s", indent6,
event->name, enabled_string(event->enabled),
safe_string(filter_msg));
if (event->attr.probe.addr != 0) {
MSG("%saddr: 0x%" PRIx64, indent8, event->attr.probe.addr);
} else {
MSG("%soffset: 0x%" PRIx64, indent8, event->attr.probe.offset);
MSG("%ssymbol: %s", indent8, event->attr.probe.symbol_name);
}
break;
case LTTNG_EVENT_FUNCTION_ENTRY:
MSG("%s%s (type: function)%s%s", indent6,
event->name, enabled_string(event->enabled),
safe_string(filter_msg));
MSG("%ssymbol: \"%s\"", indent8, event->attr.ftrace.symbol_name);
break;
case LTTNG_EVENT_SYSCALL:
MSG("%s%s%s%s%s%s", indent6, event->name,
(opt_syscall ? "" : " (type:syscall)"),
enabled_string(event->enabled),
bitness_event(event->flags),
safe_string(filter_msg));
break;
case LTTNG_EVENT_NOOP:
MSG("%s (type: noop)%s%s", indent6,
enabled_string(event->enabled),
safe_string(filter_msg));
break;
case LTTNG_EVENT_ALL:
/* We should never have "all" events in list. */
assert(0);
break;
}
free(filter_msg);
free(exclusion_msg);
}
/*
* Pretty print channel
*/
static void print_channel(struct lttng_channel *channel)
{
int ret;
uint64_t discarded_events, lost_packets, monitor_timer_interval;
int64_t blocking_timeout;
ret = lttng_channel_get_discarded_event_count(channel,
&discarded_events);
if (ret) {
ERR("Failed to retrieve discarded event count of channel");
return;
}
ret = lttng_channel_get_lost_packet_count(channel,
&lost_packets);
if (ret) {
ERR("Failed to retrieve lost packet count of channel");
return;
}
ret = lttng_channel_get_monitor_timer_interval(channel,
&monitor_timer_interval);
if (ret) {
ERR("Failed to retrieve monitor interval of channel");
return;
}
ret = lttng_channel_get_blocking_timeout(channel,
&blocking_timeout);
if (ret) {
ERR("Failed to retrieve blocking timeout of channel");
return;
}
MSG("- %s:%s\n", channel->name, enabled_string(channel->enabled));
MSG("%sAttributes:", indent4);
MSG("%sEvent-loss mode: %s", indent6, channel->attr.overwrite ? "overwrite" : "discard");
MSG("%sSub-buffer size: %" PRIu64 " bytes", indent6, channel->attr.subbuf_size);
MSG("%sSub-buffer count: %" PRIu64, indent6, channel->attr.num_subbuf);
print_timer("Switch timer", 5, channel->attr.switch_timer_interval);
print_timer("Read timer", 7, channel->attr.read_timer_interval);
print_timer("Monitor timer", 4, monitor_timer_interval);
if (!channel->attr.overwrite) {
if (blocking_timeout == -1) {
MSG("%sBlocking timeout: infinite", indent6);
} else {
MSG("%sBlocking timeout: %" PRId64 " µs", indent6, blocking_timeout);
}
}
MSG("%sTrace file count: %" PRIu64 " per stream", indent6,
channel->attr.tracefile_count == 0 ?
1 : channel->attr.tracefile_count);
if (channel->attr.tracefile_size != 0 ) {
MSG("%sTrace file size: %" PRIu64 " bytes", indent6,
channel->attr.tracefile_size);
} else {
MSG("%sTrace file size: %s", indent6, "unlimited");
}
switch (channel->attr.output) {
case LTTNG_EVENT_SPLICE:
MSG("%sOutput mode: splice", indent6);
break;
case LTTNG_EVENT_MMAP:
MSG("%sOutput mode: mmap", indent6);
break;
}
MSG("\n%sStatistics:", indent4);
if (listed_session.snapshot_mode) {
/*
* The lost packet count is omitted for sessions in snapshot
* mode as it is misleading: it would indicate the number of
* packets that the consumer could not extract during the
* course of recording the snapshot. It does not have the
* same meaning as the "regular" lost packet count that
* would result from the consumer not keeping up with
* event production in an overwrite-mode channel.
*
* A more interesting statistic would be the number of
* packets lost between the first and last extracted
* packets of a given snapshot (which prevents most analyses).
*/
MSG("%sNone", indent6);
goto skip_stats_printing;
}
if (!channel->attr.overwrite) {
MSG("%sDiscarded events: %" PRIu64, indent6, discarded_events);
} else {
MSG("%sLost packets: %" PRIu64, indent6, lost_packets);
}
skip_stats_printing:
return;
}
/*
* List agent events for a specific session using the handle.
*
* Return CMD_SUCCESS on success else a negative value.
*/
static int list_session_agent_events(void)
{
int ret = CMD_SUCCESS, count, i;
struct lttng_event *events = NULL;
count = lttng_list_events(handle, "", &events);
if (count < 0) {
ret = CMD_ERROR;
ERR("%s", lttng_strerror(count));
goto error;
}
if (lttng_opt_mi) {
/* Mi print */
ret = mi_list_session_agent_events(events, count);
if (ret) {
ret = CMD_ERROR;
goto end;
}
} else {
/* Pretty print */
MSG("Events (Logger name):\n---------------------");
if (count == 0) {
MSG("%sNone\n", indent6);
goto end;
}
for (i = 0; i < count; i++) {
const char *filter_str;
char *filter_msg = NULL;
struct lttng_event *event = &events[i];
ret = lttng_event_get_filter_expression(event,
&filter_str);
if (ret) {
filter_msg = strdup(" [failed to retrieve filter]");
} else if (filter_str) {
const char * const filter_fmt =
" [filter: '%s']";
filter_msg = malloc(strlen(filter_str) +
strlen(filter_fmt) + 1);
if (filter_msg) {
sprintf(filter_msg, filter_fmt,
filter_str);
}
}
if (event->loglevel_type !=
LTTNG_EVENT_LOGLEVEL_ALL) {
MSG("%s- %s%s (loglevel%s %s)%s", indent4,
event->name,
enabled_string(event->enabled),
logleveltype_string(
event->loglevel_type),
mi_lttng_loglevel_string(
event->loglevel,
handle->domain.type),
safe_string(filter_msg));
} else {
MSG("%s- %s%s%s", indent4, event->name,
enabled_string(event->enabled),
safe_string(filter_msg));
}
free(filter_msg);
}
MSG("");
}
end:
free(events);
error:
return ret;
}
