2 * Copyright (C) 2017 - Julien Desfossez <jdesfossez@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
22 #include <lttng/lttng-error.h>
23 #include <lttng/rotation.h>
24 #include <lttng/location-internal.h>
25 #include <lttng/rotate-internal.h>
26 #include <common/sessiond-comm/sessiond-comm.h>
27 #include <common/macros.h>
29 #include "lttng-ctl-helper.h"
32 enum lttng_rotation_status
ask_rotation_info(
33 struct lttng_rotation_handle
*rotation_handle
,
34 struct lttng_rotation_get_info_return
**info
)
36 /* lsm.get_rotation_state.rotation_id */
37 struct lttcomm_session_msg lsm
;
38 enum lttng_rotation_status status
= LTTNG_ROTATION_STATUS_OK
;
41 if (!rotation_handle
|| !info
) {
42 status
= LTTNG_ROTATION_STATUS_INVALID
;
46 memset(&lsm
, 0, sizeof(lsm
));
47 lsm
.cmd_type
= LTTNG_ROTATION_GET_INFO
;
48 lsm
.u
.get_rotation_info
.rotation_id
= rotation_handle
->rotation_id
;
50 ret
= lttng_strncpy(lsm
.session
.name
, rotation_handle
->session_name
,
51 sizeof(lsm
.session
.name
));
53 status
= LTTNG_ROTATION_STATUS_INVALID
;
57 ret
= lttng_ctl_ask_sessiond(&lsm
, (void **) info
);
59 status
= LTTNG_ROTATION_STATUS_ERROR
;
68 struct lttng_trace_archive_location
*
69 create_trace_archive_location_from_get_info(
70 const struct lttng_rotation_get_info_return
*info
)
72 struct lttng_trace_archive_location
*location
;
74 switch (info
->location_type
) {
75 case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL
:
76 location
= lttng_trace_archive_location_local_create(
77 info
->location
.local
.absolute_path
);
79 case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY
:
80 location
= lttng_trace_archive_location_relay_create(
81 info
->location
.relay
.host
,
82 info
->location
.relay
.protocol
,
83 info
->location
.relay
.ports
.control
,
84 info
->location
.relay
.ports
.data
,
85 info
->location
.relay
.relative_path
);
94 enum lttng_rotation_status
lttng_rotation_handle_get_state(
95 struct lttng_rotation_handle
*rotation_handle
,
96 enum lttng_rotation_state
*state
)
98 enum lttng_rotation_status status
= LTTNG_ROTATION_STATUS_OK
;
99 struct lttng_rotation_get_info_return
*info
= NULL
;
101 if (!rotation_handle
|| !state
) {
102 status
= LTTNG_ROTATION_STATUS_INVALID
;
106 status
= ask_rotation_info(rotation_handle
, &info
);
107 if (status
!= LTTNG_ROTATION_STATUS_OK
) {
111 *state
= (enum lttng_rotation_state
) info
->status
;
112 if (rotation_handle
->archive_location
||
113 *state
!= LTTNG_ROTATION_STATE_COMPLETED
) {
115 * The path is only provided by the sessiond once
116 * the session rotation is completed, but not expired.
122 * Cache the location since the rotation may expire before the user
123 * has a chance to query it.
125 rotation_handle
->archive_location
=
126 create_trace_archive_location_from_get_info(info
);
127 if (!rotation_handle
->archive_location
) {
128 status
= LTTNG_ROTATION_STATUS_ERROR
;
136 enum lttng_rotation_status
lttng_rotation_handle_get_archive_location(
137 struct lttng_rotation_handle
*rotation_handle
,
138 const struct lttng_trace_archive_location
**location
)
140 enum lttng_rotation_status status
= LTTNG_ROTATION_STATUS_OK
;
141 struct lttng_rotation_get_info_return
*info
= NULL
;
143 if (!rotation_handle
|| !location
) {
144 status
= LTTNG_ROTATION_STATUS_INVALID
;
148 /* Use the cached location we got from a previous query. */
149 if (rotation_handle
->archive_location
) {
150 *location
= rotation_handle
->archive_location
;
154 status
= ask_rotation_info(rotation_handle
, &info
);
155 if (status
!= LTTNG_ROTATION_STATUS_OK
) {
159 if ((enum lttng_rotation_state
) info
->status
!=
160 LTTNG_ROTATION_STATE_COMPLETED
) {
161 status
= LTTNG_ROTATION_STATUS_UNAVAILABLE
;
165 rotation_handle
->archive_location
=
166 create_trace_archive_location_from_get_info(info
);
167 if (!rotation_handle
->archive_location
) {
168 status
= LTTNG_ROTATION_STATUS_ERROR
;
176 void lttng_rotation_handle_destroy(
177 struct lttng_rotation_handle
*rotation_handle
)
179 if (!rotation_handle
) {
182 lttng_trace_archive_location_destroy(rotation_handle
->archive_location
);
183 free(rotation_handle
);
187 int init_rotation_handle(struct lttng_rotation_handle
*rotation_handle
,
188 const char *session_name
,
189 struct lttng_rotate_session_return
*rotate_return
)
193 ret
= lttng_strncpy(rotation_handle
->session_name
, session_name
,
194 sizeof(rotation_handle
->session_name
));
199 rotation_handle
->rotation_id
= rotate_return
->rotation_id
;
205 * Rotate the output folder of the session.
207 * Return 0 on success else a negative LTTng error code.
209 int lttng_rotate_session(const char *session_name
,
210 struct lttng_rotation_immediate_descriptor
*descriptor
,
211 struct lttng_rotation_handle
**rotation_handle
)
213 struct lttcomm_session_msg lsm
;
214 struct lttng_rotate_session_return
*rotate_return
= NULL
;
216 size_t session_name_len
;
219 ret
= -LTTNG_ERR_INVALID
;
223 session_name_len
= strlen(session_name
);
224 if (session_name_len
>= sizeof(lsm
.session
.name
) ||
225 session_name_len
>= member_sizeof(struct lttng_rotation_handle
, session_name
)) {
226 ret
= -LTTNG_ERR_INVALID
;
230 memset(&lsm
, 0, sizeof(lsm
));
231 lsm
.cmd_type
= LTTNG_ROTATE_SESSION
;
232 lttng_ctl_copy_string(lsm
.session
.name
, session_name
,
233 sizeof(lsm
.session
.name
));
235 ret
= lttng_ctl_ask_sessiond(&lsm
, (void **) &rotate_return
);
237 *rotation_handle
= NULL
;
241 *rotation_handle
= zmalloc(sizeof(struct lttng_rotation_handle
));
242 if (!*rotation_handle
) {
243 ret
= -LTTNG_ERR_NOMEM
;
247 init_rotation_handle(*rotation_handle
, session_name
, rotate_return
);
257 * Update the automatic rotation parameters.
258 * 'add' as true enables the provided schedule, false removes the shedule.
260 * The external API makes it appear as though arbitrary schedules can
261 * be added or removed at will. However, the session daemon is
262 * currently limited to one schedule per type (per session).
264 * The additional flexibility of the public API is offered for future
265 * rotation schedules that could indicate more precise criteria than
266 * size and time (e.g. a domain) where it could make sense to add
267 * multiple schedules of a given type to a session.
269 * Hence, the exact schedule that the user wishes to remove (and not
270 * just its type) must be passed so that the session daemon can
271 * validate that is exists before clearing it.
274 enum lttng_rotation_status
lttng_rotation_update_schedule(
275 const char *session_name
,
276 const struct lttng_rotation_schedule
*schedule
,
279 struct lttcomm_session_msg lsm
;
280 enum lttng_rotation_status status
= LTTNG_ROTATION_STATUS_OK
;
283 if (!session_name
|| !schedule
) {
284 status
= LTTNG_ROTATION_STATUS_INVALID
;
288 if (strlen(session_name
) >= sizeof(lsm
.session
.name
)) {
289 status
= LTTNG_ROTATION_STATUS_INVALID
;
293 memset(&lsm
, 0, sizeof(lsm
));
294 lsm
.cmd_type
= LTTNG_ROTATION_SET_SCHEDULE
;
295 lttng_ctl_copy_string(lsm
.session
.name
, session_name
,
296 sizeof(lsm
.session
.name
));
298 lsm
.u
.rotation_set_schedule
.type
= (uint32_t) schedule
->type
;
299 switch (schedule
->type
) {
300 case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
:
302 status
= lttng_rotation_schedule_size_threshold_get_threshold(
303 schedule
, &lsm
.u
.rotation_set_schedule
.value
);
304 if (status
!= LTTNG_ROTATION_STATUS_OK
) {
305 if (status
== LTTNG_ROTATION_STATUS_UNAVAILABLE
) {
306 status
= LTTNG_ROTATION_STATUS_INVALID
;
311 lsm
.u
.rotation_set_schedule
.set
= !!add
;
314 case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
:
316 status
= lttng_rotation_schedule_periodic_get_period(
317 schedule
, &lsm
.u
.rotation_set_schedule
.value
);
318 if (status
!= LTTNG_ROTATION_STATUS_OK
) {
319 if (status
== LTTNG_ROTATION_STATUS_UNAVAILABLE
) {
320 status
= LTTNG_ROTATION_STATUS_INVALID
;
325 lsm
.u
.rotation_set_schedule
.set
= !!add
;
329 status
= LTTNG_ROTATION_STATUS_INVALID
;
333 ret
= lttng_ctl_ask_sessiond(&lsm
, NULL
);
339 case LTTNG_ERR_ROTATION_SCHEDULE_SET
:
340 status
= LTTNG_ROTATION_STATUS_SCHEDULE_ALREADY_SET
;
342 case LTTNG_ERR_ROTATION_SCHEDULE_NOT_SET
:
343 status
= LTTNG_ROTATION_STATUS_INVALID
;
346 status
= LTTNG_ROTATION_STATUS_ERROR
;
353 struct lttng_rotation_schedules
*lttng_rotation_schedules_create(void)
355 return zmalloc(sizeof(struct lttng_rotation_schedules
));
359 void lttng_schedules_add(struct lttng_rotation_schedules
*schedules
,
360 struct lttng_rotation_schedule
*schedule
)
362 schedules
->schedules
[schedules
->count
++] = schedule
;
366 int get_schedules(const char *session_name
,
367 struct lttng_rotation_schedules
**_schedules
)
370 struct lttcomm_session_msg lsm
;
371 struct lttng_session_list_schedules_return
*schedules_comm
;
372 struct lttng_rotation_schedules
*schedules
= NULL
;
373 struct lttng_rotation_schedule
*periodic
= NULL
, *size
= NULL
;
375 memset(&lsm
, 0, sizeof(lsm
));
376 lsm
.cmd_type
= LTTNG_SESSION_LIST_ROTATION_SCHEDULES
;
377 lttng_ctl_copy_string(lsm
.session
.name
, session_name
,
378 sizeof(lsm
.session
.name
));
380 ret
= lttng_ctl_ask_sessiond(&lsm
, (void **) &schedules_comm
);
385 schedules
= lttng_rotation_schedules_create();
387 ret
= -LTTNG_ERR_NOMEM
;
391 if (schedules_comm
->periodic
.set
== 1) {
392 enum lttng_rotation_status status
;
394 periodic
= lttng_rotation_schedule_periodic_create();
396 ret
= -LTTNG_ERR_NOMEM
;
400 status
= lttng_rotation_schedule_periodic_set_period(
401 periodic
, schedules_comm
->periodic
.value
);
402 if (status
!= LTTNG_ROTATION_STATUS_OK
) {
404 * This would imply that the session daemon returned
405 * an invalid periodic rotation schedule value.
407 ret
= -LTTNG_ERR_UNK
;
411 lttng_schedules_add(schedules
, periodic
);
415 if (schedules_comm
->size
.set
== 1) {
416 enum lttng_rotation_status status
;
418 size
= lttng_rotation_schedule_size_threshold_create();
420 ret
= -LTTNG_ERR_NOMEM
;
424 status
= lttng_rotation_schedule_size_threshold_set_threshold(
425 size
, schedules_comm
->size
.value
);
426 if (status
!= LTTNG_ROTATION_STATUS_OK
) {
428 * This would imply that the session daemon returned
429 * an invalid size threshold schedule value.
431 ret
= -LTTNG_ERR_UNK
;
435 lttng_schedules_add(schedules
, size
);
441 free(schedules_comm
);
444 *_schedules
= schedules
;
448 enum lttng_rotation_schedule_type
lttng_rotation_schedule_get_type(
449 const struct lttng_rotation_schedule
*schedule
)
451 return schedule
? schedule
->type
: LTTNG_ROTATION_SCHEDULE_TYPE_UNKNOWN
;
454 struct lttng_rotation_schedule
*
455 lttng_rotation_schedule_size_threshold_create(void)
457 struct lttng_rotation_schedule_size_threshold
*schedule
;
459 schedule
= zmalloc(sizeof(*schedule
));
464 schedule
->parent
.type
= LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
;
466 return &schedule
->parent
;
469 enum lttng_rotation_status
470 lttng_rotation_schedule_size_threshold_get_threshold(
471 const struct lttng_rotation_schedule
*schedule
,
472 uint64_t *size_threshold_bytes
)
474 enum lttng_rotation_status status
= LTTNG_ROTATION_STATUS_OK
;
475 struct lttng_rotation_schedule_size_threshold
*size_schedule
;
477 if (!schedule
|| !size_threshold_bytes
||
478 schedule
->type
!= LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
) {
479 status
= LTTNG_ROTATION_STATUS_INVALID
;
483 size_schedule
= container_of(schedule
,
484 struct lttng_rotation_schedule_size_threshold
,
486 if (size_schedule
->size
.set
) {
487 *size_threshold_bytes
= size_schedule
->size
.bytes
;
489 status
= LTTNG_ROTATION_STATUS_UNAVAILABLE
;
496 enum lttng_rotation_status
497 lttng_rotation_schedule_size_threshold_set_threshold(
498 struct lttng_rotation_schedule
*schedule
,
499 uint64_t size_threshold_bytes
)
501 enum lttng_rotation_status status
= LTTNG_ROTATION_STATUS_OK
;
502 struct lttng_rotation_schedule_size_threshold
*size_schedule
;
504 if (!schedule
|| size_threshold_bytes
== 0 ||
505 size_threshold_bytes
== -1ULL ||
506 schedule
->type
!= LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
) {
507 status
= LTTNG_ROTATION_STATUS_INVALID
;
511 size_schedule
= container_of(schedule
,
512 struct lttng_rotation_schedule_size_threshold
,
514 size_schedule
->size
.bytes
= size_threshold_bytes
;
515 size_schedule
->size
.set
= true;
520 struct lttng_rotation_schedule
*
521 lttng_rotation_schedule_periodic_create(void)
523 struct lttng_rotation_schedule_periodic
*schedule
;
525 schedule
= zmalloc(sizeof(*schedule
));
530 schedule
->parent
.type
= LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
;
532 return &schedule
->parent
;
535 enum lttng_rotation_status
536 lttng_rotation_schedule_periodic_get_period(
537 const struct lttng_rotation_schedule
*schedule
,
540 enum lttng_rotation_status status
= LTTNG_ROTATION_STATUS_OK
;
541 struct lttng_rotation_schedule_periodic
*periodic_schedule
;
543 if (!schedule
|| !period_us
||
544 schedule
->type
!= LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
) {
545 status
= LTTNG_ROTATION_STATUS_INVALID
;
549 periodic_schedule
= container_of(schedule
,
550 struct lttng_rotation_schedule_periodic
,
552 if (periodic_schedule
->period
.set
) {
553 *period_us
= periodic_schedule
->period
.us
;
555 status
= LTTNG_ROTATION_STATUS_UNAVAILABLE
;
562 enum lttng_rotation_status
563 lttng_rotation_schedule_periodic_set_period(
564 struct lttng_rotation_schedule
*schedule
,
567 enum lttng_rotation_status status
= LTTNG_ROTATION_STATUS_OK
;
568 struct lttng_rotation_schedule_periodic
*periodic_schedule
;
570 if (!schedule
|| period_us
== 0 || period_us
== -1ULL ||
571 schedule
->type
!= LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
) {
572 status
= LTTNG_ROTATION_STATUS_INVALID
;
576 periodic_schedule
= container_of(schedule
,
577 struct lttng_rotation_schedule_periodic
,
579 periodic_schedule
->period
.us
= period_us
;
580 periodic_schedule
->period
.set
= true;
585 void lttng_rotation_schedule_destroy(struct lttng_rotation_schedule
*schedule
)
593 void lttng_rotation_schedules_destroy(
594 struct lttng_rotation_schedules
*schedules
)
602 for (i
= 0; i
< schedules
->count
; i
++) {
603 lttng_rotation_schedule_destroy(schedules
->schedules
[i
]);
609 enum lttng_rotation_status
lttng_rotation_schedules_get_count(
610 const struct lttng_rotation_schedules
*schedules
,
613 enum lttng_rotation_status status
= LTTNG_ROTATION_STATUS_OK
;
615 if (!schedules
|| !count
) {
616 status
= LTTNG_ROTATION_STATUS_INVALID
;
620 *count
= schedules
->count
;
625 const struct lttng_rotation_schedule
*lttng_rotation_schedules_get_at_index(
626 const struct lttng_rotation_schedules
*schedules
,
629 const struct lttng_rotation_schedule
*schedule
= NULL
;
631 if (!schedules
|| index
>= schedules
->count
) {
635 schedule
= schedules
->schedules
[index
];
640 enum lttng_rotation_status
lttng_session_add_rotation_schedule(
641 const char *session_name
,
642 const struct lttng_rotation_schedule
*schedule
)
644 return lttng_rotation_update_schedule(session_name
, schedule
, true);
647 enum lttng_rotation_status
lttng_session_remove_rotation_schedule(
648 const char *session_name
,
649 const struct lttng_rotation_schedule
*schedule
)
651 return lttng_rotation_update_schedule(session_name
, schedule
, false);
654 int lttng_session_list_rotation_schedules(
655 const char *session_name
,
656 struct lttng_rotation_schedules
**schedules
)
658 return get_schedules(session_name
, schedules
);