2 * Copyright (C) 2011 EfficiOS Inc.
3 * Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
4 * Copyright (C) 2013 Jérémie Galarneau <jeremie.galarneau@efficios.com>
6 * SPDX-License-Identifier: GPL-2.0-only
10 #include "health-sessiond.hpp"
11 #include "kernel-consumer.hpp"
13 #include "manage-kernel.hpp"
14 #include "testpoint.hpp"
18 #include <common/pipe.hpp>
19 #include <common/urcu.hpp>
20 #include <common/utils.hpp>
25 struct thread_notifiers
{
26 struct lttng_pipe
*quit_pipe
;
27 int kernel_poll_pipe_read_fd
;
32 * Update the kernel poll set of all channel fd available over all tracing
33 * session. Add the wakeup pipe at the end of the set.
35 static int update_kernel_poll(struct lttng_poll_event
*events
)
38 struct ltt_kernel_channel
*channel
;
39 struct ltt_session
*session
;
40 const struct ltt_session_list
*session_list
= session_get_list();
42 DBG("Updating kernel poll set");
45 cds_list_for_each_entry (session
, &session_list
->head
, list
) {
46 if (!session_get(session
)) {
49 session_lock(session
);
50 if (session
->kernel_session
== nullptr) {
51 session_unlock(session
);
56 cds_list_for_each_entry (
57 channel
, &session
->kernel_session
->channel_list
.head
, list
) {
58 /* Add channel fd to the kernel poll set */
59 ret
= lttng_poll_add(events
, channel
->fd
, LPOLLIN
| LPOLLRDNORM
);
61 session_unlock(session
);
65 DBG("Channel fd %d added to kernel set", channel
->fd
);
67 session_unlock(session
);
70 session_unlock_list();
75 session_unlock_list();
80 * Find the channel fd from 'fd' over all tracing session. When found, check
81 * for new channel stream and send those stream fds to the kernel consumer.
83 * Useful for CPU hotplug feature.
85 static int update_kernel_stream(int fd
)
88 struct ltt_session
*session
;
89 struct ltt_kernel_session
*ksess
;
90 struct ltt_kernel_channel
*channel
;
91 const struct ltt_session_list
*session_list
= session_get_list();
93 DBG("Updating kernel streams for channel fd %d", fd
);
96 cds_list_for_each_entry (session
, &session_list
->head
, list
) {
97 if (!session_get(session
)) {
101 session_lock(session
);
102 if (session
->kernel_session
== nullptr) {
103 session_unlock(session
);
104 session_put(session
);
108 ksess
= session
->kernel_session
;
110 cds_list_for_each_entry (channel
, &ksess
->channel_list
.head
, list
) {
111 struct lttng_ht_iter iter
;
112 struct consumer_socket
*socket
;
114 if (channel
->fd
!= fd
) {
117 DBG("Channel found, updating kernel streams");
118 ret
= kernel_open_channel_stream(channel
);
122 /* Update the stream global counter */
123 ksess
->stream_count_global
+= ret
;
126 * Have we already sent fds to the consumer? If yes, it
127 * means that tracing is started so it is safe to send
128 * our updated stream fds.
130 if (ksess
->consumer_fds_sent
!= 1 || ksess
->consumer
== nullptr) {
136 lttng::urcu::read_lock_guard read_lock
;
138 cds_lfht_for_each_entry (
139 ksess
->consumer
->socks
->ht
, &iter
.iter
, socket
, node
.node
) {
140 pthread_mutex_lock(socket
->lock
);
141 ret
= kernel_consumer_send_channel_streams(
145 session
->output_traces
? 1 : 0);
146 pthread_mutex_unlock(socket
->lock
);
154 session_unlock(session
);
155 session_put(session
);
157 session_unlock_list();
161 session_unlock(session
);
162 session_put(session
);
163 session_unlock_list();
168 * This thread manage event coming from the kernel.
170 * Features supported in this thread:
173 static void *thread_kernel_management(void *data
)
175 int ret
, i
, update_poll_flag
= 1, err
= -1;
178 struct lttng_poll_event events
;
179 struct thread_notifiers
*notifiers
= (thread_notifiers
*) data
;
180 const auto thread_quit_pipe_fd
= lttng_pipe_get_readfd(notifiers
->quit_pipe
);
182 DBG("[thread] Thread manage kernel started");
184 health_register(the_health_sessiond
, HEALTH_SESSIOND_TYPE_KERNEL
);
187 * This first step of the while is to clean this structure which could free
188 * non NULL pointers so initialize it before the loop.
190 lttng_poll_init(&events
);
192 if (testpoint(sessiond_thread_manage_kernel
)) {
193 goto error_testpoint
;
196 health_code_update();
198 if (testpoint(sessiond_thread_manage_kernel_before_loop
)) {
199 goto error_testpoint
;
203 health_code_update();
205 if (update_poll_flag
== 1) {
206 /* Clean events object. We are about to populate it again. */
207 lttng_poll_clean(&events
);
209 ret
= lttng_poll_create(&events
, 2, LTTNG_CLOEXEC
);
211 goto error_poll_create
;
214 ret
= lttng_poll_add(&events
, notifiers
->kernel_poll_pipe_read_fd
, LPOLLIN
);
219 ret
= lttng_poll_add(&events
, thread_quit_pipe_fd
, LPOLLIN
);
224 /* This will add the available kernel channel if any. */
225 ret
= update_kernel_poll(&events
);
229 update_poll_flag
= 0;
232 DBG("Thread kernel polling");
234 /* Poll infinite value of time */
237 ret
= lttng_poll_wait(&events
, -1);
238 DBG("Thread kernel return from poll on %d fds", LTTNG_POLL_GETNB(&events
));
242 * Restart interrupted system call.
244 if (errno
== EINTR
) {
248 } else if (ret
== 0) {
249 /* Should not happen since timeout is infinite */
250 ERR("Return value of poll is 0 with an infinite timeout.\n"
251 "This should not have happened! Continuing...");
257 for (i
= 0; i
< nb_fd
; i
++) {
258 /* Fetch once the poll data */
259 const auto revents
= LTTNG_POLL_GETEV(&events
, i
);
260 const auto pollfd
= LTTNG_POLL_GETFD(&events
, i
);
262 health_code_update();
264 /* Activity on thread quit pipe, exiting. */
265 if (pollfd
== thread_quit_pipe_fd
) {
266 DBG("Activity on thread quit pipe");
271 /* Check for data on kernel pipe */
272 if (revents
& LPOLLIN
) {
273 if (pollfd
== notifiers
->kernel_poll_pipe_read_fd
) {
275 notifiers
->kernel_poll_pipe_read_fd
, &tmp
, 1);
277 * Ret value is useless here, if this pipe gets any actions
278 * an update is required anyway.
280 update_poll_flag
= 1;
284 * New CPU detected by the kernel. Adding kernel stream to
285 * kernel session and updating the kernel consumer
287 ret
= update_kernel_stream(pollfd
);
293 } else if (revents
& (LPOLLERR
| LPOLLHUP
| LPOLLRDHUP
)) {
294 update_poll_flag
= 1;
297 ERR("Unexpected poll events %u for sock %d", revents
, pollfd
);
305 lttng_poll_clean(&events
);
310 ERR("Health error occurred in %s", __func__
);
311 WARN("Kernel thread died unexpectedly. "
312 "Kernel tracing can continue but CPU hotplug is disabled.");
314 health_unregister(the_health_sessiond
);
315 DBG("Kernel thread dying");
319 static bool shutdown_kernel_management_thread(void *data
)
321 struct thread_notifiers
*notifiers
= (thread_notifiers
*) data
;
322 const int write_fd
= lttng_pipe_get_writefd(notifiers
->quit_pipe
);
324 return notify_thread_pipe(write_fd
) == 1;
327 static void cleanup_kernel_management_thread(void *data
)
329 struct thread_notifiers
*notifiers
= (thread_notifiers
*) data
;
331 lttng_pipe_destroy(notifiers
->quit_pipe
);
335 bool launch_kernel_management_thread(int kernel_poll_pipe_read_fd
)
337 struct lttng_pipe
*quit_pipe
;
338 struct thread_notifiers
*notifiers
= nullptr;
339 struct lttng_thread
*thread
;
341 notifiers
= zmalloc
<thread_notifiers
>();
345 quit_pipe
= lttng_pipe_open(FD_CLOEXEC
);
349 notifiers
->quit_pipe
= quit_pipe
;
350 notifiers
->kernel_poll_pipe_read_fd
= kernel_poll_pipe_read_fd
;
352 thread
= lttng_thread_create("Kernel management",
353 thread_kernel_management
,
354 shutdown_kernel_management_thread
,
355 cleanup_kernel_management_thread
,
360 lttng_thread_put(thread
);
363 cleanup_kernel_management_thread(notifiers
);