X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcontext.c;h=c8c89243823fe47a883e675532252065a75a551f;hb=a0377dfefe40662ba7d68617bce6ff467114136c;hp=a2f022886306ccb55e9c72a4751d896d6c3f9ae2;hpb=df3c77c8dbbd102718f7149b075ba026d70a9e27;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/context.c b/src/bin/lttng-sessiond/context.c index a2f022886..c8c892438 100644 --- a/src/bin/lttng-sessiond/context.c +++ b/src/bin/lttng-sessiond/context.c @@ -1,19 +1,9 @@ /* - * Copyright (C) 2011 - David Goulet - * Copyright (C) 2016 - Jérémie Galarneau + * Copyright (C) 2011 David Goulet + * Copyright (C) 2016 Jérémie Galarneau * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License, version 2 only, - * as published by the Free Software Foundation. + * SPDX-License-Identifier: GPL-2.0-only * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #define _LGPL_SOURCE @@ -43,8 +33,8 @@ static int add_kctx_all_channels(struct ltt_kernel_session *ksession, int ret; struct ltt_kernel_channel *kchan; - assert(ksession); - assert(kctx); + LTTNG_ASSERT(ksession); + LTTNG_ASSERT(kctx); DBG("Adding kernel context to all channels"); @@ -55,6 +45,7 @@ static int add_kctx_all_channels(struct ltt_kernel_session *ksession, kctx_copy = trace_kernel_copy_context(kctx); if (!kctx_copy) { PERROR("zmalloc ltt_kernel_context"); + ret = -LTTNG_ERR_NOMEM; goto error; } @@ -83,8 +74,8 @@ static int add_kctx_to_channel(struct ltt_kernel_context *kctx, { int ret; - assert(kchan); - assert(kctx); + LTTNG_ASSERT(kchan); + LTTNG_ASSERT(kctx); DBG("Add kernel context to channel '%s'", kchan->channel->name); @@ -106,19 +97,20 @@ error: */ static int add_uctx_to_channel(struct ltt_ust_session *usess, enum lttng_domain_type domain, - struct ltt_ust_channel *uchan, struct lttng_event_context *ctx) + struct ltt_ust_channel *uchan, + const struct lttng_event_context *ctx) { int ret; struct ltt_ust_context *uctx = NULL; - assert(usess); - assert(uchan); - assert(ctx); + LTTNG_ASSERT(usess); + LTTNG_ASSERT(uchan); + LTTNG_ASSERT(ctx); /* Check if context is duplicate */ cds_list_for_each_entry(uctx, &uchan->ctx_list, list) { if (trace_ust_match_context(uctx, ctx)) { - ret = -EEXIST; + ret = LTTNG_ERR_UST_CONTEXT_EXIST; goto duplicate; } } @@ -139,7 +131,7 @@ static int add_uctx_to_channel(struct ltt_ust_session *usess, if (!agt) { agt = agent_create(domain); if (!agt) { - ret = LTTNG_ERR_NOMEM; + ret = -LTTNG_ERR_NOMEM; goto error; } agent_add(agt, usess->agents); @@ -158,28 +150,29 @@ static int add_uctx_to_channel(struct ltt_ust_session *usess, case LTTNG_DOMAIN_UST: break; default: - assert(0); + abort(); } /* Create ltt UST context */ uctx = trace_ust_create_context(ctx); if (uctx == NULL) { - ret = -EINVAL; - goto error; - } - - ret = ust_app_add_ctx_channel_glb(usess, uchan, uctx); - if (ret < 0) { + ret = LTTNG_ERR_UST_CONTEXT_INVAL; goto error; } - rcu_read_lock(); - /* Add ltt UST context node to ltt UST channel */ lttng_ht_add_ulong(uchan->ctx, &uctx->node); - rcu_read_unlock(); cds_list_add_tail(&uctx->list, &uchan->ctx_list); + if (!usess->active) { + goto end; + } + + ret = ust_app_add_ctx_channel_glb(usess, uchan, uctx); + if (ret < 0) { + goto error; + } +end: DBG("Context UST %d added to channel %s", uctx->ctx.ctx, uchan->name); return 0; @@ -194,69 +187,135 @@ duplicate: * Add kernel context to tracer. */ int context_kernel_add(struct ltt_kernel_session *ksession, - struct lttng_event_context *ctx, char *channel_name) + const struct lttng_event_context *ctx, char *channel_name) { int ret; struct ltt_kernel_channel *kchan; struct ltt_kernel_context *kctx; - assert(ksession); - assert(ctx); - assert(channel_name); + LTTNG_ASSERT(ksession); + LTTNG_ASSERT(ctx); + LTTNG_ASSERT(channel_name); kctx = trace_kernel_create_context(NULL); if (!kctx) { - ret = LTTNG_ERR_NOMEM; + ret = -LTTNG_ERR_NOMEM; goto error; } /* Setup kernel context structure */ switch (ctx->ctx) { case LTTNG_EVENT_CONTEXT_PID: - kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_PID; + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_PID; break; case LTTNG_EVENT_CONTEXT_PROCNAME: - kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_PROCNAME; + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_PROCNAME; break; case LTTNG_EVENT_CONTEXT_PRIO: - kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_PRIO; + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_PRIO; break; case LTTNG_EVENT_CONTEXT_NICE: - kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_NICE; + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_NICE; break; case LTTNG_EVENT_CONTEXT_VPID: - kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_VPID; + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VPID; break; case LTTNG_EVENT_CONTEXT_TID: - kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_TID; + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_TID; break; case LTTNG_EVENT_CONTEXT_VTID: - kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_VTID; + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VTID; break; case LTTNG_EVENT_CONTEXT_PPID: - kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_PPID; + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_PPID; break; case LTTNG_EVENT_CONTEXT_VPPID: - kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_VPPID; + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VPPID; break; case LTTNG_EVENT_CONTEXT_HOSTNAME: - kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_HOSTNAME; + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_HOSTNAME; break; case LTTNG_EVENT_CONTEXT_PERF_CPU_COUNTER: case LTTNG_EVENT_CONTEXT_PERF_COUNTER: - kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_PERF_CPU_COUNTER; + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_PERF_CPU_COUNTER; break; case LTTNG_EVENT_CONTEXT_INTERRUPTIBLE: - kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_INTERRUPTIBLE; + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_INTERRUPTIBLE; break; case LTTNG_EVENT_CONTEXT_PREEMPTIBLE: - kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_PREEMPTIBLE; + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_PREEMPTIBLE; break; case LTTNG_EVENT_CONTEXT_NEED_RESCHEDULE: - kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_NEED_RESCHEDULE; + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_NEED_RESCHEDULE; break; case LTTNG_EVENT_CONTEXT_MIGRATABLE: - kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_MIGRATABLE; + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_MIGRATABLE; + break; + case LTTNG_EVENT_CONTEXT_CALLSTACK_KERNEL: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_KERNEL; + break; + case LTTNG_EVENT_CONTEXT_CALLSTACK_USER: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_USER; + break; + case LTTNG_EVENT_CONTEXT_CGROUP_NS: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_CGROUP_NS; + break; + case LTTNG_EVENT_CONTEXT_IPC_NS: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_IPC_NS; + break; + case LTTNG_EVENT_CONTEXT_MNT_NS: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_MNT_NS; + break; + case LTTNG_EVENT_CONTEXT_NET_NS: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_NET_NS; + break; + case LTTNG_EVENT_CONTEXT_PID_NS: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_PID_NS; + break; + case LTTNG_EVENT_CONTEXT_TIME_NS: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_TIME_NS; + break; + case LTTNG_EVENT_CONTEXT_USER_NS: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_USER_NS; + break; + case LTTNG_EVENT_CONTEXT_UTS_NS: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_UTS_NS; + break; + case LTTNG_EVENT_CONTEXT_UID: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_UID; + break; + case LTTNG_EVENT_CONTEXT_EUID: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_EUID; + break; + case LTTNG_EVENT_CONTEXT_SUID: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_SUID; + break; + case LTTNG_EVENT_CONTEXT_GID: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_GID; + break; + case LTTNG_EVENT_CONTEXT_EGID: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_EGID; + break; + case LTTNG_EVENT_CONTEXT_SGID: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_SGID; + break; + case LTTNG_EVENT_CONTEXT_VUID: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VUID; + break; + case LTTNG_EVENT_CONTEXT_VEUID: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VEUID; + break; + case LTTNG_EVENT_CONTEXT_VSUID: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VSUID; + break; + case LTTNG_EVENT_CONTEXT_VGID: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VGID; + break; + case LTTNG_EVENT_CONTEXT_VEGID: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VEGID; + break; + case LTTNG_EVENT_CONTEXT_VSGID: + kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VSGID; break; default: ret = LTTNG_ERR_KERN_CONTEXT_FAIL; @@ -305,7 +364,8 @@ error: * Add UST context to tracer. */ int context_ust_add(struct ltt_ust_session *usess, - enum lttng_domain_type domain, struct lttng_event_context *ctx, + enum lttng_domain_type domain, + const struct lttng_event_context *ctx, char *channel_name) { int ret = LTTNG_OK; @@ -313,9 +373,9 @@ int context_ust_add(struct ltt_ust_session *usess, struct lttng_ht *chan_ht; struct ltt_ust_channel *uchan = NULL; - assert(usess); - assert(ctx); - assert(channel_name); + LTTNG_ASSERT(usess); + LTTNG_ASSERT(ctx); + LTTNG_ASSERT(channel_name); rcu_read_lock(); @@ -338,7 +398,7 @@ int context_ust_add(struct ltt_ust_session *usess, /* Add ctx all events, all channels */ cds_lfht_for_each_entry(chan_ht->ht, &iter.iter, uchan, node.node) { ret = add_uctx_to_channel(usess, domain, uchan, ctx); - if (ret < 0) { + if (ret) { ERR("Failed to add context to channel %s", uchan->name); continue; @@ -348,10 +408,10 @@ int context_ust_add(struct ltt_ust_session *usess, } switch (ret) { - case -EEXIST: - ret = LTTNG_ERR_UST_CONTEXT_EXIST; + case LTTNG_ERR_UST_CONTEXT_EXIST: break; case -ENOMEM: + case -LTTNG_ERR_NOMEM: ret = LTTNG_ERR_FATAL; break; case -EINVAL: @@ -361,7 +421,11 @@ int context_ust_add(struct ltt_ust_session *usess, ret = LTTNG_ERR_UNKNOWN_DOMAIN; break; default: - ret = LTTNG_OK; + if (ret != 0 && ret != LTTNG_OK) { + ret = ret > 0 ? ret : LTTNG_ERR_UNK; + } else { + ret = LTTNG_OK; + } break; }