projects / lttng-tools.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Use compiler-agnostic defines to silence warning
[lttng-tools.git] / src / bin / lttng-sessiond / context.cpp
... / ...
CommitLineData
1/*
2 * Copyright (C) 2011 EfficiOS Inc.
3 * Copyright (C) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 *
5 * SPDX-License-Identifier: GPL-2.0-only
6 *
7 */
8
9#define _LGPL_SOURCE
10#include "agent.hpp"
11#include "context.hpp"
12#include "kernel.hpp"
13#include "trace-ust.hpp"
14#include "ust-app.hpp"
15
16#include <common/error.hpp>
17#include <common/sessiond-comm/sessiond-comm.hpp>
18#include <common/urcu.hpp>
19
20#include <stdio.h>
21#include <unistd.h>
22#include <urcu/list.h>
23
24/*
25 * Add kernel context to all channel.
26 *
27 * Assumes the ownership of kctx.
28 */
29static int add_kctx_all_channels(struct ltt_kernel_session *ksession,
30 struct ltt_kernel_context *kctx)
31{
32 int ret;
33
34 LTTNG_ASSERT(ksession);
35 LTTNG_ASSERT(kctx);
36
37 DBG("Adding kernel context to all channels");
38
39 /* Go over all channels */
40 for (auto kchan :
41 lttng::urcu::list_iteration_adapter<ltt_kernel_channel, &ltt_kernel_channel::list>(
42 ksession->channel_list.head)) {
43 struct ltt_kernel_context *kctx_copy;
44
45 kctx_copy = trace_kernel_copy_context(kctx);
46 if (!kctx_copy) {
47 PERROR("zmalloc ltt_kernel_context");
48 ret = -LTTNG_ERR_NOMEM;
49 goto error;
50 }
51
52 /* Ownership of kctx_copy is transferred to the callee. */
53 ret = kernel_add_channel_context(kchan, kctx_copy);
54 kctx_copy = nullptr;
55 if (ret != 0) {
56 goto error;
57 }
58 }
59
60 ret = LTTNG_OK;
61
62error:
63 trace_kernel_destroy_context(kctx);
64 return ret;
65}
66
67/*
68 * Add kernel context to a specific channel.
69 *
70 * Assumes the ownership of kctx.
71 */
72static int add_kctx_to_channel(struct ltt_kernel_context *kctx, struct ltt_kernel_channel *kchan)
73{
74 int ret;
75
76 LTTNG_ASSERT(kchan);
77 LTTNG_ASSERT(kctx);
78
79 DBG("Add kernel context to channel '%s'", kchan->channel->name);
80
81 /* Ownership of kctx is transferred to the callee. */
82 ret = kernel_add_channel_context(kchan, kctx);
83 kctx = nullptr;
84 if (ret != 0) {
85 goto error;
86 }
87
88 ret = LTTNG_OK;
89
90error:
91 return ret;
92}
93
94/*
95 * Add UST context to channel.
96 */
97static int add_uctx_to_channel(struct ltt_ust_session *usess,
98 enum lttng_domain_type domain,
99 struct ltt_ust_channel *uchan,
100 const struct lttng_event_context *ctx)
101{
102 int ret;
103 struct ltt_ust_context *new_uctx = nullptr;
104
105 LTTNG_ASSERT(usess);
106 LTTNG_ASSERT(uchan);
107 LTTNG_ASSERT(ctx);
108
109 /* Check if context is duplicate */
110 for (auto uctx_it :
111 lttng::urcu::list_iteration_adapter<ltt_ust_context, &ltt_ust_context::list>(
112 uchan->ctx_list)) {
113 if (trace_ust_match_context(uctx_it, ctx)) {
114 ret = LTTNG_ERR_UST_CONTEXT_EXIST;
115 goto duplicate;
116 }
117 }
118
119 switch (domain) {
120 case LTTNG_DOMAIN_JUL:
121 case LTTNG_DOMAIN_LOG4J:
122 case LTTNG_DOMAIN_LOG4J2:
123 {
124 struct agent *agt;
125
126 if (ctx->ctx != LTTNG_EVENT_CONTEXT_APP_CONTEXT) {
127 /* Other contexts are not needed by the agent. */
128 break;
129 }
130 agt = trace_ust_find_agent(usess, domain);
131
132 if (!agt) {
133 agt = agent_create(domain);
134 if (!agt) {
135 ret = -LTTNG_ERR_NOMEM;
136 goto error;
137 }
138 agent_add(agt, usess->agents);
139 }
140 ret = agent_add_context(ctx, agt);
141 if (ret != LTTNG_OK) {
142 goto error;
143 }
144
145 ret = agent_enable_context(ctx, domain);
146 if (ret != LTTNG_OK) {
147 goto error;
148 }
149 break;
150 }
151 case LTTNG_DOMAIN_UST:
152 break;
153 default:
154 abort();
155 }
156
157 /* Create ltt UST context */
158 new_uctx = trace_ust_create_context(ctx);
159 if (new_uctx == nullptr) {
160 ret = LTTNG_ERR_UST_CONTEXT_INVAL;
161 goto error;
162 }
163
164 /* Add ltt UST context node to ltt UST channel */
165 lttng_ht_add_ulong(uchan->ctx, &new_uctx->node);
166 cds_list_add_tail(&new_uctx->list, &uchan->ctx_list);
167
168 if (!usess->active) {
169 goto end;
170 }
171
172 ret = ust_app_add_ctx_channel_glb(usess, uchan, new_uctx);
173 if (ret < 0) {
174 goto error;
175 }
176end:
177 DBG("Context UST %d added to channel %s", new_uctx->ctx.ctx, uchan->name);
178
179 return 0;
180
181error:
182 free(new_uctx);
183duplicate:
184 return ret;
185}
186
187/*
188 * Add kernel context to tracer.
189 */
190int context_kernel_add(struct ltt_kernel_session *ksession,
191 const struct lttng_event_context *ctx,
192 const char *channel_name)
193{
194 int ret;
195 struct ltt_kernel_channel *kchan;
196 struct ltt_kernel_context *kctx;
197
198 LTTNG_ASSERT(ksession);
199 LTTNG_ASSERT(ctx);
200 LTTNG_ASSERT(channel_name);
201
202 kctx = trace_kernel_create_context(nullptr);
203 if (!kctx) {
204 ret = -LTTNG_ERR_NOMEM;
205 goto error;
206 }
207
208 /* Setup kernel context structure */
209 switch (ctx->ctx) {
210 case LTTNG_EVENT_CONTEXT_PID:
211 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_PID;
212 break;
213 case LTTNG_EVENT_CONTEXT_PROCNAME:
214 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_PROCNAME;
215 break;
216 case LTTNG_EVENT_CONTEXT_PRIO:
217 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_PRIO;
218 break;
219 case LTTNG_EVENT_CONTEXT_NICE:
220 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_NICE;
221 break;
222 case LTTNG_EVENT_CONTEXT_VPID:
223 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VPID;
224 break;
225 case LTTNG_EVENT_CONTEXT_TID:
226 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_TID;
227 break;
228 case LTTNG_EVENT_CONTEXT_VTID:
229 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VTID;
230 break;
231 case LTTNG_EVENT_CONTEXT_PPID:
232 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_PPID;
233 break;
234 case LTTNG_EVENT_CONTEXT_VPPID:
235 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VPPID;
236 break;
237 case LTTNG_EVENT_CONTEXT_HOSTNAME:
238 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_HOSTNAME;
239 break;
240 case LTTNG_EVENT_CONTEXT_PERF_CPU_COUNTER:
241 case LTTNG_EVENT_CONTEXT_PERF_COUNTER:
242 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_PERF_CPU_COUNTER;
243 break;
244 case LTTNG_EVENT_CONTEXT_INTERRUPTIBLE:
245 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_INTERRUPTIBLE;
246 break;
247 case LTTNG_EVENT_CONTEXT_PREEMPTIBLE:
248 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_PREEMPTIBLE;
249 break;
250 case LTTNG_EVENT_CONTEXT_NEED_RESCHEDULE:
251 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_NEED_RESCHEDULE;
252 break;
253 case LTTNG_EVENT_CONTEXT_MIGRATABLE:
254 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_MIGRATABLE;
255 break;
256 case LTTNG_EVENT_CONTEXT_CALLSTACK_KERNEL:
257 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_KERNEL;
258 break;
259 case LTTNG_EVENT_CONTEXT_CALLSTACK_USER:
260 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_USER;
261 break;
262 case LTTNG_EVENT_CONTEXT_CGROUP_NS:
263 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_CGROUP_NS;
264 break;
265 case LTTNG_EVENT_CONTEXT_IPC_NS:
266 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_IPC_NS;
267 break;
268 case LTTNG_EVENT_CONTEXT_MNT_NS:
269 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_MNT_NS;
270 break;
271 case LTTNG_EVENT_CONTEXT_NET_NS:
272 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_NET_NS;
273 break;
274 case LTTNG_EVENT_CONTEXT_PID_NS:
275 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_PID_NS;
276 break;
277 case LTTNG_EVENT_CONTEXT_TIME_NS:
278 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_TIME_NS;
279 break;
280 case LTTNG_EVENT_CONTEXT_USER_NS:
281 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_USER_NS;
282 break;
283 case LTTNG_EVENT_CONTEXT_UTS_NS:
284 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_UTS_NS;
285 break;
286 case LTTNG_EVENT_CONTEXT_UID:
287 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_UID;
288 break;
289 case LTTNG_EVENT_CONTEXT_EUID:
290 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_EUID;
291 break;
292 case LTTNG_EVENT_CONTEXT_SUID:
293 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_SUID;
294 break;
295 case LTTNG_EVENT_CONTEXT_GID:
296 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_GID;
297 break;
298 case LTTNG_EVENT_CONTEXT_EGID:
299 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_EGID;
300 break;
301 case LTTNG_EVENT_CONTEXT_SGID:
302 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_SGID;
303 break;
304 case LTTNG_EVENT_CONTEXT_VUID:
305 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VUID;
306 break;
307 case LTTNG_EVENT_CONTEXT_VEUID:
308 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VEUID;
309 break;
310 case LTTNG_EVENT_CONTEXT_VSUID:
311 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VSUID;
312 break;
313 case LTTNG_EVENT_CONTEXT_VGID:
314 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VGID;
315 break;
316 case LTTNG_EVENT_CONTEXT_VEGID:
317 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VEGID;
318 break;
319 case LTTNG_EVENT_CONTEXT_VSGID:
320 kctx->ctx.ctx = LTTNG_KERNEL_ABI_CONTEXT_VSGID;
321 break;
322 default:
323 ret = LTTNG_ERR_KERN_CONTEXT_FAIL;
324 goto error;
325 }
326
327 kctx->ctx.u.perf_counter.type = ctx->u.perf_counter.type;
328 kctx->ctx.u.perf_counter.config = ctx->u.perf_counter.config;
329 strncpy(kctx->ctx.u.perf_counter.name, ctx->u.perf_counter.name, LTTNG_SYMBOL_NAME_LEN);
330 kctx->ctx.u.perf_counter.name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
331
332 if (*channel_name == '\0') {
333 ret = add_kctx_all_channels(ksession, kctx);
334 /* Ownership of kctx is transferred to the callee. */
335 kctx = nullptr;
336 if (ret != LTTNG_OK) {
337 goto error;
338 }
339 } else {
340 /* Get kernel channel */
341 kchan = trace_kernel_get_channel_by_name(channel_name, ksession);
342 if (kchan == nullptr) {
343 ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
344 goto error;
345 }
346
347 ret = add_kctx_to_channel(kctx, kchan);
348 /* Ownership of kctx is transferred to the callee. */
349 kctx = nullptr;
350 if (ret != LTTNG_OK) {
351 goto error;
352 }
353 }
354
355 ret = LTTNG_OK;
356
357error:
358 if (kctx) {
359 trace_kernel_destroy_context(kctx);
360 }
361 return ret;
362}
363
364/*
365 * Add UST context to tracer.
366 */
367int context_ust_add(struct ltt_ust_session *usess,
368 enum lttng_domain_type domain,
369 const struct lttng_event_context *ctx,
370 const char *channel_name)
371{
372 int ret = LTTNG_OK;
373 struct lttng_ht *chan_ht;
374 ltt_ust_channel *uchan = nullptr;
375
376 LTTNG_ASSERT(usess);
377 LTTNG_ASSERT(ctx);
378 LTTNG_ASSERT(channel_name);
379
380 const lttng::urcu::read_lock_guard read_lock;
381
382 chan_ht = usess->domain_global.channels;
383
384 /* Get UST channel if defined */
385 if (channel_name[0] != '\0') {
386 uchan = trace_ust_find_channel_by_name(chan_ht, channel_name);
387 if (uchan == nullptr) {
388 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
389 goto error;
390 }
391 }
392
393 if (uchan) {
394 /* Add ctx to channel */
395 ret = add_uctx_to_channel(usess, domain, uchan, ctx);
396 } else {
397 /* Add ctx all events, all channels */
398 for (auto *iterated_uchan :
399 lttng::urcu::lfht_iteration_adapter<ltt_ust_channel,
400 decltype(ltt_ust_channel::node),
401 &ltt_ust_channel::node>(*chan_ht->ht)) {
402 ret = add_uctx_to_channel(usess, domain, iterated_uchan, ctx);
403 if (ret) {
404 ERR("Failed to add context to channel %s", iterated_uchan->name);
405 continue;
406 }
407 }
408 }
409
410 switch (ret) {
411 case LTTNG_ERR_UST_CONTEXT_EXIST:
412 break;
413 case -ENOMEM:
414 case -LTTNG_ERR_NOMEM:
415 ret = LTTNG_ERR_FATAL;
416 break;
417 case -EINVAL:
418 ret = LTTNG_ERR_UST_CONTEXT_INVAL;
419 break;
420 case -ENOSYS:
421 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
422 break;
423 default:
424 if (ret != 0 && ret != LTTNG_OK) {
425 ret = ret > 0 ? ret : LTTNG_ERR_UNK;
426 } else {
427 ret = LTTNG_OK;
428 }
429 break;
430 }
431
432error:
433 return ret;
434}
LTTng 2.0 tools and control repository
This page took 0.033403 seconds and 5 git commands to generate.