#include <common/hashtable/utils.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/user-tracepoint.h>
#include <lttng/condition/condition.h>
#include <lttng/condition/event-rule-matches-internal.h>
#include <lttng/condition/event-rule-matches.h>
const struct ust_app_ht_key *key;
int ev_loglevel_value;
- assert(node);
- assert(_key);
+ LTTNG_ASSERT(node);
+ LTTNG_ASSERT(_key);
event = caa_container_of(node, struct ust_app_event, node.node);
key = _key;
struct ust_app_ht_key key;
struct lttng_ht *ht;
- assert(ua_chan);
- assert(ua_chan->events);
- assert(event);
+ LTTNG_ASSERT(ua_chan);
+ LTTNG_ASSERT(ua_chan->events);
+ LTTNG_ASSERT(event);
ht = ua_chan->events;
key.name = event->attr.name;
node_ptr = cds_lfht_add_unique(ht->ht,
ht->hash_fct(event->node.key, lttng_ht_seed),
ht_match_ust_app_event, &key, &event->node.node);
- assert(node_ptr == &event->node.node);
+ LTTNG_ASSERT(node_ptr == &event->node.node);
}
/*
caa_container_of(head, struct ust_app_notify_sock_obj, head);
/* Must have a valid fd here. */
- assert(obj->fd >= 0);
+ LTTNG_ASSERT(obj->fd >= 0);
ret = close(obj->fd);
if (ret) {
* session.
*
* A registry per UID object MUST exists before calling this function or else
- * it assert() if not found. RCU read side lock must be acquired.
+ * it LTTNG_ASSERT() if not found. RCU read side lock must be acquired.
*/
static struct ust_registry_session *get_session_registry(
struct ust_app_session *ua_sess)
{
struct ust_registry_session *registry = NULL;
- assert(ua_sess);
+ LTTNG_ASSERT(ua_sess);
switch (ua_sess->buffer_type) {
case LTTNG_BUFFER_PER_PID:
break;
}
default:
- assert(0);
+ abort();
};
error:
{
int ret;
- assert(ua_ctx);
+ LTTNG_ASSERT(ua_ctx);
if (ua_ctx->obj) {
pthread_mutex_lock(&app->sock_lock);
ret = lttng_ust_ctl_release_object(sock, ua_ctx->obj);
pthread_mutex_unlock(&app->sock_lock);
- if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app sock %d release ctx obj handle %d failed with ret %d",
- sock, ua_ctx->obj->handle, ret);
+ if (ret < 0) {
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app release ctx failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app release ctx failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app release ctx obj handle %d failed with ret %d: pid = %d, sock = %d",
+ ua_ctx->obj->handle, ret,
+ app->pid, app->sock);
+ }
}
free(ua_ctx->obj);
}
{
int ret;
- assert(ua_event);
+ LTTNG_ASSERT(ua_event);
free(ua_event->filter);
if (ua_event->exclusion != NULL)
pthread_mutex_lock(&app->sock_lock);
ret = lttng_ust_ctl_release_object(sock, ua_event->obj);
pthread_mutex_unlock(&app->sock_lock);
- if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app sock %d release event obj failed with ret %d",
- sock, ret);
+ if (ret < 0) {
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app release event failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app release event failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app release event obj failed with ret %d: pid = %d, sock = %d",
+ ret, app->pid, app->sock);
+ }
}
free(ua_event->obj);
}
{
int ret;
- assert(ua_event_notifier_rule);
+ LTTNG_ASSERT(ua_event_notifier_rule);
if (ua_event_notifier_rule->exclusion != NULL) {
free(ua_event_notifier_rule->exclusion);
pthread_mutex_lock(&app->sock_lock);
ret = lttng_ust_ctl_release_object(sock, ua_event_notifier_rule->obj);
pthread_mutex_unlock(&app->sock_lock);
- if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("Failed to release event notifier object: app = '%s' (ppid %d), ret = %d",
- app->name, (int) app->ppid, ret);
+ if (ret < 0) {
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app release event notifier failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app release event notifier failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app release event notifier failed with ret %d: pid = %d, sock = %d",
+ ret, app->pid, app->sock);
+ }
}
free(ua_event_notifier_rule->obj);
{
int ret = 0;
- assert(stream);
+ LTTNG_ASSERT(stream);
if (stream->obj) {
pthread_mutex_lock(&app->sock_lock);
ret = lttng_ust_ctl_release_object(sock, stream->obj);
pthread_mutex_unlock(&app->sock_lock);
- if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app sock %d release stream obj failed with ret %d",
- sock, ret);
+ if (ret < 0) {
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app release stream failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app release stream failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app release stream obj failed with ret %d: pid = %d, sock = %d",
+ ret, app->pid, app->sock);
+ }
}
lttng_fd_put(LTTNG_FD_APPS, 2);
free(stream->obj);
void delete_ust_app_stream(int sock, struct ust_app_stream *stream,
struct ust_app *app)
{
- assert(stream);
+ LTTNG_ASSERT(stream);
(void) release_ust_app_stream(sock, stream, app);
free(stream);
struct ust_app_stream *stream, *stmp;
struct ust_registry_session *registry;
- assert(ua_chan);
+ LTTNG_ASSERT(ua_chan);
DBG3("UST app deleting channel %s", ua_chan->name);
cds_lfht_for_each_entry(ua_chan->ctx->ht, &iter.iter, ua_ctx, node.node) {
cds_list_del(&ua_ctx->list);
ret = lttng_ht_del(ua_chan->ctx, &iter);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
delete_ust_app_ctx(sock, ua_ctx, app);
}
cds_lfht_for_each_entry(ua_chan->events->ht, &iter.iter, ua_event,
node.node) {
ret = lttng_ht_del(ua_chan->events, &iter);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
delete_ust_app_event(sock, ua_event, app);
}
/* Remove channel from application UST object descriptor. */
iter.iter.node = &ua_chan->ust_objd_node.node;
ret = lttng_ht_del(app->ust_objd, &iter);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
pthread_mutex_lock(&app->sock_lock);
ret = lttng_ust_ctl_release_object(sock, ua_chan->obj);
pthread_mutex_unlock(&app->sock_lock);
- if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app sock %d release channel obj failed with ret %d",
- sock, ret);
+ if (ret < 0) {
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app channel %s release failed. Application is dead: pid = %d, sock = %d",
+ ua_chan->name, app->pid,
+ app->sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app channel %s release failed. Communication time out: pid = %d, sock = %d",
+ ua_chan->name, app->pid,
+ app->sock);
+ } else {
+ ERR("UST app channel %s release failed with ret %d: pid = %d, sock = %d",
+ ua_chan->name, ret, app->pid,
+ app->sock);
+ }
}
lttng_fd_put(LTTNG_FD_APPS, 1);
free(ua_chan->obj);
ssize_t ret_val;
uint64_t metadata_key, metadata_version;
- assert(registry);
- assert(socket);
+ LTTNG_ASSERT(registry);
+ LTTNG_ASSERT(socket);
metadata_key = registry->metadata_key;
ssize_t ret;
struct consumer_socket *socket;
- assert(registry);
- assert(consumer);
+ LTTNG_ASSERT(registry);
+ LTTNG_ASSERT(consumer);
pthread_mutex_lock(®istry->lock);
if (registry->metadata_closed) {
uint64_t metadata_key;
bool registry_was_already_closed;
- assert(registry);
- assert(consumer);
+ LTTNG_ASSERT(registry);
+ LTTNG_ASSERT(consumer);
rcu_read_lock();
struct ust_app_channel *ua_chan;
struct ust_registry_session *registry;
- assert(ua_sess);
+ LTTNG_ASSERT(ua_sess);
pthread_mutex_lock(&ua_sess->lock);
- assert(!ua_sess->deleted);
+ LTTNG_ASSERT(!ua_sess->deleted);
ua_sess->deleted = true;
registry = get_session_registry(ua_sess);
cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
node.node) {
ret = lttng_ht_del(ua_sess->channels, &iter);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
delete_ust_app_channel(sock, ua_chan, app);
}
pthread_mutex_lock(&app->sock_lock);
ret = lttng_ust_ctl_release_handle(sock, ua_sess->handle);
pthread_mutex_unlock(&app->sock_lock);
- if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app sock %d release session handle failed with ret %d",
- sock, ret);
+ if (ret < 0) {
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app release session handle failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app release session handle failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app release session handle failed with ret %d: pid = %d, sock = %d",
+ ret, app->pid, app->sock);
+ }
}
+
/* Remove session from application UST object descriptor. */
iter.iter.node = &ua_sess->ust_objd_node.node;
ret = lttng_ht_del(app->ust_sessions_objd, &iter);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
}
pthread_mutex_unlock(&ua_sess->lock);
cds_lfht_for_each_entry (app->token_to_event_notifier_rule_ht->ht,
&iter.iter, event_notifier_rule, node.node) {
ret = lttng_ht_del(app->token_to_event_notifier_rule_ht, &iter);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
delete_ust_app_event_notifier_rule(
app->sock, event_notifier_rule, app);
int ret;
struct lttng_ht_iter iter;
- assert(app);
- assert(ua_sess);
+ LTTNG_ASSERT(app);
+ LTTNG_ASSERT(ua_sess);
iter.iter.node = &ua_sess->node.node;
ret = lttng_ht_del(app->sessions, &iter);
{
enum lttng_event_rule_generate_exclusions_status
generate_exclusion_status;
+ enum lttng_condition_status cond_status;
struct ust_app_event_notifier_rule *ua_event_notifier_rule;
struct lttng_condition *condition = NULL;
const struct lttng_event_rule *event_rule = NULL;
ua_event_notifier_rule->token);
condition = lttng_trigger_get_condition(trigger);
- assert(condition);
- assert(lttng_condition_get_type(condition) ==
+ LTTNG_ASSERT(condition);
+ LTTNG_ASSERT(lttng_condition_get_type(condition) ==
LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
- assert(LTTNG_CONDITION_STATUS_OK ==
- lttng_condition_event_rule_matches_get_rule(
- condition, &event_rule));
- assert(event_rule);
+ cond_status = lttng_condition_event_rule_matches_get_rule(
+ condition, &event_rule);
+ LTTNG_ASSERT(cond_status == LTTNG_CONDITION_STATUS_OK);
+ LTTNG_ASSERT(event_rule);
ua_event_notifier_rule->error_counter_index =
lttng_condition_event_rule_matches_get_error_counter_index(condition);
case LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_NONE:
break;
default:
- /* Error occured. */
+ /* Error occurred. */
ERR("Failed to generate exclusions from trigger while allocating an event notifier rule");
goto error_put_trigger;
}
goto error;
}
- assert(sizeof(struct lttng_bytecode) ==
+ LTTNG_ASSERT(sizeof(struct lttng_bytecode) ==
sizeof(struct lttng_ust_abi_filter_bytecode));
memcpy(filter, orig_f, sizeof(*filter) + orig_f->len);
error:
goto error;
}
- assert(sizeof(struct lttng_bytecode) ==
+ LTTNG_ASSERT(sizeof(struct lttng_bytecode) ==
sizeof(struct lttng_ust_abi_capture_bytecode));
memcpy(capture, orig_f, sizeof(*capture) + orig_f->len);
error:
struct ust_app_event *event = NULL;
struct ust_app_ht_key key;
- assert(name);
- assert(ht);
+ LTTNG_ASSERT(name);
+ LTTNG_ASSERT(ht);
/* Setup key for event lookup. */
key.name = name;
struct lttng_ht_node_u64 *node;
struct ust_app_event_notifier_rule *event_notifier_rule = NULL;
- assert(ht);
+ LTTNG_ASSERT(ht);
lttng_ht_lookup(ht, &token, &iter);
node = lttng_ht_iter_get_node_u64(&iter);
ua_chan->obj, &ua_ctx->obj);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app create channel context failed for app (pid: %d) "
- "with ret %d", app->pid, ret);
- } else {
- /*
- * This is normal behavior, an application can die during the
- * creation process. Don't report an error so the execution can
- * continue normally.
- */
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ ret = 0;
+ DBG3("UST app create channel context failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
ret = 0;
- DBG3("UST app add context failed. Application is dead.");
+ WARN("UST app create channel context failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app create channel context failed with ret %d: pid = %d, sock = %d",
+ ret, app->pid, app->sock);
}
goto error;
}
ust_object);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app set object filter failed: object = %p of app pid = %d, ret = %d",
- ust_object, app->pid, ret);
- } else {
- /*
- * This is normal behavior, an application can die during the
- * creation process. Don't report an error so the execution can
- * continue normally.
- */
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ ret = 0;
+ DBG3("UST app set filter failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
ret = 0;
- DBG3("Failed to set UST app object filter. Application is dead.");
+ WARN("UST app set filter failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app set filter failed with ret %d: pid = %d, sock = %d, object = %p",
+ ret, app->pid, app->sock, ust_object);
}
goto error;
}
ust_object);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app set object capture failed: object = %p of app pid = %d, ret = %d",
- ust_object, app->pid, ret);
- } else {
- /*
- * This is normal behavior, an application can die during the
- * creation process. Don't report an error so the execution can
- * continue normally.
- */
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ ret = 0;
+ DBG3("UST app set capture failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
ret = 0;
- DBG3("Failed to set UST app object capture. Application is dead.");
+ DBG3("UST app set capture failed. Communication timeout: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app event set capture failed with ret %d: pid = %d, sock = %d",
+ ret, app->pid,
+ app->sock);
}
goto error;
goto end;
}
- assert(sizeof(struct lttng_event_exclusion) ==
+ LTTNG_ASSERT(sizeof(struct lttng_event_exclusion) ==
sizeof(struct lttng_ust_abi_event_exclusion));
memcpy(ust_exclusion, exclusion, exclusion_alloc_size);
end:
int ret;
struct lttng_ust_abi_event_exclusion *ust_exclusions = NULL;
- assert(exclusions && exclusions->count > 0);
+ LTTNG_ASSERT(exclusions && exclusions->count > 0);
health_code_update();
ret = lttng_ust_ctl_set_exclusion(app->sock, ust_exclusions, ust_object);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("Failed to set UST app exclusions for object %p of app (pid: %d) "
- "with ret %d", ust_object, app->pid, ret);
- } else {
- /*
- * This is normal behavior, an application can die during the
- * creation process. Don't report an error so the execution can
- * continue normally.
- */
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
ret = 0;
- DBG3("Failed to set UST app object exclusions. Application is dead.");
+ DBG3("UST app event exclusion failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ ret = 0;
+ WARN("UST app event exclusion failed. Communication time out(pid: %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app event exclusions failed with ret %d: pid = %d, sock = %d, object = %p",
+ ret, app->pid, app->sock, ust_object);
}
goto error;
}
ret = lttng_ust_ctl_disable(app->sock, object);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("Failed to disable UST app object %p app (pid: %d) with ret %d",
- object, app->pid, ret);
- } else {
- /*
- * This is normal behavior, an application can die during the
- * creation process. Don't report an error so the execution can
- * continue normally.
- */
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ ret = 0;
+ DBG3("UST app disable object failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
ret = 0;
- DBG3("Failed to disable UST app object. Application is dead.");
+ WARN("UST app disable object failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app disable object failed with ret %d: pid = %d, sock = %d, object = %p",
+ ret, app->pid, app->sock, object);
}
goto error;
}
- DBG2("UST app object %p disabled successfully for app (pid: %d)",
+ DBG2("UST app object %p disabled successfully for app: pid = %d",
object, app->pid);
error:
ret = lttng_ust_ctl_disable(app->sock, ua_chan->obj);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app channel %s disable failed for app (pid: %d) "
- "and session handle %d with ret %d",
- ua_chan->name, app->pid, ua_sess->handle, ret);
- } else {
- /*
- * This is normal behavior, an application can die during the
- * creation process. Don't report an error so the execution can
- * continue normally.
- */
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ ret = 0;
+ DBG3("UST app disable channel failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
ret = 0;
- DBG3("UST app disable channel failed. Application is dead.");
+ WARN("UST app disable channel failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app channel %s disable failed, session handle %d, with ret %d: pid = %d, sock = %d",
+ ua_chan->name, ua_sess->handle, ret,
+ app->pid, app->sock);
}
goto error;
}
- DBG2("UST app channel %s disabled successfully for app (pid: %d)",
+ DBG2("UST app channel %s disabled successfully for app: pid = %d",
ua_chan->name, app->pid);
error:
ret = lttng_ust_ctl_enable(app->sock, ua_chan->obj);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app channel %s enable failed for app (pid: %d) "
- "and session handle %d with ret %d",
- ua_chan->name, app->pid, ua_sess->handle, ret);
- } else {
- /*
- * This is normal behavior, an application can die during the
- * creation process. Don't report an error so the execution can
- * continue normally.
- */
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ ret = 0;
+ DBG3("UST app channel %s enable failed. Application is dead: pid = %d, sock = %d",
+ ua_chan->name, app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
ret = 0;
- DBG3("UST app enable channel failed. Application is dead.");
+ WARN("UST app channel %s enable failed. Communication time out: pid = %d, sock = %d",
+ ua_chan->name, app->pid, app->sock);
+ } else {
+ ERR("UST app channel %s enable failed, session handle %d, with ret %d: pid = %d, sock = %d",
+ ua_chan->name, ua_sess->handle, ret,
+ app->pid, app->sock);
}
goto error;
}
ua_chan->enabled = 1;
- DBG2("UST app channel %s enabled successfully for app (pid: %d)",
+ DBG2("UST app channel %s enabled successfully for app: pid = %d",
ua_chan->name, app->pid);
error:
ret = lttng_ust_ctl_enable(app->sock, ust_object);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app enable failed for object %p app (pid: %d) with ret %d",
- ust_object, app->pid, ret);
- } else {
- /*
- * This is normal behavior, an application can die during the
- * creation process. Don't report an error so the execution can
- * continue normally.
- */
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ ret = 0;
+ DBG3("UST app enable object failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
ret = 0;
- DBG3("Failed to enable UST app object. Application is dead.");
+ WARN("UST app enable object failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app enable object failed with ret %d: pid = %d, sock = %d, object = %p",
+ ret, app->pid, app->sock, ust_object);
}
goto error;
}
- DBG2("UST app object %p enabled successfully for app (pid: %d)",
+ DBG2("UST app object %p enabled successfully for app: pid = %d",
ust_object, app->pid);
error:
int ret;
struct ust_app_stream *stream, *stmp;
- assert(app);
- assert(ua_sess);
- assert(ua_chan);
+ LTTNG_ASSERT(app);
+ LTTNG_ASSERT(ua_sess);
+ LTTNG_ASSERT(ua_chan);
health_code_update();
if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
ret = -ENOTCONN; /* Caused by app exiting. */
goto error;
+ } else if (ret == -EAGAIN) {
+ /* Caused by timeout. */
+ WARN("Communication with application %d timed out on send_channel for channel \"%s\" of session \"%" PRIu64 "\".",
+ app->pid, ua_chan->name, ua_sess->tracing_id);
+ /* Treat this the same way as an application that is exiting. */
+ ret = -ENOTCONN;
+ goto error;
} else if (ret < 0) {
goto error;
}
cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
ret = ust_consumer_send_stream_to_ust(app, ua_chan, stream);
if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
- ret = -ENOTCONN; /* Caused by app exiting. */
+ ret = -ENOTCONN; /* Caused by app exiting. */
goto error;
+ } else if (ret == -EAGAIN) {
+ /* Caused by timeout. */
+ WARN("Communication with application %d timed out on send_stream for stream \"%s\" of channel \"%s\" of session \"%" PRIu64 "\".",
+ app->pid, stream->name, ua_chan->name,
+ ua_sess->tracing_id);
+ /*
+ * Treat this the same way as an application that is
+ * exiting.
+ */
+ ret = -ENOTCONN;
} else if (ret < 0) {
goto error;
}
&ua_event->obj);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- abort();
- ERR("Error ustctl create event %s for app pid: %d with ret %d",
- ua_event->attr.name, app->pid, ret);
- } else {
- /*
- * This is normal behavior, an application can die during the
- * creation process. Don't report an error so the execution can
- * continue normally.
- */
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ ret = 0;
+ DBG3("UST app create event failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
ret = 0;
- DBG3("UST app create event failed. Application is dead.");
+ WARN("UST app create event failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app create event '%s' failed with ret %d: pid = %d, sock = %d",
+ ua_event->attr.name, ret, app->pid,
+ app->sock);
}
goto error;
}
ua_event->handle = ua_event->obj->handle;
- DBG2("UST app event %s created successfully for pid:%d object: %p",
+ DBG2("UST app event %s created successfully for pid:%d object = %p",
ua_event->attr.name, app->pid, ua_event->obj);
health_code_update();
switch (ret) {
case -LTTNG_UST_ERR_PERM:
/* Code flow problem */
- assert(0);
+ abort();
case -LTTNG_UST_ERR_EXIST:
/* It's OK for our use case. */
ret = 0;
int loglevel = -1, ret = 0;
const char *pattern;
- /* For now only LTTNG_EVENT_RULE_TYPE_TRACEPOINT are supported. */
- assert(lttng_event_rule_get_type(rule) ==
- LTTNG_EVENT_RULE_TYPE_TRACEPOINT);
memset(event_notifier, 0, sizeof(*event_notifier));
} else {
const struct lttng_log_level_rule *log_level_rule;
- status = lttng_event_rule_tracepoint_get_name_pattern(rule, &pattern);
+ LTTNG_ASSERT(lttng_event_rule_get_type(rule) ==
+ LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT);
+
+ status = lttng_event_rule_user_tracepoint_get_name_pattern(rule, &pattern);
if (status != LTTNG_EVENT_RULE_STATUS_OK) {
/* At this point, this is a fatal error. */
abort();
}
- status = lttng_event_rule_tracepoint_get_log_level_rule(
+ status = lttng_event_rule_user_tracepoint_get_log_level_rule(
rule, &log_level_rule);
if (status == LTTNG_EVENT_RULE_STATUS_UNSET) {
ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_ALL;
abort();
}
- assert(llr_status == LTTNG_LOG_LEVEL_RULE_STATUS_OK);
+ LTTNG_ASSERT(llr_status == LTTNG_LOG_LEVEL_RULE_STATUS_OK);
} else {
/* At this point this is a fatal error. */
abort();
const struct lttng_event_rule *event_rule = NULL;
unsigned int capture_bytecode_count = 0, i;
enum lttng_condition_status cond_status;
+ enum lttng_event_rule_type event_rule_type;
health_code_update();
- assert(app->event_notifier_group.object);
+ LTTNG_ASSERT(app->event_notifier_group.object);
condition = lttng_trigger_get_const_condition(
ua_event_notifier_rule->trigger);
- assert(condition);
- assert(lttng_condition_get_type(condition) ==
+ LTTNG_ASSERT(condition);
+ LTTNG_ASSERT(lttng_condition_get_type(condition) ==
LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
condition_status = lttng_condition_event_rule_matches_get_rule(
condition, &event_rule);
- assert(condition_status == LTTNG_CONDITION_STATUS_OK);
+ LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
+
+ LTTNG_ASSERT(event_rule);
- assert(event_rule);
- assert(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_TRACEPOINT);
+ event_rule_type = lttng_event_rule_get_type(event_rule);
+ LTTNG_ASSERT(event_rule_type == LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT ||
+ event_rule_type == LTTNG_EVENT_RULE_TYPE_JUL_LOGGING ||
+ event_rule_type ==
+ LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING ||
+ event_rule_type ==
+ LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING);
init_ust_event_notifier_from_event_rule(event_rule, &event_notifier);
event_notifier.event.token = ua_event_notifier_rule->token;
&ua_event_notifier_rule->obj);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("Error ustctl create event notifier: name = '%s', app = '%s' (ppid: %d), ret = %d",
- event_notifier.event.name, app->name,
- app->ppid, ret);
- } else {
- /*
- * This is normal behavior, an application can die
- * during the creation process. Don't report an error so
- * the execution can continue normally.
- */
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
ret = 0;
- DBG3("UST app create event notifier failed (application is dead): app = '%s' (ppid = %d)",
- app->name, app->ppid);
+ DBG3("UST app create event notifier failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ ret = 0;
+ WARN("UST app create event notifier failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app create event notifier '%s' failed with ret %d: pid = %d, sock = %d",
+ event_notifier.event.name, ret, app->pid,
+ app->sock);
}
-
goto error;
}
ua_event_notifier_rule->handle = ua_event_notifier_rule->obj->handle;
- DBG2("UST app event notifier %s created successfully: app = '%s' (ppid: %d), object: %p",
- event_notifier.event.name, app->name, app->ppid,
+ DBG2("UST app event notifier %s created successfully: app = '%s': pid = %d), object = %p",
+ event_notifier.event.name, app->name, app->pid,
ua_event_notifier_rule->obj);
health_code_update();
/* Set the capture bytecodes. */
cond_status = lttng_condition_event_rule_matches_get_capture_descriptor_count(
condition, &capture_bytecode_count);
- assert(cond_status == LTTNG_CONDITION_STATUS_OK);
+ LTTNG_ASSERT(cond_status == LTTNG_CONDITION_STATUS_OK);
for (i = 0; i < capture_bytecode_count; i++) {
const struct lttng_bytecode *capture_bytecode =
app->bits_per_long);
break;
default:
- assert(0);
+ abort();
goto error;
}
if (ret < 0) {
PERROR("asprintf UST shadow copy session");
- assert(0);
+ abort();
goto error;
}
app->uid, app->bits_per_long);
break;
default:
- assert(0);
+ abort();
goto error;
}
if (ret < 0) {
PERROR("sprintf UST shadow copy session");
- assert(0);
+ abort();
goto error;
}
strncat(ua_sess->shm_path, tmp_shm_path,
int ret = 0;
struct buffer_reg_pid *reg_pid;
- assert(ua_sess);
- assert(app);
+ LTTNG_ASSERT(ua_sess);
+ LTTNG_ASSERT(app);
rcu_read_lock();
int ret = 0;
struct buffer_reg_uid *reg_uid;
- assert(usess);
- assert(app);
+ LTTNG_ASSERT(usess);
+ LTTNG_ASSERT(app);
rcu_read_lock();
int ret, created = 0;
struct ust_app_session *ua_sess;
- assert(usess);
- assert(app);
- assert(ua_sess_ptr);
+ LTTNG_ASSERT(usess);
+ LTTNG_ASSERT(app);
+ LTTNG_ASSERT(ua_sess_ptr);
health_code_update();
}
break;
default:
- assert(0);
+ abort();
ret = -EINVAL;
goto error;
}
ret = lttng_ust_ctl_create_session(app->sock);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("Creating session for app pid %d with ret %d",
- app->pid, ret);
- } else {
- DBG("UST app creating session failed. Application is dead");
- /*
- * This is normal behavior, an application can die during the
- * creation process. Don't report an error so the execution can
- * continue normally. This will get flagged ENOTCONN and the
- * caller will handle it.
- */
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG("UST app creating session failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
ret = 0;
+ } else if (ret == -EAGAIN) {
+ DBG("UST app creating session failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
+ ret = 0;
+ } else {
+ ERR("UST app creating session failed with ret %d: pid = %d, sock =%d",
+ ret, app->pid, app->sock);
}
delete_ust_app_session(-1, ua_sess, app);
if (ret != -ENOMEM) {
struct ust_app_ctx *ctx;
const struct lttng_ust_context_attr *key;
- assert(node);
- assert(_key);
+ LTTNG_ASSERT(node);
+ LTTNG_ASSERT(_key);
ctx = caa_container_of(node, struct ust_app_ctx, node.node);
key = _key;
struct lttng_ht_node_ulong *node;
struct ust_app_ctx *app_ctx = NULL;
- assert(uctx);
- assert(ht);
+ LTTNG_ASSERT(uctx);
+ LTTNG_ASSERT(ht);
/* Lookup using the lttng_ust_context_type and a custom match fct. */
cds_lfht_lookup(ht->ht, ht->hash_fct((void *) uctx->ctx, lttng_ht_seed),
unsigned int nb_fd = 0;
struct consumer_socket *socket;
- assert(usess);
- assert(ua_sess);
- assert(ua_chan);
- assert(registry);
+ LTTNG_ASSERT(usess);
+ LTTNG_ASSERT(ua_sess);
+ LTTNG_ASSERT(ua_chan);
+ LTTNG_ASSERT(registry);
rcu_read_lock();
health_code_update();
{
int ret;
- assert(reg_stream);
- assert(stream);
+ LTTNG_ASSERT(reg_stream);
+ LTTNG_ASSERT(stream);
- /* Reserve the amount of file descriptor we need. */
+ /* Duplicating a stream requires 2 new fds. Reserve them. */
ret = lttng_fd_get(LTTNG_FD_APPS, 2);
if (ret < 0) {
ERR("Exhausted number of available FD upon duplicate stream");
{
int ret;
- assert(buf_reg_chan);
- assert(ua_chan);
+ LTTNG_ASSERT(buf_reg_chan);
+ LTTNG_ASSERT(ua_chan);
- /* Need two fds for the channel. */
+ /* Duplicating a channel requires 1 new fd. Reserve it. */
ret = lttng_fd_get(LTTNG_FD_APPS, 1);
if (ret < 0) {
ERR("Exhausted number of available FD upon duplicate channel");
int ret = 0;
struct ust_app_stream *stream, *stmp;
- assert(buf_reg_chan);
- assert(ua_chan);
+ LTTNG_ASSERT(buf_reg_chan);
+ LTTNG_ASSERT(ua_chan);
DBG2("UST app setup buffer registry stream");
int ret;
struct buffer_reg_channel *buf_reg_chan = NULL;
- assert(reg_sess);
- assert(ua_chan);
+ LTTNG_ASSERT(reg_sess);
+ LTTNG_ASSERT(ua_chan);
DBG2("UST app creating buffer registry channel for %s", ua_chan->name);
if (ret < 0) {
goto error_create;
}
- assert(buf_reg_chan);
+ LTTNG_ASSERT(buf_reg_chan);
buf_reg_chan->consumer_key = ua_chan->key;
buf_reg_chan->subbuf_size = ua_chan->attr.subbuf_size;
buf_reg_chan->num_subbuf = ua_chan->attr.num_subbuf;
{
int ret;
- assert(reg_sess);
- assert(buf_reg_chan);
- assert(ua_chan);
- assert(ua_chan->obj);
+ LTTNG_ASSERT(reg_sess);
+ LTTNG_ASSERT(buf_reg_chan);
+ LTTNG_ASSERT(ua_chan);
+ LTTNG_ASSERT(ua_chan->obj);
DBG2("UST app setup buffer registry channel for %s", ua_chan->name);
int ret;
struct buffer_reg_stream *reg_stream;
- assert(buf_reg_chan);
- assert(app);
- assert(ua_sess);
- assert(ua_chan);
+ LTTNG_ASSERT(buf_reg_chan);
+ LTTNG_ASSERT(app);
+ LTTNG_ASSERT(ua_sess);
+ LTTNG_ASSERT(ua_chan);
DBG("UST app sending buffer registry channel to ust sock %d", app->sock);
if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
ret = -ENOTCONN; /* Caused by app exiting. */
goto error;
+ } else if (ret == -EAGAIN) {
+ /* Caused by timeout. */
+ WARN("Communication with application %d timed out on send_channel for channel \"%s\" of session \"%" PRIu64 "\".",
+ app->pid, ua_chan->name, ua_sess->tracing_id);
+ /* Treat this the same way as an application that is exiting. */
+ ret = -ENOTCONN;
+ goto error;
} else if (ret < 0) {
goto error;
}
ret = ust_consumer_send_stream_to_ust(app, ua_chan, &stream);
if (ret < 0) {
- (void) release_ust_app_stream(-1, &stream, app);
if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
ret = -ENOTCONN; /* Caused by app exiting. */
+ } else if (ret == -EAGAIN) {
+ /*
+ * Caused by timeout.
+ * Treat this the same way as an application
+ * that is exiting.
+ */
+ WARN("Communication with application %d timed out on send_stream for stream \"%s\" of channel \"%s\" of session \"%" PRIu64 "\".",
+ app->pid, stream.name,
+ ua_chan->name,
+ ua_sess->tracing_id);
+ ret = -ENOTCONN;
}
+ (void) release_ust_app_stream(-1, &stream, app);
goto error_stream_unlock;
}
enum lttng_error_code notification_ret;
struct ust_registry_channel *ust_reg_chan;
- assert(app);
- assert(usess);
- assert(ua_sess);
- assert(ua_chan);
+ LTTNG_ASSERT(app);
+ LTTNG_ASSERT(usess);
+ LTTNG_ASSERT(ua_sess);
+ LTTNG_ASSERT(ua_chan);
DBG("UST app creating channel %s with per UID buffers", ua_chan->name);
* object. If none can be find, there is a code flow problem or a
* teardown race.
*/
- assert(reg_uid);
+ LTTNG_ASSERT(reg_uid);
buf_reg_chan = buffer_reg_channel_find(ua_chan->tracing_channel_id,
reg_uid);
}
session = session_find_by_id(ua_sess->tracing_id);
- assert(session);
- assert(pthread_mutex_trylock(&session->lock));
- assert(session_trylock_list());
+ LTTNG_ASSERT(session);
+ LTTNG_ASSERT(pthread_mutex_trylock(&session->lock));
+ LTTNG_ASSERT(session_trylock_list());
/*
* Create the buffers on the consumer side. This call populates the
pthread_mutex_lock(®_uid->registry->reg.ust->lock);
ust_reg_chan = ust_registry_channel_find(reg_uid->registry->reg.ust,
ua_chan->tracing_channel_id);
- assert(ust_reg_chan);
+ LTTNG_ASSERT(ust_reg_chan);
ust_reg_chan->consumer_key = ua_chan->key;
ust_reg_chan = NULL;
pthread_mutex_unlock(®_uid->registry->reg.ust->lock);
uint64_t chan_reg_key;
struct ust_registry_channel *ust_reg_chan;
- assert(app);
- assert(usess);
- assert(ua_sess);
- assert(ua_chan);
+ LTTNG_ASSERT(app);
+ LTTNG_ASSERT(usess);
+ LTTNG_ASSERT(ua_sess);
+ LTTNG_ASSERT(ua_chan);
DBG("UST app creating channel %s with per PID buffers", ua_chan->name);
registry = get_session_registry(ua_sess);
/* The UST app session lock is held, registry shall not be null. */
- assert(registry);
+ LTTNG_ASSERT(registry);
/* Create and add a new channel registry to session. */
ret = ust_registry_channel_add(registry, ua_chan->key);
}
session = session_find_by_id(ua_sess->tracing_id);
- assert(session);
+ LTTNG_ASSERT(session);
- assert(pthread_mutex_trylock(&session->lock));
- assert(session_trylock_list());
+ LTTNG_ASSERT(pthread_mutex_trylock(&session->lock));
+ LTTNG_ASSERT(session_trylock_list());
/* Create and get channel on the consumer side. */
ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
chan_reg_key = ua_chan->key;
pthread_mutex_lock(®istry->lock);
ust_reg_chan = ust_registry_channel_find(registry, chan_reg_key);
- assert(ust_reg_chan);
+ LTTNG_ASSERT(ust_reg_chan);
ust_reg_chan->consumer_key = ua_chan->key;
pthread_mutex_unlock(®istry->lock);
{
int ret;
- assert(app);
- assert(usess);
- assert(usess->active);
- assert(ua_sess);
- assert(ua_chan);
+ LTTNG_ASSERT(app);
+ LTTNG_ASSERT(usess);
+ LTTNG_ASSERT(usess->active);
+ LTTNG_ASSERT(ua_sess);
+ LTTNG_ASSERT(ua_chan);
/* Handle buffer type before sending the channel to the application. */
switch (usess->buffer_type) {
break;
}
default:
- assert(0);
+ abort();
ret = -EINVAL;
goto error;
}
add_unique_ust_app_event(ua_chan, ua_event);
- DBG2("UST app create event completed: app = '%s' (ppid: %d)",
- app->name, app->ppid);
+ DBG2("UST app create event completed: app = '%s' pid = %d",
+ app->name, app->pid);
end:
return ret;
lttng_ht_add_unique_u64(app->token_to_event_notifier_rule_ht,
&ua_event_notifier_rule->node);
- DBG2("UST app create token event rule completed: app = '%s' (ppid: %d), token = %" PRIu64,
- app->name, app->ppid, lttng_trigger_get_tracer_token(trigger));
+ DBG2("UST app create token event rule completed: app = '%s', pid = %d), token = %" PRIu64,
+ app->name, app->pid, lttng_trigger_get_tracer_token(trigger));
goto end;
struct ust_registry_session *registry;
struct ltt_session *session = NULL;
- assert(ua_sess);
- assert(app);
- assert(consumer);
+ LTTNG_ASSERT(ua_sess);
+ LTTNG_ASSERT(app);
+ LTTNG_ASSERT(consumer);
registry = get_session_registry(ua_sess);
/* The UST app session is held registry shall not be null. */
- assert(registry);
+ LTTNG_ASSERT(registry);
pthread_mutex_lock(®istry->lock);
registry->metadata_key = metadata->key;
session = session_find_by_id(ua_sess->tracing_id);
- assert(session);
+ LTTNG_ASSERT(session);
- assert(pthread_mutex_trylock(&session->lock));
- assert(session_trylock_list());
+ LTTNG_ASSERT(pthread_mutex_trylock(&session->lock));
+ LTTNG_ASSERT(session_trylock_list());
/*
* Ask the metadata channel creation to the consumer. The metadata object
struct ust_app *lta = NULL;
struct lttng_pipe *event_notifier_event_source_pipe = NULL;
- assert(msg);
- assert(sock >= 0);
+ LTTNG_ASSERT(msg);
+ LTTNG_ASSERT(sock >= 0);
DBG3("UST app creating application for socket %d", sock);
*/
ret = lttng_fd_get(LTTNG_FD_APPS, 2);
if (ret) {
- ERR("Failed to reserve two file descriptors for the event source pipe while creating a new application instance: app = '%s' (ppid: %d)",
- msg->name, (int) msg->ppid);
+ ERR("Failed to reserve two file descriptors for the event source pipe while creating a new application instance: app = '%s', pid = %d",
+ msg->name, (int) msg->pid);
goto error;
}
event_notifier_event_source_pipe = lttng_pipe_open(FD_CLOEXEC);
if (!event_notifier_event_source_pipe) {
- PERROR("Failed to open application event source pipe: '%s' (ppid = %d)",
- msg->name, msg->ppid);
+ PERROR("Failed to open application event source pipe: '%s' (pid = %d)",
+ msg->name, msg->pid);
goto error;
}
*/
void ust_app_add(struct ust_app *app)
{
- assert(app);
- assert(app->notify_sock >= 0);
+ LTTNG_ASSERT(app);
+ LTTNG_ASSERT(app->notify_sock >= 0);
app->registration_time = time(NULL);
lttng_ht_node_init_ulong(&app->notify_sock_n, app->notify_sock);
lttng_ht_add_unique_ulong(ust_app_ht_by_notify_sock, &app->notify_sock_n);
- DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s "
- "notify_sock:%d (version %d.%d)", app->pid, app->ppid, app->uid,
+ DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock =%d name:%s "
+ "notify_sock =%d (version %d.%d)", app->pid, app->ppid, app->uid,
app->gid, app->sock, app->name, app->notify_sock, app->v_major,
app->v_minor);
{
int ret;
- assert(app);
+ LTTNG_ASSERT(app);
pthread_mutex_lock(&app->sock_lock);
ret = lttng_ust_ctl_tracer_version(app->sock, &app->version);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
- if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
- ERR("UST app %d version failed with ret %d", app->sock, ret);
+ if (ret == -LTTNG_UST_ERR_EXITING || ret == -EPIPE) {
+ DBG3("UST app version failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app version failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
} else {
- DBG3("UST app %d version failed. Application is dead", app->sock);
+ ERR("UST app version failed with ret %d: pid = %d, sock = %d",
+ ret, app->pid, app->sock);
}
}
enum lttng_error_code lttng_ret;
enum event_notifier_error_accounting_status event_notifier_error_accounting_status;
- assert(app);
+ LTTNG_ASSERT(app);
if (!ust_app_supports_notifiers(app)) {
ret = -ENOSYS;
event_pipe_write_fd, &event_notifier_group);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
- if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
- ERR("Failed to create application event notifier group: ret = %d, app socket fd = %d, event_pipe_write_fd = %d",
- ret, app->sock, event_pipe_write_fd);
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ ret = 0;
+ DBG3("UST app create event notifier group failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ ret = 0;
+ WARN("UST app create event notifier group failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
} else {
- DBG("Failed to create application event notifier group (application is dead): app socket fd = %d",
- app->sock);
+ ERR("UST app create event notifier group failed with ret %d: pid = %d, sock = %d, event_pipe_write_fd: %d",
+ ret, app->pid, app->sock, event_pipe_write_fd);
}
-
goto error;
}
ret = lttng_pipe_write_close(app->event_notifier_group.event_pipe);
if (ret) {
- ERR("Failed to close write end of the application's event source pipe: app = '%s' (ppid = %d)",
- app->name, app->ppid);
+ ERR("Failed to close write end of the application's event source pipe: app = '%s' (pid = %d)",
+ app->name, app->pid);
goto error;
}
case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK:
break;
case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_UNSUPPORTED:
- DBG3("Failed to setup event notifier error accounting (application does not support notifier error accounting): app socket fd = %d, app name = '%s', app ppid = %d",
- app->sock, app->name, (int) app->ppid);
+ DBG3("Failed to setup event notifier error accounting (application does not support notifier error accounting): app socket fd = %d, app name = '%s', app pid = %d",
+ app->sock, app->name, (int) app->pid);
ret = 0;
goto error_accounting;
case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_APP_DEAD:
- DBG3("Failed to setup event notifier error accounting (application is dead): app socket fd = %d, app name = '%s', app ppid = %d",
- app->sock, app->name, (int) app->ppid);
+ DBG3("Failed to setup event notifier error accounting (application is dead): app socket fd = %d, app name = '%s', app pid = %d",
+ app->sock, app->name, (int) app->pid);
ret = 0;
goto error_accounting;
default:
/* Get the node reference for a call_rcu */
lttng_ht_lookup(ust_app_ht_by_sock, (void *)((unsigned long) sock), &ust_app_sock_iter);
node = lttng_ht_iter_get_node_ulong(&ust_app_sock_iter);
- assert(node);
+ LTTNG_ASSERT(node);
lta = caa_container_of(node, struct ust_app, sock_n);
DBG("PID %d unregistering with sock %d", lta->pid, sock);
/* Remove application from PID hash table */
ret = lttng_ht_del(ust_app_ht_by_sock, &ust_app_sock_iter);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
/*
* Remove application from notify hash table. The thread handling the
app->sock, ret);
} else {
DBG3("UST app tp list get failed. Application is dead");
- /*
- * This is normal behavior, an application can die during the
- * creation process. Don't report an error so the execution can
- * continue normally. Continue normal execution.
- */
break;
}
free(tmp_event);
}
ret = lttng_ust_ctl_release_handle(app->sock, handle);
pthread_mutex_unlock(&app->sock_lock);
- if (ret < 0 && ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
- ERR("Error releasing app handle for app %d with ret %d", app->sock, ret);
+ if (ret < 0) {
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("Error releasing app handle. Application died: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ WARN("Error releasing app handle. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("Error releasing app handle with ret %d: pid = %d, sock = %d",
+ ret, app->pid, app->sock);
+ }
}
}
app->sock, ret);
} else {
DBG3("UST app tp list field failed. Application is dead");
- /*
- * This is normal behavior, an application can die during the
- * creation process. Don't report an error so the execution can
- * continue normally. Reset list and count for next app.
- */
break;
}
free(tmp_event);
* Assert that all notifiers are gone as all triggers
* are unregistered prior to this clean-up.
*/
- assert(lttng_ht_get_count(app->token_to_event_notifier_rule_ht) == 0);
+ LTTNG_ASSERT(lttng_ht_get_count(app->token_to_event_notifier_rule_ht) == 0);
ust_app_notify_sock_unregister(app->notify_sock);
}
if (ust_app_ht) {
cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
ret = lttng_ht_del(ust_app_ht, &iter);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
call_rcu(&app->pid_n.head, delete_ust_app_rcu);
}
}
cds_lfht_for_each_entry(ust_app_ht_by_sock->ht, &iter.iter, app,
sock_n.node) {
ret = lttng_ht_del(ust_app_ht_by_sock, &iter);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
}
}
struct ust_app_session *ua_sess;
struct ust_app_channel *ua_chan;
- assert(usess->active);
+ LTTNG_ASSERT(usess->active);
DBG2("UST app disabling channel %s from global domain for session id %" PRIu64,
uchan->name, usess->id);
lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
/* If the session if found for the app, the channel must be there */
- assert(ua_chan_node);
+ LTTNG_ASSERT(ua_chan_node);
ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
/* The channel must not be already disabled */
- assert(ua_chan->enabled == 1);
+ LTTNG_ASSERT(ua_chan->enabled == 1);
/* Disable channel onto application */
ret = disable_ust_app_channel(ua_sess, ua_chan, app);
struct ust_app *app;
struct ust_app_session *ua_sess;
- assert(usess->active);
+ LTTNG_ASSERT(usess->active);
DBG2("UST app enabling channel %s to global domain for session id %" PRIu64,
uchan->name, usess->id);
struct ust_app_channel *ua_chan;
struct ust_app_event *ua_event;
- assert(usess->active);
+ LTTNG_ASSERT(usess->active);
DBG("UST app disabling event %s for all apps in channel "
"%s for session id %" PRIu64,
uevent->attr.name, uchan->name, usess->id);
int ret = 0;
struct ust_app_channel *ua_chan = NULL;
- assert(ua_sess);
+ LTTNG_ASSERT(ua_sess);
ASSERT_LOCKED(ua_sess->lock);
if (!strncmp(uchan->name, DEFAULT_METADATA_NAME,
struct ust_app_channel *ua_chan;
struct ust_app_event *ua_event;
- assert(usess->active);
+ LTTNG_ASSERT(usess->active);
DBG("UST app enabling event %s for all apps for session id %" PRIu64,
uevent->attr.name, usess->id);
struct ust_app_session *ua_sess;
struct ust_app_channel *ua_chan;
- assert(usess->active);
+ LTTNG_ASSERT(usess->active);
DBG("UST app creating event %s for all apps for session id %" PRIu64,
uevent->attr.name, usess->id);
lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
/* If the channel is not found, there is a code flow error */
- assert(ua_chan_node);
+ LTTNG_ASSERT(ua_chan_node);
ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
ret = lttng_ust_ctl_start_session(app->sock, ua_sess->handle);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("Error starting tracing for app pid: %d (ret: %d)",
- app->pid, ret);
- } else {
- DBG("UST app start session failed. Application is dead.");
- /*
- * This is normal behavior, an application can die during the
- * creation process. Don't report an error so the execution can
- * continue normally.
- */
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app start session failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ pthread_mutex_unlock(&ua_sess->lock);
+ goto end;
+ } else if (ret == -EAGAIN) {
+ WARN("UST app start session failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
pthread_mutex_unlock(&ua_sess->lock);
goto end;
+
+ } else {
+ ERR("UST app start session failed with ret %d: pid = %d, sock = %d",
+ ret, app->pid, app->sock);
}
goto error_unlock;
}
pthread_mutex_lock(&app->sock_lock);
ret = lttng_ust_ctl_wait_quiescent(app->sock);
pthread_mutex_unlock(&app->sock_lock);
- if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app wait quiescent failed for app pid %d ret %d",
- app->pid, ret);
+ if (ret < 0) {
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app wait quiescent failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app wait quiescent failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app wait quiescent failed with ret %d: pid %d, sock = %d",
+ ret, app->pid, app->sock);
+ }
}
end:
ret = lttng_ust_ctl_stop_session(app->sock, ua_sess->handle);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("Error stopping tracing for app pid: %d (ret: %d)",
- app->pid, ret);
- } else {
- DBG("UST app stop session failed. Application is dead.");
- /*
- * This is normal behavior, an application can die during the
- * creation process. Don't report an error so the execution can
- * continue normally.
- */
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app stop session failed. Application is dead: pid = %d, sock = %d",
+ app->pid, app->sock);
+ goto end_unlock;
+ } else if (ret == -EAGAIN) {
+ WARN("UST app stop session failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
goto end_unlock;
+
+ } else {
+ ERR("UST app stop session failed with ret %d: pid = %d, sock = %d",
+ ret, app->pid, app->sock);
}
goto error_rcu_unlock;
}
pthread_mutex_lock(&app->sock_lock);
ret = lttng_ust_ctl_wait_quiescent(app->sock);
pthread_mutex_unlock(&app->sock_lock);
- if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app wait quiescent failed for app pid %d ret %d",
- app->pid, ret);
+ if (ret < 0) {
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app wait quiescent failed. Application is dead: pid= %d, sock = %d)",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app wait quiescent failed. Communication time out: pid= %d, sock = %d)",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app wait quiescent failed with ret %d: pid= %d, sock = %d)",
+ ret, app->pid, app->sock);
+ }
}
health_code_update();
registry = get_session_registry(ua_sess);
/* The UST app session is held registry shall not be null. */
- assert(registry);
+ LTTNG_ASSERT(registry);
/* Push metadata for application before freeing the application. */
(void) push_metadata(registry, ua_sess->consumer);
break;
case LTTNG_BUFFER_PER_UID:
default:
- assert(0);
+ abort();
break;
}
}
default:
ret = -1;
- assert(0);
+ abort();
break;
}
break;
case LTTNG_BUFFER_PER_UID:
default:
- assert(0);
+ abort();
ret = -1;
break;
}
}
default:
ret = -1;
- assert(0);
+ abort();
break;
}
pthread_mutex_lock(&app->sock_lock);
ret = lttng_ust_ctl_wait_quiescent(app->sock);
pthread_mutex_unlock(&app->sock_lock);
- if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app wait quiescent failed for app pid %d ret %d",
- app->pid, ret);
+ if (ret < 0) {
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app wait quiescent failed. Application is dead: pid= %d, sock = %d)",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app wait quiescent failed. Communication time out: pid= %d, sock = %d)",
+ app->pid, app->sock);
+ } else {
+ ERR("UST app wait quiescent failed with ret %d: pid= %d, sock = %d)",
+ ret, app->pid, app->sock);
+ }
}
end:
rcu_read_unlock();
goto end;
}
- assert(triggers);
+ LTTNG_ASSERT(triggers);
t_status = lttng_triggers_get_count(triggers, &count);
if (t_status != LTTNG_TRIGGER_STATUS_OK) {
uint64_t token;
trigger = lttng_triggers_borrow_mutable_at_index(triggers, i);
- assert(trigger);
+ LTTNG_ASSERT(trigger);
token = lttng_trigger_get_tracer_token(trigger);
condition = lttng_trigger_get_condition(trigger);
condition_status =
lttng_condition_event_rule_matches_borrow_rule_mutable(
condition, &event_rule);
- assert(condition_status == LTTNG_CONDITION_STATUS_OK);
+ LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
if (lttng_event_rule_get_domain_type(event_rule) == LTTNG_DOMAIN_KERNEL) {
/* Skip kernel related triggers. */
lttng_triggers_get_at_index(
triggers, i);
- assert(trigger);
+ LTTNG_ASSERT(trigger);
notification_thread_token =
lttng_trigger_get_tracer_token(trigger);
*/
ret = lttng_ht_del(app->token_to_event_notifier_rule_ht,
&app_trigger_iter);
- assert(ret == 0);
+ LTTNG_ASSERT(ret == 0);
/* Callee logs errors. */
(void) disable_ust_object(app, event_notifier_rule->obj);
struct cds_lfht_iter uchan_iter;
struct ltt_ust_channel *uchan;
- assert(usess);
- assert(ua_sess);
- assert(app);
+ LTTNG_ASSERT(usess);
+ LTTNG_ASSERT(ua_sess);
+ LTTNG_ASSERT(app);
cds_lfht_for_each_entry(usess->domain_global.channels->ht, &uchan_iter,
uchan, node.node) {
* The application's configuration should only be synchronized for
* active sessions.
*/
- assert(usess->active);
+ LTTNG_ASSERT(usess->active);
ret = find_or_create_ust_app_session(usess, app, &ua_sess, NULL);
if (ret < 0) {
/* Tracer is probably gone or ENOMEM. */
- goto error;
+ if (ua_sess) {
+ destroy_app_session(app, ua_sess);
+ }
+ goto end;
}
- assert(ua_sess);
+ LTTNG_ASSERT(ua_sess);
pthread_mutex_lock(&ua_sess->lock);
if (ua_sess->deleted) {
- pthread_mutex_unlock(&ua_sess->lock);
- goto end;
+ goto deleted_session;
}
rcu_read_lock();
*/
ret = create_ust_app_metadata(ua_sess, app, usess->consumer);
if (ret < 0) {
- goto error_unlock;
+ ERR("Metadata creation failed for app sock %d for session id %" PRIu64,
+ app->sock, usess->id);
}
rcu_read_unlock();
-end:
- pthread_mutex_unlock(&ua_sess->lock);
- /* Everything went well at this point. */
- return;
-
-error_unlock:
- rcu_read_unlock();
+deleted_session:
pthread_mutex_unlock(&ua_sess->lock);
-error:
- if (ua_sess) {
- destroy_app_session(app, ua_sess);
- }
+end:
return;
}
*/
void ust_app_global_update(struct ltt_ust_session *usess, struct ust_app *app)
{
- assert(usess);
- assert(usess->active);
+ LTTNG_ASSERT(usess);
+ LTTNG_ASSERT(usess->active);
DBG2("UST app global update for app sock %d for session id %" PRIu64,
app->sock, usess->id);
*/
void ust_app_global_update_event_notifier_rules(struct ust_app *app)
{
- DBG2("UST application global event notifier rules update: app = '%s' (ppid: %d)",
- app->name, app->ppid);
+ DBG2("UST application global event notifier rules update: app = '%s', pid = %d)",
+ app->name, app->pid);
if (!app->compatible || !ust_app_supports_notifiers(app)) {
return;
}
if (app->event_notifier_group.object == NULL) {
- WARN("UST app global update of event notifiers for app skipped since communication handle is null: app = '%s' (ppid: %d)",
- app->name, app->ppid);
+ WARN("UST app global update of event notifiers for app skipped since communication handle is null: app = '%s' pid = %d)",
+ app->name, app->pid);
return;
}
struct ust_app_session *ua_sess;
struct ust_app *app;
- assert(usess->active);
+ LTTNG_ASSERT(usess->active);
rcu_read_lock();
cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
int ret;
uint32_t pid, ppid, uid, gid;
- assert(msg);
+ LTTNG_ASSERT(msg);
ret = lttng_ust_ctl_recv_reg_msg(sock, &msg->type, &msg->major, &msg->minor,
&pid, &ppid, &uid, &gid,
struct lttng_ht_iter iter;
struct ust_app_session *ua_sess = NULL;
- assert(app);
+ LTTNG_ASSERT(app);
lttng_ht_lookup(app->ust_sessions_objd, (void *)((unsigned long) objd), &iter);
node = lttng_ht_iter_get_node_ulong(&iter);
struct lttng_ht_iter iter;
struct ust_app_channel *ua_chan = NULL;
- assert(app);
+ LTTNG_ASSERT(app);
lttng_ht_lookup(app->ust_objd, (void *)((unsigned long) objd), &iter);
node = lttng_ht_iter_get_node_ulong(&iter);
if (!app) {
DBG("Application socket %d is being torn down. Abort event notify",
sock);
- ret = 0;
+ ret = -1;
goto error_rcu_unlock;
}
goto error_rcu_unlock;
}
- assert(ua_chan->session);
+ LTTNG_ASSERT(ua_chan->session);
ua_sess = ua_chan->session;
/* Get right session registry depending on the session buffer type. */
pthread_mutex_lock(®istry->lock);
ust_reg_chan = ust_registry_channel_find(registry, chan_reg_key);
- assert(ust_reg_chan);
+ LTTNG_ASSERT(ust_reg_chan);
if (!ust_reg_chan->register_done) {
/*
reply:
DBG3("UST app replying to register channel key %" PRIu64
- " with id %u, type: %d, ret: %d", chan_reg_key, chan_id, type,
+ " with id %u, type = %d, ret = %d", chan_reg_key, chan_id, type,
ret_code);
ret = lttng_ust_ctl_reply_register_channel(sock, chan_id, type, ret_code);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app reply channel failed with ret %d", ret);
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app reply channel failed. Application died: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app reply channel failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
} else {
- DBG3("UST app reply channel failed. Application died");
+ ERR("UST app reply channel failed with ret %d: pid = %d, sock = %d",
+ ret, app->pid, app->sock);
}
goto error;
}
if (!app) {
DBG("Application socket %d is being torn down. Abort event notify",
sock);
- ret = 0;
+ ret = -1;
goto error_rcu_unlock;
}
goto error_rcu_unlock;
}
- assert(ua_chan->session);
+ LTTNG_ASSERT(ua_chan->session);
ua_sess = ua_chan->session;
registry = get_session_registry(ua_sess);
*/
ret = lttng_ust_ctl_reply_register_event(sock, event_id, ret_code);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app reply event failed with ret %d", ret);
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app reply event failed. Application died: pid = %d, sock = %d.",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app reply event failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
} else {
- DBG3("UST app reply event failed. Application died");
+ ERR("UST app reply event failed with ret %d: pid = %d, sock = %d",
+ ret, app->pid, app->sock);
}
/*
* No need to wipe the create event since the application socket will
DBG("Application socket %d is being torn down. Aborting enum registration",
sock);
free(entries);
+ ret = -1;
goto error_rcu_unlock;
}
*/
ret = lttng_ust_ctl_reply_register_enum(sock, enum_id, ret_code);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app reply enum failed with ret %d", ret);
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app reply enum failed. Application died: pid = %d, sock = %d",
+ app->pid, app->sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app reply enum failed. Communication time out: pid = %d, sock = %d",
+ app->pid, app->sock);
} else {
- DBG3("UST app reply enum failed. Application died");
+ ERR("UST app reply enum failed with ret %d: pid = %d, sock = %d",
+ ret, app->pid, app->sock);
}
/*
* No need to wipe the create enum since the application socket will
ret = lttng_ust_ctl_recv_notify(sock, &cmd);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app recv notify failed with ret %d", ret);
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app recv notify failed. Application died: sock = %d",
+ sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app recv notify failed. Communication time out: sock = %d",
+ sock);
} else {
- DBG3("UST app recv notify failed. Application died");
+ ERR("UST app recv notify failed with ret %d: sock = %d",
+ ret, sock);
}
goto error;
}
&loglevel_value, &sig, &nr_fields, &fields,
&model_emf_uri);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app recv event failed with ret %d", ret);
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app recv event failed. Application died: sock = %d",
+ sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app recv event failed. Communication time out: sock = %d",
+ sock);
} else {
- DBG3("UST app recv event failed. Application died");
+ ERR("UST app recv event failed with ret %d: sock = %d",
+ ret, sock);
}
goto error;
}
ret = lttng_ust_ctl_recv_register_channel(sock, &sobjd, &cobjd, &nr_fields,
&fields);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app recv channel failed with ret %d", ret);
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app recv channel failed. Application died: sock = %d",
+ sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app recv channel failed. Communication time out: sock = %d",
+ sock);
} else {
- DBG3("UST app recv channel failed. Application died");
+ ERR("UST app recv channel failed with ret %d: sock = %d)",
+ ret, sock);
}
goto error;
}
ret = lttng_ust_ctl_recv_register_enum(sock, &sobjd, name,
&entries, &nr_entries);
if (ret < 0) {
- if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
- ERR("UST app recv enum failed with ret %d", ret);
+ if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
+ DBG3("UST app recv enum failed. Application died: sock = %d",
+ sock);
+ } else if (ret == -EAGAIN) {
+ WARN("UST app recv enum failed. Communication time out: sock = %d",
+ sock);
} else {
- DBG3("UST app recv enum failed. Application died");
+ ERR("UST app recv enum failed with ret %d: sock = %d",
+ ret, sock);
}
goto error;
}
}
default:
/* Should NEVER happen. */
- assert(0);
+ abort();
}
error:
struct ust_app *app;
struct ust_app_notify_sock_obj *obj;
- assert(sock >= 0);
+ LTTNG_ASSERT(sock >= 0);
rcu_read_lock();
struct ust_app *app;
char *trace_path = NULL;
- assert(usess);
- assert(output);
+ LTTNG_ASSERT(usess);
+ LTTNG_ASSERT(output);
rcu_read_lock();
break;
}
default:
- assert(0);
+ abort();
break;
}
struct ust_app *app;
struct lttng_ht_iter iter;
- assert(usess);
+ LTTNG_ASSERT(usess);
switch (usess->buffer_type) {
case LTTNG_BUFFER_PER_UID:
break;
}
default:
- assert(0);
+ abort();
break;
}
lttng_ht_lookup(ua_sess->channels, (void *) uchan->name, &uiter);
ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
/* If the session is found for the app, the channel must be there */
- assert(ua_chan_node);
+ LTTNG_ASSERT(ua_chan_node);
ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
struct ust_app *app;
struct ltt_ust_session *usess = session->ust_session;
- assert(usess);
+ LTTNG_ASSERT(usess);
rcu_read_lock();
break;
}
default:
- assert(0);
+ abort();
break;
}
char *pathname_index;
int fmt_ret;
- assert(usess->current_trace_chunk);
+ LTTNG_ASSERT(usess->current_trace_chunk);
rcu_read_lock();
switch (usess->buffer_type) {
struct ust_app *app;
struct ltt_ust_session *usess = session->ust_session;
- assert(usess);
+ LTTNG_ASSERT(usess);
rcu_read_lock();
break;
}
default:
- assert(0);
+ abort();
break;
}
struct lttng_ht_iter iter;
struct ltt_ust_session *usess = session->ust_session;
- assert(usess);
+ LTTNG_ASSERT(usess);
rcu_read_lock();
projects / lttng-tools.git / blobdiff