2 * Copyright (C) 2014 - David Goulet <dgoulet@efficios.com>
4 * This library is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU Lesser General Public License, version 2.1 only,
6 * as published by the Free Software Foundation.
8 * This library 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 Lesser General Public License
13 * You should have received a copy of the GNU Lesser General Public License
14 * along with this library; if not, write to the Free Software Foundation,
15 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 #include <lttng/lttng-error.h>
24 #include <lttng/load.h>
25 #include <lttng/load-internal.h>
26 #include <common/sessiond-comm/sessiond-comm.h>
27 #include <common/config/session-config.h>
28 #include <common/uri.h>
29 #include <common/macros.h>
31 #include "lttng-ctl-helper.h"
33 struct lttng_load_session_attr
*lttng_load_session_attr_create(void)
35 return zmalloc(sizeof(struct lttng_load_session_attr
));
38 void lttng_load_session_attr_destroy(struct lttng_load_session_attr
*attr
)
41 free(attr
->raw_override_url
);
42 free(attr
->raw_override_path_url
);
43 free(attr
->raw_override_ctrl_url
);
44 free(attr
->raw_override_data_url
);
45 if (attr
->override_attr
) {
46 free(attr
->override_attr
->path_url
);
47 free(attr
->override_attr
->ctrl_url
);
48 free(attr
->override_attr
->data_url
);
50 free(attr
->override_attr
);
55 const char *lttng_load_session_attr_get_session_name(
56 struct lttng_load_session_attr
*attr
)
58 const char *ret
= NULL
;
60 if (attr
&& attr
->session_name
[0]) {
61 ret
= attr
->session_name
;
67 const char *lttng_load_session_attr_get_input_url(
68 struct lttng_load_session_attr
*attr
)
70 const char *ret
= NULL
;
72 if (attr
&& attr
->input_url
[0]) {
73 ret
= attr
->input_url
;
79 int lttng_load_session_attr_get_overwrite(
80 struct lttng_load_session_attr
*attr
)
82 return attr
? attr
->overwrite
: -LTTNG_ERR_INVALID
;
85 const char *lttng_load_session_attr_get_override_path_url(
86 struct lttng_load_session_attr
*attr
)
88 const char *ret
= NULL
;
90 if (attr
&& attr
->override_attr
->path_url
) {
91 ret
= attr
->raw_override_path_url
;
97 const char *lttng_load_session_attr_get_override_ctrl_url(
98 struct lttng_load_session_attr
*attr
)
100 const char *ret
= NULL
;
102 if (attr
&& attr
->override_attr
->ctrl_url
) {
103 ret
= attr
->raw_override_ctrl_url
;
109 const char *lttng_load_session_attr_get_override_data_url(
110 struct lttng_load_session_attr
*attr
)
112 const char *ret
= NULL
;
114 if (attr
&& attr
->override_attr
->data_url
) {
115 ret
= attr
->raw_override_data_url
;
121 const char *lttng_load_session_attr_get_override_url(
122 struct lttng_load_session_attr
*attr
)
124 const char *ret
= NULL
;
126 if (attr
&& (attr
->override_attr
->path_url
||
127 (attr
->override_attr
->ctrl_url
&&
128 attr
->override_attr
->data_url
))) {
129 ret
= attr
->raw_override_url
;
135 int lttng_load_session_attr_set_session_name(
136 struct lttng_load_session_attr
*attr
, const char *session_name
)
141 ret
= -LTTNG_ERR_INVALID
;
148 len
= strlen(session_name
);
149 if (len
>= LTTNG_NAME_MAX
) {
150 ret
= -LTTNG_ERR_INVALID
;
154 strncpy(attr
->session_name
, session_name
, len
);
156 attr
->session_name
[0] = '\0';
162 int lttng_load_session_attr_set_input_url(
163 struct lttng_load_session_attr
*attr
, const char *url
)
168 struct lttng_uri
*uris
= NULL
;
171 ret
= -LTTNG_ERR_INVALID
;
176 attr
->input_url
[0] = '\0';
182 if (len
>= PATH_MAX
) {
183 ret
= -LTTNG_ERR_INVALID
;
187 size
= uri_parse_str_urls(url
, NULL
, &uris
);
188 if (size
<= 0 || uris
[0].dtype
!= LTTNG_DST_PATH
) {
189 ret
= -LTTNG_ERR_INVALID
;
193 /* Copy string plus the NULL terminated byte. */
194 lttng_ctl_copy_string(attr
->input_url
, uris
[0].dst
.path
,
195 sizeof(attr
->input_url
));
203 int lttng_load_session_attr_set_overwrite(
204 struct lttng_load_session_attr
*attr
, int overwrite
)
209 ret
= -LTTNG_ERR_INVALID
;
213 attr
->overwrite
= !!overwrite
;
218 int lttng_load_session_attr_set_override_path_url(
219 struct lttng_load_session_attr
*attr
, const char *url
)
223 struct lttng_uri
*uri
= NULL
;
224 char *url_str
= NULL
;
225 char *raw_str
= NULL
;
229 ret
= -LTTNG_ERR_INVALID
;
233 if (!attr
->override_attr
) {
234 attr
->override_attr
= zmalloc(sizeof(struct config_load_session_override_attr
));
235 if (!attr
->override_attr
) {
236 /* FIXME: return valid error */
237 ret
= -LTTNG_ERR_INVALID
;
242 if (attr
->override_attr
->ctrl_url
|| attr
->override_attr
->data_url
) {
244 * FIXME: return a more meaningful error.
245 * Setting a path override after a ctrl or data override make no
246 * sense and show that the user do not know what he is doing.
248 ret
= -LTTNG_ERR_INVALID
;
253 * FIXME: uri_parse should be able to take as parameter the protocol
254 * type to check validity with or the exclusion. For now only check on
255 * the parsing validity it will fail later on.
257 ret_size
= uri_parse(url
, &uri
);
259 ret
= -LTTNG_ERR_INVALID
;
263 /* Populate the internal override representation */
264 url_str
= zmalloc(PATH_MAX
);
266 /* FIXME: return valid error */
267 ret
= LTTNG_ERR_INVALID
;
271 tmp
= uri_to_str_url(&uri
[0], url_str
, PATH_MAX
);
273 ret
= -LTTNG_ERR_INVALID
;
277 raw_str
= strndup(url
, PATH_MAX
);
279 /* FIXME: return valid error */
280 ret
= LTTNG_ERR_INVALID
;
284 /* Squash old value if any */
285 free(attr
->override_attr
->path_url
);
286 free(attr
->raw_override_path_url
);
288 /* Populate the object */
289 attr
->override_attr
->path_url
= url_str
;
290 attr
->raw_override_path_url
= raw_str
;
301 int lttng_load_session_attr_set_override_ctrl_url(
302 struct lttng_load_session_attr
*attr
, const char *url
)
306 struct lttng_uri
*uri
= NULL
;
307 char *url_str
= NULL
;
308 char *raw_str
= NULL
;
312 ret
= -LTTNG_ERR_INVALID
;
316 if (!attr
->override_attr
) {
317 attr
->override_attr
= zmalloc(sizeof(struct config_load_session_override_attr
));
318 if (!attr
->override_attr
) {
319 /* FIXME: return valid error */
320 ret
= -LTTNG_ERR_INVALID
;
325 if (attr
->override_attr
->path_url
) {
327 * FIXME: return a more meaningful error.
328 * Setting a ctrl override after a path override make no
329 * sense and show that the user do not know what he is doing.
331 ret
= -LTTNG_ERR_INVALID
;
336 * FIXME: uri_parse should be able to take as parameter the protocol
337 * type to check validity with or the exclusion. For now only check on
338 * the parsing validity it will fail later on.
340 ret_size
= uri_parse(url
, &uri
);
342 ret
= -LTTNG_ERR_INVALID
;
346 if (uri
[0].port
== 0) {
347 uri
[0].port
= DEFAULT_NETWORK_CONTROL_PORT
;
350 url_str
= zmalloc(PATH_MAX
);
352 /* FIXME: return valid error */
353 ret
= LTTNG_ERR_INVALID
;
357 tmp
= uri_to_str_url(&uri
[0], url_str
, PATH_MAX
);
359 ret
= -LTTNG_ERR_INVALID
;
363 raw_str
= strndup(url
, PATH_MAX
);
365 /* FIXME: return valid error */
366 ret
= LTTNG_ERR_INVALID
;
370 /* Squash old value if any */
371 free(attr
->override_attr
->ctrl_url
);
372 free(attr
->raw_override_ctrl_url
);
374 /* Populate the object */
375 attr
->override_attr
->ctrl_url
= url_str
;
376 attr
->raw_override_ctrl_url
= raw_str
;
388 int lttng_load_session_attr_set_override_data_url(
389 struct lttng_load_session_attr
*attr
, const char *url
)
393 struct lttng_uri
*uri
= NULL
;
394 char *url_str
= NULL
;
395 char *raw_str
= NULL
;
399 ret
= -LTTNG_ERR_INVALID
;
403 if (!attr
->override_attr
) {
404 attr
->override_attr
= zmalloc(sizeof(struct config_load_session_override_attr
));
405 if (!attr
->override_attr
) {
406 /* FIXME: return valid error */
407 ret
= -LTTNG_ERR_INVALID
;
412 if (attr
->override_attr
->path_url
) {
414 * FIXME: return a more meaningful error.
415 * Setting a data override after a path override make no
416 * sense and show that the user do not know what he is doing.
418 ret
= -LTTNG_ERR_INVALID
;
423 * FIXME: uri_parse should be able to take as parameter the protocol
424 * type to check validity with or the exclusion. For now only check on
425 * the parsing validity it will fail later on.
427 ret_size
= uri_parse(url
, &uri
);
429 ret
= -LTTNG_ERR_INVALID
;
433 if (uri
[0].port
== 0) {
434 uri
[0].port
= DEFAULT_NETWORK_DATA_PORT
;
437 url_str
= zmalloc(PATH_MAX
);
439 /* FIXME: return valid error */
440 ret
= LTTNG_ERR_INVALID
;
444 tmp
= uri_to_str_url(&uri
[0], url_str
, PATH_MAX
);
446 ret
= -LTTNG_ERR_INVALID
;
450 raw_str
= strndup(url
, PATH_MAX
);
452 /* FIXME: return valid error */
453 ret
= LTTNG_ERR_INVALID
;
457 /* Squash old value if any */
458 free(attr
->override_attr
->data_url
);
459 free(attr
->raw_override_data_url
);
461 /* Populate the object */
462 attr
->override_attr
->data_url
= url_str
;
463 attr
->raw_override_data_url
= raw_str
;
474 int lttng_load_session_attr_set_override_url(
475 struct lttng_load_session_attr
*attr
, const char *url
)
479 struct lttng_uri
*uri
= NULL
;
480 char *raw_url_str
= NULL
;
481 char *raw_path_str
= NULL
;
482 char *path_str
= NULL
;
483 char *raw_ctrl_str
= NULL
;
484 char *ctrl_str
= NULL
;
485 char *raw_data_str
= NULL
;
486 char *data_str
= NULL
;
487 char buffer
[PATH_MAX
];
491 ret
= -LTTNG_ERR_INVALID
;
495 if (!attr
->override_attr
) {
496 attr
->override_attr
= zmalloc(sizeof(struct config_load_session_override_attr
));
497 if (!attr
->override_attr
) {
498 /* FIXME: return valid error */
499 ret
= -LTTNG_ERR_INVALID
;
505 * FIXME: uri_parse should be able to take as parameter the protocol
506 * type to check validity with or the exclusion. For now only check on
507 * the parsing validity it will fail later on.
509 ret_size
= uri_parse_str_urls(url
, NULL
, &uri
);
510 if (ret_size
< 0 || ret_size
> 2) {
511 ret
= -LTTNG_ERR_INVALID
;
515 raw_url_str
= strndup(url
, PATH_MAX
);
517 /* FIXME: return valid error */
518 ret
= LTTNG_ERR_INVALID
;
522 /* Fetch path | ctrl && data string url */
523 tmp
= uri_to_str_url(&uri
[0], buffer
, sizeof(buffer
));
525 ret
= -LTTNG_ERR_INVALID
;
529 switch (uri
[0].dtype
) {
531 raw_path_str
= strndup(buffer
, PATH_MAX
);
533 /* FIXME: return valid error */
534 ret
= LTTNG_ERR_INVALID
;
538 path_str
= strndup(raw_path_str
, PATH_MAX
);
540 /* FIXME: return valid error */
541 ret
= LTTNG_ERR_INVALID
;
548 ret
= -LTTNG_ERR_INVALID
;
552 raw_ctrl_str
= strndup(buffer
, PATH_MAX
);
554 /* FIXME: return valid error */
555 ret
= LTTNG_ERR_INVALID
;
559 ctrl_str
= strndup(raw_ctrl_str
, PATH_MAX
);
561 /* FIXME: return valid error */
562 ret
= LTTNG_ERR_INVALID
;
566 /* Fetch the data uri */
567 tmp
= uri_to_str_url(&uri
[1], buffer
, sizeof(buffer
));
569 ret
= -LTTNG_ERR_INVALID
;
573 raw_data_str
= strndup(buffer
, PATH_MAX
);
575 /* FIXME: return valid error */
576 ret
= LTTNG_ERR_INVALID
;
580 data_str
= strndup(raw_data_str
, PATH_MAX
);
582 /* FIXME: return valid error */
583 ret
= LTTNG_ERR_INVALID
;
589 ret
= -LTTNG_ERR_INVALID
;
593 free(attr
->override_attr
->path_url
);
594 free(attr
->override_attr
->ctrl_url
);
595 free(attr
->override_attr
->data_url
);
596 free(attr
->raw_override_url
);
597 free(attr
->raw_override_path_url
);
598 free(attr
->raw_override_ctrl_url
);
599 free(attr
->raw_override_data_url
);
601 attr
->override_attr
->path_url
= path_str
;
602 attr
->override_attr
->ctrl_url
= ctrl_str
;
603 attr
->override_attr
->data_url
= data_str
;
605 attr
->raw_override_url
= raw_url_str
;
606 attr
->raw_override_path_url
= raw_path_str
;
607 attr
->raw_override_ctrl_url
= raw_ctrl_str
;
608 attr
->raw_override_data_url
= raw_data_str
;
610 /* Pass data responsability to the struct */
631 * The lttng-ctl API does not expose all the information needed to load the
632 * session configurations. Thus, we must send a load command to the session
633 * daemon which will, in turn, load its current session configuration.
635 int lttng_load_session(struct lttng_load_session_attr
*attr
)
638 const char *url
, *session_name
;
641 ret
= -LTTNG_ERR_INVALID
;
645 url
= attr
->input_url
[0] != '\0' ? attr
->input_url
: NULL
;
646 session_name
= attr
->session_name
[0] != '\0' ?
647 attr
->session_name
: NULL
;
649 ret
= config_load_session(url
, session_name
, attr
->overwrite
, 0,
650 attr
->override_attr
);