2 * Copyright (C) 2020 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 * SPDX-License-Identifier: LGPL-2.1-only
10 #include "lttng-ctl-helper.h"
11 #include "lttng/domain.h"
12 #include "lttng/lttng-error.h"
13 #include <common/sessiond-comm/sessiond-comm.h>
14 #include <common/tracker.h>
15 #include <lttng/tracker.h>
17 struct lttng_process_attr_tracker_handle
{
19 enum lttng_domain_type domain
;
20 enum lttng_process_attr process_attr
;
21 struct lttng_process_attr_values
*inclusion_set
;
24 void lttng_process_attr_tracker_handle_destroy(
25 struct lttng_process_attr_tracker_handle
*tracker
)
31 lttng_process_attr_values_destroy(tracker
->inclusion_set
);
32 free(tracker
->session_name
);
36 enum lttng_error_code
lttng_session_get_tracker_handle(const char *session_name
,
37 enum lttng_domain_type domain
,
38 enum lttng_process_attr process_attr
,
39 struct lttng_process_attr_tracker_handle
**out_tracker_handle
)
41 enum lttng_error_code ret_code
= LTTNG_OK
;
42 struct lttng_process_attr_tracker_handle
*handle
= NULL
;
43 enum lttng_process_attr_tracker_handle_status status
;
44 enum lttng_tracking_policy policy
;
46 if (!session_name
|| !out_tracker_handle
) {
47 ret_code
= LTTNG_ERR_INVALID
;
51 if (domain
!= LTTNG_DOMAIN_KERNEL
&& domain
!= LTTNG_DOMAIN_UST
) {
52 ret_code
= LTTNG_ERR_UNSUPPORTED_DOMAIN
;
56 handle
= (lttng_process_attr_tracker_handle
*) zmalloc(sizeof(*handle
));
58 ret_code
= LTTNG_ERR_NOMEM
;
62 handle
->session_name
= strdup(session_name
);
63 if (!handle
->session_name
) {
64 ret_code
= LTTNG_ERR_NOMEM
;
68 handle
->domain
= domain
;
69 handle
->process_attr
= process_attr
;
72 * Use the `get_tracking_policy` command to validate the tracker's
75 status
= lttng_process_attr_tracker_handle_get_tracking_policy(
78 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
:
80 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST
:
81 ret_code
= LTTNG_ERR_SESSION_NOT_EXIST
;
84 ret_code
= LTTNG_ERR_UNK
;
88 *out_tracker_handle
= handle
;
91 lttng_process_attr_tracker_handle_destroy(handle
);
95 enum lttng_process_attr_tracker_handle_status
96 lttng_process_attr_tracker_handle_get_tracking_policy(
97 const struct lttng_process_attr_tracker_handle
*tracker
,
98 enum lttng_tracking_policy
*policy
)
101 int reply_ret
, copy_ret
;
102 enum lttng_process_attr_tracker_handle_status status
=
103 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
;
104 struct lttcomm_session_msg lsm
= {
105 .cmd_type
= LTTNG_PROCESS_ATTR_TRACKER_GET_POLICY
,
108 if (!tracker
|| !policy
) {
109 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID
;
113 copy_ret
= lttng_strncpy(lsm
.session
.name
, tracker
->session_name
,
114 sizeof(lsm
.session
.name
));
116 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID
;
120 lsm
.domain
.type
= tracker
->domain
;
121 lsm
.u
.process_attr_tracker_get_tracking_policy
.process_attr
=
122 (int32_t) tracker
->process_attr
;
124 /* Command returns a session descriptor on success. */
125 reply_ret
= lttng_ctl_ask_sessiond_varlen_no_cmd_header(
126 &lsm
, NULL
, 0, &reply
);
127 if (reply_ret
!= sizeof(uint32_t)) {
128 if (reply_ret
== -LTTNG_ERR_SESSION_NOT_EXIST
||
129 reply_ret
== -LTTNG_ERR_SESS_NOT_FOUND
) {
130 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST
;
132 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR
;
137 *policy
= (enum lttng_tracking_policy
)(*((const uint32_t *) reply
));
143 enum lttng_process_attr_tracker_handle_status
144 lttng_process_attr_tracker_handle_set_tracking_policy(
145 const struct lttng_process_attr_tracker_handle
*tracker
,
146 enum lttng_tracking_policy policy
)
148 int reply_ret
, copy_ret
;
149 enum lttng_process_attr_tracker_handle_status status
=
150 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
;
151 struct lttcomm_session_msg lsm
= {
152 .cmd_type
= LTTNG_PROCESS_ATTR_TRACKER_SET_POLICY
,
156 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID
;
160 copy_ret
= lttng_strncpy(lsm
.session
.name
, tracker
->session_name
,
161 sizeof(lsm
.session
.name
));
163 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID
;
167 lsm
.domain
.type
= tracker
->domain
;
168 lsm
.u
.process_attr_tracker_set_tracking_policy
.process_attr
=
169 (int32_t) tracker
->process_attr
;
170 lsm
.u
.process_attr_tracker_set_tracking_policy
.tracking_policy
=
173 /* Command returns a session descriptor on success. */
174 reply_ret
= lttng_ctl_ask_sessiond(&lsm
, NULL
);
176 if (reply_ret
== -LTTNG_ERR_SESSION_NOT_EXIST
) {
177 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST
;
179 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR
;
187 #define DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(command_upper, \
188 command_lower, process_attr_name, value_type_name, \
189 value_type_c, value_type_enum) \
190 enum lttng_process_attr_tracker_handle_status \
191 lttng_process_attr_##process_attr_name##_tracker_handle_##command_lower##_##value_type_name( \
192 const struct lttng_process_attr_tracker_handle \
194 value_type_c value) \
197 enum lttng_process_attr_tracker_handle_status status = \
198 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK; \
199 struct lttcomm_session_msg lsm = { \
200 .cmd_type = LTTNG_PROCESS_ATTR_TRACKER_##command_upper##_INCLUDE_VALUE}; \
203 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID; \
207 ret = lttng_strncpy(lsm.session.name, tracker->session_name, \
208 sizeof(lsm.session.name)); \
210 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID; \
214 lsm.domain.type = tracker->domain; \
215 lsm.u.process_attr_tracker_add_remove_include_value \
217 (int32_t) tracker->process_attr; \
218 lsm.u.process_attr_tracker_add_remove_include_value \
219 .value_type = (uint32_t) \
220 LTTNG_PROCESS_ATTR_VALUE_TYPE_##value_type_enum; \
222 if (std::is_signed<value_type_c>::value) { \
223 lsm.u.process_attr_tracker_add_remove_include_value \
224 .integral_value.u._signed = value; \
226 lsm.u.process_attr_tracker_add_remove_include_value \
227 .integral_value.u._unsigned = value; \
230 ret = lttng_ctl_ask_sessiond(&lsm, NULL); \
233 case LTTNG_ERR_PROCESS_ATTR_EXISTS: \
234 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_EXISTS; \
236 case LTTNG_ERR_PROCESS_ATTR_MISSING: \
237 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_MISSING; \
239 case LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY: \
240 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY; \
243 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR; \
250 #define DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(command_upper, \
251 command_lower, process_attr_name, value_type_name, \
253 enum lttng_process_attr_tracker_handle_status \
254 lttng_process_attr_##process_attr_name##_tracker_handle_##command_lower##_##value_type_name( \
255 const struct lttng_process_attr_tracker_handle \
260 enum lttng_process_attr_tracker_handle_status status = \
261 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK; \
262 struct lttcomm_session_msg lsm = { \
263 .cmd_type = LTTNG_PROCESS_ATTR_TRACKER_##command_upper##_INCLUDE_VALUE}; \
264 const size_t len = value ? strlen(value) + 1 : 0; \
266 if (!tracker || !value) { \
267 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID; \
271 ret = lttng_strncpy(lsm.session.name, tracker->session_name, \
272 sizeof(lsm.session.name)); \
274 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID; \
278 lsm.domain.type = tracker->domain; \
279 lsm.u.process_attr_tracker_add_remove_include_value \
281 (int32_t) tracker->process_attr; \
282 lsm.u.process_attr_tracker_add_remove_include_value.name_len = \
284 lsm.u.process_attr_tracker_add_remove_include_value \
285 .value_type = (uint32_t) \
286 LTTNG_PROCESS_ATTR_VALUE_TYPE_##value_type_enum; \
288 ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header( \
289 &lsm, value, len, NULL); \
292 case LTTNG_ERR_PROCESS_ATTR_EXISTS: \
293 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_EXISTS; \
295 case LTTNG_ERR_PROCESS_ATTR_MISSING: \
296 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_MISSING; \
298 case LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY: \
299 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY; \
301 case LTTNG_ERR_USER_NOT_FOUND: \
302 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_USER_NOT_FOUND; \
304 case LTTNG_ERR_GROUP_NOT_FOUND: \
305 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_GROUP_NOT_FOUND; \
308 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR; \
316 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
317 ADD
, add
, process_id
, pid
, pid_t
, PID
);
318 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
319 REMOVE
, remove
, process_id
, pid
, pid_t
, PID
);
322 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
323 ADD
, add
, virtual_process_id
, pid
, pid_t
, PID
);
324 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
325 REMOVE
, remove
, virtual_process_id
, pid
, pid_t
, PID
);
328 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
329 ADD
, add
, user_id
, uid
, uid_t
, UID
);
330 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
331 REMOVE
, remove
, user_id
, uid
, uid_t
, UID
);
332 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
333 ADD
, add
, user_id
, user_name
, USER_NAME
);
334 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
335 REMOVE
, remove
, user_id
, user_name
, USER_NAME
);
338 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
339 ADD
, add
, virtual_user_id
, uid
, uid_t
, UID
);
340 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
341 REMOVE
, remove
, virtual_user_id
, uid
, uid_t
, UID
);
342 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
343 ADD
, add
, virtual_user_id
, user_name
, USER_NAME
);
344 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
345 REMOVE
, remove
, virtual_user_id
, user_name
, USER_NAME
);
348 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
349 ADD
, add
, group_id
, gid
, gid_t
, GID
);
350 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
351 REMOVE
, remove
, group_id
, gid
, gid_t
, GID
);
352 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
353 ADD
, add
, group_id
, group_name
, GROUP_NAME
);
354 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
355 REMOVE
, remove
, group_id
, group_name
, GROUP_NAME
);
358 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
359 ADD
, add
, virtual_group_id
, gid
, gid_t
, GID
);
360 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
361 REMOVE
, remove
, virtual_group_id
, gid
, gid_t
, GID
);
362 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
363 ADD
, add
, virtual_group_id
, group_name
, GROUP_NAME
);
364 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
365 REMOVE
, remove
, virtual_group_id
, group_name
, GROUP_NAME
);
367 enum lttng_process_attr_tracker_handle_status
368 lttng_process_attr_tracker_handle_get_inclusion_set(
369 struct lttng_process_attr_tracker_handle
*tracker
,
370 const struct lttng_process_attr_values
**values
)
373 int reply_ret
, copy_ret
;
374 enum lttng_process_attr_tracker_handle_status status
=
375 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
;
376 struct lttcomm_session_msg lsm
= {
377 .cmd_type
= LTTNG_PROCESS_ATTR_TRACKER_GET_INCLUSION_SET
,
379 struct lttng_buffer_view inclusion_set_view
;
380 ssize_t inclusion_set_ret
;
382 if (!tracker
|| !values
) {
383 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID
;
387 lttng_process_attr_values_destroy(tracker
->inclusion_set
);
388 tracker
->inclusion_set
= NULL
;
390 copy_ret
= lttng_strncpy(lsm
.session
.name
, tracker
->session_name
,
391 sizeof(lsm
.session
.name
));
393 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID
;
397 lsm
.domain
.type
= tracker
->domain
;
398 lsm
.u
.process_attr_tracker_get_tracking_policy
.process_attr
=
399 (int32_t) tracker
->process_attr
;
401 /* Command returns a session descriptor on success. */
402 reply_ret
= lttng_ctl_ask_sessiond_varlen_no_cmd_header(
403 &lsm
, NULL
, 0, (void **) &reply
);
405 if (reply_ret
== -LTTNG_ERR_SESSION_NOT_EXIST
) {
406 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST
;
407 } else if (reply_ret
==
408 -LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY
) {
409 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY
;
411 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR
;
414 } else if (reply_ret
== 0) {
415 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR
;
419 inclusion_set_view
= lttng_buffer_view_init(reply
, 0, reply_ret
);
420 if (!inclusion_set_view
.data
) {
421 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR
;
425 inclusion_set_ret
= lttng_process_attr_values_create_from_buffer(
426 tracker
->domain
, tracker
->process_attr
,
427 &inclusion_set_view
, &tracker
->inclusion_set
);
428 if (inclusion_set_ret
< 0) {
429 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR
;
432 *values
= tracker
->inclusion_set
;
438 enum lttng_process_attr_values_status
lttng_process_attr_values_get_count(
439 const struct lttng_process_attr_values
*values
,
442 enum lttng_process_attr_values_status status
=
443 LTTNG_PROCESS_ATTR_VALUES_STATUS_OK
;
445 if (!values
|| !count
) {
446 status
= LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID
;
450 *count
= _lttng_process_attr_values_get_count(values
);
455 enum lttng_process_attr_value_type
lttng_process_attr_values_get_type_at_index(
456 const struct lttng_process_attr_values
*values
,
459 enum lttng_process_attr_value_type type
;
460 const struct process_attr_value
*value
;
463 type
= LTTNG_PROCESS_ATTR_VALUE_TYPE_INVALID
;
467 if (_lttng_process_attr_values_get_count(values
) <= index
) {
468 type
= LTTNG_PROCESS_ATTR_VALUE_TYPE_INVALID
;
472 value
= lttng_process_attr_tracker_values_get_at_index(values
, index
);
478 #define DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER( \
479 value_type_name, value_type, expected_value_type) \
480 enum lttng_process_attr_values_status \
481 lttng_process_attr_values_get_##value_type_name##_at_index( \
482 const struct lttng_process_attr_values \
484 unsigned int index, \
485 value_type *out_value) \
487 enum lttng_process_attr_values_status status = \
488 LTTNG_PROCESS_ATTR_VALUES_STATUS_OK; \
489 const struct process_attr_value *value; \
492 status = LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID; \
496 if (_lttng_process_attr_values_get_count(values) <= index) { \
497 status = LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID; \
501 value = lttng_process_attr_tracker_values_get_at_index( \
504 LTTNG_PROCESS_ATTR_VALUE_TYPE_##expected_value_type) { \
505 status = LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID_TYPE; \
508 *out_value = value->value.value_type_name; \
513 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(pid
, pid_t
, PID
);
514 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(uid
, uid_t
, UID
);
515 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(gid
, gid_t
, GID
);
516 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(user_name
, const char *, USER_NAME
);
517 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(group_name
, const char *, GROUP_NAME
);
519 static enum lttng_error_code
handle_status_to_error_code(
520 enum lttng_process_attr_tracker_handle_status handle_status
)
522 switch (handle_status
) {
523 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY
:
524 return LTTNG_ERR_INVALID
;
525 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST
:
526 return LTTNG_ERR_SESSION_NOT_EXIST
;
527 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR
:
528 return LTTNG_ERR_INVALID_PROTOCOL
;
529 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_EXISTS
:
530 return LTTNG_ERR_PID_TRACKED
;
531 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_MISSING
:
532 return LTTNG_ERR_PID_NOT_TRACKED
;
533 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
:
535 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR
:
538 return LTTNG_ERR_UNK
;
543 * Add PID to session tracker.
544 * Return 0 on success else a negative LTTng error code.
546 int lttng_track_pid(struct lttng_handle
*handle
, int pid
)
548 enum lttng_error_code ret_code
;
549 struct lttng_process_attr_tracker_handle
*tracker_handle
= NULL
;
550 enum lttng_process_attr_tracker_handle_status handle_status
;
551 enum lttng_tracking_policy policy
;
552 enum lttng_process_attr process_attr
;
555 ret_code
= LTTNG_ERR_INVALID
;
559 process_attr
= handle
->domain
.type
== LTTNG_DOMAIN_KERNEL
?
560 LTTNG_PROCESS_ATTR_PROCESS_ID
:
561 LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
;
563 ret_code
= lttng_session_get_tracker_handle(handle
->session_name
,
565 process_attr
, &tracker_handle
);
566 if (ret_code
!= LTTNG_OK
) {
571 handle_status
= lttng_process_attr_tracker_handle_set_tracking_policy(
573 LTTNG_TRACKING_POLICY_INCLUDE_ALL
);
574 ret_code
= handle_status_to_error_code(handle_status
);
578 handle_status
= lttng_process_attr_tracker_handle_get_tracking_policy(
579 tracker_handle
, &policy
);
580 if (handle_status
!= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
) {
581 ret_code
= handle_status_to_error_code(handle_status
);
585 if (policy
!= LTTNG_TRACKING_POLICY_INCLUDE_SET
) {
586 handle_status
= lttng_process_attr_tracker_handle_set_tracking_policy(
588 LTTNG_TRACKING_POLICY_INCLUDE_SET
);
589 if (handle_status
!= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
) {
590 ret_code
= handle_status_to_error_code(handle_status
);
595 handle_status
= process_attr
== LTTNG_PROCESS_ATTR_PROCESS_ID
?
596 lttng_process_attr_process_id_tracker_handle_add_pid(
599 lttng_process_attr_virtual_process_id_tracker_handle_add_pid(
602 ret_code
= handle_status_to_error_code(handle_status
);
604 lttng_process_attr_tracker_handle_destroy(tracker_handle
);
605 return ret_code
== LTTNG_OK
? 0 : -ret_code
;
609 * Remove PID from session tracker.
610 * Return 0 on success else a negative LTTng error code.
612 int lttng_untrack_pid(struct lttng_handle
*handle
, int pid
)
614 enum lttng_error_code ret_code
;
615 struct lttng_process_attr_tracker_handle
*tracker_handle
= NULL
;
616 enum lttng_process_attr_tracker_handle_status handle_status
;
617 enum lttng_tracking_policy policy
;
618 enum lttng_process_attr process_attr
;
621 ret_code
= LTTNG_ERR_INVALID
;
625 process_attr
= handle
->domain
.type
== LTTNG_DOMAIN_KERNEL
?
626 LTTNG_PROCESS_ATTR_PROCESS_ID
:
627 LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
;
628 ret_code
= lttng_session_get_tracker_handle(handle
->session_name
,
629 handle
->domain
.type
, process_attr
, &tracker_handle
);
630 if (ret_code
!= LTTNG_OK
) {
635 handle_status
= lttng_process_attr_tracker_handle_set_tracking_policy(
637 LTTNG_TRACKING_POLICY_EXCLUDE_ALL
);
638 ret_code
= handle_status_to_error_code(handle_status
);
642 handle_status
= lttng_process_attr_tracker_handle_get_tracking_policy(
643 tracker_handle
, &policy
);
644 if (handle_status
!= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
) {
645 ret_code
= handle_status_to_error_code(handle_status
);
649 if (policy
== LTTNG_TRACKING_POLICY_EXCLUDE_ALL
) {
650 ret_code
= LTTNG_ERR_PID_NOT_TRACKED
;
652 } else if (policy
== LTTNG_TRACKING_POLICY_INCLUDE_ALL
) {
653 ret_code
= LTTNG_ERR_INVALID
;
657 handle_status
= process_attr
== LTTNG_PROCESS_ATTR_PROCESS_ID
?
658 lttng_process_attr_process_id_tracker_handle_remove_pid(
661 lttng_process_attr_virtual_process_id_tracker_handle_remove_pid(
664 if (handle_status
== LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY
) {
665 ret_code
= LTTNG_ERR_PID_NOT_TRACKED
;
668 lttng_process_attr_tracker_handle_destroy(tracker_handle
);
669 return ret_code
== LTTNG_OK
? 0 : -ret_code
;
673 * List PIDs in the tracker.
675 * enabled is set to whether the PID tracker is enabled.
676 * pids is set to an allocated array of PIDs currently tracked. On
677 * success, pids must be freed by the caller.
678 * nr_pids is set to the number of entries contained by the pids array.
680 * Returns 0 on success, else a negative LTTng error code.
682 int lttng_list_tracker_pids(struct lttng_handle
*handle
,
687 enum lttng_error_code ret_code
;
688 struct lttng_process_attr_tracker_handle
*tracker_handle
= NULL
;
689 enum lttng_process_attr_tracker_handle_status handle_status
;
690 const struct lttng_process_attr_values
*values
;
691 enum lttng_tracking_policy policy
;
692 unsigned int pid_count
, i
;
693 int32_t *pid_array
= NULL
;
695 if (!handle
|| !_enabled
|| !_pids
|| !_nr_pids
) {
696 ret_code
= LTTNG_ERR_INVALID
;
700 ret_code
= lttng_session_get_tracker_handle(handle
->session_name
,
702 LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
, &tracker_handle
);
703 if (ret_code
!= LTTNG_OK
) {
708 handle_status
= lttng_process_attr_tracker_handle_get_inclusion_set(
709 tracker_handle
, &values
);
711 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
) {
712 policy
= LTTNG_TRACKING_POLICY_INCLUDE_SET
;
714 } else if (handle_status
!=
715 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY
) {
716 ret_code
= handle_status_to_error_code(handle_status
);
720 handle_status
= lttng_process_attr_tracker_handle_get_tracking_policy(
721 tracker_handle
, &policy
);
723 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
) {
724 ret_code
= handle_status_to_error_code(handle_status
);
728 /* Tracking policy changed in the meantime, retry. */
729 if (policy
== LTTNG_TRACKING_POLICY_INCLUDE_SET
) {
736 case LTTNG_TRACKING_POLICY_INCLUDE_ALL
:
739 case LTTNG_TRACKING_POLICY_EXCLUDE_ALL
:
743 case LTTNG_TRACKING_POLICY_INCLUDE_SET
:
745 const enum lttng_process_attr_values_status values_status
=
746 lttng_process_attr_values_get_count(
749 if (values_status
!= LTTNG_PROCESS_ATTR_VALUES_STATUS_OK
) {
750 ret_code
= LTTNG_ERR_UNK
;
756 ret_code
= LTTNG_ERR_INVALID_PROTOCOL
;
760 pid_array
= (int32_t *) zmalloc(pid_count
* sizeof(int32_t));
762 ret_code
= LTTNG_ERR_NOMEM
;
766 /* Extract values to a raw array. */
767 for (i
= 0; i
< pid_count
; i
++) {
769 const enum lttng_process_attr_values_status values_status
=
770 lttng_process_attr_values_get_pid_at_index(
773 if (values_status
!= LTTNG_PROCESS_ATTR_VALUES_STATUS_OK
) {
774 ret_code
= LTTNG_ERR_UNK
;
777 pid_array
[i
] = (int32_t) pid
;
779 *_nr_pids
= (size_t) pid_count
;
783 lttng_process_attr_tracker_handle_destroy(tracker_handle
);
785 return ret_code
== LTTNG_OK
? 0 : -ret_code
;