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 free(attr
->override_attr
.path_url
);
46 free(attr
->override_attr
.ctrl_url
);
47 free(attr
->override_attr
.data_url
);
52 const char *lttng_load_session_attr_get_session_name(
53 struct lttng_load_session_attr
*attr
)
55 const char *ret
= NULL
;
57 if (attr
&& attr
->session_name
[0]) {
58 ret
= attr
->session_name
;
64 const char *lttng_load_session_attr_get_input_url(
65 struct lttng_load_session_attr
*attr
)
67 const char *ret
= NULL
;
69 if (attr
&& attr
->input_url
[0]) {
70 ret
= attr
->input_url
;
76 int lttng_load_session_attr_get_overwrite(
77 struct lttng_load_session_attr
*attr
)
79 return attr
? attr
->overwrite
: -LTTNG_ERR_INVALID
;
82 const char *lttng_load_session_attr_get_override_path_url(
83 struct lttng_load_session_attr
*attr
)
85 const char *ret
= NULL
;
87 if (attr
&& attr
->override_attr
.path_url
) {
88 ret
= attr
->raw_override_path_url
;
94 const char *lttng_load_session_attr_get_override_ctrl_url(
95 struct lttng_load_session_attr
*attr
)
97 const char *ret
= NULL
;
99 if (attr
&& attr
->override_attr
.ctrl_url
) {
100 ret
= attr
->raw_override_ctrl_url
;
106 const char *lttng_load_session_attr_get_override_data_url(
107 struct lttng_load_session_attr
*attr
)
109 const char *ret
= NULL
;
111 if (attr
&& attr
->override_attr
.data_url
) {
112 ret
= attr
->raw_override_data_url
;
118 const char *lttng_load_session_attr_get_override_url(
119 struct lttng_load_session_attr
*attr
)
121 const char *ret
= NULL
;
123 if (attr
&& (attr
->override_attr
.path_url
||
124 (attr
->override_attr
.ctrl_url
&&
125 attr
->override_attr
.data_url
))) {
126 ret
= attr
->raw_override_url
;
132 int lttng_load_session_attr_set_session_name(
133 struct lttng_load_session_attr
*attr
, const char *session_name
)
138 ret
= -LTTNG_ERR_INVALID
;
145 len
= strlen(session_name
);
146 if (len
>= LTTNG_NAME_MAX
) {
147 ret
= -LTTNG_ERR_INVALID
;
151 strncpy(attr
->session_name
, session_name
, len
);
153 attr
->session_name
[0] = '\0';
159 int lttng_load_session_attr_set_input_url(
160 struct lttng_load_session_attr
*attr
, const char *url
)
165 struct lttng_uri
*uris
= NULL
;
168 ret
= -LTTNG_ERR_INVALID
;
173 attr
->input_url
[0] = '\0';
179 if (len
>= PATH_MAX
) {
180 ret
= -LTTNG_ERR_INVALID
;
184 size
= uri_parse_str_urls(url
, NULL
, &uris
);
185 if (size
<= 0 || uris
[0].dtype
!= LTTNG_DST_PATH
) {
186 ret
= -LTTNG_ERR_INVALID
;
190 /* Copy string plus the NULL terminated byte. */
191 lttng_ctl_copy_string(attr
->input_url
, uris
[0].dst
.path
,
192 sizeof(attr
->input_url
));
200 int lttng_load_session_attr_set_overwrite(
201 struct lttng_load_session_attr
*attr
, int overwrite
)
206 ret
= -LTTNG_ERR_INVALID
;
210 attr
->overwrite
= !!overwrite
;
215 int lttng_load_session_attr_set_override_path_url(
216 struct lttng_load_session_attr
*attr
, const char *url
)
220 struct lttng_uri
*uri
= NULL
;
221 char *url_str
= NULL
;
222 char *raw_str
= NULL
;
226 ret
= -LTTNG_ERR_INVALID
;
230 if (attr
->override_attr
.ctrl_url
|| attr
->override_attr
.data_url
) {
232 * FIXME: return a more meaningful error.
233 * Setting a path override after a ctrl or data override make no
234 * sense and show that the user do not know what he is doing.
236 ret
= -LTTNG_ERR_INVALID
;
241 * FIXME: uri_parse should be able to take as parameter the protocol
242 * type to check validity with or the exclusion. For now only check on
243 * the parsing validity it will fail later on.
245 ret_size
= uri_parse(url
, &uri
);
247 ret
= -LTTNG_ERR_INVALID
;
251 /* Populate the internal override representation */
252 url_str
= zmalloc(PATH_MAX
);
254 /* FIXME: return valid error */
255 ret
= LTTNG_ERR_INVALID
;
259 tmp
= uri_to_str_url(&uri
[0], url_str
, PATH_MAX
);
261 ret
= -LTTNG_ERR_INVALID
;
265 raw_str
= strndup(url
, PATH_MAX
);
267 /* FIXME: return valid error */
268 ret
= LTTNG_ERR_INVALID
;
272 /* Squash old value if any */
273 free(attr
->override_attr
.path_url
);
274 free(attr
->raw_override_path_url
);
276 /* Populate the object */
277 attr
->override_attr
.path_url
= url_str
;
278 attr
->raw_override_path_url
= raw_str
;
289 int lttng_load_session_attr_set_override_ctrl_url(
290 struct lttng_load_session_attr
*attr
, const char *url
)
294 struct lttng_uri
*uri
= NULL
;
295 char *url_str
= NULL
;
296 char *raw_str
= NULL
;
300 ret
= -LTTNG_ERR_INVALID
;
304 if (attr
->override_attr
.path_url
) {
306 * FIXME: return a more meaningful error.
307 * Setting a ctrl override after a path override make no
308 * sense and show that the user do not know what he is doing.
310 ret
= -LTTNG_ERR_INVALID
;
315 * FIXME: uri_parse should be able to take as parameter the protocol
316 * type to check validity with or the exclusion. For now only check on
317 * the parsing validity it will fail later on.
319 ret_size
= uri_parse(url
, &uri
);
321 ret
= -LTTNG_ERR_INVALID
;
325 if (uri
[0].port
== 0) {
326 uri
[0].port
= DEFAULT_NETWORK_CONTROL_PORT
;
329 url_str
= zmalloc(PATH_MAX
);
331 /* FIXME: return valid error */
332 ret
= LTTNG_ERR_INVALID
;
336 tmp
= uri_to_str_url(&uri
[0], url_str
, PATH_MAX
);
338 ret
= -LTTNG_ERR_INVALID
;
342 raw_str
= strndup(url
, PATH_MAX
);
344 /* FIXME: return valid error */
345 ret
= LTTNG_ERR_INVALID
;
349 /* Squash old value if any */
350 free(attr
->override_attr
.ctrl_url
);
351 free(attr
->raw_override_ctrl_url
);
353 /* Populate the object */
354 attr
->override_attr
.ctrl_url
= url_str
;
355 attr
->raw_override_ctrl_url
= raw_str
;
367 int lttng_load_session_attr_set_override_data_url(
368 struct lttng_load_session_attr
*attr
, const char *url
)
372 struct lttng_uri
*uri
= NULL
;
373 char *url_str
= NULL
;
374 char *raw_str
= NULL
;
378 ret
= -LTTNG_ERR_INVALID
;
382 if (attr
->override_attr
.path_url
) {
384 * FIXME: return a more meaningful error.
385 * Setting a data override after a path override make no
386 * sense and show that the user do not know what he is doing.
388 ret
= -LTTNG_ERR_INVALID
;
393 * FIXME: uri_parse should be able to take as parameter the protocol
394 * type to check validity with or the exclusion. For now only check on
395 * the parsing validity it will fail later on.
397 ret_size
= uri_parse(url
, &uri
);
399 ret
= -LTTNG_ERR_INVALID
;
403 if (uri
[0].port
== 0) {
404 uri
[0].port
= DEFAULT_NETWORK_DATA_PORT
;
407 url_str
= zmalloc(PATH_MAX
);
409 /* FIXME: return valid error */
410 ret
= LTTNG_ERR_INVALID
;
414 tmp
= uri_to_str_url(&uri
[0], url_str
, PATH_MAX
);
416 ret
= -LTTNG_ERR_INVALID
;
420 raw_str
= strndup(url
, PATH_MAX
);
422 /* FIXME: return valid error */
423 ret
= LTTNG_ERR_INVALID
;
427 /* Squash old value if any */
428 free(attr
->override_attr
.data_url
);
429 free(attr
->raw_override_data_url
);
431 /* Populate the object */
432 attr
->override_attr
.data_url
= url_str
;
433 attr
->raw_override_data_url
= raw_str
;
444 int lttng_load_session_attr_set_override_url(
445 struct lttng_load_session_attr
*attr
, const char *url
)
449 struct lttng_uri
*uri
= NULL
;
450 char *raw_url_str
= NULL
;
451 char *raw_path_str
= NULL
;
452 char *path_str
= NULL
;
453 char *raw_ctrl_str
= NULL
;
454 char *ctrl_str
= NULL
;
455 char *raw_data_str
= NULL
;
456 char *data_str
= NULL
;
457 char buffer
[PATH_MAX
];
461 ret
= -LTTNG_ERR_INVALID
;
467 * FIXME: uri_parse should be able to take as parameter the protocol
468 * type to check validity with or the exclusion. For now only check on
469 * the parsing validity it will fail later on.
471 ret_size
= uri_parse_str_urls(url
, NULL
, &uri
);
472 if (ret_size
< 0 || ret_size
> 2) {
473 ret
= -LTTNG_ERR_INVALID
;
477 raw_url_str
= strndup(url
, PATH_MAX
);
479 /* FIXME: return valid error */
480 ret
= LTTNG_ERR_INVALID
;
484 /* Fetch path | ctrl && data string url */
485 tmp
= uri_to_str_url(&uri
[0], buffer
, sizeof(buffer
));
487 ret
= -LTTNG_ERR_INVALID
;
491 switch (uri
[0].dtype
) {
493 raw_path_str
= strndup(buffer
, PATH_MAX
);
495 /* FIXME: return valid error */
496 ret
= LTTNG_ERR_INVALID
;
500 path_str
= strndup(raw_path_str
, PATH_MAX
);
502 /* FIXME: return valid error */
503 ret
= LTTNG_ERR_INVALID
;
510 ret
= -LTTNG_ERR_INVALID
;
514 raw_ctrl_str
= strndup(buffer
, PATH_MAX
);
516 /* FIXME: return valid error */
517 ret
= LTTNG_ERR_INVALID
;
521 ctrl_str
= strndup(raw_ctrl_str
, PATH_MAX
);
523 /* FIXME: return valid error */
524 ret
= LTTNG_ERR_INVALID
;
528 /* Fetch the data uri */
529 tmp
= uri_to_str_url(&uri
[1], buffer
, sizeof(buffer
));
531 ret
= -LTTNG_ERR_INVALID
;
535 raw_data_str
= strndup(buffer
, PATH_MAX
);
537 /* FIXME: return valid error */
538 ret
= LTTNG_ERR_INVALID
;
542 data_str
= strndup(raw_data_str
, PATH_MAX
);
544 /* FIXME: return valid error */
545 ret
= LTTNG_ERR_INVALID
;
551 ret
= -LTTNG_ERR_INVALID
;
555 free(attr
->override_attr
.path_url
);
556 free(attr
->override_attr
.ctrl_url
);
557 free(attr
->override_attr
.data_url
);
558 free(attr
->raw_override_url
);
559 free(attr
->raw_override_path_url
);
560 free(attr
->raw_override_ctrl_url
);
561 free(attr
->raw_override_data_url
);
563 attr
->override_attr
.path_url
= path_str
;
564 attr
->override_attr
.ctrl_url
= ctrl_str
;
565 attr
->override_attr
.data_url
= data_str
;
567 attr
->raw_override_url
= raw_url_str
;
568 attr
->raw_override_path_url
= raw_path_str
;
569 attr
->raw_override_ctrl_url
= raw_ctrl_str
;
570 attr
->raw_override_data_url
= raw_data_str
;
572 /* Pass data responsability to the struct */
593 * The lttng-ctl API does not expose all the information needed to load the
594 * session configurations. Thus, we must send a load command to the session
595 * daemon which will, in turn, load its current session configuration.
597 int lttng_load_session(struct lttng_load_session_attr
*attr
)
600 const char *url
, *session_name
;
603 ret
= -LTTNG_ERR_INVALID
;
607 url
= attr
->input_url
[0] != '\0' ? attr
->input_url
: NULL
;
608 session_name
= attr
->session_name
[0] != '\0' ?
609 attr
->session_name
: NULL
;
611 ret
= config_load_session(url
, session_name
, attr
->overwrite
, 0);