lttng: clean-up the printout of snapshot outputs
[lttng-tools.git] / src / bin / lttng / commands / snapshot.c
1 /*
2 * Copyright (C) 2013 - David Goulet <dgoulet@efficios.com>
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License, version 2 only, as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 51
15 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16 */
17
18 #define _LGPL_SOURCE
19 #include <assert.h>
20 #include <inttypes.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 #include <assert.h>
29
30 #include <common/utils.h>
31 #include <common/mi-lttng.h>
32 #include <lttng/snapshot.h>
33
34 #include "../command.h"
35
36 static const char *opt_session_name;
37 static const char *opt_output_name;
38 static const char *opt_data_url;
39 static const char *opt_ctrl_url;
40 static const char *current_session_name;
41 static uint64_t opt_max_size;
42
43 /* Stub for the cmd struct actions. */
44 static int cmd_add_output(int argc, const char **argv);
45 static int cmd_del_output(int argc, const char **argv);
46 static int cmd_list_output(int argc, const char **argv);
47 static int cmd_record(int argc, const char **argv);
48
49 static const char *indent4 = " ";
50
51 #ifdef LTTNG_EMBED_HELP
52 static const char help_msg[] =
53 #include <lttng-snapshot.1.h>
54 ;
55 #endif
56
57 enum {
58 OPT_HELP = 1,
59 OPT_LIST_OPTIONS,
60 OPT_MAX_SIZE,
61 OPT_LIST_COMMANDS,
62 };
63
64 static struct mi_writer *writer;
65
66 static struct poptOption snapshot_opts[] = {
67 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
68 {"help", 'h', POPT_ARG_NONE, 0, OPT_HELP, 0, 0},
69 {"session", 's', POPT_ARG_STRING, &opt_session_name, 0, 0, 0},
70 {"ctrl-url", 'C', POPT_ARG_STRING, &opt_ctrl_url, 0, 0, 0},
71 {"data-url", 'D', POPT_ARG_STRING, &opt_data_url, 0, 0, 0},
72 {"name", 'n', POPT_ARG_STRING, &opt_output_name, 0, 0, 0},
73 {"max-size", 'm', POPT_ARG_STRING, 0, OPT_MAX_SIZE, 0, 0},
74 {"list-options", 0, POPT_ARG_NONE, NULL, OPT_LIST_OPTIONS, NULL, NULL},
75 {"list-commands", 0, POPT_ARG_NONE, NULL, OPT_LIST_COMMANDS},
76 {0, 0, 0, 0, 0, 0, 0}
77 };
78
79 static struct cmd_struct actions[] = {
80 { "add-output", cmd_add_output },
81 { "del-output", cmd_del_output },
82 { "list-output", cmd_list_output },
83 { "record", cmd_record },
84 { NULL, NULL } /* Array closure */
85 };
86
87 /*
88 * Count and return the number of arguments in argv.
89 */
90 static int count_arguments(const char **argv)
91 {
92 int i = 0;
93
94 assert(argv);
95
96 while (argv[i] != NULL) {
97 i++;
98 }
99
100 return i;
101 }
102
103 /*
104 * Create a snapshot output object from arguments using the given URL.
105 *
106 * Return a newly allocated object or NULL on error.
107 */
108 static struct lttng_snapshot_output *create_output_from_args(const char *url)
109 {
110 int ret = 0;
111 struct lttng_snapshot_output *output = NULL;
112
113 output = lttng_snapshot_output_create();
114 if (!output) {
115 goto error_create;
116 }
117
118 if (url) {
119 ret = lttng_snapshot_output_set_ctrl_url(url, output);
120 if (ret < 0) {
121 goto error;
122 }
123 } else if (opt_ctrl_url) {
124 ret = lttng_snapshot_output_set_ctrl_url(opt_ctrl_url, output);
125 if (ret < 0) {
126 goto error;
127 }
128 }
129
130 if (opt_data_url) {
131 ret = lttng_snapshot_output_set_data_url(opt_data_url, output);
132 if (ret < 0) {
133 goto error;
134 }
135 }
136
137 if (opt_max_size) {
138 ret = lttng_snapshot_output_set_size(opt_max_size, output);
139 if (ret < 0) {
140 goto error;
141 }
142 }
143
144 if (opt_output_name) {
145 ret = lttng_snapshot_output_set_name(opt_output_name, output);
146 if (ret < 0) {
147 goto error;
148 }
149 }
150
151 return output;
152
153 error:
154 lttng_snapshot_output_destroy(output);
155 error_create:
156 return NULL;
157 }
158
159 static int list_output(void)
160 {
161 int ret, output_seen = 0;
162 struct lttng_snapshot_output *s_iter;
163 struct lttng_snapshot_output_list *list;
164
165 ret = lttng_snapshot_list_output(current_session_name, &list);
166 if (ret < 0) {
167 goto error;
168 }
169
170 MSG("Snapshot output list for session %s", current_session_name);
171
172 if (lttng_opt_mi) {
173 ret = mi_lttng_snapshot_output_session_name(writer,
174 current_session_name);
175 if (ret) {
176 ret = CMD_ERROR;
177 goto end;
178 }
179 }
180
181 while ((s_iter = lttng_snapshot_output_list_get_next(list)) != NULL) {
182 if (lttng_snapshot_output_get_maxsize(s_iter)) {
183 MSG("%s[%" PRIu32 "] %s: %s (max size: %" PRIu64 " bytes)", indent4,
184 lttng_snapshot_output_get_id(s_iter),
185 lttng_snapshot_output_get_name(s_iter),
186 lttng_snapshot_output_get_ctrl_url(s_iter),
187 lttng_snapshot_output_get_maxsize(s_iter));
188 } else {
189 MSG("%s[%" PRIu32 "] %s: %s", indent4,
190 lttng_snapshot_output_get_id(s_iter),
191 lttng_snapshot_output_get_name(s_iter),
192 lttng_snapshot_output_get_ctrl_url(s_iter));
193 }
194 output_seen = 1;
195 if (lttng_opt_mi) {
196 ret = mi_lttng_snapshot_list_output(writer, s_iter);
197 if (ret) {
198 ret = CMD_ERROR;
199 goto end;
200 }
201 }
202 }
203
204 if (lttng_opt_mi) {
205 /* Close snapshot snapshots element */
206 ret = mi_lttng_writer_close_element(writer);
207 if (ret) {
208 ret = CMD_ERROR;
209 goto end;
210 }
211
212 /* Close snapshot session element */
213 ret = mi_lttng_writer_close_element(writer);
214 if (ret) {
215 ret = CMD_ERROR;
216 }
217 }
218 end:
219 lttng_snapshot_output_list_destroy(list);
220
221 if (!output_seen) {
222 MSG("%sNone", indent4);
223 }
224
225 error:
226 return ret;
227 }
228
229 /*
230 * Delete output by ID.
231 */
232 static int del_output(uint32_t id, const char *name)
233 {
234 int ret;
235 struct lttng_snapshot_output *output = NULL;
236
237 output = lttng_snapshot_output_create();
238 if (!output) {
239 ret = CMD_FATAL;
240 goto error;
241 }
242
243 if (name) {
244 ret = lttng_snapshot_output_set_name(name, output);
245 } else if (id != UINT32_MAX) {
246 ret = lttng_snapshot_output_set_id(id, output);
247 } else {
248 ret = CMD_ERROR;
249 goto error;
250 }
251 if (ret < 0) {
252 ret = CMD_FATAL;
253 goto error;
254 }
255
256 ret = lttng_snapshot_del_output(current_session_name, output);
257 if (ret < 0) {
258 goto error;
259 }
260
261 if (id != UINT32_MAX) {
262 MSG("Snapshot output id %" PRIu32 " successfully deleted for session %s",
263 id, current_session_name);
264 } else {
265 MSG("Snapshot output %s successfully deleted for session %s",
266 name, current_session_name);
267 }
268
269 if (lttng_opt_mi) {
270 ret = mi_lttng_snapshot_del_output(writer, id, name,
271 current_session_name);
272 if (ret) {
273 ret = CMD_ERROR;
274 }
275 }
276
277 error:
278 lttng_snapshot_output_destroy(output);
279 return ret;
280 }
281
282 /*
283 * Add output from the user URL.
284 */
285 static int add_output(const char *url)
286 {
287 int ret;
288 struct lttng_snapshot_output *output = NULL;
289 char name[NAME_MAX];
290 const char *n_ptr;
291
292 if (!url && (!opt_data_url || !opt_ctrl_url)) {
293 ret = CMD_ERROR;
294 goto error;
295 }
296
297 output = create_output_from_args(url);
298 if (!output) {
299 ret = CMD_FATAL;
300 goto error;
301 }
302
303 /* This call, if successful, populates the id of the output object. */
304 ret = lttng_snapshot_add_output(current_session_name, output);
305 if (ret < 0) {
306 goto error;
307 }
308
309 n_ptr = lttng_snapshot_output_get_name(output);
310 if (*n_ptr == '\0') {
311 int pret;
312 pret = snprintf(name, sizeof(name), DEFAULT_SNAPSHOT_NAME "-%" PRIu32,
313 lttng_snapshot_output_get_id(output));
314 if (pret < 0) {
315 PERROR("snprintf add output name");
316 }
317 n_ptr = name;
318 }
319
320 MSG("Snapshot output successfully added for session %s",
321 current_session_name);
322 if (opt_max_size) {
323 MSG(" [%" PRIu32 "] %s: %s (max size: %" PRIu64 " bytes)",
324 lttng_snapshot_output_get_id(output), n_ptr,
325 lttng_snapshot_output_get_ctrl_url(output),
326 lttng_snapshot_output_get_maxsize(output));
327 } else {
328 MSG(" [%" PRIu32 "] %s: %s",
329 lttng_snapshot_output_get_id(output), n_ptr,
330 lttng_snapshot_output_get_ctrl_url(output));
331 }
332 if (lttng_opt_mi) {
333 ret = mi_lttng_snapshot_add_output(writer, current_session_name,
334 n_ptr, output);
335 if (ret) {
336 ret = CMD_ERROR;
337 }
338 }
339 error:
340 lttng_snapshot_output_destroy(output);
341 return ret;
342 }
343
344 static int cmd_add_output(int argc, const char **argv)
345 {
346 int ret;
347
348 if (argc < 2 && (!opt_data_url || !opt_ctrl_url)) {
349 ret = CMD_ERROR;
350 goto end;
351 }
352
353 ret = add_output(argv[1]);
354
355 end:
356 return ret;
357 }
358
359 static int cmd_del_output(int argc, const char **argv)
360 {
361 int ret;
362 char *name;
363 long id;
364
365 if (argc < 2) {
366 ret = CMD_ERROR;
367 goto end;
368 }
369
370 errno = 0;
371 id = strtol(argv[1], &name, 10);
372 if (id == 0 && (errno == 0 || errno == EINVAL)) {
373 ret = del_output(UINT32_MAX, name);
374 } else if (errno == 0 && *name == '\0') {
375 ret = del_output(id, NULL);
376 } else {
377 ERR("Argument %s not recognized", argv[1]);
378 ret = -1;
379 goto end;
380 }
381
382 end:
383 return ret;
384 }
385
386 static int cmd_list_output(int argc, const char **argv)
387 {
388 int ret;
389
390 ret = list_output();
391
392 return ret;
393 }
394
395 /*
396 * Do a snapshot record with the URL if one is given.
397 */
398 static int record(const char *url)
399 {
400 int ret;
401 struct lttng_snapshot_output *output = NULL;
402
403 output = create_output_from_args(url);
404 if (!output) {
405 ret = CMD_FATAL;
406 goto error;
407 }
408
409 ret = lttng_snapshot_record(current_session_name, output, 0);
410 if (ret < 0) {
411 if (ret == -LTTNG_ERR_MAX_SIZE_INVALID) {
412 ERR("Invalid snapshot size. Cannot fit at least one packet per stream.");
413 }
414 goto error;
415 }
416
417 MSG("Snapshot recorded successfully for session %s", current_session_name);
418
419 if (url) {
420 MSG("Snapshot written at: %s", url);
421 } else if (opt_ctrl_url) {
422 MSG("Snapshot written to ctrl: %s, data: %s", opt_ctrl_url,
423 opt_data_url);
424 }
425
426 if (lttng_opt_mi) {
427 ret = mi_lttng_snapshot_record(writer, current_session_name, url,
428 opt_ctrl_url, opt_data_url);
429 if (ret) {
430 ret = CMD_ERROR;
431 }
432 }
433
434 error:
435 lttng_snapshot_output_destroy(output);
436 return ret;
437 }
438
439 static int cmd_record(int argc, const char **argv)
440 {
441 int ret;
442
443 if (argc == 2) {
444 ret = record(argv[1]);
445 } else {
446 ret = record(NULL);
447 }
448
449 return ret;
450 }
451
452 static enum cmd_error_code handle_command(const char **argv)
453 {
454 int mi_ret, i = 0, argc;
455 enum cmd_error_code cmd_ret;
456 struct cmd_struct *cmd;
457
458 if (!argv) {
459 ERR("No action specified for snapshot command.");
460 cmd_ret = CMD_ERROR;
461 goto end;
462 }
463
464 if ((!opt_ctrl_url && opt_data_url) ||
465 (opt_ctrl_url && !opt_data_url)) {
466 ERR("URLs must be specified for both data and control");
467 cmd_ret = CMD_ERROR;
468 goto end;
469 }
470
471 argc = count_arguments(argv);
472 /* popt should have passed NULL if no arguments are present. */
473 assert(argc > 0);
474
475 cmd = &actions[i];
476 while (cmd->func != NULL) {
477 /* Find command */
478 if (strcmp(argv[0], cmd->name) == 0) {
479 int result;
480
481 if (lttng_opt_mi) {
482 /* Action element */
483 mi_ret = mi_lttng_writer_open_element(writer,
484 mi_lttng_element_command_action);
485 if (mi_ret) {
486 cmd_ret = CMD_ERROR;
487 goto end;
488 }
489
490 /* Name of the action */
491 mi_ret = mi_lttng_writer_write_element_string(writer,
492 config_element_name, argv[0]);
493 if (mi_ret) {
494 cmd_ret = CMD_ERROR;
495 goto end;
496 }
497
498 /* Open output element */
499 mi_ret = mi_lttng_writer_open_element(writer,
500 mi_lttng_element_command_output);
501 if (mi_ret) {
502 cmd_ret = CMD_ERROR;
503 goto end;
504 }
505 }
506
507 result = cmd->func(argc, argv);
508 if (result) {
509 switch (-result) {
510 case LTTNG_ERR_SNAPSHOT_NODATA:
511 WARN("%s", lttng_strerror(result));
512
513 /* A warning is fine since the user has no control on
514 * whether or not applications (or the kernel) have
515 * produced any event between the start of the tracing
516 * session and the recording of the snapshot. MI wise
517 * the command is not a success since nothing was
518 * recorded.
519 */
520 cmd_ret = CMD_SUCCESS;
521 break;
522 default:
523 ERR("%s", lttng_strerror(result));
524 cmd_ret = CMD_ERROR;
525 break;
526 }
527 } else {
528 cmd_ret = CMD_SUCCESS;
529 }
530
531
532 if (lttng_opt_mi) {
533 /* Close output and action element */
534 mi_ret = mi_lttng_close_multi_element(writer, 2);
535 if (mi_ret) {
536 cmd_ret = CMD_ERROR;
537 goto end;
538 }
539 }
540 goto end;
541 }
542 i++;
543 cmd = &actions[i];
544 }
545
546 cmd_ret = CMD_UNDEFINED;
547
548 end:
549 return cmd_ret;
550 }
551 /*
552 * The 'snapshot <cmd> <options>' first level command
553 */
554 int cmd_snapshot(int argc, const char **argv)
555 {
556 int opt;
557 int mi_ret;
558 enum cmd_error_code cmd_ret = CMD_SUCCESS;
559 char *session_name = NULL;
560 static poptContext pc;
561
562 pc = poptGetContext(NULL, argc, argv, snapshot_opts, 0);
563 poptReadDefaultConfig(pc, 0);
564
565 /* Mi check */
566 if (lttng_opt_mi) {
567 writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi);
568 if (!writer) {
569 cmd_ret = CMD_ERROR;
570 goto end;
571 }
572
573 /* Open command element */
574 mi_ret = mi_lttng_writer_command_open(writer,
575 mi_lttng_element_command_snapshot);
576 if (mi_ret) {
577 cmd_ret = CMD_ERROR;
578 goto end;
579 }
580
581 /* Open output element */
582 mi_ret = mi_lttng_writer_open_element(writer,
583 mi_lttng_element_command_output);
584 if (mi_ret) {
585 cmd_ret = CMD_ERROR;
586 goto end;
587 }
588 }
589
590 while ((opt = poptGetNextOpt(pc)) != -1) {
591 switch (opt) {
592 case OPT_HELP:
593 {
594 int ret;
595
596 /* SHOW_HELP assigns to ret. */
597 SHOW_HELP();
598 cmd_ret = ret;
599 goto end;
600 }
601 case OPT_LIST_OPTIONS:
602 list_cmd_options(stdout, snapshot_opts);
603 goto end;
604 case OPT_LIST_COMMANDS:
605 list_commands(actions, stdout);
606 goto end;
607 case OPT_MAX_SIZE:
608 {
609 uint64_t val;
610 const char *opt = poptGetOptArg(pc);
611
612 if (utils_parse_size_suffix((char *) opt, &val) < 0) {
613 ERR("Unable to handle max-size value %s", opt);
614 cmd_ret = CMD_ERROR;
615 goto end;
616 }
617
618 opt_max_size = val;
619
620 break;
621 }
622 default:
623 cmd_ret = CMD_UNDEFINED;
624 goto end;
625 }
626 }
627
628 if (!opt_session_name) {
629 session_name = get_session_name();
630 if (session_name == NULL) {
631 cmd_ret = CMD_ERROR;
632 goto end;
633 }
634 current_session_name = session_name;
635 } else {
636 current_session_name = opt_session_name;
637 }
638
639 cmd_ret = handle_command(poptGetArgs(pc));
640
641 if (lttng_opt_mi) {
642 /* Close output element */
643 mi_ret = mi_lttng_writer_close_element(writer);
644 if (mi_ret) {
645 cmd_ret = CMD_ERROR;
646 goto end;
647 }
648
649 /* Success ? */
650 mi_ret = mi_lttng_writer_write_element_bool(writer,
651 mi_lttng_element_command_success,
652 cmd_ret == CMD_SUCCESS);
653 if (mi_ret) {
654 cmd_ret = CMD_ERROR;
655 goto end;
656 }
657
658 /* Command element close */
659 mi_ret = mi_lttng_writer_command_close(writer);
660 if (mi_ret) {
661 cmd_ret = CMD_ERROR;
662 goto end;
663 }
664 }
665
666 end:
667 /* Mi clean-up */
668 if (writer && mi_lttng_writer_destroy(writer)) {
669 cmd_ret = CMD_ERROR;
670 }
671
672 if (!opt_session_name) {
673 free(session_name);
674 }
675
676 poptFreeContext(pc);
677 return cmd_ret;
678 }
This page took 0.075313 seconds and 4 git commands to generate.