projects / lttng-tools.git / blob
? search:


cf3f3efcf36f87464e5c5eb05425e6bcfccbbd8e
[lttng-tools.git] / src / bin / lttng / commands / add_context.c
1 /*
2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License, version 2 only,
6 * as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16 */
17
18 #define _GNU_SOURCE
19 #define _LGPL_SOURCE
20 #include <ctype.h>
21 #include <popt.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <sys/stat.h>
26 #include <sys/types.h>
27 #include <unistd.h>
28
29 #include <urcu/list.h>
30
31 #include <common/mi-lttng.h>
32
33 #include "../command.h"
34
35 #define PRINT_LINE_LEN 80
36
37 static char *opt_channel_name;
38 static char *opt_session_name;
39 static int opt_kernel;
40 static int opt_userspace;
41 static char *opt_type;
42
43 #if 0
44 /* Not implemented yet */
45 static char *opt_cmd_name;
46 static pid_t opt_pid;
47 #endif
48
49 enum {
50 OPT_HELP = 1,
51 OPT_TYPE,
52 OPT_USERSPACE,
53 OPT_LIST_OPTIONS,
54 };
55
56 static struct lttng_handle *handle;
57 static struct mi_writer *writer;
58
59 /*
60 * Taken from the LTTng ABI
61 */
62 enum context_type {
63 CONTEXT_PID = 0,
64 CONTEXT_PERF_COUNTER = 1, /* Backward compat. */
65 CONTEXT_PROCNAME = 2,
66 CONTEXT_PRIO = 3,
67 CONTEXT_NICE = 4,
68 CONTEXT_VPID = 5,
69 CONTEXT_TID = 6,
70 CONTEXT_VTID = 7,
71 CONTEXT_PPID = 8,
72 CONTEXT_VPPID = 9,
73 CONTEXT_PTHREAD_ID = 10,
74 CONTEXT_HOSTNAME = 11,
75 CONTEXT_IP = 12,
76 CONTEXT_PERF_CPU_COUNTER = 13,
77 CONTEXT_PERF_THREAD_COUNTER = 14,
78 };
79
80 /*
81 * Taken from the Perf ABI (all enum perf_*)
82 */
83 enum perf_type {
84 PERF_TYPE_HARDWARE = 0,
85 PERF_TYPE_SOFTWARE = 1,
86 PERF_TYPE_HW_CACHE = 3,
87 };
88
89 enum perf_count_hard {
90 PERF_COUNT_HW_CPU_CYCLES = 0,
91 PERF_COUNT_HW_INSTRUCTIONS = 1,
92 PERF_COUNT_HW_CACHE_REFERENCES = 2,
93 PERF_COUNT_HW_CACHE_MISSES = 3,
94 PERF_COUNT_HW_BRANCH_INSTRUCTIONS = 4,
95 PERF_COUNT_HW_BRANCH_MISSES = 5,
96 PERF_COUNT_HW_BUS_CYCLES = 6,
97 PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 7,
98 PERF_COUNT_HW_STALLED_CYCLES_BACKEND = 8,
99 };
100
101 enum perf_count_soft {
102 PERF_COUNT_SW_CPU_CLOCK = 0,
103 PERF_COUNT_SW_TASK_CLOCK = 1,
104 PERF_COUNT_SW_PAGE_FAULTS = 2,
105 PERF_COUNT_SW_CONTEXT_SWITCHES = 3,
106 PERF_COUNT_SW_CPU_MIGRATIONS = 4,
107 PERF_COUNT_SW_PAGE_FAULTS_MIN = 5,
108 PERF_COUNT_SW_PAGE_FAULTS_MAJ = 6,
109 PERF_COUNT_SW_ALIGNMENT_FAULTS = 7,
110 PERF_COUNT_SW_EMULATION_FAULTS = 8,
111 };
112
113 /*
114 * Generalized hardware cache events:
115 *
116 * { L1-D, L1-I, LLC, ITLB, DTLB, BPU } x
117 * { read, write, prefetch } x
118 * { accesses, misses }
119 */
120 enum perf_hw_cache_id {
121 PERF_COUNT_HW_CACHE_L1D = 0,
122 PERF_COUNT_HW_CACHE_L1I = 1,
123 PERF_COUNT_HW_CACHE_LL = 2,
124 PERF_COUNT_HW_CACHE_DTLB = 3,
125 PERF_COUNT_HW_CACHE_ITLB = 4,
126 PERF_COUNT_HW_CACHE_BPU = 5,
127
128 PERF_COUNT_HW_CACHE_MAX, /* non-ABI */
129 };
130
131 enum perf_hw_cache_op_id {
132 PERF_COUNT_HW_CACHE_OP_READ = 0,
133 PERF_COUNT_HW_CACHE_OP_WRITE = 1,
134 PERF_COUNT_HW_CACHE_OP_PREFETCH = 2,
135
136 PERF_COUNT_HW_CACHE_OP_MAX, /* non-ABI */
137 };
138
139 enum perf_hw_cache_op_result_id {
140 PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0,
141 PERF_COUNT_HW_CACHE_RESULT_MISS = 1,
142
143 PERF_COUNT_HW_CACHE_RESULT_MAX, /* non-ABI */
144 };
145
146 static struct poptOption long_options[] = {
147 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
148 {"help", 'h', POPT_ARG_NONE, 0, OPT_HELP, 0, 0},
149 {"session", 's', POPT_ARG_STRING, &opt_session_name, 0, 0, 0},
150 {"channel", 'c', POPT_ARG_STRING, &opt_channel_name, 0, 0, 0},
151 {"kernel", 'k', POPT_ARG_VAL, &opt_kernel, 1, 0, 0},
152 {"userspace", 'u', POPT_ARG_NONE, 0, OPT_USERSPACE, 0, 0},
153 {"type", 't', POPT_ARG_STRING, &opt_type, OPT_TYPE, 0, 0},
154 {"list-options", 0, POPT_ARG_NONE, NULL, OPT_LIST_OPTIONS, NULL, NULL},
155 {0, 0, 0, 0, 0, 0, 0}
156 };
157
158 /*
159 * Context options
160 */
161 #define PERF_HW(optstr, name, type, hide) \
162 { \
163 optstr, type, hide, \
164 .u.perf = { PERF_TYPE_HARDWARE, PERF_COUNT_HW_##name, },\
165 }
166
167 #define PERF_SW(optstr, name, type, hide) \
168 { \
169 optstr, type, hide, \
170 .u.perf = { PERF_TYPE_SOFTWARE, PERF_COUNT_SW_##name, },\
171 }
172
173 #define _PERF_HW_CACHE(optstr, name, type, op, result, hide) \
174 { \
175 optstr, type, hide, \
176 .u.perf = { \
177 PERF_TYPE_HW_CACHE, \
178 (uint64_t) PERF_COUNT_HW_CACHE_##name \
179 | ((uint64_t) PERF_COUNT_HW_CACHE_OP_##op << 8) \
180 | ((uint64_t) PERF_COUNT_HW_CACHE_RESULT_##result << 16), \
181 }, \
182 }
183
184 #define PERF_HW_CACHE(optstr, name, type, hide) \
185 _PERF_HW_CACHE(optstr "-loads", name, type, \
186 READ, ACCESS, hide), \
187 _PERF_HW_CACHE(optstr "-load-misses", name, type, \
188 READ, MISS, hide), \
189 _PERF_HW_CACHE(optstr "-stores", name, type, \
190 WRITE, ACCESS, hide), \
191 _PERF_HW_CACHE(optstr "-store-misses", name, type, \
192 WRITE, MISS, hide), \
193 _PERF_HW_CACHE(optstr "-prefetches", name, type, \
194 PREFETCH, ACCESS, hide), \
195 _PERF_HW_CACHE(optstr "-prefetch-misses", name, type, \
196 PREFETCH, MISS, hide)
197
198 static
199 const struct ctx_opts {
200 char *symbol;
201 enum context_type ctx_type;
202 int hide_help; /* Hide from --help */
203 union {
204 struct {
205 uint32_t type;
206 uint64_t config;
207 } perf;
208 } u;
209 } ctx_opts[] = {
210 { "pid", CONTEXT_PID },
211 { "procname", CONTEXT_PROCNAME },
212 { "prio", CONTEXT_PRIO },
213 { "nice", CONTEXT_NICE },
214 { "vpid", CONTEXT_VPID },
215 { "tid", CONTEXT_TID },
216 { "pthread_id", CONTEXT_PTHREAD_ID },
217 { "vtid", CONTEXT_VTID },
218 { "ppid", CONTEXT_PPID },
219 { "vppid", CONTEXT_VPPID },
220 { "hostname", CONTEXT_HOSTNAME },
221 { "ip", CONTEXT_IP },
222
223 /* Perf options */
224
225 /* Perf per-CPU counters */
226 PERF_HW("perf:cpu:cpu-cycles", CPU_CYCLES,
227 CONTEXT_PERF_CPU_COUNTER, 0),
228 PERF_HW("perf:cpu:cycles", CPU_CYCLES,
229 CONTEXT_PERF_CPU_COUNTER, 0),
230 PERF_HW("perf:cpu:stalled-cycles-frontend", STALLED_CYCLES_FRONTEND,
231 CONTEXT_PERF_CPU_COUNTER, 0),
232 PERF_HW("perf:cpu:idle-cycles-frontend", STALLED_CYCLES_FRONTEND,
233 CONTEXT_PERF_CPU_COUNTER, 0),
234 PERF_HW("perf:cpu:stalled-cycles-backend", STALLED_CYCLES_BACKEND,
235 CONTEXT_PERF_CPU_COUNTER, 0),
236 PERF_HW("perf:cpu:idle-cycles-backend", STALLED_CYCLES_BACKEND,
237 CONTEXT_PERF_CPU_COUNTER, 0),
238 PERF_HW("perf:cpu:instructions", INSTRUCTIONS,
239 CONTEXT_PERF_CPU_COUNTER, 0),
240 PERF_HW("perf:cpu:cache-references", CACHE_REFERENCES,
241 CONTEXT_PERF_CPU_COUNTER, 0),
242 PERF_HW("perf:cpu:cache-misses", CACHE_MISSES,
243 CONTEXT_PERF_CPU_COUNTER, 0),
244 PERF_HW("perf:cpu:branch-instructions", BRANCH_INSTRUCTIONS,
245 CONTEXT_PERF_CPU_COUNTER, 0),
246 PERF_HW("perf:cpu:branches", BRANCH_INSTRUCTIONS,
247 CONTEXT_PERF_CPU_COUNTER, 0),
248 PERF_HW("perf:cpu:branch-misses", BRANCH_MISSES,
249 CONTEXT_PERF_CPU_COUNTER, 0),
250 PERF_HW("perf:cpu:bus-cycles", BUS_CYCLES,
251 CONTEXT_PERF_CPU_COUNTER, 0),
252
253 PERF_HW_CACHE("perf:cpu:L1-dcache", L1D,
254 CONTEXT_PERF_CPU_COUNTER, 0),
255 PERF_HW_CACHE("perf:cpu:L1-icache", L1I,
256 CONTEXT_PERF_CPU_COUNTER, 0),
257 PERF_HW_CACHE("perf:cpu:LLC", LL,
258 CONTEXT_PERF_CPU_COUNTER, 0),
259 PERF_HW_CACHE("perf:cpu:dTLB", DTLB,
260 CONTEXT_PERF_CPU_COUNTER, 0),
261 _PERF_HW_CACHE("perf:cpu:iTLB-loads", ITLB,
262 CONTEXT_PERF_CPU_COUNTER, READ, ACCESS, 0),
263 _PERF_HW_CACHE("perf:cpu:iTLB-load-misses", ITLB,
264 CONTEXT_PERF_CPU_COUNTER, READ, MISS, 0),
265 _PERF_HW_CACHE("perf:cpu:branch-loads", BPU,
266 CONTEXT_PERF_CPU_COUNTER, READ, ACCESS, 0),
267 _PERF_HW_CACHE("perf:cpu:branch-load-misses", BPU,
268 CONTEXT_PERF_CPU_COUNTER, READ, MISS, 0),
269
270 PERF_SW("perf:cpu:cpu-clock", CPU_CLOCK,
271 CONTEXT_PERF_CPU_COUNTER, 0),
272 PERF_SW("perf:cpu:task-clock", TASK_CLOCK,
273 CONTEXT_PERF_CPU_COUNTER, 0),
274 PERF_SW("perf:cpu:page-fault", PAGE_FAULTS,
275 CONTEXT_PERF_CPU_COUNTER, 0),
276 PERF_SW("perf:cpu:faults", PAGE_FAULTS,
277 CONTEXT_PERF_CPU_COUNTER, 0),
278 PERF_SW("perf:cpu:major-faults", PAGE_FAULTS_MAJ,
279 CONTEXT_PERF_CPU_COUNTER, 0),
280 PERF_SW("perf:cpu:minor-faults", PAGE_FAULTS_MIN,
281 CONTEXT_PERF_CPU_COUNTER, 0),
282 PERF_SW("perf:cpu:context-switches", CONTEXT_SWITCHES,
283 CONTEXT_PERF_CPU_COUNTER, 0),
284 PERF_SW("perf:cpu:cs", CONTEXT_SWITCHES,
285 CONTEXT_PERF_CPU_COUNTER, 0),
286 PERF_SW("perf:cpu:cpu-migrations", CPU_MIGRATIONS,
287 CONTEXT_PERF_CPU_COUNTER, 0),
288 PERF_SW("perf:cpu:migrations", CPU_MIGRATIONS,
289 CONTEXT_PERF_CPU_COUNTER, 0),
290 PERF_SW("perf:cpu:alignment-faults", ALIGNMENT_FAULTS,
291 CONTEXT_PERF_CPU_COUNTER, 0),
292 PERF_SW("perf:cpu:emulation-faults", EMULATION_FAULTS,
293 CONTEXT_PERF_CPU_COUNTER, 0),
294
295 /* Perf per-thread counters */
296 PERF_HW("perf:thread:cpu-cycles", CPU_CYCLES,
297 CONTEXT_PERF_THREAD_COUNTER, 0),
298 PERF_HW("perf:thread:cycles", CPU_CYCLES,
299 CONTEXT_PERF_THREAD_COUNTER, 0),
300 PERF_HW("perf:thread:stalled-cycles-frontend", STALLED_CYCLES_FRONTEND,
301 CONTEXT_PERF_THREAD_COUNTER, 0),
302 PERF_HW("perf:thread:idle-cycles-frontend", STALLED_CYCLES_FRONTEND,
303 CONTEXT_PERF_THREAD_COUNTER, 0),
304 PERF_HW("perf:thread:stalled-cycles-backend", STALLED_CYCLES_BACKEND,
305 CONTEXT_PERF_THREAD_COUNTER, 0),
306 PERF_HW("perf:thread:idle-cycles-backend", STALLED_CYCLES_BACKEND,
307 CONTEXT_PERF_THREAD_COUNTER, 0),
308 PERF_HW("perf:thread:instructions", INSTRUCTIONS,
309 CONTEXT_PERF_THREAD_COUNTER, 0),
310 PERF_HW("perf:thread:cache-references", CACHE_REFERENCES,
311 CONTEXT_PERF_THREAD_COUNTER, 0),
312 PERF_HW("perf:thread:cache-misses", CACHE_MISSES,
313 CONTEXT_PERF_THREAD_COUNTER, 0),
314 PERF_HW("perf:thread:branch-instructions", BRANCH_INSTRUCTIONS,
315 CONTEXT_PERF_THREAD_COUNTER, 0),
316 PERF_HW("perf:thread:branches", BRANCH_INSTRUCTIONS,
317 CONTEXT_PERF_THREAD_COUNTER, 0),
318 PERF_HW("perf:thread:branch-misses", BRANCH_MISSES,
319 CONTEXT_PERF_THREAD_COUNTER, 0),
320 PERF_HW("perf:thread:bus-cycles", BUS_CYCLES,
321 CONTEXT_PERF_THREAD_COUNTER, 0),
322
323 PERF_HW_CACHE("perf:thread:L1-dcache", L1D,
324 CONTEXT_PERF_THREAD_COUNTER, 0),
325 PERF_HW_CACHE("perf:thread:L1-icache", L1I,
326 CONTEXT_PERF_THREAD_COUNTER, 0),
327 PERF_HW_CACHE("perf:thread:LLC", LL,
328 CONTEXT_PERF_THREAD_COUNTER, 0),
329 PERF_HW_CACHE("perf:thread:dTLB", DTLB,
330 CONTEXT_PERF_THREAD_COUNTER, 0),
331 _PERF_HW_CACHE("perf:thread:iTLB-loads", ITLB,
332 CONTEXT_PERF_THREAD_COUNTER, READ, ACCESS, 0),
333 _PERF_HW_CACHE("perf:thread:iTLB-load-misses", ITLB,
334 CONTEXT_PERF_THREAD_COUNTER, READ, MISS, 0),
335 _PERF_HW_CACHE("perf:thread:branch-loads", BPU,
336 CONTEXT_PERF_THREAD_COUNTER, READ, ACCESS, 0),
337 _PERF_HW_CACHE("perf:thread:branch-load-misses", BPU,
338 CONTEXT_PERF_THREAD_COUNTER, READ, MISS, 0),
339
340 PERF_SW("perf:thread:cpu-clock", CPU_CLOCK,
341 CONTEXT_PERF_THREAD_COUNTER, 0),
342 PERF_SW("perf:thread:task-clock", TASK_CLOCK,
343 CONTEXT_PERF_THREAD_COUNTER, 0),
344 PERF_SW("perf:thread:page-fault", PAGE_FAULTS,
345 CONTEXT_PERF_THREAD_COUNTER, 0),
346 PERF_SW("perf:thread:faults", PAGE_FAULTS,
347 CONTEXT_PERF_THREAD_COUNTER, 0),
348 PERF_SW("perf:thread:major-faults", PAGE_FAULTS_MAJ,
349 CONTEXT_PERF_THREAD_COUNTER, 0),
350 PERF_SW("perf:thread:minor-faults", PAGE_FAULTS_MIN,
351 CONTEXT_PERF_THREAD_COUNTER, 0),
352 PERF_SW("perf:thread:context-switches", CONTEXT_SWITCHES,
353 CONTEXT_PERF_THREAD_COUNTER, 0),
354 PERF_SW("perf:thread:cs", CONTEXT_SWITCHES,
355 CONTEXT_PERF_THREAD_COUNTER, 0),
356 PERF_SW("perf:thread:cpu-migrations", CPU_MIGRATIONS,
357 CONTEXT_PERF_THREAD_COUNTER, 0),
358 PERF_SW("perf:thread:migrations", CPU_MIGRATIONS,
359 CONTEXT_PERF_THREAD_COUNTER, 0),
360 PERF_SW("perf:thread:alignment-faults", ALIGNMENT_FAULTS,
361 CONTEXT_PERF_THREAD_COUNTER, 0),
362 PERF_SW("perf:thread:emulation-faults", EMULATION_FAULTS,
363 CONTEXT_PERF_THREAD_COUNTER, 0),
364
365 /*
366 * Perf per-CPU counters, backward compatibilty for names.
367 * Hidden from help listing.
368 */
369 PERF_HW("perf:cpu-cycles", CPU_CYCLES,
370 CONTEXT_PERF_COUNTER, 1),
371 PERF_HW("perf:cycles", CPU_CYCLES,
372 CONTEXT_PERF_COUNTER, 1),
373 PERF_HW("perf:stalled-cycles-frontend", STALLED_CYCLES_FRONTEND,
374 CONTEXT_PERF_COUNTER, 1),
375 PERF_HW("perf:idle-cycles-frontend", STALLED_CYCLES_FRONTEND,
376 CONTEXT_PERF_COUNTER, 1),
377 PERF_HW("perf:stalled-cycles-backend", STALLED_CYCLES_BACKEND,
378 CONTEXT_PERF_COUNTER, 1),
379 PERF_HW("perf:idle-cycles-backend", STALLED_CYCLES_BACKEND,
380 CONTEXT_PERF_COUNTER, 1),
381 PERF_HW("perf:instructions", INSTRUCTIONS,
382 CONTEXT_PERF_COUNTER, 1),
383 PERF_HW("perf:cache-references", CACHE_REFERENCES,
384 CONTEXT_PERF_COUNTER, 1),
385 PERF_HW("perf:cache-misses", CACHE_MISSES,
386 CONTEXT_PERF_COUNTER, 1),
387 PERF_HW("perf:branch-instructions", BRANCH_INSTRUCTIONS,
388 CONTEXT_PERF_COUNTER, 1),
389 PERF_HW("perf:branches", BRANCH_INSTRUCTIONS,
390 CONTEXT_PERF_COUNTER, 1),
391 PERF_HW("perf:branch-misses", BRANCH_MISSES,
392 CONTEXT_PERF_COUNTER, 1),
393 PERF_HW("perf:bus-cycles", BUS_CYCLES,
394 CONTEXT_PERF_COUNTER, 1),
395
396 PERF_HW_CACHE("perf:L1-dcache", L1D,
397 CONTEXT_PERF_COUNTER, 1),
398 PERF_HW_CACHE("perf:L1-icache", L1I,
399 CONTEXT_PERF_COUNTER, 1),
400 PERF_HW_CACHE("perf:LLC", LL,
401 CONTEXT_PERF_COUNTER, 1),
402 PERF_HW_CACHE("perf:dTLB", DTLB,
403 CONTEXT_PERF_COUNTER, 1),
404 _PERF_HW_CACHE("perf:iTLB-loads", ITLB,
405 CONTEXT_PERF_COUNTER, READ, ACCESS, 1),
406 _PERF_HW_CACHE("perf:iTLB-load-misses", ITLB,
407 CONTEXT_PERF_COUNTER, READ, MISS, 1),
408 _PERF_HW_CACHE("perf:branch-loads", BPU,
409 CONTEXT_PERF_COUNTER, READ, ACCESS, 1),
410 _PERF_HW_CACHE("perf:branch-load-misses", BPU,
411 CONTEXT_PERF_COUNTER, READ, MISS, 1),
412
413 PERF_SW("perf:cpu-clock", CPU_CLOCK,
414 CONTEXT_PERF_COUNTER, 1),
415 PERF_SW("perf:task-clock", TASK_CLOCK,
416 CONTEXT_PERF_COUNTER, 1),
417 PERF_SW("perf:page-fault", PAGE_FAULTS,
418 CONTEXT_PERF_COUNTER, 1),
419 PERF_SW("perf:faults", PAGE_FAULTS,
420 CONTEXT_PERF_COUNTER, 1),
421 PERF_SW("perf:major-faults", PAGE_FAULTS_MAJ,
422 CONTEXT_PERF_COUNTER, 1),
423 PERF_SW("perf:minor-faults", PAGE_FAULTS_MIN,
424 CONTEXT_PERF_COUNTER, 1),
425 PERF_SW("perf:context-switches", CONTEXT_SWITCHES,
426 CONTEXT_PERF_COUNTER, 1),
427 PERF_SW("perf:cs", CONTEXT_SWITCHES,
428 CONTEXT_PERF_COUNTER, 1),
429 PERF_SW("perf:cpu-migrations", CPU_MIGRATIONS,
430 CONTEXT_PERF_COUNTER, 1),
431 PERF_SW("perf:migrations", CPU_MIGRATIONS,
432 CONTEXT_PERF_COUNTER, 1),
433 PERF_SW("perf:alignment-faults", ALIGNMENT_FAULTS,
434 CONTEXT_PERF_COUNTER, 1),
435 PERF_SW("perf:emulation-faults", EMULATION_FAULTS,
436 CONTEXT_PERF_COUNTER, 1),
437
438 { NULL, -1 }, /* Closure */
439 };
440
441 #undef PERF_HW_CACHE
442 #undef _PERF_HW_CACHE
443 #undef PERF_SW
444 #undef PERF_HW
445
446 /*
447 * Context type for command line option parsing.
448 */
449 struct ctx_type {
450 const struct ctx_opts *opt;
451 struct cds_list_head list;
452 };
453
454 /*
455 * List of context type. Use to enable multiple context on a single command
456 * line entry.
457 */
458 struct ctx_type_list {
459 struct cds_list_head head;
460 } ctx_type_list = {
461 .head = CDS_LIST_HEAD_INIT(ctx_type_list.head),
462 };
463
464 /*
465 * Pretty print context type.
466 */
467 static void print_ctx_type(FILE *ofp)
468 {
469 const char *indent = " ";
470 int indent_len = strlen(indent);
471 int len, i = 0;
472
473 fprintf(ofp, "%s", indent);
474 len = indent_len;
475 while (ctx_opts[i].symbol != NULL) {
476 if (!ctx_opts[i].hide_help) {
477 if (len > indent_len) {
478 if (len + strlen(ctx_opts[i].symbol) + 2
479 >= PRINT_LINE_LEN) {
480 fprintf(ofp, ",\n");
481 fprintf(ofp, "%s", indent);
482 len = indent_len;
483 } else {
484 len += fprintf(ofp, ", ");
485 }
486 }
487 len += fprintf(ofp, "%s", ctx_opts[i].symbol);
488 }
489 i++;
490 }
491 }
492
493 /*
494 * usage
495 */
496 static void usage(FILE *ofp)
497 {
498 fprintf(ofp, "usage: lttng add-context -t TYPE [-k|-u] [OPTIONS]\n");
499 fprintf(ofp, "\n");
500 fprintf(ofp, "If no channel is given (-c), the context is added to\n");
501 fprintf(ofp, "all channels.\n");
502 fprintf(ofp, "\n");
503 fprintf(ofp, "Otherwise the context is added only to the channel (-c).\n");
504 fprintf(ofp, "\n");
505 fprintf(ofp, "Exactly one domain (-k or -u) must be specified.\n");
506 fprintf(ofp, "\n");
507 fprintf(ofp, "Options:\n");
508 fprintf(ofp, " -h, --help Show this help\n");
509 fprintf(ofp, " --list-options Simple listing of options\n");
510 fprintf(ofp, " -s, --session NAME Apply to session name\n");
511 fprintf(ofp, " -c, --channel NAME Apply to channel\n");
512 fprintf(ofp, " -k, --kernel Apply to the kernel tracer\n");
513 fprintf(ofp, " -u, --userspace Apply to the user-space tracer\n");
514 fprintf(ofp, "\n");
515 fprintf(ofp, "Context:\n");
516 fprintf(ofp, " -t, --type TYPE Context type. You can repeat that option on\n");
517 fprintf(ofp, " the command line to specify multiple contexts at once.\n");
518 fprintf(ofp, " (--kernel preempts --userspace)\n");
519 fprintf(ofp, " TYPE can be one of the strings below:\n");
520 print_ctx_type(ofp);
521 fprintf(ofp, "\n");
522 fprintf(ofp, "Note that the vpid, vppid and vtid context types represent the virtual process id,\n"
523 "virtual parent process id and virtual thread id as seen from the current execution context\n"
524 "as opposed to the pid, ppid and tid which are kernel internal data structures.\n\n");
525 fprintf(ofp, "Example:\n");
526 fprintf(ofp, "This command will add the context information 'prio' and two per-cpu\n"
527 "perf counters (hardware branch misses and cache misses), to all channels\n"
528 "in the trace data output:\n");
529 fprintf(ofp, "# lttng add-context -k -t prio -t perf:cpu:branch-misses -t perf:cpu:cache-misses\n");
530 fprintf(ofp, "\n");
531 }
532
533 /*
534 * Find context numerical value from string.
535 */
536 static int find_ctx_type_idx(const char *opt)
537 {
538 int ret = -1, i = 0;
539
540 while (ctx_opts[i].symbol != NULL) {
541 if (strcmp(opt, ctx_opts[i].symbol) == 0) {
542 ret = i;
543 goto end;
544 }
545 i++;
546 }
547
548 end:
549 return ret;
550 }
551
552 /*
553 * Add context to channel or event.
554 */
555 static int add_context(char *session_name)
556 {
557 int ret = CMD_SUCCESS, warn = 0, success = 0;
558 struct lttng_event_context context;
559 struct lttng_domain dom;
560 struct ctx_type *type;
561 char *ptr;
562
563 memset(&context, 0, sizeof(context));
564 memset(&dom, 0, sizeof(dom));
565
566 if (opt_kernel) {
567 dom.type = LTTNG_DOMAIN_KERNEL;
568 } else if (opt_userspace) {
569 dom.type = LTTNG_DOMAIN_UST;
570 } else {
571 print_missing_domain();
572 ret = CMD_ERROR;
573 goto error;
574 }
575
576 handle = lttng_create_handle(session_name, &dom);
577 if (handle == NULL) {
578 ret = CMD_ERROR;
579 goto error;
580 }
581
582 if (lttng_opt_mi) {
583 /* Open a contexts element */
584 ret = mi_lttng_writer_open_element(writer, config_element_contexts);
585 if (ret) {
586 goto error;
587 }
588 }
589
590 /* Iterate over all the context types given */
591 cds_list_for_each_entry(type, &ctx_type_list.head, list) {
592 context.ctx = (enum lttng_event_context_type) type->opt->ctx_type;
593 switch (context.ctx) {
594 case LTTNG_EVENT_CONTEXT_PERF_COUNTER:
595 case LTTNG_EVENT_CONTEXT_PERF_CPU_COUNTER:
596 case LTTNG_EVENT_CONTEXT_PERF_THREAD_COUNTER:
597 context.u.perf_counter.type = type->opt->u.perf.type;
598 context.u.perf_counter.config = type->opt->u.perf.config;
599 strncpy(context.u.perf_counter.name, type->opt->symbol,
600 LTTNG_SYMBOL_NAME_LEN);
601 context.u.perf_counter.name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
602 /* Replace : and - by _ */
603 while ((ptr = strchr(context.u.perf_counter.name, '-')) != NULL) {
604 *ptr = '_';
605 }
606 while ((ptr = strchr(context.u.perf_counter.name, ':')) != NULL) {
607 *ptr = '_';
608 }
609 break;
610 default:
611 break;
612 }
613 DBG("Adding context...");
614
615 if (lttng_opt_mi) {
616 /* We leave context open the update the success of the command */
617 ret = mi_lttng_context(writer, &context, 1);
618 if (ret) {
619 ret = CMD_ERROR;
620 goto error;
621 }
622 }
623
624 ret = lttng_add_context(handle, &context, NULL, opt_channel_name);
625 if (ret < 0) {
626 ERR("%s: %s", type->opt->symbol, lttng_strerror(ret));
627 warn = 1;
628 success = 0;
629 } else {
630 if (opt_channel_name) {
631 MSG("%s context %s added to channel %s",
632 opt_kernel ? "kernel" : "UST", type->opt->symbol,
633 opt_channel_name);
634 } else {
635 MSG("%s context %s added to all channels",
636 opt_kernel ? "kernel" : "UST", type->opt->symbol)
637 }
638 success = 1;
639 }
640
641 if (lttng_opt_mi) {
642 /* Is the single operation a success ? */
643 ret = mi_lttng_writer_write_element_bool(writer,
644 mi_lttng_element_success, success);
645 if (ret) {
646 ret = CMD_ERROR;
647 goto error;
648 }
649
650 /* Close the context element */
651 ret = mi_lttng_writer_close_element(writer);
652 if (ret) {
653 ret = CMD_ERROR;
654 goto error;
655 }
656 }
657 }
658
659 if (lttng_opt_mi) {
660 /* Close contexts element */
661 ret = mi_lttng_writer_close_element(writer);
662 if (ret) {
663 goto error;
664 }
665 }
666
667 ret = CMD_SUCCESS;
668
669 error:
670 lttng_destroy_handle(handle);
671
672 /*
673 * This means that at least one add_context failed and tells the user to
674 * look on stderr for error(s).
675 */
676 if (!ret && warn) {
677 ret = CMD_WARNING;
678 }
679 return ret;
680 }
681
682 /*
683 * Add context to channel or event.
684 */
685 int cmd_add_context(int argc, const char **argv)
686 {
687 int index, opt, ret = CMD_SUCCESS, command_ret = CMD_SUCCESS;
688 int success = 1;
689 static poptContext pc;
690 struct ctx_type *type, *tmptype;
691 char *session_name = NULL;
692
693 if (argc < 2) {
694 usage(stderr);
695 ret = CMD_ERROR;
696 goto end;
697 }
698
699 pc = poptGetContext(NULL, argc, argv, long_options, 0);
700 poptReadDefaultConfig(pc, 0);
701
702 while ((opt = poptGetNextOpt(pc)) != -1) {
703 switch (opt) {
704 case OPT_HELP:
705 usage(stdout);
706 goto end;
707 case OPT_TYPE:
708 /*
709 * Look up the index of opt_type in ctx_opts[] first, so we don't
710 * have to free(type) on failure.
711 */
712 index = find_ctx_type_idx(opt_type);
713 if (index < 0) {
714 ERR("Unknown context type %s", opt_type);
715 ret = CMD_ERROR;
716 goto end;
717 }
718
719 type = zmalloc(sizeof(struct ctx_type));
720 if (type == NULL) {
721 PERROR("malloc ctx_type");
722 ret = CMD_FATAL;
723 goto end;
724 }
725
726 type->opt = &ctx_opts[index];
727 if (type->opt->symbol == NULL) {
728 ERR("Unknown context type %s", opt_type);
729 free(type);
730 ret = CMD_ERROR;
731 goto end;
732 } else {
733 cds_list_add_tail(&type->list, &ctx_type_list.head);
734 }
735 break;
736 case OPT_USERSPACE:
737 opt_userspace = 1;
738 #if 0
739 opt_cmd_name = poptGetOptArg(pc);
740 #endif
741 break;
742 case OPT_LIST_OPTIONS:
743 list_cmd_options(stdout, long_options);
744 goto end;
745 default:
746 usage(stderr);
747 ret = CMD_UNDEFINED;
748 goto end;
749 }
750 }
751
752 if (!opt_type) {
753 ERR("Missing mandatory -t TYPE");
754 usage(stderr);
755 ret = CMD_ERROR;
756 goto end;
757 }
758
759 if (!opt_session_name) {
760 session_name = get_session_name();
761 if (session_name == NULL) {
762 ret = CMD_ERROR;
763 goto end;
764 }
765 } else {
766 session_name = opt_session_name;
767 }
768
769 /* Mi check */
770 if (lttng_opt_mi) {
771 writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi);
772 if (!writer) {
773 ret = -LTTNG_ERR_NOMEM;
774 goto end;
775 }
776
777 /* Open command element */
778 ret = mi_lttng_writer_command_open(writer,
779 mi_lttng_element_command_add_context);
780 if (ret) {
781 ret = CMD_ERROR;
782 goto end;
783 }
784
785 /* Open output element */
786 ret = mi_lttng_writer_open_element(writer,
787 mi_lttng_element_command_output);
788 if (ret) {
789 ret = CMD_ERROR;
790 goto end;
791 }
792 }
793
794 command_ret = add_context(session_name);
795 if (command_ret) {
796 success = 0;
797 }
798
799 /* Mi closing */
800 if (lttng_opt_mi) {
801 /* Close output element */
802 ret = mi_lttng_writer_close_element(writer);
803 if (ret) {
804 ret = CMD_ERROR;
805 goto end;
806 }
807
808 /* Success ? */
809 ret = mi_lttng_writer_write_element_bool(writer,
810 mi_lttng_element_command_success, success);
811 if (ret) {
812 ret = CMD_ERROR;
813 goto end;
814 }
815
816 /* Command element close */
817 ret = mi_lttng_writer_command_close(writer);
818 if (ret) {
819 ret = CMD_ERROR;
820 goto end;
821 }
822 }
823
824 end:
825 if (!opt_session_name) {
826 free(session_name);
827 }
828
829 /* Mi clean-up */
830 if (writer && mi_lttng_writer_destroy(writer)) {
831 /* Preserve original error code */
832 ret = ret ? ret : LTTNG_ERR_MI_IO_FAIL;
833 }
834
835 /* Cleanup allocated memory */
836 cds_list_for_each_entry_safe(type, tmptype, &ctx_type_list.head, list) {
837 free(type);
838 }
839
840 /* Overwrite ret if an error occurred during add_context() */
841 ret = command_ret ? command_ret : ret;
842
843 poptFreeContext(pc);
844 return ret;
845 }
LTTng 2.0 tools and control repository
This page took 0.04457 seconds and 3 git commands to generate.