2 * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
4 * SPDX-License-Identifier: GPL-2.0-only
15 #include <sys/types.h>
17 #include <common/common.h>
18 #include <common/hashtable/utils.h>
19 #include <common/trace-chunk.h>
20 #include <common/kernel-ctl/kernel-ctl.h>
21 #include <common/kernel-ctl/kernel-ioctl.h>
22 #include <common/sessiond-comm/sessiond-comm.h>
23 #include <common/tracker.h>
24 #include <common/utils.h>
25 #include <lttng/event.h>
26 #include <lttng/lttng-error.h>
27 #include <lttng/tracker.h>
29 #include <lttng/userspace-probe.h>
30 #include <lttng/userspace-probe-internal.h>
31 #include <lttng/condition/on-event.h>
32 #include <lttng/condition/on-event-internal.h>
33 #include <lttng/event-rule/event-rule.h>
34 #include <lttng/event-rule/event-rule-internal.h>
35 #include <lttng/event-rule/userspace-probe-internal.h>
36 #include <lttng/map/map.h>
37 #include <lttng/map/map-internal.h>
38 #include <lttng/map/map-query-internal.h>
39 #include <lttng/map-key.h>
40 #include <lttng/map-key-internal.h>
42 #include "event-notifier-error-accounting.h"
43 #include "lttng-sessiond.h"
44 #include "lttng-syscall.h"
45 #include "condition-internal.h"
48 #include "kernel-consumer.h"
49 #include "kern-modules.h"
51 #include "sessiond-config.h"
56 #include "notification-thread-commands.h"
59 * Key used to reference a channel between the sessiond and the consumer. This
60 * is only read and updated with the session_list lock held.
62 static uint64_t next_kernel_channel_key
;
64 static const char *module_proc_lttng
= "/proc/lttng";
66 static int kernel_tracer_fd
= -1;
67 static int kernel_tracer_event_notifier_group_fd
= -1;
68 static int kernel_tracer_event_notifier_group_notification_fd
= -1;
69 static struct cds_lfht
*kernel_token_to_event_notifier_rule_ht
;
72 * Add context on a kernel channel.
74 * Assumes the ownership of ctx.
76 int kernel_add_channel_context(struct ltt_kernel_channel
*chan
,
77 struct ltt_kernel_context
*ctx
)
84 DBG("Adding context to channel %s", chan
->channel
->name
);
85 ret
= kernctl_add_context(chan
->fd
, &ctx
->ctx
);
89 /* Exists but not available for this kernel */
90 ret
= LTTNG_ERR_KERN_CONTEXT_UNAVAILABLE
;
93 /* If EEXIST, we just ignore the error */
97 PERROR("add context ioctl");
98 ret
= LTTNG_ERR_KERN_CONTEXT_FAIL
;
105 cds_list_add_tail(&ctx
->list
, &chan
->ctx_list
);
110 trace_kernel_destroy_context(ctx
);
116 * Create a new kernel session, register it to the kernel tracer and add it to
117 * the session daemon session.
119 int kernel_create_session(struct ltt_session
*session
)
122 struct ltt_kernel_session
*lks
;
126 /* Allocate data structure */
127 lks
= trace_kernel_create_session();
133 /* Kernel tracer session creation */
134 ret
= kernctl_create_session(kernel_tracer_fd
);
136 PERROR("ioctl kernel create session");
141 /* Prevent fd duplication after execlp() */
142 ret
= fcntl(lks
->fd
, F_SETFD
, FD_CLOEXEC
);
144 PERROR("fcntl session fd");
147 lks
->id
= session
->id
;
148 lks
->consumer_fds_sent
= 0;
149 session
->kernel_session
= lks
;
151 DBG("Kernel session created (fd: %d)", lks
->fd
);
154 * This is necessary since the creation time is present in the session
155 * name when it is generated.
157 if (session
->has_auto_generated_name
) {
158 ret
= kernctl_session_set_name(lks
->fd
, DEFAULT_SESSION_NAME
);
160 ret
= kernctl_session_set_name(lks
->fd
, session
->name
);
163 WARN("Could not set kernel session name for session %" PRIu64
" name: %s",
164 session
->id
, session
->name
);
167 ret
= kernctl_session_set_creation_time(lks
->fd
, session
->creation_time
);
169 WARN("Could not set kernel session creation time for session %" PRIu64
" name: %s",
170 session
->id
, session
->name
);
177 trace_kernel_destroy_session(lks
);
178 trace_kernel_free_session(lks
);
184 * Create a kernel channel, register it to the kernel tracer and add it to the
187 int kernel_create_channel(struct ltt_kernel_session
*session
,
188 struct lttng_channel
*chan
)
191 struct ltt_kernel_channel
*lkc
;
196 /* Allocate kernel channel */
197 lkc
= trace_kernel_create_channel(chan
);
202 DBG3("Kernel create channel %s with attr: %d, %" PRIu64
", %" PRIu64
", %u, %u, %d, %d",
203 chan
->name
, lkc
->channel
->attr
.overwrite
,
204 lkc
->channel
->attr
.subbuf_size
, lkc
->channel
->attr
.num_subbuf
,
205 lkc
->channel
->attr
.switch_timer_interval
, lkc
->channel
->attr
.read_timer_interval
,
206 lkc
->channel
->attr
.live_timer_interval
, lkc
->channel
->attr
.output
);
208 /* Kernel tracer channel creation */
209 ret
= kernctl_create_channel(session
->fd
, &lkc
->channel
->attr
);
211 PERROR("ioctl kernel create channel");
215 /* Setup the channel fd */
217 /* Prevent fd duplication after execlp() */
218 ret
= fcntl(lkc
->fd
, F_SETFD
, FD_CLOEXEC
);
220 PERROR("fcntl session fd");
223 /* Add channel to session */
224 cds_list_add(&lkc
->list
, &session
->channel_list
.head
);
225 session
->channel_count
++;
226 lkc
->session
= session
;
227 lkc
->key
= ++next_kernel_channel_key
;
229 DBG("Kernel channel %s created (fd: %d, key: %" PRIu64
")",
230 lkc
->channel
->name
, lkc
->fd
, lkc
->key
);
243 * Create a kernel event notifier group, register it to the kernel tracer and
244 * add it to the kernel session.
246 static int kernel_create_event_notifier_group(int *event_notifier_group_fd
)
251 assert(event_notifier_group_fd
);
253 /* Kernel event notifier group creation. */
254 ret
= kernctl_create_event_notifier_group(kernel_tracer_fd
);
256 PERROR("Failed to create kernel event notifier group");
263 /* Prevent fd duplication after execlp(). */
264 ret
= fcntl(local_fd
, F_SETFD
, FD_CLOEXEC
);
266 PERROR("Failed to set FD_CLOEXEC on kernel event notifier group file descriptor: fd = %d",
271 DBG("Created kernel event notifier group: fd = %d", local_fd
);
272 *event_notifier_group_fd
= local_fd
;
277 ret
= close(local_fd
);
279 PERROR("Failed to close kernel event notifier group file descriptor: fd = %d",
288 * Compute the offset of the instrumentation byte in the binary based on the
289 * function probe location using the ELF lookup method.
291 * Returns 0 on success and set the offset out parameter to the offset of the
293 * Returns -1 on error
296 int extract_userspace_probe_offset_function_elf(
297 const struct lttng_userspace_probe_location
*probe_location
,
298 uid_t uid
, gid_t gid
, uint64_t *offset
)
302 const char *symbol
= NULL
;
303 const struct lttng_userspace_probe_location_lookup_method
*lookup
= NULL
;
304 enum lttng_userspace_probe_location_lookup_method_type lookup_method_type
;
306 assert(lttng_userspace_probe_location_get_type(probe_location
) ==
307 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION
);
309 lookup
= lttng_userspace_probe_location_get_lookup_method(
317 lttng_userspace_probe_location_lookup_method_get_type(lookup
);
319 assert(lookup_method_type
==
320 LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF
);
322 symbol
= lttng_userspace_probe_location_function_get_function_name(
329 fd
= lttng_userspace_probe_location_function_get_binary_fd(probe_location
);
335 ret
= run_as_extract_elf_symbol_offset(fd
, symbol
, uid
, gid
, offset
);
337 DBG("userspace probe offset calculation failed for "
338 "function %s", symbol
);
342 DBG("userspace probe elf offset for %s is 0x%jd", symbol
, (intmax_t)(*offset
));
348 * Compute the offsets of the instrumentation bytes in the binary based on the
349 * tracepoint probe location using the SDT lookup method. This function
350 * allocates the offsets buffer, the caller must free it.
352 * Returns 0 on success and set the offset out parameter to the offsets of the
354 * Returns -1 on error.
357 int extract_userspace_probe_offset_tracepoint_sdt(
358 const struct lttng_userspace_probe_location
*probe_location
,
359 uid_t uid
, gid_t gid
, uint64_t **offsets
,
360 uint32_t *offsets_count
)
362 enum lttng_userspace_probe_location_lookup_method_type lookup_method_type
;
363 const struct lttng_userspace_probe_location_lookup_method
*lookup
= NULL
;
364 const char *probe_name
= NULL
, *provider_name
= NULL
;
368 assert(lttng_userspace_probe_location_get_type(probe_location
) ==
369 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT
);
371 lookup
= lttng_userspace_probe_location_get_lookup_method(probe_location
);
378 lttng_userspace_probe_location_lookup_method_get_type(lookup
);
380 assert(lookup_method_type
==
381 LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT
);
384 probe_name
= lttng_userspace_probe_location_tracepoint_get_probe_name(
391 provider_name
= lttng_userspace_probe_location_tracepoint_get_provider_name(
393 if (!provider_name
) {
398 fd
= lttng_userspace_probe_location_tracepoint_get_binary_fd(probe_location
);
404 ret
= run_as_extract_sdt_probe_offsets(fd
, provider_name
, probe_name
,
405 uid
, gid
, offsets
, offsets_count
);
407 DBG("userspace probe offset calculation failed for sdt "
408 "probe %s:%s", provider_name
, probe_name
);
412 if (*offsets_count
== 0) {
413 DBG("no userspace probe offset found");
417 DBG("%u userspace probe SDT offsets found for %s:%s at:",
418 *offsets_count
, provider_name
, probe_name
);
419 for (i
= 0; i
< *offsets_count
; i
++) {
420 DBG("\t0x%jd", (intmax_t)((*offsets
)[i
]));
427 int userspace_probe_add_callsite(
428 const struct lttng_userspace_probe_location
*location
,
429 uid_t uid
, gid_t gid
, int fd
)
431 const struct lttng_userspace_probe_location_lookup_method
*lookup_method
= NULL
;
432 enum lttng_userspace_probe_location_lookup_method_type type
;
435 lookup_method
= lttng_userspace_probe_location_get_lookup_method(location
);
436 if (!lookup_method
) {
441 type
= lttng_userspace_probe_location_lookup_method_get_type(lookup_method
);
443 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF
:
445 struct lttng_kernel_event_callsite callsite
;
448 ret
= extract_userspace_probe_offset_function_elf(location
,
451 ret
= LTTNG_ERR_PROBE_LOCATION_INVAL
;
455 callsite
.u
.uprobe
.offset
= offset
;
456 ret
= kernctl_add_callsite(fd
, &callsite
);
458 WARN("Failed to add callsite to ELF userspace probe.");
459 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
464 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT
:
467 uint64_t *offsets
= NULL
;
468 uint32_t offsets_count
;
469 struct lttng_kernel_event_callsite callsite
;
472 * This call allocates the offsets buffer. This buffer must be freed
475 ret
= extract_userspace_probe_offset_tracepoint_sdt(location
,
476 uid
, gid
, &offsets
, &offsets_count
);
478 ret
= LTTNG_ERR_PROBE_LOCATION_INVAL
;
481 for (i
= 0; i
< offsets_count
; i
++) {
482 callsite
.u
.uprobe
.offset
= offsets
[i
];
483 ret
= kernctl_add_callsite(fd
, &callsite
);
485 WARN("Failed to add callsite to SDT userspace probe");
486 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
495 ret
= LTTNG_ERR_PROBE_LOCATION_INVAL
;
503 * Extract the offsets of the instrumentation point for the different lookup
507 int userspace_probe_event_add_callsites(struct lttng_event
*ev
,
508 struct ltt_kernel_session
*session
, int fd
)
511 const struct lttng_userspace_probe_location
*location
= NULL
;
514 assert(ev
->type
== LTTNG_EVENT_USERSPACE_PROBE
);
516 location
= lttng_event_get_userspace_probe_location(ev
);
522 ret
= userspace_probe_add_callsite(location
, session
->uid
, session
->gid
,
525 WARN("Failed to add callsite to userspace probe event '%s'",
534 * Extract the offsets of the instrumentation point for the different look-up
537 static int userspace_probe_event_rule_add_callsites(
538 const struct lttng_event_rule
*rule
,
539 const struct lttng_credentials
*creds
,
543 enum lttng_event_rule_status status
;
544 enum lttng_event_rule_type event_rule_type
;
545 const struct lttng_userspace_probe_location
*location
= NULL
;
550 event_rule_type
= lttng_event_rule_get_type(rule
);
551 assert(event_rule_type
== LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE
);
553 status
= lttng_event_rule_userspace_probe_get_location(rule
, &location
);
554 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
|| !location
) {
559 ret
= userspace_probe_add_callsite(location
,
560 lttng_credentials_get_uid(creds
),
561 lttng_credentials_get_gid(creds
), fd
);
563 WARN("Failed to add callsite to user space probe object: fd = %d",
572 * Create a kernel event, enable it to the kernel tracer and add it to the
573 * channel event list of the kernel session.
574 * We own filter_expression and filter.
576 int kernel_create_event(struct lttng_event
*ev
,
577 struct ltt_kernel_channel
*channel
,
578 char *filter_expression
,
579 struct lttng_bytecode
*filter
)
582 enum lttng_error_code ret
;
583 struct ltt_kernel_event
*event
;
588 /* We pass ownership of filter_expression and filter */
589 ret
= trace_kernel_create_event(ev
, filter_expression
,
591 if (ret
!= LTTNG_OK
) {
595 fd
= kernctl_create_event(channel
->fd
, event
->event
);
599 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
602 WARN("Event type not implemented");
603 ret
= LTTNG_ERR_KERN_EVENT_ENOSYS
;
606 WARN("Event %s not found!", ev
->name
);
607 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
610 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
611 PERROR("create event ioctl");
616 event
->type
= ev
->type
;
618 /* Prevent fd duplication after execlp() */
619 err
= fcntl(event
->fd
, F_SETFD
, FD_CLOEXEC
);
621 PERROR("fcntl session fd");
625 err
= kernctl_filter(event
->fd
, filter
);
629 ret
= LTTNG_ERR_FILTER_NOMEM
;
632 ret
= LTTNG_ERR_FILTER_INVAL
;
639 if (ev
->type
== LTTNG_EVENT_USERSPACE_PROBE
) {
640 ret
= userspace_probe_event_add_callsites(ev
, channel
->session
,
643 goto add_callsite_error
;
647 err
= kernctl_enable(event
->fd
);
651 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
654 PERROR("enable kernel event");
655 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
661 /* Add event to event list */
662 cds_list_add(&event
->list
, &channel
->events_list
.head
);
663 channel
->event_count
++;
665 DBG("Event %s created (fd: %d)", ev
->name
, event
->fd
);
675 closeret
= close(event
->fd
);
677 PERROR("close event fd");
687 * Disable a kernel channel.
689 int kernel_disable_channel(struct ltt_kernel_channel
*chan
)
695 ret
= kernctl_disable(chan
->fd
);
697 PERROR("disable chan ioctl");
702 DBG("Kernel channel %s disabled (fd: %d, key: %" PRIu64
")",
703 chan
->channel
->name
, chan
->fd
, chan
->key
);
712 * Enable a kernel channel.
714 int kernel_enable_channel(struct ltt_kernel_channel
*chan
)
720 ret
= kernctl_enable(chan
->fd
);
721 if (ret
< 0 && ret
!= -EEXIST
) {
722 PERROR("Enable kernel chan");
727 DBG("Kernel channel %s enabled (fd: %d, key: %" PRIu64
")",
728 chan
->channel
->name
, chan
->fd
, chan
->key
);
737 * Enable a kernel event.
739 int kernel_enable_event(struct ltt_kernel_event
*event
)
745 ret
= kernctl_enable(event
->fd
);
749 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
752 PERROR("enable kernel event");
759 DBG("Kernel event %s enabled (fd: %d)", event
->event
->name
, event
->fd
);
768 * Disable a kernel event.
770 int kernel_disable_event(struct ltt_kernel_event
*event
)
776 ret
= kernctl_disable(event
->fd
);
780 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
783 PERROR("disable kernel event");
790 DBG("Kernel event %s disabled (fd: %d)", event
->event
->name
, event
->fd
);
799 * Disable a kernel event notifier.
802 int kernel_disable_event_notifier_rule(struct ltt_kernel_event_notifier_rule
*event
)
809 cds_lfht_del(kernel_token_to_event_notifier_rule_ht
, &event
->ht_node
);
812 ret
= kernctl_disable(event
->fd
);
816 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
819 PERROR("Failed to disable kernel event notifier: fd = %d, token = %" PRIu64
,
820 event
->fd
, event
->token
);
827 DBG("Disabled kernel event notifier: fd = %d, token = %" PRIu64
,
828 event
->fd
, event
->token
);
835 struct process_attr_tracker
*_kernel_get_process_attr_tracker(
836 struct ltt_kernel_session
*session
,
837 enum lttng_process_attr process_attr
)
839 switch (process_attr
) {
840 case LTTNG_PROCESS_ATTR_PROCESS_ID
:
841 return session
->tracker_pid
;
842 case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
:
843 return session
->tracker_vpid
;
844 case LTTNG_PROCESS_ATTR_USER_ID
:
845 return session
->tracker_uid
;
846 case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID
:
847 return session
->tracker_vuid
;
848 case LTTNG_PROCESS_ATTR_GROUP_ID
:
849 return session
->tracker_gid
;
850 case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID
:
851 return session
->tracker_vgid
;
857 const struct process_attr_tracker
*kernel_get_process_attr_tracker(
858 struct ltt_kernel_session
*session
,
859 enum lttng_process_attr process_attr
)
861 return (const struct process_attr_tracker
*)
862 _kernel_get_process_attr_tracker(session
, process_attr
);
865 enum lttng_error_code
kernel_process_attr_tracker_set_tracking_policy(
866 struct ltt_kernel_session
*session
,
867 enum lttng_process_attr process_attr
,
868 enum lttng_tracking_policy policy
)
871 enum lttng_error_code ret_code
= LTTNG_OK
;
872 struct process_attr_tracker
*tracker
=
873 _kernel_get_process_attr_tracker(session
, process_attr
);
874 enum lttng_tracking_policy previous_policy
;
877 ret_code
= LTTNG_ERR_INVALID
;
881 previous_policy
= process_attr_tracker_get_tracking_policy(tracker
);
882 ret
= process_attr_tracker_set_tracking_policy(tracker
, policy
);
884 ret_code
= LTTNG_ERR_UNK
;
888 if (previous_policy
== policy
) {
893 case LTTNG_TRACKING_POLICY_INCLUDE_ALL
:
894 if (process_attr
== LTTNG_PROCESS_ATTR_PROCESS_ID
) {
896 * Maintain a special case for the process ID process
897 * attribute tracker as it was the only supported
898 * attribute prior to 2.12.
900 ret
= kernctl_track_pid(session
->fd
, -1);
902 ret
= kernctl_track_id(session
->fd
, process_attr
, -1);
905 case LTTNG_TRACKING_POLICY_EXCLUDE_ALL
:
906 case LTTNG_TRACKING_POLICY_INCLUDE_SET
:
908 if (process_attr
== LTTNG_PROCESS_ATTR_PROCESS_ID
) {
910 * Maintain a special case for the process ID process
911 * attribute tracker as it was the only supported
912 * attribute prior to 2.12.
914 ret
= kernctl_untrack_pid(session
->fd
, -1);
916 ret
= kernctl_untrack_id(session
->fd
, process_attr
, -1);
922 /* kern-ctl error handling */
928 ret_code
= LTTNG_ERR_INVALID
;
931 ret_code
= LTTNG_ERR_NOMEM
;
934 ret_code
= LTTNG_ERR_PROCESS_ATTR_EXISTS
;
937 ret_code
= LTTNG_ERR_UNK
;
944 enum lttng_error_code
kernel_process_attr_tracker_inclusion_set_add_value(
945 struct ltt_kernel_session
*session
,
946 enum lttng_process_attr process_attr
,
947 const struct process_attr_value
*value
)
949 int ret
, integral_value
;
950 enum lttng_error_code ret_code
;
951 struct process_attr_tracker
*tracker
;
952 enum process_attr_tracker_status status
;
955 * Convert process attribute tracker value to the integral
956 * representation required by the kern-ctl API.
958 switch (process_attr
) {
959 case LTTNG_PROCESS_ATTR_PROCESS_ID
:
960 case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
:
961 integral_value
= (int) value
->value
.pid
;
963 case LTTNG_PROCESS_ATTR_USER_ID
:
964 case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID
:
965 if (value
->type
== LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME
) {
968 ret_code
= utils_user_id_from_name(
969 value
->value
.user_name
, &uid
);
970 if (ret_code
!= LTTNG_OK
) {
973 integral_value
= (int) uid
;
975 integral_value
= (int) value
->value
.uid
;
978 case LTTNG_PROCESS_ATTR_GROUP_ID
:
979 case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID
:
980 if (value
->type
== LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME
) {
983 ret_code
= utils_group_id_from_name(
984 value
->value
.group_name
, &gid
);
985 if (ret_code
!= LTTNG_OK
) {
988 integral_value
= (int) gid
;
990 integral_value
= (int) value
->value
.gid
;
994 ret_code
= LTTNG_ERR_INVALID
;
998 tracker
= _kernel_get_process_attr_tracker(session
, process_attr
);
1000 ret_code
= LTTNG_ERR_INVALID
;
1004 status
= process_attr_tracker_inclusion_set_add_value(tracker
, value
);
1005 if (status
!= PROCESS_ATTR_TRACKER_STATUS_OK
) {
1007 case PROCESS_ATTR_TRACKER_STATUS_EXISTS
:
1008 ret_code
= LTTNG_ERR_PROCESS_ATTR_EXISTS
;
1010 case PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY
:
1011 ret_code
= LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY
;
1013 case PROCESS_ATTR_TRACKER_STATUS_ERROR
:
1015 ret_code
= LTTNG_ERR_UNK
;
1021 DBG("Kernel track %s %d for session id %" PRIu64
,
1022 lttng_process_attr_to_string(process_attr
),
1023 integral_value
, session
->id
);
1024 if (process_attr
== LTTNG_PROCESS_ATTR_PROCESS_ID
) {
1026 * Maintain a special case for the process ID process attribute
1027 * tracker as it was the only supported attribute prior to 2.12.
1029 ret
= kernctl_track_pid(session
->fd
, integral_value
);
1031 ret
= kernctl_track_id(
1032 session
->fd
, process_attr
, integral_value
);
1035 ret_code
= LTTNG_OK
;
1039 kernel_wait_quiescent();
1041 /* kern-ctl error handling */
1044 ret_code
= LTTNG_OK
;
1047 ret_code
= LTTNG_ERR_INVALID
;
1050 ret_code
= LTTNG_ERR_NOMEM
;
1053 ret_code
= LTTNG_ERR_PROCESS_ATTR_EXISTS
;
1056 ret_code
= LTTNG_ERR_UNK
;
1060 /* Attempt to remove the value from the tracker. */
1061 status
= process_attr_tracker_inclusion_set_remove_value(
1063 if (status
!= PROCESS_ATTR_TRACKER_STATUS_OK
) {
1064 ERR("Failed to roll-back the tracking of kernel %s process attribute %d while handling a kern-ctl error",
1065 lttng_process_attr_to_string(process_attr
),
1072 enum lttng_error_code
kernel_process_attr_tracker_inclusion_set_remove_value(
1073 struct ltt_kernel_session
*session
,
1074 enum lttng_process_attr process_attr
,
1075 const struct process_attr_value
*value
)
1077 int ret
, integral_value
;
1078 enum lttng_error_code ret_code
;
1079 struct process_attr_tracker
*tracker
;
1080 enum process_attr_tracker_status status
;
1083 * Convert process attribute tracker value to the integral
1084 * representation required by the kern-ctl API.
1086 switch (process_attr
) {
1087 case LTTNG_PROCESS_ATTR_PROCESS_ID
:
1088 case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
:
1089 integral_value
= (int) value
->value
.pid
;
1091 case LTTNG_PROCESS_ATTR_USER_ID
:
1092 case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID
:
1093 if (value
->type
== LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME
) {
1096 ret_code
= utils_user_id_from_name(
1097 value
->value
.user_name
, &uid
);
1098 if (ret_code
!= LTTNG_OK
) {
1101 integral_value
= (int) uid
;
1103 integral_value
= (int) value
->value
.uid
;
1106 case LTTNG_PROCESS_ATTR_GROUP_ID
:
1107 case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID
:
1108 if (value
->type
== LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME
) {
1111 ret_code
= utils_group_id_from_name(
1112 value
->value
.group_name
, &gid
);
1113 if (ret_code
!= LTTNG_OK
) {
1116 integral_value
= (int) gid
;
1118 integral_value
= (int) value
->value
.gid
;
1122 ret_code
= LTTNG_ERR_INVALID
;
1126 tracker
= _kernel_get_process_attr_tracker(session
, process_attr
);
1128 ret_code
= LTTNG_ERR_INVALID
;
1132 status
= process_attr_tracker_inclusion_set_remove_value(
1134 if (status
!= PROCESS_ATTR_TRACKER_STATUS_OK
) {
1136 case PROCESS_ATTR_TRACKER_STATUS_MISSING
:
1137 ret_code
= LTTNG_ERR_PROCESS_ATTR_MISSING
;
1139 case PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY
:
1140 ret_code
= LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY
;
1142 case PROCESS_ATTR_TRACKER_STATUS_ERROR
:
1144 ret_code
= LTTNG_ERR_UNK
;
1150 DBG("Kernel track %s %d for session id %" PRIu64
,
1151 lttng_process_attr_to_string(process_attr
),
1152 integral_value
, session
->id
);
1153 if (process_attr
== LTTNG_PROCESS_ATTR_PROCESS_ID
) {
1155 * Maintain a special case for the process ID process attribute
1156 * tracker as it was the only supported attribute prior to 2.12.
1158 ret
= kernctl_untrack_pid(session
->fd
, integral_value
);
1160 ret
= kernctl_untrack_id(
1161 session
->fd
, process_attr
, integral_value
);
1164 ret_code
= LTTNG_OK
;
1167 kernel_wait_quiescent();
1169 /* kern-ctl error handling */
1172 ret_code
= LTTNG_OK
;
1175 ret_code
= LTTNG_ERR_INVALID
;
1178 ret_code
= LTTNG_ERR_NOMEM
;
1181 ret_code
= LTTNG_ERR_PROCESS_ATTR_MISSING
;
1184 ret_code
= LTTNG_ERR_UNK
;
1188 /* Attempt to add the value to the tracker. */
1189 status
= process_attr_tracker_inclusion_set_add_value(
1191 if (status
!= PROCESS_ATTR_TRACKER_STATUS_OK
) {
1192 ERR("Failed to roll-back the tracking of kernel %s process attribute %d while handling a kern-ctl error",
1193 lttng_process_attr_to_string(process_attr
),
1201 * Create kernel metadata, open from the kernel tracer and add it to the
1204 int kernel_open_metadata(struct ltt_kernel_session
*session
)
1207 struct ltt_kernel_metadata
*lkm
= NULL
;
1211 /* Allocate kernel metadata */
1212 lkm
= trace_kernel_create_metadata();
1217 /* Kernel tracer metadata creation */
1218 ret
= kernctl_open_metadata(session
->fd
, &lkm
->conf
->attr
);
1224 lkm
->key
= ++next_kernel_channel_key
;
1225 /* Prevent fd duplication after execlp() */
1226 ret
= fcntl(lkm
->fd
, F_SETFD
, FD_CLOEXEC
);
1228 PERROR("fcntl session fd");
1231 session
->metadata
= lkm
;
1233 DBG("Kernel metadata opened (fd: %d)", lkm
->fd
);
1238 trace_kernel_destroy_metadata(lkm
);
1244 * Start tracing session.
1246 int kernel_start_session(struct ltt_kernel_session
*session
)
1252 ret
= kernctl_start_session(session
->fd
);
1254 PERROR("ioctl start session");
1258 DBG("Kernel session started");
1267 * Make a kernel wait to make sure in-flight probe have completed.
1269 void kernel_wait_quiescent(void)
1272 int fd
= kernel_tracer_fd
;
1274 DBG("Kernel quiescent wait on %d", fd
);
1276 ret
= kernctl_wait_quiescent(fd
);
1278 PERROR("wait quiescent ioctl");
1279 ERR("Kernel quiescent wait failed");
1284 * Force flush buffer of metadata.
1286 int kernel_metadata_flush_buffer(int fd
)
1290 DBG("Kernel flushing metadata buffer on fd %d", fd
);
1292 ret
= kernctl_buffer_flush(fd
);
1294 ERR("Fail to flush metadata buffers %d (ret: %d)", fd
, ret
);
1301 * Force flush buffer for channel.
1303 int kernel_flush_buffer(struct ltt_kernel_channel
*channel
)
1306 struct ltt_kernel_stream
*stream
;
1310 DBG("Flush buffer for channel %s", channel
->channel
->name
);
1312 cds_list_for_each_entry(stream
, &channel
->stream_list
.head
, list
) {
1313 DBG("Flushing channel stream %d", stream
->fd
);
1314 ret
= kernctl_buffer_flush(stream
->fd
);
1317 ERR("Fail to flush buffer for stream %d (ret: %d)",
1326 * Stop tracing session.
1328 int kernel_stop_session(struct ltt_kernel_session
*session
)
1334 ret
= kernctl_stop_session(session
->fd
);
1339 DBG("Kernel session stopped");
1348 * Open stream of channel, register it to the kernel tracer and add it
1349 * to the stream list of the channel.
1351 * Note: given that the streams may appear in random order wrt CPU
1352 * number (e.g. cpu hotplug), the index value of the stream number in
1353 * the stream name is not necessarily linked to the CPU number.
1355 * Return the number of created stream. Else, a negative value.
1357 int kernel_open_channel_stream(struct ltt_kernel_channel
*channel
)
1360 struct ltt_kernel_stream
*lks
;
1364 while ((ret
= kernctl_create_stream(channel
->fd
)) >= 0) {
1365 lks
= trace_kernel_create_stream(channel
->channel
->name
,
1366 channel
->stream_count
);
1376 /* Prevent fd duplication after execlp() */
1377 ret
= fcntl(lks
->fd
, F_SETFD
, FD_CLOEXEC
);
1379 PERROR("fcntl session fd");
1382 lks
->tracefile_size
= channel
->channel
->attr
.tracefile_size
;
1383 lks
->tracefile_count
= channel
->channel
->attr
.tracefile_count
;
1385 /* Add stream to channel stream list */
1386 cds_list_add(&lks
->list
, &channel
->stream_list
.head
);
1387 channel
->stream_count
++;
1389 DBG("Kernel stream %s created (fd: %d, state: %d)", lks
->name
, lks
->fd
,
1393 return channel
->stream_count
;
1400 * Open the metadata stream and set it to the kernel session.
1402 int kernel_open_metadata_stream(struct ltt_kernel_session
*session
)
1408 ret
= kernctl_create_stream(session
->metadata
->fd
);
1410 PERROR("kernel create metadata stream");
1414 DBG("Kernel metadata stream created (fd: %d)", ret
);
1415 session
->metadata_stream_fd
= ret
;
1416 /* Prevent fd duplication after execlp() */
1417 ret
= fcntl(session
->metadata_stream_fd
, F_SETFD
, FD_CLOEXEC
);
1419 PERROR("fcntl session fd");
1429 * Get the event list from the kernel tracer and return the number of elements.
1431 ssize_t
kernel_list_events(struct lttng_event
**events
)
1435 size_t nbmem
, count
= 0;
1437 struct lttng_event
*elist
;
1441 fd
= kernctl_tracepoint_list(kernel_tracer_fd
);
1443 PERROR("kernel tracepoint list");
1447 fp
= fdopen(fd
, "r");
1449 PERROR("kernel tracepoint list fdopen");
1454 * Init memory size counter
1455 * See kernel-ctl.h for explanation of this value
1457 nbmem
= KERNEL_EVENT_INIT_LIST_SIZE
;
1458 elist
= zmalloc(sizeof(struct lttng_event
) * nbmem
);
1459 if (elist
== NULL
) {
1460 PERROR("alloc list events");
1465 while (fscanf(fp
, "event { name = %m[^;]; };\n", &event
) == 1) {
1466 if (count
>= nbmem
) {
1467 struct lttng_event
*new_elist
;
1470 new_nbmem
= nbmem
<< 1;
1471 DBG("Reallocating event list from %zu to %zu bytes",
1473 new_elist
= realloc(elist
, new_nbmem
* sizeof(struct lttng_event
));
1474 if (new_elist
== NULL
) {
1475 PERROR("realloc list events");
1481 /* Zero the new memory */
1482 memset(new_elist
+ nbmem
, 0,
1483 (new_nbmem
- nbmem
) * sizeof(struct lttng_event
));
1487 strncpy(elist
[count
].name
, event
, LTTNG_SYMBOL_NAME_LEN
);
1488 elist
[count
].name
[LTTNG_SYMBOL_NAME_LEN
- 1] = '\0';
1489 elist
[count
].enabled
= -1;
1495 DBG("Kernel list events done (%zu events)", count
);
1497 ret
= fclose(fp
); /* closes both fp and fd */
1513 * Get kernel version and validate it.
1515 int kernel_validate_version(struct lttng_kernel_tracer_version
*version
,
1516 struct lttng_kernel_tracer_abi_version
*abi_version
)
1520 ret
= kernctl_tracer_version(kernel_tracer_fd
, version
);
1522 ERR("Failed to retrieve the lttng-modules version");
1526 /* Validate version */
1527 if (version
->major
!= VERSION_MAJOR
) {
1528 ERR("Kernel tracer major version (%d) is not compatible with lttng-tools major version (%d)",
1529 version
->major
, VERSION_MAJOR
);
1532 ret
= kernctl_tracer_abi_version(kernel_tracer_fd
, abi_version
);
1534 ERR("Failed to retrieve lttng-modules ABI version");
1537 if (abi_version
->major
!= LTTNG_MODULES_ABI_MAJOR_VERSION
) {
1538 ERR("Kernel tracer ABI version (%d.%d) does not match the expected ABI major version (%d.*)",
1539 abi_version
->major
, abi_version
->minor
,
1540 LTTNG_MODULES_ABI_MAJOR_VERSION
);
1543 DBG2("Kernel tracer version validated (%d.%d, ABI %d.%d)",
1544 version
->major
, version
->minor
,
1545 abi_version
->major
, abi_version
->minor
);
1552 ERR("Kernel tracer version check failed; kernel tracing will not be available");
1557 * Kernel work-arounds called at the start of sessiond main().
1559 int init_kernel_workarounds(void)
1565 * boot_id needs to be read once before being used concurrently
1566 * to deal with a Linux kernel race. A fix is proposed for
1567 * upstream, but the work-around is needed for older kernels.
1569 fp
= fopen("/proc/sys/kernel/random/boot_id", "r");
1576 ret
= fread(buf
, 1, sizeof(buf
), fp
);
1578 /* Ignore error, we don't really care */
1590 * Teardown of a kernel session, keeping data required by destroy notifiers.
1592 void kernel_destroy_session(struct ltt_kernel_session
*ksess
)
1594 struct lttng_trace_chunk
*trace_chunk
;
1596 if (ksess
== NULL
) {
1597 DBG3("No kernel session when tearing down session");
1601 DBG("Tearing down kernel session");
1602 trace_chunk
= ksess
->current_trace_chunk
;
1605 * Destroy channels on the consumer if at least one FD has been sent and we
1606 * are in no output mode because the streams are in *no* monitor mode so we
1607 * have to send a command to clean them up or else they leaked.
1609 if (!ksess
->output_traces
&& ksess
->consumer_fds_sent
) {
1611 struct consumer_socket
*socket
;
1612 struct lttng_ht_iter iter
;
1614 /* For each consumer socket. */
1616 cds_lfht_for_each_entry(ksess
->consumer
->socks
->ht
, &iter
.iter
,
1617 socket
, node
.node
) {
1618 struct ltt_kernel_channel
*chan
;
1620 /* For each channel, ask the consumer to destroy it. */
1621 cds_list_for_each_entry(chan
, &ksess
->channel_list
.head
, list
) {
1622 ret
= kernel_consumer_destroy_channel(socket
, chan
);
1624 /* Consumer is probably dead. Use next socket. */
1632 /* Close any relayd session */
1633 consumer_output_send_destroy_relayd(ksess
->consumer
);
1635 trace_kernel_destroy_session(ksess
);
1636 lttng_trace_chunk_put(trace_chunk
);
1639 /* Teardown of data required by destroy notifiers. */
1640 void kernel_free_session(struct ltt_kernel_session
*ksess
)
1642 if (ksess
== NULL
) {
1645 trace_kernel_free_session(ksess
);
1649 * Destroy a kernel channel object. It does not do anything on the tracer side.
1651 void kernel_destroy_channel(struct ltt_kernel_channel
*kchan
)
1653 struct ltt_kernel_session
*ksess
= NULL
;
1656 assert(kchan
->channel
);
1658 DBG3("Kernel destroy channel %s", kchan
->channel
->name
);
1660 /* Update channel count of associated session. */
1661 if (kchan
->session
) {
1662 /* Keep pointer reference so we can update it after the destroy. */
1663 ksess
= kchan
->session
;
1666 trace_kernel_destroy_channel(kchan
);
1669 * At this point the kernel channel is not visible anymore. This is safe
1670 * since in order to work on a visible kernel session, the tracing session
1671 * lock (ltt_session.lock) MUST be acquired.
1674 ksess
->channel_count
--;
1679 * Take a snapshot for a given kernel session.
1681 * Return LTTNG_OK on success or else return a LTTNG_ERR code.
1683 enum lttng_error_code
kernel_snapshot_record(
1684 struct ltt_kernel_session
*ksess
,
1685 const struct consumer_output
*output
, int wait
,
1686 uint64_t nb_packets_per_stream
)
1688 int err
, ret
, saved_metadata_fd
;
1689 enum lttng_error_code status
= LTTNG_OK
;
1690 struct consumer_socket
*socket
;
1691 struct lttng_ht_iter iter
;
1692 struct ltt_kernel_metadata
*saved_metadata
;
1693 char *trace_path
= NULL
;
1694 size_t consumer_path_offset
= 0;
1697 assert(ksess
->consumer
);
1700 DBG("Kernel snapshot record started");
1702 /* Save current metadata since the following calls will change it. */
1703 saved_metadata
= ksess
->metadata
;
1704 saved_metadata_fd
= ksess
->metadata_stream_fd
;
1708 ret
= kernel_open_metadata(ksess
);
1710 status
= LTTNG_ERR_KERN_META_FAIL
;
1714 ret
= kernel_open_metadata_stream(ksess
);
1716 status
= LTTNG_ERR_KERN_META_FAIL
;
1717 goto error_open_stream
;
1720 trace_path
= setup_channel_trace_path(ksess
->consumer
,
1721 DEFAULT_KERNEL_TRACE_DIR
, &consumer_path_offset
);
1723 status
= LTTNG_ERR_INVALID
;
1726 /* Send metadata to consumer and snapshot everything. */
1727 cds_lfht_for_each_entry(output
->socks
->ht
, &iter
.iter
,
1728 socket
, node
.node
) {
1729 struct ltt_kernel_channel
*chan
;
1731 pthread_mutex_lock(socket
->lock
);
1732 /* This stream must not be monitored by the consumer. */
1733 ret
= kernel_consumer_add_metadata(socket
, ksess
, 0);
1734 pthread_mutex_unlock(socket
->lock
);
1736 status
= LTTNG_ERR_KERN_META_FAIL
;
1737 goto error_consumer
;
1740 /* For each channel, ask the consumer to snapshot it. */
1741 cds_list_for_each_entry(chan
, &ksess
->channel_list
.head
, list
) {
1742 status
= consumer_snapshot_channel(socket
, chan
->key
, output
, 0,
1743 ksess
->uid
, ksess
->gid
,
1744 &trace_path
[consumer_path_offset
], wait
,
1745 nb_packets_per_stream
);
1746 if (status
!= LTTNG_OK
) {
1747 (void) kernel_consumer_destroy_metadata(socket
,
1749 goto error_consumer
;
1753 /* Snapshot metadata, */
1754 status
= consumer_snapshot_channel(socket
, ksess
->metadata
->key
, output
,
1755 1, ksess
->uid
, ksess
->gid
, &trace_path
[consumer_path_offset
],
1757 if (status
!= LTTNG_OK
) {
1758 goto error_consumer
;
1762 * The metadata snapshot is done, ask the consumer to destroy it since
1763 * it's not monitored on the consumer side.
1765 (void) kernel_consumer_destroy_metadata(socket
, ksess
->metadata
);
1769 /* Close newly opened metadata stream. It's now on the consumer side. */
1770 err
= close(ksess
->metadata_stream_fd
);
1772 PERROR("close snapshot kernel");
1776 trace_kernel_destroy_metadata(ksess
->metadata
);
1778 /* Restore metadata state.*/
1779 ksess
->metadata
= saved_metadata
;
1780 ksess
->metadata_stream_fd
= saved_metadata_fd
;
1787 * Get the syscall mask array from the kernel tracer.
1789 * Return 0 on success else a negative value. In both case, syscall_mask should
1792 int kernel_syscall_mask(int chan_fd
, char **syscall_mask
, uint32_t *nr_bits
)
1794 assert(syscall_mask
);
1797 return kernctl_syscall_mask(chan_fd
, syscall_mask
, nr_bits
);
1801 int kernel_tracer_abi_greater_or_equal(unsigned int major
, unsigned int minor
)
1804 struct lttng_kernel_tracer_abi_version abi
;
1806 ret
= kernctl_tracer_abi_version(kernel_tracer_fd
, &abi
);
1808 ERR("Failed to retrieve lttng-modules ABI version");
1812 ret
= abi
.major
> major
|| (abi
.major
== major
&& abi
.minor
>= minor
);
1818 * Check for the support of the RING_BUFFER_SNAPSHOT_SAMPLE_POSITIONS via abi
1821 * Return 1 on success, 0 when feature is not supported, negative value in case
1824 int kernel_supports_ring_buffer_snapshot_sample_positions(void)
1827 * RING_BUFFER_SNAPSHOT_SAMPLE_POSITIONS was introduced in 2.3
1829 return kernel_tracer_abi_greater_or_equal(2, 3);
1833 * Check for the support of the packet sequence number via abi version number.
1835 * Return 1 on success, 0 when feature is not supported, negative value in case
1838 int kernel_supports_ring_buffer_packet_sequence_number(void)
1841 * Packet sequence number was introduced in LTTng 2.8,
1842 * lttng-modules ABI 2.1.
1844 return kernel_tracer_abi_greater_or_equal(2, 1);
1848 * Check for the support of event notifiers via abi version number.
1850 * Return 1 on success, 0 when feature is not supported, negative value in case
1853 int kernel_supports_event_notifiers(void)
1856 * Event notifiers were introduced in LTTng 2.13, lttng-modules ABI 2.6.
1858 return kernel_tracer_abi_greater_or_equal(2, 6);
1862 * Rotate a kernel session.
1864 * Return LTTNG_OK on success or else an LTTng error code.
1866 enum lttng_error_code
kernel_rotate_session(struct ltt_session
*session
)
1869 enum lttng_error_code status
= LTTNG_OK
;
1870 struct consumer_socket
*socket
;
1871 struct lttng_ht_iter iter
;
1872 struct ltt_kernel_session
*ksess
= session
->kernel_session
;
1875 assert(ksess
->consumer
);
1877 DBG("Rotate kernel session %s started (session %" PRIu64
")",
1878 session
->name
, session
->id
);
1883 * Note that this loop will end after one iteration given that there is
1884 * only one kernel consumer.
1886 cds_lfht_for_each_entry(ksess
->consumer
->socks
->ht
, &iter
.iter
,
1887 socket
, node
.node
) {
1888 struct ltt_kernel_channel
*chan
;
1890 /* For each channel, ask the consumer to rotate it. */
1891 cds_list_for_each_entry(chan
, &ksess
->channel_list
.head
, list
) {
1892 DBG("Rotate kernel channel %" PRIu64
", session %s",
1893 chan
->key
, session
->name
);
1894 ret
= consumer_rotate_channel(socket
, chan
->key
,
1895 ksess
->uid
, ksess
->gid
, ksess
->consumer
,
1896 /* is_metadata_channel */ false);
1898 status
= LTTNG_ERR_ROTATION_FAIL_CONSUMER
;
1904 * Rotate the metadata channel.
1906 ret
= consumer_rotate_channel(socket
, ksess
->metadata
->key
,
1907 ksess
->uid
, ksess
->gid
, ksess
->consumer
,
1908 /* is_metadata_channel */ true);
1910 status
= LTTNG_ERR_ROTATION_FAIL_CONSUMER
;
1920 enum lttng_error_code
kernel_create_channel_subdirectories(
1921 const struct ltt_kernel_session
*ksess
)
1923 enum lttng_error_code ret
= LTTNG_OK
;
1924 enum lttng_trace_chunk_status chunk_status
;
1927 assert(ksess
->current_trace_chunk
);
1930 * Create the index subdirectory which will take care
1931 * of implicitly creating the channel's path.
1933 chunk_status
= lttng_trace_chunk_create_subdirectory(
1934 ksess
->current_trace_chunk
,
1935 DEFAULT_KERNEL_TRACE_DIR
"/" DEFAULT_INDEX_DIR
);
1936 if (chunk_status
!= LTTNG_TRACE_CHUNK_STATUS_OK
) {
1937 ret
= LTTNG_ERR_CREATE_DIR_FAIL
;
1946 * Setup necessary data for kernel tracer action.
1949 int init_kernel_tracer(void)
1952 bool is_root
= !getuid();
1954 /* Modprobe lttng kernel modules */
1955 ret
= modprobe_lttng_control();
1960 /* Open debugfs lttng */
1961 kernel_tracer_fd
= open(module_proc_lttng
, O_RDWR
);
1962 if (kernel_tracer_fd
< 0) {
1963 DBG("Failed to open %s", module_proc_lttng
);
1967 /* Validate kernel version */
1968 ret
= kernel_validate_version(&kernel_tracer_version
,
1969 &kernel_tracer_abi_version
);
1974 ret
= modprobe_lttng_data();
1979 ret
= kernel_supports_ring_buffer_snapshot_sample_positions();
1984 WARN("Kernel tracer does not support buffer monitoring. "
1985 "The monitoring timer of channels in the kernel domain "
1986 "will be set to 0 (disabled).");
1989 ret
= kernel_supports_event_notifiers();
1991 ERR("Failed to check for kernel tracer event notifier support");
1994 ret
= kernel_create_event_notifier_group(&kernel_tracer_event_notifier_group_fd
);
1996 /* This is not fatal. */
1997 WARN("Failed to create kernel event notifier group");
1998 kernel_tracer_event_notifier_group_fd
= -1;
2000 enum event_notifier_error_accounting_status error_accounting_status
;
2001 enum lttng_error_code error_code_ret
=
2002 kernel_create_event_notifier_group_notification_fd(
2003 &kernel_tracer_event_notifier_group_notification_fd
);
2005 if (error_code_ret
!= LTTNG_OK
) {
2009 error_accounting_status
= event_notifier_error_accounting_register_kernel(
2010 kernel_tracer_event_notifier_group_fd
);
2011 if (error_accounting_status
!= EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK
) {
2012 ERR("Error initializing event notifier error accounting for kernel tracer.");
2013 error_code_ret
= LTTNG_ERR_EVENT_NOTIFIER_ERROR_ACCOUNTING
;
2017 kernel_token_to_event_notifier_rule_ht
= cds_lfht_new(
2018 DEFAULT_HT_SIZE
, 1, 0,
2019 CDS_LFHT_AUTO_RESIZE
| CDS_LFHT_ACCOUNTING
,
2021 if (!kernel_token_to_event_notifier_rule_ht
) {
2022 goto error_token_ht
;
2026 DBG("Kernel tracer initialized: kernel tracer fd = %d, event notifier group fd = %d, event notifier group notification fd = %d",
2027 kernel_tracer_fd
, kernel_tracer_event_notifier_group_fd
,
2028 kernel_tracer_event_notifier_group_notification_fd
);
2030 ret
= syscall_init_table(kernel_tracer_fd
);
2032 ERR("Unable to populate syscall table. Syscall tracing won't "
2033 "work for this session daemon.");
2039 modprobe_remove_lttng_control();
2040 ret
= close(kernel_tracer_fd
);
2042 PERROR("Failed to close kernel tracer file descriptor: fd = %d",
2045 kernel_tracer_fd
= -1;
2046 return LTTNG_ERR_KERN_VERSION
;
2050 ret
= close(kernel_tracer_event_notifier_group_notification_fd
);
2052 PERROR("Failed to close kernel tracer event notifier group notification file descriptor: fd = %d",
2053 kernel_tracer_event_notifier_group_notification_fd
);
2057 ret
= close(kernel_tracer_event_notifier_group_fd
);
2059 PERROR("Failed to close kernel tracer event notifier group file descriptor: fd = %d",
2060 kernel_tracer_event_notifier_group_fd
);
2063 ret
= close(kernel_tracer_fd
);
2065 PERROR("Failed to close kernel tracer file descriptor: fd = %d",
2070 modprobe_remove_lttng_control();
2073 WARN("No kernel tracer available");
2074 kernel_tracer_fd
= -1;
2076 return LTTNG_ERR_NEED_ROOT_SESSIOND
;
2078 return LTTNG_ERR_KERN_NA
;
2083 void cleanup_kernel_tracer(void)
2085 DBG2("Closing kernel event notifier group notification file descriptor");
2086 if (kernel_tracer_event_notifier_group_notification_fd
>= 0) {
2087 int ret
= notification_thread_command_remove_tracer_event_source(
2088 notification_thread_handle
,
2089 kernel_tracer_event_notifier_group_notification_fd
);
2090 if (ret
!= LTTNG_OK
) {
2091 ERR("Failed to remove kernel event notifier notification from notification thread");
2094 ret
= close(kernel_tracer_event_notifier_group_notification_fd
);
2096 PERROR("Failed to close kernel event notifier group notification file descriptor: fd = %d",
2097 kernel_tracer_event_notifier_group_notification_fd
);
2100 kernel_tracer_event_notifier_group_notification_fd
= -1;
2103 if (kernel_token_to_event_notifier_rule_ht
) {
2104 const int ret
= cds_lfht_destroy(
2105 kernel_token_to_event_notifier_rule_ht
, NULL
);
2109 DBG2("Closing kernel event notifier group file descriptor");
2110 if (kernel_tracer_event_notifier_group_fd
>= 0) {
2111 const int ret
= close(kernel_tracer_event_notifier_group_fd
);
2114 PERROR("Failed to close kernel event notifier group file descriptor: fd = %d",
2115 kernel_tracer_event_notifier_group_fd
);
2118 kernel_tracer_event_notifier_group_fd
= -1;
2121 DBG2("Closing kernel fd");
2122 if (kernel_tracer_fd
>= 0) {
2123 const int ret
= close(kernel_tracer_fd
);
2126 PERROR("Failed to close kernel tracer file descriptor: fd = %d",
2130 kernel_tracer_fd
= -1;
2133 free(syscall_table
);
2137 bool kernel_tracer_is_initialized(void)
2139 return kernel_tracer_fd
>= 0;
2142 enum lttng_error_code
kernel_clear_session_channels(struct ltt_session
*session
)
2145 enum lttng_error_code status
= LTTNG_OK
;
2146 struct consumer_socket
*socket
;
2147 struct lttng_ht_iter iter
;
2148 struct ltt_kernel_session
*ksess
= session
->kernel_session
;
2151 assert(ksess
->consumer
);
2155 if (ksess
->active
) {
2156 ERR("Expecting inactive session %s (%" PRIu64
")", session
->name
, session
->id
);
2157 status
= LTTNG_ERR_FATAL
;
2162 * Note that this loop will end after one iteration given that there is
2163 * only one kernel consumer.
2165 cds_lfht_for_each_entry(ksess
->consumer
->socks
->ht
, &iter
.iter
,
2166 socket
, node
.node
) {
2167 struct ltt_kernel_channel
*chan
;
2169 /* For each channel, ask the consumer to clear it. */
2170 cds_list_for_each_entry(chan
, &ksess
->channel_list
.head
, list
) {
2171 DBG("Clear kernel channel %" PRIu64
", session %s",
2172 chan
->key
, session
->name
);
2173 ret
= consumer_clear_channel(socket
, chan
->key
);
2179 if (!ksess
->metadata
) {
2181 * Nothing to do for the metadata.
2182 * This is a snapshot session.
2183 * The metadata is genererated on the fly.
2189 * Clear the metadata channel.
2190 * Metadata channel is not cleared per se but we still need to
2191 * perform a rotation operation on it behind the scene.
2193 ret
= consumer_clear_channel(socket
, ksess
->metadata
->key
);
2203 case LTTCOMM_CONSUMERD_RELAYD_CLEAR_DISALLOWED
:
2204 status
= LTTNG_ERR_CLEAR_RELAY_DISALLOWED
;
2207 status
= LTTNG_ERR_CLEAR_FAIL_CONSUMER
;
2216 enum lttng_error_code
kernel_map_clear_all(struct ltt_kernel_map
*map
)
2218 enum lttng_error_code status
;
2219 uint64_t descr_count
, i
;
2224 ret
= kernctl_counter_map_descriptor_count(map
->fd
, &descr_count
);
2226 ERR("Error getting map descriptor count");
2227 status
= LTTNG_ERR_MAP_VALUES_LIST_FAIL
;
2231 for(i
= 0; i
< descr_count
; i
++) {
2232 struct lttng_kernel_counter_map_descriptor descriptor
= {0};
2233 struct lttng_kernel_counter_clear counter_clear
= {0};
2235 descriptor
.descriptor_index
= i
;
2237 ret
= kernctl_counter_map_descriptor(map
->fd
, &descriptor
);
2239 ERR("Error getting map descriptor %"PRIu64
, i
);
2240 status
= LTTNG_ERR_MAP_VALUES_LIST_FAIL
;
2244 counter_clear
.index
.number_dimensions
= 1;
2245 counter_clear
.index
.dimension_indexes
[0] = descriptor
.array_index
;
2247 ret
= kernctl_counter_clear(map
->fd
, &counter_clear
);
2249 ERR("Error clearing value of map descriptor %"PRIu64
, i
);
2250 status
= LTTNG_ERR_MAP_VALUES_LIST_FAIL
;
2261 enum lttng_error_code
kernel_clear_session_maps(struct ltt_session
*session
)
2263 enum lttng_error_code status
= LTTNG_OK
;
2264 struct ltt_kernel_map
*map
;
2265 struct ltt_kernel_session
*ksess
= session
->kernel_session
;
2269 cds_list_for_each_entry(map
, &ksess
->map_list
.head
, list
) {
2270 DBG("Clear kernel map %" PRIu64
", session %s",
2271 map
->key
, session
->name
);
2272 status
= kernel_map_clear_all(map
);
2273 if (status
!= LTTNG_OK
) {
2274 ERR("Clearing all values of map");
2284 * Clear a kernel session.
2286 * Return LTTNG_OK on success or else an LTTng error code.
2288 enum lttng_error_code
kernel_clear_session(struct ltt_session
*session
)
2290 enum lttng_error_code status
= LTTNG_OK
;
2291 struct ltt_kernel_session
*ksess
= session
->kernel_session
;
2294 assert(ksess
->consumer
);
2296 DBG("Clear kernel session %s (session %" PRIu64
")",
2297 session
->name
, session
->id
);
2301 if (ksess
->active
) {
2302 ERR("Expecting inactive session %s (%" PRIu64
")", session
->name
, session
->id
);
2303 status
= LTTNG_ERR_FATAL
;
2307 status
= kernel_clear_session_channels(session
);
2308 if (status
!= LTTNG_OK
) {
2312 * Iterate and clear all kernel maps.
2314 status
= kernel_clear_session_maps(session
);
2315 if (status
!= LTTNG_OK
) {
2325 enum lttng_error_code
kernel_create_event_notifier_group_notification_fd(
2326 int *event_notifier_group_notification_fd
)
2328 int local_fd
= -1, ret
;
2329 enum lttng_error_code error_code_ret
;
2331 assert(event_notifier_group_notification_fd
);
2333 ret
= kernctl_create_event_notifier_group_notification_fd(
2334 kernel_tracer_event_notifier_group_fd
);
2336 PERROR("Failed to create kernel event notifier group notification file descriptor");
2337 error_code_ret
= LTTNG_ERR_EVENT_NOTIFIER_GROUP_NOTIFICATION_FD
;
2343 /* Prevent fd duplication after execlp(). */
2344 ret
= fcntl(local_fd
, F_SETFD
, FD_CLOEXEC
);
2346 PERROR("Failed to set FD_CLOEXEC on kernel event notifier group notification file descriptor: fd = %d",
2348 error_code_ret
= LTTNG_ERR_EVENT_NOTIFIER_GROUP_NOTIFICATION_FD
;
2352 DBG("Created kernel notifier group notification file descriptor: fd = %d",
2354 error_code_ret
= LTTNG_OK
;
2355 *event_notifier_group_notification_fd
= local_fd
;
2359 if (local_fd
>= 0) {
2360 ret
= close(local_fd
);
2362 PERROR("Failed to close kernel event notifier group notification file descriptor: fd = %d",
2367 return error_code_ret
;
2370 enum lttng_error_code
kernel_destroy_event_notifier_group_notification_fd(
2371 int event_notifier_group_notification_fd
)
2373 enum lttng_error_code ret_code
= LTTNG_OK
;
2375 DBG("Closing event notifier group notification file descriptor: fd = %d",
2376 event_notifier_group_notification_fd
);
2377 if (event_notifier_group_notification_fd
>= 0) {
2378 const int ret
= close(event_notifier_group_notification_fd
);
2380 PERROR("Failed to close event notifier group notification file descriptor: fd = %d",
2381 event_notifier_group_notification_fd
);
2389 unsigned long hash_trigger(const struct lttng_trigger
*trigger
)
2391 const struct lttng_condition
*condition
=
2392 lttng_trigger_get_const_condition(trigger
);
2394 return lttng_condition_hash(condition
);
2398 int match_trigger(struct cds_lfht_node
*node
, const void *key
)
2400 const struct ltt_kernel_event_notifier_rule
*event_notifier_rule
;
2401 const struct lttng_trigger
*trigger
= key
;
2403 event_notifier_rule
= caa_container_of(node
,
2404 const struct ltt_kernel_event_notifier_rule
, ht_node
);
2406 return lttng_trigger_is_equal(trigger
, event_notifier_rule
->trigger
);
2410 int add_key_token(struct lttng_kernel_key_token
*kernel_key_token
,
2411 const struct lttng_map_key_token
*key_token
)
2414 switch (key_token
->type
) {
2415 case LTTNG_MAP_KEY_TOKEN_TYPE_STRING
:
2417 const struct lttng_map_key_token_string
*str_token
;
2418 str_token
= (typeof(str_token
)) key_token
;
2420 kernel_key_token
->type
= LTTNG_KERNEL_KEY_TOKEN_STRING
;
2421 kernel_key_token
->arg
.string_ptr
= (uint64_t) str_token
->string
;
2425 case LTTNG_MAP_KEY_TOKEN_TYPE_VARIABLE
:
2427 const struct lttng_map_key_token_variable
*var_token
;
2428 var_token
= (typeof(var_token
)) key_token
;
2429 switch (var_token
->type
) {
2430 case LTTNG_MAP_KEY_TOKEN_VARIABLE_TYPE_EVENT_NAME
:
2431 kernel_key_token
->type
= LTTNG_KERNEL_KEY_TOKEN_EVENT_NAME
;
2433 case LTTNG_MAP_KEY_TOKEN_VARIABLE_TYPE_PROVIDER_NAME
:
2434 /* The kernel events don't have providers */
2435 ERR("Provider variable token type not supported for kernel tracer");
2452 enum lttng_error_code
kernel_create_event_counter(
2453 struct ltt_kernel_map
*kmap
,
2454 const struct lttng_credentials
*creds
,
2455 uint64_t action_tracer_token
,
2456 const struct lttng_event_rule
*event_rule
,
2457 struct lttng_map_key
*key
)
2459 int err
, fd
, ret
= 0;
2460 unsigned int i
, key_token_count
;
2461 enum lttng_error_code error_code_ret
;
2462 enum lttng_map_key_status status
;
2463 struct ltt_kernel_event_counter
*event_counter
;
2464 struct lttng_kernel_counter_event k_counter_event
= {};
2467 event_counter
= zmalloc(sizeof(*event_counter
));
2468 if (!event_counter
) {
2469 error_code_ret
= LTTNG_ERR_NOMEM
;
2473 trace_kernel_init_event_counter_from_event_rule(event_rule
,
2475 event_counter
->fd
= -1;
2476 event_counter
->enabled
= 1;
2477 event_counter
->action_tracer_token
= action_tracer_token
;
2478 event_counter
->filter
= lttng_event_rule_get_filter_bytecode(event_rule
);
2480 k_counter_event
.event
.token
= action_tracer_token
;
2482 /* Set the key pattern for this event counter. */
2483 k_counter_event
.key
.nr_dimensions
= 1;
2485 status
= lttng_map_key_get_token_count(key
, &key_token_count
);
2486 if (status
!= LTTNG_MAP_KEY_STATUS_OK
) {
2487 error_code_ret
= LTTNG_ERR_UNK
;
2491 assert(key_token_count
> 0);
2493 k_counter_event
.key
.key_dimensions
[0].nr_key_tokens
= key_token_count
;
2495 for (i
= 0; i
< key_token_count
; i
++) {
2496 const struct lttng_map_key_token
*token
=
2497 lttng_map_key_get_token_at_index(key
, i
);
2499 ret
= add_key_token(&k_counter_event
.key
.key_dimensions
[0].key_tokens
[i
],
2502 ERR("Error appending map key token");
2503 error_code_ret
= LTTNG_ERR_INVALID
;
2508 fd
= kernctl_create_counter_event(kmap
->fd
, &k_counter_event
);
2512 error_code_ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
2515 WARN("Event counter type not implemented");
2516 error_code_ret
= LTTNG_ERR_KERN_EVENT_ENOSYS
;
2519 WARN("Event counter %s not found!", k_counter_event
.event
.name
);
2520 error_code_ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
2523 error_code_ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
2524 PERROR("create event counter ioctl");
2528 event_counter
->fd
= fd
;
2529 event_counter
->enabled
= true;
2531 /* Prevent fd duplication after execlp() */
2532 err
= fcntl(fd
, F_SETFD
, FD_CLOEXEC
);
2534 PERROR("fcntl session fd");
2537 if (event_counter
->filter
) {
2538 err
= kernctl_filter(event_counter
->fd
, event_counter
->filter
);
2542 error_code_ret
= LTTNG_ERR_FILTER_NOMEM
;
2545 error_code_ret
= LTTNG_ERR_FILTER_INVAL
;
2551 if (lttng_event_rule_get_type(event_rule
) ==
2552 LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE
) {
2553 ret
= userspace_probe_event_rule_add_callsites(
2554 event_rule
, creds
, event_counter
->fd
);
2556 error_code_ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
2557 goto add_callsite_error
;
2561 err
= kernctl_enable(event_counter
->fd
);
2565 error_code_ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
2568 PERROR("enable kernel counter event");
2569 error_code_ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
2575 /* Add event to event list */
2577 lttng_ht_node_init_u64(&event_counter
->ht_node
,
2578 event_counter
->action_tracer_token
);
2579 lttng_ht_add_unique_u64(kmap
->event_counters_ht
,
2580 &event_counter
->ht_node
);
2582 kmap
->event_count
++;
2584 DBG("Kernel event counter %s created (fd: %d)",
2585 event_counter
->event
->name
,
2587 error_code_ret
= LTTNG_OK
;
2593 return error_code_ret
;
2596 static enum lttng_error_code
kernel_create_event_notifier_rule(
2597 struct lttng_trigger
*trigger
,
2598 const struct lttng_credentials
*creds
, uint64_t token
)
2600 int err
, fd
, ret
= 0;
2601 enum lttng_error_code error_code_ret
;
2602 enum lttng_condition_status condition_status
;
2603 enum lttng_condition_type condition_type
;
2604 enum lttng_event_rule_type event_rule_type
;
2605 struct ltt_kernel_event_notifier_rule
*event_notifier_rule
;
2606 struct lttng_kernel_event_notifier kernel_event_notifier
= {};
2607 unsigned int capture_bytecode_count
= 0, i
;
2608 const struct lttng_condition
*condition
= NULL
;
2609 const struct lttng_event_rule
*event_rule
= NULL
;
2610 enum lttng_condition_status cond_status
;
2614 condition
= lttng_trigger_get_const_condition(trigger
);
2617 condition_type
= lttng_condition_get_type(condition
);
2618 assert(condition_type
== LTTNG_CONDITION_TYPE_ON_EVENT
);
2620 /* Does not acquire a reference. */
2621 condition_status
= lttng_condition_on_event_get_rule(
2622 condition
, &event_rule
);
2623 assert(condition_status
== LTTNG_CONDITION_STATUS_OK
);
2626 event_rule_type
= lttng_event_rule_get_type(event_rule
);
2627 assert(event_rule_type
!= LTTNG_EVENT_RULE_TYPE_UNKNOWN
);
2629 error_code_ret
= trace_kernel_create_event_notifier_rule(trigger
, token
,
2630 lttng_condition_on_event_get_error_counter_index(condition
),
2631 &event_notifier_rule
);
2632 if (error_code_ret
!= LTTNG_OK
) {
2636 error_code_ret
= trace_kernel_init_event_notifier_from_event_rule(
2637 event_rule
, &kernel_event_notifier
);
2638 if (error_code_ret
!= LTTNG_OK
) {
2642 kernel_event_notifier
.event
.token
= event_notifier_rule
->token
;
2643 kernel_event_notifier
.error_counter_idx
=
2644 lttng_condition_on_event_get_error_counter_index(condition
);
2646 fd
= kernctl_create_event_notifier(
2647 kernel_tracer_event_notifier_group_fd
,
2648 &kernel_event_notifier
);
2652 error_code_ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
2655 WARN("Failed to create kernel event notifier: not notifier type not implemented");
2656 error_code_ret
= LTTNG_ERR_KERN_EVENT_ENOSYS
;
2659 WARN("Failed to create kernel event notifier: not found: name = '%s'",
2660 kernel_event_notifier
.event
.name
);
2661 error_code_ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
2664 PERROR("Failed to create kernel event notifier: error code = %d, name = '%s'",
2665 fd
, kernel_event_notifier
.event
.name
);
2666 error_code_ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
2671 event_notifier_rule
->fd
= fd
;
2672 /* Prevent fd duplication after execlp(). */
2673 err
= fcntl(event_notifier_rule
->fd
, F_SETFD
, FD_CLOEXEC
);
2675 PERROR("Failed to set FD_CLOEXEC on kernel event notifier file descriptor: fd = %d",
2677 error_code_ret
= LTTNG_ERR_FATAL
;
2678 goto set_cloexec_error
;
2681 if (event_notifier_rule
->filter
) {
2682 err
= kernctl_filter(event_notifier_rule
->fd
, event_notifier_rule
->filter
);
2686 error_code_ret
= LTTNG_ERR_FILTER_NOMEM
;
2689 error_code_ret
= LTTNG_ERR_FILTER_INVAL
;
2696 if (lttng_event_rule_get_type(event_rule
) ==
2697 LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE
) {
2698 ret
= userspace_probe_event_rule_add_callsites(
2699 event_rule
, creds
, event_notifier_rule
->fd
);
2701 error_code_ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
2702 goto add_callsite_error
;
2706 /* Set the capture bytecode if any */
2707 cond_status
= lttng_condition_on_event_get_capture_descriptor_count(condition
, &capture_bytecode_count
);
2708 assert(cond_status
== LTTNG_CONDITION_STATUS_OK
);
2709 for (i
= 0; i
< capture_bytecode_count
; i
++) {
2710 const struct lttng_bytecode
*capture_bytecode
=
2711 lttng_condition_on_event_get_capture_bytecode_at_index(
2713 if (capture_bytecode
== NULL
) {
2714 error_code_ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
2718 ret
= kernctl_capture(event_notifier_rule
->fd
, capture_bytecode
);
2720 error_code_ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
2725 err
= kernctl_enable(event_notifier_rule
->fd
);
2729 error_code_ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
2732 PERROR("enable kernel event notifier");
2733 error_code_ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
2739 /* Add trigger to kernel token mapping in the hash table. */
2741 cds_lfht_add(kernel_token_to_event_notifier_rule_ht
, hash_trigger(trigger
),
2742 &event_notifier_rule
->ht_node
);
2745 DBG("Created kernel event notifier: name = '%s', fd = %d",
2746 kernel_event_notifier
.event
.name
,
2747 event_notifier_rule
->fd
);
2756 const int close_ret
= close(event_notifier_rule
->fd
);
2759 PERROR("Failed to close kernel event notifier file descriptor: fd = %d",
2760 event_notifier_rule
->fd
);
2764 free(event_notifier_rule
);
2766 return error_code_ret
;
2769 enum lttng_error_code
kernel_register_event_notifier(
2770 struct lttng_trigger
*trigger
,
2771 const struct lttng_credentials
*cmd_creds
)
2773 enum lttng_error_code ret
;
2774 enum lttng_condition_status status
;
2775 enum lttng_domain_type domain_type
;
2776 const struct lttng_event_rule
*event_rule
;
2777 const struct lttng_condition
*const condition
=
2778 lttng_trigger_get_const_condition(trigger
);
2779 const uint64_t token
= lttng_trigger_get_tracer_token(trigger
);
2783 /* Does not acquire a reference to the event rule. */
2784 status
= lttng_condition_on_event_get_rule(
2785 condition
, &event_rule
);
2786 assert(status
== LTTNG_CONDITION_STATUS_OK
);
2788 domain_type
= lttng_event_rule_get_domain_type(event_rule
);
2789 assert(domain_type
== LTTNG_DOMAIN_KERNEL
);
2791 ret
= kernel_create_event_notifier_rule(trigger
, cmd_creds
, token
);
2792 if (ret
!= LTTNG_OK
) {
2793 ERR("Failed to create kernel event notifier rule");
2799 enum lttng_error_code
kernel_unregister_event_notifier(
2800 const struct lttng_trigger
*trigger
)
2802 struct ltt_kernel_event_notifier_rule
*token_event_rule_element
;
2803 struct cds_lfht_node
*node
;
2804 struct cds_lfht_iter iter
;
2805 enum lttng_error_code error_code_ret
;
2810 cds_lfht_lookup(kernel_token_to_event_notifier_rule_ht
,
2811 hash_trigger(trigger
), match_trigger
, trigger
, &iter
);
2813 node
= cds_lfht_iter_get_node(&iter
);
2815 error_code_ret
= LTTNG_ERR_TRIGGER_NOT_FOUND
;
2819 token_event_rule_element
= caa_container_of(node
,
2820 struct ltt_kernel_event_notifier_rule
, ht_node
);
2822 ret
= kernel_disable_event_notifier_rule(token_event_rule_element
);
2824 error_code_ret
= LTTNG_ERR_FATAL
;
2828 trace_kernel_destroy_event_notifier_rule(token_event_rule_element
);
2829 error_code_ret
= LTTNG_OK
;
2834 return error_code_ret
;
2837 struct key_ht_entry
{
2839 struct lttng_ht_node_str node
;
2842 enum lttng_error_code
kernel_list_map_values(const struct ltt_kernel_map
*map
,
2843 const struct lttng_map_query
*query
,
2844 struct lttng_map_content
**map_content
)
2846 enum lttng_map_status map_status
;
2847 enum lttng_error_code ret_code
;
2848 const char *map_name
= NULL
;
2849 uint64_t descr_count
, descr_idx
, cpu_idx
;
2850 struct lttng_map_content
*local_map_content
;
2851 struct lttng_ht
*key_ht
;
2852 struct lttng_ht
*values
= NULL
;
2853 struct lttng_ht_node_str
*node
;
2854 struct key_ht_entry
*ht_entry
;
2855 struct lttng_ht_iter iter
;
2856 enum lttng_map_query_status map_query_status
;
2857 const char *key_filter
;
2858 bool sum_cpus
= lttng_map_query_get_config_sum_by_cpu(query
);
2859 enum lttng_map_query_config_cpu config_cpu
;
2864 local_map_content
= lttng_map_content_create(LTTNG_BUFFER_GLOBAL
);
2865 if (!local_map_content
) {
2866 ERR("Error creating map content");
2867 ret_code
= LTTNG_ERR_NOMEM
;
2871 map_query_status
= lttng_map_query_get_key_filter(query
, &key_filter
);
2872 if (map_query_status
== LTTNG_MAP_QUERY_STATUS_NONE
) {
2874 } else if (map_query_status
!= LTTNG_MAP_QUERY_STATUS_OK
) {
2875 ret_code
= LTTNG_ERR_INVALID
;
2879 config_cpu
= lttng_map_query_get_config_cpu(query
);
2880 if (config_cpu
== LTTNG_MAP_QUERY_CONFIG_CPU_SUBSET
) {
2882 map_query_status
= lttng_map_query_get_cpu_count(query
, &count
);
2883 assert(map_query_status
== LTTNG_MAP_QUERY_STATUS_OK
);
2886 map_query_status
= lttng_map_query_get_cpu_at_index(query
, 0,
2888 assert(map_query_status
== LTTNG_MAP_QUERY_STATUS_OK
);
2891 map_status
= lttng_map_get_name(map
->map
, &map_name
);
2892 assert(map_status
== LTTNG_MAP_STATUS_OK
);
2894 DBG("Listing kernel map values: map-name = '%s'", map_name
);
2896 ret
= kernctl_counter_map_descriptor_count(map
->fd
, &descr_count
);
2898 ERR("Error getting map descriptor count");
2899 ret_code
= LTTNG_ERR_MAP_VALUES_LIST_FAIL
;
2904 * The kernel tracer sends us descriptors that may be identical aside
2905 * from their user token field. This ABI was design this way to cover a
2906 * potential use case where the user wants to know what enabler might
2907 * have contributed to a specific bucket.
2909 * We use this hashtable to de-duplicate keys.
2912 values
= lttng_ht_new(0, LTTNG_HT_TYPE_STRING
);
2914 ret_code
= LTTNG_ERR_NOMEM
;
2919 DBG("Querying kernel for all map values: "
2920 "map-name = '%s', key-value count = %"PRIu64
,
2921 map_name
, descr_count
);
2922 for (cpu_idx
= 0; cpu_idx
< utils_get_number_of_possible_cpus(); cpu_idx
++) {
2923 struct lttng_kernel_counter_read value
= {0};
2925 if (config_cpu
== LTTNG_MAP_QUERY_CONFIG_CPU_SUBSET
) {
2926 if (selected_cpu
!= cpu_idx
) {
2932 values
= lttng_ht_new(0, LTTNG_HT_TYPE_STRING
);
2936 key_ht
= lttng_ht_new(0, LTTNG_HT_TYPE_STRING
);
2938 ret_code
= LTTNG_ERR_NOMEM
;
2942 for(descr_idx
= 0; descr_idx
< descr_count
; descr_idx
++) {
2943 struct lttng_kernel_counter_map_descriptor descriptor
= {0};
2945 DBG("Querying kernel for map key-value descriptor: "
2946 "map-name = '%s', descriptor = %"PRIu64
,
2947 map_name
, descr_idx
);
2948 descriptor
.descriptor_index
= descr_idx
;
2950 ret
= kernctl_counter_map_descriptor(map
->fd
, &descriptor
);
2952 ERR("Error getting map descriptor %"PRIu64
, descr_idx
);
2953 ret_code
= LTTNG_ERR_MAP_VALUES_LIST_FAIL
;
2957 if (key_filter
&& strcmp(key_filter
, descriptor
.key
) != 0) {
2961 lttng_ht_lookup(key_ht
, descriptor
.key
, &iter
);
2962 node
= lttng_ht_iter_get_node_str(&iter
);
2964 /* This key was already appended to the list. */
2969 value
.index
.number_dimensions
= 1;
2970 value
.index
.dimension_indexes
[0] = descriptor
.array_index
;
2971 value
.cpu
= cpu_idx
;
2973 DBG("Querying kernel for map descriptor value: "
2974 "map-name = '%s', counter-index = %"PRIu64
,
2975 map_name
, descriptor
.array_index
);
2976 ret
= kernctl_counter_read_value(map
->fd
, &value
);
2978 ERR("Error getting value of map descriptor %"PRIu64
, descr_idx
);
2979 ret_code
= LTTNG_ERR_MAP_VALUES_LIST_FAIL
;
2983 map_add_or_increment_map_values(values
, descriptor
.key
,
2984 value
.value
.value
, value
.value
.underflow
,
2985 value
.value
.overflow
);
2987 ht_entry
= zmalloc(sizeof(*ht_entry
));
2989 ht_entry
->key
= strdup(descriptor
.key
);
2990 lttng_ht_node_init_str(&ht_entry
->node
, ht_entry
->key
);
2991 lttng_ht_add_unique_str(key_ht
, &ht_entry
->node
);
2995 ret
= map_new_content_section(local_map_content
,
2996 LTTNG_MAP_KEY_VALUE_PAIR_LIST_TYPE_KERNEL
,
3003 lttng_ht_destroy(values
);
3007 * Remove all the keys before destroying the hashtable.
3009 cds_lfht_for_each_entry(key_ht
->ht
, &iter
.iter
, ht_entry
, node
.node
) {
3010 struct lttng_ht_iter entry_iter
;
3012 entry_iter
.iter
.node
= &ht_entry
->node
.node
;
3013 lttng_ht_del(key_ht
, &entry_iter
);
3018 lttng_ht_destroy(key_ht
);
3022 ret
= map_new_content_section(local_map_content
,
3023 LTTNG_MAP_KEY_VALUE_PAIR_LIST_TYPE_KERNEL
,
3024 sum_cpus
, 0, 0, values
);
3028 lttng_ht_destroy(values
);
3032 *map_content
= local_map_content
;
3033 local_map_content
= NULL
;
3034 ret_code
= LTTNG_OK
;
3037 lttng_map_content_destroy(local_map_content
);
3041 int kernel_get_notification_fd(void)
3043 return kernel_tracer_event_notifier_group_notification_fd
;