0575ab91d5e12c50ed154d5cd74a2e314a66a39e
[lttng-tools.git] / src / bin / lttng-sessiond / context.c
1 /*
2 * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
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 <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13 #include <unistd.h>
14 #include <urcu/list.h>
15
16 #include <common/error.h>
17 #include <common/sessiond-comm/sessiond-comm.h>
18
19 #include "context.h"
20 #include "kernel.h"
21 #include "ust-app.h"
22 #include "trace-ust.h"
23 #include "agent.h"
24
25 /*
26 * Add kernel context to all channel.
27 *
28 * Assumes the ownership of kctx.
29 */
30 static int add_kctx_all_channels(struct ltt_kernel_session *ksession,
31 struct ltt_kernel_context *kctx)
32 {
33 int ret;
34 struct ltt_kernel_channel *kchan;
35
36 assert(ksession);
37 assert(kctx);
38
39 DBG("Adding kernel context to all channels");
40
41 /* Go over all channels */
42 cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) {
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 = NULL;
55 if (ret != 0) {
56 goto error;
57 }
58 }
59
60 ret = LTTNG_OK;
61
62 error:
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 */
72 static int add_kctx_to_channel(struct ltt_kernel_context *kctx,
73 struct ltt_kernel_channel *kchan)
74 {
75 int ret;
76
77 assert(kchan);
78 assert(kctx);
79
80 DBG("Add kernel context to channel '%s'", kchan->channel->name);
81
82 /* Ownership of kctx is transferred to the callee. */
83 ret = kernel_add_channel_context(kchan, kctx);
84 kctx = NULL;
85 if (ret != 0) {
86 goto error;
87 }
88
89 ret = LTTNG_OK;
90
91 error:
92 return ret;
93 }
94
95 /*
96 * Add UST context to channel.
97 */
98 static int add_uctx_to_channel(struct ltt_ust_session *usess,
99 enum lttng_domain_type domain,
100 struct ltt_ust_channel *uchan,
101 const struct lttng_event_context *ctx)
102 {
103 int ret;
104 struct ltt_ust_context *uctx = NULL;
105
106 assert(usess);
107 assert(uchan);
108 assert(ctx);
109
110 /* Check if context is duplicate */
111 cds_list_for_each_entry(uctx, &uchan->ctx_list, list) {
112 if (trace_ust_match_context(uctx, ctx)) {
113 ret = LTTNG_ERR_UST_CONTEXT_EXIST;
114 goto duplicate;
115 }
116 }
117 uctx = NULL;
118
119 switch (domain) {
120 case LTTNG_DOMAIN_JUL:
121 case LTTNG_DOMAIN_LOG4J:
122 {
123 struct agent *agt;
124
125 if (ctx->ctx != LTTNG_EVENT_CONTEXT_APP_CONTEXT) {
126 /* Other contexts are not needed by the agent. */
127 break;
128 }
129 agt = trace_ust_find_agent(usess, domain);
130
131 if (!agt) {
132 agt = agent_create(domain);
133 if (!agt) {
134 ret = -LTTNG_ERR_NOMEM;
135 goto error;
136 }
137 agent_add(agt, usess->agents);
138 }
139 ret = agent_add_context(ctx, agt);
140 if (ret != LTTNG_OK) {
141 goto error;
142 }
143
144 ret = agent_enable_context(ctx, domain);
145 if (ret != LTTNG_OK) {
146 goto error;
147 }
148 break;
149 }
150 case LTTNG_DOMAIN_UST:
151 break;
152 default:
153 assert(0);
154 }
155
156 /* Create ltt UST context */
157 uctx = trace_ust_create_context(ctx);
158 if (uctx == NULL) {
159 ret = LTTNG_ERR_UST_CONTEXT_INVAL;
160 goto error;
161 }
162
163 /* Add ltt UST context node to ltt UST channel */
164 lttng_ht_add_ulong(uchan->ctx, &uctx->node);
165 cds_list_add_tail(&uctx->list, &uchan->ctx_list);
166
167 if (!usess->active) {
168 goto end;
169 }
170
171 ret = ust_app_add_ctx_channel_glb(usess, uchan, uctx);
172 if (ret < 0) {
173 goto error;
174 }
175 end:
176 DBG("Context UST %d added to channel %s", uctx->ctx.ctx, uchan->name);
177
178 return 0;
179
180 error:
181 free(uctx);
182 duplicate:
183 return ret;
184 }
185
186 /*
187 * Add kernel context to tracer.
188 */
189 int context_kernel_add(struct ltt_kernel_session *ksession,
190 const struct lttng_event_context *ctx, char *channel_name)
191 {
192 int ret;
193 struct ltt_kernel_channel *kchan;
194 struct ltt_kernel_context *kctx;
195
196 assert(ksession);
197 assert(ctx);
198 assert(channel_name);
199
200 kctx = trace_kernel_create_context(NULL);
201 if (!kctx) {
202 ret = -LTTNG_ERR_NOMEM;
203 goto error;
204 }
205
206 /* Setup kernel context structure */
207 switch (ctx->ctx) {
208 case LTTNG_EVENT_CONTEXT_PID:
209 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_PID;
210 break;
211 case LTTNG_EVENT_CONTEXT_PROCNAME:
212 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_PROCNAME;
213 break;
214 case LTTNG_EVENT_CONTEXT_PRIO:
215 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_PRIO;
216 break;
217 case LTTNG_EVENT_CONTEXT_NICE:
218 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_NICE;
219 break;
220 case LTTNG_EVENT_CONTEXT_VPID:
221 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_VPID;
222 break;
223 case LTTNG_EVENT_CONTEXT_TID:
224 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_TID;
225 break;
226 case LTTNG_EVENT_CONTEXT_VTID:
227 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_VTID;
228 break;
229 case LTTNG_EVENT_CONTEXT_PPID:
230 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_PPID;
231 break;
232 case LTTNG_EVENT_CONTEXT_VPPID:
233 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_VPPID;
234 break;
235 case LTTNG_EVENT_CONTEXT_HOSTNAME:
236 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_HOSTNAME;
237 break;
238 case LTTNG_EVENT_CONTEXT_PERF_CPU_COUNTER:
239 case LTTNG_EVENT_CONTEXT_PERF_COUNTER:
240 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_PERF_CPU_COUNTER;
241 break;
242 case LTTNG_EVENT_CONTEXT_INTERRUPTIBLE:
243 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_INTERRUPTIBLE;
244 break;
245 case LTTNG_EVENT_CONTEXT_PREEMPTIBLE:
246 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_PREEMPTIBLE;
247 break;
248 case LTTNG_EVENT_CONTEXT_NEED_RESCHEDULE:
249 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_NEED_RESCHEDULE;
250 break;
251 case LTTNG_EVENT_CONTEXT_MIGRATABLE:
252 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_MIGRATABLE;
253 break;
254 case LTTNG_EVENT_CONTEXT_CALLSTACK_KERNEL:
255 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_CALLSTACK_KERNEL;
256 break;
257 case LTTNG_EVENT_CONTEXT_CALLSTACK_USER:
258 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_CALLSTACK_USER;
259 break;
260 case LTTNG_EVENT_CONTEXT_CGROUP_NS:
261 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_CGROUP_NS;
262 break;
263 case LTTNG_EVENT_CONTEXT_IPC_NS:
264 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_IPC_NS;
265 break;
266 case LTTNG_EVENT_CONTEXT_MNT_NS:
267 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_MNT_NS;
268 break;
269 case LTTNG_EVENT_CONTEXT_NET_NS:
270 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_NET_NS;
271 break;
272 case LTTNG_EVENT_CONTEXT_PID_NS:
273 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_PID_NS;
274 break;
275 case LTTNG_EVENT_CONTEXT_USER_NS:
276 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_USER_NS;
277 break;
278 case LTTNG_EVENT_CONTEXT_UTS_NS:
279 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_UTS_NS;
280 break;
281 case LTTNG_EVENT_CONTEXT_UID:
282 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_UID;
283 break;
284 case LTTNG_EVENT_CONTEXT_EUID:
285 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_EUID;
286 break;
287 case LTTNG_EVENT_CONTEXT_SUID:
288 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_SUID;
289 break;
290 case LTTNG_EVENT_CONTEXT_GID:
291 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_GID;
292 break;
293 case LTTNG_EVENT_CONTEXT_EGID:
294 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_EGID;
295 break;
296 case LTTNG_EVENT_CONTEXT_SGID:
297 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_SGID;
298 break;
299 case LTTNG_EVENT_CONTEXT_VUID:
300 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_VUID;
301 break;
302 case LTTNG_EVENT_CONTEXT_VEUID:
303 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_VEUID;
304 break;
305 case LTTNG_EVENT_CONTEXT_VSUID:
306 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_VSUID;
307 break;
308 case LTTNG_EVENT_CONTEXT_VGID:
309 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_VGID;
310 break;
311 case LTTNG_EVENT_CONTEXT_VEGID:
312 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_VEGID;
313 break;
314 case LTTNG_EVENT_CONTEXT_VSGID:
315 kctx->ctx.ctx = LTTNG_KERNEL_CONTEXT_VSGID;
316 break;
317 default:
318 ret = LTTNG_ERR_KERN_CONTEXT_FAIL;
319 goto error;
320 }
321
322 kctx->ctx.u.perf_counter.type = ctx->u.perf_counter.type;
323 kctx->ctx.u.perf_counter.config = ctx->u.perf_counter.config;
324 strncpy(kctx->ctx.u.perf_counter.name, ctx->u.perf_counter.name,
325 LTTNG_SYMBOL_NAME_LEN);
326 kctx->ctx.u.perf_counter.name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
327
328 if (*channel_name == '\0') {
329 ret = add_kctx_all_channels(ksession, kctx);
330 /* Ownership of kctx is transferred to the callee. */
331 kctx = NULL;
332 if (ret != LTTNG_OK) {
333 goto error;
334 }
335 } else {
336 /* Get kernel channel */
337 kchan = trace_kernel_get_channel_by_name(channel_name, ksession);
338 if (kchan == NULL) {
339 ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
340 goto error;
341 }
342
343 ret = add_kctx_to_channel(kctx, kchan);
344 /* Ownership of kctx is transferred to the callee. */
345 kctx = NULL;
346 if (ret != LTTNG_OK) {
347 goto error;
348 }
349 }
350
351 ret = LTTNG_OK;
352
353 error:
354 if (kctx) {
355 trace_kernel_destroy_context(kctx);
356 }
357 return ret;
358 }
359
360 /*
361 * Add UST context to tracer.
362 */
363 int context_ust_add(struct ltt_ust_session *usess,
364 enum lttng_domain_type domain,
365 const struct lttng_event_context *ctx,
366 char *channel_name)
367 {
368 int ret = LTTNG_OK;
369 struct lttng_ht_iter iter;
370 struct lttng_ht *chan_ht;
371 struct ltt_ust_channel *uchan = NULL;
372
373 assert(usess);
374 assert(ctx);
375 assert(channel_name);
376
377 rcu_read_lock();
378
379 chan_ht = usess->domain_global.channels;
380
381 /* Get UST channel if defined */
382 if (channel_name[0] != '\0') {
383 uchan = trace_ust_find_channel_by_name(chan_ht, channel_name);
384 if (uchan == NULL) {
385 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
386 goto error;
387 }
388 }
389
390 if (uchan) {
391 /* Add ctx to channel */
392 ret = add_uctx_to_channel(usess, domain, uchan, ctx);
393 } else {
394 rcu_read_lock();
395 /* Add ctx all events, all channels */
396 cds_lfht_for_each_entry(chan_ht->ht, &iter.iter, uchan, node.node) {
397 ret = add_uctx_to_channel(usess, domain, uchan, ctx);
398 if (ret) {
399 ERR("Failed to add context to channel %s",
400 uchan->name);
401 continue;
402 }
403 }
404 rcu_read_unlock();
405 }
406
407 switch (ret) {
408 case LTTNG_ERR_UST_CONTEXT_EXIST:
409 break;
410 case -ENOMEM:
411 case -LTTNG_ERR_NOMEM:
412 ret = LTTNG_ERR_FATAL;
413 break;
414 case -EINVAL:
415 ret = LTTNG_ERR_UST_CONTEXT_INVAL;
416 break;
417 case -ENOSYS:
418 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
419 break;
420 default:
421 if (ret != 0 && ret != LTTNG_OK) {
422 ret = ret > 0 ? ret : LTTNG_ERR_UNK;
423 } else {
424 ret = LTTNG_OK;
425 }
426 break;
427 }
428
429 error:
430 rcu_read_unlock();
431 return ret;
432 }
This page took 0.058991 seconds and 4 git commands to generate.