2 * Copyright (C) 2020 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 * SPDX-License-Identifier: LGPL-2.1-only
8 #include "lttng-ctl-helper.hpp"
9 #include "lttng/domain.h"
10 #include "lttng/lttng-error.h"
11 #include <common/sessiond-comm/sessiond-comm.hpp>
12 #include <common/tracker.hpp>
13 #include <lttng/tracker.h>
14 #include <type_traits>
16 struct lttng_process_attr_tracker_handle
{
18 enum lttng_domain_type domain
;
19 enum lttng_process_attr process_attr
;
20 struct lttng_process_attr_values
*inclusion_set
;
23 void lttng_process_attr_tracker_handle_destroy(
24 struct lttng_process_attr_tracker_handle
*tracker
)
30 lttng_process_attr_values_destroy(tracker
->inclusion_set
);
31 free(tracker
->session_name
);
35 enum lttng_error_code
lttng_session_get_tracker_handle(const char *session_name
,
36 enum lttng_domain_type domain
,
37 enum lttng_process_attr process_attr
,
38 struct lttng_process_attr_tracker_handle
**out_tracker_handle
)
40 enum lttng_error_code ret_code
= LTTNG_OK
;
41 struct lttng_process_attr_tracker_handle
*handle
= NULL
;
42 enum lttng_process_attr_tracker_handle_status status
;
43 enum lttng_tracking_policy policy
;
45 if (!session_name
|| !out_tracker_handle
) {
46 ret_code
= LTTNG_ERR_INVALID
;
50 if (domain
!= LTTNG_DOMAIN_KERNEL
&& domain
!= LTTNG_DOMAIN_UST
) {
51 ret_code
= LTTNG_ERR_UNSUPPORTED_DOMAIN
;
55 handle
= (lttng_process_attr_tracker_handle
*) zmalloc(sizeof(*handle
));
57 ret_code
= LTTNG_ERR_NOMEM
;
61 handle
->session_name
= strdup(session_name
);
62 if (!handle
->session_name
) {
63 ret_code
= LTTNG_ERR_NOMEM
;
67 handle
->domain
= domain
;
68 handle
->process_attr
= process_attr
;
71 * Use the `get_tracking_policy` command to validate the tracker's
74 status
= lttng_process_attr_tracker_handle_get_tracking_policy(
77 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
:
79 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST
:
80 ret_code
= LTTNG_ERR_SESSION_NOT_EXIST
;
83 ret_code
= LTTNG_ERR_UNK
;
87 *out_tracker_handle
= handle
;
90 lttng_process_attr_tracker_handle_destroy(handle
);
94 enum lttng_process_attr_tracker_handle_status
95 lttng_process_attr_tracker_handle_get_tracking_policy(
96 const struct lttng_process_attr_tracker_handle
*tracker
,
97 enum lttng_tracking_policy
*policy
)
100 int reply_ret
, copy_ret
;
101 enum lttng_process_attr_tracker_handle_status status
=
102 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
;
103 struct lttcomm_session_msg lsm
= {
104 .cmd_type
= LTTNG_PROCESS_ATTR_TRACKER_GET_POLICY
,
107 if (!tracker
|| !policy
) {
108 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID
;
112 copy_ret
= lttng_strncpy(lsm
.session
.name
, tracker
->session_name
,
113 sizeof(lsm
.session
.name
));
115 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID
;
119 lsm
.domain
.type
= tracker
->domain
;
120 lsm
.u
.process_attr_tracker_get_tracking_policy
.process_attr
=
121 (int32_t) tracker
->process_attr
;
123 /* Command returns a session descriptor on success. */
124 reply_ret
= lttng_ctl_ask_sessiond_varlen_no_cmd_header(
125 &lsm
, NULL
, 0, &reply
);
126 if (reply_ret
!= sizeof(uint32_t)) {
127 if (reply_ret
== -LTTNG_ERR_SESSION_NOT_EXIST
||
128 reply_ret
== -LTTNG_ERR_SESS_NOT_FOUND
) {
129 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST
;
131 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR
;
136 *policy
= (enum lttng_tracking_policy
)(*((const uint32_t *) reply
));
142 enum lttng_process_attr_tracker_handle_status
143 lttng_process_attr_tracker_handle_set_tracking_policy(
144 const struct lttng_process_attr_tracker_handle
*tracker
,
145 enum lttng_tracking_policy policy
)
147 int reply_ret
, copy_ret
;
148 enum lttng_process_attr_tracker_handle_status status
=
149 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
;
150 struct lttcomm_session_msg lsm
= {
151 .cmd_type
= LTTNG_PROCESS_ATTR_TRACKER_SET_POLICY
,
155 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID
;
159 copy_ret
= lttng_strncpy(lsm
.session
.name
, tracker
->session_name
,
160 sizeof(lsm
.session
.name
));
162 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID
;
166 lsm
.domain
.type
= tracker
->domain
;
167 lsm
.u
.process_attr_tracker_set_tracking_policy
.process_attr
=
168 (int32_t) tracker
->process_attr
;
169 lsm
.u
.process_attr_tracker_set_tracking_policy
.tracking_policy
=
172 /* Command returns a session descriptor on success. */
173 reply_ret
= lttng_ctl_ask_sessiond(&lsm
, NULL
);
175 if (reply_ret
== -LTTNG_ERR_SESSION_NOT_EXIST
) {
176 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST
;
178 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR
;
186 #define DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(command_upper, \
187 command_lower, process_attr_name, value_type_name, \
188 value_type_c, value_type_enum) \
189 enum lttng_process_attr_tracker_handle_status \
190 lttng_process_attr_##process_attr_name##_tracker_handle_##command_lower##_##value_type_name( \
191 const struct lttng_process_attr_tracker_handle \
193 value_type_c value) \
196 enum lttng_process_attr_tracker_handle_status status = \
197 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK; \
198 struct lttcomm_session_msg lsm = { \
199 .cmd_type = LTTNG_PROCESS_ATTR_TRACKER_##command_upper##_INCLUDE_VALUE}; \
202 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID; \
206 ret = lttng_strncpy(lsm.session.name, tracker->session_name, \
207 sizeof(lsm.session.name)); \
209 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID; \
213 lsm.domain.type = tracker->domain; \
214 lsm.u.process_attr_tracker_add_remove_include_value \
216 (int32_t) tracker->process_attr; \
217 lsm.u.process_attr_tracker_add_remove_include_value \
218 .value_type = (uint32_t) \
219 LTTNG_PROCESS_ATTR_VALUE_TYPE_##value_type_enum; \
221 if (std::is_signed<value_type_c>::value) { \
222 lsm.u.process_attr_tracker_add_remove_include_value \
223 .integral_value.u._signed = value; \
225 lsm.u.process_attr_tracker_add_remove_include_value \
226 .integral_value.u._unsigned = value; \
229 ret = lttng_ctl_ask_sessiond(&lsm, NULL); \
232 case LTTNG_ERR_PROCESS_ATTR_EXISTS: \
233 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_EXISTS; \
235 case LTTNG_ERR_PROCESS_ATTR_MISSING: \
236 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_MISSING; \
238 case LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY: \
239 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY; \
242 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR; \
249 #define DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(command_upper, \
250 command_lower, process_attr_name, value_type_name, \
252 enum lttng_process_attr_tracker_handle_status \
253 lttng_process_attr_##process_attr_name##_tracker_handle_##command_lower##_##value_type_name( \
254 const struct lttng_process_attr_tracker_handle \
259 enum lttng_process_attr_tracker_handle_status status = \
260 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK; \
261 struct lttcomm_session_msg lsm = { \
262 .cmd_type = LTTNG_PROCESS_ATTR_TRACKER_##command_upper##_INCLUDE_VALUE}; \
263 const size_t len = value ? strlen(value) + 1 : 0; \
265 if (!tracker || !value) { \
266 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID; \
270 ret = lttng_strncpy(lsm.session.name, tracker->session_name, \
271 sizeof(lsm.session.name)); \
273 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID; \
277 lsm.domain.type = tracker->domain; \
278 lsm.u.process_attr_tracker_add_remove_include_value \
280 (int32_t) tracker->process_attr; \
281 lsm.u.process_attr_tracker_add_remove_include_value.name_len = \
283 lsm.u.process_attr_tracker_add_remove_include_value \
284 .value_type = (uint32_t) \
285 LTTNG_PROCESS_ATTR_VALUE_TYPE_##value_type_enum; \
287 ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header( \
288 &lsm, value, len, NULL); \
291 case LTTNG_ERR_PROCESS_ATTR_EXISTS: \
292 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_EXISTS; \
294 case LTTNG_ERR_PROCESS_ATTR_MISSING: \
295 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_MISSING; \
297 case LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY: \
298 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY; \
300 case LTTNG_ERR_USER_NOT_FOUND: \
301 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_USER_NOT_FOUND; \
303 case LTTNG_ERR_GROUP_NOT_FOUND: \
304 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_GROUP_NOT_FOUND; \
307 status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR; \
315 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
316 ADD
, add
, process_id
, pid
, pid_t
, PID
);
317 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
318 REMOVE
, remove
, process_id
, pid
, pid_t
, PID
);
321 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
322 ADD
, add
, virtual_process_id
, pid
, pid_t
, PID
);
323 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
324 REMOVE
, remove
, virtual_process_id
, pid
, pid_t
, PID
);
327 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
328 ADD
, add
, user_id
, uid
, uid_t
, UID
);
329 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
330 REMOVE
, remove
, user_id
, uid
, uid_t
, UID
);
331 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
332 ADD
, add
, user_id
, user_name
, USER_NAME
);
333 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
334 REMOVE
, remove
, user_id
, user_name
, USER_NAME
);
337 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
338 ADD
, add
, virtual_user_id
, uid
, uid_t
, UID
);
339 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
340 REMOVE
, remove
, virtual_user_id
, uid
, uid_t
, UID
);
341 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
342 ADD
, add
, virtual_user_id
, user_name
, USER_NAME
);
343 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
344 REMOVE
, remove
, virtual_user_id
, user_name
, USER_NAME
);
347 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
348 ADD
, add
, group_id
, gid
, gid_t
, GID
);
349 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
350 REMOVE
, remove
, group_id
, gid
, gid_t
, GID
);
351 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
352 ADD
, add
, group_id
, group_name
, GROUP_NAME
);
353 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
354 REMOVE
, remove
, group_id
, group_name
, GROUP_NAME
);
357 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
358 ADD
, add
, virtual_group_id
, gid
, gid_t
, GID
);
359 DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
360 REMOVE
, remove
, virtual_group_id
, gid
, gid_t
, GID
);
361 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
362 ADD
, add
, virtual_group_id
, group_name
, GROUP_NAME
);
363 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
364 REMOVE
, remove
, virtual_group_id
, group_name
, GROUP_NAME
);
366 enum lttng_process_attr_tracker_handle_status
367 lttng_process_attr_tracker_handle_get_inclusion_set(
368 struct lttng_process_attr_tracker_handle
*tracker
,
369 const struct lttng_process_attr_values
**values
)
372 int reply_ret
, copy_ret
;
373 enum lttng_process_attr_tracker_handle_status status
=
374 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
;
375 struct lttcomm_session_msg lsm
= {
376 .cmd_type
= LTTNG_PROCESS_ATTR_TRACKER_GET_INCLUSION_SET
,
378 struct lttng_buffer_view inclusion_set_view
;
379 ssize_t inclusion_set_ret
;
381 if (!tracker
|| !values
) {
382 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID
;
386 lttng_process_attr_values_destroy(tracker
->inclusion_set
);
387 tracker
->inclusion_set
= NULL
;
389 copy_ret
= lttng_strncpy(lsm
.session
.name
, tracker
->session_name
,
390 sizeof(lsm
.session
.name
));
392 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID
;
396 lsm
.domain
.type
= tracker
->domain
;
397 lsm
.u
.process_attr_tracker_get_tracking_policy
.process_attr
=
398 (int32_t) tracker
->process_attr
;
400 /* Command returns a session descriptor on success. */
401 reply_ret
= lttng_ctl_ask_sessiond_varlen_no_cmd_header(
402 &lsm
, NULL
, 0, (void **) &reply
);
404 if (reply_ret
== -LTTNG_ERR_SESSION_NOT_EXIST
) {
405 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST
;
406 } else if (reply_ret
==
407 -LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY
) {
408 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY
;
410 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR
;
413 } else if (reply_ret
== 0) {
414 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR
;
418 inclusion_set_view
= lttng_buffer_view_init(reply
, 0, reply_ret
);
419 if (!inclusion_set_view
.data
) {
420 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR
;
424 inclusion_set_ret
= lttng_process_attr_values_create_from_buffer(
425 tracker
->domain
, tracker
->process_attr
,
426 &inclusion_set_view
, &tracker
->inclusion_set
);
427 if (inclusion_set_ret
< 0) {
428 status
= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR
;
431 *values
= tracker
->inclusion_set
;
437 enum lttng_process_attr_values_status
lttng_process_attr_values_get_count(
438 const struct lttng_process_attr_values
*values
,
441 enum lttng_process_attr_values_status status
=
442 LTTNG_PROCESS_ATTR_VALUES_STATUS_OK
;
444 if (!values
|| !count
) {
445 status
= LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID
;
449 *count
= _lttng_process_attr_values_get_count(values
);
454 enum lttng_process_attr_value_type
lttng_process_attr_values_get_type_at_index(
455 const struct lttng_process_attr_values
*values
,
458 enum lttng_process_attr_value_type type
;
459 const struct process_attr_value
*value
;
462 type
= LTTNG_PROCESS_ATTR_VALUE_TYPE_INVALID
;
466 if (_lttng_process_attr_values_get_count(values
) <= index
) {
467 type
= LTTNG_PROCESS_ATTR_VALUE_TYPE_INVALID
;
471 value
= lttng_process_attr_tracker_values_get_at_index(values
, index
);
477 #define DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER( \
478 value_type_name, value_type, expected_value_type) \
479 enum lttng_process_attr_values_status \
480 lttng_process_attr_values_get_##value_type_name##_at_index( \
481 const struct lttng_process_attr_values \
483 unsigned int index, \
484 value_type *out_value) \
486 enum lttng_process_attr_values_status status = \
487 LTTNG_PROCESS_ATTR_VALUES_STATUS_OK; \
488 const struct process_attr_value *value; \
491 status = LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID; \
495 if (_lttng_process_attr_values_get_count(values) <= index) { \
496 status = LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID; \
500 value = lttng_process_attr_tracker_values_get_at_index( \
503 LTTNG_PROCESS_ATTR_VALUE_TYPE_##expected_value_type) { \
504 status = LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID_TYPE; \
507 *out_value = value->value.value_type_name; \
512 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(pid
, pid_t
, PID
);
513 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(uid
, uid_t
, UID
);
514 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(gid
, gid_t
, GID
);
515 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(user_name
, const char *, USER_NAME
);
516 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(group_name
, const char *, GROUP_NAME
);
518 static enum lttng_error_code
handle_status_to_error_code(
519 enum lttng_process_attr_tracker_handle_status handle_status
)
521 switch (handle_status
) {
522 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY
:
523 return LTTNG_ERR_INVALID
;
524 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST
:
525 return LTTNG_ERR_SESSION_NOT_EXIST
;
526 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR
:
527 return LTTNG_ERR_INVALID_PROTOCOL
;
528 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_EXISTS
:
529 return LTTNG_ERR_PID_TRACKED
;
530 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_MISSING
:
531 return LTTNG_ERR_PID_NOT_TRACKED
;
532 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
:
534 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR
:
537 return LTTNG_ERR_UNK
;
542 * Add PID to session tracker.
543 * Return 0 on success else a negative LTTng error code.
545 int lttng_track_pid(struct lttng_handle
*handle
, int pid
)
547 enum lttng_error_code ret_code
;
548 struct lttng_process_attr_tracker_handle
*tracker_handle
= NULL
;
549 enum lttng_process_attr_tracker_handle_status handle_status
;
550 enum lttng_tracking_policy policy
;
551 enum lttng_process_attr process_attr
;
554 ret_code
= LTTNG_ERR_INVALID
;
558 process_attr
= handle
->domain
.type
== LTTNG_DOMAIN_KERNEL
?
559 LTTNG_PROCESS_ATTR_PROCESS_ID
:
560 LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
;
562 ret_code
= lttng_session_get_tracker_handle(handle
->session_name
,
564 process_attr
, &tracker_handle
);
565 if (ret_code
!= LTTNG_OK
) {
570 handle_status
= lttng_process_attr_tracker_handle_set_tracking_policy(
572 LTTNG_TRACKING_POLICY_INCLUDE_ALL
);
573 ret_code
= handle_status_to_error_code(handle_status
);
577 handle_status
= lttng_process_attr_tracker_handle_get_tracking_policy(
578 tracker_handle
, &policy
);
579 if (handle_status
!= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
) {
580 ret_code
= handle_status_to_error_code(handle_status
);
584 if (policy
!= LTTNG_TRACKING_POLICY_INCLUDE_SET
) {
585 handle_status
= lttng_process_attr_tracker_handle_set_tracking_policy(
587 LTTNG_TRACKING_POLICY_INCLUDE_SET
);
588 if (handle_status
!= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
) {
589 ret_code
= handle_status_to_error_code(handle_status
);
594 handle_status
= process_attr
== LTTNG_PROCESS_ATTR_PROCESS_ID
?
595 lttng_process_attr_process_id_tracker_handle_add_pid(
598 lttng_process_attr_virtual_process_id_tracker_handle_add_pid(
601 ret_code
= handle_status_to_error_code(handle_status
);
603 lttng_process_attr_tracker_handle_destroy(tracker_handle
);
604 return ret_code
== LTTNG_OK
? 0 : -ret_code
;
608 * Remove PID from session tracker.
609 * Return 0 on success else a negative LTTng error code.
611 int lttng_untrack_pid(struct lttng_handle
*handle
, int pid
)
613 enum lttng_error_code ret_code
;
614 struct lttng_process_attr_tracker_handle
*tracker_handle
= NULL
;
615 enum lttng_process_attr_tracker_handle_status handle_status
;
616 enum lttng_tracking_policy policy
;
617 enum lttng_process_attr process_attr
;
620 ret_code
= LTTNG_ERR_INVALID
;
624 process_attr
= handle
->domain
.type
== LTTNG_DOMAIN_KERNEL
?
625 LTTNG_PROCESS_ATTR_PROCESS_ID
:
626 LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
;
627 ret_code
= lttng_session_get_tracker_handle(handle
->session_name
,
628 handle
->domain
.type
, process_attr
, &tracker_handle
);
629 if (ret_code
!= LTTNG_OK
) {
634 handle_status
= lttng_process_attr_tracker_handle_set_tracking_policy(
636 LTTNG_TRACKING_POLICY_EXCLUDE_ALL
);
637 ret_code
= handle_status_to_error_code(handle_status
);
641 handle_status
= lttng_process_attr_tracker_handle_get_tracking_policy(
642 tracker_handle
, &policy
);
643 if (handle_status
!= LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
) {
644 ret_code
= handle_status_to_error_code(handle_status
);
648 if (policy
== LTTNG_TRACKING_POLICY_EXCLUDE_ALL
) {
649 ret_code
= LTTNG_ERR_PID_NOT_TRACKED
;
651 } else if (policy
== LTTNG_TRACKING_POLICY_INCLUDE_ALL
) {
652 ret_code
= LTTNG_ERR_INVALID
;
656 handle_status
= process_attr
== LTTNG_PROCESS_ATTR_PROCESS_ID
?
657 lttng_process_attr_process_id_tracker_handle_remove_pid(
660 lttng_process_attr_virtual_process_id_tracker_handle_remove_pid(
663 if (handle_status
== LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY
) {
664 ret_code
= LTTNG_ERR_PID_NOT_TRACKED
;
667 lttng_process_attr_tracker_handle_destroy(tracker_handle
);
668 return ret_code
== LTTNG_OK
? 0 : -ret_code
;
672 * List PIDs in the tracker.
674 * enabled is set to whether the PID tracker is enabled.
675 * pids is set to an allocated array of PIDs currently tracked. On
676 * success, pids must be freed by the caller.
677 * nr_pids is set to the number of entries contained by the pids array.
679 * Returns 0 on success, else a negative LTTng error code.
681 int lttng_list_tracker_pids(struct lttng_handle
*handle
,
686 enum lttng_error_code ret_code
;
687 struct lttng_process_attr_tracker_handle
*tracker_handle
= NULL
;
688 enum lttng_process_attr_tracker_handle_status handle_status
;
689 const struct lttng_process_attr_values
*values
;
690 enum lttng_tracking_policy policy
;
691 unsigned int pid_count
, i
;
692 int32_t *pid_array
= NULL
;
694 if (!handle
|| !_enabled
|| !_pids
|| !_nr_pids
) {
695 ret_code
= LTTNG_ERR_INVALID
;
699 ret_code
= lttng_session_get_tracker_handle(handle
->session_name
,
701 LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
, &tracker_handle
);
702 if (ret_code
!= LTTNG_OK
) {
707 handle_status
= lttng_process_attr_tracker_handle_get_inclusion_set(
708 tracker_handle
, &values
);
710 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
) {
711 policy
= LTTNG_TRACKING_POLICY_INCLUDE_SET
;
713 } else if (handle_status
!=
714 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY
) {
715 ret_code
= handle_status_to_error_code(handle_status
);
719 handle_status
= lttng_process_attr_tracker_handle_get_tracking_policy(
720 tracker_handle
, &policy
);
722 LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
) {
723 ret_code
= handle_status_to_error_code(handle_status
);
727 /* Tracking policy changed in the meantime, retry. */
728 if (policy
== LTTNG_TRACKING_POLICY_INCLUDE_SET
) {
735 case LTTNG_TRACKING_POLICY_INCLUDE_ALL
:
738 case LTTNG_TRACKING_POLICY_EXCLUDE_ALL
:
742 case LTTNG_TRACKING_POLICY_INCLUDE_SET
:
744 const enum lttng_process_attr_values_status values_status
=
745 lttng_process_attr_values_get_count(
748 if (values_status
!= LTTNG_PROCESS_ATTR_VALUES_STATUS_OK
) {
749 ret_code
= LTTNG_ERR_UNK
;
755 ret_code
= LTTNG_ERR_INVALID_PROTOCOL
;
759 pid_array
= (int32_t *) zmalloc(pid_count
* sizeof(int32_t));
761 ret_code
= LTTNG_ERR_NOMEM
;
765 /* Extract values to a raw array. */
766 for (i
= 0; i
< pid_count
; i
++) {
768 const enum lttng_process_attr_values_status values_status
=
769 lttng_process_attr_values_get_pid_at_index(
772 if (values_status
!= LTTNG_PROCESS_ATTR_VALUES_STATUS_OK
) {
773 ret_code
= LTTNG_ERR_UNK
;
776 pid_array
[i
] = (int32_t) pid
;
778 *_nr_pids
= (size_t) pid_count
;
782 lttng_process_attr_tracker_handle_destroy(tracker_handle
);
784 return ret_code
== LTTNG_OK
? 0 : -ret_code
;