2 * Copyright (C) 2013 - David Goulet <dgoulet@efficios.com>
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License, version 2 only, as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 51
15 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 #include <common/common.h>
22 #include <common/sessiond-comm/sessiond-comm.h>
23 #include <common/uri.h>
24 #include <common/utils.h>
27 #include "jul-thread.h"
28 #include "lttng-sessiond.h"
33 * Note that there is not port here. It's set after this URI is parsed so we
34 * can let the user define a custom one. However, localhost is ALWAYS the
35 * default listening address.
37 static const char *default_reg_uri
= "tcp://localhost";
40 * Update JUL application using the given socket. This is done just after
41 * registration was successful.
43 * This is a quite heavy call in terms of locking since the session list lock
44 * AND session lock are acquired.
46 static void update_jul_app(int sock
)
48 struct ltt_session
*session
, *stmp
;
49 struct ltt_session_list
*list
;
51 list
= session_get_list();
55 cds_list_for_each_entry_safe(session
, stmp
, &list
->head
, list
) {
56 session_lock(session
);
57 if (session
->ust_session
) {
58 jul_update(&session
->ust_session
->domain_jul
, sock
);
60 session_unlock(session
);
62 session_unlock_list();
66 * Destroy a JUL application by socket.
68 static void destroy_jul_app(int sock
)
75 * Not finding an application is a very important error that should NEVER
76 * happen. The hash table deletion is ONLY done through this call even on
80 app
= jul_find_app_by_sock(sock
);
84 /* RCU read side lock is taken in this function call. */
87 /* The application is freed in a RCU call but the socket is closed here. */
92 * Cleanup remaining JUL apps in the hash table. This should only be called in
93 * the exit path of the thread.
95 static void clean_jul_apps_ht(void)
97 struct lttng_ht_node_ulong
*node
;
98 struct lttng_ht_iter iter
;
100 DBG3("[jul-thread] Cleaning JUL apps ht");
103 cds_lfht_for_each_entry(jul_apps_ht_by_sock
->ht
, &iter
.iter
, node
, node
) {
106 app
= caa_container_of(node
, struct jul_app
, node
);
107 destroy_jul_app(app
->sock
->fd
);
113 * Create and init socket from uri.
115 static struct lttcomm_sock
*init_tcp_socket(void)
118 struct lttng_uri
*uri
= NULL
;
119 struct lttcomm_sock
*sock
= NULL
;
122 * This should never fail since the URI is hardcoded and the port is set
123 * before this thread is launched.
125 ret
= uri_parse(default_reg_uri
, &uri
);
127 assert(jul_tcp_port
);
128 uri
->port
= jul_tcp_port
;
130 sock
= lttcomm_alloc_sock_from_uri(uri
);
133 ERR("[jul-thread] JUL allocating TCP socket");
137 ret
= lttcomm_create_sock(sock
);
142 ret
= sock
->ops
->bind(sock
);
147 ret
= sock
->ops
->listen(sock
, -1);
152 DBG("[jul-thread] Listening on TCP port %u and socket %d", jul_tcp_port
,
159 lttcomm_destroy_sock(sock
);
165 * Close and destroy the given TCP socket.
167 static void destroy_tcp_socket(struct lttcomm_sock
*sock
)
171 DBG3("[jul-thread] Destroy TCP socket on port %u", jul_tcp_port
);
173 /* This will return gracefully if fd is invalid. */
174 sock
->ops
->close(sock
);
175 lttcomm_destroy_sock(sock
);
179 * Handle a new JUL registration using the reg socket. After that, a new JUL
180 * application is added to the global hash table and attach to an UST app
183 * Return the new FD created upon accept() on success or else a negative errno
186 static int handle_registration(struct lttcomm_sock
*reg_sock
)
192 struct jul_register_msg msg
;
193 struct lttcomm_sock
*new_sock
;
197 new_sock
= reg_sock
->ops
->accept(reg_sock
);
203 size
= new_sock
->ops
->recvmsg(new_sock
, &msg
, sizeof(msg
), 0);
204 if (size
< sizeof(msg
)) {
208 pid
= be32toh(msg
.pid
);
210 DBG2("[jul-thread] New registration for pid %d on socket %d", pid
,
213 app
= jul_create_app(pid
, new_sock
);
220 * Add before assigning the socket value to the UST app so it can be found
226 * We don't need to attach the JUL app to the app. If we ever do
227 * so, we should consider both registration order of JUL before
228 * app and app before JUL.
234 new_sock
->ops
->close(new_sock
);
235 lttcomm_destroy_sock(new_sock
);
241 * This thread manage application notify communication.
243 void *jul_thread_manage_registration(void *data
)
246 uint32_t revents
, nb_fd
;
247 struct lttng_poll_event events
;
248 struct lttcomm_sock
*reg_sock
;
250 DBG("[jul-thread] Manage JUL application registration.");
252 rcu_register_thread();
255 /* JUL initialization call MUST be called before starting the thread. */
256 assert(jul_apps_ht_by_sock
);
258 /* Create pollset with size 2, quit pipe and socket. */
259 ret
= sessiond_set_thread_pollset(&events
, 2);
261 goto error_poll_create
;
264 reg_sock
= init_tcp_socket();
266 goto error_tcp_socket
;
269 /* Add create valid TCP socket to poll set. */
270 ret
= lttng_poll_add(&events
, reg_sock
->fd
,
271 LPOLLIN
| LPOLLERR
| LPOLLHUP
| LPOLLRDHUP
);
277 DBG3("[jul-thread] Manage JUL polling on %d fds",
278 LTTNG_POLL_GETNB(&events
));
280 /* Inifinite blocking call, waiting for transmission */
282 ret
= lttng_poll_wait(&events
, -1);
285 * Restart interrupted system call.
287 if (errno
== EINTR
) {
293 DBG3("[jul-thread] %d fd ready", nb_fd
);
295 for (i
= 0; i
< nb_fd
; i
++) {
296 /* Fetch once the poll data */
297 revents
= LTTNG_POLL_GETEV(&events
, i
);
298 pollfd
= LTTNG_POLL_GETFD(&events
, i
);
300 /* Thread quit pipe has been closed. Killing thread. */
301 ret
= sessiond_check_thread_quit_pipe(pollfd
, revents
);
307 * Check first if this is a POLLERR since POLLIN is also included
308 * in an error value thus checking first.
310 if (revents
& (LPOLLERR
| LPOLLHUP
| LPOLLRDHUP
)) {
311 /* Removing from the poll set */
312 ret
= lttng_poll_del(&events
, pollfd
);
317 destroy_jul_app(pollfd
);
318 } else if (revents
& (LPOLLIN
)) {
321 /* Pollin event of JUL app socket should NEVER happen. */
322 assert(pollfd
== reg_sock
->fd
);
324 new_fd
= handle_registration(reg_sock
);
326 WARN("[jul-thread] JUL registration failed. Ignoring.");
327 /* Somehow the communication failed. Just continue. */
331 /* Only add poll error event to only detect shutdown. */
332 ret
= lttng_poll_add(&events
, new_fd
,
333 LPOLLERR
| LPOLLHUP
| LPOLLRDHUP
);
335 destroy_jul_app(new_fd
);
339 /* Update newly registered app. */
340 update_jul_app(new_fd
);
342 ERR("Unknown poll events %u for sock %d", revents
, pollfd
);
349 /* Whatever happens, try to delete it and exit. */
350 (void) lttng_poll_del(&events
, reg_sock
->fd
);
352 destroy_tcp_socket(reg_sock
);
354 lttng_poll_clean(&events
);
356 DBG("[jul-thread] is cleaning up and stopping.");
358 if (jul_apps_ht_by_sock
) {
360 lttng_ht_destroy(jul_apps_ht_by_sock
);
363 rcu_thread_offline();
364 rcu_unregister_thread();
This page took 0.051633 seconds and 4 git commands to generate.