2 * Copyright (C) 2011 EfficiOS Inc.
3 * Copyright (C) 2019 Jérémie Galarneau <jeremie.galarneau@efficios.com>
5 * SPDX-License-Identifier: GPL-2.0-only
10 #include "../command.hpp"
11 #include "../utils.hpp"
13 #include <common/compat/time.hpp>
14 #include <common/defaults.hpp>
15 #include <common/mi-lttng.hpp>
16 #include <common/path.hpp>
17 #include <common/sessiond-comm/sessiond-comm.hpp>
18 #include <common/uri.hpp>
19 #include <common/utils.hpp>
21 #include <lttng/lttng.h>
30 #include <sys/types.h>
34 static char *opt_output_path
;
36 static char *opt_ctrl_url
;
37 static char *opt_data_url
;
38 static char *opt_shm_path
;
39 static int opt_no_consumer
;
40 static int opt_no_output
;
41 static int opt_snapshot
;
42 static uint32_t opt_live_timer
;
44 #ifdef LTTNG_EMBED_HELP
45 static const char help_msg
[] =
46 #include <lttng-create.1.h>
63 static struct mi_writer
*writer
;
64 static struct poptOption long_options
[] = {
65 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
66 { "help", 'h', POPT_ARG_NONE
, NULL
, OPT_HELP
, NULL
, NULL
},
67 { "output", 'o', POPT_ARG_STRING
, &opt_output_path
, 0, NULL
, NULL
},
68 { "list-options", 0, POPT_ARG_NONE
, NULL
, OPT_LIST_OPTIONS
, NULL
, NULL
},
69 { "set-url", 'U', POPT_ARG_STRING
, &opt_url
, 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 { "no-output", 0, POPT_ARG_VAL
, &opt_no_output
, 1, 0, 0 },
73 { "no-consumer", 0, POPT_ARG_VAL
, &opt_no_consumer
, 1, 0, 0 },
74 { "snapshot", 0, POPT_ARG_VAL
, &opt_snapshot
, 1, 0, 0 },
75 { "live", 0, POPT_ARG_INT
| POPT_ARGFLAG_OPTIONAL
, 0, OPT_LIVE_TIMER
, 0, 0 },
76 { "shm-path", 0, POPT_ARG_STRING
, &opt_shm_path
, 0, 0, 0 },
77 { 0, 0, 0, 0, 0, 0, 0 }
81 * Retrieve the created session and mi output it based on provided argument
82 * This is currently a summary of what was pretty printed and is subject to
85 static int mi_created_session(const char *session_name
)
87 int ret
, i
, count
, found
;
88 struct lttng_session
*sessions
;
90 /* session_name should not be null */
91 LTTNG_ASSERT(session_name
);
94 count
= lttng_list_sessions(&sessions
);
97 ERR("%s", lttng_strerror(ret
));
102 ERR("Error session creation failed: session %s not found", session_name
);
103 ret
= -LTTNG_ERR_SESS_NOT_FOUND
;
108 for (i
= 0; i
< count
; i
++) {
109 if (strncmp(sessions
[i
].name
, session_name
, NAME_MAX
) == 0) {
111 ret
= mi_lttng_session(writer
, &sessions
[i
], 0);
120 ret
= -LTTNG_ERR_SESS_NOT_FOUND
;
131 static struct lttng_session_descriptor
*create_session_descriptor(const char *session_name
)
134 enum output_type output_type
;
135 struct lttng_uri
*uris
= NULL
;
136 struct lttng_session_descriptor
*descriptor
= NULL
;
137 const char *uri_str1
= NULL
, *uri_str2
= NULL
;
138 char local_output_path
[LTTNG_PATH_MAX
] = {};
141 output_type
= OUTPUT_NONE
;
142 } else if (opt_output_path
) {
143 char *expanded_output_path
;
146 output_type
= OUTPUT_LOCAL
;
147 expanded_output_path
= utils_expand_path(opt_output_path
);
148 if (!expanded_output_path
) {
149 ERR("Failed to expand output path.");
153 local_output_path
, expanded_output_path
, sizeof(local_output_path
));
154 free(expanded_output_path
);
156 ERR("Output path exceeds the maximal supported length (%zu bytes)",
157 sizeof(local_output_path
));
160 } else if (opt_url
|| opt_ctrl_url
) {
163 uri_str1
= opt_ctrl_url
? opt_ctrl_url
: opt_url
;
164 uri_str2
= opt_data_url
;
166 uri_count
= uri_parse_str_urls(uri_str1
, uri_str2
, &uris
);
167 if (uri_count
!= 1 && uri_count
!= 2) {
168 ERR("Unrecognized URL format.");
174 output_type
= OUTPUT_LOCAL
;
175 if (uris
[0].dtype
!= LTTNG_DST_PATH
) {
176 ERR("Unrecognized URL format.");
180 local_output_path
, uris
[0].dst
.path
, sizeof(local_output_path
));
182 ERR("Output path exceeds the maximal supported length (%zu bytes)",
183 sizeof(local_output_path
));
187 output_type
= OUTPUT_NETWORK
;
190 /* Already checked. */
194 output_type
= OUTPUT_UNSPECIFIED
;
198 /* Snapshot session. */
199 switch (output_type
) {
200 case OUTPUT_UNSPECIFIED
:
202 descriptor
= lttng_session_descriptor_snapshot_local_create(
204 output_type
== OUTPUT_LOCAL
? local_output_path
: NULL
);
207 descriptor
= lttng_session_descriptor_snapshot_create(session_name
);
210 descriptor
= lttng_session_descriptor_snapshot_network_create(
211 session_name
, uri_str1
, uri_str2
);
216 } else if (opt_live_timer
) {
218 if (output_type
!= OUTPUT_UNSPECIFIED
&& output_type
!= OUTPUT_NETWORK
) {
219 ERR("Unsupported output type specified for live session.");
222 descriptor
= lttng_session_descriptor_live_network_create(
223 session_name
, uri_str1
, uri_str2
, opt_live_timer
);
225 /* Regular session. */
226 switch (output_type
) {
227 case OUTPUT_UNSPECIFIED
:
229 descriptor
= lttng_session_descriptor_local_create(
231 output_type
== OUTPUT_LOCAL
? local_output_path
: NULL
);
234 descriptor
= lttng_session_descriptor_create(session_name
);
237 descriptor
= lttng_session_descriptor_network_create(
238 session_name
, uri_str1
, uri_str2
);
245 ERR("Failed to initialize session creation command.");
248 * Auto-launch the relay daemon when a live session
249 * is created using default URLs.
251 if (!opt_url
&& !opt_ctrl_url
&& !opt_data_url
&& opt_live_timer
&&
254 const char *pathname
= opt_relayd_path
?: INSTALL_BIN_PATH
"/lttng-relayd";
256 ret
= spawn_relayd(pathname
, 0);
258 lttng_session_descriptor_destroy(descriptor
);
269 * Create a tracing session.
270 * If no name is specified, a default name is generated.
272 * Returns one of the CMD_* result constants.
274 static int create_session(const char *session_name
)
277 char shm_path
[LTTNG_PATH_MAX
] = {};
278 struct lttng_session_descriptor
*session_descriptor
= NULL
;
279 enum lttng_session_descriptor_status descriptor_status
;
280 enum lttng_error_code ret_code
;
281 struct lttng_session
*sessions
= NULL
;
282 const struct lttng_session
*created_session
= NULL
;
283 const char *created_session_name
;
285 /* Validate options. */
287 if (strlen(session_name
) > NAME_MAX
) {
288 ERR("Session name too long. Length must be lower or equal to %d", NAME_MAX
);
293 * Check if the session name begins with "auto-" or is exactly "auto".
294 * Both are reserved for the default session name. See bug #449 to
295 * understand why we need to check both here.
297 if ((strncmp(session_name
,
298 DEFAULT_SESSION_NAME
"-",
299 strlen(DEFAULT_SESSION_NAME
) + 1) == 0) ||
300 (strncmp(session_name
, DEFAULT_SESSION_NAME
, strlen(DEFAULT_SESSION_NAME
)) ==
302 strlen(session_name
) == strlen(DEFAULT_SESSION_NAME
))) {
303 ERR("%s is a reserved keyword for default session(s)",
304 DEFAULT_SESSION_NAME
);
310 if (opt_snapshot
&& opt_live_timer
) {
311 ERR("Snapshot and live modes are mutually exclusive.");
316 if ((!opt_ctrl_url
&& opt_data_url
) || (opt_ctrl_url
&& !opt_data_url
)) {
317 ERR("Both control and data URLs must be specified.");
322 session_descriptor
= create_session_descriptor(session_name
);
323 if (!session_descriptor
) {
327 ret_code
= lttng_create_session_ext(session_descriptor
);
328 if (ret_code
!= LTTNG_OK
) {
329 ERR("%s", lttng_strerror(-ret_code
));
334 descriptor_status
= lttng_session_descriptor_get_session_name(session_descriptor
,
335 &created_session_name
);
336 if (descriptor_status
!= LTTNG_SESSION_DESCRIPTOR_STATUS_OK
) {
337 ERR("Failed to obtain created session name");
342 ret
= lttng_list_sessions(&sessions
);
344 ERR("Failed to fetch properties of created session: %s", lttng_strerror(ret
));
348 for (i
= 0; i
< ret
; i
++) {
349 if (!strcmp(created_session_name
, sessions
[i
].name
)) {
350 created_session
= &sessions
[i
];
354 if (!created_session
) {
355 ERR("Failed to fetch properties of created session");
361 char datetime_suffix
[17] = {};
364 * An auto-generated session name already includes the creation
368 uint64_t creation_time
;
370 time_t creation_time_t
;
373 ret_code
= lttng_session_get_creation_time(created_session
, &creation_time
);
374 if (ret_code
!= LTTNG_OK
) {
375 ERR("%s", lttng_strerror(-ret_code
));
379 creation_time_t
= (time_t) creation_time
;
380 timeinfo
= localtime(&creation_time_t
);
382 PERROR("Failed to interpret session creation time");
386 strftime_ret
= strftime(datetime_suffix
,
387 sizeof(datetime_suffix
),
390 if (strftime_ret
== 0) {
391 ERR("Failed to format session creation time.");
397 ret
= snprintf(shm_path
,
401 created_session_name
,
403 if (ret
< 0 || ret
>= sizeof(shm_path
)) {
404 ERR("Failed to format the shared memory path.");
408 ret
= lttng_set_session_shm_path(created_session_name
, shm_path
);
410 lttng_destroy_session(created_session_name
);
417 MSG("Snapshot session %s created.", created_session_name
);
418 } else if (opt_live_timer
) {
419 MSG("Live session %s created.", created_session_name
);
421 MSG("Session %s created.", created_session_name
);
424 if (*created_session
->path
&& !opt_snapshot
) {
425 MSG("Traces will be output to %s", created_session
->path
);
427 if (opt_live_timer
) {
428 MSG("Live timer interval set to %u %s", opt_live_timer
, USEC_UNIT
);
430 } else if (opt_snapshot
) {
431 struct lttng_snapshot_output_list
*list
;
432 struct lttng_snapshot_output
*iter
;
433 char snapshot_url
[LTTNG_PATH_MAX
] = {};
435 ret
= lttng_snapshot_list_output(created_session_name
, &list
);
437 ERR("Failed to list snapshot outputs.");
442 while ((iter
= lttng_snapshot_output_list_get_next(list
))) {
443 const char *url
= NULL
;
445 url
= lttng_snapshot_output_get_ctrl_url(iter
);
446 ret
= lttng_strncpy(snapshot_url
, url
, sizeof(snapshot_url
));
448 snapshot_url
[0] = '\0';
449 ERR("Failed to retrieve snapshot output destination");
453 lttng_snapshot_output_list_destroy(list
);
456 MSG("Default snapshot output set to %s", snapshot_url
);
458 MSG("Every channel enabled for this session will be set to mmap output and default to overwrite mode.");
461 MSG("Shared memory path set to %s", shm_path
);
466 ret
= mi_created_session(created_session_name
);
473 /* Init lttng session config */
474 ret
= config_init(created_session_name
);
482 lttng_session_descriptor_destroy(session_descriptor
);
490 * Spawn a session daemon by forking and execv.
492 static int spawn_sessiond(const char *pathname
)
497 MSG("Spawning a session daemon");
501 * Spawn session daemon in daemon mode.
503 execlp(pathname
, "lttng-sessiond", "--daemonize", NULL
);
504 /* execlp only returns if error happened */
505 if (errno
== ENOENT
) {
506 ERR("No session daemon found. Use --sessiond-path.");
510 kill(getppid(), SIGTERM
); /* wake parent */
512 } else if (pid
> 0) {
514 * In daemon mode (--daemonize), sessiond only exits when
515 * it's ready to accept commands.
519 pid_t wait_pid_ret
= waitpid(pid
, &status
, 0);
521 if (wait_pid_ret
< 0) {
522 if (errno
== EINTR
) {
530 if (WIFSIGNALED(status
)) {
531 ERR("Session daemon was killed by signal %d", WTERMSIG(status
));
534 } else if (WIFEXITED(status
)) {
535 DBG("Session daemon terminated normally (exit status: %d)",
536 WEXITSTATUS(status
));
538 if (WEXITSTATUS(status
) != 0) {
539 ERR("Session daemon terminated with an error (exit status: %d)",
540 WEXITSTATUS(status
));
562 * Check if the session daemon is available using
563 * the liblttngctl API for the check. If not, try to
566 static int launch_sessiond(void)
569 const char *pathname
= NULL
;
571 ret
= lttng_session_daemon_alive();
573 /* Sessiond is alive, not an error */
578 /* Try command line option path */
579 pathname
= opt_sessiond_path
;
581 /* Try LTTNG_SESSIOND_PATH env variable */
582 if (pathname
== NULL
) {
583 pathname
= getenv(DEFAULT_SESSIOND_PATH_ENV
);
586 /* Try with configured path */
587 if (pathname
== NULL
) {
588 if (CONFIG_SESSIOND_BIN
[0] != '\0') {
589 pathname
= CONFIG_SESSIOND_BIN
;
593 /* Try the default path */
594 if (pathname
== NULL
) {
595 pathname
= INSTALL_BIN_PATH
"/lttng-sessiond";
598 DBG("Session daemon binary path: %s", pathname
);
600 /* Check existence and permissions */
601 ret
= access(pathname
, F_OK
| X_OK
);
603 ERR("No such file or access denied: %s", pathname
);
607 ret
= spawn_sessiond(pathname
);
610 ERR("Problem occurred while launching session daemon (%s)", pathname
);
615 static int validate_url_option_combination(void)
620 used_count
+= !!opt_url
;
621 used_count
+= !!opt_output_path
;
622 used_count
+= (opt_data_url
|| opt_ctrl_url
);
623 if (used_count
> 1) {
624 ERR("Only one of the --set-url, --ctrl-url/data-url, or --output options may be used at once.");
632 * The 'create <options>' first level command
634 * Returns one of the CMD_* result constants.
636 int cmd_create(int argc
, const char **argv
)
638 int opt
, ret
= CMD_SUCCESS
, command_ret
= CMD_SUCCESS
, success
= 1;
639 char *opt_arg
= NULL
;
640 const char *arg_session_name
= NULL
;
641 const char *leftover
= NULL
;
642 static poptContext pc
;
644 pc
= poptGetContext(NULL
, argc
, argv
, long_options
, 0);
645 poptReadDefaultConfig(pc
, 0);
647 while ((opt
= poptGetNextOpt(pc
)) != -1) {
652 case OPT_LIST_OPTIONS
:
653 list_cmd_options(stdout
, long_options
);
665 opt_arg
= poptGetOptArg(pc
);
667 /* Set up default values. */
668 opt_live_timer
= (uint32_t) DEFAULT_LTTNG_LIVE_TIMER
;
669 DBG("Session live timer interval set to default value %d",
674 if (utils_parse_time_suffix(opt_arg
, &v
) < 0) {
675 ERR("Wrong value for --live parameter: %s", opt_arg
);
680 if (v
!= (uint32_t) v
) {
681 ERR("32-bit overflow in --live parameter: %s", opt_arg
);
687 ERR("Live timer interval must be greater than zero");
692 opt_live_timer
= (uint32_t) v
;
693 DBG("Session live timer interval set to %d", opt_live_timer
);
702 if (opt_no_consumer
) {
703 MSG("The option --no-consumer is obsolete. Use --no-output now.");
708 ret
= validate_url_option_combination();
714 /* Spawn a session daemon if needed */
715 if (!opt_no_sessiond
) {
716 ret
= launch_sessiond();
723 /* MI initialization */
725 writer
= mi_lttng_writer_create(fileno(stdout
), lttng_opt_mi
);
727 ret
= -LTTNG_ERR_NOMEM
;
731 /* Open command element */
732 ret
= mi_lttng_writer_command_open(writer
, mi_lttng_element_command_create
);
738 /* Open output element */
739 ret
= mi_lttng_writer_open_element(writer
, mi_lttng_element_command_output
);
746 /* Get the optional session name argument. */
747 arg_session_name
= poptGetArg(pc
);
749 leftover
= poptGetArg(pc
);
751 ERR("Unknown argument: %s", leftover
);
756 command_ret
= create_session(arg_session_name
);
762 /* Close output element */
763 ret
= mi_lttng_writer_close_element(writer
);
770 ret
= mi_lttng_writer_write_element_bool(
771 writer
, mi_lttng_element_command_success
, success
);
777 /* Command element close */
778 ret
= mi_lttng_writer_command_close(writer
);
787 if (writer
&& mi_lttng_writer_destroy(writer
)) {
788 /* Preserve original error code */
789 ret
= ret
? ret
: -LTTNG_ERR_MI_IO_FAIL
;
792 /* Overwrite ret if an error occurred in create_session() */
793 ret
= command_ret
? command_ret
: ret
;