*/
#define _LGPL_SOURCE
-#include <assert.h>
#include <urcu/uatomic.h>
#include <urcu/rculist.h>
#include <lttng/event-rule/event-rule.h>
#include <lttng/event-rule/event-rule-internal.h>
-#include <lttng/event-rule/tracepoint.h>
+#include <lttng/event-rule/jul-logging.h>
+#include <lttng/event-rule/log4j-logging.h>
+#include <lttng/event-rule/python-logging.h>
#include <lttng/condition/condition.h>
-#include <lttng/condition/event-rule.h>
+#include <lttng/condition/event-rule-matches.h>
#include <lttng/domain-internal.h>
+#include <lttng/log-level-rule-internal.h>
#include <common/common.h>
#include <common/sessiond-comm/agent.h>
#define AGENT_RET_CODE_INDEX(code) (code - AGENT_RET_CODE_SUCCESS)
+typedef enum lttng_event_rule_status (*event_rule_logging_get_name_pattern)(
+ const struct lttng_event_rule *rule, const char **pattern);
+typedef enum lttng_event_rule_status (*event_rule_logging_get_log_level_rule)(
+ const struct lttng_event_rule *rule,
+ const struct lttng_log_level_rule **log_level_rule);
+
/*
* Agent application context representation.
*/
struct agent_event *event;
const struct agent_ht_key *key;
- assert(node);
- assert(_key);
+ LTTNG_ASSERT(node);
+ LTTNG_ASSERT(_key);
event = caa_container_of(node, struct agent_event, node.node);
key = _key;
const struct agent_ht_key *key;
int ll_match;
- assert(node);
- assert(_key);
+ LTTNG_ASSERT(node);
+ LTTNG_ASSERT(_key);
event = caa_container_of(node, struct agent_event, node.node);
key = _key;
struct cds_lfht_node *node_ptr;
struct agent_ht_key key;
- assert(ht);
- assert(ht->ht);
- assert(event);
+ LTTNG_ASSERT(ht);
+ LTTNG_ASSERT(ht->ht);
+ LTTNG_ASSERT(event);
key.name = event->name;
key.loglevel_value = event->loglevel_value;
node_ptr = cds_lfht_add_unique(ht->ht,
ht->hash_fct(event->node.key, lttng_ht_seed),
ht_match_event, &key, &event->node.node);
- assert(node_ptr == &event->node.node);
+ LTTNG_ASSERT(node_ptr == &event->node.node);
}
/*
ssize_t size;
struct lttcomm_agent_hdr msg;
- assert(sock);
+ LTTNG_ASSERT(sock);
memset(&msg, 0, sizeof(msg));
msg.data_size = htobe64(data_size);
int ret;
ssize_t len;
- assert(sock);
- assert(data);
+ LTTNG_ASSERT(sock);
+ LTTNG_ASSERT(data);
len = sock->ops->sendmsg(sock, data, size, 0);
if (len < size) {
int ret;
ssize_t len;
- assert(sock);
- assert(buf);
+ LTTNG_ASSERT(sock);
+ LTTNG_ASSERT(buf);
len = sock->ops->recvmsg(sock, buf, size, 0);
if (len < size) {
struct lttcomm_agent_list_reply *reply = NULL;
struct lttcomm_agent_list_reply_hdr reply_hdr;
- assert(app);
- assert(app->sock);
- assert(events);
+ LTTNG_ASSERT(app);
+ LTTNG_ASSERT(app->sock);
+ LTTNG_ASSERT(events);
DBG2("Agent listing events for app pid: %d and socket %d", app->pid,
app->sock->fd);
struct lttcomm_agent_enable_event msg;
struct lttcomm_agent_generic_reply reply;
- assert(app);
- assert(app->sock);
- assert(event);
+ LTTNG_ASSERT(app);
+ LTTNG_ASSERT(app->sock);
+ LTTNG_ASSERT(event);
DBG2("Agent enabling event %s for app pid: %d and socket %d", event->name,
app->pid, app->sock->fd);
struct lttcomm_agent_generic_reply reply;
size_t app_ctx_provider_name_len, app_ctx_name_len, data_size;
- assert(app);
- assert(app->sock);
- assert(ctx);
- assert(cmd == AGENT_CMD_APP_CTX_ENABLE ||
+ LTTNG_ASSERT(app);
+ LTTNG_ASSERT(app->sock);
+ LTTNG_ASSERT(ctx);
+ LTTNG_ASSERT(cmd == AGENT_CMD_APP_CTX_ENABLE ||
cmd == AGENT_CMD_APP_CTX_DISABLE);
DBG2("Agent %s application %s:%s for app pid: %d and socket %d",
struct lttcomm_agent_disable_event msg;
struct lttcomm_agent_generic_reply reply;
- assert(app);
- assert(app->sock);
- assert(event);
+ LTTNG_ASSERT(app);
+ LTTNG_ASSERT(app->sock);
+ LTTNG_ASSERT(event);
DBG2("Agent disabling event %s for app pid: %d and socket %d", event->name,
app->pid, app->sock->fd);
*/
int agent_send_registration_done(struct agent_app *app)
{
- assert(app);
- assert(app->sock);
+ LTTNG_ASSERT(app);
+ LTTNG_ASSERT(app->sock);
DBG("Agent sending registration done to app socket %d", app->sock->fd);
struct agent_app *app;
struct lttng_ht_iter iter;
- assert(event);
+ LTTNG_ASSERT(event);
rcu_read_lock();
- cds_lfht_for_each_entry(agent_apps_ht_by_sock->ht, &iter.iter, app,
+ cds_lfht_for_each_entry(the_agent_apps_ht_by_sock->ht, &iter.iter, app,
node.node) {
if (app->domain != domain) {
continue;
goto end;
}
- assert(ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT);
+ LTTNG_ASSERT(ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT);
agent_ctx = zmalloc(sizeof(*ctx));
if (!agent_ctx) {
goto end;
struct agent_app *app;
struct lttng_ht_iter iter;
- assert(ctx);
+ LTTNG_ASSERT(ctx);
if (ctx->ctx != LTTNG_EVENT_CONTEXT_APP_CONTEXT) {
ret = LTTNG_ERR_INVALID;
goto error;
rcu_read_lock();
- cds_lfht_for_each_entry(agent_apps_ht_by_sock->ht, &iter.iter, app,
+ cds_lfht_for_each_entry(the_agent_apps_ht_by_sock->ht, &iter.iter, app,
node.node) {
struct agent_app_ctx *agent_ctx;
struct agent_app *app;
struct lttng_ht_iter iter;
- assert(event);
+ LTTNG_ASSERT(event);
if (!AGENT_EVENT_IS_ENABLED(event)) {
goto end;
}
rcu_read_lock();
- cds_lfht_for_each_entry(agent_apps_ht_by_sock->ht, &iter.iter, app,
+ cds_lfht_for_each_entry(the_agent_apps_ht_by_sock->ht, &iter.iter, app,
node.node) {
if (app->domain != domain) {
continue;
}
/* event->enabled_count is now 0. */
- assert(!AGENT_EVENT_IS_ENABLED(event));
+ LTTNG_ASSERT(!AGENT_EVENT_IS_ENABLED(event));
error:
rcu_read_unlock();
struct agent_app *app;
struct lttng_ht_iter iter;
- assert(ctx);
+ LTTNG_ASSERT(ctx);
rcu_read_lock();
DBG2("Disabling agent application context %s:%s",
ctx->provider_name, ctx->ctx_name);
- cds_lfht_for_each_entry(agent_apps_ht_by_sock->ht, &iter.iter, app,
+ cds_lfht_for_each_entry(the_agent_apps_ht_by_sock->ht, &iter.iter, app,
node.node) {
if (app->domain != domain) {
continue;
struct lttng_event *tmp_events = NULL;
struct lttng_ht_iter iter;
- assert(events);
+ LTTNG_ASSERT(events);
DBG2("Agent listing events for domain %d", domain);
}
rcu_read_lock();
- cds_lfht_for_each_entry(agent_apps_ht_by_sock->ht, &iter.iter, app,
+ cds_lfht_for_each_entry(the_agent_apps_ht_by_sock->ht, &iter.iter, app,
node.node) {
ssize_t nb_ev;
struct lttng_event *agent_events;
{
struct agent_app *app;
- assert(sock);
+ LTTNG_ASSERT(sock);
app = zmalloc(sizeof(*app));
if (!app) {
struct lttng_ht_iter iter;
struct agent_app *app;
- assert(sock >= 0);
+ LTTNG_ASSERT(sock >= 0);
- lttng_ht_lookup(agent_apps_ht_by_sock, (void *)((unsigned long) sock), &iter);
+ lttng_ht_lookup(the_agent_apps_ht_by_sock,
+ (void *) ((unsigned long) sock), &iter);
node = lttng_ht_iter_get_node_ulong(&iter);
if (node == NULL) {
goto error;
*/
void agent_add_app(struct agent_app *app)
{
- assert(app);
+ LTTNG_ASSERT(app);
DBG3("Agent adding app sock: %d and pid: %d to ht", app->sock->fd, app->pid);
- lttng_ht_add_unique_ulong(agent_apps_ht_by_sock, &app->node);
+ lttng_ht_add_unique_ulong(the_agent_apps_ht_by_sock, &app->node);
}
/*
int ret;
struct lttng_ht_iter iter;
- assert(app);
+ LTTNG_ASSERT(app);
DBG3("Agent deleting app pid: %d and sock: %d", app->pid, app->sock->fd);
iter.iter.node = &app->node.node;
- ret = lttng_ht_del(agent_apps_ht_by_sock, &iter);
- assert(!ret);
+ ret = lttng_ht_del(the_agent_apps_ht_by_sock, &iter);
+ LTTNG_ASSERT(!ret);
}
/*
*/
void agent_destroy_app(struct agent_app *app)
{
- assert(app);
+ LTTNG_ASSERT(app);
if (app->sock) {
app->sock->ops->close(app->sock);
{
int ret;
- assert(agt);
+ LTTNG_ASSERT(agt);
agt->events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
if (!agt->events) {
*/
void agent_add(struct agent *agt, struct lttng_ht *ht)
{
- assert(agt);
- assert(ht);
+ LTTNG_ASSERT(agt);
+ LTTNG_ASSERT(ht);
DBG3("Agent adding from domain %d", agt->domain);
*/
void agent_add_event(struct agent_event *event, struct agent *agt)
{
- assert(event);
- assert(agt);
- assert(agt->events);
+ LTTNG_ASSERT(event);
+ LTTNG_ASSERT(agt);
+ LTTNG_ASSERT(agt->events);
DBG3("Agent adding event %s", event->name);
add_unique_agent_event(agt->events, event);
int ret = LTTNG_OK;
struct agent_app_ctx *agent_ctx = NULL;
- assert(ctx);
- assert(agt);
- assert(agt->events);
- assert(ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT);
+ LTTNG_ASSERT(ctx);
+ LTTNG_ASSERT(agt);
+ LTTNG_ASSERT(agt->events);
+ LTTNG_ASSERT(ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT);
agent_ctx = create_app_ctx(ctx);
if (!agent_ctx) {
struct lttng_ht *ht;
struct agent_ht_key key;
- assert(name);
- assert(agt);
- assert(agt->events);
- assert(iter);
+ LTTNG_ASSERT(name);
+ LTTNG_ASSERT(agt);
+ LTTNG_ASSERT(agt->events);
+ LTTNG_ASSERT(iter);
ht = agt->events;
key.name = name;
const struct lttng_event_rule *rule;
const char *name;
const char *filter_expression;
+ const struct lttng_log_level_rule *log_level_rule;
/* Unused when loglevel_type is 'ALL'. */
int loglevel_value = 0;
enum lttng_loglevel_type loglevel_type;
+ event_rule_logging_get_name_pattern logging_get_name_pattern;
+ event_rule_logging_get_log_level_rule logging_get_log_level_rule;
- assert(agt);
- assert(agt->events);
+ LTTNG_ASSERT(agt);
+ LTTNG_ASSERT(agt->events);
condition = lttng_trigger_get_const_condition(trigger);
- assert(lttng_condition_get_type(condition) ==
- LTTNG_CONDITION_TYPE_ON_EVENT);
+ LTTNG_ASSERT(lttng_condition_get_type(condition) ==
+ LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
- c_status = lttng_condition_on_event_get_rule(condition, &rule);
- assert(c_status == LTTNG_CONDITION_STATUS_OK);
+ c_status = lttng_condition_event_rule_matches_get_rule(
+ condition, &rule);
+ LTTNG_ASSERT(c_status == LTTNG_CONDITION_STATUS_OK);
- assert(lttng_event_rule_get_type(rule) ==
- LTTNG_EVENT_RULE_TYPE_TRACEPOINT);
+ switch (lttng_event_rule_get_type(rule)) {
+ case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
+ logging_get_name_pattern =
+ lttng_event_rule_jul_logging_get_name_pattern;
+ logging_get_log_level_rule =
+ lttng_event_rule_jul_logging_get_log_level_rule;
+ break;
+ case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
+ logging_get_name_pattern =
+ lttng_event_rule_log4j_logging_get_name_pattern;
+ logging_get_log_level_rule =
+ lttng_event_rule_log4j_logging_get_log_level_rule;
+ break;
+ case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
+ logging_get_name_pattern =
+ lttng_event_rule_python_logging_get_name_pattern;
+ logging_get_log_level_rule =
+ lttng_event_rule_python_logging_get_log_level_rule;
+ break;
+ default:
+ abort();
+ break;
+ }
domain = lttng_event_rule_get_domain_type(rule);
- assert(domain == LTTNG_DOMAIN_JUL || domain == LTTNG_DOMAIN_LOG4J ||
+ LTTNG_ASSERT(domain == LTTNG_DOMAIN_JUL || domain == LTTNG_DOMAIN_LOG4J ||
domain == LTTNG_DOMAIN_PYTHON);
- /* Get the event's pattern ('name' in the legacy terminology). */
- er_status = lttng_event_rule_tracepoint_get_pattern(rule, &name);
- assert(er_status == LTTNG_EVENT_RULE_STATUS_OK);
+ /* Get the event's pattern name ('name' in the legacy terminology). */
+ er_status = logging_get_name_pattern(rule, &name);
+ LTTNG_ASSERT(er_status == LTTNG_EVENT_RULE_STATUS_OK);
/* Get the internal filter expression. */
filter_expression = lttng_event_rule_get_filter(rule);
- er_status = lttng_event_rule_tracepoint_get_log_level_type(
- rule, &loglevel_type);
- assert(er_status == LTTNG_EVENT_RULE_STATUS_OK);
-
- if (loglevel_type != LTTNG_EVENT_LOGLEVEL_ALL) {
- er_status = lttng_event_rule_tracepoint_get_log_level(
- rule, &loglevel_value);
- assert(er_status == LTTNG_EVENT_RULE_STATUS_OK);
+ /* Map log_level_rule to loglevel value. */
+ er_status = logging_get_log_level_rule(rule, &log_level_rule);
+ if (er_status == LTTNG_EVENT_RULE_STATUS_UNSET) {
+ loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
+ loglevel_value = 0;
+ } else if (er_status == LTTNG_EVENT_RULE_STATUS_OK) {
+ lttng_log_level_rule_to_loglevel(log_level_rule, &loglevel_type, &loglevel_value);
+ } else {
+ abort();
}
return agent_find_event(name, loglevel_type, loglevel_value,
struct lttng_ht *ht;
struct agent_ht_key key;
- assert(name);
- assert(agt);
- assert(agt->events);
+ LTTNG_ASSERT(name);
+ LTTNG_ASSERT(agt);
+ LTTNG_ASSERT(agt->events);
ht = agt->events;
key.name = name;
*/
void agent_destroy_event(struct agent_event *event)
{
- assert(event);
+ LTTNG_ASSERT(event);
free(event->filter);
free(event->filter_expression);
struct lttng_ht_iter iter;
struct agent_app_ctx *ctx;
- assert(agt);
+ LTTNG_ASSERT(agt);
DBG3("Agent destroy");
(void) agent_disable_event(event, agt->domain);
ret = lttng_ht_del(agt->events, &iter);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
call_rcu(&node->head, destroy_event_agent_rcu);
}
*/
int agent_app_ht_alloc(void)
{
- agent_apps_ht_by_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
- return agent_apps_ht_by_sock ? 0 : -1;
+ the_agent_apps_ht_by_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
+ return the_agent_apps_ht_by_sock ? 0 : -1;
}
/*
{
struct agent_app *app;
- assert(sock >= 0);
+ LTTNG_ASSERT(sock >= 0);
/*
* Not finding an application is a very important error that should NEVER
*/
rcu_read_lock();
app = agent_find_app_by_sock(sock);
- assert(app);
+ LTTNG_ASSERT(app);
/* RCU read side lock is assumed to be held by this function. */
agent_delete_app(app);
struct lttng_ht_node_ulong *node;
struct lttng_ht_iter iter;
- if (!agent_apps_ht_by_sock) {
+ if (!the_agent_apps_ht_by_sock) {
return;
}
rcu_read_lock();
- cds_lfht_for_each_entry(agent_apps_ht_by_sock->ht, &iter.iter, node, node) {
+ cds_lfht_for_each_entry(
+ the_agent_apps_ht_by_sock->ht, &iter.iter, node, node) {
struct agent_app *app;
app = caa_container_of(node, struct agent_app, node);
}
rcu_read_unlock();
- lttng_ht_destroy(agent_apps_ht_by_sock);
+ lttng_ht_destroy(the_agent_apps_ht_by_sock);
}
/*
struct lttng_ht_iter iter;
struct agent_app_ctx *ctx;
- assert(agt);
- assert(app);
+ LTTNG_ASSERT(agt);
+ LTTNG_ASSERT(app);
DBG("Agent updating app: pid = %ld", (long) app->pid);
*/
int agent_by_event_notifier_domain_ht_create(void)
{
- trigger_agents_ht_by_domain = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
- return trigger_agents_ht_by_domain ? 0 : -1;
+ the_trigger_agents_ht_by_domain = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
+ return the_trigger_agents_ht_by_domain ? 0 : -1;
}
/*
struct lttng_ht_node_u64 *node;
struct lttng_ht_iter iter;
- if (!trigger_agents_ht_by_domain) {
+ if (!the_trigger_agents_ht_by_domain) {
return;
}
rcu_read_lock();
- cds_lfht_for_each_entry (trigger_agents_ht_by_domain->ht, &iter.iter,
- node, node) {
+ cds_lfht_for_each_entry(the_trigger_agents_ht_by_domain->ht,
+ &iter.iter, node, node) {
struct agent *agent =
caa_container_of(node, struct agent, node);
const int ret = lttng_ht_del(
- trigger_agents_ht_by_domain, &iter);
+ the_trigger_agents_ht_by_domain, &iter);
- assert(ret == 0);
+ LTTNG_ASSERT(ret == 0);
agent_destroy(agent);
}
rcu_read_unlock();
- lttng_ht_destroy(trigger_agents_ht_by_domain);
+ lttng_ht_destroy(the_trigger_agents_ht_by_domain);
}
struct agent *agent_find_by_event_notifier_domain(
struct lttng_ht_iter iter;
const uint64_t key = (uint64_t) domain_type;
- assert(trigger_agents_ht_by_domain);
+ LTTNG_ASSERT(the_trigger_agents_ht_by_domain);
DBG3("Per-event notifier domain agent lookup for domain '%s'",
lttng_domain_type_str(domain_type));
- lttng_ht_lookup(trigger_agents_ht_by_domain, &key, &iter);
+ lttng_ht_lookup(the_trigger_agents_ht_by_domain, &key, &iter);
node = lttng_ht_iter_get_node_u64(&iter);
if (!node) {
goto end;
projects / lttng-tools.git / blobdiff