2385fd70e8216a8fd6ef7bc0b4817305e3f9a3b7
[lttng-tools.git] / src / bin / lttng / commands / create.cpp
1 /*
2 * Copyright (C) 2011 EfficiOS Inc.
3 * Copyright (C) 2019 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 <ctype.h>
11 #include <popt.h>
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <sys/stat.h>
16 #include <sys/types.h>
17 #include <common/compat/time.h>
18 #include <unistd.h>
19 #include <signal.h>
20 #include <sys/wait.h>
21
22 #include <common/mi-lttng.h>
23
24 #include "../command.h"
25 #include "../utils.h"
26
27 #include <common/defaults.h>
28 #include <common/sessiond-comm/sessiond-comm.h>
29 #include <common/uri.h>
30 #include <common/utils.h>
31 #include <common/path.h>
32 #include <lttng/lttng.h>
33
34 static char *opt_output_path;
35 static char *opt_session_name;
36 static char *opt_url;
37 static char *opt_ctrl_url;
38 static char *opt_data_url;
39 static char *opt_shm_path;
40 static int opt_no_consumer;
41 static int opt_no_output;
42 static int opt_snapshot;
43 static uint32_t opt_live_timer;
44
45 #ifdef LTTNG_EMBED_HELP
46 static const char help_msg[] =
47 #include <lttng-create.1.h>
48 ;
49 #endif
50
51 enum {
52 OPT_HELP = 1,
53 OPT_LIST_OPTIONS,
54 OPT_LIVE_TIMER,
55 };
56
57 enum output_type {
58 OUTPUT_NONE,
59 OUTPUT_LOCAL,
60 OUTPUT_NETWORK,
61 OUTPUT_UNSPECIFIED,
62 };
63
64 static struct mi_writer *writer;
65 static struct poptOption long_options[] = {
66 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
67 {"help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL},
68 {"output", 'o', POPT_ARG_STRING, &opt_output_path, 0, NULL, NULL},
69 {"list-options", 0, POPT_ARG_NONE, NULL, OPT_LIST_OPTIONS, NULL, NULL},
70 {"set-url", 'U', POPT_ARG_STRING, &opt_url, 0, 0, 0},
71 {"ctrl-url", 'C', POPT_ARG_STRING, &opt_ctrl_url, 0, 0, 0},
72 {"data-url", 'D', POPT_ARG_STRING, &opt_data_url, 0, 0, 0},
73 {"no-output", 0, POPT_ARG_VAL, &opt_no_output, 1, 0, 0},
74 {"no-consumer", 0, POPT_ARG_VAL, &opt_no_consumer, 1, 0, 0},
75 {"snapshot", 0, POPT_ARG_VAL, &opt_snapshot, 1, 0, 0},
76 {"live", 0, POPT_ARG_INT | POPT_ARGFLAG_OPTIONAL, 0, OPT_LIVE_TIMER, 0, 0},
77 {"shm-path", 0, POPT_ARG_STRING, &opt_shm_path, 0, 0, 0},
78 {0, 0, 0, 0, 0, 0, 0}
79 };
80
81 /*
82 * Retrieve the created session and mi output it based on provided argument
83 * This is currently a summary of what was pretty printed and is subject to
84 * enhancements.
85 */
86 static int mi_created_session(const char *session_name)
87 {
88 int ret, i, count, found;
89 struct lttng_session *sessions;
90
91 /* session_name should not be null */
92 LTTNG_ASSERT(session_name);
93 LTTNG_ASSERT(writer);
94
95 count = lttng_list_sessions(&sessions);
96 if (count < 0) {
97 ret = count;
98 ERR("%s", lttng_strerror(ret));
99 goto error;
100 }
101
102 if (count == 0) {
103 ERR("Error session creation failed: session %s not found", session_name);
104 ret = -LTTNG_ERR_SESS_NOT_FOUND;
105 goto end;
106 }
107
108 found = 0;
109 for (i = 0; i < count; i++) {
110 if (strncmp(sessions[i].name, session_name, NAME_MAX) == 0) {
111 found = 1;
112 ret = mi_lttng_session(writer, &sessions[i], 0);
113 if (ret) {
114 goto error;
115 }
116 break;
117 }
118 }
119
120 if (!found) {
121 ret = -LTTNG_ERR_SESS_NOT_FOUND;
122 } else {
123 ret = CMD_SUCCESS;
124 }
125
126 error:
127 free(sessions);
128 end:
129 return ret;
130 }
131
132 static
133 struct lttng_session_descriptor *create_session_descriptor(void)
134 {
135 ssize_t uri_count;
136 enum output_type output_type;
137 struct lttng_uri *uris = NULL;
138 struct lttng_session_descriptor *descriptor = NULL;
139 const char *uri_str1 = NULL, *uri_str2 = NULL;
140 char local_output_path[LTTNG_PATH_MAX] = {};
141
142 if (opt_no_output) {
143 output_type = OUTPUT_NONE;
144 } else if (opt_output_path) {
145 char *expanded_output_path;
146 int ret;
147
148 output_type = OUTPUT_LOCAL;
149 expanded_output_path = utils_expand_path(opt_output_path);
150 if (!expanded_output_path) {
151 ERR("Failed to expand output path.");
152 goto end;
153 }
154 ret = lttng_strncpy(local_output_path, expanded_output_path,
155 sizeof(local_output_path));
156 free(expanded_output_path);
157 if (ret) {
158 ERR("Output path exceeds the maximal supported length (%zu bytes)",
159 sizeof(local_output_path));
160 goto end;
161 }
162 } else if (opt_url || opt_ctrl_url) {
163 int ret;
164
165 uri_str1 = opt_ctrl_url ? opt_ctrl_url : opt_url;
166 uri_str2 = opt_data_url;
167
168 uri_count = uri_parse_str_urls(uri_str1, uri_str2, &uris);
169 if (uri_count != 1 && uri_count != 2) {
170 ERR("Unrecognized URL format.");
171 goto end;
172 }
173
174 switch (uri_count) {
175 case 1:
176 output_type = OUTPUT_LOCAL;
177 if (uris[0].dtype != LTTNG_DST_PATH) {
178 ERR("Unrecognized URL format.");
179 goto end;
180 }
181 ret = lttng_strncpy(local_output_path, uris[0].dst.path,
182 sizeof(local_output_path));
183 if (ret) {
184 ERR("Output path exceeds the maximal supported length (%zu bytes)",
185 sizeof(local_output_path));
186 }
187 break;
188 case 2:
189 output_type = OUTPUT_NETWORK;
190 break;
191 default:
192 /* Already checked. */
193 abort();
194 }
195 } else {
196 output_type = OUTPUT_UNSPECIFIED;
197 }
198
199 if (opt_snapshot) {
200 /* Snapshot session. */
201 switch (output_type) {
202 case OUTPUT_UNSPECIFIED:
203 case OUTPUT_LOCAL:
204 descriptor = lttng_session_descriptor_snapshot_local_create(
205 opt_session_name,
206 output_type == OUTPUT_LOCAL ?
207 local_output_path : NULL);
208 break;
209 case OUTPUT_NONE:
210 descriptor = lttng_session_descriptor_snapshot_create(
211 opt_session_name);
212 break;
213 case OUTPUT_NETWORK:
214 descriptor = lttng_session_descriptor_snapshot_network_create(
215 opt_session_name, uri_str1, uri_str2);
216 break;
217 default:
218 abort();
219 }
220 } else if (opt_live_timer) {
221 /* Live session. */
222 if (output_type != OUTPUT_UNSPECIFIED &&
223 output_type != OUTPUT_NETWORK) {
224 ERR("Unsupported output type specified for live session.");
225 goto end;
226 }
227 descriptor = lttng_session_descriptor_live_network_create(
228 opt_session_name, uri_str1, uri_str2,
229 opt_live_timer);
230 } else {
231 /* Regular session. */
232 switch (output_type) {
233 case OUTPUT_UNSPECIFIED:
234 case OUTPUT_LOCAL:
235 descriptor = lttng_session_descriptor_local_create(
236 opt_session_name,
237 output_type == OUTPUT_LOCAL ?
238 local_output_path : NULL);
239 break;
240 case OUTPUT_NONE:
241 descriptor = lttng_session_descriptor_create(
242 opt_session_name);
243 break;
244 case OUTPUT_NETWORK:
245 descriptor = lttng_session_descriptor_network_create(
246 opt_session_name, uri_str1, uri_str2);
247 break;
248 default:
249 abort();
250 }
251 }
252 if (!descriptor) {
253 ERR("Failed to initialize session creation command.");
254 } else {
255 /*
256 * Auto-launch the relay daemon when a live session
257 * is created using default URLs.
258 */
259 if (!opt_url && !opt_ctrl_url && !opt_data_url &&
260 opt_live_timer && !check_relayd()) {
261 int ret;
262 const char *pathname = opt_relayd_path ? :
263 INSTALL_BIN_PATH "/lttng-relayd";
264
265 ret = spawn_relayd(pathname, 0);
266 if (ret < 0) {
267 lttng_session_descriptor_destroy(descriptor);
268 descriptor = NULL;
269 }
270 }
271 }
272 end:
273 free(uris);
274 return descriptor;
275 }
276
277 /*
278 * Create a tracing session.
279 * If no name is specified, a default name is generated.
280 *
281 * Returns one of the CMD_* result constants.
282 */
283 static int create_session(void)
284 {
285 int ret, i;
286 char shm_path[LTTNG_PATH_MAX] = {};
287 struct lttng_session_descriptor *session_descriptor = NULL;
288 enum lttng_session_descriptor_status descriptor_status;
289 enum lttng_error_code ret_code;
290 struct lttng_session *sessions = NULL;
291 const struct lttng_session *created_session = NULL;
292 const char *created_session_name;
293
294 /* Validate options. */
295 if (opt_session_name) {
296 if (strlen(opt_session_name) > NAME_MAX) {
297 ERR("Session name too long. Length must be lower or equal to %d",
298 NAME_MAX);
299 ret = CMD_ERROR;
300 goto error;
301 }
302 /*
303 * Check if the session name begins with "auto-" or is exactly "auto".
304 * Both are reserved for the default session name. See bug #449 to
305 * understand why we need to check both here.
306 */
307 if ((strncmp(opt_session_name, DEFAULT_SESSION_NAME "-",
308 strlen(DEFAULT_SESSION_NAME) + 1) == 0) ||
309 (strncmp(opt_session_name, DEFAULT_SESSION_NAME,
310 strlen(DEFAULT_SESSION_NAME)) == 0 &&
311 strlen(opt_session_name) == strlen(DEFAULT_SESSION_NAME))) {
312 ERR("%s is a reserved keyword for default session(s)",
313 DEFAULT_SESSION_NAME);
314 ret = CMD_ERROR;
315 goto error;
316 }
317 }
318
319 if (opt_snapshot && opt_live_timer) {
320 ERR("Snapshot and live modes are mutually exclusive.");
321 ret = CMD_ERROR;
322 goto error;
323 }
324
325 if ((!opt_ctrl_url && opt_data_url) || (opt_ctrl_url && !opt_data_url)) {
326 ERR("Both control and data URLs must be specified.");
327 ret = CMD_ERROR;
328 goto error;
329 }
330
331 session_descriptor = create_session_descriptor();
332 if (!session_descriptor) {
333 ret = CMD_ERROR;
334 goto error;
335 }
336 ret_code = lttng_create_session_ext(session_descriptor);
337 if (ret_code != LTTNG_OK) {
338 ERR("%s", lttng_strerror(-ret_code));
339 ret = CMD_ERROR;
340 goto error;
341 }
342
343 descriptor_status = lttng_session_descriptor_get_session_name(
344 session_descriptor, &created_session_name);
345 if (descriptor_status != LTTNG_SESSION_DESCRIPTOR_STATUS_OK) {
346 ERR("Failed to obtain created session name");
347 ret = CMD_ERROR;
348 goto error;
349 }
350
351 ret = lttng_list_sessions(&sessions);
352 if (ret < 0) {
353 ERR("Failed to fetch properties of created session: %s",
354 lttng_strerror(ret));
355 ret = CMD_ERROR;
356 goto error;
357 }
358 for (i = 0; i < ret; i++) {
359 if (!strcmp(created_session_name, sessions[i].name)) {
360 created_session = &sessions[i];
361 break;
362 }
363 }
364 if (!created_session) {
365 ERR("Failed to fetch properties of created session");
366 ret = CMD_ERROR;
367 goto error;
368 }
369
370 if (opt_shm_path) {
371 char datetime_suffix[17] = {};
372
373 /*
374 * An auto-generated session name already includes the creation
375 * timestamp.
376 */
377 if (opt_session_name) {
378 uint64_t creation_time;
379 struct tm *timeinfo;
380 time_t creation_time_t;
381 size_t strftime_ret;
382
383 ret_code = lttng_session_get_creation_time(
384 created_session,
385 &creation_time);
386 if (ret_code != LTTNG_OK) {
387 ERR("%s", lttng_strerror(-ret_code));
388 ret = CMD_ERROR;
389 goto error;
390 }
391 creation_time_t = (time_t) creation_time;
392 timeinfo = localtime(&creation_time_t);
393 if (!timeinfo) {
394 PERROR("Failed to interpret session creation time");
395 ret = CMD_ERROR;
396 goto error;
397 }
398 strftime_ret = strftime(datetime_suffix,
399 sizeof(datetime_suffix),
400 "-%Y%m%d-%H%M%S", timeinfo);
401 if (strftime_ret == 0) {
402 ERR("Failed to format session creation time.");
403 ret = CMD_ERROR;
404 goto error;
405 }
406 }
407
408 ret = snprintf(shm_path, sizeof(shm_path),
409 "%s/%s%s", opt_shm_path, created_session_name,
410 datetime_suffix);
411 if (ret < 0 || ret >= sizeof(shm_path)) {
412 ERR("Failed to format the shared memory path.");
413 ret = CMD_ERROR;
414 goto error;
415 }
416 ret = lttng_set_session_shm_path(created_session_name,
417 shm_path);
418 if (ret < 0) {
419 lttng_destroy_session(created_session_name);
420 ret = CMD_ERROR;
421 goto error;
422 }
423 }
424
425 if (opt_snapshot) {
426 MSG("Snapshot session %s created.", created_session_name);
427 } else if (opt_live_timer) {
428 MSG("Live session %s created.", created_session_name);
429 } else {
430 MSG("Session %s created.", created_session_name);
431 }
432
433 if (*created_session->path && !opt_snapshot) {
434 MSG("Traces will be output to %s", created_session->path);
435
436 if (opt_live_timer) {
437 MSG("Live timer interval set to %u %s", opt_live_timer,
438 USEC_UNIT);
439 }
440 } else if (opt_snapshot) {
441 struct lttng_snapshot_output_list *list;
442 struct lttng_snapshot_output *iter;
443 char snapshot_url[LTTNG_PATH_MAX] = {};
444
445 ret = lttng_snapshot_list_output(created_session_name, &list);
446 if (ret < 0) {
447 ERR("Failed to list snapshot outputs.");
448 ret = CMD_ERROR;
449 goto error;
450 }
451
452 while ((iter = lttng_snapshot_output_list_get_next(list))) {
453 const char *url = NULL;
454
455 url = lttng_snapshot_output_get_ctrl_url(
456 iter);
457 ret = lttng_strncpy(snapshot_url, url,
458 sizeof(snapshot_url));
459 if (ret) {
460 snapshot_url[0] = '\0';
461 ERR("Failed to retrieve snapshot output destination");
462 }
463 break;
464 }
465 lttng_snapshot_output_list_destroy(list);
466
467 if (*snapshot_url) {
468 MSG("Default snapshot output set to %s",
469 snapshot_url);
470 }
471 MSG("Every channel enabled for this session will be set to mmap output and default to overwrite mode.");
472 }
473 if (opt_shm_path) {
474 MSG("Shared memory path set to %s", shm_path);
475 }
476
477 /* Mi output */
478 if (lttng_opt_mi) {
479 ret = mi_created_session(created_session_name);
480 if (ret) {
481 ret = CMD_ERROR;
482 goto error;
483 }
484 }
485
486 /* Init lttng session config */
487 ret = config_init(created_session_name);
488 if (ret < 0) {
489 ret = CMD_ERROR;
490 goto error;
491 }
492
493 ret = CMD_SUCCESS;
494 error:
495 lttng_session_descriptor_destroy(session_descriptor);
496 free(sessions);
497 return ret;
498 }
499
500 /*
501 * spawn_sessiond
502 *
503 * Spawn a session daemon by forking and execv.
504 */
505 static int spawn_sessiond(const char *pathname)
506 {
507 int ret = 0;
508 pid_t pid;
509
510 MSG("Spawning a session daemon");
511 pid = fork();
512 if (pid == 0) {
513 /*
514 * Spawn session daemon in daemon mode.
515 */
516 execlp(pathname, "lttng-sessiond",
517 "--daemonize", NULL);
518 /* execlp only returns if error happened */
519 if (errno == ENOENT) {
520 ERR("No session daemon found. Use --sessiond-path.");
521 } else {
522 PERROR("execlp");
523 }
524 kill(getppid(), SIGTERM); /* wake parent */
525 exit(EXIT_FAILURE);
526 } else if (pid > 0) {
527 /*
528 * In daemon mode (--daemonize), sessiond only exits when
529 * it's ready to accept commands.
530 */
531 for (;;) {
532 int status;
533 pid_t wait_pid_ret = waitpid(pid, &status, 0);
534
535 if (wait_pid_ret < 0) {
536 if (errno == EINTR) {
537 continue;
538 }
539 PERROR("waitpid");
540 ret = -errno;
541 goto end;
542 }
543
544 if (WIFSIGNALED(status)) {
545 ERR("Session daemon was killed by signal %d",
546 WTERMSIG(status));
547 ret = -1;
548 goto end;
549 } else if (WIFEXITED(status)) {
550 DBG("Session daemon terminated normally (exit status: %d)",
551 WEXITSTATUS(status));
552
553 if (WEXITSTATUS(status) != 0) {
554 ERR("Session daemon terminated with an error (exit status: %d)",
555 WEXITSTATUS(status));
556 ret = -1;
557 goto end;
558 }
559 break;
560 }
561 }
562
563 goto end;
564 } else {
565 PERROR("fork");
566 ret = -1;
567 goto end;
568 }
569
570 end:
571 return ret;
572 }
573
574 /*
575 * launch_sessiond
576 *
577 * Check if the session daemon is available using
578 * the liblttngctl API for the check. If not, try to
579 * spawn a daemon.
580 */
581 static int launch_sessiond(void)
582 {
583 int ret;
584 const char *pathname = NULL;
585
586 ret = lttng_session_daemon_alive();
587 if (ret) {
588 /* Sessiond is alive, not an error */
589 ret = 0;
590 goto end;
591 }
592
593 /* Try command line option path */
594 pathname = opt_sessiond_path;
595
596 /* Try LTTNG_SESSIOND_PATH env variable */
597 if (pathname == NULL) {
598 pathname = getenv(DEFAULT_SESSIOND_PATH_ENV);
599 }
600
601 /* Try with configured path */
602 if (pathname == NULL) {
603 if (CONFIG_SESSIOND_BIN[0] != '\0') {
604 pathname = CONFIG_SESSIOND_BIN;
605 }
606 }
607
608 /* Try the default path */
609 if (pathname == NULL) {
610 pathname = INSTALL_BIN_PATH "/lttng-sessiond";
611 }
612
613 DBG("Session daemon binary path: %s", pathname);
614
615 /* Check existence and permissions */
616 ret = access(pathname, F_OK | X_OK);
617 if (ret < 0) {
618 ERR("No such file or access denied: %s", pathname);
619 goto end;
620 }
621
622 ret = spawn_sessiond(pathname);
623 end:
624 if (ret) {
625 ERR("Problem occurred while launching session daemon (%s)",
626 pathname);
627 }
628 return ret;
629 }
630
631 static
632 int validate_url_option_combination(void)
633 {
634 int ret = 0;
635 int used_count = 0;
636
637 used_count += !!opt_url;
638 used_count += !!opt_output_path;
639 used_count += (opt_data_url || opt_ctrl_url);
640 if (used_count > 1) {
641 ERR("Only one of the --set-url, --ctrl-url/data-url, or --output options may be used at once.");
642 ret = -1;
643 }
644
645 return ret;
646 }
647
648 /*
649 * The 'create <options>' first level command
650 *
651 * Returns one of the CMD_* result constants.
652 */
653 int cmd_create(int argc, const char **argv)
654 {
655 int opt, ret = CMD_SUCCESS, command_ret = CMD_SUCCESS, success = 1;
656 char *opt_arg = NULL;
657 const char *leftover = NULL;
658 static poptContext pc;
659
660 pc = poptGetContext(NULL, argc, argv, long_options, 0);
661 poptReadDefaultConfig(pc, 0);
662
663 while ((opt = poptGetNextOpt(pc)) != -1) {
664 switch (opt) {
665 case OPT_HELP:
666 SHOW_HELP();
667 goto end;
668 case OPT_LIST_OPTIONS:
669 list_cmd_options(stdout, long_options);
670 goto end;
671 case OPT_LIVE_TIMER:
672 {
673 uint64_t v;
674
675 errno = 0;
676 opt_arg = poptGetOptArg(pc);
677 if (!opt_arg) {
678 /* Set up default values. */
679 opt_live_timer = (uint32_t) DEFAULT_LTTNG_LIVE_TIMER;
680 DBG("Session live timer interval set to default value %d",
681 opt_live_timer);
682 break;
683 }
684
685 if (utils_parse_time_suffix(opt_arg, &v) < 0) {
686 ERR("Wrong value for --live parameter: %s", opt_arg);
687 ret = CMD_ERROR;
688 goto end;
689 }
690
691 if (v != (uint32_t) v) {
692 ERR("32-bit overflow in --live parameter: %s", opt_arg);
693 ret = CMD_ERROR;
694 goto end;
695 }
696
697 if (v == 0) {
698 ERR("Live timer interval must be greater than zero");
699 ret = CMD_ERROR;
700 goto end;
701 }
702
703 opt_live_timer = (uint32_t) v;
704 DBG("Session live timer interval set to %d", opt_live_timer);
705 break;
706 }
707 default:
708 ret = CMD_UNDEFINED;
709 goto end;
710 }
711 }
712
713 if (opt_no_consumer) {
714 MSG("The option --no-consumer is obsolete. Use --no-output now.");
715 ret = CMD_WARNING;
716 goto end;
717 }
718
719 ret = validate_url_option_combination();
720 if (ret) {
721 ret = CMD_ERROR;
722 goto end;
723 }
724
725 /* Spawn a session daemon if needed */
726 if (!opt_no_sessiond) {
727 ret = launch_sessiond();
728 if (ret) {
729 ret = CMD_ERROR;
730 goto end;
731 }
732 }
733
734 /* MI initialization */
735 if (lttng_opt_mi) {
736 writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi);
737 if (!writer) {
738 ret = -LTTNG_ERR_NOMEM;
739 goto end;
740 }
741
742 /* Open command element */
743 ret = mi_lttng_writer_command_open(writer,
744 mi_lttng_element_command_create);
745 if (ret) {
746 ret = CMD_ERROR;
747 goto end;
748 }
749
750 /* Open output element */
751 ret = mi_lttng_writer_open_element(writer,
752 mi_lttng_element_command_output);
753 if (ret) {
754 ret = CMD_ERROR;
755 goto end;
756 }
757 }
758 opt_session_name = (char*) poptGetArg(pc);
759
760 leftover = poptGetArg(pc);
761 if (leftover) {
762 ERR("Unknown argument: %s", leftover);
763 ret = CMD_ERROR;
764 goto end;
765 }
766
767 command_ret = create_session();
768 if (command_ret) {
769 success = 0;
770 }
771
772 if (lttng_opt_mi) {
773 /* Close output element */
774 ret = mi_lttng_writer_close_element(writer);
775 if (ret) {
776 ret = CMD_ERROR;
777 goto end;
778 }
779
780 /* Success ? */
781 ret = mi_lttng_writer_write_element_bool(writer,
782 mi_lttng_element_command_success, success);
783 if (ret) {
784 ret = CMD_ERROR;
785 goto end;
786 }
787
788 /* Command element close */
789 ret = mi_lttng_writer_command_close(writer);
790 if (ret) {
791 ret = CMD_ERROR;
792 goto end;
793 }
794 }
795
796 end:
797 /* Mi clean-up */
798 if (writer && mi_lttng_writer_destroy(writer)) {
799 /* Preserve original error code */
800 ret = ret ? ret : -LTTNG_ERR_MI_IO_FAIL;
801 }
802
803 /* Overwrite ret if an error occurred in create_session() */
804 ret = command_ret ? command_ret : ret;
805
806 poptFreeContext(pc);
807 return ret;
808 }
This page took 0.045566 seconds and 3 git commands to generate.